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

单行注释  #

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

6、声明变量注意事项有那些?

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

不能以Python的关键字命名，

能表明变量的意义

8、如何查看变量在内存中的地址?
z=1
. y, ?' ~. n# j5 D5 I9 |print(id(z))
9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

10、写代码
8 k, [$ E3 u! v4 G: x9 \a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
name=input('name:').strip()
, P5 w% E, I$ j+ y' o: hpwd=input('pwd：').strip()
/ z6 X# C2 N0 S0 t& ?! ^if name=='seven' and pwd=='123' :
    print('ok')
2 y. L' p+ f0 Q5 f8 b& e/ T/ e; Uelse:
    print('error')
6 a4 Z/ p0 c" W5 b# l# A* Q
b.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
count=1
while count<=3 :
: O. l* [4 @" N* y# S    name = input('name:').strip()
    pwd = input('pwd：').strip()
7 z& O/ _7 t" c; d7 t
    if name=='seven' and pwd=='123' :
8 |, G! V; A/ Y0 |0 }7 @  _        print('ok')
5 n+ c8 u: j+ r( Q$ {    else:
        print('error')
        count += 1
: ^* g9 T8 y* i3 D% Qfor循环：
0 r) Y! G: G  w3 @+ ~for count in range(3) :
    name = input('name:').strip()
- o8 v) D2 c( V8 a  m2 L8 k    pwd = input('pwd：').strip()

/ ~3 \* E: r: E; m' u4 \5 L1 c# I$ P    if name=='seven' and pwd=='123' :
& Q1 y6 N* S: _6 N& y3 `5 F' y# U9 j        print('ok')
/ h0 N: d" L& V$ v- t( f    else:
        print('error')
        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
- h: w7 W% T- c( S) n% Ucount =1
4 J7 i2 {+ m7 P1 Ywhile count<=3 :
- r+ X4 G  w# h# E- [    name = input('name: ')
    pwd = input('pwd: ')
% ^: J& Q" W) R0 Q# h    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
9 t, F* K' V' N# ]9 f7 |        print('ok')
    else :
5 Z* ]6 [2 _* i+ w' o" M. E        print('error')
        count+=1
for循环
for count in range(3)  :
    name = input('name: ')
; f5 F( [' P- Y2 X    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
" |4 U) R; C0 I2 R$ h# m    else :
        print('error')
        count+=111、写代码
a. 使用while循环实现输出2-3+4-5+6...+100 的和
2 d. A$ Z6 s. p  Q, u. o- x* O0 j) Tcount=2
num=0
6 x! e8 W" e% E/ vwhile count<=100 :
* v/ |% D% @+ Z# [* A    if count % 2 ==0 :
        num=count+num
        count+=1
    else:
5 r0 Q$ u4 a% U. `& j, N        num=num-count
        count+=1
% ]: r+ U% Q) e4 J2 O" {' _print(num)
; s. \+ H- m/ y8 [- e+ {
* T% x& s" M8 x$ K( }1 `# H  ~b. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
num=0
+ X/ M: ^1 R" m6 Zcount=1
0 V& {9 @8 f' b8 \6 H7 |4 Yfor count in range(100) :
3 Z5 J1 w8 e$ C& ]) h0 @9 \/ e9 b+ c    if count % 2 == 0 :
9 \5 M; M1 x2 y) x        num=num - count
    else :
. S7 \# ^6 \' [8 Q        num=num+count
: t* P+ [, W) l+ Q& qprint(num)

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

