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

单行注释  #

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

- O/ M1 x8 W5 O1 m1 A# V  n6、声明变量注意事项有那些?

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

不能以Python的关键字命名，

能表明变量的意义

8、如何查看变量在内存中的地址?
z=1
0 D* h3 ~- F: U- y: u% u: Hprint(id(z))
' h5 D' F! X% }1 S9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

10、写代码
4 I7 m: p' }2 K, z* P+ ~2 ]a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
name=input('name:').strip()
- p" l( S5 c, P' l/ z, o1 Epwd=input('pwd：').strip()
if name=='seven' and pwd=='123' :
    print('ok')
else:
# H- s  W# F: R$ J    print('error')

b.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
count=1
while count<=3 :
    name = input('name:').strip()
" \+ e& B% [0 U    pwd = input('pwd：').strip()
* N  I" s/ |- w4 `. Z. u6 d( s
    if name=='seven' and pwd=='123' :
        print('ok')
* q4 }% }1 Y0 |' |    else:
/ r3 m* j9 r% O, O5 _        print('error')
# x% I0 F7 U* b; U6 J0 v        count += 1
0 W$ m6 C/ L" T8 X! x- B( E- |* {for循环：
; p: E. S% s9 o9 R7 q& y3 X; G4 mfor count in range(3) :
    name = input('name:').strip()
. u) e5 _+ r  e" j8 p7 m8 m    pwd = input('pwd：').strip()
' K3 g& r: N  w6 I8 w
9 X) i) J! E" n7 b& C2 W2 t    if name=='seven' and pwd=='123' :
        print('ok')
    else:
        print('error')
