Python基础知识汇总

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 单行注释和多行注释分别用什么?

单行注释  #

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

9 D9 C% K, b0 u, Y8 ?4 p6 N' B6、声明变量注意事项有那些?

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

不能以Python的关键字命名，

能表明变量的意义

: W+ G% f7 }  H8 s; f0 v, ^8、如何查看变量在内存中的地址?
! A! r# N+ t$ X; a) Uz=1
) s  B5 c: y* n. S5 {$ c; \/ Y0 dprint(id(z))
/ f; O. k& x1 y7 Y% n$ }9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

1 y5 Y0 x% k1 h' G% w& L7 h8 g10、写代码
! A6 v2 z. p3 _" F7 C! |# ^a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
1 D/ h/ }; f! l' q, cname=input('name:').strip()
% ^0 P! m. r' ]' S, a6 U0 g* r$ Cpwd=input('pwd：').strip()
6 b( f+ ^; ?3 v6 b4 Y( r- Yif name=='seven' and pwd=='123' :
    print('ok')
1 a! M2 x8 Z, }( C# f  b1 Selse:
    print('error')

b.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
count=1
4 N4 ]. j0 i6 D" J: i, y' d- }while count<=3 :
0 @& F8 n2 C" ^; b, p# z    name = input('name:').strip()
    pwd = input('pwd：').strip()

    if name=='seven' and pwd=='123' :
        print('ok')
    else:
9 ^$ \* b5 I+ M: l# F$ [8 v! C        print('error')
        count += 1
7 E6 K) e: k5 A& Ufor循环：
2 r3 l, k1 i$ u( V5 x/ a: ifor count in range(3) :
1 V2 r+ |+ N7 q% D0 o, f    name = input('name:').strip()
    pwd = input('pwd：').strip()

    if name=='seven' and pwd=='123' :
2 c* e; ]( E  u        print('ok')
    else:
        print('error')
        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
count =1
while count<=3 :
! N9 I! {# u; o- n- P( |    name = input('name: ')
7 t' H& R1 z& c  T. _  P+ T    pwd = input('pwd: ')
8 Q0 [& j* Z+ P9 o8 ]" q+ ?    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
- r. Z& s/ g# P4 w/ q' B        print('ok')
5 }# n5 j/ |! P    else :
        print('error')
        count+=1
0 m! N0 t# ]' Rfor循环
for count in range(3)  :
    name = input('name: ')
    pwd = input('pwd: ')
& O3 W: \" @! u# a9 L/ x& X* k    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
# ?/ v/ }+ q7 n# d        print('ok')
    else :
        print('error')
, H& [/ Y3 B$ `  ]        count+=111、写代码
a. 使用while循环实现输出2-3+4-5+6...+100 的和
count=2
6 a8 ?3 ]* @$ S' h( dnum=0
0 h( m4 B% [" P" Iwhile count<=100 :
' V8 y* L; v5 R% C  p6 ^$ T8 K  v    if count % 2 ==0 :
$ k& K6 D5 }6 f8 F" B2 u( }. j        num=count+num
        count+=1
, i# Y* D" a' d$ T: }    else:
        num=num-count
        count+=1
print(num)
8 A) a  i& ]+ {
b. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
& G; y2 O/ M7 I1 `5 y. ]& P& F num=0
( e: T- \# f- h  K% E2 J. y( {) dcount=1
: _5 G& e! Z0 t8 s" x7 U  F6 Jfor count in range(100) :
5 O0 }0 d. h4 @6 f3 i# T    if count % 2 == 0 :
        num=num - count
5 Y% m- y2 u# T) i# |% ~& q/ ?    else :
: ~: X* b$ Z0 W, y8 n3 s        num=num+count
) K" B  ]% L' R/ _3 [2 Sprint(num)

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

+ i: I; W$ @5 U8 x, R7 ncount=1
4 A2 r* O& @8 \8 f1 G7 e) b& y& n+ swhile count < 13 :
- I& z" m/ W4 c2 p. ?% f- ^  D6 v    if count !=6 :
# Y2 F$ |: I7 d- O' i2 ^        if count !=10 :
5 r1 c' e1 `, |% ?4 t7 E3 v, n0 \            print(count)

    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
for i in range(101) :
    if i %2 != 0 :