$ E: A. x' D0 E( wcount=1
5 e% y. K1 t4 S3 S4 C; Q* S7 {while count < 13 :
    if count !=6 :
  G  E' o+ }7 F" o1 i3 ~        if count !=10 :
            print(count)

    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
" ^% ]* ]1 B+ H" z3 x% Tfor i in range(101) :
    if i %2 != 0 :
        print(i)
1 p7 x# [/ n( S- |% F+ u
! j' Q. g; E; Acount=0
# N7 s$ V& A4 v& \. A1 j9 Mwhile count<100 :
    if count %2 != 0 :
        print(count)
* y; I; o$ Y- M1 X    count += 1

6 u2 o1 l4 m; ^5 Y& Ke. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
, j- m" x, I# q# u! O* U* {, n    if i %2 == 0:
        print(i)
1 T5 k! z) F5 I1 Q3 X- b8 C
( j' X' r, A  k! R) lcount=0
while count<100 :
2 i  B- l7 ~3 y8 S! Z0 y9 g    if count%2 == 0 :
& C# x- o3 ^5 P1 e& Q5 {& j        print(count)
& M$ [/ V  \! d% D' ^. p( \& H8 t    count+=1

+ g' N( n# V3 j) `% f4 j7 O12、分别书写数字 5，10，32，7 的二进制表示
) @8 L6 t' @) z, P
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.指向同一个内存地址，
/ t- r. v7 h: r* V17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

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

& F. Y, @  d5 O) r  i
18、布尔值分别有什么?

False .Ture ,或1  和0

20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
a. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())
0 q. u) Y% o6 [2 r6 J# E8 i
) s4 P- T# Z; z5 H2 L* P/ Q/ N% A3 eb. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
, v& {3 O8 l- S. Z: bprint(name.startswith('al'))
) y% Y7 @  x$ bc. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
+ F) v' x5 D* S3 ld. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
print(name.replace('l','p'))   apex  
5 T( m7 f# r: X1 ke. 将 name 变量对应的值根据 “l” 分割，并输出结果。
6 j" H# p+ ?- R6 ]print(name.split('e'))   ['al', 'x  ']  列表

/ p8 e. b5 c+ I" ?7 t/ B4 \g. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])

0 _! W, ^% d  k. I2 H2 zj. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
1 u, F8 k. U$ L7 o3 p依赖索引
& f2 N8 B; T8 z8 Tname = "Alex  "
) T# p0 ]9 B$ _# Ffor i in range(len(name)) :
    print(name)
for i in name:
    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
$ l( ~% c& A' f  \" d4 q22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
print(li)
['alex', 'eric', 'rain', 'seven']
3 S2 W9 v7 g9 M* L& g- x& bc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
3 [% X( O! `9 Hprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
" ]3 H) W4 g: S: ~print(li)
- g) F) Q% c3 Q& s: q4 _; ne. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
li.pop(1)
print(li)    ['alex', 'rain']
指名道姓的删除li = ['alex', 'eric', 'rain']
li.remove('alex')
. s" b1 J# G2 K- vprint(li)
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
print(li.pop(1))
0 M% b6 n; ~, t: L/ P2 E  Mprint(li)
6 J& Z" W& A* Y+ m% k; v9 U1 F
eric
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
, Z& g9 h! u4 udel li[1:]
! i/ M/ q" l4 Mprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
% A' q* T+ i! C4 A# @7 j2 u8 sli = ['alex', 'eric', 'rain']
. s$ b! Z3 s0 G" q" p/ xfor k,v in enumerate(li,1):
3 W0 P6 O- `3 @  i1 O: j* h' K2 r    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
# R. @5 W1 v) s* t4 Qa. 请输出 “Kelly”
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
print(li[2][1][1])
: j6 n3 I/ V, p! M+ ^: @+ [4 _3 T$ e# qb. 请使用索引找到 'all' 元素并将其修改为 “ALL”
: R1 N$ c. F9 ~) {) X* Nli[2][2]='ALL'
" w# U5 @8 k: S3 S8 Jprint(li)
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
. Q) L+ o# f4 e/ ya. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
% M4 U; S) X* ~3 ]! T' @/ Wprint(len(tu))
; j0 o! W, G1 O5 _8 Yb. 获取元组的第 2 个元素，并输出
print(tu[1])
e. 请使用 for、len、range 输出元组的索引
6 Z# k% B3 w& S; r+ g: s" ^for i in range(len(tu)) :
( o* _! K/ E: N) M5 h    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
for k,v in enumerate(tu,10) :
    print(k,v)
