Python基础知识汇总

1.执行脚本的两种方式

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

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

2、简述位、字节的关系

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

& \( t& w5 U# E# ]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

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

单行注释  #

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

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

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

不能以Python的关键字命名，

能表明变量的意义

8 A* ?) o* p+ f1 N8、如何查看变量在内存中的地址?
2 j( U, i8 m% K# Z; A5 o6 E9 Nz=1
print(id(z))
9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

4 w  o$ m% z, a% n5 v7 M10、写代码
a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
3 T  [1 P" C6 s! Q6 |name=input('name:').strip()
: `. S( w- w; N  |. ^pwd=input('pwd：').strip()
  {- A# R- C1 B# m* ?if name=='seven' and pwd=='123' :
9 `2 l5 I  k3 ]* C. V% k3 @6 K    print('ok')
else:
    print('error')
8 P3 R* s, V' d
b.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
count=1
while count<=3 :
$ c7 r; w! H: V2 J4 v8 i, V3 s( V    name = input('name:').strip()
6 S  i$ g; O' S    pwd = input('pwd：').strip()
# v4 O8 b* J! [3 @6 @+ U
    if name=='seven' and pwd=='123' :
        print('ok')
    else:
) z8 R9 @% |$ U        print('error')
# C9 [( j: X4 C+ D' H        count += 1
for循环：
for count in range(3) :
    name = input('name:').strip()
    pwd = input('pwd：').strip()
4 Q& q; Q. f  C3 }
  M; q1 H9 v6 J! H% u# B& R    if name=='seven' and pwd=='123' :
        print('ok')
    else:
: o  Z! M& k! u) l        print('error')
- N' @* ]% f. L/ B5 ^0 l$ C        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
count =1
while count<=3 :
    name = input('name: ')
& Q* M$ P9 Q9 w; A7 c    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
4 R1 g2 O% V* E! I    else :
        print('error')
        count+=1
' z. A* q( z# ffor循环
/ Q+ [: g. f6 t/ sfor count in range(3)  :
2 B7 I$ S) h  U) b- y5 v( l    name = input('name: ')
& P  E' T5 E+ o! C  `    pwd = input('pwd: ')
6 s6 f, w  d4 }, P7 m+ Z! u( \    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
    else :
* F$ E* R; G9 Q. _        print('error')
& W2 C; ~2 N; R# Q" c        count+=111、写代码
a. 使用while循环实现输出2-3+4-5+6...+100 的和
; Y2 G2 Q+ x3 z4 V4 r" Wcount=2
; x! b* c6 e# {% `1 V8 _; u/ [num=0
6 [. f. K2 X1 Jwhile count<=100 :
) B3 Q  L, A) c4 ?) Z; e    if count % 2 ==0 :
        num=count+num
  Y, d" w- G" j9 g9 z* p8 A        count+=1
    else:
