Python基础知识汇总

1.执行脚本的两种方式

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

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

2、简述位、字节的关系

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

6 [5 F3 |: L0 f7 ?) P0 C' ~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个字节代表一个字符，

6 B- L- s& C( Q4 m) S, p! u4、请写出 “李杰” 分别用 utf-8 和 gbk 编码所占的位数

utf-8    是3 bytes=24bit

gbk     是2bytes=16bit

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

单行注释  #

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

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

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

不能以Python的关键字命名，

能表明变量的意义

8、如何查看变量在内存中的地址?
" t3 n( M) o4 Q2 Pz=1
print(id(z))
' @  s3 U% X. x2 W2 J9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

10、写代码
' S! X6 S# F  J8 M& ?) ^. Ia.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
name=input('name:').strip()
pwd=input('pwd：').strip()
if name=='seven' and pwd=='123' :
, U7 N  B" ?% @5 C" r, v    print('ok')
else:
9 {- x/ L5 I+ A$ K0 a9 A% g    print('error')

  D4 h9 N6 M0 c3 Q. p3 E* |b.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
count=1
while count<=3 :
$ o& e; b# T8 \. R/ p8 j    name = input('name:').strip()
    pwd = input('pwd：').strip()

    if name=='seven' and pwd=='123' :
        print('ok')
    else:
/ s  F- Y! E, _) \        print('error')
        count += 1
' F* p# N% G* S8 U) q5 ^for循环：
for count in range(3) :
% ~& l# W& u+ W) V5 g    name = input('name:').strip()
! S* \& D. p( ]4 e( i+ E    pwd = input('pwd：').strip()

& o9 c  X- X  H& Z$ W    if name=='seven' and pwd=='123' :
- ~- h4 i4 J" v# F; F# P        print('ok')
    else:
        print('error')
        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
count =1
while count<=3 :
2 Y! _9 ~, o- W  c& G' y- X    name = input('name: ')
    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
) u2 L! ^; }: F0 y. x5 u; q        print('ok')
" T, E) f3 M$ c$ u) c, y    else :
& o9 V! C7 A+ c' _        print('error')
        count+=1
for循环
for count in range(3)  :
    name = input('name: ')
* [; E; Y9 u) X. R    pwd = input('pwd: ')
) d: }1 F' O- u3 `+ i/ p    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
    else :
8 x6 P/ n2 }, Y" w# t, d        print('error')
; |) f" \+ L  V# V: E        count+=111、写代码
a. 使用while循环实现输出2-3+4-5+6...+100 的和
6 G7 S/ b4 P& z4 K6 s: ecount=2
- J6 m9 i# J. i) _" f8 T7 enum=0
while count<=100 :
    if count % 2 ==0 :
6 j% ~  e: M) b1 k        num=count+num
        count+=1
# c2 W& T$ k8 L- X/ e1 V    else:
        num=num-count
8 W* q6 n- j/ I$ c6 @        count+=1
/ M3 P! T* ?  U/ Fprint(num)
5 Z2 ?$ }* w  x1 u5 N
b. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
) A$ S+ y# H! I+ l3 ~' b1 u num=0
5 H2 J( K3 e, _3 C) b5 a$ Z8 X" a4 Zcount=1
. g; M- O# V* Pfor count in range(100) :
9 B1 q+ b' y7 D: S1 V; E    if count % 2 == 0 :
! |) c! B& ?9 b; S% H  `5 a' L! R        num=num - count
    else :
        num=num+count
print(num)

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

/ r; O5 e: e! R" icount=1
* |, f, P! B% J3 ywhile count < 13 :
' ?) e4 L1 N: A3 j- K3 {' p    if count !=6 :
* f% k7 H  n+ X$ f1 S6 U        if count !=10 :
! k3 H7 y- D0 S            print(count)
0 t% M$ a. s# I  g9 x& a! X/ ~) O
) x* O" |, L' T+ h    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
7 D; Z4 }: g1 H1 M5 `for i in range(101) :
+ Z, E5 p# K6 ?* `: C" V; K    if i %2 != 0 :
        print(i)
& f$ V) A$ P: p3 a0 }
9 \. c. q7 A" R7 p6 J1 a9 Xcount=0
" ], z% p+ T, Z) O: q0 Z$ Iwhile count<100 :
    if count %2 != 0 :
        print(count)
