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 v& i$ m: m6 i- G5 n
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) :( e2 l  p" a& ?3 {; C* j5 s: ?
name = input('name:').strip()- L( d6 N% e% l4 K
pwd = input('pwd：').strip()5 ^8 \& e! B! c5 {5 V: Y
+ I. O8 z. H% `; \1 {$ v2 }2 l. a
if name=='seven' and pwd=='123' :! y! P; P$ h( K' |6 k1 [
      print('ok')
' O2 W8 t, i* N% T; `( K4 o6 v, ? else:
& C3 j+ R6 q1 }* J2 U5 r       print('error')' u1 ?4 b2 m* M: y5 _, B9 H5 p! @' [
      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)  :
  P& Y1 _) ]# ]3 ` name = input('name: ')9 q% X$ A' W3 ^: A" W7 t! c' I
pwd = input('pwd: ')
6 T3 T2 z5 j8 u: V6 T0 V if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
% ]: ~) C$ X) P$ D7 C       print('ok')! M" N0 m1 S6 S" i- {" j
else :" @2 S' {/ L# V, t, n- w4 t. o) j
      print('error')
" B5 o( v. }+ y       count+=111、写代码
! V  G9 O7 n4 N1 H- b( W, h' L0 Ja. 使用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) :
6 a% p1 Q: s4 _8 [  z( Q if i %2 != 0 :+ K& \: C+ E' {. r& Y
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :% A  c/ x1 t5 H. }* h
if i %2 == 0:% [1 E7 t! i5 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"$ y+ r- {) @/ `& v. ]6 S2 x$ \
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)
) u& O' W) J. O3 y# H4 V; Ffor i in name:
3 @4 L6 O& m  `4 {8 E  r2 X% R7 e print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain, A9 e- |9 M8 g
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']2 x' o1 @  r" M6 H9 Q! P5 E
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
9 ]" ~! D+ `& k7 xprint(li)5 A, g  L$ P* `1 x7 ?: s& i
['alex', 'eric', 'rain', 'seven']' _. T+ v2 c" j) t4 g5 r( [
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')# O. v- P/ V" k2 D- b! i7 x
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')8 ^3 J8 Q( I1 B) f1 p
print(li). q2 w  s$ m& M: ?7 H8 {7 b1 J
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']2 y, ~6 x; V. ?  }( @& J" ~: T+ q
li.pop(1)/ `# Q$ i/ a+ r% U' d% U
print(li) ['alex', 'rain']0 @/ O( G" J# G3 |4 M
指名道姓的删除li = ['alex', 'eric', 'rain']
6 Q: b+ a' T- B* L; A: \li.remove('alex')
3 k! `1 J; I! x9 C; ^2 |! qprint(li)
% l% j; C! {; j8 [f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
: S) n$ A" @  E0 L9 Y9 W5 {print(li.pop(1))
( f4 g  g1 @9 i% Xprint(li)
0 S* j1 i3 r( i' G  S
% R# X. j; O& \$ \& [eric
) @! O( \& e" x- |- T  V4 U, m['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
  t8 R. ?( e+ h4 [del li[1:]; m8 e. D+ C1 `+ a0 P
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
& _- V9 L, H! H# Eli = ['alex', 'eric', 'rain']
6 I) n7 n6 }7 b" U" L# u, J" H) Nfor k,v in enumerate(li,1):- f  _# E1 D+ [! I: o: t: H  r, [5 l
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
, V; s1 w9 M' @  I8 n. g( l) ]a. 请输出 “Kelly”
3 x' I5 N7 A9 H4 [. g6 o" N7 uli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]4 O7 G- l; y% _$ O+ \
print(li[2][1][1])/ n# L1 z% W4 {* F
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”* h- E* I5 ^; Z8 a; `! ~
li[2][2]='ALL'
2 g+ s# _1 x1 C8 n6 p; vprint(li)
- V7 o% S$ o5 d, x, {$ ]24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')  j' r! F; M% ~; f' P6 u: s+ k
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')6 K6 |2 L: ^; r6 j3 F! T  |
print(len(tu))
6 R2 j: g8 S% D& ?& d# Eb. 获取元组的第 2 个元素，并输出
! D7 y: \1 w3 F+ F$ j* ]print(tu[1]), e. d' Q2 b$ n* Y# }
e. 请使用 for、len、range 输出元组的索引
4 m* ?8 V9 B0 r: m4 f" wfor i in range(len(tu)) :
- V2 C- Z1 `! }9 E. U- h  Q$ q print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
, Z' s  ~" b0 f; Y0 cfor k,v in enumerate(tu,10) :
5 j3 T1 P) e0 }. E6 P print(k,v)
  A; P: e0 R/ W2 V5 f10 alex
