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

4、请写出 “李杰” 分别用 utf-8 和 gbk 编码所占的位数

utf-8    是3 bytes=24bit

gbk     是2bytes=16bit

$ {$ ]7 Q0 P3 A- |5、Pyhton 单行注释和多行注释分别用什么?

单行注释  #

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

# G  g, t- ?# y* Y+ H& u6 V/ }6、声明变量注意事项有那些?

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

不能以Python的关键字命名，

能表明变量的意义

6 h* _# c' ]. E; ]! X7 M: h8、如何查看变量在内存中的地址?
z=1
print(id(z))
2 v* E# f6 Q& _9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

10、写代码
a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
3 s# M7 x) {3 J  U' Gname=input('name:').strip()
pwd=input('pwd：').strip()
if name=='seven' and pwd=='123' :
9 K0 T8 |4 a0 ?$ X& c+ ^    print('ok')
else:
    print('error')

' w0 O5 b" ^3 m2 F6 I# `* u& Kb.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
count=1
while count<=3 :
    name = input('name:').strip()
    pwd = input('pwd：').strip()
( H2 K) f1 }1 k" }$ ~, e6 e: d/ f
0 g0 ]5 R: ?  o+ B* v* ]    if name=='seven' and pwd=='123' :
8 d2 n) G, Z/ z! @, W        print('ok')
    else:
        print('error')
        count += 1
$ Y- m* J) i* F# K5 pfor循环：
5 T8 o3 t7 Y( B% d4 |. i8 }for count in range(3) :
    name = input('name:').strip()
    pwd = input('pwd：').strip()
; U- F; v/ o. O+ K, F! g
' \& l! K4 [3 M# P    if name=='seven' and pwd=='123' :
        print('ok')
- Z3 w: D% e6 P" m* p    else:
        print('error')
        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
5 O  l9 D: L1 |: Mcount =1
7 p! f6 O3 s. I9 j2 f7 ?while count<=3 :
# y1 [' [2 a' o* J+ X    name = input('name: ')
    pwd = input('pwd: ')
! ]6 }4 t7 I' b6 v% |    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
: ]5 C! y2 ~- A6 W4 T    else :
! v3 f) e$ G2 `( g) _        print('error')
        count+=1
for循环
for count in range(3)  :
    name = input('name: ')
    pwd = input('pwd: ')
  j# d3 r' P. Q4 K2 z0 @$ @' ?) L    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
. G, L* X7 H1 y; M2 m* _        print('ok')
5 A  G! V- @5 H8 s* o    else :
        print('error')
        count+=111、写代码
1 \2 q- s+ R; w4 ~4 X% Va. 使用while循环实现输出2-3+4-5+6...+100 的和
% M4 b# ]6 s7 H/ M" V+ Pcount=2
9 o% ^. s) ~9 e" G5 qnum=0
* e5 v: O3 E! M8 z/ P1 u: ywhile count<=100 :
    if count % 2 ==0 :
+ h# e; L" D7 H0 {1 t7 b$ l' ^        num=count+num
        count+=1
. G; g; J! x% |# I/ E5 x7 J    else:
        num=num-count
3 [9 ?$ }9 T4 A8 r. O( _% d; k        count+=1
* W* B; C4 O. y  x* T8 fprint(num)
. q1 X2 G9 x$ x: B  g+ j7 ]5 W9 ?
" g/ E( q2 g  k# V( L3 Jb. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
num=0
count=1
8 Y' k+ a9 a$ afor count in range(100) :
1 X" H3 \6 i) T' D8 u, M4 I) g7 D. ~    if count % 2 == 0 :
+ \, T! }& _' \        num=num - count
    else :
: J; C2 t' x8 v, U$ V4 I        num=num+count
print(num)

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

  j7 Q- Y7 _. n+ [0 j0 Ocount=1
, l* y! O; Y( q- m1 A% _) Xwhile count < 13 :
    if count !=6 :
        if count !=10 :
6 Y8 F% j3 w- \; l' f2 |3 O* T            print(count)
, t) B) S( h* ]4 t& v$ l. c3 q
    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
2 B) I+ a, j  afor i in range(101) :
% l1 b# l. e7 L    if i %2 != 0 :
: _  r3 c7 ]  d+ s# y        print(i)
  h& H. G. q+ `! a% a, u( W/ y9 [
count=0
: [2 r+ [0 `2 E8 I3 n* G2 J3 Owhile count<100 :
# ]$ k( C7 N5 a; H0 `    if count %2 != 0 :
, ~, ?5 ]; t* m' r* d  W+ S        print(count)
    count += 1

3 z( }7 q) x) S" Oe. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
    if i %2 == 0:
/ `$ L1 ?( b0 Z: R        print(i)
# C. h+ L( G* Z. |$ Y! D
count=0
while count<100 :
    if count%2 == 0 :
        print(count)
    count+=1

& h# D- ]; z. r& g12、分别书写数字 5，10，32，7 的二进制表示
) }( n# n+ B; \
print(bin(5))二进制   0b101
' F# g& e' `  @' |2 ^print(hex(10))十六进制  0x5
) E5 |  O7 }: m0 T! B2 Sprint(oct(5))  八进制  0o5
' F" G, a7 B) r4 a+ ]# M, F0 d14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