# k6 j3 V9 U, x8 ~+ Y    count += 1
+ F- ?  T9 f( N& C  U( Q' X: r* }! V6 |7 x
/ i- d' C% i+ ~3 e2 i1 J! A: Qe. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
    if i %2 == 0:
        print(i)
& D3 D* O1 I, s: c6 z( O
count=0
while count<100 :
# m' g' G' {0 M    if count%2 == 0 :
        print(count)
    count+=1

! R; n# d7 D7 g# r9 l7 `12、分别书写数字 5，10，32，7 的二进制表示
* V; Z- z, [8 C1 w4 S6 g
print(bin(5))二进制   0b101
print(hex(10))十六进制  0x5
print(oct(5))  八进制  0o5
* D+ m2 i3 g2 Y& S: f5 A14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
" u% ]* G# [# ?! X7 S6 y17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

n1=5
1 }2 Y0 E2 a  K$ B1 V# Wprint(int.bit_length(n1))  结果  3

. w7 l5 a+ i4 M3 }: a2 F18、布尔值分别有什么?

False .Ture ,或1  和0

8 G, u3 G. H1 d% |7 c. f1 V' g6 B3 D20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
+ ?$ S# @8 d+ Na. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())
$ _4 i0 }1 H" O1 x/ T* L- S
+ \, J4 A. [) e$ m! |b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
, o& l$ Y6 Z; n7 pprint(name.startswith('al'))
4 O5 e& x+ b  r4 w% mc. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
d. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
: ^3 ^8 [  l: @: s2 e6 p3 ~print(name.replace('l','p'))   apex  
5 d. K) |8 k4 t8 z9 p, ve. 将 name 变量对应的值根据 “l” 分割，并输出结果。
print(name.split('e'))   ['al', 'x  ']  列表
3 D& V. v# K5 b  s$ j4 q
, P9 k6 J$ J! ?# y* ^: u# a* eg. 将 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'))
/ E9 D7 i, Y& t6 L21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
' x( d$ U$ E/ S( ?( h3 T7 S  ]' V依赖索引
: M/ K4 \( K+ T- [& S, p7 |name = "Alex  "
for i in range(len(name)) :
5 ^" D3 n$ F: _6 _4 t, h1 h+ Y    print(name)
for i in name:
4 b# e/ M+ D6 g, e. A/ Q    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
( l% x! Q9 B( q+ u7 P$ y6 I6 gprint(li)
['alex', 'eric', 'rain', 'seven']
6 M# |7 y, R6 }* h# Ac. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
7 c  O7 h! [* A8 L% V! Jprint(li)
1 ?5 O: u! a# ]5 F1 O% l% g& {e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
5 c, f/ ~' q- c5 ~7 \% s% xli.pop(1)
print(li)    ['alex', 'rain']
指名道姓的删除li = ['alex', 'eric', 'rain']
li.remove('alex')
8 y+ ~8 L5 w/ Iprint(li)
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
print(li.pop(1))
. C% m% A- O8 |9 P( b* I! Z8 @print(li)

1 b+ w+ W. m4 \5 N( Xeric
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
del li[1:]
+ n1 Z$ G8 F( |4 R! z" A1 A9 Yprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
% b+ P2 U* F+ L* R8 M  Rli = ['alex', 'eric', 'rain']
for k,v in enumerate(li,1):
$ W# ~, }! x  ^% E1 ]' j5 ~/ y    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
/ \( M* A$ W  I: u, @% }9 {a. 请输出 “Kelly”
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
print(li[2][1][1])
( `# I) Y, @. b" n: Q3 ?# N. r' cb. 请使用索引找到 'all' 元素并将其修改为 “ALL”
li[2][2]='ALL'
8 O5 C/ `" }  y1 `& [* A2 f6 Gprint(li)
# ]/ g2 M& \" H4 Z( J24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
; K6 q! b' ^2 o& ~9 Q0 M; s: ]print(len(tu))
7 r$ k8 z- f& b+ W  Bb. 获取元组的第 2 个元素，并输出
2 X# `, o$ D( ^! A4 }print(tu[1])
e. 请使用 for、len、range 输出元组的索引
for i in range(len(tu)) :
4 ^  Q8 B, {6 P  z- _4 H9 r    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
$ c* e5 j: r; b7 p1 f  e/ V  Lfor k,v in enumerate(tu,10) :
$ X8 n$ H/ L) t3 p1 ]7 I3 T, R    print(k,v)
10 alex
. d, ]( r$ s& G7 r11 eric
3 ^  b2 T* O- ?9 P/ @12 rain
8 P$ U% Y# P1 r' U4 F
* W2 u% D! i9 {$ j( jfor k in enumerate(tu,10) :
    print(k)
& G0 {9 @7 m1 D(10, 'alex')
0 U3 T& J2 [! @5 T7 \1 C(11, 'eric')
(12, 'rain')
1 Y8 {6 u6 `, {' t  O, X

25、有如下变量，请实现要求的功能
. P& k( p- n. s5 S: E9 |% x+ J0 w& Atu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

元组，不可以

% G  e6 r/ v3 l; g( }% Hd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
5 f0 Q1 j/ i" n% ures=tu[1][2]['k2'].append('seven')

print(tu)
4 j/ }) P  c% v* O26、字典
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
    print(i)b. 请循环输出所有的 value
+ Y1 [+ t2 W6 \for i in dic:
    print(dic)
c. 请循环输出所有的 key 和 valuefor i in dic:
8 w' U3 l' O6 V. n0 Vprint(i,dic)
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
# t. z+ d8 F! |' y% v5 Pdic['k4']='v4'
print(dic)
0 o! }+ m: h. Z( M- |e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
dic['k1']='alex'
5 X1 K1 l" z- s3 R% Cprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
dic['k3'].append(44)
6 l# e( i. y) a8 ~* v: eprint(dic)

g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
dic['k3'].insert(0,44)
& T7 x. t) m7 M& Q" y7 }8 qprint(dic)
: h& o9 }3 O8 q: V2 T8 B1 u27、转换
/ [- S# L4 L0 [6 O( {/ @5 m) x( M; Ca. 将字符串 s = "alex" 转换成列表  s = "alex"

print(list(s))b. 将字符串 s = "alex" 转换成元祖
: u! F1 V0 r' q% |1 Ts = "alex"
7 h, {$ p& G+ S4 aprint(tuple(s))

$ k9 Y1 o! R7 a. ~; d( J1 cb. 将列表 li = ["alex", "seven"] 转换成元组
+ Q& c8 E0 u8 F2 T  Rli = ["alex", "seven"]
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
tu = ('Alex', "seven")
li=list(tu)
print(li)
& e4 H/ F; p  E! [, _
3 Y7 c9 d8 O' ]! w% i
$ Q6 `/ Y4 M- _. m6 kd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
/ q& o  U3 Q" P, J( y, O
$ o$ T6 J( g; j  u( N7 k6 b( i2 k- sdic={}
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
; _# Y  H. q4 s" g  `2 G* l: G    dic[k]=v
    print(dic)27、转码n = "老男孩"
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
% L4 G. N5 k5 u. H. J5 H7 |. u$ C/ W9 ba=n.encode('utf-8')   
- C) [" F4 e7 {) h! @- P8 Yprint(a)
b=a.decode('utf-8')
print(b)
0 H3 |/ {1 W( Z* N) pb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
print(a)
b=a.decode('gbk')
print(b)28、求 1-100 内的所有数的和
% W2 Q& Y! T& }count=1
. M3 G/ O2 w' y4 \sum=0
. H& I7 Q) C: q, d% g" Dfor i in range(100) :
; I2 ^9 \3 d) a4 b) R! w6 J    sum=sum+count
4 P" k. }  q; [3 }$ c    count+=1
print(sum)

5 B% H: P* h0 I9 L- gcount=1
- L9 W( A- v9 y: o6 H# p1 ]sum=0
while count<=100 :
! Y8 s4 ]! f* c    sum+=count
    count+=1
- ?/ U; h1 }. B$ yprint(sum)29、元素分类
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
. L9 w4 u4 b* y; p( P将小于 66 的值保存至第二个 key 的值中。
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
. G5 q3 w' d' T2 W+ Q# ?li=[11,22,33,44,55,66,77,88,99,90]
2 Q( n. k% H0 V/ q- \, xdic1={
  f# b$ K, j9 x8 V9 s0 R) ^    'max':[],
    'min':[]
}
for i in li :
    if i <66 :
$ U& l+ R" P; z* y5 b; G) r        dic1['min'].append(i)
    else:
- x3 R! q6 Z+ u6 G3 ~2 b! C        dic1['max'].append(i)
% P9 A  Y& P, v3 g9 L5 Y3 o  d% c$ R5 vprint(dic1)

3 S3 S3 @, q( ~  O5 m2 B" t---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
) @. E& q- p/ ^; m