Python基础知识汇总

1.执行脚本的两种方式

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

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

2、简述位、字节的关系

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

! t# t9 u& U5 m  e4 }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 M1 ?% X2 j: l! f6、声明变量注意事项有那些?

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

不能以Python的关键字命名，

能表明变量的意义

8、如何查看变量在内存中的地址?
$ {8 c$ W/ S/ Q: @7 ~" F' N, Sz=1
print(id(z))
9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

10、写代码
( `* {1 i3 `/ D2 ~+ W3 k7 Za.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
name=input('name:').strip()
pwd=input('pwd：').strip()
if name=='seven' and pwd=='123' :
1 U) a# F6 M, k" f! A    print('ok')
else:
    print('error')
+ e& J" Q5 R4 G2 ^
b.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
, {% U7 e# O% ?4 G  t. R8 ^count=1
8 a1 F2 F5 h5 S; Jwhile count<=3 :
5 \& P) f# z0 f- V; c5 [    name = input('name:').strip()
6 }5 |. F; d* ^# k1 u3 x) Q    pwd = input('pwd：').strip()
* H2 S, o! O' C
    if name=='seven' and pwd=='123' :
2 L: v' f+ c6 G( K8 H+ g        print('ok')
  n! ]( }* P. d: {! Z$ d    else:
        print('error')
        count += 1
5 p& u9 H  ~9 y, ^% Mfor循环：
& L; E; X0 v# D! tfor count in range(3) :
4 m1 W3 b  V. R    name = input('name:').strip()
, ^$ a$ ~  A( k, n& S9 g% S    pwd = input('pwd：').strip()
4 D7 R" u8 p# }3 l' B3 B
& Q. I+ n% p% A9 L# I: ?# N9 e    if name=='seven' and pwd=='123' :
8 S5 m1 u6 Y5 ~4 e. T1 S' N- k' N        print('ok')
    else:
1 e5 V) R, u' U: l: |& _        print('error')
& ]% }. \5 V  V: V$ S: E        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
count =1
while count<=3 :
    name = input('name: ')
    pwd = input('pwd: ')
0 `! X! o5 ^4 a/ ]    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
5 d4 I8 ?  T. A2 j, {) \' A        print('ok')
$ r5 H6 a( a2 H, h    else :
% {: f0 Q9 a1 [/ y2 E2 K; ^$ g        print('error')
7 w) f7 T6 E, M: P% k8 h        count+=1
for循环
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')
; y4 Z4 I+ \5 ~) G8 i' X    else :
+ N3 K/ g0 h# j& ]" F        print('error')
5 L! Q( l" S  U2 [9 S. s. f/ M! Q3 J        count+=111、写代码
0 Z4 X; e3 X: L6 H/ Xa. 使用while循环实现输出2-3+4-5+6...+100 的和
count=2
# f* [# A. o0 d6 |* _1 I$ r; cnum=0
while count<=100 :
    if count % 2 ==0 :
2 m" \- R, F" q: D        num=count+num
        count+=1
    else:
6 [5 s& x; z* I  l$ J        num=num-count
5 ~6 ?( \* X6 o* }. e# g" d4 J8 y        count+=1
. \$ g3 `7 K' E/ }8 |print(num)
! U# ?" s+ [2 h1 Z8 A1 A
* N; v# e- f  c1 Tb. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
. P9 ~  h4 e; G8 H4 @  U* Y6 r8 w; [ num=0
6 [: x2 ?' W! T) m. Z4 u9 ocount=1
6 S% m$ A( P+ G+ cfor count in range(100) :
3 }9 m; J3 K. ~, g, f, F9 \    if count % 2 == 0 :
        num=num - count
    else :
0 ~/ h$ z0 l5 I5 p7 z0 C        num=num+count
0 x% s; L" Y5 d9 f2 ^6 t4 Sprint(num)

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

4 A: @% Z4 M/ m/ bcount=1
% Y; [0 B) X2 q2 D8 }0 F1 ?" ewhile count < 13 :
/ U4 T7 h. t4 P9 O+ p; _    if count !=6 :
        if count !=10 :
- U) l' W+ n: L/ P            print(count)

    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
' ^7 h9 \. K- U$ P- S! q1 ofor i in range(101) :
6 O* j7 C& b0 y0 j' E& \    if i %2 != 0 :
        print(i)
