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、写代码
  `5 A1 t+ ^5 G, Ca.实现用户输入用户名和密码，当用户名为 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) :" N& A/ f) Y# m/ L9 t
name = input('name:').strip()
$ G8 g8 ?0 M0 i  `1 E) M8 v% G3 a pwd = input('pwd：').strip()0 M0 {' I# z2 t+ x# o+ p. A

" _. j' w; m- _) ? if name=='seven' and pwd=='123' :% X' C, q; K* A9 B  m- W) \; m
      print('ok')
. V. g$ B+ b) A. e. y else:0 R5 n" K8 l9 u
      print('error')  p& Z2 v. ~2 p& a
      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)  :- |! k9 k4 }" U* n
name = input('name: ')
) {, F" E# R0 N1 n. i9 [. V' d pwd = input('pwd: ')
% J* ?" n) Q1 _9 x4 A if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':$ w! e* n; M  ~! l
      print('ok')8 h: y1 ^$ h( i: r7 Q5 R8 T" M. L" l
else :
9 r9 o( L5 t5 b# l$ W/ @2 |       print('error')$ E! n" q" k* \3 Z) r" C2 _
      count+=111、写代码4 ?5 q2 S0 d: }  @' \6 Z
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) :8 {1 H* h1 S, U* n
if i %2 != 0 :+ @2 j5 s  _- y! G. a& S. \+ F: }
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :- l& W( e+ k4 {8 P% x. e1 E8 U" G
if i %2 == 0:$ ?# j4 R5 T; {& u- }; @1 h1 m( ]
      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"
3 g6 q6 V7 X% F, O0 n" Ea. 移除 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)+ L6 G, R2 m- X2 x
for i in name:: L0 D9 Q: L! K. L
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain4 w0 I5 b0 E+ e3 }
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
4 h: }+ @7 N5 W! K4 u1 V7 Uprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
# W- I. Z! }! |+ bprint(li)/ m4 C) Y( V( a
['alex', 'eric', 'rain', 'seven']
3 a0 ?5 T* I; {1 S$ D7 Z0 Qc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
0 D; i" v9 Z9 p7 S9 Kprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
0 ?$ }$ y  j+ fprint(li)
( q6 Q# k( E. j* S( _$ l; qe. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']4 [; X1 q1 Q" p% t
li.pop(1)
1 @" Y/ ?- X: v6 `& M: Iprint(li) ['alex', 'rain']
3 R- G+ p1 g( j3 i4 }指名道姓的删除li = ['alex', 'eric', 'rain']. K2 t8 x7 W- I6 T7 E' ]! c& l, l- A2 C
li.remove('alex')
" [: p* v- y  ?/ y, [: Yprint(li)+ I4 M* o/ t; C" o/ @
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
7 [) [5 m/ S( a# nprint(li.pop(1))2 e; Z, V+ G. Z2 c" h" {
print(li)
3 b; G* B1 _/ \3 ^+ F1 ^) \
# B# e! R* r0 _4 V% Peric
5 }1 {; v8 H6 G2 p/ ^) S['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
) i" _1 l+ y1 V; C/ ]6 edel li[1:]
) o  Y! i2 y. Gprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)3 X. n4 I, l7 F/ I: S
li = ['alex', 'eric', 'rain']4 j4 W: r2 S1 W2 S* C5 V7 I# i5 F: B
for k,v in enumerate(li,1):8 a5 B4 Q: z, i! o' R
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
5 h: j7 a+ T3 `8 u/ W* _a. 请输出 “Kelly”
. x6 X( w4 j1 @/ t* A$ K9 ili = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]2 A: F2 a0 ~4 k. q
print(li[2][1][1])6 W+ l. z, J  k
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”  |) `* Z7 W+ ^2 ]! H& u5 P- ~) A
li[2][2]='ALL'; |4 ^; @: n2 w+ |- n5 Z
print(li)
* q4 e7 V. I- k* `, [" m24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
9 r; L8 o. x2 Q+ X; m- fa. 计算元组长度并输出tu = ('alex', 'eric', 'rain'): Q# j: s# B3 ?
print(len(tu)): q* @0 @$ H# p& }3 F( c# p
b. 获取元组的第 2 个元素，并输出
9 w( V) t1 z2 K, J" Nprint(tu[1])& v: [' L2 x/ U* C8 g( m: Q
e. 请使用 for、len、range 输出元组的索引
/ ?& l3 I  E9 g' x* y6 c, Vfor i in range(len(tu)) :
6 q1 _8 A7 Z* `) H print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
+ T% k! W7 g- bfor k,v in enumerate(tu,10) :6 k! s' H% Z; J* c+ m
print(k,v)
0 t* W- D4 q4 t10 alex, w2 T- o" W' U! X0 M+ X
11 eric
6 }: X/ M  P; b, x$ ]) F! U& t0 b3 B12 rain. I) [# }! v0 ]0 u/ ?/ {

7 D9 f1 t- b0 k5 {! g  Z- wfor k in enumerate(tu,10) :! G& p* B. e3 ?* u2 X! @# V4 A
print(k)
% Q  a  @  K( M5 B(10, 'alex')) ]! R/ @) N& S6 {
(11, 'eric')( d. E# {2 A5 F0 B" a8 G
(12, 'rain')
. G# ~5 y6 b/ D- v8 B" S3 H1 I5 e8 e, B

) K$ J+ e- x) r2 i; u; g2 N. E25、有如下变量，请实现要求的功能
, y4 ^( ]7 O; g! O9 w0 Rtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

) g* v/ Z' _1 W6 `' {0 Gd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
0 |! G2 Z+ e. S6 S7 r7 ktu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
1 _9 ~. C5 H9 I! T! C, x8 g% \res=tu[1][2]['k2'].append('seven')
( ]' p! O% T' F' {( h7 u: E1 }
- z" w0 ~- A6 X3 z* C: Xprint(tu)
! s9 r7 H: |: K0 {% I26、字典" C/ K( e! A6 D. T+ E0 B% @% m1 D
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:) H9 o* c0 o/ @% s
print(i)b. 请循环输出所有的 value
; W, m* F: f, |5 h' `& Gfor i in dic:, V+ L. G4 o1 O1 X
print(dic)
- e* B% J3 x$ bc. 请循环输出所有的 key 和 valuefor i in dic:, c" z" Z  L5 Q, }8 r/ z
print(i,dic)
" c" F; T- j& t6 Z4 C  t9 u7 Fd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典% l/ N2 G& S7 f- X. K0 V
dic['k4']='v4'' j+ U* l. h1 e  u; Y8 T! n
print(dic)
' t3 ]4 m$ N5 o4 fe. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典" l0 j- @; ^3 m! `0 N* u: J
dic['k1']='alex'
& l4 ]9 F8 R3 z5 v8 v. L6 nprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典0 f" @9 u% y5 A; r# S7 k- L9 L( y
dic['k3'].append(44)& P0 X0 P$ s* o( m" E6 `
print(dic)% p# p3 L* U( I$ R. W& X
# d2 q2 }8 c" C6 \1 N1 v
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
6 ]/ H. F2 L. Udic['k3'].insert(0,44)
, k5 J* V& j2 A# cprint(dic)- Z# A4 S# q8 V" o6 P7 `" d
27、转换
9 f0 ~: k( N, r% E4 V/ sa. 将字符串 s = "alex" 转换成列表  s = "alex"9 Y& e4 o" W! q$ `

- v, ~# W* I5 g( Wprint(list(s))b. 将字符串 s = "alex" 转换成元祖
0 @- I2 w7 k: K- V% xs = "alex"( Q. K7 D' Q2 @0 [
print(tuple(s))& b/ d+ T: S. O# F, ?1 H" Q
  W3 t% D2 e7 I$ |) |
b. 将列表 li = ["alex", "seven"] 转换成元组
0 ?+ c3 l! M3 _- j' H5 A: _li = ["alex", "seven"]( m' }6 s6 _8 B0 X+ R
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表3 Q/ ~8 k  G+ n' A7 j
tu = ('Alex', "seven"), T) U. u- V4 U; e3 f7 y
li=list(tu)
4 Y4 a1 }/ O, _& |7 F! ]print(li)6 F3 e/ R3 _3 u# \# G. ?6 q