- D, I3 @4 K) A7 r0 |9 D        print(i)
" r$ a, z& ?3 I2 D& g$ i
2 C8 m2 E* v/ U9 L& d; Acount=0
( Q0 B8 h" ^$ w8 J/ twhile count<100 :
    if count %2 != 0 :
) S3 C' J3 w2 O7 O. r- Q        print(count)
8 e: p' x  J! D6 N: I    count += 1
% j# k: ^2 t$ Q
e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
$ s$ e& j8 E# U! J3 P! q6 |7 K: m! T* q    if i %2 == 0:
        print(i)
5 x0 ^0 g; N9 G% ?7 i2 c
. _; q1 |$ m6 ucount=0
while count<100 :
! \" P' [5 @, B) O5 [/ C    if count%2 == 0 :
& P2 U8 h1 r- g: F2 `/ T        print(count)
    count+=1
# q7 W5 ^# V9 v" A
12、分别书写数字 5，10，32，7 的二进制表示

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

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

! F6 Y( t$ x0 U/ g! m/ c' N/ v16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

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

18、布尔值分别有什么?

False .Ture ,或1  和0

4 J% Y  |8 a, j) N; K) r20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
a. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())

- \( b% I4 ^+ {5 I* [& }b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
print(name.startswith('al'))
c. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
. C: s2 Y: o4 {8 b! V2 h. C( f& [, N& ?d. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
7 p: G# k3 ^4 u+ I! M  c% wprint(name.replace('l','p'))   apex  
e. 将 name 变量对应的值根据 “l” 分割，并输出结果。
- Q# l. C/ v, I2 O! dprint(name.split('e'))   ['al', 'x  ']  列表

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

2 v) o% ^, V8 G  K( @j. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
# z3 l$ M; S0 o7 G5 z1 V依赖索引
( b: ^! o6 @; P4 x8 p# Uname = "Alex  "
for i in range(len(name)) :
    print(name)
+ Z# D; Y9 @8 P4 u2 _& c) Q( Cfor i in name:
    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
1 q& O9 E) K9 F& i22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
/ o2 P( D* n) q/ ]& }( ~/ q. Nprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
print(li)
7 _0 L4 E2 C/ Q) b! m8 I ['alex', 'eric', 'rain', 'seven']
0 y, ~9 s# f9 w9 h3 E4 E( b6 dc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
( O7 w% a  K! Q# \) p0 F8 Fprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
! A5 K" Z5 D  g9 xprint(li)
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
li.pop(1)
0 D, c  Z: J( ^$ Xprint(li)    ['alex', 'rain']
4 ^! M8 j4 K5 z; G. P7 G" |  b6 m指名道姓的删除li = ['alex', 'eric', 'rain']
$ o" E+ G# a; t; s4 Z2 p, Jli.remove('alex')
print(li)
& @/ a. S% m6 m# U/ a2 Rf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
print(li.pop(1))
9 E8 R" P0 u9 f9 \$ c- |& vprint(li)
$ s0 f5 F& Y/ u
eric
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
& V$ t" N( N' l; o0 }1 i: adel li[1:]
" _# s6 ^7 n& }! {+ Xprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
4 x& V& H; F* f! [/ Ali = ['alex', 'eric', 'rain']
1 |* i" ]/ l& G8 ^9 qfor k,v in enumerate(li,1):
/ l0 p  F6 ]7 j" E    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
a. 请输出 “Kelly”
: a3 a7 Q9 }4 u6 n3 hli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
print(li[2][1][1])
' J( y" ~! C9 F4 i2 nb. 请使用索引找到 'all' 元素并将其修改为 “ALL”
li[2][2]='ALL'
0 [8 D% R- _( k9 D* V0 s8 ~print(li)
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
print(len(tu))
" l# a3 h2 q7 c4 Z) C. Nb. 获取元组的第 2 个元素，并输出
print(tu[1])
7 @  R0 |$ r1 ge. 请使用 for、len、range 输出元组的索引
0 J7 Y  n8 t5 O0 l+ O4 J$ sfor i in range(len(tu)) :
    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
6 N8 @, c+ u& w" P; @( afor k,v in enumerate(tu,10) :
' ]& f8 ~& u  B  l, [( ^4 K$ O) O% p    print(k,v)
10 alex
! r1 \* v0 q$ M* I8 T11 eric
1 s1 I7 v& I* e) Q12 rain
) V0 ?' q6 H$ y2 b
7 V( r% A9 ]$ M2 l. G8 ~  i) Qfor k in enumerate(tu,10) :
  s  r" ?% I0 x) M/ r' u6 X    print(k)
; ^. Y. Y% Q& x6 s2 R/ @& M(10, 'alex')
(11, 'eric')
! `7 ^! w. L4 ](12, 'rain')
# p/ M) g6 B6 @9 L0 Z0 {

