Python基础知识汇总

显示全部楼层 · 2019-6-11 00:22:31

1.执行脚本的两种方式

Python a.py 直接调用Python解释器执行文件

chomd +x a.py ./a.py #修改a.py文件的属性，为可执行，在用 ./ 执行a.py 文件

2、简述位、字节的关系

1bytes=8bit ,2**8=256,可以代表256中变化，

3、简述 ascii、unicode、utf-8、gbk 的关系

ascii 是最早美国用的标准信息交换码，把所有的字母的大小写，各种符号用二进制来表示，共有256中，加入些拉丁文等字符，1bytes代表一个字符，

Unicode是为了统一世界各国语言的不用，统一用2个bytes代表一个字符，可以表达2**16=65556个，称为万国语言，特点：速度快，但浪费空间，

可以用在内存处理中，兼容了utf-8，gbk，ASCII，

utf-8 为了改变Unicode的这种缺点，规定1个英文字符用1个字节表示，1个中文字符用3个字节表示，特点；节省空间，速度慢，用在硬盘数据传输，网络数据传输，相比硬盘和网络速度，体现不出来的，

gbk 是中文的字符编码，用2个字节代表一个字符，

4、请写出 “李杰” 分别用 utf-8 和 gbk 编码所占的位数

utf-8 是3 bytes=24bit

gbk 是2bytes=16bit

5、Pyhton 单行注释和多行注释分别用什么?

单行注释 #

多行注释 """ """三个双引号或是三个单引号把要解释的内容放中间， ‘’‘ ’’’

6、声明变量注意事项有那些?

万能避错规则，以小写字母开头命名，可以加上下划线，或者数字，

不能以Python的关键字命名，

能表明变量的意义

8、如何查看变量在内存中的地址?
z=1
print(id(z))
9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

.pyc 是编译py文件后的二进制文件，用于加速运行

10、写代码; ^+ O5 G0 `, m9 K
a.实现用户输入用户名和密码，当用户名为 seven 且密码为 123 时，显示登陆成功，否则登陆失败!
name=input('name:').strip()
pwd=input('pwd：').strip()
if name=='seven' and pwd=='123' :
print('ok')
else:
print('error')

b.实现用户输入用户名和密码，当用户名为 seven 且密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
count=1
while count<=3 :
name = input('name:').strip()
pwd = input('pwd：').strip()

if name=='seven' and pwd=='123' :
      print('ok')
else:
      print('error')
      count += 1
for循环：
for count in range(3) :3 g. N( C  v2 U: U
name = input('name:').strip()" {, k" v7 P1 X
pwd = input('pwd：').strip()
- L2 P3 V+ L) N4 T8 a, m8 Q! Y: m* {4 t1 p# A6 c1 F1 B; P
if name=='seven' and pwd=='123' :$ ^. K+ w- r% S) O9 p2 `' J3 U
      print('ok'): y* `! j: Y; x1 f7 j
else:
0 M# d8 D8 l9 L( h       print('error')
4 J: Y& S) n$ i& b# ?& g( M       count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
count =1
while count<=3 :
name = input('name: ')
pwd = input('pwd: ')
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
      print('ok')
else :
      print('error')
      count+=1
for循环
for count in range(3)  :' D8 J8 u9 j  k) C+ u9 v) x
name = input('name: ')5 x% `! c5 q8 Y9 q- X" ?
pwd = input('pwd: ')9 P7 X# M+ N2 C# G; z  @
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':/ X0 g6 x8 `2 `/ a
      print('ok')
- P% |, i! S  R$ G2 h else :
4 w) i# W, [; d  E       print('error')$ K1 O: J" N  |. M# Q
      count+=111、写代码
6 k% J% \" Z8 a; G5 ~a. 使用while循环实现输出2-3+4-5+6...+100 的和
count=2
num=0
while count<=100 :
if count % 2 ==0 :
      num=count+num
      count+=1
