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、写代码+ j1 c& ~) F8 q: l2 F: Q
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) :' Z# l( a6 R8 l0 B1 b! z
name = input('name:').strip()+ ~  O% L! M0 b* {  P
pwd = input('pwd：').strip()
- l7 @1 g# W9 x  Z) Q% s8 p/ ^
* a; ^8 ~7 d) r+ r2 O$ b$ K if name=='seven' and pwd=='123' :* Z2 h  L# @% p( I' |7 a8 o( r* e
      print('ok')
) ?3 A8 u1 w: K1 t" a: B" C else:  i! l! V5 j# N1 E4 z! c
      print('error')
* u) k& b6 d+ h0 {! t7 f% B       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)  :
' F3 j0 a- u3 _ name = input('name: ')
& T; j3 g9 s9 F7 b+ P, o- h pwd = input('pwd: ')9 y1 T: n: N3 l5 b) O4 o6 ]# W6 x
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
0 o+ |5 O9 L' `) S7 k2 O/ F: X       print('ok')
. M  e8 w! S0 H8 O8 J else :  b) h6 P6 w$ |; M* w6 i7 D
      print('error')
) ]( a+ @& D2 Y7 _, h4 A       count+=111、写代码
: R4 G3 Z& K% s$ \  c( aa. 使用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) :
0 G6 h+ y9 e- |7 o  \; A if i %2 != 0 :
: C0 K! k+ x! [2 A       print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
0 z0 q: U1 L* A7 t, S, m- P if i %2 == 0:
  S! \0 T! f, j" ?, ^       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"
! q! l0 Y8 V# l! ^a. 移除 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)
0 B. R; ]" `. N- H4 w: ]( s- zfor i in name:7 D. z! V" o* ?  Y- p
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain4 C6 h) G+ H& y, T5 d  V
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
* u( V5 \3 u3 n/ {* A* Qprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
4 i, w9 A; y5 Gprint(li)
. p. x5 e4 [  U7 Z4 N) U ['alex', 'eric', 'rain', 'seven']
0 S" g* D! v  x  x) Kc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
# D4 f+ e( c" Z, k( B* Vprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')6 s; m% m9 a* |2 I. m' v6 o8 b
print(li)# W  E4 v( {! L: x* q: l) @
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
! o2 X4 ?* `+ n  c5 |. @li.pop(1)
5 j$ z2 T4 N* w5 }6 H7 H) }print(li) ['alex', 'rain']
& f- Y! X$ V& q( a! _指名道姓的删除li = ['alex', 'eric', 'rain']* N# h/ G: S9 z; s3 K: p
li.remove('alex'); Z1 q, Y' t* o. k
print(li)
  p9 ?2 U, n9 `2 ff. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']3 v- ?6 D0 h5 N8 g: ?2 v' [
print(li.pop(1))
6 L5 ]  |) h7 t( U, {3 G% Q$ qprint(li)2 M( a9 P5 U4 @4 }/ \/ x9 P

& M8 j* i) O/ E' X& q1 Q$ Y0 j) F5 Weric
* T( \+ h" s, F8 B) F1 }7 r- N['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
+ `5 q2 c# u4 w" P$ h" R/ udel li[1:]
! T) X0 r3 O' |+ a" m# _print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)2 z: F, O' }0 D/ c
li = ['alex', 'eric', 'rain']& J* j+ x2 n: l, h
for k,v in enumerate(li,1):
* ?; g" `! _6 G3 I" H print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
# p- E7 y' v7 \a. 请输出 “Kelly”
% ?) R+ G; ^) J1 y1 N. z! `li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]4 S4 W6 ?3 Q3 M9 l4 C
print(li[2][1][1])9 e9 f" u, E6 k- I4 m* w! e; G
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”: B6 Y0 r, }- t7 p4 u
li[2][2]='ALL'
" |  P" s! }! D" H- A# ?print(li)
, X7 D* r' Z7 i24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')/ E$ N1 O( R6 H
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
! M  p- `3 V) P9 E' C2 o5 Kprint(len(tu))
& M) K+ W9 P+ U+ W$ W9 D: Sb. 获取元组的第 2 个元素，并输出% p0 n- E. v1 j/ ~" s2 h$ a. N' K
print(tu[1])
& {+ S: \/ }9 `, Q1 x9 X' I, X, le. 请使用 for、len、range 输出元组的索引5 n$ ]% a- Z! A1 [
for i in range(len(tu)) :
" ]  I" C8 U6 M, \* I print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始): ?7 o/ a: h; x: z! z/ c' i
for k,v in enumerate(tu,10) :- h* g- }% p; x
print(k,v)- {" m% E/ y! F. w0 l
10 alex# h- `1 @8 f. G0 M! J1 A
11 eric. }6 b5 B9 k& t2 _# l" C. v9 X
12 rain% v7 V' |# \% Y% e  M
3 B& N+ I5 A) w' j- x, @% X
for k in enumerate(tu,10) :+ x: i5 I  S( z9 ~2 v' t
print(k)' a9 O$ }) x0 m4 b3 U
(10, 'alex')
9 M  \: v% T+ d$ ?( M3 ](11, 'eric')
" l0 d0 L5 _2 A0 O0 o9 |(12, 'rain')7 E( Z& p* ^: i% p
$ e( `4 x3 [+ R& c. ~0 B+ [

$ R: H; X! k, D5 G, C* T6 e25、有如下变量，请实现要求的功能
" d. J9 k2 T6 O$ c6 Btu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

5 a7 \7 |5 @+ td. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
7 k* Z6 i: r& S4 r0 Y) G% e3 }tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])  U9 l* Y$ b) C& r
res=tu[1][2]['k2'].append('seven')! T) P$ w. Z: l0 L
* l8 l& Y% ?3 j1 ], d5 t
print(tu)$ C" W4 E8 {1 K
26、字典
, b- a+ O: s, O6 U6 a$ zdic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
9 B" k7 C( T8 Q3 Y& g, B$ D6 t6 D print(i)b. 请循环输出所有的 value1 m# h( m. k3 F% r8 |. L$ i
for i in dic:% l5 i% n, }5 g- Q* L& F6 F
print(dic)
1 _& T. i: v! t4 F! m; L; ?7 vc. 请循环输出所有的 key 和 valuefor i in dic:
* P. S0 y4 V2 L& G) }1 |print(i,dic)7 n2 k3 t" @7 S6 n) |" @- U
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典: }% q7 y* D. g
dic['k4']='v4'
0 M8 B: w$ v3 T% eprint(dic)
( P, m6 Y6 {1 _2 g4 ye. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
4 W# |* x% ~/ j( Vdic['k1']='alex'
. S& y- o" I# {4 n4 ^print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典' N, v! l3 v8 G  A* t6 `
dic['k3'].append(44)* R7 k  N+ o! Z
print(dic)
$ ^% u7 q& M+ M8 @8 n
4 T% u: ~# n) G% g, ~g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
' F$ I; p4 b$ v- N( N, ndic['k3'].insert(0,44)* q* A2 X( f" a
print(dic)
# e# q! K9 {- I  I27、转换
$ w3 H. o. o( M. `# E' V$ C; ^a. 将字符串 s = "alex" 转换成列表  s = "alex"
. i0 L) O% g1 z& L6 X# T3 C
  @: D1 e3 _7 ]- W4 wprint(list(s))b. 将字符串 s = "alex" 转换成元祖
7 s1 V5 x3 j' q3 `: [: p- k5 k. us = "alex"" \0 `8 w6 ~5 ]% y
print(tuple(s))
# t5 @: D( y* O0 K+ |, ]3 g
+ s& i7 o. @, \" s) Vb. 将列表 li = ["alex", "seven"] 转换成元组
' K+ u% E, h# ^; kli = ["alex", "seven"]
4 H+ A% h0 h$ s2 k7 Cprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表$ v% a2 T" f* f; V: F1 Y$ U
tu = ('Alex', "seven")
1 O: z" A, l2 N, lli=list(tu)& k" v9 U% w1 ]$ M. y" @
print(li)
) a$ M" |! I7 J, G  \) l6 G/ _9 F  @, P4 ^2 P8 V

3 Q1 u+ a) R" `, O- D( ]3 x( ?d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
6 J3 h5 d; [: K, F+ ?4 C0 }" S4 w( N+ W' i8 a& b
dic={}/ j7 S& l: J" {# X; U
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
$ v& n5 S: m: F" ~& i dic[k]=v# }. }! Z5 A' R$ g3 z# B
print(dic)27、转码n = "老男孩"8 A- D  A& y8 r7 u* \# q
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"  }1 f' p" D! |8 F$ F
a=n.encode('utf-8') * l6 k( G4 `$ O) m! O
print(a)
4 F  e; t( [" lb=a.decode('utf-8')
/ u! M: T( j# d& sprint(b)# p, F- f" T2 q' t3 m
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
/ u9 B' I1 n& }5 T& b3 v( zprint(a)+ r$ H' ]- c0 R' s( _
b=a.decode('gbk')2 T( c. k2 S6 J' j3 }
print(b)28、求 1-100 内的所有数的和( t4 M8 J+ i2 ?0 v
count=1
, S9 f1 E- P9 Z: R: Lsum=0$ b5 c- v& L& v" a7 b
for i in range(100) :; E' r" i% s' e& a; Y: f* @
sum=sum+count
% Y! N: P  p3 O& m count+=1; T2 r1 C8 o6 `  X
print(sum)0 X2 o! |5 a# J( g
- L& X! s1 u5 U, d% X2 m
count=1
2 T0 v$ ?) O6 A/ Esum=0& N" K& |- e; Y0 G( f
while count<=100 :: a, J+ g; P  p+ n$ A
sum+=count% I( t, t. b. ]2 y. w* i; S, M; w
count+=1# `: a% C) F% w8 Q7 J9 y4 y
print(sum)29、元素分类; l7 u& _, t! @; F7 `$ T2 J
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
2 h* n# M6 [: x3 Y/ e3 W将小于 66 的值保存至第二个 key 的值中。
/ A. a, F4 p, U! D; `: l2 B( ^即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
2 ^1 j8 l6 c& m2 j8 T; dli=[11,22,33,44,55,66,77,88,99,90]
- ^3 C4 O) X( @8 G9 K  Y- x4 sdic1={5 z8 B; ], n6 X: P  {: L
'max':[],
9 j; [+ _/ p& t  C' M1 p 'min':[]
( i( G' g% g5 O, I8 E( `. D3 g}5 R1 Q7 p  @; A4 ?5 y* q% ^
for i in li :; F& x: r; G  D6 Z/ n- G
if i <66 :: l5 D' g6 l* J; ^
      dic1['min'].append(i)
) k6 W9 h1 h2 E' U7 q% x else:' c" }1 c. Q8 m- I
      dic1['max'].append(i)
; W. w- a! G( jprint(dic1)0 _0 ^' a. E2 b
. Z; o0 A1 f6 t( W" f- q
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}9 ~: p0 v5 p) m

Python基础知识汇总

主题推荐