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

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

单行注释  #

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

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

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

不能以Python的关键字命名，

能表明变量的意义

8、如何查看变量在内存中的地址?
. \+ c1 S) b* o. v8 l4 s; vz=1
print(id(z))
9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

4 d. {) A; W9 O* p  f* |) q1 B" h* v10、写代码
a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
9 y7 w" I5 B) U* tname=input('name:').strip()
6 H3 |* z* t3 g1 m- x) Bpwd=input('pwd：').strip()
if name=='seven' and pwd=='123' :
    print('ok')
/ I% j! `- l2 M# r- g; e. Q2 felse:
5 e7 ?/ V1 C5 A8 `! b) c    print('error')
! q- h7 Y6 g5 q7 k2 I% `
6 k7 j' j% u4 u7 ^! \b.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
3 w/ B' E2 G3 x, i, N  v! @count=1
) ?( |* z" K5 R8 K/ Lwhile count<=3 :
# a0 L. S: z; e( |    name = input('name:').strip()
( b# D0 H9 s( `9 b* J* n7 j    pwd = input('pwd：').strip()

    if name=='seven' and pwd=='123' :
        print('ok')
4 `( C) f! r; f( A  Q5 C6 {- C    else:
; |& @# D3 }+ l  I; X( [: y- ]        print('error')
        count += 1
for循环：
7 U" ~! X6 K9 |1 w2 ^" t% Q. Y& Ifor count in range(3) :
# Y9 t2 Y3 y; @( P& N! t    name = input('name:').strip()
( `5 Y- ?: U6 F7 E- k5 T    pwd = input('pwd：').strip()
* F- p$ B! G5 v3 ~
    if name=='seven' and pwd=='123' :
: J$ s, g" M- g3 a        print('ok')
; a$ i4 _' H+ W$ b, g7 @& Y1 w    else:
, Z3 f  s5 ~' \2 l        print('error')
        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
1 a' U# \5 R% B# p: ycount =1
) P6 K! s( k5 Pwhile count<=3 :
& B. i8 U9 y1 s6 O" o+ \    name = input('name: ')
& R/ x7 _1 O, A7 E/ M1 e    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
; P; p# \3 A+ Y7 T0 q6 e        print('ok')
. p7 y. H3 Z9 N6 r6 A    else :
        print('error')
        count+=1
for循环
for count in range(3)  :
    name = input('name: ')
    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
7 E3 D& Z" K5 G. e% W, }        print('ok')
. ]$ \  l. I" l( B, F2 M  u. h    else :
        print('error')
