Python基础知识汇总

1.执行脚本的两种方式

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

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

2、简述位、字节的关系

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

' M" y  K9 r9 G) A. L3、简述 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 单行注释和多行注释分别用什么?

单行注释  #

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

8 K) C" e4 y1 ?% g7 _3 d6、声明变量注意事项有那些?

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

不能以Python的关键字命名，

能表明变量的意义

8、如何查看变量在内存中的地址?
, R9 n8 _8 D  a5 iz=1
print(id(z))
9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

10、写代码
a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
* O  ~6 s7 a2 j0 l! Iname=input('name:').strip()
9 q+ S2 i! D1 e$ ?pwd=input('pwd：').strip()
if name=='seven' and pwd=='123' :
5 Z& O; J; S  B* K) y    print('ok')
else:
! Y& o3 N$ a* b$ r- P& c- @    print('error')

% l! U7 z! D; Y6 @9 o, zb.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
count=1
4 V' ~& a4 x' J  F: h  L7 Qwhile count<=3 :
    name = input('name:').strip()
! Z" p+ q( Q  D1 a! H' R    pwd = input('pwd：').strip()

1 N5 F& f" E& P( A7 ~8 l# u+ r: G- R    if name=='seven' and pwd=='123' :
        print('ok')
    else:
8 K. z2 O1 M; r! `/ T6 ]! g& ?# |        print('error')
        count += 1
9 G7 n8 z5 _5 D& o  ]for循环：
for count in range(3) :
    name = input('name:').strip()
    pwd = input('pwd：').strip()

. n( n( t0 Y. o( ?    if name=='seven' and pwd=='123' :
6 n3 z4 L* t: z, b        print('ok')
    else:
2 e& y% Z0 s9 L/ j        print('error')
+ k0 F/ J" F" x9 O1 i2 C        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
count =1
while count<=3 :
    name = input('name: ')
. B* A; L+ W' ]    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
/ g0 B8 P" L: O. S        print('ok')
    else :
( V& F8 ?/ X+ u. B        print('error')
' s. y& y! T# t" e4 o        count+=1
for循环
for count in range(3)  :
- Y, Z) P4 f% j3 y- \$ z, e    name = input('name: ')
( u) e, S' I% l    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
    else :
% Q* Y, r/ K/ w. s% Z0 w        print('error')
        count+=111、写代码
a. 使用while循环实现输出2-3+4-5+6...+100 的和
count=2
6 a; ~1 ]- i9 \% S1 a3 bnum=0
' y/ l2 z0 [5 [# C# O; e+ qwhile count<=100 :
    if count % 2 ==0 :
        num=count+num
        count+=1
$ \+ \+ f+ H, m- e1 j7 C( Q    else:
        num=num-count
        count+=1
' t6 y, V+ A- Tprint(num)
7 Z$ W! T/ B. D9 `, k6 ?. f
b. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
num=0
count=1
* k& N* ]8 }' V; M+ efor count in range(100) :
    if count % 2 == 0 :
3 `. m  v& C4 ?9 \# f6 d1 t        num=num - count
    else :
# t. Y0 K  _+ B* V        num=num+count
print(num)

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

count=1
while count < 13 :
. A' `% P; k& W' W0 V6 N7 c% R/ k1 }! K    if count !=6 :
        if count !=10 :
