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

# a7 w0 L  Y0 \9 Q" N- m' J; E5、Pyhton 单行注释和多行注释分别用什么?

单行注释  #

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

( x2 a# D9 J0 x6、声明变量注意事项有那些?

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

不能以Python的关键字命名，

能表明变量的意义

8、如何查看变量在内存中的地址?
" ?3 l6 N' P; Z1 |3 G' W% yz=1
1 R( v. W7 S1 i: N) i7 J* ~print(id(z))
( b0 Q" E: ~/ V7 {9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

4 }( z. I! z; b1 v- y5 q7 E" ?; M9 A10、写代码
a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
name=input('name:').strip()
; l0 W/ i: a- R$ [2 z1 apwd=input('pwd：').strip()
& b5 G& T$ e& f9 j9 r; Uif name=='seven' and pwd=='123' :
    print('ok')
/ b3 A9 x/ T& z: \) _else:
    print('error')
9 [) o+ T& p2 j- }: p3 v
b.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
* g! }& P, @4 ]' R. acount=1
# u- A/ P- u6 A( ^, Owhile count<=3 :
4 U3 R  a, L4 Z1 j/ d5 y1 C    name = input('name:').strip()
+ \6 F2 V9 e8 g    pwd = input('pwd：').strip()

    if name=='seven' and pwd=='123' :
        print('ok')
+ j: E  X) E+ s    else:
        print('error')
4 `! X* m1 S! W2 w# _        count += 1
for循环：
for count in range(3) :
% m# z7 f+ f2 w1 f    name = input('name:').strip()
9 [# q+ a0 i3 U( w6 G( g" Y    pwd = input('pwd：').strip()
" b* d1 L5 ]0 u4 k6 o
    if name=='seven' and pwd=='123' :
0 J9 @7 f, v" ~. q        print('ok')
' j6 M2 r/ p6 A# C$ Q9 Y    else:
1 d% i1 O% h4 O6 ~( B8 g2 B- C        print('error')
        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
, {0 J& M7 p$ K2 u: j4 T5 Pcount =1
while count<=3 :
, K7 `& B/ g# ~' I; _    name = input('name: ')
5 ^2 O7 Q1 r4 j* I) m6 L9 a2 O    pwd = input('pwd: ')
0 p7 ]  k$ G" \' g+ N5 K& q9 J    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
1 `$ G. n# G$ x        print('ok')
% c) ^: P) I" l    else :
        print('error')
% T3 B9 [' f) r3 _+ @        count+=1
for循环
3 I5 o/ Q" P) y% g! \; l8 Kfor count in range(3)  :
    name = input('name: ')
    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
: [- |& L$ j8 a: r3 o9 V% k        print('ok')
5 l, H7 o1 S: S# I3 Q    else :
( \+ j! Z9 j$ h" U2 o. @6 }        print('error')
% {, _$ \# d3 d" M        count+=111、写代码
3 ?% I; S, r( Y( ^: G! Q6 sa. 使用while循环实现输出2-3+4-5+6...+100 的和
# {" Y- E9 s, G! N4 W! Z7 Z2 `count=2
num=0
while count<=100 :
    if count % 2 ==0 :
        num=count+num
: |5 H1 f8 }+ `6 o        count+=1
    else:
        num=num-count
        count+=1
9 N7 s- Y+ D$ y8 i; @2 eprint(num)

b. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
num=0
count=1
- ]% M& w! Z$ D4 k  ?  O  g! Afor count in range(100) :
    if count % 2 == 0 :
; t0 k& u  _" }/ p, Z        num=num - count
    else :
- Q6 [" Y9 s. J/ M$ L; B# R$ Q' R7 E        num=num+count
. O. P" A% x  {4 L9 A- vprint(num)

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

% h0 j0 `% K- C" r" S' I- \count=1
while count < 13 :
    if count !=6 :
        if count !=10 :
            print(count)
3 c. d+ u9 j/ R) L
    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
for i in range(101) :
    if i %2 != 0 :
1 L6 G% G: i/ ~% c2 C, P% x        print(i)

count=0
$ T% g; c! Y) F$ l+ q7 O& xwhile count<100 :
    if count %2 != 0 :