1 D) ^5 s! I. \. ]( f11 eric
# I  T, E  ?( K  ?3 W/ W' j. X12 rain
  @  K) C8 x: p) I+ ]' w7 g) Y/ i) P5 x' A( [7 u' J% g3 ~5 k
for k in enumerate(tu,10) :
& [+ X/ h: M9 L print(k)
/ J; ?9 c6 c5 \) ~$ B(10, 'alex')
- S0 |8 E$ h9 k1 ?# f; e0 j(11, 'eric')/ v1 c2 o! s! a0 L& p6 z5 Y
(12, 'rain')' }; w6 L- B& N2 s- W  W/ l0 e
5 G: b& `1 ^. R& _9 m1 e

6 [0 Q0 P+ R7 ?7 X) K( D25、有如下变量，请实现要求的功能
1 b$ {  K, O6 Ttu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
$ J/ A4 x: J$ N: l  C8 b8 h6 \2 Q; U
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
) w. e. f0 X- q, a* i( w1 wtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])" D8 a. I/ x) s: c# d
res=tu[1][2]['k2'].append('seven')7 B. O, J  u2 R7 [( W+ _8 X! p- U

9 k% q) G6 [5 E0 b+ [, B3 kprint(tu); z7 c5 b" y; T2 O6 q) M
26、字典
% y( V1 y8 r3 [) n8 Ydic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
3 a1 o' `) J( D2 r/ U& q% y print(i)b. 请循环输出所有的 value7 q% P0 `$ I5 v- O
for i in dic:& O3 U, i+ ^9 s3 f" c& z, k5 l
print(dic)6 f: \6 d4 x6 f
c. 请循环输出所有的 key 和 valuefor i in dic:, f! s: S+ H; m% D; [4 Q
print(i,dic)! ]; `+ b' W# _7 q3 g* d; p0 ]
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
+ _6 `8 ~: U* o' Q0 Tdic['k4']='v4'  |) p8 \0 {0 _: W, s; F2 `
print(dic)
( A% k2 ?5 @1 [9 I' Re. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
/ L8 j! d" C: Z0 _) D4 Wdic['k1']='alex'
, y1 y( S7 u$ g' W: Uprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典. H" ?; o  v" H& D5 `
dic['k3'].append(44)3 J! G! T$ y7 b4 J3 Q3 [7 r
print(dic)7 \! N2 ^/ m2 {" @; X2 j

  N# l$ I$ m- Jg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典/ C: o) \  t2 }3 ?
dic['k3'].insert(0,44)- K3 u/ x- n. _/ r
print(dic)! `# q; {* s. C8 n2 q. B- x
27、转换
% ^+ D( H# H3 Y9 F% R% F& }: Ca. 将字符串 s = "alex" 转换成列表  s = "alex"
* r3 e+ _2 D8 A% C% M9 E2 a* m" x1 n3 t, L; N; K" m8 q
print(list(s))b. 将字符串 s = "alex" 转换成元祖
- r% Q- U% L3 c1 D9 U9 m4 qs = "alex"% Y7 A# f9 K% X4 E
print(tuple(s))7 f& N% W+ H& z) a2 R6 n

# H8 t' m  D! h, Wb. 将列表 li = ["alex", "seven"] 转换成元组
) o9 A9 w1 j$ dli = ["alex", "seven"]
! Z( f; Y1 r* j+ Y4 x0 ]print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表3 i+ L4 ~  X& ]3 z5 [$ E- y5 `) X" S
tu = ('Alex', "seven")
( R3 c# s0 H, c3 a6 V) Sli=list(tu)
" k  o" ~1 Z# P, ?print(li)
6 c7 L& ]. K2 V* h
1 J. c0 j* ]& L* \* Q1 F/ s6 A; t- T+ j  ~, g& {
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增" ~4 b9 r- g/ ]& K  ?; ~0 D

5 w) o7 p7 D* [$ m6 ^dic={}" A$ |0 e0 E% r$ F- r
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面3 O, s+ f; u4 X% P* |% L3 T- T/ I  A
dic[k]=v( O0 Z, b+ W% N2 q- o! R
print(dic)27、转码n = "老男孩"
& s$ E+ O. k. l' za. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"4 q2 |( p$ W2 N: t( u- R4 ^. I3 x$ {
a=n.encode('utf-8')
. l7 J; E% S$ f5 ]. qprint(a)& Q1 C- @5 b3 f: l, C9 e# W
b=a.decode('utf-8')
. I+ H) f9 H: Kprint(b)
6 p. V; q( i7 y3 W7 v4 Yb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')3 `  O- j1 j. i4 Y
print(a)
0 v9 t1 _6 V. `) p- l7 j9 f; jb=a.decode('gbk')
) T! B1 o$ a* y( z9 _* ]+ |print(b)28、求 1-100 内的所有数的和
, j$ f" Z6 z  u# L# `& W* s2 dcount=1% ]9 f. t( I" U* G$ V
sum=0( u/ c9 }% E* I2 A2 |
for i in range(100) :
  ~6 u/ m) Y% m sum=sum+count. j* g  l4 \: |; m
count+=1& V) p0 Q+ I& V# P; @$ ~  j% q
print(sum)
, u1 r/ ~" b4 j
" f6 X! f! ~: j( G" Lcount=10 B  H. X: Q2 N' e' x
sum=01 w" V( e+ V5 q) |. M
while count<=100 :
2 T# _4 L+ L; j9 O- g  S5 R7 `4 _ sum+=count
+ k. U& S- T) x1 [) {0 | count+=1
2 ~6 i4 e4 _* C# P4 Z& a* Lprint(sum)29、元素分类; t2 e7 V, T5 Y, @. X- S( ?
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
! n6 N0 o2 N9 b7 Q6 ~0 `将小于 66 的值保存至第二个 key 的值中。& e5 y" Q( H: v4 ?1 ]0 N
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}7 b/ \* v" L8 E% B
li=[11,22,33,44,55,66,77,88,99,90]
: J5 C/ I+ E3 K6 T! q5 {* ~dic1={$ [" e0 ?% g8 L9 f* \
'max':[],
6 R" F% x5 T! E. Q* _ 'min':[]
1 l; q- K7 s$ @- ~/ \) W/ W9 h}$ H* L- N/ E6 B0 J+ k, a6 E
for i in li :
0 R5 \- C% T, u; n7 H5 z9 P if i <66 :
) g  p9 C# y3 g7 U5 F; v* x       dic1['min'].append(i)
0 h# `$ ?* y7 _ else:) C8 g0 m6 T3 h5 z2 A  g8 K; b
      dic1['max'].append(i)
' N* d" @" O$ a; \0 }7 qprint(dic1)
- n% G1 W2 ~$ u$ N
8 f" h) W1 s% [! x  h5 o  v---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}1 ?9 R$ T) i* C6 |

Python基础知识汇总

主题推荐