Python基础知识汇总

1.执行脚本的两种方式

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

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

2、简述位、字节的关系

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

* B5 }) I  o- x- Y; |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

9 e9 J/ \( f$ q4 A5、Pyhton 单行注释和多行注释分别用什么?

单行注释  #

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

, |0 L) @; L7 z: D! z" e2 L5 P6、声明变量注意事项有那些?

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

不能以Python的关键字命名，

能表明变量的意义

8、如何查看变量在内存中的地址?
; f* h% c8 X' D+ y# Yz=1
# }4 Y6 Y% w' R' `' e  t0 `. Dprint(id(z))
$ m# [- g7 O& h. ~8 Z& M9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

8 I' {" z& G% S3 G10、写代码
a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
( q- T* `8 m( s$ c# J# Oname=input('name:').strip()
6 K% G+ I' y) fpwd=input('pwd：').strip()
if name=='seven' and pwd=='123' :
( R" c  m1 O' a% X0 S6 b/ l- ^3 S    print('ok')
else:
    print('error')

/ t+ q8 A1 o) G9 z2 Gb.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
count=1
while count<=3 :
    name = input('name:').strip()
- l/ K' @2 J$ K4 y. b7 M, V    pwd = input('pwd：').strip()

1 Y. @; |1 v3 o1 z! E0 L" a3 f    if name=='seven' and pwd=='123' :
+ Q; s3 z% N0 D' B* U" |/ H        print('ok')
" g5 P" g# X* `    else:
        print('error')
/ j9 k, Y. \/ n        count += 1
for循环：
' `* y3 A/ ?2 m% K3 h& P9 j% C0 jfor count in range(3) :
    name = input('name:').strip()
    pwd = input('pwd：').strip()
  S- X  e3 i' m1 n6 y5 S, a+ Y
    if name=='seven' and pwd=='123' :
, N; J6 R9 C$ ^        print('ok')
    else:
        print('error')
        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
count =1
% {) C" C0 U& dwhile count<=3 :
    name = input('name: ')
    pwd = input('pwd: ')
1 k) J) ?  x$ l    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
    else :
        print('error')
        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')
    else :
0 V* v2 S" r# c/ D* x  F        print('error')
        count+=111、写代码
4 f4 t% [  e  ]3 Q0 s( N# l6 d4 p4 Ta. 使用while循环实现输出2-3+4-5+6...+100 的和
count=2
num=0
. Q: \( Y! P9 Y9 l* @2 Jwhile count<=100 :
' z8 N" H) t3 l( z8 b' O+ O    if count % 2 ==0 :
# f, R  [% D* Z7 T        num=count+num
' K  v. Z! B# `: i2 D$ k  {+ U3 k        count+=1
* Z$ K' i/ u9 G) J. Z9 v% a    else:
, }4 t. B9 q& K/ i- p; y* u- |& l: n        num=num-count
7 u9 J" }* y1 o" a1 k; }9 \        count+=1
/ V- l" I5 N4 ^. Tprint(num)
6 D' i7 F. D" _' i7 V8 H
, A1 M5 \& D) H9 rb. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
" h3 B% t0 w8 I% E num=0
count=1
for count in range(100) :
    if count % 2 == 0 :
        num=num - count
& m2 s/ Y' x5 m* Q7 i" P( J    else :
5 H, m: {5 S- i- Q2 @- U        num=num+count
. O" H" @; h5 ^3 }* p' q8 F* Nprint(num)

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

count=1
0 r+ L5 [: }, l% zwhile count < 13 :
; F3 U6 u. O6 Z6 Z# I7 R    if count !=6 :
        if count !=10 :
8 J) L* U) O$ f3 e3 P9 Q            print(count)
# W$ W* A  u+ `1 \5 ~
/ _: |5 G; p) i3 V' F8 p+ y    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
1 |/ D6 u# r5 P) |5 E: c) mfor i in range(101) :
9 P3 i' t, T( n$ ~    if i %2 != 0 :
        print(i)

