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个字节代表一个字符，

1 c9 T; M! Q" U) O- }  I0 v4、请写出 “李杰” 分别用 utf-8 和 gbk 编码所占的位数

utf-8    是3 bytes=24bit

gbk     是2bytes=16bit

5、Pyhton 单行注释和多行注释分别用什么?

单行注释  #

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

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

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

不能以Python的关键字命名，

能表明变量的意义

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

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

; m2 F5 R( [5 t% p7 D10、写代码
6 ]& k+ \; }6 ra.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
; O, A# c. `$ D9 ]0 R) A- S5 qname=input('name:').strip()
% K1 y) E# B! |# s! Q: S0 ]- u; Ipwd=input('pwd：').strip()
  ]0 Y4 P- i! \% J4 I: l& n0 Jif name=='seven' and pwd=='123' :
    print('ok')
; U, H8 A! P5 L" j1 q7 M9 ?. V. `else:
    print('error')

, `- e  v, t. Q) t  Q+ k+ _+ vb.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
count=1
while count<=3 :
  h" R+ _; \! C8 u* d* B    name = input('name:').strip()
    pwd = input('pwd：').strip()

    if name=='seven' and pwd=='123' :
        print('ok')
    else:
        print('error')
        count += 1
2 _/ }  v$ s1 p6 O/ h7 i2 Vfor循环：
( Z9 z& f+ G' s% A. Z  m# b& @, @  ~  vfor count in range(3) :
    name = input('name:').strip()
    pwd = input('pwd：').strip()
1 o+ }* R5 o! s7 Y" p+ L# l% W
8 g' S6 f3 Y1 f* d, c/ _3 P    if name=='seven' and pwd=='123' :
        print('ok')
    else:
        print('error')
  ~% c  O  h. a( h. l6 V        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
count =1
while count<=3 :
    name = input('name: ')
0 G( ^# y6 Q' ?1 \/ n    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
* V* g; T$ `$ d        print('ok')
    else :
        print('error')
        count+=1
$ D+ S, L/ q# h4 K* Cfor循环
for count in range(3)  :
    name = input('name: ')
    pwd = input('pwd: ')
1 c* l4 ?% U6 v' [    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
    else :
        print('error')
        count+=111、写代码
0 @; _% h. U2 J: t1 x: Na. 使用while循环实现输出2-3+4-5+6...+100 的和
count=2
4 X# a0 H% c* C8 [9 V7 Bnum=0
2 g5 A. \+ o7 V% Ywhile count<=100 :
! ?  S9 m4 E% A: @7 a    if count % 2 ==0 :
, \6 R2 R8 N; \        num=count+num
/ Q! R) Q0 o) a2 }        count+=1
    else:
" Y# p6 u% l3 B+ p( R# B        num=num-count
        count+=1