" Y* v8 c+ V0 {  p" \0 `9 \% ]1 \        num=num-count
4 l1 r1 b1 r) I, Q' f        count+=1
print(num)
, v- B2 x1 q# a7 }5 W
+ \* J! F3 @/ lb. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
; Y6 F2 J, b' G9 f: M$ ~8 a num=0
! o! D2 Y4 E4 p- }, y5 }5 pcount=1
  M8 c7 T( V  ]4 Y# K" Cfor count in range(100) :
    if count % 2 == 0 :
& v9 h; ?6 G, Y! l        num=num - count
- [. [" f: T: a0 g    else :
        num=num+count
print(num)

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

count=1
while count < 13 :
    if count !=6 :
: Y. h& a  @6 t' F9 B: u        if count !=10 :
            print(count)
6 H5 W6 f$ q. s* H
    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
for i in range(101) :
    if i %2 != 0 :
        print(i)
: I3 q8 ]0 Q0 {
count=0
: {) A, ]! _# G" d  ]; Iwhile count<100 :
6 b, l3 d$ m- J6 }, g2 E* T! i+ P  J    if count %2 != 0 :
+ I/ g- v6 y8 D7 s        print(count)
    count += 1

e. 使用 while 循环实现输出 1-100 内的所有偶数
( ^# E6 K* @* t" c7 N  f; p3 Ufor i in range(100) :
    if i %2 == 0:
+ m* g7 @0 ?" H) s$ n        print(i)
! q! r& c- a  h3 m, T6 Y4 ~
8 A4 J$ Y& Y* t- ^1 kcount=0
while count<100 :
5 s- ^6 t& G* \) d0 T% `    if count%2 == 0 :
! O+ E/ f# [9 a        print(count)
' K0 S! p5 R& h    count+=1
2 K/ w  d0 B- E0 M" I
, O2 B- h7 U) p: j: z5 b# R% E. X12、分别书写数字 5，10，32，7 的二进制表示
% W8 B3 O$ G- v' ]0 ]2 q5 v
3 n( s! t! Y3 [  ]" B& A, p' jprint(bin(5))二进制   0b101
print(hex(10))十六进制  0x5
print(oct(5))  八进制  0o5
14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

# o# X( x) d' a1 E5 i& V; _. L16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

n1=5
! I* m- S( q' X* D4 U; Jprint(int.bit_length(n1))  结果  3

2 c' ^5 X% l  L- R, T8 c+ r
18、布尔值分别有什么?

False .Ture ,或1  和0

20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
a. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())

b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
+ E# U+ q6 H' B! R6 N# }; }print(name.startswith('al'))
c. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
d. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
print(name.replace('l','p'))   apex  
e. 将 name 变量对应的值根据 “l” 分割，并输出结果。
) m4 w% e! w2 D' d/ l8 G2 o. X$ Kprint(name.split('e'))   ['al', 'x  ']  列表
! K( @/ T9 R4 b3 D2 E0 e
" U7 f3 U' w( }# T' wg. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])

' F1 T& l6 ~" a; V7 y  Ij. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
依赖索引
. S' Z- R' x! S7 O  Rname = "Alex  "
  P- p4 z( [) Z! l6 Q8 ufor i in range(len(name)) :
    print(name)
/ k7 d4 t0 R% ^1 K1 Q1 mfor i in name:
" U; B4 w1 x5 u5 C2 f( C    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
6 S" f% \) F2 s( T, Eprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
" G7 [, l3 i' Iprint(li)
! N& W+ c8 v  z- n7 y  l ['alex', 'eric', 'rain', 'seven']
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
print(li)
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
9 M8 u) X/ H& c2 Z/ }; G( ]0 Xli.pop(1)
# B  Q) p3 q) T3 o+ j5 ]print(li)    ['alex', 'rain']
指名道姓的删除li = ['alex', 'eric', 'rain']
  M$ z& Y- L: qli.remove('alex')
