Python基础知识汇总

1.执行脚本的两种方式

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

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

2、简述位、字节的关系

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

$ e' T$ [2 @# [0 }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个字节代表一个字符，

7 |/ g; q% |8 ~, g8 Q4、请写出 “李杰” 分别用 utf-8 和 gbk 编码所占的位数

utf-8    是3 bytes=24bit

gbk     是2bytes=16bit

- g) [$ y, u: r, {( ~" W5、Pyhton 单行注释和多行注释分别用什么?

单行注释  #

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

9 P! G8 _" e% Q8 }; H$ D3 g7 C7 B6、声明变量注意事项有那些?

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

不能以Python的关键字命名，

能表明变量的意义

1 i3 @8 l. n$ P5 s, f- ?; v8、如何查看变量在内存中的地址?
+ A# t7 x# t1 w- p7 R( M) \1 Cz=1
print(id(z))
9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

. x8 h, S. C3 _$ @4 i# R. R10、写代码
a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
name=input('name:').strip()
pwd=input('pwd：').strip()
if name=='seven' and pwd=='123' :
    print('ok')
else:
    print('error')
. P, U  a4 M% H4 S- B; N' W
b.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
count=1
# D8 {* @& s4 k7 A: E* e: owhile count<=3 :
( {) s, G) O) ]* j' Y    name = input('name:').strip()
2 q. R3 v8 z. M$ S2 B! b* ?# R    pwd = input('pwd：').strip()

    if name=='seven' and pwd=='123' :
4 n" _9 H; k: I0 X        print('ok')
    else:
        print('error')
! B6 f! l- J* I# H        count += 1
( \! E$ k9 U2 [7 ~6 ufor循环：
2 l9 a& U4 h( y: ^for count in range(3) :
    name = input('name:').strip()
2 w/ Q4 Y7 y3 \) u% e% t( U    pwd = input('pwd：').strip()
3 ?2 I1 }$ k: @% A4 O- Z. o; M* z
    if name=='seven' and pwd=='123' :
        print('ok')
    else:
        print('error')
( {6 X  N4 z9 O* u( Y- a        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
count =1
while count<=3 :
" i: `1 I+ s: k2 k# h# n( G0 e    name = input('name: ')
    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
  F) c5 d& f! G4 R; k  }        print('ok')
    else :
, \9 R7 d* Y! x' a+ x        print('error')
        count+=1
1 J) @/ r6 Q1 Hfor循环
for count in range(3)  :
  Z" y! i+ Z# y5 L* n    name = input('name: ')
7 u7 j6 G+ ?0 T    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
# q" N0 x1 @+ s8 J/ [9 p    else :
: {$ V" x+ \: @; {- ^# {        print('error')
% {" v% m1 Y+ j: D0 q  D, R        count+=111、写代码
a. 使用while循环实现输出2-3+4-5+6...+100 的和
# l/ ]  t- H( k+ tcount=2
num=0
while count<=100 :
    if count % 2 ==0 :
        num=count+num
6 ^* y- P: n/ H" G        count+=1
0 @* w8 ~8 w9 W9 ?" B& I( s    else:
        num=num-count
& b" w" ^5 U/ v- p) R        count+=1
print(num)
. j& m4 k" ^6 J
b. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
- d" ~$ h# h0 X1 ^. q9 Z3 d# C num=0
! R1 b& _2 _1 Y9 K: ^, _' wcount=1
for count in range(100) :
$ w" q0 |& S, r; c, P9 g    if count % 2 == 0 :
# a& W% E7 l8 K        num=num - count
  o( w4 s: x$ E# ?7 i    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 :
! h" ]% Y! n  y% u, r" f( M: [: W5 t        if count !=10 :
5 ~: r% G/ ^# V+ T: Y            print(count)

    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
3 B8 t' C% I" E! wfor i in range(101) :
    if i %2 != 0 :
- ]1 \- X& q0 q( o+ o; _% {( r3 J, w6 K        print(i)
9 w  F4 ]+ C0 d9 D8 s/ ^) D' l
7 w+ s" N) s" L- Jcount=0
while count<100 :
    if count %2 != 0 :
* P9 ~& ]( @+ s) S# h' @        print(count)
    count += 1

1 l! Z: L3 Y4 N6 ^+ ]e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
    if i %2 == 0:
        print(i)
  E0 P& w) `3 o! {
. y; d7 j) F" a& s$ |1 {# Lcount=0
while count<100 :
    if count%2 == 0 :
        print(count)
0 E' H+ q8 Z) q    count+=1

! u4 m; e7 o, s9 w12、分别书写数字 5，10，32，7 的二进制表示

print(bin(5))二进制   0b101
: s2 |. `2 {9 d+ g. T! l( T/ L% iprint(hex(10))十六进制  0x5
  J# ^  b9 s/ j9 x; q0 x. f" ~/ Zprint(oct(5))  八进制  0o5
" |( v9 `7 }) f# j! @* c* t6 Y14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
. L0 z) ]( O# m$ v2 j- I. G, u1 x17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

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

5 `1 E; p# x$ P" S3 Q  x, j: I18、布尔值分别有什么?

False .Ture ,或1  和0

6 C4 X( T0 b8 g- a& p20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
1 {2 I6 x2 |0 x; b4 \+ a/ aa. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())

' J) H* M% T, ^" i6 {" _b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
/ k; M# |9 X0 T: O( b0 i, Lprint(name.startswith('al'))
3 ~1 e, h8 G+ R. o6 P, `- Ec. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
# ^* P9 o& c3 ~; g# B( \  Y' o& Ld. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
1 k% f# f' e0 E. e) ?print(name.replace('l','p'))   apex  
e. 将 name 变量对应的值根据 “l” 分割，并输出结果。
) M6 \$ e! Y; L3 D% |print(name.split('e'))   ['al', 'x  ']  列表
' D) I4 n8 ]% ^; i$ B( m
g. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])
# K5 ?* E, }5 d! D" s$ w( {8 e
2 Z0 R9 E# t, k0 K' n0 Pj. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
8 t2 u" m9 {6 ~  u5 S8 y21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
依赖索引
name = "Alex  "
for i in range(len(name)) :
    print(name)
0 s: ~0 B" W# m8 |for i in name:
    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
3 h0 J$ f1 B% Z: ]22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
) m- c% G$ S! c9 Eprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
print(li)
['alex', 'eric', 'rain', 'seven']
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
! c9 e4 b* s# ^# r6 n6 Oprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
print(li)
# ]  E8 O7 g) T, j  ]/ f6 ne. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
) R3 P/ x5 I$ x2 f1 l5 i6 nli.pop(1)
print(li)    ['alex', 'rain']
指名道姓的删除li = ['alex', 'eric', 'rain']
7 ^6 q5 f& X7 ?6 |% e  hli.remove('alex')
" e. X* m1 Q  W! ?4 yprint(li)
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
print(li.pop(1))
! }: ?' Y/ \4 O7 n; g- Fprint(li)
% u( i+ I& {3 w4 p/ ?
; i) Z" L. l( ^1 ]; _eric
6 L8 S. e* F8 e, C; b. {) ]['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
del li[1:]
1 l) K- g0 z' |( z( m+ H7 u& u4 qprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
: o* p/ K  h$ _# d9 wli = ['alex', 'eric', 'rain']
for k,v in enumerate(li,1):
    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
