Python基础知识汇总

1.执行脚本的两种方式

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

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

2、简述位、字节的关系

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

: p; \+ |- b  e/ J) O. J+ m; D7 i3、简述 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

; n  j: x/ v  R0 @0 \5、Pyhton 单行注释和多行注释分别用什么?

单行注释  #

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

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

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

不能以Python的关键字命名，

能表明变量的意义

8、如何查看变量在内存中的地址?
$ P/ F1 U1 @- S# Dz=1
print(id(z))
& |5 I; H! P% [, A9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

10、写代码
a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
0 Z) ^! I/ b' ]. W) t+ W5 g9 t+ r, Cname=input('name:').strip()
pwd=input('pwd：').strip()
if name=='seven' and pwd=='123' :
    print('ok')
9 {# w% K  _, _2 H2 U+ Qelse:
4 k" D: T" D; \# F, N' I    print('error')

* G  x/ q# g& d; kb.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
count=1
while count<=3 :
" B' {6 ^5 M3 ^! j    name = input('name:').strip()
    pwd = input('pwd：').strip()
4 k7 i! c8 D6 y7 G, y; D
$ q# O) i  N8 W    if name=='seven' and pwd=='123' :
        print('ok')
: _# G" o/ E0 J' s    else:
. @. c( s/ N, H2 G        print('error')
. C( l$ z4 u9 c4 d$ |        count += 1
2 i& ^8 P2 i4 r0 C( hfor循环：
for count in range(3) :
    name = input('name:').strip()
% F7 ?- T, g. r" \$ l% w3 w    pwd = input('pwd：').strip()
' Q$ S2 S4 {* W6 I; i! K6 p3 o
    if name=='seven' and pwd=='123' :
        print('ok')
/ q* w1 u3 j9 E9 P$ I( b    else:
        print('error')
        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
$ E7 s$ \0 @7 r4 Q+ K' }8 Rcount =1
( Y5 Y- ?5 W, ]# Uwhile count<=3 :
    name = input('name: ')
    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
8 D2 G$ @3 T1 G! W( }: R6 r8 O    else :
) @  D: r) i$ @- K        print('error')
        count+=1
for循环
5 L( r& O7 N8 _' Yfor count in range(3)  :
, f3 `6 C) q- X* A    name = input('name: ')
) `3 t$ ~: b8 T% ~  e% b# ?    pwd = input('pwd: ')
1 [4 t) D# z2 j2 ]1 ]    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
- j7 k( V3 o" O2 y+ p5 R" ^        print('ok')
& W1 N( j' ]5 ^8 w4 w    else :
        print('error')
. r$ t8 x2 G( _- k        count+=111、写代码
: J/ U/ n1 Z2 z3 {; f# u$ G+ a3 ta. 使用while循环实现输出2-3+4-5+6...+100 的和
count=2
# B$ n" Y* C+ r+ p) dnum=0
9 m& o' \6 i. [' e4 _& Twhile count<=100 :
: y( X; X9 r: r    if count % 2 ==0 :
        num=count+num
        count+=1
    else:
        num=num-count
        count+=1
! N3 j# h8 A% c' p' X( \print(num)
8 t1 y' j# _+ h. X: ]4 l& Y7 G* e; m
b. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
$ ]6 U. n# b0 b/ F$ k* s6 H1 C2 b) Y$ l num=0
) R9 V, B2 A2 h1 O9 b# o7 }count=1
, E6 B* t3 p) Ifor count in range(100) :
' H% G, M* a1 W, P; n    if count % 2 == 0 :
' [/ K- S6 G5 }0 Y9 C* W  s        num=num - count
8 f, p% W+ l5 l- j    else :
, u' {8 }  z1 b+ o$ F" U/ @0 Y        num=num+count
print(num)

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

; Y1 s0 ~2 `( i" Z+ ecount=1
while count < 13 :
: n* q% r% C& `; _( @1 c$ O    if count !=6 :
* f3 g5 ^2 S4 G1 L; o        if count !=10 :
* f" t2 |' j# I" n$ u0 @+ [! }  p" C            print(count)

9 u% p" g, L. c    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
1 }1 m) W2 c9 f5 \7 Nfor i in range(101) :
    if i %2 != 0 :
        print(i)

count=0
9 T( k# b. L: l( hwhile count<100 :
    if count %2 != 0 :
8 z+ `3 {  v4 K3 |! F5 P        print(count)
' D) ~3 {2 k5 G" X+ M) \  D    count += 1
, s3 U5 A4 J( Y. p. H9 d5 H
e. 使用 while 循环实现输出 1-100 内的所有偶数
# {; x7 O# {- I$ u  B. hfor i in range(100) :
5 N9 A3 a2 G0 i& _- V    if i %2 == 0:
4 Q+ C+ u* W4 f( W, [5 _1 U        print(i)

count=0
while count<100 :
: N) u( \. W  a) H: u0 ?    if count%2 == 0 :
        print(count)
    count+=1

12、分别书写数字 5，10，32，7 的二进制表示

print(bin(5))二进制   0b101
print(hex(10))十六进制  0x5
print(oct(5))  八进制  0o5
1 o3 _' O9 l) G" ?+ q14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

, Y) ?6 ^! Q$ V" F# Q! u& b9 d16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

n1=5
+ d! R4 X% k# e. {print(int.bit_length(n1))  结果  3

3 i) t  k% m$ O  L. ]4 H) E. l
  ~0 s4 F" C  z1 K2 A" U18、布尔值分别有什么?

False .Ture ,或1  和0

8 ^% Z" c, u3 W7 L8 ^20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
a. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())

# G* C( W! d. ~3 `2 i" Qb. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
3 ?0 R( H  f% m- h/ Gprint(name.startswith('al'))
9 ~* d+ D$ @2 K: D6 S" }c. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
4 @$ N; O' M4 Q6 w! C4 g" gd. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
" L) v6 L, m: H4 @print(name.replace('l','p'))   apex  
e. 将 name 变量对应的值根据 “l” 分割，并输出结果。
print(name.split('e'))   ['al', 'x  ']  列表

/ `$ e: U/ p9 W4 [2 m( J# rg. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])
$ Q1 y2 ?( K9 c3 A" W
) T1 c2 I3 }5 [. w! \7 Lj. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
! @" ^9 J6 @8 N% a$ k* F依赖索引
" ~5 E- t8 V7 z1 X* kname = "Alex  "
3 D6 f! H; C5 ifor i in range(len(name)) :
. w$ W2 i: F- R/ g* U    print(name)
# C, |) a) B/ N& x/ Ofor 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')      
4 x* I6 a- A+ u) Rprint(li)
: W: v5 s# a5 n1 z; r1 C ['alex', 'eric', 'rain', 'seven']
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
2 o- ~! V0 U0 F) W9 n7 n& Fprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
0 ?  h6 n7 P# K& X# F2 b- rprint(li)
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
% Y1 M( U4 c& J9 ]$ Y- Pli.pop(1)
print(li)    ['alex', 'rain']
1 @5 @0 C' `0 B6 [指名道姓的删除li = ['alex', 'eric', 'rain']
- J2 s- [" L( Q2 u7 Kli.remove('alex')
1 l7 Y0 `: g% P8 D/ nprint(li)
% K+ G5 u( N! ~: Y) N& E/ `6 D) e, uf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
print(li.pop(1))
( p  J( q/ {2 M1 E2 W. Q) k' mprint(li)
& Q  g, O' M1 q4 v% j3 J& n
2 W, a& ?+ ~" K# G( {eric
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
del li[1:]
. u3 `- [; _5 e7 d2 wprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
5 P1 v  S% c4 F1 Lli = ['alex', 'eric', 'rain']
- W# A! q6 l+ ^: Qfor k,v in enumerate(li,1):
    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
  V; y2 D9 c% ^( S8 ]8 u, ea. 请输出 “Kelly”
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
print(li[2][1][1])
) _' c5 ^3 w3 [4 V1 L. Bb. 请使用索引找到 'all' 元素并将其修改为 “ALL”
! R* P5 o7 T! h7 Cli[2][2]='ALL'
/ ~, J# q2 d$ u# fprint(li)
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
. k  Y7 z5 b' Y* I+ Za. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
# J1 a" I+ ^: g( e* \print(len(tu))
' D* P9 N2 _) w4 j& i) Cb. 获取元组的第 2 个元素，并输出
print(tu[1])
e. 请使用 for、len、range 输出元组的索引
. I5 o5 x5 U& n) v$ \, Vfor i in range(len(tu)) :
6 N3 |+ W8 B; T' C    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
for k,v in enumerate(tu,10) :
( ]0 ?1 _8 k2 u6 l' J* K4 @    print(k,v)
0 c9 W, \( j/ u! ]) v8 Z4 a8 X, d10 alex
11 eric
12 rain
$ i5 C- B5 E" ^" V6 k+ \' Z2 u
: t3 o+ j& S3 u* l5 ofor k in enumerate(tu,10) :
    print(k)
2 Z. ?8 a+ c+ U; R9 x' O" b(10, 'alex')
(11, 'eric')
(12, 'rain')
- S6 G8 f; E5 V
, y' p$ b# F. N$ u
/ ~/ P. V* C5 ?  _  h25、有如下变量，请实现要求的功能
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

元组，不可以

d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
% y  `6 V$ X% {, @5 ?- O; }; rres=tu[1][2]['k2'].append('seven')
4 ?  B) l+ i+ a" ]5 c3 I/ Z
print(tu)
; U: T, l7 R3 a+ b, i26、字典
8 j9 c( S0 }- @; v# zdic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
- ^& m" u/ C/ m$ n9 S4 b# q! w    print(i)b. 请循环输出所有的 value
$ A$ J7 T) E2 O- J0 l, b4 G# gfor i in dic:
    print(dic)
c. 请循环输出所有的 key 和 valuefor i in dic:
' K) E# b/ I8 C2 O5 Aprint(i,dic)
& g: Y1 b- |7 G' ^4 R8 ]9 ~d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
: t& D4 V5 e8 ]3 i5 _dic['k4']='v4'
print(dic)
9 k/ o/ l0 n* ee. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
: l2 n3 O8 f7 Q% P+ x" s$ pdic['k1']='alex'
( k8 `1 x3 N+ S" Y+ Cprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
, f$ t4 O* }# b3 O6 u- `dic['k3'].append(44)
print(dic)
4 {  B  t! v" s  P, h$ F6 X! ~
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
dic['k3'].insert(0,44)
print(dic)
27、转换
  S* y2 S( k: @0 `. t+ Ta. 将字符串 s = "alex" 转换成列表  s = "alex"
" }; ]# c$ i( [- A  h
print(list(s))b. 将字符串 s = "alex" 转换成元祖
s = "alex"
2 w' [6 e' u. M* c* K9 G2 `; t& `5 Xprint(tuple(s))
- N+ m* |7 i1 L
- ^" o9 s& ?/ J# Kb. 将列表 li = ["alex", "seven"] 转换成元组
% D! D# J+ p9 {; [) i  r5 u* ?1 rli = ["alex", "seven"]
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
tu = ('Alex', "seven")
li=list(tu)
; G% _9 r0 v! F6 mprint(li)

. M! I& {, U2 u9 L' C' p
2 }# F! t% ?  `# Z+ Y! v7 K7 k$ Od. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
! P, L- K' k8 i8 n/ p
dic={}
# k& U, @) `* {for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
' j: Z  b3 Q+ w% t5 D    dic[k]=v
    print(dic)27、转码n = "老男孩"
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
a=n.encode('utf-8')   
print(a)
b=a.decode('utf-8')
print(b)
) V) J# M' {1 u- ?# Nb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
7 ]5 {: J, G0 B& D: bprint(a)
b=a.decode('gbk')
print(b)28、求 1-100 内的所有数的和
count=1
sum=0
for i in range(100) :
    sum=sum+count
    count+=1
print(sum)
2 z$ Q  W1 o% `; W/ w- A
count=1
5 L% L7 ]8 x* ]0 \sum=0
0 }1 H3 k/ \& S) g4 U0 }+ Kwhile count<=100 :
' M. w9 f  m" y' L7 h3 A8 S% R    sum+=count
5 g9 T% X! D* `% {    count+=1
( W4 E* e8 \2 q7 q) F7 H5 kprint(sum)29、元素分类
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
将小于 66 的值保存至第二个 key 的值中。
3 z8 w* G7 F  e9 J, Q2 ~' f, b即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
li=[11,22,33,44,55,66,77,88,99,90]
& m' h% q2 f& E$ D8 ^dic1={
    'max':[],
3 D7 p5 V% _8 u0 T+ w    'min':[]
}
for i in li :
: ]6 T9 j7 {; p/ L    if i <66 :
        dic1['min'].append(i)
# f- P, ?; _8 r    else:
        dic1['max'].append(i)
print(dic1)

---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
) w% M: Y3 d1 |0 E2 M