Python基础知识汇总

1.执行脚本的两种方式

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

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

2、简述位、字节的关系

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

8 c* ?3 s4 c' i( b% c3、简述 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
7 `) j2 c/ F) R1 P: y7 Uprint(id(z))
9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

% a' K2 [. @4 J2 I, E8 U2 u10、写代码
a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
name=input('name:').strip()
pwd=input('pwd：').strip()
" M* r# A& ~/ fif name=='seven' and pwd=='123' :
/ b7 H9 U2 d7 h0 k  U- Y    print('ok')
else:
. z! p7 [' |9 o0 m4 p3 [! r    print('error')
8 g( H0 n9 u: M+ d! S% x
" \" w# o+ l4 e& Zb.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
count=1
while count<=3 :
    name = input('name:').strip()
5 R2 |+ m( r5 F( t) M) r    pwd = input('pwd：').strip()
0 y! j" h: y9 g; E0 ?1 v: U4 \) G
    if name=='seven' and pwd=='123' :
        print('ok')
    else:
        print('error')
        count += 1
for循环：
( c, f, N2 O; a4 u# gfor count in range(3) :
    name = input('name:').strip()
    pwd = input('pwd：').strip()
) _0 r2 M  |- m, l% F5 X
    if name=='seven' and pwd=='123' :
        print('ok')
    else:
        print('error')
2 D% Y  u4 q* ~, W- k! V        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
count =1
6 e" y; G% J# b' Uwhile count<=3 :
7 W6 D* h) Q4 \# }8 W; `# `    name = input('name: ')
    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
    else :
( v* c7 t4 O/ y8 _; C& ?/ l& C        print('error')
3 B6 P9 v, r: ~( q  _* d" \        count+=1
for循环
0 c5 M* K" F* Y* X! }for count in range(3)  :
9 ~+ }2 i& [5 e" C. f. \: O    name = input('name: ')
8 S2 h' {/ u7 U) C5 {1 ?& u: B    pwd = input('pwd: ')
1 L8 x4 @+ n# k. M$ `    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
    else :
7 x4 D7 ]( n) V9 U        print('error')
        count+=111、写代码
% Y, E' R) [/ ya. 使用while循环实现输出2-3+4-5+6...+100 的和
count=2
num=0
4 k3 b$ _9 L& S$ cwhile count<=100 :
$ f' \4 m6 j2 U" |    if count % 2 ==0 :
% g6 a: {0 _2 N" s        num=count+num
        count+=1
    else:
# b# `1 y3 K0 E6 S9 V1 z2 Q  }# z- ]        num=num-count
5 t- j  b6 Q  Q, ^( f        count+=1
print(num)

b. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
2 u( l8 ^- ]$ x; \+ G num=0
+ z! q2 e+ B9 M4 X+ Bcount=1
for count in range(100) :
( S- O- p* O" ^& g3 ]9 J) `    if count % 2 == 0 :
. P  X- y+ q! f8 K' I- {        num=num - count
    else :
0 I& [' J% M8 a/ y5 e2 a; Q        num=num+count
+ O0 A3 Y6 {8 jprint(num)

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

count=1
# U6 |8 H* ^9 {; nwhile count < 13 :
6 X9 ^; @. w& O. ]4 W2 ]+ @- z& q    if count !=6 :
        if count !=10 :
            print(count)

    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
for i in range(101) :
    if i %2 != 0 :
  t! K5 ~0 r! z* c        print(i)

count=0
# S0 [* N  @) x8 U3 Cwhile count<100 :
* ~* u- \1 h7 f7 G    if count %2 != 0 :
        print(count)
    count += 1
) k# G! F* A5 w* z2 V5 K3 ?
e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
% Y+ E) N# V) A6 X: I    if i %2 == 0:
        print(i)
+ M# G, R6 x# n& L% u
count=0
while count<100 :
$ U' G; z% O7 t( c5 W    if count%2 == 0 :
        print(count)
/ b9 c# t6 s0 c- W- K: o+ u4 T0 O    count+=1
: d$ P: j/ @- {6 y
12、分别书写数字 5，10，32，7 的二进制表示
9 n# e/ s+ C5 h9 ^1 `" [
) j, O/ J3 l+ G& }" cprint(bin(5))二进制   0b101
- r/ Y$ v" \1 u& b8 L7 k# Jprint(hex(10))十六进制  0x5
print(oct(5))  八进制  0o5
14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

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

n1=5
; _6 t3 J+ ?; Zprint(int.bit_length(n1))  结果  3

8 p* }- }$ L* ]& G
! B; ]; _/ S) \( x2 E8 ]18、布尔值分别有什么?