2 Y8 ~" @* ^; cprint(li)
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
/ @' j6 m+ _# K1 K' z% I3 O& @% o' Yprint(li.pop(1))
5 D. {5 v3 I! |4 M7 d; \print(li)

( x2 R! J3 H$ ^" y; y% ]/ veric
( ]+ I( r/ I" _" S. [0 i+ ]['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
del li[1:]
print(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]
a. 请输出 “Kelly”
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
print(li[2][1][1])
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
li[2][2]='ALL'
print(li)
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
4 b$ g/ g$ P' {6 Za. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
4 X; _1 a/ B% p& U$ h- xprint(len(tu))
b. 获取元组的第 2 个元素，并输出
" p9 R! G8 m& ?print(tu[1])
/ L, \9 K# V$ he. 请使用 for、len、range 输出元组的索引
for i in range(len(tu)) :
2 D: S& T) g7 K    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
8 W1 C2 g* a+ l9 d0 Q  z' wfor k,v in enumerate(tu,10) :
    print(k,v)
10 alex
2 S1 b6 R( z4 e, ~11 eric
) B- n- K5 \- `4 q12 rain
8 I. z  W( e: V( w  L- t* z
for k in enumerate(tu,10) :
    print(k)
# J# e0 w. L6 k/ ^: l(10, 'alex')
% i2 W2 X& ~" W* i6 k3 r2 {(11, 'eric')
8 G$ a* p& C( u2 o- C" A$ A9 w4 p(12, 'rain')


25、有如下变量，请实现要求的功能
0 G: c  {5 p, Gtu = ("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])
res=tu[1][2]['k2'].append('seven')
5 l) b3 q. C( N" p3 B% p& ?
print(tu)
, `/ U- Z  m* M1 [6 ?4 c! @! k3 r9 P  M26、字典
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
    print(i)b. 请循环输出所有的 value
for i in dic:
    print(dic)
c. 请循环输出所有的 key 和 valuefor i in dic:
3 y4 x) l) _" L3 pprint(i,dic)
! \& z' J; r* i: P: B9 Q- Ed. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
3 [) j" _4 J6 S* E# {dic['k4']='v4'
7 U: O% ^# {; ~: o, X5 _print(dic)
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
dic['k1']='alex'
+ p3 E  M4 Q0 ~4 G; j0 sprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
dic['k3'].append(44)
+ A9 y* y7 S+ O' O+ C% B9 T1 Z9 Mprint(dic)

g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
% _/ _# k4 w8 Z- N. Q+ ydic['k3'].insert(0,44)
% J$ t9 i+ w+ @, q% Bprint(dic)
, G7 Q* \9 l) v  X5 m- k27、转换
a. 将字符串 s = "alex" 转换成列表  s = "alex"

print(list(s))b. 将字符串 s = "alex" 转换成元祖
( A. u- h4 O- p4 fs = "alex"
9 F& S4 n$ X  W; S* v/ \print(tuple(s))
' n2 k* b7 \, g0 L( @" Z
b. 将列表 li = ["alex", "seven"] 转换成元组
' d" k. p8 @* Cli = ["alex", "seven"]
4 i2 K2 R/ f1 {* uprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
tu = ('Alex', "seven")
1 d5 L% }7 K0 P5 z. ?' d2 ]$ yli=list(tu)
print(li)


. G% i5 r8 X4 G  x4 G9 t+ x/ P& c' xd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增

( e( z4 X8 l$ b3 Idic={}
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
    dic[k]=v
4 n0 e1 Y- v. p8 H5 U    print(dic)27、转码n = "老男孩"
' y& X5 J0 I/ E4 L% ta. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
a=n.encode('utf-8')   
print(a)
b=a.decode('utf-8')
, a7 ]# M# T2 Jprint(b)
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
print(a)
' S& Y, T2 C4 f, ub=a.decode('gbk')
+ T; K: C& y" N/ X5 [print(b)28、求 1-100 内的所有数的和
count=1
sum=0
for i in range(100) :
0 I7 f8 J& N# P    sum=sum+count
- ]+ Z3 k' P( ?3 _, _; W  B% i* k    count+=1
7 h5 w6 C6 o7 f' `. m, B, X* @print(sum)

0 }! Q! s) Q4 z9 l1 c, xcount=1
2 t1 g& S& f- f) u4 y( esum=0
+ M6 q& e' K+ B  m  z, e3 z5 |while count<=100 :
0 v& q& ]- a; _2 n1 q" |    sum+=count
, c8 _. y  {1 l0 s1 U1 ]    count+=1
8 V9 a) g( D9 xprint(sum)29、元素分类
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
3 u! ]3 ?8 r5 s8 n0 P将小于 66 的值保存至第二个 key 的值中。
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
li=[11,22,33,44,55,66,77,88,99,90]
dic1={
- b* V& y. j' o! Y. f7 n2 l    'max':[],
( Z( c* x5 U0 o8 @, s    'min':[]
}
- J5 }# n4 v! x" afor i in li :
: Z4 r& u+ o8 u; [/ \    if i <66 :
        dic1['min'].append(i)
    else:
2 V- n6 `9 v! }) H1 K+ x        dic1['max'].append(i)
5 d& Q' c: S2 n2 g' Vprint(dic1)
. U1 T6 @- Q( G1 T% O) u* g: f
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}