, c4 H  O( W4 E            print(count)

, o) F  |. _! u( x( v5 d5 `' O    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
8 d. Z+ M- X9 r" K; K1 N9 zfor i in range(101) :
3 p- @& L3 T! P* ]4 S; y    if i %2 != 0 :
8 n' r: V! F2 R        print(i)
6 }; b. b8 x7 f, i5 U! B
8 B1 R/ \7 Z" Qcount=0
  D' T: Y$ e6 M8 Z& U' x5 ]3 K) Owhile count<100 :
    if count %2 != 0 :
+ G4 r; ]3 z+ G, }4 m        print(count)
2 D: h- J4 N% x+ \+ {    count += 1
# P* Y* M' h' e; i( t5 L; C$ _* V' f. ]
7 ^- v9 I( v3 m  P) g7 H9 N; ae. 使用 while 循环实现输出 1-100 内的所有偶数
6 W) |. P; c; a9 Z& rfor i in range(100) :
    if i %2 == 0:
        print(i)

count=0
0 \# O9 ?1 U; _! Fwhile count<100 :
/ a+ p# }: a2 U3 P% z- T  E. e7 M    if count%2 == 0 :
+ D8 I- n# v& _5 W2 |; ^- I        print(count)
! G8 e3 a1 {+ I    count+=1

" a$ K" N, X7 [12、分别书写数字 5，10，32，7 的二进制表示
: A5 b  I- B; }& f* q2 p
print(bin(5))二进制   0b101
0 _- q2 k3 E  E9 qprint(hex(10))十六进制  0x5
print(oct(5))  八进制  0o5
14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
0 f. c. y3 |  X# X3 @17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

n1=5
9 ^' H% U/ P9 a6 Q! mprint(int.bit_length(n1))  结果  3

: \% f$ [: m0 Q
18、布尔值分别有什么?

False .Ture ,或1  和0

6 y+ c; U, o" V# y# f# m20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
a. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())
% ^% \! K, O( c. s" t) u% e
: ^; Q) `: E! B/ J9 Db. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
+ t  D( V  u) [( E  A; W6 uprint(name.startswith('al'))
c. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
+ [: n2 ?4 t2 p# Rd. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
" n( o7 z8 ^9 k  j. Sprint(name.replace('l','p'))   apex  
0 y- @: m$ I9 ]5 q# a: b4 b6 ne. 将 name 变量对应的值根据 “l” 分割，并输出结果。
/ H; j7 {  w4 ?/ R* ?6 w( ^print(name.split('e'))   ['al', 'x  ']  列表
6 ]+ t0 o6 r' B- K9 N0 @* s
g. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])
2 i3 ?; e1 f7 \5 z
j. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
- ~+ \" f, L8 R21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
依赖索引
name = "Alex  "
9 p- i& ^* W7 A0 R/ Z8 Jfor i in range(len(name)) :
    print(name)
1 w# j, e5 U$ l9 H1 A" ?* kfor i in name:
; ^6 c, c. F: E' n1 V% v    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
' c2 l! B- z9 e4 M4 D22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
print(li)
* K( [) w+ h% @* k ['alex', 'eric', 'rain', 'seven']
0 R/ \- s! L  f. ~0 Fc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
; U3 c5 q8 h% B5 R( Hprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
; m6 n1 V, }! kprint(li)
" {3 f9 K- g+ D" t/ X/ O" ~" q$ @. h0 De. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
li.pop(1)
print(li)    ['alex', 'rain']
3 b1 K1 I6 P9 a指名道姓的删除li = ['alex', 'eric', 'rain']
li.remove('alex')
print(li)
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
# C( C$ _+ l, B4 ^8 G! Yprint(li.pop(1))
' G. }3 B, n  e( _print(li)

' \8 g( S: ?( X# X" \8 f! Zeric
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
: C: a; `; p3 k0 o8 x% Ndel li[1:]
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
7 I" T  m* F& z+ n0 C, D9 Vli = ['alex', 'eric', 'rain']
for k,v in enumerate(li,1):
    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
a. 请输出 “Kelly”
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
print(li[2][1][1])
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
li[2][2]='ALL'
8 O# Z5 I! v. O% m+ Pprint(li)
0 t+ C$ r6 x& F% N8 z8 f8 ?24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
# ]! a" Z% g  U$ x$ f. Q  T& F* wa. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
print(len(tu))
b. 获取元组的第 2 个元素，并输出
4 d+ Z6 Q- S6 q, }5 ^! g' bprint(tu[1])
! }8 d+ B/ d2 G# se. 请使用 for、len、range 输出元组的索引
for i in range(len(tu)) :
) y/ T0 r/ V' G" p9 [    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
for k,v in enumerate(tu,10) :
: F0 \7 J" R+ n    print(k,v)
. v% o4 p3 p- A2 }, m# J10 alex
7 F, M3 t1 Q/ l! ]  s11 eric
! ?% I  ?+ P2 v, X" O7 H12 rain

9 T; c" @0 y( i- ^+ N" Wfor k in enumerate(tu,10) :
    print(k)
4 [0 K) R0 l; _" D% a/ Z9 f2 m% W(10, 'alex')
(11, 'eric')
( t) X2 s4 L( u* e; k2 u1 P(12, 'rain')
8 c* g+ ]2 W7 W
! C6 Y. e! R  e9 Q/ I  w: Q
25、有如下变量，请实现要求的功能
/ k8 A. t8 H9 M4 z, dtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

元组，不可以

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

& `0 R, B5 i- j( Cprint(tu)
3 p2 _, a$ V) f* N1 X. m. G26、字典
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
* t3 U2 u* H. H7 t    print(i)b. 请循环输出所有的 value
! |% G5 \# W* t4 Bfor i in dic:
    print(dic)
c. 请循环输出所有的 key 和 valuefor i in dic:
. @9 s7 Q5 j! k! Lprint(i,dic)
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
dic['k4']='v4'
print(dic)
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
+ Z2 d! E. z& Y0 r4 pdic['k1']='alex'
/ q/ j! S$ q: Q3 Eprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
dic['k3'].append(44)
! s# I; Y) {7 {3 _8 J4 y; \print(dic)
2 f1 }" I9 n& E# V4 C
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
dic['k3'].insert(0,44)
print(dic)
% S) j0 K# t  D+ A: q6 H27、转换
a. 将字符串 s = "alex" 转换成列表  s = "alex"
' U2 u% X" o, v" U8 ^6 ~
print(list(s))b. 将字符串 s = "alex" 转换成元祖
$ b0 ?  w' |, z$ U! k: Ms = "alex"
print(tuple(s))
3 G8 h1 ~  s8 s- a3 y8 X$ g% G
# h' G/ S$ @2 Z. W* M7 fb. 将列表 li = ["alex", "seven"] 转换成元组
li = ["alex", "seven"]
: P9 s/ v* B, m* Qprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
tu = ('Alex', "seven")
  H9 Y1 b( L9 R8 q7 Y1 xli=list(tu)
print(li)


' i5 t9 z! n5 ?6 b6 [d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
% o' f" d& H+ Q* A. P
dic={}
( L1 G" t7 W( E6 h" ~, rfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
3 V! a  f" }4 x; I# D1 ?    dic[k]=v
7 w; B: p+ ?+ g0 B* B4 L    print(dic)27、转码n = "老男孩"
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
a=n.encode('utf-8')   
+ z3 Q9 r4 `+ a) ]. `% f4 uprint(a)
" c! e* D1 \/ O- \' [* r) Hb=a.decode('utf-8')
print(b)
3 c) y8 v# O: |  O- w, x$ Ub. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
# g, p% u2 E8 c# qprint(a)
b=a.decode('gbk')
print(b)28、求 1-100 内的所有数的和
; I4 Q8 z* n! p4 s, @5 Ecount=1
sum=0
for i in range(100) :
. J% V9 y1 K! r' j+ |7 B; e5 N& e) F    sum=sum+count
    count+=1
+ a! `7 y* X. b  H+ ~print(sum)
/ K- b. p# O% |2 p. y
1 ^0 Q) V8 D5 l+ a- u$ }; L' Lcount=1
/ N( P5 T5 v/ Z  o0 Rsum=0
# Y- c6 K& L+ t9 {" x: H+ A; Zwhile count<=100 :
    sum+=count
5 K4 t, p4 F: o/ J: p1 E7 G    count+=1
' A. ?5 {) J0 m% j  v: h* tprint(sum)29、元素分类
9 E- c! x$ u# W有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
将小于 66 的值保存至第二个 key 的值中。
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
. t) e) M$ y0 m1 Bli=[11,22,33,44,55,66,77,88,99,90]
dic1={
9 e0 |9 @6 t9 b+ N    'max':[],
8 J% L; H; `) E$ C  d    'min':[]
}
for i in li :
" y$ y& s- X' H2 B9 p    if i <66 :
        dic1['min'].append(i)
% b- E- ?+ N: B' h/ b    else:
        dic1['max'].append(i)
+ s/ {% q) F7 z2 w' ~8 a8 iprint(dic1)

---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
; ], T- P6 r/ Q" X