( l6 w- Z( i2 z8 ^- y6 a16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
% b1 {4 w+ ]9 W17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

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

: u, e' _  G; Y( r2 g
18、布尔值分别有什么?

False .Ture ,或1  和0

' h0 p) s9 N; e/ s; l20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
8 v, K' M" F1 z$ {& O& D; @, ra. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())
# G2 J) y% g1 v$ Q, z& r9 h1 p
! I% q2 C" V  M4 t0 A, Ab. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
+ \6 U+ K) }+ N9 q1 x9 S/ Cprint(name.startswith('al'))
9 J" X4 J8 d" ~2 v  Y8 Dc. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
- S2 u7 Z/ S# M2 q+ Q5 bd. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
print(name.replace('l','p'))   apex  
e. 将 name 变量对应的值根据 “l” 分割，并输出结果。
9 Q. \$ U$ x7 B! K5 B: a3 _print(name.split('e'))   ['al', 'x  ']  列表
+ f  V$ ]. h" B4 l; `% V, |2 K
8 G8 p. g3 t+ I7 E' o$ @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'))
2 ?% V7 d* K; W0 f7 c21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
' p8 T6 P6 e+ n( [" `' B依赖索引
" l8 J5 E( O8 L0 P/ u1 E" P1 I/ cname = "Alex  "
for i in range(len(name)) :
$ ]" z* G9 ~/ G; S$ s, }: M    print(name)
for i in name:
    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
9 ~' H6 t2 t) O8 w% Sprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
; _. ^( A! s9 @$ E6 Jprint(li)
['alex', 'eric', 'rain', 'seven']
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
  G4 }2 a" M8 c8 z& p9 M& Uprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
print(li)
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
4 A- F  Q1 ], E" z1 ili.pop(1)
+ m2 w: s/ ]0 Sprint(li)    ['alex', 'rain']
指名道姓的删除li = ['alex', 'eric', 'rain']
. `6 y( ]' t; U9 D& y/ b8 l& _li.remove('alex')
0 J' w5 H/ v2 ~0 V- V7 nprint(li)
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
6 h$ W% h& b0 T6 c- |print(li.pop(1))
print(li)
6 {5 J6 z, G9 q/ u% K
& Y& U6 X$ M* @7 g4 e8 @2 meric
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
! n: M- z! G- _, Z2 l% m, Odel li[1:]
( }/ i2 c% \% V- C+ b( ~print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
$ t" d* e! F( O; C0 {; Eli = ['alex', 'eric', 'rain']
2 [/ I0 F; n+ @9 b) z$ sfor 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]
& S( ~2 z  h' m; r! i5 m& lprint(li[2][1][1])
$ V# ~4 s& \- R1 @9 v1 \b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
6 [+ Y/ S: h1 u+ N' {; a% u$ Ali[2][2]='ALL'
3 }+ O4 Z/ Y3 z" E+ n; w1 ^print(li)
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
print(len(tu))
1 k8 j; W4 E/ {6 @$ i5 Z9 G1 ^4 C) M* Mb. 获取元组的第 2 个元素，并输出
2 j5 U. E! C: K2 |5 y2 S) C+ jprint(tu[1])
& P% i  o6 W% @* V/ o9 F+ D* r; ae. 请使用 for、len、range 输出元组的索引
$ l( b1 R- K8 z4 efor i in range(len(tu)) :
    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
2 z' ]& X7 S5 |4 C' d+ A4 ~for k,v in enumerate(tu,10) :
    print(k,v)
10 alex
( H- }6 }" G7 g' m' w# V3 l11 eric
12 rain

- C, M% e( v* a9 L0 o3 _for k in enumerate(tu,10) :
8 R' U# C% J2 n7 S2 J4 b9 e8 f- N    print(k)
# k8 l6 X, Z4 ~" J3 l% |; y(10, 'alex')
(11, 'eric')
$ w- v- d) U1 @3 A* h% x(12, 'rain')

; p, \9 b1 S" ~( L
8 ?. I& o" ~1 y* Q25、有如下变量，请实现要求的功能
tu = ("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')
- J4 F) W$ X2 [6 ~
print(tu)
26、字典
/ ^1 x; j0 n+ i! R; `dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
    print(i)b. 请循环输出所有的 value