. }6 F& I" ]& ~% ~0 m. P% f
$ t8 Y( N* X' l/ [8 f0 {+ ycount=0
while count<100 :
( \$ x  t* C/ B8 M% _9 q5 V( i    if count %2 != 0 :
( J8 {# k  C8 {, N; s2 a( b! U3 K+ \        print(count)
    count += 1

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
$ t& q$ x# {- T- {7 Y    if i %2 == 0:
1 I' a2 C& C$ O& b5 p: X        print(i)
$ D$ I; S. ^/ ]2 |) n6 o  X
4 c) T5 r6 x, _% z" @9 |count=0
. s7 t. C( K" _while count<100 :
. f0 D" z) L3 J) ~; Y    if count%2 == 0 :
        print(count)
    count+=1

12、分别书写数字 5，10，32，7 的二进制表示
# _& ~( C5 ?0 k( p# I. \- G
print(bin(5))二进制   0b101
: Y& y( n7 S/ F2 {9 `. T4 @print(hex(10))十六进制  0x5
+ m+ Q: R1 F; a! iprint(oct(5))  八进制  0o5
14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

$ j+ k4 z$ Z2 D16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
' W5 d: T7 C9 l' ~+ G  E# D17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

n1=5
% e1 M/ s9 E  }( S, J1 E1 F$ B$ z! v% xprint(int.bit_length(n1))  结果  3

, w6 {0 ?3 `+ i6 L7 C$ X( l9 N- ~; l
18、布尔值分别有什么?

False .Ture ,或1  和0

" Q6 W. M! m0 N1 Q& U20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
4 D* a8 I% B6 R% e7 d4 da. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())
" o) F7 C+ M% P; q8 V" K' Q7 O
( u; A: e+ f& b. }: E$ p1 F. w$ pb. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
print(name.startswith('al'))
c. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
d. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
print(name.replace('l','p'))   apex  
+ A% I6 _# m/ R9 W* le. 将 name 变量对应的值根据 “l” 分割，并输出结果。
, R' l2 k0 I  x4 `print(name.split('e'))   ['al', 'x  ']  列表

4 p: N% b: r$ pg. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])

j. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
' X- D' G# H* N8 D% F9 J7 b/ Y依赖索引
name = "Alex  "
( c! @, f) B& |for i in range(len(name)) :
9 N  Y; ^/ V% [8 h# `* [    print(name)
0 u3 p4 ^9 A8 p" g7 [; T# rfor i in name:
    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
5 ]6 R7 j  N( d8 s: {- f22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
8 s+ f/ w2 _( H! l6 P( H" gprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
1 X9 m4 V0 {+ W! b, Nprint(li)
0 n8 m' q1 u, ~" W- u. t ['alex', 'eric', 'rain', 'seven']
; u/ ^' F4 ]* a9 l6 r1 U& lc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
7 y  L2 i5 h; S0 m  mprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
" i( w( O4 S8 K, ]" ?print(li)
: n% E7 o) c0 O$ t, [e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
li.pop(1)
print(li)    ['alex', 'rain']
指名道姓的删除li = ['alex', 'eric', 'rain']
* d5 ~. e. i; {. U# Fli.remove('alex')
print(li)
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
! X  X* L2 U0 m1 r  ?print(li.pop(1))
! Y7 C( K  f. i& u; d. eprint(li)
+ u$ y4 y$ X3 t2 z
eric
. v+ H4 U3 A& T& [. T['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
; U& d# r) f0 [2 _* q# N9 ~del li[1:]
# y9 E. R& f& T4 a* [( j8 g; dprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
li = ['alex', 'eric', 'rain']
; g  H0 O* O0 N' Y1 Bfor 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]
7 M" F1 u7 K! u8 C1 p8 mprint(li[2][1][1])
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
li[2][2]='ALL'
" W! k$ n/ M8 v, Cprint(li)
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
' G0 k: n3 l8 L6 Mprint(len(tu))
2 R) C3 |; {% ~' v* Tb. 获取元组的第 2 个元素，并输出
+ L  p. R9 _8 x' @7 ~: Uprint(tu[1])
e. 请使用 for、len、range 输出元组的索引
for i in range(len(tu)) :
0 L% X! z% h8 q. E; i    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
for k,v in enumerate(tu,10) :
% G3 \' P/ ~7 @% o6 i7 T7 `5 n! j    print(k,v)
6 N4 J6 e; N+ r- a0 h7 G. u, m10 alex
; g7 F/ p6 L7 Q2 u5 S11 eric
' O  V: Z4 z$ N- S/ ~0 ]; Y3 i; l12 rain

for k in enumerate(tu,10) :
' h% z0 h4 [- f6 U9 y    print(k)
(10, 'alex')
(11, 'eric')
(12, 'rain')
2 l) ~1 C+ f/ w) y5 U
# L* _! C$ b9 N" M7 P9 t; q+ H. q7 w
25、有如下变量，请实现要求的功能
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

元组，不可以

d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
0 t$ A+ N: p1 I% Etu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
; F4 k1 k  m8 R1 A' qres=tu[1][2]['k2'].append('seven')
9 W9 }3 |& S3 O# p4 Y6 s  b
print(tu)
26、字典
# B4 h7 r) y" h6 X  ]- A: jdic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
    print(i)b. 请循环输出所有的 value
for i in dic:
, b* f# S; r* C6 Z    print(dic)
" `9 r6 o6 U2 tc. 请循环输出所有的 key 和 valuefor i in dic:
print(i,dic)
7 f7 C; e4 v9 p6 vd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
dic['k4']='v4'
" X6 I5 a9 }% \- `, _# ?$ Aprint(dic)
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
dic['k1']='alex'
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
3 c. ]* N' m8 ]0 x. Qdic['k3'].append(44)
print(dic)

g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
0 a+ _" z( n% X8 j1 |. F6 R1 }dic['k3'].insert(0,44)
' Z6 }2 f' l. q% G% sprint(dic)
# S# q2 [/ ?( W) t27、转换
a. 将字符串 s = "alex" 转换成列表  s = "alex"
- y. x) w/ w& j& o
print(list(s))b. 将字符串 s = "alex" 转换成元祖
s = "alex"
$ [& K7 R2 e, u4 _( s& X) T% B# }# [print(tuple(s))

$ L( x4 y6 Y& e7 d9 T% L2 ?b. 将列表 li = ["alex", "seven"] 转换成元组
li = ["alex", "seven"]
: q. f& F2 z* N* ^4 mprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
tu = ('Alex', "seven")
: o. {" k: E4 N6 K- Xli=list(tu)
print(li)


# s" W. p$ @3 R6 ?9 Qd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增

: w( V% |- X3 A, T! E9 m" k4 zdic={}
6 J1 c5 I% R( Q, H$ i- ~for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
    dic[k]=v
    print(dic)27、转码n = "老男孩"
6 @) Y1 Z9 G0 t0 Q; [/ `7 A. y' P. Ka. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
a=n.encode('utf-8')   
1 R* a, F5 t! Gprint(a)
3 G  L$ E" Q8 E$ ]" W9 \. E0 T* ?% Eb=a.decode('utf-8')
, c( D7 d2 u4 `print(b)
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
print(a)
b=a.decode('gbk')
; i+ v8 r* o3 [4 T7 w% Sprint(b)28、求 1-100 内的所有数的和
( w7 z! O  b/ c: Pcount=1
' F" [5 j0 U" p6 @" X2 x) O( Hsum=0
for i in range(100) :
5 B3 R+ \) |6 z1 H- p  }* b    sum=sum+count
5 M+ F8 w* z9 l4 e# @8 v    count+=1
) e- y, {8 x8 G2 ^3 s- q2 C% Wprint(sum)

) H6 p0 [8 h% t8 L3 Y( _* q5 |count=1
sum=0
while count<=100 :
    sum+=count
    count+=1
& _1 d; }# n* X/ W" wprint(sum)29、元素分类
2 t, \; A$ k6 |. k有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
将小于 66 的值保存至第二个 key 的值中。
" H/ k0 _& c) X- h6 W即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
6 e8 ?0 P9 ^$ e  Rli=[11,22,33,44,55,66,77,88,99,90]
dic1={
+ L1 x6 `1 y9 e8 y  k( C6 P' ~: e    'max':[],
    'min':[]
}
: [, z$ D. `  `4 @  `for i in li :
  c1 H7 w5 a2 x3 L' d# o  J( |    if i <66 :
        dic1['min'].append(i)
    else:
* A) x! s  L+ [. U6 [0 Y        dic1['max'].append(i)
8 J+ a% ?2 W) b6 o7 Q4 x2 fprint(dic1)
7 Z9 w, x" X* B! \
* T" d3 @9 n; b7 c% e---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
) R* L. m: a! o* y