False .Ture ,或1  和0

20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
a. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())
* a, h' b% z  l% D: j3 P! h. r) {
7 V0 t; v/ v  Ab. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
# r" Y  c  M/ ]8 _% ~$ bprint(name.startswith('al'))
c. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
1 C8 O: U, N' {+ H- Qd. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
( c% ^; t2 k: G; `9 B/ P4 Fprint(name.replace('l','p'))   apex  
e. 将 name 变量对应的值根据 “l” 分割，并输出结果。
print(name.split('e'))   ['al', 'x  ']  列表
  Z1 [$ N2 D% P/ a! {
2 ^* g3 N! c5 e. m7 u" B' xg. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])
2 ^; r. F( n  }* s6 k  Q
. b5 U7 W: S0 P. P% B1 e  c' Jj. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
1 j- f1 g. v6 ]% L7 j4 N$ U依赖索引
0 Y, I! ^) a- u$ b3 Xname = "Alex  "
for i in range(len(name)) :
    print(name)
for i in name:
$ I; r& L/ g& }. n, }9 b9 c2 q) B# t    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
6 {& Z1 O, C7 z" f5 U) d6 E& N8 _22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
print(li)
['alex', 'eric', 'rain', 'seven']
* {, J4 p5 @4 r: [( I5 O$ o+ Ec. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
5 E& C7 N" o3 ?. z! B. sprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
! ?. a# {& b! E) C+ ?print(li)
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
; |2 u2 S4 i# O; |, d* hli.pop(1)
( ~+ L& `3 m: v! b# u) j. U2 lprint(li)    ['alex', 'rain']
指名道姓的删除li = ['alex', 'eric', 'rain']
li.remove('alex')
print(li)
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
print(li.pop(1))
7 L5 |( c$ A9 }! B- w+ Iprint(li)
9 K2 u- R5 S0 M# |
5 Y8 h( ^# u$ ?: ~eric
9 Q/ W7 Y% r+ b; m['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
del li[1:]
/ t5 Y* x3 F4 S6 \, Z& ]7 e: ^2 hprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
1 V) y6 H+ r4 G: Ili = ['alex', 'eric', 'rain']
# a- I: N) h5 ^for k,v in enumerate(li,1):
6 u; J8 ]; t8 p* @; l    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
a. 请输出 “Kelly”
1 a  }" B/ c0 E2 O/ ]li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
print(li[2][1][1])
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
8 G/ {9 [7 @/ O7 d1 z6 cli[2][2]='ALL'
) g' T' K* ^! G1 @9 t# V. w/ B/ Eprint(li)
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
$ ?5 p$ \; P# I2 {a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
) z+ u$ L: t; F6 I, m, n+ m3 Y) Wprint(len(tu))
9 I# |8 [3 a4 U1 A  t+ Db. 获取元组的第 2 个元素，并输出
print(tu[1])
9 t( g! g$ e3 I; F9 s3 l$ Ve. 请使用 for、len、range 输出元组的索引
# {9 e2 s& `+ m0 R% u7 I. o* ufor i in range(len(tu)) :
    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
% r0 C# ^) m, sfor k,v in enumerate(tu,10) :
8 J+ z7 X# g4 v& k2 O; U    print(k,v)
10 alex
11 eric
12 rain
8 j7 {; t  X4 i2 f
, v2 X3 X- n/ {$ F8 gfor k in enumerate(tu,10) :
    print(k)
% r* U, N/ r: f& J(10, 'alex')
8 f9 `3 s5 u9 j6 p: X' t$ b(11, 'eric')
(12, 'rain')

; t) T, S2 D$ ]) u' ?
, ^3 B; B: f3 l( z' x25、有如下变量，请实现要求的功能
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

元组，不可以

3 l; {3 P0 N4 m2 g7 X% C- M2 y8 w% Id. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
& e$ d1 ^- f/ v. Gtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
res=tu[1][2]['k2'].append('seven')
4 Z/ @, C1 W6 y2 {7 y( b6 R
; f  @( e% B4 H; [7 Z! gprint(tu)
- B5 v8 ?- {1 W26、字典
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
7 r4 ~7 E7 `# J: J    print(i)b. 请循环输出所有的 value
for i in dic:
/ V/ }. i" I* `2 b5 O4 }    print(dic)
c. 请循环输出所有的 key 和 valuefor i in dic:
) v2 n% ^7 r: _9 r5 K0 sprint(i,dic)
! a+ H2 f8 z3 y) \6 s. V  A) Wd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
( E/ g8 m. E5 V4 I3 l# ]dic['k4']='v4'
print(dic)
4 R) o* I- o$ r5 M! @. Z$ {  Pe. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
dic['k1']='alex'
5 n' o" y' t2 m; u! \% wprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
dic['k3'].append(44)
print(dic)

6 Y0 w5 @5 M) g  ^4 wg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
dic['k3'].insert(0,44)
7 I, F  A& g3 s) w' [  N5 Mprint(dic)
! j  I6 [1 Y: N/ }* q& a  X; p27、转换
& A6 P- a2 Q: O% t0 ~/ l9 y' j4 ua. 将字符串 s = "alex" 转换成列表  s = "alex"