, p2 \, Y& x8 B$ H7 `25、有如下变量，请实现要求的功能
, E: E2 @1 J3 l+ x. K) \; P" u. e0 ^( b& Gtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

元组，不可以

d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
res=tu[1][2]['k2'].append('seven')

; N3 ^' B: C' C) Y; [7 qprint(tu)
- L1 s5 h5 j3 m+ ^( r0 ~; h26、字典
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
4 W7 O- b9 Z, O+ A% A0 I# \    print(i)b. 请循环输出所有的 value
% z# K: M6 T4 t: n5 c$ u/ Wfor i in dic:
    print(dic)
c. 请循环输出所有的 key 和 valuefor i in dic:
print(i,dic)
) C2 q" B; O! l/ x' h8 {( \. od. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
1 c. R, N0 W0 L8 j* f, ]9 [# w1 @dic['k4']='v4'
, V- R0 z9 W! x' d1 j6 o: g9 Nprint(dic)
9 r% L/ }2 p% u3 r& ?1 ~" Se. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
5 o$ r. s4 |% Pdic['k1']='alex'
! Y. Y/ U9 \8 f! ~print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
+ K/ @: Q9 Q7 ?dic['k3'].append(44)
print(dic)
9 J8 N* T0 a; d7 B( p
& L5 Q! w" m1 b2 fg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
% x$ q6 |* [8 |6 @3 xdic['k3'].insert(0,44)
& C/ Q; n8 e( hprint(dic)
$ W+ q+ c* P9 v6 a) \9 l5 c27、转换
a. 将字符串 s = "alex" 转换成列表  s = "alex"
) \+ B3 Z6 m7 S. P, c. r
print(list(s))b. 将字符串 s = "alex" 转换成元祖
s = "alex"
print(tuple(s))

b. 将列表 li = ["alex", "seven"] 转换成元组
' k4 {+ X  d) F* v0 N8 ^0 ^; \li = ["alex", "seven"]
) A9 o5 @+ [" q; B& Aprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
tu = ('Alex', "seven")
li=list(tu)
print(li)
6 H8 R8 a% G* \0 T

5 a# B* @$ U. |8 b) T* r; Bd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增

* c; v8 t) ^( I2 e+ d6 Kdic={}
/ V8 P0 }  a: \8 n4 B% nfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
    dic[k]=v
0 X9 E' n: j. X! d4 o$ g1 Y    print(dic)27、转码n = "老男孩"
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
: S* D, w. p$ C3 c8 k1 c- qa=n.encode('utf-8')   
- E3 t. v, I; ]! l$ z* Aprint(a)
b=a.decode('utf-8')
: m, S! H  E% d& V" cprint(b)
, @' m  n6 V! e0 c) F7 ]b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
7 k6 V, F3 k+ s/ M  `print(a)
b=a.decode('gbk')
6 ?6 [5 U) a) f. g, w0 mprint(b)28、求 1-100 内的所有数的和
7 ]4 p) o6 v) H' b+ ?2 E6 x( p' dcount=1
sum=0
for i in range(100) :
' g: ^- |2 x1 S, Q5 B" w3 ?    sum=sum+count
0 `" w5 N# g4 k% y5 g    count+=1
4 I$ _8 {  E" s. H4 [print(sum)

count=1
1 V4 z$ v, \9 U6 B( {! z8 B2 asum=0
) O7 y' |7 y% c& K: }) l4 Bwhile count<=100 :
    sum+=count
- T% i/ y# }& {    count+=1
& N5 _5 [: O+ c2 s+ kprint(sum)29、元素分类
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
将小于 66 的值保存至第二个 key 的值中。
1 l$ h: ?+ R1 R. {  c# p1 |即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
li=[11,22,33,44,55,66,77,88,99,90]
dic1={
    'max':[],
    'min':[]
  G- f( t( ^- O# G  K. g1 e3 j+ H}
0 \# c. r* v) f( r/ n/ ]: |$ j7 i3 ]for i in li :
6 `' ?/ L# w/ y& F* ~: Q: g    if i <66 :
        dic1['min'].append(i)
  ]  E5 \, I% I2 g    else:
  t1 O* l+ v6 B        dic1['max'].append(i)
print(dic1)
  s% O1 @* L" J3 _0 x* M* _& L
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
  w1 l, j( V% z) R