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

, g* ?9 W# ?4 m4 q' c3 Q* O& }4、请写出 “李杰” 分别用 utf-8 和 gbk 编码所占的位数

utf-8    是3 bytes=24bit

gbk     是2bytes=16bit

# O+ Q0 J6 {. a" L5、Pyhton 单行注释和多行注释分别用什么?

单行注释  #

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

, B; l0 E' a8 i; X+ f6、声明变量注意事项有那些?

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

不能以Python的关键字命名，

能表明变量的意义

8、如何查看变量在内存中的地址?
z=1
print(id(z))
/ N7 E; K" k- h' R3 _4 m! e$ W/ o9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

10、写代码
6 S- b0 t) [( q+ G9 |  S  i; y( Ua.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
name=input('name:').strip()
) V* Q2 L: U2 upwd=input('pwd：').strip()
4 _6 P" t5 _8 o# b8 B; I( Uif name=='seven' and pwd=='123' :
    print('ok')
else:
$ U7 G6 i7 d2 N# j- B7 q  b    print('error')
+ J- l, F# Y( J. i% Y
# c. O/ I: z3 B1 B8 H. Ab.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
count=1
while count<=3 :
    name = input('name:').strip()
) I8 }6 D+ X. ]9 X    pwd = input('pwd：').strip()
: O) a* Q8 n0 I
    if name=='seven' and pwd=='123' :
- }3 i' w; S6 Y8 f6 b3 g        print('ok')
    else:
% {* A1 J$ S" \        print('error')
2 j8 v! x. h* h1 v9 l$ [. H& h. f6 p        count += 1
for循环：
for count in range(3) :
    name = input('name:').strip()
6 v& h* v& b2 U: g6 y1 f    pwd = input('pwd：').strip()

$ Y4 C6 n  l9 a! Q0 r    if name=='seven' and pwd=='123' :
0 u5 n5 ]" x* c3 e        print('ok')
" {: M* E3 R; H9 u    else:
        print('error')
  ]1 z+ s7 G1 X9 f3 L9 T" v) ^" x        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
  S. T% f, I6 G) ]% Acount =1