0 z$ X4 _0 Z+ {$ G10 alex
% |. ~8 }$ K: k3 X; e: z11 eric
- p- j. q1 o( k0 S6 U& n# R12 rain
/ w- a) ?, t1 B
for k in enumerate(tu,10) :
/ m" ^- E1 Z. j9 n9 P: P0 y    print(k)
(10, 'alex')
/ O0 ~" |% B% ]# L; ]: F. V6 P(11, 'eric')
/ I: _, @. e' Z$ j2 S2 x(12, 'rain')

/ F" v* H' t9 G( N2 X8 x
25、有如下变量，请实现要求的功能
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

元组，不可以

d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
4 U, d  z, D7 D4 u2 qtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
+ f" D% {9 u4 Z. C/ P; @res=tu[1][2]['k2'].append('seven')

" m* ?0 U5 j5 t+ [; s' b, wprint(tu)
* d) `9 A% [" X* [26、字典
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
- D: g3 X$ w( U4 `; Q    print(i)b. 请循环输出所有的 value
2 N' t1 ?8 }! l" C+ ~% t- v! t% S4 bfor i in dic:
! @/ q0 v0 }& N2 J& ^$ j( H% O    print(dic)
c. 请循环输出所有的 key 和 valuefor i in dic:
print(i,dic)
  }6 F1 }& {( N! u8 ]7 v2 T  }d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
: B- t% S! @( z, qdic['k4']='v4'
print(dic)
2 f1 V, `. i0 je. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
2 D+ M" [" b7 f# X9 tdic['k1']='alex'
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
7 z. S9 U8 ^! X) D: A  Odic['k3'].append(44)
: q) h: [# r! _) h' Nprint(dic)
) G, Y. p% v1 b* m( [
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
dic['k3'].insert(0,44)
- ?) q3 d" v+ y+ Y2 v; @3 uprint(dic)
27、转换
a. 将字符串 s = "alex" 转换成列表  s = "alex"
) M: \; ^: E" S. t- c7 J+ Z' }( R
( p4 H+ c% c* Tprint(list(s))b. 将字符串 s = "alex" 转换成元祖
4 D/ A/ f. i0 A0 l8 E- I2 |) Ss = "alex"
print(tuple(s))

3 A+ Y0 y  b% `* A# ob. 将列表 li = ["alex", "seven"] 转换成元组
li = ["alex", "seven"]
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
. p5 s- \0 T% V+ c& `: ytu = ('Alex', "seven")
4 R- r1 U: y1 P0 x; i+ W$ B6 Z  ]li=list(tu)
print(li)
) J! J) R/ T9 O
6 r) ?6 I3 m% h) P( m
$ k9 l7 M) ?% r5 K9 F" X( }& Qd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增

dic={}
) M( ^+ ?! o2 H* q9 q1 xfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
    dic[k]=v
    print(dic)27、转码n = "老男孩"
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
; U7 F+ B. I1 F/ ~. Z1 q& qa=n.encode('utf-8')   
, |  a( X* `) ]  Z! qprint(a)
b=a.decode('utf-8')
print(b)
: F; j5 k  z- e. Y& C( F: ab. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
print(a)
b=a.decode('gbk')
. w! G, G' G- E& {* S/ Qprint(b)28、求 1-100 内的所有数的和
count=1
# p" A7 u; R. o. C% P# M0 Lsum=0
for i in range(100) :
    sum=sum+count
    count+=1
/ `, b6 ~9 a( Z) uprint(sum)

" z4 \  x1 q7 h8 c0 d4 tcount=1
9 {( X% N: @' i. [; M2 Rsum=0
while count<=100 :
( }, j; n2 d4 ~" a: r. _0 N    sum+=count
    count+=1
1 F8 I- P, G. d5 J5 F" pprint(sum)29、元素分类
5 a6 g2 _9 p# ~2 p  H6 \6 F有如下值集合 [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={
9 k$ N0 ]& t- T( o+ \& _    'max':[],
    'min':[]
}
for i in li :
$ f9 P  h1 F4 u; I    if i <66 :
        dic1['min'].append(i)
    else:
! e- ~( @. D. b$ Y        dic1['max'].append(i)
* {& o. S5 O. J: bprint(dic1)

6 G; g3 X4 E7 I7 ^2 S---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
) d; D$ M- t/ I9 H