print(num)
* y5 T3 t$ U  ]" _/ I
b. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
num=0
% e8 z7 F( g5 n! kcount=1
9 U( Z4 l$ K9 b3 h3 afor count in range(100) :
    if count % 2 == 0 :
        num=num - count
1 M) t: B  G# a1 M: j& z! j! C    else :
" M5 |3 h. A  K& H        num=num+count
print(num)

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

* S' V* O4 r3 M5 M; ^& H& d8 Ycount=1
" `: F) c  H& K) u! g+ I5 twhile count < 13 :
: J- [$ p" K2 L5 b9 |+ N2 }    if count !=6 :
        if count !=10 :
4 ?' J' @6 F! Y& y3 f, a1 w4 x            print(count)

    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
: ?5 t& S6 q+ K6 e5 }, E8 K+ |for i in range(101) :
    if i %2 != 0 :
0 p; `; c' S3 o! Z, F  f0 _& G        print(i)
( S3 f7 Q( B' w3 C  r: g" d! D0 I
count=0
" V3 f! U5 V: m0 F5 Twhile count<100 :
    if count %2 != 0 :
$ f6 K9 Z: g. i7 Q; n, [        print(count)
+ Z8 }5 _' m+ c+ L" |4 |; }8 a# R4 B) u    count += 1

( Y! l7 @. Z: a7 N0 t# i+ U9 ve. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
. }* G, S# X4 {* T: k1 R    if i %2 == 0:
        print(i)

7 f% p, l, y# B7 j7 x2 E' E% ncount=0
while count<100 :
    if count%2 == 0 :
6 j! I6 [2 d6 v, ^  g* e        print(count)
! ?+ Y. [2 [+ C    count+=1

12、分别书写数字 5，10，32，7 的二进制表示
. t/ S6 [+ r, f, O
print(bin(5))二进制   0b101
print(hex(10))十六进制  0x5
# o' `' |7 A) R0 m' cprint(oct(5))  八进制  0o5
% D: r5 B0 Z2 P) H$ q) a! {  t14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
7 e& C# g0 k# `8 S7 n% H, F1 ~4 `17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

n1=5
+ w/ c$ d! n0 b" p$ Y4 y# mprint(int.bit_length(n1))  结果  3

- Q; }3 }9 [9 M% E+ Q
18、布尔值分别有什么?

False .Ture ,或1  和0

20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
2 E! x% _- v( P/ Qa. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())
3 B- W  Y: l5 G
: D3 u: N1 P4 ob. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
+ J% g7 r9 c3 e. @1 o- d. Eprint(name.startswith('al'))
c. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
) z7 T  ]# `" e9 P; n. q* s' Md. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
print(name.replace('l','p'))   apex  
7 U" X, f. Y! e! M7 l5 ae. 将 name 变量对应的值根据 “l” 分割，并输出结果。
$ O2 ?: a/ {+ x7 uprint(name.split('e'))   ['al', 'x  ']  列表

/ Y* O1 u7 m$ gg. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])

