Python基础知识汇总

1.执行脚本的两种方式

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

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

2、简述位、字节的关系

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

- S- G* Y% \- n! x+ ~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个字节代表一个字符，

6 Q7 ]) h* I2 E4、请写出 “李杰” 分别用 utf-8 和 gbk 编码所占的位数

utf-8    是3 bytes=24bit

gbk     是2bytes=16bit

3 Q, W1 U7 l0 x0 B' O7 R5、Pyhton 单行注释和多行注释分别用什么?

单行注释  #

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

6、声明变量注意事项有那些?

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

不能以Python的关键字命名，

能表明变量的意义

4 M; \) T2 d' ^* D' ^$ r; e6 }1 R8、如何查看变量在内存中的地址?
z=1
7 ]/ y# H* @/ z+ Xprint(id(z))
9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

10、写代码
a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
name=input('name:').strip()
/ f' ^  c  O: u9 ]( j. [8 S8 d  Opwd=input('pwd：').strip()
if name=='seven' and pwd=='123' :
( y- r6 I& T, u/ ?, b+ f    print('ok')
! P+ `6 G2 H5 @5 f7 Z) j! Velse:
    print('error')

b.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
count=1
while count<=3 :
    name = input('name:').strip()
' }7 w7 o- d# c3 `% F( B  L+ x( w; T    pwd = input('pwd：').strip()
* c7 ~! N% A% }* G2 s+ W
/ u  C1 l! ]0 L    if name=='seven' and pwd=='123' :
& m" {' ^6 V8 |1 _        print('ok')
    else:
% R% s3 W7 P0 y        print('error')
: J4 {  d9 x" b        count += 1
8 `, _5 V" x& c0 }% {for循环：
; b; w* Z* |1 v9 T# g1 |0 Vfor count in range(3) :
' w; t0 H( \. B    name = input('name:').strip()
    pwd = input('pwd：').strip()

! F5 s( P6 m1 ~% I    if name=='seven' and pwd=='123' :
  F; i3 _6 w/ ]+ L0 }9 Q        print('ok')
7 l: R& K% p8 J& k7 S# z    else:
        print('error')
        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
count =1
while count<=3 :
    name = input('name: ')
3 A9 ^% s$ q* H$ `# Y3 l$ N7 ?    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
7 _* s, k/ ?! H        print('ok')
    else :
        print('error')
* q' V7 }6 D: b$ k! V& p2 a# X        count+=1
for循环
3 ~/ u+ N$ P- [( X5 v% i  R7 Q! Wfor count in range(3)  :
    name = input('name: ')
/ M+ C1 R: P) Y    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
2 T7 e, M' w& K    else :
2 d9 D6 ~1 a: I- {7 v        print('error')
        count+=111、写代码
a. 使用while循环实现输出2-3+4-5+6...+100 的和
count=2
) d" Q) Z" ]4 p! y$ Vnum=0
while count<=100 :
    if count % 2 ==0 :
6 }3 {  M( I. m! O* |        num=count+num
9 q, K5 y$ }- F: q! l        count+=1
  G1 K3 [: K% e    else:
4 `) t; p6 P. k6 {        num=num-count
        count+=1
print(num)
* l: v8 o( d" i
b. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
, ^2 r% H. {0 Z' P& U7 S! t num=0
4 \4 X! x& |, J5 s1 R# K; Ocount=1
% l* x6 f" d8 X+ A$ Jfor count in range(100) :
$ m3 \0 |) v+ p- N) h    if count % 2 == 0 :
# ]9 g3 w! @* x        num=num - count
    else :
) H- o7 l4 D( H% [        num=num+count
- H# ]4 J, r0 Xprint(num)

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

6 n) m$ v3 z0 ~3 s  ncount=1
while count < 13 :
4 e# ?# ?" |! d! u+ r    if count !=6 :
: B, e2 l# m8 @9 K, j; A# \' }( v        if count !=10 :
            print(count)
( h- \, S* p: `) V7 u& t: [2 \6 Q
    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
1 u; j6 ]" b2 W5 n4 ]% a" xfor i in range(101) :
    if i %2 != 0 :
! o1 T3 ?# H" u0 p0 ]  O. ?" X        print(i)

5 T) E4 ?2 k% M* Ucount=0
% n, ^- B0 h8 _$ ?while count<100 :
; b$ P0 u" f2 A3 U    if count %2 != 0 :
0 d3 g3 w2 e' X/ w        print(count)
    count += 1
# l1 ~; E( P( M; _+ u5 h
. x7 D0 k, d3 g1 a9 k$ ]e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
: `) q2 D" p7 R& n, Q    if i %2 == 0:
        print(i)
6 F6 W! Z+ A) K+ F5 `
7 F+ K$ x- v/ ]7 h8 N( i" Ycount=0
9 K, T8 X" H9 n) gwhile count<100 :
" I6 H( E. U( G; w    if count%2 == 0 :
# r. a: T8 l* \4 T1 A        print(count)
    count+=1

12、分别书写数字 5，10，32，7 的二进制表示

print(bin(5))二进制   0b101
. j. S7 D/ ^  r/ H: d. Q9 n/ @& _print(hex(10))十六进制  0x5
print(oct(5))  八进制  0o5
14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

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

n1=5
  m  s2 }, |4 c  `print(int.bit_length(n1))  结果  3

, Q, m; p- y7 S18、布尔值分别有什么?

False .Ture ,或1  和0

0 ?: G- h* Y3 _, T4 o20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
a. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())

+ U5 x* e) ^2 I2 Q7 v& Ib. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
" P, W6 {& R" U0 V2 Kprint(name.startswith('al'))
9 y# b4 w7 V5 o& H/ X% G) vc. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
d. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
2 ?% ~4 j3 l2 A2 F  Qprint(name.replace('l','p'))   apex  
7 d2 v- P% i8 Z* d0 d2 Be. 将 name 变量对应的值根据 “l” 分割，并输出结果。
1 A' f% K4 Z+ h  }, \9 bprint(name.split('e'))   ['al', 'x  ']  列表
% G8 u' T, z8 o+ {/ z, \
g. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])
8 i* Y, e5 M. ]1 q# c+ F) f
j. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
  {0 m) p# M( m7 Q  J8 P! @; `依赖索引