else:
      num=num-count
      count+=1
print(num)

b. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
num=0
count=1
for count in range(100) :
if count % 2 == 0 :
      num=num - count
else :
      num=num+count
print(num)

c. 使用 while 循环实现输出 1，2，3，4，5， 7，8，9， 11，12

count=1
while count < 13 :
if count !=6 :
      if count !=10 :
         print(count)

count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
for i in range(101) :9 h# N3 M4 L7 A5 |0 I4 y
if i %2 != 0 :
0 |1 [4 u3 v0 W, i6 t0 J       print(i)

count=0
while count<100 :
if count %2 != 0 :
      print(count)
count += 1

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :* y5 M1 Q5 Y7 Y$ X1 L7 e5 M
if i %2 == 0:
4 G- @  E1 a+ T       print(i)

count=0
while count<100 :
if count%2 == 0 :
      print(count)
count+=1

12、分别书写数字 5，10，32，7 的二进制表示

print(bin(5))二进制 0b101
print(hex(10))十六进制  0x5
print(oct(5))  八进制  0o5
14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

n1,n2是连个不同的变量名，但值都一样，都指向了同一个内存地址，

16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

n1=5
print(int.bit_length(n1)) 结果 3

18、布尔值分别有什么?

False .Ture ,或1 和0

20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
( J4 j* h7 Q, ^6 }% u, Sa. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())

b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
print(name.startswith('al'))
c. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
d. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
print(name.replace('l','p')) apex
e. 将 name 变量对应的值根据 “l” 分割，并输出结果。
print(name.split('e')) ['al', 'x  ']  列表

g. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])

j. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
依赖索引
name = "Alex  "
for i in range(len(name)) :
print(name)
  a1 `7 H& Z# tfor i in name:' `7 g# Q; y- B' A
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain1 i! \' w8 r6 B3 f3 E5 u
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']% L' `2 w. y9 r- ?7 M! G$ B
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
. K' h% c. a& _9 b+ i6 v, d1 jprint(li)7 ]# [( {$ m- i" a2 H9 k3 W
['alex', 'eric', 'rain', 'seven']
' H+ [$ M& K4 l) h9 k3 _c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')3 }/ j( |$ o* [5 R8 h& }
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')2 t+ [% l' e. H$ E; ?5 Z* @4 F
print(li)
3 h- f) O) t* o. L; s" g, ie. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
# P) Y/ G1 _& U" o% r! ]4 {4 l" Zli.pop(1)
% O! e9 p4 g+ L- z( U! C. E% Dprint(li) ['alex', 'rain']* s- t, s: U1 T8 z+ g7 `. U
指名道姓的删除li = ['alex', 'eric', 'rain']: C3 c  E+ T/ ]0 @$ {6 U4 a% ^
li.remove('alex')0 @1 [: |  i+ ~: U/ Z3 w
print(li)
0 l1 ]4 j# X7 kf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
* d$ F+ v" d1 U5 a0 Y% {print(li.pop(1))" E8 _$ a! N* z2 U! ^% z
print(li)8 C' @: M* B6 R$ j1 p8 m" ]1 S
- W) h- \+ ?9 X+ o+ u
eric
9 f3 T! _$ ~! J9 \2 S2 b['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']1 g( s2 {8 E- e) z
del li[1:]6 E3 k/ e8 i4 W
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)1 m/ p  @( w, m5 o  p* G# r
li = ['alex', 'eric', 'rain']5 {3 M* X, d- P+ ~6 s) U0 l! ^
for k,v in enumerate(li,1):
( b0 X% g) n! Y. {5 W1 c" X print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
/ L: B1 A- F1 x! b, d( ba. 请输出 “Kelly”
& K3 n  O/ J1 K5 c: A( B9 Jli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
4 ~% f5 I5 B* [+ ^0 }0 o4 dprint(li[2][1][1])- G4 X" q: U# w" x, g" t
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”; d; L3 s) u/ Y
li[2][2]='ALL': N5 v  p4 S1 R, H0 k2 i4 X
print(li): Q. T+ W2 j! H2 W  X$ K
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
8 e6 b3 B5 ]8 c" B2 C" G5 z5 La. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
1 {7 t( T/ P+ I6 r  Sprint(len(tu))" V6 W  Z! {% C
b. 获取元组的第 2 个元素，并输出% c$ M! f' X4 ?. H" ~  B
print(tu[1])
5 Y% r8 f( I/ T- U! z3 C) {e. 请使用 for、len、range 输出元组的索引. [" g9 Y) _2 g+ d
for i in range(len(tu)) :
0 w, g0 x) H* X- p: _: d6 R  R0 \ print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)7 v% y9 ]4 _$ J( V% |
for k,v in enumerate(tu,10) :
) p* D  ~7 i2 m# |" L. Q print(k,v)
, J* S+ n% w7 q0 f5 v10 alex
: V( K0 [8 k' B8 U11 eric
4 d, a4 ^7 c! {9 T12 rain* ~; N, @' L/ a7 r) o

* I# E  D/ a5 x6 Q7 X8 |for k in enumerate(tu,10) :
- Z$ H6 I! b; S9 l- Z print(k)
: }! `- n: x  ^) I+ m& Z4 F(10, 'alex')
# G6 |( V3 i+ [9 n" f# u(11, 'eric')/ G$ _+ G+ I; S3 W0 W4 K" i! K: m6 U' \
(12, 'rain')* a" S, H7 D; W- r# R9 x) l
2 f$ N/ M2 W% {0 @: g# e

2 v4 T( D2 e# [4 N25、有如下变量，请实现要求的功能
5 g2 I3 y' U! q) Ztu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

7 _- m' i6 i& H5 Cd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以. o1 W# C: a5 o+ V
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
0 q: ~5 G: \+ ]( e  P3 nres=tu[1][2]['k2'].append('seven')
1 r2 g- J4 V. e  F# V! z  j7 I6 O+ [! q  k# Y5 s) r
print(tu)7 T, z9 K. l- n6 o3 Q* [
26、字典
7 X$ c. }' ^- E$ c% k% S' x7 s) I$ udic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:; z: \: \2 v0 A0 T
print(i)b. 请循环输出所有的 value- d9 A* I5 w6 ~( `4 ^0 v3 n* D
for i in dic:
# V4 y; k7 ^* D+ u8 q print(dic)+ ], g3 `" i# X0 R; Y
c. 请循环输出所有的 key 和 valuefor i in dic:
) h5 m1 L0 j' S$ }print(i,dic)
( ~! K2 V# F+ h/ K6 C# J2 fd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
$ Y0 W3 j, i* Zdic['k4']='v4'
/ E/ X$ R: D4 ?3 q5 Pprint(dic)! }/ h2 E6 l+ C1 ^1 P
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
( o* A9 w+ @/ M' |; Q! tdic['k1']='alex'$ k8 D/ G8 D/ p7 z9 m# u
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典( l' W* y% c  q  \5 t8 Z
dic['k3'].append(44)
) c1 }, r+ K7 @7 Bprint(dic)+ r& W) I' b$ T) M4 n( y

* d( D" m6 Y1 L# ~" f0 ng. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
, N5 `, ]% L, r6 w( xdic['k3'].insert(0,44)% J: t+ _6 J! ~- W- P+ q6 d) }
print(dic)
" j6 V5 E* o0 m1 s) Z/ l: ~- u3 U27、转换
% e3 P6 }* f; o; {a. 将字符串 s = "alex" 转换成列表  s = "alex"/ S. ^8 M" A0 w# F& A# ~
$ Y! F3 S" u* s2 N; }
print(list(s))b. 将字符串 s = "alex" 转换成元祖
: o( i; \. u2 k' \; d# Cs = "alex", y" X/ t% F' n1 D& u
print(tuple(s))+ ?* F  N. I# {3 _  |$ t
- i; d$ J& G. b1 k9 l
b. 将列表 li = ["alex", "seven"] 转换成元组
9 w' K% M; w$ f1 B! xli = ["alex", "seven"]
3 i6 y. H; i) y; c% Hprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
9 O0 B% G  G0 T* g" Ftu = ('Alex', "seven")
  k: j" Q" M' f- x, `% uli=list(tu)
8 q/ O' X' _2 T/ U* o+ A8 gprint(li)
; R8 B0 d2 E7 H
; C. @0 [: c! {: r/ L  P$ x- E$ f3 t$ W6 U
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
: H" a# i4 v+ D+ p0 C
) h1 n% V) J6 s; T% fdic={}
- W1 g( \( o; t7 j3 Pfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面4 P$ e7 b" G) _) u9 D' i
dic[k]=v
4 E5 C* {3 f* |, s, y0 \+ U print(dic)27、转码n = "老男孩"
3 A: T' ]5 g/ ^( fa. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"( h5 E/ c8 d/ {5 Q! o
a=n.encode('utf-8') ! d9 {9 W' n  J7 C) E4 D7 g
print(a)
- Q+ K& e7 p, Y1 r5 Tb=a.decode('utf-8')
: @: W+ N8 ?0 l: [6 H& Iprint(b); D% N9 G8 v9 x4 L! t+ M
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
# K6 I5 P& G* _% a$ p. z, T8 kprint(a)
) j8 x9 V1 l5 E9 A8 ~# yb=a.decode('gbk')$ A2 F: r; J/ O  G  ^( R  X
print(b)28、求 1-100 内的所有数的和3 @* Z: \8 D4 e
count=13 C; E3 W2 _) g
sum=0& i! P8 G* X7 p+ x# J% Z
for i in range(100) :
: _, n% ~2 `1 r4 y sum=sum+count1 ?6 A$ D( R" {
count+=1
+ C9 o1 U) e# V- ~5 T2 s1 N( l7 \print(sum): ?7 v6 i/ G" D* a3 a6 q
; ?; m! u5 o7 T% G" F! E
count=1
4 E( j; R0 X; _. d, i( Dsum=0
7 E  E4 w- F6 U; m. U, O  _( V+ Twhile count<=100 :
" v7 w/ a+ J- q- Y) _+ M* B sum+=count5 ?- b3 H: h& T
count+=1
2 c2 C7 ^' U0 L4 O# xprint(sum)29、元素分类
2 u& t. |* n( Q0 f3 C7 y有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
7 x' I/ E% V/ l将小于 66 的值保存至第二个 key 的值中。" g. x, S8 h! L$ |/ G8 c8 z% v9 p2 v2 C
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}/ `5 w3 u8 [; J9 y
li=[11,22,33,44,55,66,77,88,99,90]
, G4 ]9 i* T1 a0 n+ Hdic1={
0 B( r! o" e# O9 g 'max':[],
5 C! M- d/ K% h: _+ F) X% Y$ L 'min':[]' o* a0 |5 S, K6 Z" E& G: W
}# o  K. W- }. J0 Z5 F3 @
for i in li :$ ]0 S' U; M* I  z& `# h, e( O1 j6 ~
if i <66 :
2 x, L# w8 C! Z  o* ^% ]       dic1['min'].append(i): ~* ^6 K! M1 _0 @) O( o3 ?3 P+ L
else:
  [- k" x& o& l5 ^" Y  }0 S       dic1['max'].append(i)
) r7 B' y. F4 v+ x7 b: l3 wprint(dic1)
/ Y" X$ e8 v  Z7 t8 E4 u8 t  l" f) M$ g
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
3 n. S: Y% J4 A( D) i

Python基础知识汇总

主题推荐