6 _# C/ D' }, N7 g+ S$ _        print(count)
: E$ ?2 E7 `) h. J$ _1 q# n0 y* X    count += 1
8 @6 o7 C; V" B0 b" E8 h9 O
9 a1 o/ H& t9 M) j/ x& me. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
    if i %2 == 0:
1 ^5 x% r( K. L  D+ |- B/ W2 g        print(i)
3 S, X! q5 {8 j1 Z3 {. ^$ ]0 u
count=0
4 i* }" R4 r& b  W1 zwhile count<100 :
+ v+ p( `1 }! G, C4 T7 `! ?% J7 v/ h    if count%2 == 0 :
        print(count)
    count+=1
% l: H( F3 Y. k2 z+ {( n2 _4 {
+ X- m  y; h1 Z5 ^5 y- @8 L12、分别书写数字 5，10，32，7 的二进制表示
. E7 ]2 j; U6 n8 i1 |: {! K+ ^
print(bin(5))二进制   0b101
print(hex(10))十六进制  0x5
* P7 v* I) r% \! j! i3 jprint(oct(5))  八进制  0o5
14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

6 Z1 S3 k' q  L. z+ g- N# c3 A16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

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

18、布尔值分别有什么?

False .Ture ,或1  和0

- Q+ `1 q9 A; n2 s+ j8 a+ y% Q20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
a. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())
+ Q, k4 d4 `! H
- H6 _* e* J$ j! wb. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
0 Q* ?$ A9 i' c8 |2 t1 Z: xprint(name.startswith('al'))
c. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
d. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
+ [3 w5 T! U- ?' g  z, u, aprint(name.replace('l','p'))   apex  
/ y. _% w$ e; F/ N1 e4 R  Ee. 将 name 变量对应的值根据 “l” 分割，并输出结果。
print(name.split('e'))   ['al', 'x  ']  列表
- w$ ?+ P* u9 [9 p$ }- z/ L
g. 将 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 循环每一个元素?
依赖索引
2 w3 c3 }; t. I5 Nname = "Alex  "
for i in range(len(name)) :
  A' \" }- k6 D/ I    print(name)
2 `4 ]$ ?7 {6 n5 P# w  K4 W1 vfor i in name:
) I. [5 _; ?" u8 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']
1 c2 G+ n1 M" Y8 g  f+ d1 Tprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
print(li)
['alex', 'eric', 'rain', 'seven']
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
; ^- W9 R2 u5 vprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
5 E  J8 u) C6 w8 k9 J  N/ jprint(li)
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
li.pop(1)
7 @+ W2 V1 i" _: t7 {7 \6 eprint(li)    ['alex', 'rain']
指名道姓的删除li = ['alex', 'eric', 'rain']
+ T! A4 G+ f' u; ?2 Q/ |" Wli.remove('alex')
3 Q* |, j" n7 h4 h0 {2 q/ hprint(li)
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
( N8 B5 f  N+ p9 J/ c, f' J) lprint(li.pop(1))
; n4 m  T- h; {0 n7 p; a* Xprint(li)

8 U6 i: B& o3 }6 h! F# g7 heric
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
: _8 b* i* x" _6 c1 c/ U2 {7 Bdel li[1:]
& f8 A+ l: }) I  P( Zprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
li = ['alex', 'eric', 'rain']
for k,v in enumerate(li,1):
    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
0 ~3 ?% f, L3 D7 F; Fa. 请输出 “Kelly”
! k) V0 C: A+ v0 gli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
5 O; \6 o( J- _: G0 v& mprint(li[2][1][1])
& [( G% |& ]* _( l& b  {# H; b3 Gb. 请使用索引找到 'all' 元素并将其修改为 “ALL”
& d5 u4 F6 }! u, J, B* Zli[2][2]='ALL'
# \8 g+ Y( F/ o5 oprint(li)
) B( U. {& R* G, [$ B# x. J4 R+ k24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
print(len(tu))
b. 获取元组的第 2 个元素，并输出
# F. ~% p" i3 M. ?6 @2 kprint(tu[1])
3 f; U9 z9 j: A* ye. 请使用 for、len、range 输出元组的索引
for i in range(len(tu)) :
    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
for k,v in enumerate(tu,10) :
    print(k,v)
10 alex
11 eric
# ]9 h3 @9 A( o, n/ t12 rain

for k in enumerate(tu,10) :
8 u! R4 u0 I6 M. y9 D( q( t. M. U2 T    print(k)
(10, 'alex')
(11, 'eric')
. T- ]# w7 ~& X3 H" v# }6 _; d6 l(12, 'rain')
! A6 l# P( J* z5 ?

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

元组，不可以

d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
0 \6 E% _. K1 k$ K5 l; Mres=tu[1][2]['k2'].append('seven')
$ I) J6 c; {5 ]0 P1 h: g
print(tu)
26、字典
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
    print(i)b. 请循环输出所有的 value
) o( u" }: q5 N. i3 ]$ i! [: kfor i in dic:
- x( l/ M( `- v* M+ o7 e2 Y    print(dic)
c. 请循环输出所有的 key 和 valuefor i in dic:
print(i,dic)
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
dic['k4']='v4'
4 H# ?! K& T7 k1 W6 ^1 J$ h# zprint(dic)
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
4 G0 Q0 r7 Z: b! Ndic['k1']='alex'
0 q) W7 Z2 B- M! z$ M0 B5 V+ {print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
' V6 \% P+ o. n& p! i9 H0 cdic['k3'].append(44)
+ O9 R/ T4 K5 K4 ]0 c4 v- _print(dic)

* |! H( H0 m0 |g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
" V$ O$ Q" P8 f! J1 W7 k7 ?. u8 x3 `7 pdic['k3'].insert(0,44)
print(dic)
! u& z; ^! e& s& E' e: G  i27、转换
a. 将字符串 s = "alex" 转换成列表  s = "alex"
% ^3 W0 a* }! z; z- {
print(list(s))b. 将字符串 s = "alex" 转换成元祖
s = "alex"
print(tuple(s))
" I  S7 U) Q6 ]" G
) c/ b3 v7 ~& U; W; ]3 Qb. 将列表 li = ["alex", "seven"] 转换成元组
' ?. p& m8 g9 p, d( Q' w0 dli = ["alex", "seven"]
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
1 w+ {6 V: \& gtu = ('Alex', "seven")
li=list(tu)
4 ^+ @" D" ~- |% f" s+ G: ^/ o8 ^print(li)

- A$ {' z$ @6 \
" \" U( x/ Y/ M* u/ ?+ M- K) Zd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增

dic={}
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
    dic[k]=v
    print(dic)27、转码n = "老男孩"
$ G4 x* t. D' y, T' Pa. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
a=n.encode('utf-8')   
print(a)
$ {* f/ [  D: E( Rb=a.decode('utf-8')
9 Z0 t0 Z3 D. u: W9 cprint(b)
/ W# |: N# i8 b6 h" A  i; mb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
! o' u/ m3 x; s. Z3 j. [- Dprint(a)
; N5 l% g8 W( p1 F. D8 Y5 H% Zb=a.decode('gbk')
. s2 W% ~/ T/ c/ l. g( G9 N' eprint(b)28、求 1-100 内的所有数的和
+ ]$ s: o8 ~& k) `count=1
sum=0
for i in range(100) :
: S* d3 g; ~% H7 s' P1 z+ q    sum=sum+count
/ Y9 m9 p. l! ]  ]3 n" \$ ~    count+=1
print(sum)
' O( J' M/ I( `
! K  J( f6 y+ [count=1
sum=0
while count<=100 :
    sum+=count
; i7 ~3 }$ X, i- D+ j    count+=1
; {1 {3 E9 \1 S7 ~: bprint(sum)29、元素分类
/ y4 T, y0 r2 N2 ]# w; Z: f有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
将小于 66 的值保存至第二个 key 的值中。
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
' f4 O& N1 u" K1 ]8 F$ k& h1 Ili=[11,22,33,44,55,66,77,88,99,90]
) B0 z! Y9 R% m: Ydic1={
    'max':[],
    'min':[]
& e6 t' s3 |6 r3 _1 K}
for i in li :
- ~4 X0 ^0 k! S  z    if i <66 :
$ W* {1 q% \9 ^) O        dic1['min'].append(i)
    else:
! O, v& x% l( e( p" M" B( v& K8 h        dic1['max'].append(i)
6 T  i) d- G7 ^6 v1 `0 e$ j) r4 [/ ]print(dic1)

& ]2 E2 ?& E! i' j9 ^2 {2 X5 O---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
4 x; I- j2 K3 D