5 X: z( A5 B5 Q2 |& j% }name = "Alex  "
8 w/ G+ `& w% U# s; i* Vfor i in range(len(name)) :
/ o! c5 S, \  ^1 r5 {: A9 X: M    print(name)
) E- P. v' P. Vfor i in name:
    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
" P/ R3 ?7 e" E1 K22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
" C5 l3 g* V: a- iprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
! y, G, W+ T, Z3 |% yprint(li)
: W; `! q/ _" I. r8 f, Z ['alex', 'eric', 'rain', 'seven']
8 j  J# a& @% S  `$ `: J8 l7 m2 m% Dc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
9 D4 L) d3 O/ a* zprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
4 }5 g$ A5 l" b, [  z2 tprint(li)
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
: {9 g. d9 D9 A! v. Y8 P! z- Ali.pop(1)
5 A& c! t* G9 ?* d: u' ~, `6 fprint(li)    ['alex', 'rain']
指名道姓的删除li = ['alex', 'eric', 'rain']
li.remove('alex')
print(li)
6 a6 I' @7 S* ]0 ~& cf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
- E6 K5 z9 F+ @- V7 v  q" @  T8 d1 zprint(li.pop(1))
$ y( u& F0 }+ O; C; B# gprint(li)

eric
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
del li[1:]
7 e! D. S- o& ]print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
/ r& a8 {( B) N' J9 o5 ?4 eli = ['alex', 'eric', 'rain']
for k,v in enumerate(li,1):
    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
a. 请输出 “Kelly”
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
0 t+ O  O$ a: q: z7 mprint(li[2][1][1])
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
, m* F* ?# c! Q2 z/ {5 G' [li[2][2]='ALL'
print(li)
2 `& n3 t3 J) X24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
- n0 l0 w: I5 x4 g' Y" _print(len(tu))
b. 获取元组的第 2 个元素，并输出
* G. _) K: V& U$ vprint(tu[1])
e. 请使用 for、len、range 输出元组的索引
for i in range(len(tu)) :
( e5 U* Y2 u2 @' u1 q# }    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
& f& b* f! c- \% Vfor k,v in enumerate(tu,10) :
    print(k,v)
! O2 x3 @1 h3 S# P! ~10 alex
3 K, I3 ?/ h1 |9 [" d11 eric
12 rain

for k in enumerate(tu,10) :
    print(k)
(10, 'alex')
7 x. q+ j" S' D(11, 'eric')
* j- }6 {9 B- U1 i(12, 'rain')

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

元组，不可以

( y4 p, c/ k4 z! W5 w, _" v4 t+ gd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
% L( l7 L) G1 {/ H/ a. Ores=tu[1][2]['k2'].append('seven')

print(tu)
26、字典
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
) L/ }8 A( h) z0 w  T+ T6 X/ B    print(i)b. 请循环输出所有的 value
for i in dic:
    print(dic)
c. 请循环输出所有的 key 和 valuefor i in dic:
3 _" @& [9 V  Iprint(i,dic)
+ L0 ?3 @) g3 [; A5 D1 _; }5 rd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
/ V# q' w9 C- f7 [1 s( g2 y, tdic['k4']='v4'
print(dic)
' D2 o7 y' q! ^e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
7 F0 o; t* m2 F( Rdic['k1']='alex'
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
( S1 Y2 Z6 j+ e3 a6 v' m* odic['k3'].append(44)
print(dic)
+ p+ x) y4 t0 [; K& L
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
( o# \  x3 L. v3 c- ?* hdic['k3'].insert(0,44)
, t) _) f) u! `" a7 Rprint(dic)
27、转换
1 L, M0 z, W/ p: q6 i/ }a. 将字符串 s = "alex" 转换成列表  s = "alex"

