Python基础知识汇总

1.执行脚本的两种方式

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

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

2、简述位、字节的关系

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

& o+ B" @& t! S; e1 \5 r0 U# d0 S3、简述 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个字节代表一个字符，

0 ^1 r2 |; u6 d/ P4、请写出 “李杰” 分别用 utf-8 和 gbk 编码所占的位数

utf-8    是3 bytes=24bit

gbk     是2bytes=16bit

5、Pyhton 单行注释和多行注释分别用什么?

单行注释  #

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

6 l0 s; C: Z9 \/ }% C4 _4 d1 B5 t6、声明变量注意事项有那些?

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

不能以Python的关键字命名，

能表明变量的意义

8、如何查看变量在内存中的地址?
z=1
) t' @& \2 |' ^9 A3 ~/ W! i9 Yprint(id(z))
9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

10、写代码
a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
* }; t5 K8 E# H1 R0 `# ]4 x  nname=input('name:').strip()
pwd=input('pwd：').strip()
& c1 c* X& s1 I$ f4 t( t( sif name=='seven' and pwd=='123' :
    print('ok')
1 x; z) M. L/ t/ G3 D& o) nelse:
    print('error')
0 Q4 [/ K0 }! @) J' y2 M& a: t
b.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
count=1
while count<=3 :
    name = input('name:').strip()