' s* Y$ i+ D. {1 c3 Rj. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
' y1 T$ Z: h( Z21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
依赖索引
1 D! R2 G9 {" U- Wname = "Alex  "
for i in range(len(name)) :
- X: X2 q1 M9 Z, [* V, t    print(name)
, Y9 ?5 k, `. G2 X9 {for i in name:
7 z1 f1 ]: M8 @" N6 f# J    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
" ^0 G2 }$ V/ k4 F: f) H( mprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
print(li)
: R1 w$ ~9 S/ {; t) w' {) H ['alex', 'eric', 'rain', 'seven']
) y2 R+ X' q# f& E( n) r% h; U% ^c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
8 g# w. Y$ v$ W3 H. H: Lprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
$ f5 H) o" t0 L, }1 pprint(li)
& M: M9 ]" t  O" I. ?0 Le. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
) E7 E) s; U( t- \li.pop(1)
" @: |5 [  J0 N# p) wprint(li)    ['alex', 'rain']
指名道姓的删除li = ['alex', 'eric', 'rain']
/ u/ @4 J) p- s" N% N" N% Lli.remove('alex')
print(li)
' [: }. s0 z+ [3 cf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
print(li.pop(1))
print(li)
4 j' N  J1 C) T' S! I! v
% Z( q# [2 X' B7 k+ a/ n" leric
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
/ _' C7 \+ z! P2 ]: }/ Q3 _del li[1:]
- }4 G, Y) U  x# l& Bprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
. R6 F3 d( f% O6 |7 pli = ['alex', 'eric', 'rain']
9 J1 b2 U$ J3 w1 _: O+ b+ Bfor k,v in enumerate(li,1):
7 \/ e1 a8 Z! Z  K" A! |& C    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
a. 请输出 “Kelly”
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
7 t" T. }$ q8 z  s  \print(li[2][1][1])
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
li[2][2]='ALL'
print(li)
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
4 W' e# P" p$ B5 p0 X% nprint(len(tu))
4 a* Z) G" z( D5 S/ eb. 获取元组的第 2 个元素，并输出
8 _- P" h# C& C) z( r8 d; Tprint(tu[1])
- U' ^$ t- E) M% y, Y' b  r, v& J6 t3 |e. 请使用 for、len、range 输出元组的索引
0 E/ d4 A5 a" I' k1 F/ K( p* Jfor i in range(len(tu)) :
7 d* T/ h% I! \7 k: T! p8 `    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
for k,v in enumerate(tu,10) :
    print(k,v)
10 alex
% O: W, r6 u# G2 t& J! U! f11 eric
; |" M; f5 r* W( L- o12 rain

for k in enumerate(tu,10) :
! G$ o- C4 ?. K4 w    print(k)
& D8 o# {8 r* I(10, 'alex')
+ r. I; j* o" o(11, 'eric')
(12, 'rain')
  S+ l  `; _) G8 _5 O6 T' _  q

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

元组，不可以

3 N4 y; v) m% `9 g- F7 X# V" Hd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
. y( `" B4 c" r( p. [9 Itu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
7 A$ f* @6 S$ d4 R3 Lres=tu[1][2]['k2'].append('seven')

print(tu)
26、字典
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
    print(i)b. 请循环输出所有的 value
: O1 P/ S% B4 p9 b. j4 ]for i in dic:
    print(dic)
  U9 i/ M5 d6 s2 v0 N5 `& cc. 请循环输出所有的 key 和 valuefor i in dic:
* r" c" _' M+ }* I2 H& l6 N3 U4 @print(i,dic)
$ @1 \4 X+ ~! ^7 ud. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
dic['k4']='v4'
; y+ P: k5 M1 n' Xprint(dic)
% P  v' }: ~; Ve. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
dic['k1']='alex'
; b- P. n* @4 q( |print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
- y0 ?) h* W) m) L7 {8 y# S5 v  U. Ndic['k3'].append(44)
' U+ U2 W4 ^& H  f5 p2 oprint(dic)
9 q5 _' R  S+ Z, z! c
1 M5 ~& t8 u' y% g7 \g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
dic['k3'].insert(0,44)
  T6 f% j; [& L' f9 ~1 }- c" Cprint(dic)
5 [+ z# g9 |! @9 n  `9 y8 Q0 J27、转换
5 ~, p5 Z4 @  ^( Wa. 将字符串 s = "alex" 转换成列表  s = "alex"
$ L7 |$ b3 ^9 ?# V0 s5 E! `
print(list(s))b. 将字符串 s = "alex" 转换成元祖
s = "alex"
1 y" w' X4 E) `print(tuple(s))

, @0 \' Z( ~9 |( C% Ob. 将列表 li = ["alex", "seven"] 转换成元组
li = ["alex", "seven"]
2 W) Q4 C! `' w- W! wprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
tu = ('Alex', "seven")
li=list(tu)
print(li)
9 Q! K, O" E$ i

d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
# ]' J: Y) A! ~! R. W5 ~6 U3 X, A
; o0 \% n2 ^5 X1 @6 zdic={}
& V/ B/ N  a: Y$ ofor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
# Q! q, p1 h4 ^! h# V1 ?% d5 r    dic[k]=v
9 {8 Z: Y9 @: M2 Y8 r% n    print(dic)27、转码n = "老男孩"
6 W' e4 r) t% S) R3 h0 |a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
5 W& h5 B- Q3 l6 f- l6 Ea=n.encode('utf-8')   
: ]" U$ ?! k+ f, m/ |: p7 }print(a)
b=a.decode('utf-8')
print(b)
& r- L% y5 s, M) R, zb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
print(a)
b=a.decode('gbk')
print(b)28、求 1-100 内的所有数的和
count=1
sum=0
for i in range(100) :
( C8 p+ V% |* c# A  [1 |    sum=sum+count
    count+=1
print(sum)

% }$ n/ v- J7 \, }: icount=1
sum=0
while count<=100 :
    sum+=count
    count+=1
9 P$ p4 m6 C- Y: x! f9 mprint(sum)29、元素分类
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
/ ~" v/ u# b: d+ K将小于 66 的值保存至第二个 key 的值中。
/ H# H% r. ~$ H8 |# o# F# r' k即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
li=[11,22,33,44,55,66,77,88,99,90]
9 F2 v1 ~) [$ x( t2 U- K8 j- e; Z! Vdic1={
    'max':[],
0 [# n% |" l6 X  Y    'min':[]
" P4 l7 y+ w, u4 a' v4 `- r1 C}
5 N- R4 I! y) T  X# l* A) efor i in li :
    if i <66 :
        dic1['min'].append(i)
* U4 }; }. L7 W* n6 p! U    else:
        dic1['max'].append(i)
' x2 I& X; J0 `& O7 G& Mprint(dic1)
! s' w$ S$ p6 y9 I
/ M( y2 @6 R1 f* T: B+ m. B---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}