7 N! x) w2 z: c% T0 T6 s. M! `/ A- L        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
count =1
while count<=3 :
    name = input('name: ')
/ c/ B6 R' V" c. G    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
) b  j5 f1 c2 |% ^) c" {7 j3 x$ M    else :
( C, R2 y5 d1 A2 o: h        print('error')
        count+=1
for循环
for count in range(3)  :
7 v  `8 C2 H8 o+ u+ @: _    name = input('name: ')
: h1 J* H) S: I" A4 x% a7 u! ]    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
+ J  [% M5 ?* c1 Z2 t5 Y        print('ok')
# D; g+ X! Y& X( _& [1 P0 [9 A    else :
        print('error')
        count+=111、写代码
a. 使用while循环实现输出2-3+4-5+6...+100 的和
count=2
num=0
while count<=100 :
    if count % 2 ==0 :
        num=count+num
3 O+ y" M6 r$ F- _/ j# W        count+=1
    else:
        num=num-count
+ b6 J, w/ j; ~2 U' S  P        count+=1
8 Q, v, z1 T8 W4 @; N- q* nprint(num)
( u7 y8 G& ]6 R9 D$ q( j9 j
" n  j% ^7 y9 J' d: t+ h: P+ Lb. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
num=0
count=1
for count in range(100) :
    if count % 2 == 0 :
9 c5 v! A: @; S0 `1 C        num=num - count
    else :
* j- F6 K/ w! w$ z        num=num+count
print(num)

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

count=1
while count < 13 :
5 g! Y0 x2 J, h( E' s. K, B    if count !=6 :
        if count !=10 :
6 n. V( P, s1 u6 d) x. i' j  G            print(count)
+ `+ Z/ h# P5 u4 U" b
0 c/ S( Q: w8 T( F- r1 q    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
for i in range(101) :
, ?) v( o  T2 `* {    if i %2 != 0 :
* C4 x) U) e# r5 l: I# s8 W2 g& g        print(i)
9 w, Z- N1 A/ X4 a* Q
5 }: X. w7 k& n9 O3 }2 T' [count=0
while count<100 :
    if count %2 != 0 :
; Z- o7 X, a- R        print(count)
    count += 1

9 @" E! F$ h& Z% {) m  K9 E' U  Te. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
% V$ G0 c* `. k! ^7 ]. U    if i %2 == 0:
        print(i)
' ]0 S8 \: {( s% t0 Z
count=0
5 Q4 D0 c2 d3 L  G  dwhile count<100 :
3 j, W( i! V+ l6 v8 N% y3 u# u, a3 m+ e3 i    if count%2 == 0 :
' G: b5 T% B0 Q- J        print(count)
: ?9 z  R- s, z    count+=1
& V: J2 G! |) r+ u
/ s: X) h& w3 n% R12、分别书写数字 5，10，32，7 的二进制表示

print(bin(5))二进制   0b101
7 g4 g. s6 M" M/ A) Kprint(hex(10))十六进制  0x5
print(oct(5))  八进制  0o5
( h9 t) p( C6 n: ?! v# N1 L14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

  |* U7 e6 l( L( W# u4 d- x16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

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

5 J& h1 `0 P, t/ i6 Z. N
18、布尔值分别有什么?

False .Ture ,或1  和0

20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
a. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())
4 r4 k1 P8 v( d7 o" @, T1 T  F) }
  z) b* w+ l+ g# V/ w1 x8 \b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
print(name.startswith('al'))
3 s" ~1 H# b4 b% A% F$ ^5 lc. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
d. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
, T2 @) f( X" E, \" Z- o" Nprint(name.replace('l','p'))   apex  
e. 将 name 变量对应的值根据 “l” 分割，并输出结果。
print(name.split('e'))   ['al', 'x  ']  列表
  `) b' C8 e+ W  ]
7 D/ x; _4 h% K% {* @$ Ug. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])
0 S& R1 L9 E( u: {
j. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
依赖索引
name = "Alex  "
7 @: C5 w' M8 G& h: r* tfor i in range(len(name)) :
& H( [6 p% w+ ^! ~    print(name)
for i in name:
    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
4 \7 D9 e: |4 h( D22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
( ?4 b+ N& o8 d" p* N7 Y0 Pprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
print(li)
['alex', 'eric', 'rain', 'seven']
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
) D6 `4 L4 n& Y0 N# o5 E( |+ Oprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
print(li)
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
) c; C* Z4 {1 Z2 L- l; Dli.pop(1)
print(li)    ['alex', 'rain']
6 p  V) v' A' o6 C( H3 g8 j% w$ Q6 ]指名道姓的删除li = ['alex', 'eric', 'rain']
li.remove('alex')
8 F3 c. Z7 y4 C* W) h  Q# m# w% Z* |print(li)
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
print(li.pop(1))
& v7 a' m8 D( L% N' [print(li)
) B" A" \0 I/ r. @% B
* v& B3 N  B8 G/ o& H  weric
% A, l  ]2 t0 Q1 b6 \' @" {# w['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
8 c) G1 a: H9 y; `# j: I/ d" |del li[1:]
- b0 E) q# {& ~) D7 Tprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
li = ['alex', 'eric', 'rain']
. H' R# ?1 `' o2 j& g9 a# Yfor k,v in enumerate(li,1):
    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
a. 请输出 “Kelly”
5 b9 Q: R' v% m, oli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
) F7 e& Q3 p% j3 O" qprint(li[2][1][1])
3 x; g5 E$ B; o7 E$ Sb. 请使用索引找到 'all' 元素并将其修改为 “ALL”
! n7 S: j, ?/ R- e" [3 Q. Bli[2][2]='ALL'
) D3 s9 F6 Z0 O& pprint(li)
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
print(len(tu))
' P2 d& `8 f3 `$ y. z( ib. 获取元组的第 2 个元素，并输出
print(tu[1])
) a  A% i, r& x. ke. 请使用 for、len、range 输出元组的索引
for i in range(len(tu)) :
% U6 p- P3 L' @6 g  p9 l" P6 E" }    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
1 W: N) t5 e/ e, Jfor k,v in enumerate(tu,10) :
: \$ _8 w% Z5 V4 @2 Z3 s% V+ Z    print(k,v)
10 alex
11 eric
12 rain
, E: ^0 c& C5 m3 N( a/ J
for k in enumerate(tu,10) :
    print(k)
/ W  w/ I! w' O6 F9 \( `(10, 'alex')
* H2 E. `" U9 _+ o% U(11, 'eric')
(12, 'rain')
7 ~1 \! t4 t1 z( X+ |- v/ h4 b) j5 j

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

元组，不可以

d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
3 u/ C/ l7 l$ }3 \3 o, G* n7 `tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
res=tu[1][2]['k2'].append('seven')

print(tu)
+ d7 R/ M1 `1 X8 A8 i4 W; o/ L26、字典
, P% i  D( K: f0 `% Rdic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
% b7 i" r6 W9 |7 u) f5 z    print(i)b. 请循环输出所有的 value
# q; U2 D0 S/ p+ ffor i in dic:
1 S0 x; [/ l! {& Q- u2 I    print(dic)
c. 请循环输出所有的 key 和 valuefor i in dic:
print(i,dic)
4 X5 O. K# D5 sd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
5 A% x; v, w- i3 o% W7 |3 A' v! _dic['k4']='v4'
print(dic)
7 U$ ^5 S/ J4 U; De. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
% B& e+ w/ H% Kdic['k1']='alex'
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
dic['k3'].append(44)
* U! h0 t' \4 h4 s* m0 Gprint(dic)

g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
# Z( K' {, z" g9 e9 ddic['k3'].insert(0,44)
print(dic)
6 j0 W! G4 X# r+ T  x27、转换
a. 将字符串 s = "alex" 转换成列表  s = "alex"

6 S. B# F, B# K+ |, G" _6 s5 i# F6 ]print(list(s))b. 将字符串 s = "alex" 转换成元祖
; K. b# z7 _) i4 Q, ^! l7 ws = "alex"
% P/ W5 N1 h6 A0 sprint(tuple(s))
& H7 s+ ?( L( T. G+ o
b. 将列表 li = ["alex", "seven"] 转换成元组
( E' }9 `2 i) ^- p$ K4 nli = ["alex", "seven"]
" N/ y8 k$ j9 |& k" X: T: f  jprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
9 y8 C3 A3 {+ y! w8 Y# btu = ('Alex', "seven")
li=list(tu)
' `0 P- _' f. dprint(li)

" K2 A  V0 k% Y2 @
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
  o& H# W* ~7 t/ z1 f) d( [( U
dic={}
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
5 Z- z: J$ {: d: V. w    dic[k]=v
    print(dic)27、转码n = "老男孩"
2 V: j! q1 ^" \a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
3 L! V1 @: c5 E7 o- t( L2 X; ^+ za=n.encode('utf-8')   
print(a)
b=a.decode('utf-8')
print(b)
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
print(a)
6 Z6 i2 V4 G; m; b2 Y& ub=a.decode('gbk')
print(b)28、求 1-100 内的所有数的和
+ t7 o8 z2 U- b$ Q" J6 }: ecount=1
' D2 |+ h+ R# Bsum=0
+ @- |8 p3 H4 Y# Ffor i in range(100) :
    sum=sum+count
) _- \# U0 |" Q    count+=1
4 M6 o  K1 Z8 j5 Pprint(sum)

: c$ I# j+ ~, a; P/ w' \' U8 G/ [count=1
sum=0
while count<=100 :
    sum+=count
+ @  \; g& J- B( s; B9 l    count+=1
0 |, T$ V# R( w$ q9 ]print(sum)29、元素分类
8 P, M# q9 Y3 p: Z+ u有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
1 A4 h- D- \. b9 y5 g4 ?9 ]* f将小于 66 的值保存至第二个 key 的值中。
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
6 i% U1 a; N. U" i6 Q% t; R" lli=[11,22,33,44,55,66,77,88,99,90]
dic1={
    'max':[],
* `$ s  T( G! C/ K    'min':[]
; T5 V. ^. |4 A3 O+ o4 }+ E: \3 n; ^: C}
for i in li :
4 b, [! n4 v. o, p2 k3 F  c, w    if i <66 :
        dic1['min'].append(i)
    else:
        dic1['max'].append(i)
% o" X& x3 j+ h4 B+ Z/ jprint(dic1)
2 `7 ~; q0 q3 Y. X- X
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}