, u; |( r$ p9 y9 R5 G9 Ccount=0
  ?! p, D9 W; W" o$ qwhile count<100 :
    if count %2 != 0 :
: E5 H! w& D, F' T8 ~$ C0 D        print(count)
    count += 1

8 j) ?& m3 [. d% ge. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
. i4 u( F& g4 Z5 Y" q7 x; H: o    if i %2 == 0:
        print(i)
/ ~5 \8 g' a- Y7 e
. S3 O4 r, b/ p  m0 R1 @1 qcount=0
while count<100 :
    if count%2 == 0 :
        print(count)
    count+=1
$ d% x8 ?' {1 v8 ~& M, S4 G
12、分别书写数字 5，10，32，7 的二进制表示
+ _+ ~& i7 v2 O7 _" W
1 v* Z3 K. s. d+ r# E) r) fprint(bin(5))二进制   0b101
' D% O6 }) m7 ?0 ]" P; ^1 T5 R" Yprint(hex(10))十六进制  0x5
print(oct(5))  八进制  0o5
' f! A: f# r: ^9 ?' g5 O+ m14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

: i6 w5 f0 k. H; e( n4 Y16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
2 ~4 Q6 E* x* @' v  D/ w# d0 k6 D17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

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

* h' L7 {9 p1 A( `+ l. q  ?
18、布尔值分别有什么?

False .Ture ,或1  和0

$ q0 t, ?7 k5 o* ^& J; l20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
a. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())
; b( J( Q/ x3 B# ]$ Y6 W
" y& c1 H- h" f" B0 x8 w: [9 s8 {b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
print(name.startswith('al'))
c. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
/ d; }9 @6 A- h1 z8 Ad. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
print(name.replace('l','p'))   apex  
e. 将 name 变量对应的值根据 “l” 分割，并输出结果。
print(name.split('e'))   ['al', 'x  ']  列表

6 s  z) p4 v3 q: |( E& Tg. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])
5 D- o8 V5 s7 K7 V" z" T
j. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
3 p) A8 d" U0 w) j21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
依赖索引
/ y! B! a: N2 {8 p; w. e) N5 cname = "Alex  "
for i in range(len(name)) :
: `9 T! |8 M6 D% J) s5 K: ]    print(name)
/ F+ L8 g) t% e: j9 ]- `$ Cfor i in name:
2 q, o2 X" @/ ?0 n; R4 o+ d6 K( \    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
. V8 a9 M, x3 H/ y: N% B4 N7 dprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
; }% A; V. j, ?* @% zprint(li)
- x6 T9 p* A' p ['alex', 'eric', 'rain', 'seven']
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
# A0 [5 S0 L# bprint(li)
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
6 q5 u$ e8 [; ?' {7 Qli.pop(1)
! g' R% y7 r0 i  ?2 Z5 ?print(li)    ['alex', 'rain']
. r, j3 ^# W: x, I' u指名道姓的删除li = ['alex', 'eric', 'rain']
li.remove('alex')
print(li)
+ W: h+ }8 l& B* v4 F2 M( Of. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
1 U, Q5 e" j, ?* g7 d* u$ Uprint(li.pop(1))
print(li)

- r' p* ~% {! R3 xeric
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
del li[1:]
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
li = ['alex', 'eric', 'rain']
0 b  z9 {8 D! o5 z3 ]for k,v in enumerate(li,1):
    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
4 p% M5 H8 t  n* p1 f+ l( B6 a" ~3 [a. 请输出 “Kelly”
" f5 V; h- J- z# H2 G4 A( ali = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
% c  s4 t( i$ Uprint(li[2][1][1])
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
li[2][2]='ALL'
print(li)
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
! \) B6 g" G# t7 F: la. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
" l- k  f# P$ l* P" jprint(len(tu))
b. 获取元组的第 2 个元素，并输出
print(tu[1])
e. 请使用 for、len、range 输出元组的索引
: Y3 F8 ]- D( v* Afor i in range(len(tu)) :
+ O7 A6 q5 ~- I2 j+ J: ?    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
for k,v in enumerate(tu,10) :
    print(k,v)
, T! j; }0 Q8 ^" [10 alex
9 d: Z/ ?0 \2 H) {8 D1 T11 eric
12 rain

6 S% I' I) J$ h& c1 u; R7 P5 f! Ofor k in enumerate(tu,10) :
    print(k)
; \* J3 z: s# l3 q" a# q1 @; [(10, 'alex')
(11, 'eric')
(12, 'rain')
& S% w7 L0 \( V! x& H, H

7 Y- {5 M( ]6 Q$ V$ [* d2 D9 h9 k25、有如下变量，请实现要求的功能
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

元组，不可以

$ Y1 h. n( s1 Y, }d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
: X2 I# t% J' j. C9 ^4 ^tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
, n, w% b# H( O8 G5 P; K8 pres=tu[1][2]['k2'].append('seven')
7 O/ T3 A4 @  [' z. B3 d! u
  E4 C, L& j4 Y  wprint(tu)
* |8 A* z! W  n) f% w' ~( A7 n26、字典
% @  a; L% w$ c1 M( [" Ndic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
    print(i)b. 请循环输出所有的 value
for i in dic:
    print(dic)
, w" T( ~: Q: y, D# oc. 请循环输出所有的 key 和 valuefor i in dic:
6 [+ q! @, t: N4 f' X( eprint(i,dic)
+ r( A* e, s  e9 P; l9 e% C1 `  Vd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
dic['k4']='v4'
print(dic)
! h5 x  ?* v7 |, t5 n+ oe. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
/ a9 g5 u" \' L* k- R) Vdic['k1']='alex'
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
5 H1 p  S9 @& n0 P% m2 I  @% m2 Ldic['k3'].append(44)
2 C) k5 C7 @. g( w0 yprint(dic)
5 A- J) a9 b% c* a
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
2 k; W! A9 T) Y! i& M& w/ ^& v: p2 y! vdic['k3'].insert(0,44)
print(dic)
27、转换
a. 将字符串 s = "alex" 转换成列表  s = "alex"
' ]3 ?8 O) j  F2 ?8 {( s
5 T4 N) }  F& |1 E4 J. }. F- cprint(list(s))b. 将字符串 s = "alex" 转换成元祖
+ K" T8 v% {. c  u3 ?9 I3 l& Ys = "alex"
9 K( w) P: m5 D" T: ^! ?: ^print(tuple(s))

) V2 I4 e8 }& V3 bb. 将列表 li = ["alex", "seven"] 转换成元组
5 s5 [! P+ U. M0 J, D, jli = ["alex", "seven"]
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
' e: t% ^. C% p: ?' c0 ytu = ('Alex', "seven")
li=list(tu)
0 [8 e7 x. r* F/ `- G5 h0 nprint(li)

/ ?( M9 J& Y: S9 ?  O6 R
. U. [* J2 T" P* B8 W# u; C! wd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
# G4 I4 R! e% V. y% y
dic={}
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
. l1 ~* O) f3 w0 o0 C    dic[k]=v
6 v3 d2 I2 u3 T* u    print(dic)27、转码n = "老男孩"
$ A/ K( A' K8 ma. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
a=n.encode('utf-8')   
1 l. ~/ ~# f5 Z6 v6 X$ ~print(a)
b=a.decode('utf-8')
print(b)
2 H% V: S% t/ \0 Cb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
, M( z3 h8 g: xprint(a)
b=a.decode('gbk')
print(b)28、求 1-100 内的所有数的和
count=1
sum=0
5 C# O6 G; ^! L2 e6 Z  c8 b  F3 F. Lfor i in range(100) :
    sum=sum+count
, F6 C1 R- j4 `4 T* A5 c  @    count+=1
print(sum)

! S, X5 ]( X+ zcount=1
sum=0
while count<=100 :
    sum+=count
    count+=1
6 Y  c% V( l" E$ L& J* B6 G' o! iprint(sum)29、元素分类
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
将小于 66 的值保存至第二个 key 的值中。
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
3 m0 d; U9 h( s, g. {! ~+ q7 a% ~" Gli=[11,22,33,44,55,66,77,88,99,90]
dic1={
; ~! s% s: A) }" V    'max':[],
    'min':[]
! L3 M$ g+ P8 s: D7 O}
for i in li :
7 j# x+ Q9 R6 u6 J; C    if i <66 :
        dic1['min'].append(i)
    else:
        dic1['max'].append(i)
print(dic1)
" H# E7 [: r# J! G3 O8 {7 M
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}