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

" K8 Q: }6 J; b$ A, }1 _( ~5、Pyhton 单行注释和多行注释分别用什么?

单行注释  #

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

; h. b( l5 U$ y* P, b6、声明变量注意事项有那些?

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

不能以Python的关键字命名，

能表明变量的意义

8、如何查看变量在内存中的地址?
" B! K5 d" O3 t& mz=1
print(id(z))
' x/ e. w$ u" p% ^$ w, Q8 a3 L9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

5 X) }* H  ~, L& z  R/ m  h10、写代码
a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
6 b6 g1 ^7 A1 W$ _+ jname=input('name:').strip()
# k! e4 P# e' a7 z4 O& I; ypwd=input('pwd：').strip()
: v) o$ G  w: ~* T9 x1 hif name=='seven' and pwd=='123' :
    print('ok')
else:
    print('error')
) @! P( _  w! E( r; u" E* \
b.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
8 y" z/ N8 F3 y. S1 d' p, {: V/ }# Tcount=1
% M: N& c4 Q; C* v0 K6 C. Hwhile count<=3 :
" N' G7 @/ F* y* {3 p4 g    name = input('name:').strip()
    pwd = input('pwd：').strip()

    if name=='seven' and pwd=='123' :
9 }/ _) B5 v% P: j. _        print('ok')
    else:
        print('error')
" h. L9 d) M$ R0 b# }        count += 1
4 f0 X: ~; u& p) m# O* v# M! p3 gfor循环：
7 t7 W, |6 [& D) ^% B$ cfor count in range(3) :
1 {0 ^+ M, `, X/ d( H0 |    name = input('name:').strip()
    pwd = input('pwd：').strip()
2 K; U" b' f  f$ t
    if name=='seven' and pwd=='123' :
) H9 @% i5 ^; J        print('ok')
* o& C9 j2 b! R- \' i: _( I$ e5 r    else:
        print('error')
        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
* @( D% O8 f3 M! Q6 M4 h5 \  [count =1
; t$ H0 ?  _+ u) `3 p* ewhile count<=3 :
    name = input('name: ')
    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
5 \, a1 u/ A. R9 s  P        print('ok')
0 t% D$ W5 c9 j1 [4 i$ g    else :
7 `* a' G5 Q* s: X  C5 i' o* i5 H; n        print('error')
        count+=1
* M) o: U) J* V9 A. z' pfor循环
for count in range(3)  :
% ?; ]9 f9 s! t0 |* b9 ]) @+ \    name = input('name: ')
0 T6 ]1 R6 _! C    pwd = input('pwd: ')
' p) c0 k0 x( Y" R7 v2 c    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
* `7 M3 x3 l9 `* z0 L: W0 i        print('ok')
* y* x5 G9 N7 I/ R    else :
1 \+ T* h3 s! R+ U+ L        print('error')
        count+=111、写代码
& t! K* ~* R4 [" b* q1 {5 Q# z! Fa. 使用while循环实现输出2-3+4-5+6...+100 的和
count=2
num=0
1 k) G# D- P/ m7 M" m% gwhile count<=100 :
    if count % 2 ==0 :
        num=count+num
# h6 B. `8 g# X5 F' E        count+=1
    else:
        num=num-count
        count+=1
print(num)

; k  @  e8 b; |2 v) Qb. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
# c7 E+ O% k* l$ A& Y5 w num=0
count=1
- e$ t1 q4 q+ C8 Y/ Z$ Xfor count in range(100) :
5 C3 I/ `1 V8 _7 y5 N  K) I' E    if count % 2 == 0 :
5 X4 X; ^# M6 ]5 b: E        num=num - count
' Y2 V7 A. H& v    else :
% S) ^: U4 }' U! Y; q% u7 z: h        num=num+count
print(num)

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

count=1
/ b! R# b0 E# C& p" Z4 l7 @while count < 13 :
    if count !=6 :
        if count !=10 :
8 p5 ?  m9 i+ N2 G2 u  j$ k5 J: \            print(count)
1 d. ~9 q( M2 J
    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
2 `, A- I1 o4 f  a, h6 mfor i in range(101) :
    if i %2 != 0 :
3 W: h) F$ u! w6 B4 g        print(i)
  N1 A' o8 i9 P+ I- m$ q
