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

2 m( ^% I% z! @6 t. m5 k. D4、请写出 “李杰” 分别用 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文件后的二进制文件，用于加速运行

10、写代码
. F% @; s% ]. J  g4 o, Va.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
2 f  H- ^+ _' E, W: Hname=input('name:').strip()
pwd=input('pwd：').strip()
; ]/ H! l, `9 O+ @4 {" W  R! Qif name=='seven' and pwd=='123' :
    print('ok')
* D' w( y9 ]% r' N  Z* ]1 H1 J5 Pelse:
7 W; H5 ]- d1 z' E    print('error')
( f/ L+ a: Z( O3 g; s
b.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
, G+ g/ m; d- W4 v7 rcount=1
while count<=3 :
    name = input('name:').strip()
    pwd = input('pwd：').strip()
8 }4 R8 I- q( ^* F6 d7 S! y. e/ l
    if name=='seven' and pwd=='123' :
        print('ok')
    else:
0 O6 e" }) @" n" J( Q        print('error')
        count += 1
* E5 c9 x. ]2 ]# g# [$ Hfor循环：
for count in range(3) :
1 W( A3 G2 M8 N6 I+ u    name = input('name:').strip()
    pwd = input('pwd：').strip()

; j7 v) ^; T: Y7 z) \5 g    if name=='seven' and pwd=='123' :
        print('ok')
    else:
* T) S  ?% J3 G& ?% a! J        print('error')
% j6 {" C' n0 O) w7 E        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
/ G; H$ s, G% Z2 Icount =1
- R# Z: Q5 M) f+ `/ iwhile count<=3 :
* n/ f! U& @, B! ^    name = input('name: ')
9 d- L- y! Z. w    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
, s7 _! l1 W9 [3 S    else :
        print('error')
        count+=1
+ L# o: Z; R: Pfor循环
4 @' _$ W9 O: Y5 |% ]for count in range(3)  :
    name = input('name: ')
    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
+ G" O: {7 h3 K( c6 F        print('ok')
    else :
5 E; Q5 X0 \. a  a' _& L8 _3 a        print('error')
# I& T6 @: m8 `: x  D        count+=111、写代码
a. 使用while循环实现输出2-3+4-5+6...+100 的和
" D. ?% I; {" r, Ocount=2
num=0
; A6 V: b0 V9 b' ^; P% e, Fwhile count<=100 :
6 I% w- Q" e# E, z' Q2 Z    if count % 2 ==0 :
        num=count+num
5 q# i( I/ O6 s        count+=1
    else:
+ T5 L, ]$ W5 c0 ]        num=num-count
8 u- P' f3 C9 `. Y' D2 e        count+=1
3 }! [$ Z8 N+ J" x8 G; s/ ~/ K* ^print(num)
1 h6 u  q# I  h) e; L
b. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
num=0
count=1
for count in range(100) :
    if count % 2 == 0 :
        num=num - count
2 J2 S6 M  g+ X9 m! C7 W    else :
/ A: c2 U: _7 {2 F  n7 _        num=num+count
% P! d+ t' s; M9 mprint(num)

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

count=1
while count < 13 :
/ \0 G& W4 P! Q# ]# n9 f: B" H    if count !=6 :
, H# Z1 ?1 `. a# P        if count !=10 :
1 {7 O: K, _  R1 l1 I; B% o            print(count)
% [- H* s( K4 u! A" i/ W
    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
for i in range(101) :
    if i %2 != 0 :
* G# _. g6 \4 q# r7 p0 L% N2 ?        print(i)
( B, h* a4 K& g; y4 p- W2 s: Z
count=0
; y4 a3 G  @& ?% Iwhile count<100 :
$ A- N" U8 Y- ]" [- B    if count %2 != 0 :
" U  Q2 s/ Q8 H6 J$ o" P        print(count)
    count += 1
* K9 k0 {! \/ m& a7 w! d
e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
    if i %2 == 0:
$ h3 L/ a" `3 s0 M9 Q- Y3 A        print(i)

count=0
while count<100 :
    if count%2 == 0 :
' Z" G+ L5 b9 S- N, W9 l        print(count)
- f5 e5 p5 l4 Y/ @    count+=1

7 M6 F7 Z. N6 _5 p1 j0 v) Y12、分别书写数字 5，10，32，7 的二进制表示

print(bin(5))二进制   0b101
print(hex(10))十六进制  0x5
4 y, ~: a1 k0 b/ f8 X: dprint(oct(5))  八进制  0o5
14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
' d! ]2 W/ P0 X( h- @3 G, @17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

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

18、布尔值分别有什么?

False .Ture ,或1  和0

20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
a. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())
) L' C2 E6 ]5 a1 @' m
/ b) M0 R$ q. g- sb. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
: X! o- R( E; }3 X% |- |1 T- |print(name.startswith('al'))
6 t) Y! `$ g& L: f7 J$ s" U' `( {c. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
d. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
* D, |) [0 b1 gprint(name.replace('l','p'))   apex  
7 `) r. [5 A% B* j( ]7 Pe. 将 name 变量对应的值根据 “l” 分割，并输出结果。
2 p" R0 Y' w3 A0 H' l% Rprint(name.split('e'))   ['al', 'x  ']  列表

, r: O$ s. j! |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 循环每一个元素?
' y6 d& L3 C4 ^依赖索引
name = "Alex  "
( m0 F) Q2 f3 Q3 q5 e0 }for i in range(len(name)) :
2 B2 O) x/ g1 V8 ^) g    print(name)
for i in name:
9 ~/ M% Q3 U7 }. `' H    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
8 \! a4 \. m; u5 G3 W7 I# h7 v5 Eprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
print(li)
0 `; D0 |" _2 s9 v/ h ['alex', 'eric', 'rain', 'seven']
% `7 h) V; B0 d! l+ c6 X8 x% rc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
- [# A2 ^" D/ H' g8 Eprint(li)
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
li.pop(1)
( J& j9 C/ u, S% }+ Z/ v- bprint(li)    ['alex', 'rain']
/ `/ k- m: y( {7 N指名道姓的删除li = ['alex', 'eric', 'rain']
2 R8 g9 a, V) d# T' cli.remove('alex')
+ t: u2 G% T: f+ {% ?print(li)
- G3 b( s( w  a5 \1 pf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
0 ~4 c  X& L7 m. lprint(li.pop(1))
print(li)
  A8 l* i( T4 [+ K8 b1 m/ g
) {  u8 m0 o6 D! @eric
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
  Q; x  b4 |7 |1 @del li[1:]
4 y/ B5 r0 A$ o' R( Q( Pprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
, M. r- i8 G# \" g  @4 cli = ['alex', 'eric', 'rain']
for k,v in enumerate(li,1):
- l( g" e" s  W. |, b- W- W1 x    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
) B2 _# k+ P8 Va. 请输出 “Kelly”
: z$ o0 _* R) ~li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
- o9 m! s* {4 N( g# k5 Z& tprint(li[2][1][1])
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
/ `3 ?' K; n7 V: K% c# m# Y! Z! @3 Oli[2][2]='ALL'
print(li)
! S$ I6 N4 r7 ~" M% S24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
1 G( ~* I. Y/ v% J# o& `2 J: ba. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
print(len(tu))
b. 获取元组的第 2 个元素，并输出
print(tu[1])
4 H9 n: `6 B5 A6 ae. 请使用 for、len、range 输出元组的索引
6 Z- k2 h: H0 [for i in range(len(tu)) :
$ O  O5 x6 @  Z. W3 \2 @1 @    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
/ Z" F5 K$ c+ M7 X0 e" C1 S9 H# Rfor k,v in enumerate(tu,10) :
    print(k,v)
$ U7 y2 o" O; M2 J. p/ p% ~10 alex
* ?6 h, f/ X5 }$ Q# T$ g; p( ?8 X11 eric
5 C8 W( ]  h6 D$ z& U, N. m+ \12 rain
. s$ z/ ~8 s( P
for k in enumerate(tu,10) :
    print(k)
(10, 'alex')
(11, 'eric')
0 l/ p, U0 O$ {6 ?+ ~(12, 'rain')
2 W" S! d' P/ G( D

$ M5 ^1 r( X$ E- f' S25、有如下变量，请实现要求的功能
! Y. A0 V* H. M1 _/ q( l/ Q2 Btu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

元组，不可以

" W0 Z* D# n( B& S* P1 |d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
: M, {8 T! T$ ctu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
res=tu[1][2]['k2'].append('seven')
) |3 ]6 h& A/ E" @! c: k6 s: v
, p8 K0 z7 b3 \2 Kprint(tu)
  V. f! ]8 O2 q5 T1 N0 D26、字典
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
    print(i)b. 请循环输出所有的 value
  i5 F- P4 y& o! T: r3 r, bfor i in dic:
    print(dic)
c. 请循环输出所有的 key 和 valuefor i in dic:
- E& |5 z( c3 x2 bprint(i,dic)
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
8 K* l5 ]1 V0 [8 [( hdic['k4']='v4'
print(dic)
7 `$ p, G. ~# Xe. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
dic['k1']='alex'
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
2 f) W9 H  q  u# b9 c/ gdic['k3'].append(44)
print(dic)

0 T5 j* ~8 i- n" @g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
dic['k3'].insert(0,44)
' p) |  E& n& l% uprint(dic)
27、转换
a. 将字符串 s = "alex" 转换成列表  s = "alex"
0 ]( J7 f, B* W5 l9 A+ o
print(list(s))b. 将字符串 s = "alex" 转换成元祖
5 R4 ^- h- N7 T1 D: {) z# O# Ms = "alex"
5 t* i, P8 v& N& N: gprint(tuple(s))

b. 将列表 li = ["alex", "seven"] 转换成元组
( P# L4 {: d2 ^0 F' R$ \& F3 mli = ["alex", "seven"]
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
tu = ('Alex', "seven")
li=list(tu)
print(li)
4 E+ J6 s8 d; R+ x- t# X
7 Z0 k8 M9 ^# }9 y
% v1 `) @8 Z0 G& d1 y3 J; Z& ~2 x. Dd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
# l& Z8 x# F6 c) S
dic={}
) i+ p- P4 ?7 x3 O( |* d0 Q7 Jfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
    dic[k]=v
; P3 r) {0 }5 N" B% E1 M    print(dic)27、转码n = "老男孩"
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
, X# H; k  T6 }4 A% L+ Qa=n.encode('utf-8')   
print(a)
. @2 q: l, A7 s+ U  ~b=a.decode('utf-8')
print(b)
) T& f4 a( S8 @$ K8 i* ~* B3 ~b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
print(a)
; q: s+ k( g3 `/ g- Xb=a.decode('gbk')
3 `. [7 k+ v# b2 {( h; oprint(b)28、求 1-100 内的所有数的和
) W. S* l/ i0 y. W0 Z: V3 Hcount=1
$ M7 X& J* ]# C6 u2 ysum=0
for i in range(100) :
7 h2 k1 l3 L2 {7 O6 e    sum=sum+count
# T  i2 o# b0 o# t0 S1 Y/ K    count+=1
print(sum)
$ T- t5 B' C# }
count=1
sum=0
8 t  `% K& m3 Nwhile count<=100 :
8 @2 z5 \  l2 R5 @, X$ U4 P4 S8 Z9 t    sum+=count
/ f5 i% [3 w8 p8 ]) C% R    count+=1
print(sum)29、元素分类
$ a) g! u/ N+ ]: m有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
将小于 66 的值保存至第二个 key 的值中。
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
8 [: D8 ~4 B: f5 B8 l) Zli=[11,22,33,44,55,66,77,88,99,90]
dic1={
    'max':[],
    'min':[]
) K$ k0 p$ M3 [; l/ q& h3 V}
for i in li :
    if i <66 :
        dic1['min'].append(i)
0 T5 V7 b; h2 ^, U) d4 p- }. F3 [    else:
. h, L/ A& ]' ~3 j+ E        dic1['max'].append(i)
0 n/ Y" |$ W# K. a0 c- s5 |print(dic1)
6 G0 N1 N6 O$ f" v- k$ x
9 m8 l5 ]' J8 ~  L. ?0 b---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
% M; }2 j: v* [4 @* K, R( u