/ A" i1 [7 d# v# U5 W( M( ?7 [0 ]0 w; {! K$ |% M" m9 M
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
- l$ |" W/ O; q$ R/ C4 J* `# m* P7 ]# i" }: `  [$ n( a; P: f
dic={}+ ]# s' \3 ]% P. y4 H
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
. J$ R$ m( n4 n7 q dic[k]=v
& |& S( A' P9 [ print(dic)27、转码n = "老男孩"& ]; |0 j. S. ^$ u. U2 \* I, [
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"' Y4 Q% H+ Z2 w3 A( w7 U2 g
a=n.encode('utf-8')
9 [+ N- ]! W7 b# Oprint(a)5 J8 C7 }) V3 t, f3 r
b=a.decode('utf-8')
0 i2 g) G  A6 [" C2 Qprint(b)
% V- G  o' J% Y/ ^6 nb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
2 ?6 Y) D/ S4 N1 O+ z! h( B  Iprint(a)& H, }, |6 w, W7 ~, y* v. q
b=a.decode('gbk')
7 g5 b. i# d! q  `/ lprint(b)28、求 1-100 内的所有数的和- x; l" g) Z5 h& w
count=1
4 E6 S# F1 t4 b, W1 nsum=0% E2 }" k/ a7 q+ c) j7 h# w& V
for i in range(100) :
. O' o0 A, q& }: K3 F! J4 g sum=sum+count$ ?) ?) F$ J2 _1 s5 R. ?
count+=1
% a" J. J  \% f, v' l4 P4 y1 Jprint(sum)
3 v/ J* {3 @* x4 k7 W
/ J# Z" |9 F. T0 Mcount=1+ c9 g1 k. L: r0 v5 Q8 [* P, ]
sum=0
3 F) ~4 I' b, B+ P# a8 ~while count<=100 :
3 M: L5 m. P9 V0 A sum+=count
+ _: ?- r" r9 c: Q2 q) j2 M count+=18 W% Y$ G/ C4 k% }
print(sum)29、元素分类2 m  }- V4 S$ D7 \
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，5 T' A4 @: t) ]& {/ a! J
将小于 66 的值保存至第二个 key 的值中。, `4 z; }& `' h" o! V4 U4 H& V
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}& g( T& h5 \& T" ?$ b
li=[11,22,33,44,55,66,77,88,99,90]" y' `; R8 U/ O# ^3 e7 W
dic1={
  a" i2 G8 r6 T$ R5 |) U 'max':[],1 i# C9 C* E6 l5 h' X. j
'min':[]4 Y1 i0 g% t( j% F0 x  a3 P2 V% b( D
}8 E% }+ m# a' ]# u0 ?  b
for i in li :
- a( K( ~# Q7 {1 U0 s: F% _& c if i <66 :+ n" r+ w2 w6 |8 L* u( }9 i1 L
      dic1['min'].append(i)9 r' C# |2 t& J- R$ a
else:
7 k5 p; l: `( _/ j& n6 _. g8 V       dic1['max'].append(i), D# W, P5 \+ Z2 H
print(dic1)8 O/ l- b0 J0 c- v

2 W9 J! L! Z9 q$ o, `3 Q; D---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
0 A2 y. p$ V# f3 b" F# |

Python基础知识汇总

主题推荐