print(list(s))b. 将字符串 s = "alex" 转换成元祖
9 C4 j7 J( U) |s = "alex"
4 c% U! C: M, x" h% sprint(tuple(s))
$ P5 x7 f; z2 Z' |1 m4 \5 w
b. 将列表 li = ["alex", "seven"] 转换成元组
2 o) J2 \! }# Q1 k3 N: pli = ["alex", "seven"]
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
% \' F: @6 s: D) Z0 ~tu = ('Alex', "seven")
li=list(tu)
print(li)


d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
% b* \+ y3 m" m5 ?
2 s/ Z2 ^: ?: u( [; Mdic={}
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
    dic[k]=v
    print(dic)27、转码n = "老男孩"
6 D2 ^6 S, x5 V5 ja. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
- E  I+ `, Y  o9 g& n  ]3 z7 |a=n.encode('utf-8')   
: [' `- R" Q( lprint(a)
b=a.decode('utf-8')
print(b)
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
print(a)
7 A7 ]* g( m8 o% o) w; j0 Xb=a.decode('gbk')
print(b)28、求 1-100 内的所有数的和
count=1
8 ?! v* e& m2 S( Wsum=0
for i in range(100) :
+ i3 L: ~+ g+ T+ l4 T9 ~    sum=sum+count
    count+=1
print(sum)

count=1
sum=0
while count<=100 :
    sum+=count
    count+=1
+ S, U$ d! x& Q* n/ qprint(sum)29、元素分类
6 X* e7 N* y7 v- O+ o有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
' C1 u1 }  A# T) u$ n3 y+ V将小于 66 的值保存至第二个 key 的值中。
% X. {$ ?$ E, Y7 w" f. u即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
li=[11,22,33,44,55,66,77,88,99,90]
4 _) A: S) G, x$ b7 f; {dic1={
, C7 N' ^4 ?3 D) d) A9 E( d$ Y  J7 |    'max':[],
    'min':[]
: K, h% }* W6 M+ ]- p}
for i in li :
1 e6 q5 T, o! f$ y5 f9 |    if i <66 :
4 \# x9 i" `9 r1 r# X0 M        dic1['min'].append(i)
    else:
        dic1['max'].append(i)
; M$ i* }% c# R3 y. O/ tprint(dic1)

7 O+ Q# M; L3 I5 R" m4 i---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
4 q5 s) l- @) K4 Q