Python基础知识汇总

1.执行脚本的两种方式

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

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

2、简述位、字节的关系

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

1 i/ ^3 u/ b) K3 V3、简述 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 单行注释和多行注释分别用什么?

单行注释  #

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

/ [9 k; a  K6 Y: K. p6、声明变量注意事项有那些?

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

不能以Python的关键字命名，

能表明变量的意义

4 O. _/ U2 |4 d% m; C1 l, H" S& k$ B8、如何查看变量在内存中的地址?
0 t& y# W. l8 y& x7 Cz=1
8 X9 i. r& f: ]print(id(z))
9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

10、写代码
+ @( ^* C/ e& v' Ga.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
name=input('name:').strip()
pwd=input('pwd：').strip()
1 a9 q* {1 s/ }if name=='seven' and pwd=='123' :
    print('ok')
else:
    print('error')
- F6 Q& o8 r* l2 u+ ]4 ]  Q3 t
b.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
count=1
+ T5 I) f9 R+ cwhile count<=3 :
    name = input('name:').strip()
    pwd = input('pwd：').strip()
$ @! G( n7 y! q7 p
    if name=='seven' and pwd=='123' :
        print('ok')
8 W8 @; |( t; N0 g* a8 J$ u    else:
        print('error')
  x$ G$ Q2 o  b0 h        count += 1
; ~' i. K7 E, z' q& {7 z7 ]for循环：
for count in range(3) :
- m( k& e6 p+ z/ D1 x/ t4 s! F  ~    name = input('name:').strip()
! n  I0 O$ H. D7 d- _    pwd = input('pwd：').strip()

* f( T# Z8 g/ O, P5 L( u  C    if name=='seven' and pwd=='123' :
' G) A. D. Y! w7 m8 Y        print('ok')
) b) V& m' G4 L' E& Z9 p& L    else:
5 H3 u/ A" B* A5 _+ t7 M: \        print('error')
2 b' f$ j" }  ?; b) t        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
  u0 M0 f& b) u& pcount =1
while count<=3 :
    name = input('name: ')
    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
) n: d4 A1 [& j9 P; V' d# m        print('ok')
    else :
  m# R4 m9 Q4 w1 x1 U9 R9 @* s        print('error')
        count+=1
for循环
3 r8 i" L4 W3 T# l$ [for count in range(3)  :
/ Q" w5 b. o% d  h- B    name = input('name: ')
    pwd = input('pwd: ')
; z, F! J6 d- J6 y- H! [    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
+ J9 ?4 y+ b2 X& [, M0 B) R8 \        print('ok')
    else :
        print('error')
6 ]. F, ^4 V. D! [3 P" B/ P        count+=111、写代码
1 ]( D5 K( T6 Y' V8 |. xa. 使用while循环实现输出2-3+4-5+6...+100 的和
count=2
: r/ `9 ^( c1 H( ~num=0
while count<=100 :
    if count % 2 ==0 :
# \, e' ]( g4 c+ E        num=count+num
        count+=1
    else:
        num=num-count
+ Z! N- F! @2 ]% U) {        count+=1
+ w# i+ }# n' N7 o( bprint(num)
: U$ V1 ]0 }% [7 n1 h6 [
. _+ @1 F$ Z* ^' y, ~% sb. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
. w; Y7 q& d9 Q9 m) ^  D. z0 T num=0
, r6 T; h* V% L' i! H; K+ @4 Bcount=1
for count in range(100) :
    if count % 2 == 0 :
        num=num - count
% j" {# g; H% H7 y1 [; g    else :
        num=num+count
* B) `+ R* O2 t' }print(num)

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

count=1
, S* n+ S6 J7 w* n4 N' O0 M5 F+ vwhile count < 13 :
% G9 l3 s% a+ Z    if count !=6 :
, I* D0 h0 I$ g/ [: U/ K  {$ Q( m        if count !=10 :
            print(count)
9 I  r5 }! m- q3 ?8 {; ]
    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
5 P% U  w; y+ t! C, vfor i in range(101) :
    if i %2 != 0 :
        print(i)
9 t0 F' ?/ c4 ]0 S  r( L
+ D5 T: L& i; f% x" R. N3 y6 Dcount=0
2 `3 \% X6 D3 b! ?& Twhile count<100 :
- B1 q! \  f: w    if count %2 != 0 :
        print(count)
/ r* s9 l4 z# j9 J1 L  O' g" K    count += 1

% G! u8 a: m+ T5 x" `' ye. 使用 while 循环实现输出 1-100 内的所有偶数
( q* h% O. X, [" n! yfor i in range(100) :
- t3 o( C/ I/ y- U    if i %2 == 0:
4 T: U# i& h( |9 ?) F        print(i)

count=0
$ Q+ J! H, X$ P6 e2 s$ |; {* Q7 Xwhile count<100 :
$ }0 a! a# c0 N0 ]7 Q. \8 a  M" p    if count%2 == 0 :
        print(count)
    count+=1
6 S! U! D+ ?* e( _" ~
  f6 T+ M2 w4 t$ `$ R3 n12、分别书写数字 5，10，32，7 的二进制表示
: {* J. s  K8 p; h# R7 j
  ?5 m( Z$ P& E# X$ C" }5 d2 c6 nprint(bin(5))二进制   0b101
print(hex(10))十六进制  0x5
% E7 C5 x4 ?! C+ q, Nprint(oct(5))  八进制  0o5
7 R% r$ V$ x9 h% C& v+ o$ m3 `14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

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

n1=5
. c4 e! {/ x' G6 Hprint(int.bit_length(n1))  结果  3

18、布尔值分别有什么?

False .Ture ,或1  和0

& x8 {0 u3 \# T. q) U% _- p/ _20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
3 X: m, |( W+ da. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())
9 W5 N! Z$ l* d) K; C
b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
print(name.startswith('al'))
. s* I1 [6 S& Xc. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
# q& s/ z  j( `( P, yd. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
print(name.replace('l','p'))   apex  
e. 将 name 变量对应的值根据 “l” 分割，并输出结果。
' a  k8 r! j' m$ E+ O# P( m8 m! Rprint(name.split('e'))   ['al', 'x  ']  列表
7 l$ [7 m) R9 t; K* w: ?, D
+ {2 ]# o7 x/ g5 k" G" `6 kg. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])

j. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
5 v- K+ l( x9 r: k- J1 V依赖索引
name = "Alex  "
for i in range(len(name)) :
3 `* S. i) M0 i. p& e' }; k5 n    print(name)
4 l9 d: H7 I. k+ c5 ^  ]% Cfor i in name:
8 a) d9 t/ [; d# p    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
& z+ y# r: r/ w3 m22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
print(li)
  Z1 ^8 Q' n2 s6 j' m& f ['alex', 'eric', 'rain', 'seven']
2 K% J5 i& {7 ^' T. bc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
3 T( A0 T7 I) Y7 ~3 bprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
" P) C1 u# x* l; \5 _' ^6 {) u/ Aprint(li)
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
li.pop(1)
print(li)    ['alex', 'rain']
5 Q4 R! L# Y' n3 B7 B# w( B. V指名道姓的删除li = ['alex', 'eric', 'rain']
1 B3 x  O3 d- K& o  X5 h" l& Rli.remove('alex')
& [+ ?* z& G5 l9 W. Iprint(li)
+ \  O1 O1 _4 j3 F7 v9 Tf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
print(li.pop(1))
print(li)

/ Q1 @! a+ _9 e/ Y5 S- Geric
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
del li[1:]
. [. U: @; F1 [& _- lprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
li = ['alex', 'eric', 'rain']
1 K: O. k- q1 T+ d/ q4 g; mfor k,v in enumerate(li,1):
    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
a. 请输出 “Kelly”
8 ^  _) L- ]8 j0 m& r% C; S5 E8 kli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
$ p5 x3 |  O# h' Q. p0 mprint(li[2][1][1])
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
  P- X- @! E" c0 J$ _( d) Mli[2][2]='ALL'
print(li)
9 v; B* H1 H- `24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
9 l! s3 Z! a" D# h1 la. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
print(len(tu))
b. 获取元组的第 2 个元素，并输出
2 P0 f+ C, _+ b; f* Y8 S6 ]/ U$ Aprint(tu[1])
& ]6 y% e4 s' D4 |+ Le. 请使用 for、len、range 输出元组的索引
' L4 Y/ _7 Q9 P" O0 P% D+ P( Bfor i in range(len(tu)) :
    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
  L3 \# [3 W: _% U1 Q. c/ efor k,v in enumerate(tu,10) :
9 n8 I, z1 }" U- a& x    print(k,v)
* \! |7 l, j5 a3 Z; L10 alex
11 eric
& C8 h1 \1 O8 |& C7 |  x9 O4 \12 rain
* t  s# d3 J% B/ q4 m1 _3 b3 @
for k in enumerate(tu,10) :
# R8 [- U4 ]) q# `. B    print(k)
(10, 'alex')
(11, 'eric')
(12, 'rain')
8 ]. y0 v- F0 g* o" K

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

元组，不可以

) ~) \4 e' y  W8 J* I" gd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
3 m  ]. v& S0 \- @+ ores=tu[1][2]['k2'].append('seven')
, j5 a3 e6 s7 N, v$ L
3 c( c5 O8 k7 ?5 u1 L5 b3 gprint(tu)
26、字典
' O: R5 V! t7 i5 F6 C: ?6 i& w) vdic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
9 K: `+ l2 [0 `2 N' k    print(i)b. 请循环输出所有的 value
for i in dic:
) F* y+ U* Y5 |% Q! |    print(dic)
/ T* ]6 L( G) f" ^; l( c) Z( wc. 请循环输出所有的 key 和 valuefor i in dic:
print(i,dic)
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
0 I+ _9 B* Q0 t# a, [2 K0 ]dic['k4']='v4'
: J; `- Z. x* d: |$ R6 Sprint(dic)
% P; C" k- b% P, ^5 se. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
dic['k1']='alex'
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
dic['k3'].append(44)
print(dic)
! @- @/ U7 x: B8 z) }
, }5 w) \7 [* c1 H. H4 j) m8 Bg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
0 p2 g1 i6 _; a0 I; H+ e$ ydic['k3'].insert(0,44)
print(dic)
, f" v7 f. K; ?5 ~27、转换
a. 将字符串 s = "alex" 转换成列表  s = "alex"
" g! |" `- n9 W, h( B- |7 @
print(list(s))b. 将字符串 s = "alex" 转换成元祖
( \: ]/ d& K8 t( X3 Ss = "alex"
+ d& S8 I' J, }. sprint(tuple(s))
2 a* j, F3 t* n- H
b. 将列表 li = ["alex", "seven"] 转换成元组
li = ["alex", "seven"]
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
, s# w- h% h5 D( T+ xtu = ('Alex', "seven")
li=list(tu)
print(li)
' t/ Z* Z9 Z% a7 e( N5 M! d

d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
0 o: B$ y% k2 r! D4 D
  r) E! S; H+ j& u( g& p6 ldic={}
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
    dic[k]=v
* ^' P% v  Q5 W5 T  `/ C9 K9 G- q    print(dic)27、转码n = "老男孩"
; V& S, g0 K+ f2 }, B4 @a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
a=n.encode('utf-8')   
7 f0 }5 u2 m2 B- J+ p9 m: Uprint(a)
8 Q/ P+ D3 B7 M9 u% x% o3 y6 pb=a.decode('utf-8')
print(b)
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
print(a)
b=a.decode('gbk')
% N: ^) t% F/ ^" r% ^; e* Bprint(b)28、求 1-100 内的所有数的和
$ l( r% a1 d  |5 K( Q0 tcount=1
8 }: K( i- r. w+ G, h6 }( z, hsum=0
7 S) B' x' z8 ~% B( Cfor i in range(100) :
3 u8 u& i8 i; s. l; s- R7 g/ A. o/ M    sum=sum+count
    count+=1
print(sum)
1 J! `' L$ N, O, |
count=1
% t: q" C9 M2 o! m' V: \' osum=0
. o7 p- D) x; T0 E! |7 B5 v/ \8 qwhile count<=100 :
    sum+=count
    count+=1
8 K# N* C6 z# V3 rprint(sum)29、元素分类
  b$ h/ F/ c6 u( S有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
. I0 A2 w/ i) I' @9 F$ J1 V将小于 66 的值保存至第二个 key 的值中。
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
li=[11,22,33,44,55,66,77,88,99,90]
) ?* H# }7 Y# Jdic1={
    'max':[],
    'min':[]
}
" F  |) \; y' i( pfor i in li :
5 y+ K" f! s& ~% [! r4 e    if i <66 :
+ i$ {8 H9 Y, z4 F' o' y1 R. F        dic1['min'].append(i)
; y4 \. z% L! r$ f4 ]3 M$ ~    else:
        dic1['max'].append(i)
2 H. U; f  i( x7 c# K2 yprint(dic1)

---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
1 j8 f5 W2 D  d+ b5 L