/ ?( j6 f( [6 T7 o        count+=111、写代码
a. 使用while循环实现输出2-3+4-5+6...+100 的和
count=2
( _7 {4 o. p7 X/ \num=0
/ T0 M# m6 V  m; S3 z/ Kwhile count<=100 :
0 C- O6 S& [% k) L: p" ^    if count % 2 ==0 :
        num=count+num
        count+=1
    else:
        num=num-count
        count+=1
print(num)
1 w/ d4 N1 m9 W9 ?8 I/ M8 t
b. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
num=0
$ l8 y3 A1 S6 A0 F" p+ @& Z4 {count=1
  C, y0 u6 \, g7 E) ]2 c! H6 v0 Pfor count in range(100) :
    if count % 2 == 0 :
        num=num - count
$ s1 F" L' \' g    else :
        num=num+count
print(num)

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

$ g' r2 E' r3 @* n/ q1 qcount=1
while count < 13 :
    if count !=6 :
9 w. ?% c% O5 u7 y) f        if count !=10 :
            print(count)
+ M' Y( e  @2 z
    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
# y/ ^0 V/ q9 Ofor i in range(101) :
    if i %2 != 0 :
! I5 [  [* [: _, Y" ]) t        print(i)
3 s0 ^8 n3 J3 t0 i
count=0
while count<100 :
/ ~( w" b( J" S. @7 I    if count %2 != 0 :
        print(count)
- O  E, {( b4 S! V1 ~3 R; n, Z    count += 1

e. 使用 while 循环实现输出 1-100 内的所有偶数
- r4 U7 r% ]! K4 E. V+ Bfor i in range(100) :
- D9 U6 v9 C7 t* W9 B8 v! G    if i %2 == 0:
        print(i)
- N& J% c4 \7 i9 q% y' Z
count=0
while count<100 :
* k) F4 h1 Q( x5 m( n    if count%2 == 0 :
        print(count)
    count+=1
) N) ^3 A9 F. G" b4 v: ]) r
2 ~5 Y$ |6 `& X0 ^- S12、分别书写数字 5，10，32，7 的二进制表示
  @7 m& X; X7 ]2 ~% m! ?, V6 D" v
6 P! E9 w% ~! T0 R! iprint(bin(5))二进制   0b101
print(hex(10))十六进制  0x5
print(oct(5))  八进制  0o5
2 _' P4 x2 N  ?. e; l* T14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

; L  O" Z+ |4 w! u16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

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

1 Q/ x% i$ f0 i" J18、布尔值分别有什么?

False .Ture ,或1  和0

20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
a. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())
/ B  \3 s8 v% B; g; o4 `3 v* a
; O1 B5 ~% p* H4 d3 B/ X+ y- Nb. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
print(name.startswith('al'))
0 Q# B: \/ r% z7 Q' Zc. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
: o( k/ x( ]( g# t' bd. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
! W" u$ [( ?6 ^0 _' Aprint(name.replace('l','p'))   apex  
  b, b2 L6 U6 G: ke. 将 name 变量对应的值根据 “l” 分割，并输出结果。
print(name.split('e'))   ['al', 'x  ']  列表

g. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])
9 v/ F. E$ Q! E1 B- K) F% `- a
j. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
4 N( s3 \: Q' g21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
; ^1 {4 _/ O4 S4 c2 S, O: a) y依赖索引
! C+ t* m, t) ]3 t; E) z4 Jname = "Alex  "
for i in range(len(name)) :
    print(name)
for i in name:
    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
) E9 u" x1 }& ~% z! W$ X. O# }  f6 w22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
) S# j3 z" ?) j3 C. Z9 mprint(li)
['alex', 'eric', 'rain', 'seven']
' F4 v$ X- v1 _5 I; o7 Ic. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
5 O5 L& @+ Q* L4 C' M, H+ p# _print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
print(li)
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
: G6 @! d% Y4 Q- mli.pop(1)
print(li)    ['alex', 'rain']
  G% L  q/ M+ H% b& g1 s! N  T指名道姓的删除li = ['alex', 'eric', 'rain']
- L4 C4 U4 C- O. oli.remove('alex')
print(li)
0 A( P4 c* u6 @6 b+ \2 T( J! c8 of. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
# K( i: M1 S8 F% qprint(li.pop(1))
0 A7 O: U) q# T" [& T. Zprint(li)
; D) ?: S6 }7 r6 ^
eric
7 _/ Q: z6 \# B" ]0 Z['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
del li[1:]
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
li = ['alex', 'eric', 'rain']
$ Z6 X/ u; ?6 g) o+ }/ Kfor k,v in enumerate(li,1):
    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
0 x6 h/ Y, U$ B  Ta. 请输出 “Kelly”
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
! w5 s, m; t& ?/ R, \/ c; f7 Hprint(li[2][1][1])
9 M% o9 L; g/ _/ q4 y! b) a) ~; @b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
li[2][2]='ALL'
7 }& X+ N( Z  ~, i  u/ Jprint(li)
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
3 I  Z- D6 [/ k# p  A! _0 da. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
2 P7 _% N* |# P  _print(len(tu))
- y, _8 K* E! e/ d* Q  x& Ob. 获取元组的第 2 个元素，并输出
$ R! j: S2 m% tprint(tu[1])
e. 请使用 for、len、range 输出元组的索引
for i in range(len(tu)) :
    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
for k,v in enumerate(tu,10) :
* f$ [% b, d* O3 f$ |/ T$ s    print(k,v)
10 alex
& q1 S  ~/ h+ n0 r: {) S11 eric
12 rain

for k in enumerate(tu,10) :
    print(k)
) O' Q  H: z+ M/ r+ h(10, 'alex')
5 F9 A, _% h5 J9 _4 H% d(11, 'eric')
(12, 'rain')
# i2 f% a4 ?( a' M0 I. C# O8 j
" t" f' D9 C% r
25、有如下变量，请实现要求的功能
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

元组，不可以

2 o- H" b  \& t) B" F+ w+ ld. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
  v; v6 \- w: C+ wtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
: P+ z9 N5 Q1 X" \/ w4 w+ `res=tu[1][2]['k2'].append('seven')

' k+ |; n( m$ s1 ~0 Qprint(tu)
/ S6 D  b3 T' D# ~1 u! f) S26、字典
& B9 a5 g! `* Q2 Ddic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
    print(i)b. 请循环输出所有的 value
! A  ]$ {) N' ^' I0 Bfor i in dic:
  a1 k. M$ V! i! m    print(dic)
8 r, |/ L2 r5 H% _c. 请循环输出所有的 key 和 valuefor i in dic:
print(i,dic)
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
dic['k4']='v4'
print(dic)
6 O! D, ?4 I/ }% T; f# D% ne. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
dic['k1']='alex'
& v- L1 F( p5 x3 V1 uprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
dic['k3'].append(44)
print(dic)
: x: W; s# J, R4 y1 H
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
; V* R% {. g( Zdic['k3'].insert(0,44)
# S" ~, Y: W  R; w1 ]print(dic)
1 [7 U& l$ L8 A, S. w, V27、转换
  @8 H* K/ t3 Y* i+ ia. 将字符串 s = "alex" 转换成列表  s = "alex"

print(list(s))b. 将字符串 s = "alex" 转换成元祖
s = "alex"
print(tuple(s))

; k. K; O; y; Pb. 将列表 li = ["alex", "seven"] 转换成元组
( u# l/ j( l2 @' i9 q; Jli = ["alex", "seven"]
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
tu = ('Alex', "seven")
li=list(tu)
print(li)


d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增

dic={}
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
    dic[k]=v
    print(dic)27、转码n = "老男孩"
  [" p3 Z  N3 b5 P0 Sa. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
( k& `' o$ Y8 k2 {- k! _/ Ca=n.encode('utf-8')   
+ W1 q3 C1 @/ Q8 _$ @print(a)
5 M" Q. c+ j* Ib=a.decode('utf-8')
print(b)
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
print(a)
7 f3 m' C' }: d) z) O3 K7 kb=a.decode('gbk')
print(b)28、求 1-100 内的所有数的和
. x7 O; F- f8 F' qcount=1
sum=0
for i in range(100) :
    sum=sum+count
' ]; e/ Q& j2 R; K  U- }) \    count+=1
/ R: m1 w; y( ?) F! A/ H3 O  X7 R9 tprint(sum)

count=1
sum=0
% c# b$ K( d4 G( o( awhile count<=100 :
/ p9 ], p7 g3 u5 X1 M0 v    sum+=count
2 r! S; [# H, T8 L' J, P6 ?    count+=1
  T! q0 G3 w! ]$ `5 s' s3 S/ D" \print(sum)29、元素分类
3 P. l" C% V3 L% H. J) R有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
将小于 66 的值保存至第二个 key 的值中。
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
2 N0 m4 k8 O/ D+ Vli=[11,22,33,44,55,66,77,88,99,90]
dic1={
    'max':[],
8 X' k! `& E. Z* |    'min':[]
! P9 d4 f+ j( p' n6 i}
1 Q: X# G, I2 D/ h! afor i in li :
    if i <66 :
' H& X7 z& J+ ~        dic1['min'].append(i)
    else:
        dic1['max'].append(i)
0 ~, X0 F5 O* A" Y8 i7 A$ b  [, iprint(dic1)

; j  J! X+ V3 @9 _7 ?$ R9 @---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
$ A5 \4 w- a, I: U