count=0
; `* C2 r/ i$ H9 L$ O7 v$ t- twhile count<100 :
    if count %2 != 0 :
        print(count)
5 Q4 ]1 g, K5 E) n    count += 1
9 J2 n5 m& l) q( @* `, O: M
: p; s/ ^5 v/ _e. 使用 while 循环实现输出 1-100 内的所有偶数
0 v- r" M8 H/ Z5 v7 f8 ifor i in range(100) :
    if i %2 == 0:
% f9 U2 R& N/ _, s& J' L% D        print(i)

count=0
1 U2 [' E$ a1 t" n6 N; M) H: vwhile count<100 :
/ b* ^$ s1 a. L0 `6 k( ]  W    if count%2 == 0 :
        print(count)
    count+=1

3 {& H9 y8 g4 L8 `' a5 R12、分别书写数字 5，10，32，7 的二进制表示
0 l* |( U/ M* U1 s6 e
# }& j4 C9 [% x: f0 a& \9 _print(bin(5))二进制   0b101
print(hex(10))十六进制  0x5
1 l, E, x, J9 h5 X" Rprint(oct(5))  八进制  0o5
14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

" ^/ ~0 `) n2 D4 u16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
& p- J0 p* h; L17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

n1=5
$ X  |) b% h$ c. s/ uprint(int.bit_length(n1))  结果  3

18、布尔值分别有什么?

False .Ture ,或1  和0

7 s6 A$ U: |: ~* {. g20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
a. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())
# m1 w2 a3 z. u3 d- j
b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
) g# d* Q: x1 q! u! Nprint(name.startswith('al'))
- _. W: F4 j. |2 }c. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
! v7 e( U* `) c4 |  @4 qd. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
print(name.replace('l','p'))   apex  
; N5 o) Q! W/ D' U: }3 T1 u% o' Be. 将 name 变量对应的值根据 “l” 分割，并输出结果。
7 \5 H4 P1 v- z  K3 `/ nprint(name.split('e'))   ['al', 'x  ']  列表
4 l( k' |% \1 X7 P* t
g. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])
; ~0 p/ ?0 K+ R( \$ {! m
j. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
2 r3 M: C3 P5 K. H; s- L21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
依赖索引
- [* c* F0 D- c2 m/ _name = "Alex  "
for i in range(len(name)) :
7 g: t. B" z- C! w    print(name)
' x2 |9 g. ?7 V$ c3 _! \for i in name:
2 X9 H" H8 Q' n5 U% G9 y    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
2 ]& |' A" s8 j+ F" o22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
9 Y, m) u0 H5 g, |: ~  bprint(li)
. B- N* j% F/ W; l. O) P* G ['alex', 'eric', 'rain', 'seven']
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
" v6 I+ Z& C' U* F# w7 H- c5 Lprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
print(li)
) t1 j+ N; D3 ve. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
: V- A. u2 E6 l0 z3 l) W5 _li.pop(1)
: s( F5 H# _. bprint(li)    ['alex', 'rain']
1 U5 R1 k+ v" q9 }指名道姓的删除li = ['alex', 'eric', 'rain']
li.remove('alex')
3 O; A% N6 ~: i! s# {) \0 o2 J# \print(li)
) X: v/ k$ S+ ?  L8 hf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
print(li.pop(1))
- j8 J% f$ ~2 a  l' z- V+ nprint(li)

eric
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
del li[1:]
& s0 i3 c' e# T; F, D$ ?9 q' |2 zprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
li = ['alex', 'eric', 'rain']
for k,v in enumerate(li,1):
7 j' m2 l8 X0 S# w0 B. i    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
a. 请输出 “Kelly”
7 F  N" \0 \5 P9 n2 zli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
print(li[2][1][1])
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
2 ]- T# d% B. ^4 X( Lli[2][2]='ALL'
print(li)
1 b4 P- d6 M$ p24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
2 G1 K9 n. M$ C- L1 V: H& ta. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
" b: ^+ O: @- G8 G+ _print(len(tu))
1 j/ s  ?  t( Z) s2 n  ib. 获取元组的第 2 个元素，并输出
print(tu[1])
6 D1 e0 k5 v! f% v2 B& U8 Fe. 请使用 for、len、range 输出元组的索引
for i in range(len(tu)) :
! p) |5 N# X- f+ c0 `    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
6 P) e7 ]8 Y( \0 n% F8 J1 Efor k,v in enumerate(tu,10) :
    print(k,v)
% c" ]8 a2 F' i8 g; j0 x2 \5 O10 alex
11 eric
" |8 K  y) d! v  E7 p2 O12 rain
; S. O; w- F& v, q1 J
for k in enumerate(tu,10) :
1 u) Q4 I% r1 l- B9 z/ k$ X    print(k)
(10, 'alex')
(11, 'eric')
- n8 ], z; b  i" z' f6 D; N(12, 'rain')


