Python基础知识汇总

1.执行脚本的两种方式

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

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

2、简述位、字节的关系

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

3 Q9 v+ \9 \  U3 e8 s, k3、简述 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

  M% q( |$ m. J2 r9 d+ H  x: M2 n5、Pyhton 单行注释和多行注释分别用什么?

单行注释  #

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

' y1 C- J- h8 g3 b/ v. Z$ G6、声明变量注意事项有那些?

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

不能以Python的关键字命名，

能表明变量的意义

8、如何查看变量在内存中的地址?
z=1
print(id(z))
" F9 s" \$ }  {9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

4 ^% q! ]7 s, b6 s10、写代码
a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
4 D. h  |+ [% g- c% L# Zname=input('name:').strip()
pwd=input('pwd：').strip()
& q- a. j' O: H% Q4 T7 oif name=='seven' and pwd=='123' :
    print('ok')
8 p; f  V. V( ?' uelse:
% g+ m/ m5 V( C) n    print('error')
; Q7 n' q# {3 O8 L, o1 y6 M
b.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
count=1
while count<=3 :
    name = input('name:').strip()
    pwd = input('pwd：').strip()
. Q6 R7 |4 N' Y, \1 X
: ?/ W9 L9 V  [    if name=='seven' and pwd=='123' :
        print('ok')
    else:
: ]1 \# Y6 U0 B  \* A        print('error')
        count += 1
5 j2 C1 E. C( Rfor循环：
for count in range(3) :
: \4 v$ P# C+ P. G    name = input('name:').strip()
2 }' x0 M  _4 q" U1 _& q    pwd = input('pwd：').strip()
) `/ f& s9 v: g9 K- ^
! T$ F2 V6 ]: `% k    if name=='seven' and pwd=='123' :
        print('ok')
3 L8 J/ A" a: h; v$ u1 N6 _; W    else:
        print('error')
- I! g6 R, u; a/ d( k        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
6 P  m8 x, B! m5 Bcount =1
while count<=3 :
    name = input('name: ')
    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
    else :
, R+ T* G% n6 g5 S        print('error')
4 F7 m2 O1 J; P% Q' O: V        count+=1
3 F  N# ]' P* t: M! W; b7 Hfor循环
for count in range(3)  :
    name = input('name: ')
5 V% H7 B/ ^7 @' M    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
1 i# _' Y) a* b+ Z& r        print('ok')
  O5 w0 a, `8 S    else :
        print('error')
9 o: o( M& Y/ |% f5 f) N        count+=111、写代码
4 ]  Z7 E9 x- a0 e$ ?a. 使用while循环实现输出2-3+4-5+6...+100 的和
5 [! c9 F+ v0 y. C- r+ ]9 Wcount=2
. q6 h) v9 x% A- Znum=0
# q, ~' V2 a3 H) c: kwhile count<=100 :
9 S. ?; N, x: @- v: u    if count % 2 ==0 :
3 X9 c$ E! I. _        num=count+num
. X$ r6 z; f& L5 J- v        count+=1
! t+ o, Q* G% {" T* L5 C    else:
        num=num-count
& w" x) e, T5 r8 y        count+=1
print(num)

5 \' F0 h4 W& ?! E; C- n% Rb. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
# s6 Q( Q1 M) G  \ num=0
count=1
for count in range(100) :
    if count % 2 == 0 :
        num=num - count
9 l; q2 l! |& _! v* w3 Z    else :
        num=num+count
print(num)

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

count=1
) y2 O/ J2 u& g, B8 S/ R! ^while count < 13 :
" \, o$ ^9 Y( G* x2 Y. |    if count !=6 :
1 D6 p" a8 k* B/ |- O        if count !=10 :
            print(count)

! Z/ I5 X/ E  u! _    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
for i in range(101) :
    if i %2 != 0 :
2 t2 D5 P5 w! ?! f; c        print(i)

* d- x6 i( ^& ?' w4 f9 zcount=0
4 k1 q% f" T( v9 ^( Vwhile count<100 :
, N: K5 e( ?* m. ]& M: @0 @4 G$ [    if count %2 != 0 :
, R, P0 H5 X, E: [6 [( D" M- Q        print(count)
    count += 1
0 J" n6 H. s0 }% C0 G
e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
    if i %2 == 0:
        print(i)

7 M/ a4 l$ [/ O, Qcount=0
% V1 m" B6 I* T" c9 e* r) [- Owhile count<100 :
1 n' H  C+ q+ D9 F& w0 u    if count%2 == 0 :
( \2 k( N1 z/ I4 }- c        print(count)
3 V2 x, g4 m! q. F2 ]    count+=1
9 V8 l  R+ ^$ v' n: l$ \4 |
# z1 f/ s5 m5 I6 {4 I. i12、分别书写数字 5，10，32，7 的二进制表示
4 z- y$ y; ?1 T6 j
print(bin(5))二进制   0b101
& W* c% _; n) E4 N# ]: t: Y& xprint(hex(10))十六进制  0x5
print(oct(5))  八进制  0o5
7 H! t; Y. z$ ^8 x0 V( L  l14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

: z* \+ V( M+ h1 s  Q) j! s16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
/ F5 X. V! {3 V, P5 I17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

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

8 @& C) f* D% X% M' h- @18、布尔值分别有什么?

False .Ture ,或1  和0

20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
a. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())

1 I% d" b; J5 @( n8 Fb. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
, s! G& w2 g* Z2 V( Vprint(name.startswith('al'))
( E: a; M* o  n+ p, `c. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
d. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
print(name.replace('l','p'))   apex  
0 b  ^: l2 y, P/ `e. 将 name 变量对应的值根据 “l” 分割，并输出结果。
print(name.split('e'))   ['al', 'x  ']  列表
9 u+ ]: U6 _) h7 [0 I
g. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])
! ]4 r0 K  {' Y/ f: G
j. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
2 E% l+ e: t3 b% }" |- _4 g依赖索引
$ y* b2 {( a% V8 u2 p9 l2 ?; Aname = "Alex  "
for i in range(len(name)) :
% y4 [: _. \6 a! F! P/ y. m! z1 T    print(name)
0 ?0 S; i: M) v3 afor i in name:
3 {+ O1 V% M" H' o% \, @2 }! @    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
% |: {: c3 U% f; Z- P/ z" s' f22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
* K  M- J1 A! W3 [print(li)
/ g( o2 n2 k2 r3 G, }& V3 g ['alex', 'eric', 'rain', 'seven']
- j9 h6 O' S5 q' v0 j) e# w0 ~9 h7 Xc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
print(li)
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
li.pop(1)
7 Y, w' w, d# z3 n  \" x% Sprint(li)    ['alex', 'rain']
指名道姓的删除li = ['alex', 'eric', 'rain']
- Z: s; b# _/ Cli.remove('alex')
$ ]0 [) y. |( G6 S6 a, Mprint(li)
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
9 h2 L" x& L  \: b5 Yprint(li.pop(1))
print(li)

eric
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
, J6 ~. `; W- N2 W( U( \7 Pdel li[1:]
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
& q+ O  C8 I8 t  r, ^8 dli = ['alex', 'eric', 'rain']
) B8 {% a2 V7 U) bfor k,v in enumerate(li,1):
    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
2 v# @! A/ ~' Wa. 请输出 “Kelly”
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
print(li[2][1][1])
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
li[2][2]='ALL'
( E. k2 q- ?* M: Y2 y( mprint(li)
9 S6 O2 ]- F* c2 [24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
8 y2 c: R' Y4 C2 N! x3 o5 La. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
& i9 l1 n: ?" E& W5 T% S* e: ~print(len(tu))
b. 获取元组的第 2 个元素，并输出
, L2 M6 B( \2 B' x' \print(tu[1])
( f! @7 ?, k4 W% R' }/ ue. 请使用 for、len、range 输出元组的索引
3 M. q; B8 P2 j; v9 N  s) kfor i in range(len(tu)) :
9 O0 }$ Y2 d. ~" j, f  s/ J    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
for k,v in enumerate(tu,10) :
( t& b1 @% a2 _* J! N+ u( V$ C1 I    print(k,v)
( |9 a" ^3 c1 X3 T1 N5 Z10 alex
3 z4 k7 ^7 \* y11 eric
. ?0 \- ?. ]1 Q% ^12 rain

for k in enumerate(tu,10) :
" Y/ ~7 G! g1 m. y- i    print(k)
* d  F  S4 u: c# L! i" t(10, 'alex')
5 W, ~2 S! |6 r* O( g(11, 'eric')
6 n  Q- q- t5 G; T(12, 'rain')

) L9 Z# g1 y+ f- h9 c
25、有如下变量，请实现要求的功能
) t4 J* ?' F- }% U* Y  Itu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

元组，不可以

* H& U6 D/ ^7 A, ~& N$ U3 ?d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
8 f  U% K; x) utu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
8 X$ @$ M3 R+ L1 j( ^. q/ yres=tu[1][2]['k2'].append('seven')

print(tu)
, {0 J3 R/ p( m  G: ^' ]26、字典
, M! `  X! g$ a" I+ cdic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
8 B, q( k4 I: P. z    print(i)b. 请循环输出所有的 value
for i in dic:
    print(dic)
' J( P0 K! D6 E5 c5 e2 _- `c. 请循环输出所有的 key 和 valuefor i in dic:
print(i,dic)
# X: x# n' V, G: wd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
9 \$ O; o( U+ r/ a8 Fdic['k4']='v4'
print(dic)
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
( {7 w" ?# q$ _* h( xdic['k1']='alex'
+ s. L3 b) i" U+ kprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
dic['k3'].append(44)
/ a! q$ \0 ?4 E% Y6 `! Qprint(dic)
- B: e4 o* a) [' g* V
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
dic['k3'].insert(0,44)
print(dic)
27、转换
a. 将字符串 s = "alex" 转换成列表  s = "alex"
  H, @/ b7 l7 ~. N
print(list(s))b. 将字符串 s = "alex" 转换成元祖
0 q$ `. W4 o. P6 R3 @' C# V* e" Ms = "alex"
4 e& @) V& y0 s$ O9 Xprint(tuple(s))

b. 将列表 li = ["alex", "seven"] 转换成元组
3 B7 Z% l: W4 r5 |li = ["alex", "seven"]
, y/ |" v) F7 U, f! jprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
6 [" R. R& T3 s, _tu = ('Alex', "seven")
+ p* X- x5 w* d7 t% Q. oli=list(tu)
print(li)
( k; T. ?; T. J1 E, Z
5 r; n+ K5 z: v: q% O" Y
* y, P( I9 r+ l6 R' s! {d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增

dic={}
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
    dic[k]=v
6 \9 k  }, U. g2 A) i3 V    print(dic)27、转码n = "老男孩"
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
1 i" g* s; ?# V. I% `% |a=n.encode('utf-8')   
print(a)
! K: r; g6 W8 {) {. Z4 G  E1 ?2 Fb=a.decode('utf-8')
5 W% b! _, f7 e! lprint(b)
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
print(a)
' d2 b( t1 F) r+ Q. T2 t: Sb=a.decode('gbk')
print(b)28、求 1-100 内的所有数的和
count=1
% t# w' d: B7 I: }0 T6 w' Y. _sum=0
8 A& @# {" u) ~3 D  Q; Rfor i in range(100) :
    sum=sum+count
2 m7 T: \4 [+ k- L9 `# s0 H    count+=1
( I4 Q, l/ S* ?3 V9 iprint(sum)
8 d, M: |' R4 }+ N5 }# B6 \: X
count=1
* Q0 w  P; x! h6 m+ ?/ e$ isum=0
while count<=100 :
" D3 I$ p% L" q  _' w, R    sum+=count
$ d, I, s2 U% n) ]    count+=1
2 d: ^, ]4 v) o4 P8 Wprint(sum)29、元素分类
! T* u7 i7 N2 d& d有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
% O# T( X" F( u2 b1 Z0 J1 _将小于 66 的值保存至第二个 key 的值中。
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
li=[11,22,33,44,55,66,77,88,99,90]
# a+ w' f% \, c" y, i" d$ N$ xdic1={
+ A3 s4 @- ?" N/ P  Q# o    'max':[],
0 g0 {, ~6 z4 [, P, C* E6 S    'min':[]
3 r3 G1 n7 s" [. O}
8 x8 [! t. S( h& p4 h2 l7 T7 Q& Dfor i in li :
) }9 U* c* j! m, n" w    if i <66 :
        dic1['min'].append(i)
    else:
5 Y) n% t# k% i) Q& k$ j: Q        dic1['max'].append(i)
print(dic1)
8 e2 `0 x1 s1 P! }$ J& Z* J4 a' c
8 q* D3 {' n: z/ ~8 x4 f, Y) O---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}