- h" }& Y, q4 J: N    pwd = input('pwd：').strip()
( W( X8 z) G9 W2 A8 t
    if name=='seven' and pwd=='123' :
        print('ok')
! j$ h" c  c2 J    else:
! b- S6 W2 G% [: h% x1 [: B, B2 e        print('error')
        count += 1
1 s/ q- L6 n7 s& @for循环：
( ]1 X' Z. ~; C8 H3 K8 W. ~for count in range(3) :
7 b/ K, ~% [4 o7 w9 _* {/ ?. l    name = input('name:').strip()
% O$ l( n" A- x, U1 D    pwd = input('pwd：').strip()

    if name=='seven' and pwd=='123' :
        print('ok')
    else:
        print('error')
! p+ G  E& m9 r$ ~+ p) @% W) M7 z        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
+ [3 \; c' F2 e) o! s# \* M' ?count =1
while count<=3 :
    name = input('name: ')
    pwd = input('pwd: ')
" Q4 e2 A# v8 G    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
    else :
        print('error')
' p2 F& H, h4 v$ [" E8 N        count+=1
7 r3 B8 b9 N$ k! hfor循环
for count in range(3)  :
    name = input('name: ')
    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
* [$ L* H3 H* Q    else :
! G( E, Z1 I. U# o: f9 z        print('error')
        count+=111、写代码
a. 使用while循环实现输出2-3+4-5+6...+100 的和
9 b) s, n4 y- _7 gcount=2
: J$ z# m" t; ]  |num=0
: V& Y% c* a1 ?6 \while count<=100 :
: d$ H. f) a) [% y2 d    if count % 2 ==0 :
5 j7 `% F/ H: K# p, {7 u        num=count+num
        count+=1
, o# O& s8 p& G7 t' d1 C5 s    else:
2 }& C  _& o/ o- |8 |% T4 E        num=num-count
        count+=1
print(num)

8 b, t# @! E4 ob. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
: Y1 }& [: E' V& ~7 w1 k$ ^, ` num=0
6 y: p8 K( u2 B) a! Z' K# a+ p1 Acount=1
for count in range(100) :
    if count % 2 == 0 :
' I+ R$ }! n, [& o6 w: x        num=num - count
* l* R  U! D: c7 ^' H: H9 a$ X  F    else :
! l5 K" o1 D9 ~  S1 O3 A4 y# [4 c4 o6 d        num=num+count
1 D2 O" ~' _5 J( I& S" A& Tprint(num)

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

count=1
6 I* D9 A# P# {) fwhile count < 13 :
3 S2 ^$ l) F# y2 f1 \    if count !=6 :
        if count !=10 :
, e9 A# T0 r  C2 D" w            print(count)

    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
for i in range(101) :
    if i %2 != 0 :
3 C6 k% K$ }! a/ T( S" Z        print(i)

) O3 {9 O" p/ Gcount=0
while count<100 :
    if count %2 != 0 :
        print(count)
$ _# [; x2 Y  {  x: ^! F) [    count += 1

$ @# M# W1 T- N* |2 ?+ Ze. 使用 while 循环实现输出 1-100 内的所有偶数
- p% d6 Q3 F2 `; L1 b/ m8 z9 Bfor i in range(100) :
2 }" @# @# R- R  s  Q9 X5 }    if i %2 == 0:
4 O8 z6 O* P6 O; }4 ~- f& l2 z) I        print(i)
. J' `5 q9 o% L0 I% {3 u: j8 n
count=0
; \5 \" D; G1 i7 M  l& V% {, kwhile count<100 :
; B8 ]! K: I! p& _7 L    if count%2 == 0 :
        print(count)
7 B1 g- p3 r0 I; k7 G4 N    count+=1
/ q8 a9 r8 E: M9 o/ p6 E
4 k! C; `6 d6 @4 i  A% a! O" x12、分别书写数字 5，10，32，7 的二进制表示

( _; j: Y$ e/ P0 eprint(bin(5))二进制   0b101
+ }; p; K/ {( {) ?print(hex(10))十六进制  0x5
+ \' D9 k" G* I5 o# x" p4 Yprint(oct(5))  八进制  0o5
14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

8 E/ N  r+ C" K9 ~0 E3 @* c: G$ d  }16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

n1=5
7 C) ^4 r: N5 b3 |+ L3 cprint(int.bit_length(n1))  结果  3

- b+ R) s9 y# s7 ^  g: w' Q; h
0 ^5 y) y+ q: k% H7 p1 B18、布尔值分别有什么?

False .Ture ,或1  和0

3 b5 G& b; ?! ~& v20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
  Z$ A# S' J) t8 Z. Y& ka. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())

b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
print(name.startswith('al'))
c. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
d. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
( o$ B3 @& y+ t+ P1 c2 O) v" f; B' q' |print(name.replace('l','p'))   apex  
8 t  x3 ^( e2 g% Ze. 将 name 变量对应的值根据 “l” 分割，并输出结果。
: M; f' _0 m3 p1 r/ gprint(name.split('e'))   ['al', 'x  ']  列表

0 g% j* E  q% H0 G  Zg. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])
" s# n4 x! c# \2 m' Y1 f
( t8 j; ^! C& o$ u3 {j. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
& `' h: Y' j( W" G2 `5 o  `- x: O21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
依赖索引
' ?8 b( a- L" j( X) Sname = "Alex  "
) G- {! H5 k8 d$ Q, N9 y$ S/ ~for i in range(len(name)) :
    print(name)
for i in name:
/ J" b. m3 {7 P6 Z: R    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
1 P3 _, ?: c4 m) O9 q; c8 k4 o, W22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
5 h; o/ Y/ ]5 T+ {& A; B: o9 B8 T& {print(li)
- {# x0 k' |) g9 A0 J2 q2 t+ ] ['alex', 'eric', 'rain', 'seven']
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
print(li)
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
1 N/ G# G& B2 O3 I0 Q7 Q  v0 d- _li.pop(1)
print(li)    ['alex', 'rain']
指名道姓的删除li = ['alex', 'eric', 'rain']
! F7 l3 _4 B1 s8 w; U9 I. ili.remove('alex')
print(li)
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
print(li.pop(1))
7 H$ ]7 L$ u% \print(li)
' C  j* y  k7 ~6 a) V/ i' U
eric
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
: l: m  H. q4 {. w8 b, K4 i  ?. W7 qdel li[1:]
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
1 V5 E) n% b# S) q3 M2 l- Fli = ['alex', 'eric', 'rain']
& Q2 C! \$ [/ T. h0 @for k,v in enumerate(li,1):
7 L! E: J$ H/ ?' O. N    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
a. 请输出 “Kelly”
7 P, @7 ]5 S1 sli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
& u' h; E* c  ^2 i% F+ |; Lprint(li[2][1][1])
& P3 V8 v' a4 ~7 lb. 请使用索引找到 'all' 元素并将其修改为 “ALL”
, J. p( q6 u9 g8 q! M. r! jli[2][2]='ALL'
print(li)
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
3 X/ j0 r) d5 J: `' f, p, s; X3 oa. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
9 h# K! r* V0 V% j1 @& Qprint(len(tu))
b. 获取元组的第 2 个元素，并输出
" K" W) E9 J# G0 h( \  E5 ~# V; Cprint(tu[1])
4 u# m; l) B4 U$ ]9 Fe. 请使用 for、len、range 输出元组的索引
# J8 I/ F" k$ F. |for i in range(len(tu)) :
    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
for k,v in enumerate(tu,10) :
/ \" F3 F" s+ M- F; {    print(k,v)
10 alex
11 eric
' m4 {4 P: v6 `0 I1 d  b: s% \9 q12 rain

for k in enumerate(tu,10) :
    print(k)
. G* i7 ]/ I3 `: O* n' {(10, 'alex')
0 O- }$ L# ~+ {4 ^6 D(11, 'eric')
9 D; F/ R+ g, c" J& ^5 }/ t+ E(12, 'rain')


3 v3 I! |2 b- m25、有如下变量，请实现要求的功能
  a: G4 K. L1 Htu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

元组，不可以

, V; `* b' z; D1 Ad. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
" e" G+ q$ M) B! O% ~6 w* Vtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
res=tu[1][2]['k2'].append('seven')
2 N2 U& _# j3 {
+ f- H  F" s. {$ U9 Bprint(tu)
. \- P8 N' A1 N. t. ^- v' K0 m26、字典
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
% s6 \% @; j3 J- C: X1 O9 c# ~    print(i)b. 请循环输出所有的 value
3 S  c! I) _8 F( {% `$ Wfor i in dic:
    print(dic)
0 B( J/ c. T  L% t  Yc. 请循环输出所有的 key 和 valuefor i in dic:
2 T9 }% ]' ?, R% u6 V. `6 v1 Mprint(i,dic)
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
dic['k4']='v4'
print(dic)
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
! G5 a2 E& J/ ?9 R2 P9 Gdic['k1']='alex'
, L/ |& t" M) s' Z- b. a: [! hprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
dic['k3'].append(44)
print(dic)
$ G6 H! c& Q9 W( I9 p
  G5 o7 I! s! ]g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
dic['k3'].insert(0,44)
( e% N( Z7 C6 j6 s2 |/ H0 rprint(dic)
& B0 B" i- s  Y; Q! g5 V0 K7 l0 \27、转换
: w, K+ Q7 K4 t8 j2 }a. 将字符串 s = "alex" 转换成列表  s = "alex"
# z! F( S" e, s' B
+ F" _- }- N, @print(list(s))b. 将字符串 s = "alex" 转换成元祖
+ I. a  _6 T. f  N; as = "alex"
6 \# D* v3 n$ h$ U5 lprint(tuple(s))
9 Z3 x  L  [; w2 Q. P6 _. j" U) P
b. 将列表 li = ["alex", "seven"] 转换成元组
li = ["alex", "seven"]
2 d9 Q& w! F" {; P6 Fprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
  R* P7 @. V& [- O. K+ e" X) {tu = ('Alex', "seven")
li=list(tu)
print(li)
% U3 P8 ~5 ?2 a; {5 u: D
: W% s" ~. n+ j" d5 E$ f; H2 U
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增

dic={}
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
    dic[k]=v
    print(dic)27、转码n = "老男孩"
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
. E6 J" ^5 M7 B8 e; |* xa=n.encode('utf-8')   
# B8 N+ k* F& l+ O8 ]( z4 V4 Dprint(a)
b=a.decode('utf-8')
print(b)
- E, W! @9 `& [' b. k) Xb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
  W$ J) ^8 W# l% c- @* f, Oprint(a)
; t6 L1 i0 a2 Y3 q2 Ib=a.decode('gbk')
print(b)28、求 1-100 内的所有数的和
count=1
) k% y+ m) ?$ N6 hsum=0
for i in range(100) :
    sum=sum+count
    count+=1
print(sum)
/ I# b9 y( i* Z
! [4 z+ a& L+ {count=1
/ a. L# ^' a/ P& T2 n5 D, @sum=0
' ]3 W4 m. n0 T/ b' d) A# wwhile count<=100 :
+ O8 {' J) ?4 c7 M# n    sum+=count
    count+=1
print(sum)29、元素分类
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
& d% _# c; l% n6 b" g将小于 66 的值保存至第二个 key 的值中。
+ b* n2 q1 E5 Q3 P& O' G6 |4 u即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
li=[11,22,33,44,55,66,77,88,99,90]
3 E. \$ d. R1 n. |dic1={
# Y5 h! u. g) C# ]2 |  E; @/ V    'max':[],
% `1 H7 N2 q5 V& Z' O7 T6 N    'min':[]
}
( h* z1 F4 O) A2 rfor i in li :
3 U% h2 X1 Q% H; {# }9 q4 J" Z9 O    if i <66 :
        dic1['min'].append(i)
; [8 k- D3 E) g2 T! w6 z    else:
        dic1['max'].append(i)
. r! U5 m1 L' x" V4 Mprint(dic1)
$ J$ `+ ~& \9 L7 C% S
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}