+ [- n; m0 P1 o% v- u25、有如下变量，请实现要求的功能
: r. y* h) O# A# ytu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

元组，不可以

7 b! D& ]4 }; @# T' e" D- L  Qd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
6 c5 o- N# J3 s* E2 m, ^4 E& g% mtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
* [8 w6 C7 M  O! q$ `res=tu[1][2]['k2'].append('seven')
; V4 W/ J5 |* [/ k! b0 P
0 ~( Z+ e% J9 a* N/ X9 e4 Vprint(tu)
26、字典
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
    print(i)b. 请循环输出所有的 value
) B- [8 i+ W& g: t3 b9 p' Jfor i in dic:
: F4 e0 k0 @" T9 T    print(dic)
& F/ T: y7 e# Y) R0 u1 Nc. 请循环输出所有的 key 和 valuefor i in dic:
print(i,dic)
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
dic['k4']='v4'
print(dic)
" p$ U8 v0 p% \) ^8 J1 {9 oe. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
2 S* y' k/ F# J  i( U+ Tdic['k1']='alex'
, [' R4 u; {* D2 |2 j+ _9 Kprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
2 |8 n: l: Q' u/ F; }+ K6 v. Bdic['k3'].append(44)
print(dic)
3 f+ C% m" v& v# U# @2 C+ R$ ]
! Q' a. y2 W7 s- v& _& C; Q3 q% Z. Wg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
2 M1 }7 |1 w: W' [1 kdic['k3'].insert(0,44)
print(dic)
' L! B$ a  \) u5 W" f& u+ t8 F27、转换
a. 将字符串 s = "alex" 转换成列表  s = "alex"
* |' m, [; u7 K  R. `
print(list(s))b. 将字符串 s = "alex" 转换成元祖
s = "alex"
: d6 J2 k, \- c& Gprint(tuple(s))
5 e; n) @2 p8 ?- k3 o3 w3 j
5 c" x1 b1 I" y2 zb. 将列表 li = ["alex", "seven"] 转换成元组
li = ["alex", "seven"]
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
tu = ('Alex', "seven")
li=list(tu)
print(li)
7 X' ?3 Q! M1 n: j7 I6 g: U' g: a7 E
. z- N# `1 e  S& V4 f" u
! ?6 }0 b8 b1 f0 ?8 td. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
" r5 }1 r' K* o3 X; c
dic={}
. Z+ [; a, G4 k, }( G, }6 Z9 `for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
- p* R4 X6 r2 \* J) `  B    dic[k]=v
" h4 J: x; }6 a3 Z    print(dic)27、转码n = "老男孩"
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
) S$ Y. Y5 B* c0 _a=n.encode('utf-8')   
print(a)
' X3 V+ S% u9 @, ^) Db=a.decode('utf-8')
print(b)
) ]: u4 B7 F) Q: B( o% H4 \b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
4 b& m' p- }# qprint(a)
5 [( w9 Y* I( y; R1 C6 Rb=a.decode('gbk')
& o: r/ @9 h; w/ X- s1 Dprint(b)28、求 1-100 内的所有数的和
# r* G7 h/ Q$ {- I8 \, Wcount=1
sum=0
' a3 v, G$ O' y) t% _# S+ Bfor i in range(100) :
) ]! Q) T5 _% Y( p. Q9 ?3 M    sum=sum+count
# n, W- k; o! s9 L1 P! o& T/ S    count+=1
print(sum)
" f1 V) C5 ]2 U# U" `+ J
) X$ i+ r# T3 ]" ncount=1
) u3 {; _; @0 C' q; P- ~sum=0
while count<=100 :
    sum+=count
6 J7 v6 Y$ l5 |- M    count+=1
print(sum)29、元素分类
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
将小于 66 的值保存至第二个 key 的值中。
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
0 q( W# v6 z" Nli=[11,22,33,44,55,66,77,88,99,90]
dic1={
    'max':[],
    'min':[]
}
4 A' P5 q* }/ a+ n+ h- Xfor i in li :
    if i <66 :
8 }7 L$ C( r. T5 \; T! Q) D        dic1['min'].append(i)
    else:
: i/ e% ^- v6 j+ u- g# U9 Q        dic1['max'].append(i)
print(dic1)

1 P7 P+ e- |, m# G---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}