while count<=3 :
0 {5 o! _" e$ K, P' Z5 o) Z" [    name = input('name: ')
    pwd = input('pwd: ')
/ C  k, s' E1 n: _  }0 B2 R7 k    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
( E" }' `* g$ I9 e; r        print('ok')
4 T& H$ S! g  S. h: r. s    else :
        print('error')
4 j( ^! `* f  ?# K& d& _        count+=1
% @0 r+ k6 f' F8 Pfor循环
for count in range(3)  :
; c/ F% E$ M/ \    name = input('name: ')
    pwd = input('pwd: ')
4 p9 X( @$ z# K: N    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
7 ?3 C4 R* N4 r    else :
        print('error')
        count+=111、写代码
a. 使用while循环实现输出2-3+4-5+6...+100 的和
# m( |& W! o5 }) |6 icount=2
' Q8 L. v% Q$ m$ h- E" _) Q& J, Ynum=0
0 o6 K2 }# ]. N0 W$ z5 vwhile count<=100 :
    if count % 2 ==0 :
        num=count+num
/ P6 \  s6 p. a+ A/ e. j        count+=1
    else:
9 |' [+ w$ N% O" k: z        num=num-count
% |  b  D1 A0 c" [        count+=1
print(num)
) v6 R6 _9 R+ B( b+ _5 ?
b. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
0 x7 ~5 J9 g6 D* f9 M" D7 h! P num=0
count=1
; x9 x/ c/ \4 \for count in range(100) :
    if count % 2 == 0 :
1 w  J5 V; B, j# r        num=num - count
% w% [1 f) `' D. ^# ~/ S0 @    else :
+ C: ~/ a( X( Z8 t# E" J        num=num+count
) Z4 N$ o. P; Zprint(num)

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

count=1
while count < 13 :
    if count !=6 :
' F. E; Z3 c; d+ x7 A) x        if count !=10 :
. E2 P" u* d$ M; |( {4 i: h: Y            print(count)
3 \8 ~1 W2 z% H- P' {! O
' N" |* |/ c& s: Z1 i, S* D3 e    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
; m: u" @' T! ^+ F8 Nfor i in range(101) :
8 K8 C% t) g/ O& K7 a/ s# v    if i %2 != 0 :
        print(i)
9 {! n* ?2 \5 @3 N
; S) `: O5 n( G  i, |3 vcount=0
" x: U4 W2 P7 }& ]+ G7 Mwhile count<100 :
    if count %2 != 0 :
        print(count)
' T; I: h2 D; m' ~7 y    count += 1

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
; }! n( z- W& m' g# C* {" \    if i %2 == 0:
        print(i)
& G6 Y' Q# H+ m; g5 d, t5 [8 ]' D
/ t! t. d, y" t' dcount=0
while count<100 :
/ J1 K  j7 P: \' r    if count%2 == 0 :
( F3 n+ @% r; M' C2 Y- a* I        print(count)
    count+=1

' b5 r' t4 d% E12、分别书写数字 5，10，32，7 的二进制表示
$ f' _8 w9 a4 B
+ p# _- s$ |8 q. ]9 s& T/ L3 G1 \print(bin(5))二进制   0b101
1 l. E4 I4 t! `) S1 g3 hprint(hex(10))十六进制  0x5
print(oct(5))  八进制  0o5
6 `" |# ]9 ~7 c- E14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

% X# l# \6 a$ ~16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
; z9 K: O2 B- Z; F5 ~3 c17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

n1=5
" r3 ~8 _# l: j& Gprint(int.bit_length(n1))  结果  3

5 U: {- b* U7 C/ o8 h
18、布尔值分别有什么?

False .Ture ,或1  和0

20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
& X& K* x7 g- J4 H! l3 }7 ^a. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())
+ `6 v5 @! F0 E, C( Q, w+ l, i
b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
( r& a$ b9 }* |. k* Q/ E4 m! Uprint(name.startswith('al'))
" e- I" F  H# Z1 }c. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
( j& w3 s* u0 p: _% ^- c% [7 [$ p+ Yd. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
print(name.replace('l','p'))   apex  
% o( a% P/ A: t/ f1 I6 F" S1 de. 将 name 变量对应的值根据 “l” 分割，并输出结果。
print(name.split('e'))   ['al', 'x  ']  列表

5 o# C" t1 ]2 N" j. ?+ Q  D8 mg. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])
( p" f  @6 b* A9 ~( P2 ]- z
7 n9 X5 @" d+ I$ n' ^j. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
" r$ n3 h' H% |# a( g  Q依赖索引
name = "Alex  "
- U8 _9 t; K$ U- Qfor i in range(len(name)) :
" ~+ X1 y! e2 c' L    print(name)
for i in name:
9 B2 J8 o. |0 F# P9 Y, v    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
' ~  v0 E' _& C, U7 Rprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
, w# h% h; Y0 r$ W# v  |print(li)
['alex', 'eric', 'rain', 'seven']
5 t3 G5 P0 T. v. Ac. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
print(li)
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
1 g+ {' R. H+ {3 ]7 C- Rli.pop(1)
print(li)    ['alex', 'rain']
指名道姓的删除li = ['alex', 'eric', 'rain']
# y2 P# m% Z0 _/ ?% g3 Xli.remove('alex')
! O) D: O) _+ V1 U0 f; ~print(li)
+ q9 q8 H- H( [' C% U0 vf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
5 D5 G  D; p9 A/ |! t  r' R! n9 Z) vprint(li.pop(1))
; O: C9 [0 {0 Q. f$ m' F. j1 Mprint(li)
& }2 |' Q8 z( ~8 h8 E
eric
; B& g1 y: |5 J/ B4 r3 b# s['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
/ D6 F: G; _  `9 n  T7 edel li[1:]
/ {! B8 z" g' qprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
$ K% v8 ^. G! Jli = ['alex', 'eric', 'rain']
6 @; M" h9 j8 J8 e: }7 ifor k,v in enumerate(li,1):
    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
a. 请输出 “Kelly”
: R8 p# g  [  K: D- R% c) z/ Dli = ["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')
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
; B" i! D) x8 S1 }% tprint(len(tu))
b. 获取元组的第 2 个元素，并输出
print(tu[1])
e. 请使用 for、len、range 输出元组的索引
for i in range(len(tu)) :
    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
9 r- J9 t6 h  k  {6 ufor k,v in enumerate(tu,10) :
" _1 X$ \8 Y8 s! C. o8 V    print(k,v)
10 alex
11 eric
9 a( m& g, E  _7 J/ v12 rain
- I' A1 Y, j- \' \1 _1 s4 ~
% y; M7 C9 s% pfor k in enumerate(tu,10) :
" c5 i5 n' ?6 E2 y( C, b    print(k)
(10, 'alex')
/ B& c6 [/ O, n7 Y% R6 L+ ~/ X(11, 'eric')
- H) ~1 Y9 N  C* E(12, 'rain')


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

元组，不可以

8 c: m9 M0 q, T2 n5 Ld. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
7 b8 n/ @4 u3 V) ]" p+ lres=tu[1][2]['k2'].append('seven')

print(tu)
26、字典
3 K8 |7 X+ I9 B0 tdic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
    print(i)b. 请循环输出所有的 value
for i in dic:
) g7 M8 p" l6 S# n% @5 j5 M    print(dic)
* E  ?; U9 O& K3 vc. 请循环输出所有的 key 和 valuefor i in dic:
print(i,dic)
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
) C! `' p# G" n* f/ \: t5 kdic['k4']='v4'
7 `4 @6 ?; C1 {' Eprint(dic)
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
dic['k1']='alex'
$ }) Z" M# T" c7 R5 cprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
dic['k3'].append(44)
/ N( q4 O. v$ x! b4 @print(dic)
. T( {3 W* C: d0 [* I4 l9 a
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
dic['k3'].insert(0,44)
print(dic)
* O- J/ h$ ^: I  r  E27、转换
( N* R. X3 t8 W) ^# B7 Ya. 将字符串 s = "alex" 转换成列表  s = "alex"

3 W0 V* K  G% Y/ n+ E) Gprint(list(s))b. 将字符串 s = "alex" 转换成元祖
0 t/ y6 N) Z0 G- Q. w8 w' }s = "alex"
print(tuple(s))
. n4 S7 W& a- V' F2 _  W
b. 将列表 li = ["alex", "seven"] 转换成元组
3 Z/ l; @3 |6 S/ J7 i5 ?- O% s$ i" zli = ["alex", "seven"]
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
tu = ('Alex', "seven")
+ ]' o' m; Y/ `+ k1 o. wli=list(tu)
print(li)


' W3 }5 y3 h1 o8 t6 s0 s3 _. V9 `d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
7 E' v7 ~: X& c" _  @% U
- E+ [6 g; Q3 ?3 b# x3 r  xdic={}
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
- [4 Q# [3 ]" a% l& Q    dic[k]=v
" F' Z8 C! f" q5 H    print(dic)27、转码n = "老男孩"
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
a=n.encode('utf-8')   
8 J' ?6 ?7 J$ J- }9 Iprint(a)
8 @, S$ `* h6 I# h, s: z% rb=a.decode('utf-8')
% H% \) b: w4 [: ?/ F1 }/ T/ S' Oprint(b)
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
! L9 O$ G. R0 Y7 `/ Lprint(a)
6 a1 S" z% ?  S7 ~* db=a.decode('gbk')
5 }' s4 |3 Y$ z4 dprint(b)28、求 1-100 内的所有数的和
) P# n8 O' r0 D& L* o' Icount=1
6 e- K- g3 S( G2 ]sum=0
for i in range(100) :
3 p2 F! ]0 }: c    sum=sum+count
: g4 h: M4 ]2 w" R- k+ d# G: Q2 k    count+=1
print(sum)
; c* H0 k; `/ O3 I' h* ?) s
, E) \. h# i8 f! @& w! ycount=1
; D8 N  y0 o8 k9 @sum=0
& y# e0 I- _: |6 M% ?6 ~, A  N/ ~( Xwhile count<=100 :
5 Q. x; E- {. |- I0 k0 }: q    sum+=count
, y' M; P9 W: s    count+=1
( X6 b( [8 p6 @7 k& J! S; g5 Vprint(sum)29、元素分类
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
将小于 66 的值保存至第二个 key 的值中。
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
li=[11,22,33,44,55,66,77,88,99,90]
1 |- L# G6 g: |3 G- O* Jdic1={
0 W9 K9 F% k, J0 |7 q7 f    'max':[],
    'min':[]
; i( r$ j$ g2 U1 l& X% R; ]9 j}
5 Y3 j2 i9 C4 l; nfor i in li :
    if i <66 :
: e7 L+ l2 D- g% z# T+ J) a        dic1['min'].append(i)
" j& a* }- Q" q; z) m$ x    else:
; [4 K' G, m* T* c1 E4 v6 [% W        dic1['max'].append(i)
print(dic1)
) e) X% U; A# v$ Y7 n
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}