+ s0 o* ?4 F2 Q/ O1 X( ~4 b' l4 Ofor i in dic:
    print(dic)
c. 请循环输出所有的 key 和 valuefor i in dic:
print(i,dic)
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
dic['k4']='v4'
print(dic)
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
6 p4 h' ]9 j& [  e9 \4 b& m! X4 gdic['k1']='alex'
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
dic['k3'].append(44)
+ w  Q+ Q# Q5 G- V: a2 C% Bprint(dic)
/ y/ }" e$ n$ Y+ E, J: g6 z  u  s
# h9 `% i# u8 t) u! h0 o! qg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
dic['k3'].insert(0,44)
; o/ r( b8 w  G  eprint(dic)
) t& h, I0 _; y" j- E( M5 O. e8 r27、转换
7 }9 |3 _9 ?! R3 j# c1 ]9 E  pa. 将字符串 s = "alex" 转换成列表  s = "alex"
' F/ D& R  ^! j0 @, H1 d
print(list(s))b. 将字符串 s = "alex" 转换成元祖
( d6 M( [' F7 J) L3 U% K: J, ps = "alex"
* g# d% g5 E! s6 ~2 p: d  Jprint(tuple(s))

6 n' X" n! Y: `6 r8 d, Y$ ub. 将列表 li = ["alex", "seven"] 转换成元组
. V% u7 L1 C# Y+ L2 yli = ["alex", "seven"]
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
2 I7 z% h2 S6 c' n* ]: gtu = ('Alex', "seven")
li=list(tu)
print(li)
% q2 a- H' j0 p. l/ k- y  i
$ y) t0 j7 [& H
6 X+ _, T+ o% `d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增

1 P" E$ h8 H5 Qdic={}
1 Q( {: }4 C& @7 y: jfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
+ J. ~+ Z- `+ n8 O, R* W9 z    dic[k]=v
3 g  m5 H% W8 B! _3 H. U    print(dic)27、转码n = "老男孩"
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
a=n.encode('utf-8')   
print(a)
b=a.decode('utf-8')
print(b)
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
print(a)
b=a.decode('gbk')
print(b)28、求 1-100 内的所有数的和
count=1
# o$ D4 i9 R; I  b2 m  isum=0
7 o% i/ ~2 o8 N- y( Lfor i in range(100) :
5 Y7 R5 M7 k+ d- v1 w0 f. ~8 G    sum=sum+count
    count+=1
print(sum)
0 Q* H9 E2 w: Z
- c' Z- H& v- u/ [count=1
5 `9 P) T5 I" ^( tsum=0
while count<=100 :
    sum+=count
    count+=1
print(sum)29、元素分类
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
将小于 66 的值保存至第二个 key 的值中。
* y$ r7 c5 k$ u' I0 I& \即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
li=[11,22,33,44,55,66,77,88,99,90]
% X1 T- o! T4 Rdic1={
    'max':[],
+ o. j+ g: E, V/ N+ y    'min':[]
- m" F* Y) O- u- c1 a- q}
for i in li :
    if i <66 :
+ J. x( q. [# `+ W        dic1['min'].append(i)
    else:
        dic1['max'].append(i)
- w# V6 i5 ?! R8 [0 Dprint(dic1)

- L9 l+ ~7 B+ K: k6 j7 K---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
# h) {4 X" g+ C$ b8 S