Python基础知识汇总

1.执行脚本的两种方式

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

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

2、简述位、字节的关系

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

. ^0 W5 z, C# D4 J4 X1 ~' t3、简述 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

0 d( i1 y+ l2 S- J4 ]$ f; O5、Pyhton 单行注释和多行注释分别用什么?

单行注释  #

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

( s& q- {; z0 }) U, h6、声明变量注意事项有那些?

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

不能以Python的关键字命名，

能表明变量的意义

8、如何查看变量在内存中的地址?
z=1
print(id(z))
/ g8 f  C4 ~; l% q5 W9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

10、写代码
a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
4 ?& r$ h, j2 K$ Y/ ?1 vname=input('name:').strip()
pwd=input('pwd：').strip()
if name=='seven' and pwd=='123' :
! q* d. |' ]4 y5 {; C    print('ok')
else:
    print('error')
! Q9 _9 h: x' S$ a% \5 v
( a# i0 _* v! z& rb.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
8 {3 G; K" ~! M4 o8 G" ]3 Ycount=1
while count<=3 :
    name = input('name:').strip()
    pwd = input('pwd：').strip()
8 l# ^. K! Y1 c$ I6 y' r% h
    if name=='seven' and pwd=='123' :
        print('ok')
9 v, g9 Y  [& F8 R5 y    else:
( l0 h* q2 C/ a0 B) t        print('error')
        count += 1
: {: H* Y5 Y& y, z/ tfor循环：
8 q5 d0 y5 _4 I. Q" p* S7 efor count in range(3) :
    name = input('name:').strip()
* R6 w0 u6 M/ L: o" i" R( z    pwd = input('pwd：').strip()

4 B. R& F, f% K; J8 p    if name=='seven' and pwd=='123' :
        print('ok')
7 i3 t" m2 t$ T/ S' f6 v    else:
        print('error')
' g* f, [# B- O7 Z2 x2 w        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
0 w5 l/ J& N$ X! {+ l0 qcount =1
& M4 M' F$ h; c4 B7 d) m; W# Owhile count<=3 :
    name = input('name: ')
    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
  c# d$ O( X2 M1 S( a' Y    else :
        print('error')
! @% v) g+ m7 E" }4 t        count+=1
' }2 L6 D' M5 a% Rfor循环
for count in range(3)  :
# m2 p" r! D) i" z1 g5 U2 }    name = input('name: ')
    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
$ q4 R8 F- U3 G( K% W! L        print('ok')
    else :
8 w2 N7 o2 @9 c" h) o        print('error')
        count+=111、写代码
a. 使用while循环实现输出2-3+4-5+6...+100 的和
count=2
4 `6 [: ?( u# _" \* u8 g% J# xnum=0
6 U4 O0 R' s. B  k, y2 ^$ s+ _- Owhile count<=100 :
1 E  j, Y+ f- h    if count % 2 ==0 :
        num=count+num
        count+=1
    else:
! E9 N; S  L* X        num=num-count
# Y3 k8 ~' d" ]- m. k! k! n& p        count+=1
print(num)
: E& \; c% e: w* a+ a6 M/ X9 b9 g
( H$ U. G* ?6 r# j9 wb. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
num=0
count=1
4 \' t0 E4 F' Z+ T. g; A/ f- afor count in range(100) :
    if count % 2 == 0 :
        num=num - count
    else :
        num=num+count
/ X* ]/ _: R2 `0 }4 a! l* s6 tprint(num)

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

count=1
7 f' l/ p0 @7 S6 m+ p. r! Wwhile count < 13 :
    if count !=6 :
        if count !=10 :
7 C* q, W# Y3 j4 ]8 f: z/ t            print(count)

* o8 K$ X) y: c9 s    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
for i in range(101) :
    if i %2 != 0 :
        print(i)

count=0
while count<100 :
    if count %2 != 0 :
        print(count)
    count += 1
9 V  X  f# e7 W
( o5 t2 [8 v$ X! u8 O- D. Xe. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
    if i %2 == 0:
6 J* a5 A8 E; l* _$ w% d        print(i)

count=0
while count<100 :
0 x. I! ?6 h/ ?    if count%2 == 0 :
        print(count)
    count+=1

( E/ ]9 D3 ]' q$ @5 C5 ^, `12、分别书写数字 5，10，32，7 的二进制表示
1 h; u" A* K7 X) J0 _
print(bin(5))二进制   0b101
print(hex(10))十六进制  0x5
! V/ m3 M% N1 r4 ^5 ~% q" X- P0 yprint(oct(5))  八进制  0o5
14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

( u/ n( Z1 |4 R5 V! k' r16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
' V# g* I# I9 }8 f4 T0 M. \17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

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

18、布尔值分别有什么?

False .Ture ,或1  和0

20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
a. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())
( {- q; X+ l8 [/ b3 V
1 A3 r$ \4 c* e7 n) d4 x# i  Xb. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
print(name.startswith('al'))
c. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
d. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
. i, `! A, D2 B; h' Yprint(name.replace('l','p'))   apex  
e. 将 name 变量对应的值根据 “l” 分割，并输出结果。
print(name.split('e'))   ['al', 'x  ']  列表
' U5 |8 O* M+ q$ N
0 c2 g9 Y  A8 xg. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])
4 w0 X) X4 Q+ P3 C4 r$ B6 r
j. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
3 q& |( A( a1 s. d$ Z" ]& S2 r21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
依赖索引
) ^7 b- t$ V! s5 ]3 n7 Iname = "Alex  "
) @. H, W6 I* ?for i in range(len(name)) :
2 a$ s" }4 A9 R/ q    print(name)
for i in name:
  U7 G1 X) A1 n& G  r7 E2 i    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
) Z) B+ V  F: |9 ?+ gprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
print(li)
['alex', 'eric', 'rain', 'seven']
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
print(li)
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
li.pop(1)
0 x) D1 u  m4 @1 k  O  ?4 dprint(li)    ['alex', 'rain']
指名道姓的删除li = ['alex', 'eric', 'rain']
li.remove('alex')
print(li)
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
/ \) E. e, f* S; v7 Bprint(li.pop(1))
print(li)

6 @9 E8 A8 ~! L9 ~* B- I8 ~+ G2 ~eric
$ n$ a2 I' U. f['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
/ |: {" ?8 G2 idel li[1:]
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
% A* n# ~4 s$ O% H2 Dli = ['alex', 'eric', 'rain']
3 t# T: l. S6 ?for k,v in enumerate(li,1):
; L' F; n) x$ B; y    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
a. 请输出 “Kelly”
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
) F+ S( }5 }! Aprint(li[2][1][1])
4 n. q% P4 C, r0 M1 \* a- }b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
( E4 ]* q# T7 o( oli[2][2]='ALL'
9 f; T1 f' s1 [2 y# ]. Zprint(li)
9 H: a, {# o% H  ]7 y% a6 A24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
/ V3 o( o# I, l( q' O1 [& @% ~* Q0 P, ta. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
print(len(tu))
1 B8 x& {' e5 `6 A1 X$ ]5 Wb. 获取元组的第 2 个元素，并输出
, B: y, f, k# V3 d% \print(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) :
( Q3 Z; [6 l: h! H. w. X+ I# s    print(k,v)
10 alex
  n, u8 M: m0 N/ W: p11 eric
12 rain
* v' i1 G: D  C& L
for k in enumerate(tu,10) :
* e9 }7 A8 ~' [1 ^    print(k)
(10, 'alex')
2 d9 F! f. h$ {0 W5 N(11, 'eric')
8 m2 e" O8 |1 S(12, 'rain')

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

元组，不可以

7 s" X; t+ i' d. l3 ld. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
res=tu[1][2]['k2'].append('seven')

print(tu)
0 B1 [- K5 g' B- J- s% [5 h4 {26、字典
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
$ s  R$ W+ w8 m4 V, K0 b4 \    print(i)b. 请循环输出所有的 value
7 z! ^. y4 l$ ?) S, f) @3 b3 ^for i in dic:
    print(dic)
c. 请循环输出所有的 key 和 valuefor i in dic:
print(i,dic)
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
dic['k4']='v4'
9 q2 i, _4 ?, [) o$ v, }9 g# t, Qprint(dic)
. x/ ]; V5 g  i9 se. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
dic['k1']='alex'
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
dic['k3'].append(44)
; Q3 ?" T/ K6 y% }( @print(dic)

g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
; |& h% o9 K5 l! h. Z3 Xdic['k3'].insert(0,44)
# S& f$ c" `, ^0 _' R% {print(dic)
* H# P$ {' f1 k27、转换
: b+ K4 j0 L1 q0 @/ ?a. 将字符串 s = "alex" 转换成列表  s = "alex"

print(list(s))b. 将字符串 s = "alex" 转换成元祖
s = "alex"
print(tuple(s))
6 `+ @' V* O/ t$ p
7 v$ ?5 @( o( w# ~) @& Wb. 将列表 li = ["alex", "seven"] 转换成元组
li = ["alex", "seven"]
3 L/ `! L$ D6 v( C' q; i! ^7 kprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
tu = ('Alex', "seven")
6 r3 m8 i/ L' m! ~/ Y. y* Fli=list(tu)
print(li)

' ?! O: a) v7 ^+ D+ d6 R
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
: n$ D7 `, E+ I
dic={}
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
    dic[k]=v
    print(dic)27、转码n = "老男孩"
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
a=n.encode('utf-8')   
# I% S5 K1 e! n0 o. u- t4 Zprint(a)
b=a.decode('utf-8')
print(b)
6 i# d% Z( u; [; u/ t& X) lb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
print(a)
' v8 f+ E) J3 Y4 s4 A- g) ]0 W% \b=a.decode('gbk')
( N. i2 u$ q) I4 Pprint(b)28、求 1-100 内的所有数的和
& q* B* a# q3 k9 Wcount=1
sum=0
for i in range(100) :
    sum=sum+count
    count+=1
print(sum)

0 X  o4 C+ p* O- @% ^count=1
sum=0
while count<=100 :
  I7 ^/ J9 ?$ W9 G& w; l" d    sum+=count
    count+=1
4 E/ K% Y  U$ M1 P. d: j/ Lprint(sum)29、元素分类
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
将小于 66 的值保存至第二个 key 的值中。
1 T% H4 e5 S1 ?1 U/ B0 w即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
li=[11,22,33,44,55,66,77,88,99,90]
* W7 r/ _2 S0 N# pdic1={
    'max':[],
    'min':[]
}
for i in li :
; G7 z! t% j/ |" M" Z8 B6 g    if i <66 :
3 i3 W# e! q; q7 ?$ S7 F/ E% q' n        dic1['min'].append(i)
    else:
        dic1['max'].append(i)
print(dic1)
- V( n; Z: Q2 p0 D# r. C
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
7 D* z7 d1 R$ ~4 i3 j