2 r9 j7 H: R6 H/ h+ n. k3 jprint(list(s))b. 将字符串 s = "alex" 转换成元祖
2 ]' D) N0 k# b; g: `0 s; ]s = "alex"
  y! S; x( ^7 k2 s, Aprint(tuple(s))

b. 将列表 li = ["alex", "seven"] 转换成元组
li = ["alex", "seven"]
- j; ~! M* J0 r/ Cprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
3 _& N0 Q, c, W8 [7 c  L- ttu = ('Alex', "seven")
li=list(tu)
print(li)


9 k  K4 f2 Z* W$ o* j: }d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增

1 q! p6 l6 A7 ?dic={}
2 g- I) {, ^8 w; M2 r! J1 Bfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
# F; L. S( P9 m+ m2 Y    dic[k]=v
; _+ O0 m+ f9 i( u$ M1 k' u    print(dic)27、转码n = "老男孩"
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
a=n.encode('utf-8')   
1 h2 B. A" j. F8 _7 E# Y6 E6 n3 |print(a)
b=a.decode('utf-8')
print(b)
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
print(a)
b=a.decode('gbk')
0 A4 N& c' P/ X4 ]" |$ Rprint(b)28、求 1-100 内的所有数的和
& G2 l, X' @1 g& e* Q# xcount=1
sum=0
for i in range(100) :
; ?+ }) }" t: ~( D2 q# p    sum=sum+count
. @$ Y- v; O) E$ s$ g; k9 u( _    count+=1
print(sum)
6 |5 i. ?5 d5 U% l0 `0 a
2 V, u2 X- u" _7 j9 i5 Ocount=1
2 M: h. Y  U! |* V6 m' m( ^- J" g! Usum=0
while count<=100 :
, X1 A0 r- N* F4 h8 e1 c    sum+=count
    count+=1
+ H0 U. Y. l/ k0 `  Hprint(sum)29、元素分类
1 Z* ~5 x$ m3 z7 {" C9 _有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
将小于 66 的值保存至第二个 key 的值中。
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
li=[11,22,33,44,55,66,77,88,99,90]
dic1={
    'max':[],
    'min':[]
}
) S4 o( M" u1 bfor i in li :
: \; f: I  a1 D# j- @    if i <66 :
        dic1['min'].append(i)
" T4 ]- {+ V0 k% s0 n: N' M, B    else:
        dic1['max'].append(i)
! c( p/ K. w9 I( Oprint(dic1)

$ o3 ?, k- p1 u* t% C5 t---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}