. t5 \1 U. A* ^  s+ w: F4 ~a. 请输出 “Kelly”
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
) w) Y; E) }+ Gprint(li[2][1][1])
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
li[2][2]='ALL'
6 M2 z! x( y$ q8 B; b0 Bprint(li)
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
% `. A3 |# r. x$ o$ x4 I$ na. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
" w" a6 I+ w: M* v/ \$ qprint(len(tu))
2 D: w7 V& g3 T  Z& x7 |9 N( ~b. 获取元组的第 2 个元素，并输出
8 c3 v, L1 [/ K( Kprint(tu[1])
, V* K/ h1 |) j  c4 h7 e0 \) xe. 请使用 for、len、range 输出元组的索引
for i in range(len(tu)) :
' l. V) x  K7 p" b! T/ W    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
for k,v in enumerate(tu,10) :
6 C8 F% T9 O7 w5 S    print(k,v)
  \6 n7 [: J6 s% a10 alex
3 N1 S8 R. M) p3 p1 I' |( v11 eric
12 rain
$ {. {8 ^7 N& X- A
: r% V9 I& m% o# Z% a. _; T/ _. Afor k in enumerate(tu,10) :
    print(k)
(10, 'alex')
$ ?& M2 y% c3 z& E1 @9 h: M(11, 'eric')
% f+ H1 }+ C* P1 w7 A- i(12, 'rain')
6 I6 R. q4 u! |6 b, f% }
' W  W; ^% `1 f4 w: d' o( |
& n9 s' A  O9 }% y9 l* g. ~, c25、有如下变量，请实现要求的功能
; U9 O* V: \# T7 l. ktu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

元组，不可以

7 n4 W$ D8 _# r$ T8 d+ b" zd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
( P  d5 v) ?7 Jres=tu[1][2]['k2'].append('seven')
5 g/ Q3 ?/ ^4 ?6 Z( r9 Z7 f) o
print(tu)
26、字典
/ u5 Q  }  l1 P, [3 x! x6 k+ Xdic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
9 P# F/ u2 V: M4 c8 g; x8 h    print(i)b. 请循环输出所有的 value
for i in dic:
    print(dic)
c. 请循环输出所有的 key 和 valuefor i in dic:
print(i,dic)
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
' B- J  T9 \3 V- A+ l/ F. Tdic['k4']='v4'
9 g- W  }" s- x/ y  ]print(dic)
) ^1 E( C: d- S! d2 Z& Ee. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
. d4 U' N8 d# d9 ^6 a, z6 h% E! Udic['k1']='alex'
6 n' }) q' l; p4 d7 d& U' o, yprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
( L* X: i* t$ C- g2 M# R7 U+ tdic['k3'].append(44)
4 l* f4 B# X, v7 |! iprint(dic)
# P4 V4 F: E% T) s' m
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
dic['k3'].insert(0,44)
print(dic)
27、转换
9 D) c+ i- |( R4 E/ La. 将字符串 s = "alex" 转换成列表  s = "alex"
4 C2 H, i) q, }2 A
6 a7 U, G; S" oprint(list(s))b. 将字符串 s = "alex" 转换成元祖
s = "alex"
6 q) ^( N1 L4 P  Vprint(tuple(s))

8 K+ f5 q& Q- T: y. a: _6 f+ Sb. 将列表 li = ["alex", "seven"] 转换成元组
! h4 v6 C7 s/ G; G8 Xli = ["alex", "seven"]
' o' I4 d  \0 G6 [7 n4 dprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
' ^( V  u  g% }, u( [4 btu = ('Alex', "seven")
li=list(tu)
, g$ N6 e) A1 o- T9 R, P, b; pprint(li)

. \( I6 L9 o3 t3 y" \7 h
( p. t( O: w  i$ d& f' X, P1 dd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
$ S2 y& w& R' R% d* K; H0 \' `
5 m3 _, A3 _# qdic={}
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
! a, t2 V# H9 A$ x6 E! ~0 }% S    dic[k]=v
. u+ T. E! z% D( \; c    print(dic)27、转码n = "老男孩"
+ Z' r' X+ j) l& r1 ~' {- S7 Ua. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
9 H6 `1 n7 f$ [7 S; \+ @a=n.encode('utf-8')   
print(a)
b=a.decode('utf-8')
% U  l# z  F3 @/ y4 V; |: aprint(b)
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
% J% B4 h8 k/ Z5 oprint(a)
0 j/ m" Z, P- O3 mb=a.decode('gbk')
8 z' v; b3 e( F( ~. [( ^; Cprint(b)28、求 1-100 内的所有数的和
count=1
sum=0
for i in range(100) :
    sum=sum+count
# ^- U/ b" A2 S. [" x    count+=1
print(sum)

+ g2 C  B2 t% u& Z/ a/ @* [& pcount=1
sum=0
1 [3 B9 L8 ], q+ H: P) cwhile count<=100 :
5 m9 N. I3 N* @1 Q9 j6 P% V    sum+=count
    count+=1
' t( w. x% ~+ C' r! bprint(sum)29、元素分类
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
# w. ]* ?/ _$ i- |3 Q$ X7 c7 h% a将小于 66 的值保存至第二个 key 的值中。
/ a' ~% w' A9 W4 s7 n即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
li=[11,22,33,44,55,66,77,88,99,90]
dic1={
    'max':[],
    'min':[]
5 _: M! [; n! F/ I# r}
# g' E. e; z' W* ffor i in li :
& t- [! z: G2 a    if i <66 :
! w- F" c* n6 B! E* {' p$ a. I        dic1['min'].append(i)
    else:
        dic1['max'].append(i)
2 x0 p+ {1 m0 X& a* V; b& @& O( mprint(dic1)

. O( v' |# i8 M5 A& l4 ^---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}