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

" i: R& f; d* @5、Pyhton 单行注释和多行注释分别用什么?

单行注释  #

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

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

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

不能以Python的关键字命名，

能表明变量的意义

8、如何查看变量在内存中的地址?
; d  b! U1 g% g% cz=1
print(id(z))
7 c0 @1 J5 t6 L, i! I5 t9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

10、写代码
a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
& W2 Y% A% g# S' ?! Ename=input('name:').strip()
5 p. \" u4 d8 D, P& C4 Bpwd=input('pwd：').strip()
5 c1 R) M! E) I6 U/ g( {if name=='seven' and pwd=='123' :
% h$ K0 Y5 o' b) }9 i6 m    print('ok')
else:
    print('error')
6 L& G, e) |3 p8 o
% x% A3 k( b9 A! H# G) U- Ub.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
count=1
while count<=3 :
+ X+ V: z% N# ~9 `8 r5 E    name = input('name:').strip()
    pwd = input('pwd：').strip()
& z: v8 b0 y# r) X+ I& r- }9 c
    if name=='seven' and pwd=='123' :
        print('ok')
    else:
' j8 _7 w- q: x        print('error')
0 J/ w$ M, Y1 j7 X- G, s0 L" l        count += 1
: [* @: P7 b8 \: \- y! Dfor循环：
for count in range(3) :
    name = input('name:').strip()
    pwd = input('pwd：').strip()

$ x3 H$ V/ j- o5 p. x  K, O( v7 u    if name=='seven' and pwd=='123' :
        print('ok')
6 I" F3 s$ H( ^: y3 @    else:
! ~+ I6 }8 N+ n! B. h. A3 {1 I        print('error')
& p8 c# ^+ h4 J% t' W- X8 x        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
count =1
while count<=3 :
    name = input('name: ')
    pwd = input('pwd: ')
, m4 K% j, Y9 E  }; t7 {9 h. `    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
0 R  X. Z+ s$ ^( _, Q- w& K: A# l        print('ok')
    else :
        print('error')
! N( X6 m9 E; Y        count+=1
9 W0 f- q4 d2 i7 ~5 Dfor循环
for count in range(3)  :
    name = input('name: ')
2 s8 T; x3 a0 i/ `    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
' e& ~. S' ?0 a. N, Y    else :
        print('error')
        count+=111、写代码
: i1 h* A( E2 Q6 [a. 使用while循环实现输出2-3+4-5+6...+100 的和
count=2
num=0
5 }5 B, i6 p/ f3 R. C, j. }9 d- r& Swhile count<=100 :
    if count % 2 ==0 :
* v" m- j3 O0 L7 s, e2 N# c; e; @$ I        num=count+num
        count+=1
    else:
        num=num-count
- k* _  J6 N# `8 N        count+=1
8 [2 a- f$ l) s8 y- c2 f! Kprint(num)
! W- I: T( f  }
+ L" ]+ w, J) b. u( j! \/ `5 Y. v2 Ib. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
6 l1 X4 c% a- {0 N3 R+ z+ C num=0
2 S: x# q  y8 kcount=1
for count in range(100) :
! x, g* \6 F9 t+ O% |5 Z8 S8 A  F    if count % 2 == 0 :
# ?# x5 e% w' c        num=num - count
    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 :
& l7 `1 O( j: l% _        if count !=10 :
            print(count)
, [/ Y: R" l9 H6 M6 O4 l" E+ k
    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
( J* X* J' H) ?5 M: p3 hfor i in range(101) :
    if i %2 != 0 :
6 d& R* A/ f; R& M" y. f( @3 w' {( n        print(i)

count=0
- i& x2 y( ^* V: U2 _while count<100 :
- ]( ]1 E" m3 ?    if count %2 != 0 :
        print(count)
6 B' X7 J$ i, k    count += 1

e. 使用 while 循环实现输出 1-100 内的所有偶数
9 O9 y' g1 _! Y8 a$ Wfor i in range(100) :
    if i %2 == 0:
* m$ m( @5 S/ _* ?        print(i)
9 [% \: ?7 K7 e, B! p- s# [
' e0 H9 N1 O- c- j* O2 |count=0
( z0 g: r! s% Z9 U, O2 fwhile count<100 :
' R8 W0 g4 ]! v  |! d5 I$ }- t    if count%2 == 0 :
        print(count)
    count+=1

12、分别书写数字 5，10，32，7 的二进制表示
' w4 F" C9 A. }6 F/ l% T9 b
% w* {0 _. i1 T! gprint(bin(5))二进制   0b101
: y0 D6 P3 g4 n# L  \# lprint(hex(10))十六进制  0x5
: D* ?6 |; |2 Z# V' H, H" Eprint(oct(5))  八进制  0o5
6 Z$ N" }0 }5 R, J# q14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
0 {) J4 H% {8 R) w17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

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

9 Y/ I! F. w9 }, w# K* l
* c2 q% l9 E" p1 P5 p: ~18、布尔值分别有什么?

False .Ture ,或1  和0

- E9 `5 c/ P* I3 T+ D0 {20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
  G) }% w3 q# F8 U+ F- D  Ka. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())
9 s! p7 {; {: x  P& D$ W! c5 E
b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
print(name.startswith('al'))
c. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
d. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
# L! O6 |, V: ^5 m& I1 Hprint(name.replace('l','p'))   apex  
, C( @$ p, Q# C9 g( v3 m9 u5 ]e. 将 name 变量对应的值根据 “l” 分割，并输出结果。
print(name.split('e'))   ['al', 'x  ']  列表
' }7 `% Q  a; q
g. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])
+ r- m2 A. W: E3 {4 |/ z- c
j. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
% h1 F2 q, v3 w8 w依赖索引
name = "Alex  "
for i in range(len(name)) :
, ]4 F* [  c- }2 [1 X    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']
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
' h% W" j1 w6 Hprint(li)
['alex', 'eric', 'rain', 'seven']
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
print(li)
7 K% |' L* @0 n3 t' b/ T! k: k! F1 Le. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
/ b4 H' R$ t. m" _li.pop(1)
( l9 ~3 z) j8 o  \: Sprint(li)    ['alex', 'rain']
8 a* d2 L- g  [6 a指名道姓的删除li = ['alex', 'eric', 'rain']
li.remove('alex')
print(li)
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
print(li.pop(1))
- A% A* k) l) yprint(li)

eric
3 ~) J+ n( B% Y% H2 D4 Y['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
del li[1:]
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
li = ['alex', 'eric', 'rain']
for k,v in enumerate(li,1):
6 V/ b- r: x- \# S& l4 `3 s    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
+ R8 E0 {" W5 p+ ^8 `" ^! Da. 请输出 “Kelly”
6 \5 C3 f& n; p7 F9 t3 E6 |  G$ {/ vli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
. w  t! Z" ^+ I* }- jprint(li[2][1][1])
8 J+ R& ^# o5 \7 u: bb. 请使用索引找到 'all' 元素并将其修改为 “ALL”
li[2][2]='ALL'
print(li)
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
$ E2 [, W; j- P. g, H9 Oa. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
print(len(tu))
) a+ W* V: V+ ^b. 获取元组的第 2 个元素，并输出
+ Z; E9 P9 w. q' |# t, S2 Jprint(tu[1])
e. 请使用 for、len、range 输出元组的索引
for i in range(len(tu)) :
$ J/ }/ T4 V8 T+ U% w7 i7 q+ A% [    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
for k,v in enumerate(tu,10) :
* q' A0 F+ V" S" D: I/ Z    print(k,v)
10 alex
# g/ N" ~. y( c+ S5 K" j11 eric
12 rain
. m" T; z- }8 B% m, t/ F
for k in enumerate(tu,10) :
    print(k)
(10, 'alex')
(11, 'eric')
(12, 'rain')
( G9 U9 ~2 E* k

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

元组，不可以

! ^) k" H$ v9 ~2 B5 B% c" `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')

' I$ G1 h! c! ]4 o7 vprint(tu)
0 B3 X5 n, G7 J. I' P; t26、字典
* g) R/ }, r0 j$ \) [3 ?dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
    print(i)b. 请循环输出所有的 value
for i in dic:
    print(dic)
c. 请循环输出所有的 key 和 valuefor i in dic:
, p6 Q- p8 P* g% \1 Gprint(i,dic)
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
$ b6 C3 u0 J1 p: \9 V; edic['k4']='v4'
: U4 b; H/ \$ {! oprint(dic)
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
, r, V$ v! P% V( I; m9 y. J4 {: Gdic['k1']='alex'
: j: ?! q4 G: k2 e$ Xprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
dic['k3'].append(44)
* x+ \) O3 S+ R. [1 ~print(dic)
9 B9 `+ h3 ~3 T9 i, @
5 W# @% z% B# @0 E! _6 x% mg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
2 ?/ t0 I7 r# N, H" d; j+ Sdic['k3'].insert(0,44)
print(dic)
7 r0 K; U. Q) V* B% Y3 j) Q27、转换
5 A  c$ \) @6 e$ {) s; B( \a. 将字符串 s = "alex" 转换成列表  s = "alex"
1 H2 Q5 C; A+ e4 W% y
print(list(s))b. 将字符串 s = "alex" 转换成元祖
s = "alex"
; q3 f" a' {5 r; h3 r; ]8 lprint(tuple(s))
, H# G' Y" N4 u1 b) ?0 B
b. 将列表 li = ["alex", "seven"] 转换成元组
li = ["alex", "seven"]
- P4 ?( L: k8 f' ^print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
tu = ('Alex', "seven")
+ I' P2 s5 m0 x4 e  J0 y7 m+ uli=list(tu)
print(li)
! Z7 B1 G" i# X# L0 S

d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
3 h) k1 e+ v) \; r
dic={}
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
6 t0 g) B) H! {7 K" c7 B    dic[k]=v
    print(dic)27、转码n = "老男孩"
. r, E* z; |3 Y$ Y$ Aa. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
a=n.encode('utf-8')   
print(a)
, W5 M4 }2 W& Ab=a.decode('utf-8')
print(b)
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
4 k; z/ r: V8 q1 _print(a)
b=a.decode('gbk')
7 v2 V- u; A( t, }/ P4 t) p! rprint(b)28、求 1-100 内的所有数的和
( m, K  @& s. ?" }  k- zcount=1
sum=0
for i in range(100) :
    sum=sum+count
    count+=1
! h% y3 ?  e9 j  Z: tprint(sum)
" G3 ?! Z+ a4 s- C! J
count=1
sum=0
+ m0 Q% I  _8 W6 s# Hwhile count<=100 :
    sum+=count
    count+=1
6 M+ u9 B0 o. Q# e: V9 _6 Q- Pprint(sum)29、元素分类
6 x* |3 n5 Y$ A$ q* r* S% C7 e有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
; K/ `% \/ V' E4 O将小于 66 的值保存至第二个 key 的值中。
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
li=[11,22,33,44,55,66,77,88,99,90]
dic1={
    'max':[],
    'min':[]
: x9 A8 V, e: N, b" p/ B}
9 \) x2 X0 ]$ Xfor i in li :
2 |% O5 A; j/ h8 ], t' f    if i <66 :
! L1 O$ C  m1 A6 l1 }2 R9 o        dic1['min'].append(i)
    else:
        dic1['max'].append(i)
$ X( S# [8 d- j/ c5 w( `print(dic1)

* c4 y) k% |6 r4 Q9 ~" _. f---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}