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个字节代表一个字符，

7 _5 V8 W' p( i/ i1 u4、请写出 “李杰” 分别用 utf-8 和 gbk 编码所占的位数

utf-8    是3 bytes=24bit

gbk     是2bytes=16bit

/ h3 c( g; k2 f, \! w4 ~9 T5、Pyhton 单行注释和多行注释分别用什么?

单行注释  #

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

+ |" U8 C  o, H! a1 P; T" U; M6、声明变量注意事项有那些?

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

不能以Python的关键字命名，

能表明变量的意义

( [! v3 s% r2 V4 i; b8、如何查看变量在内存中的地址?
( [1 w/ M$ \; o6 xz=1
print(id(z))
" ?+ C* q+ f* q9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

10、写代码
a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
name=input('name:').strip()
pwd=input('pwd：').strip()
/ V2 M2 u# L$ ?0 z& Wif name=='seven' and pwd=='123' :
    print('ok')
else:
0 R3 z& _% I( v8 Z. g2 x    print('error')
* m- R( D7 d* `7 j: \. s
% ]2 x# C, r! s, }" P' A7 Tb.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
+ W5 o  ~& {2 T2 e  i1 z! ^; lcount=1
# `3 F9 v0 v) c1 Iwhile count<=3 :
    name = input('name:').strip()
6 j( U0 K% E# z1 _0 y    pwd = input('pwd：').strip()

9 r- M  q: r- `  V    if name=='seven' and pwd=='123' :
        print('ok')
    else:
% G, X# j! `8 r  Y2 h8 M) r: v        print('error')
  s) p  ?( Z9 F" c7 W3 f9 k  f3 f        count += 1
: E2 _+ O& w  F' gfor循环：
: A# v5 f2 n  L/ F2 ufor count in range(3) :
    name = input('name:').strip()
! ~# \: P* P7 \    pwd = input('pwd：').strip()

9 b7 \$ W4 m) B) O: F+ `' U    if name=='seven' and pwd=='123' :
; q/ M; I2 m" C        print('ok')
+ h, @, g$ W% p: h) a. Q8 P    else:
7 c4 |; C4 o" P( z  D+ ^        print('error')
- M7 Z5 z- V2 f( E) l        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
% [+ C* O. E, r# ]- ]$ G' Rcount =1
1 @" I9 V; o+ Q) P7 z7 k& K7 Dwhile count<=3 :
! Y% {6 o  g1 H, E; S$ y    name = input('name: ')
    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
    else :
8 d' k7 Y! Z0 M/ `8 T/ t! I        print('error')
        count+=1
for循环
2 _5 q! G; d. y9 j: g% o! dfor count in range(3)  :
    name = input('name: ')
    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
    else :
2 a; U* K' ~7 d" l( A" {5 ~% b        print('error')
        count+=111、写代码
( K4 X9 g' V! w; Q7 |7 ga. 使用while循环实现输出2-3+4-5+6...+100 的和
count=2
num=0
while count<=100 :
+ n* ~' e! u+ P8 o    if count % 2 ==0 :
        num=count+num
        count+=1
    else:
; c6 W# l5 H7 u' M        num=num-count
! U. P6 p7 X" H1 Z' E" [, S        count+=1
print(num)
: q. F; E/ P5 _
4 r" s6 b! h  B, Z5 b0 t- F) hb. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
6 t8 t, C' A0 _% E* h% _# G0 q  r num=0
& C2 l4 S' H1 G( v5 o+ C+ wcount=1
for count in range(100) :
; A: @  p* N. i2 H# K9 w5 R    if count % 2 == 0 :
        num=num - count
$ k- L3 Q! }( b! K2 H    else :
        num=num+count
print(num)

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

4 B+ I/ t# W& Q: B3 _9 r" f4 }$ l6 @count=1
while count < 13 :
7 _! z* j5 @4 [7 D+ c    if count !=6 :
        if count !=10 :
; B2 ]4 g3 m+ K* C+ W            print(count)
2 _3 L2 I" R0 ]
    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
for i in range(101) :
/ u$ \2 O, w( z/ u+ o3 N1 P( D    if i %2 != 0 :
7 |3 m8 b6 Y. J2 r        print(i)
$ f( G* Q9 a/ P: M8 m9 G
* k3 p3 j5 d. }) Bcount=0
while count<100 :
    if count %2 != 0 :
        print(count)
    count += 1

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
    if i %2 == 0:
        print(i)

count=0
while count<100 :
! l. z/ r8 n  G    if count%2 == 0 :
        print(count)
" ~% [+ G3 }5 a6 a    count+=1
+ l" Y/ F# b4 m2 T  T4 i# o
12、分别书写数字 5，10，32，7 的二进制表示
. N" r, k5 B) Y/ D1 _7 n
. P8 q; j2 z! l4 o# B  cprint(bin(5))二进制   0b101
$ a; Z# u; t/ X* Z& jprint(hex(10))十六进制  0x5
; s9 Q; U- ]7 C/ Aprint(oct(5))  八进制  0o5
) ~2 v2 A! Y: d3 H  I( Q14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

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

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

" r) p, B' d7 D2 ~
+ Y' |; j/ b* Q! e: s+ R/ S' V% A& w18、布尔值分别有什么?

False .Ture ,或1  和0

6 P  {7 L% l- L' q& a' k20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"
( n# B) w) Q. @a. 移除 name 变量对应的值两边的空格，并输入移除有的内容print(name.strip())

b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
print(name.startswith('al'))
c. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
d. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
print(name.replace('l','p'))   apex  
e. 将 name 变量对应的值根据 “l” 分割，并输出结果。
print(name.split('e'))   ['al', 'x  ']  列表
- d" n: \! J% `3 }9 }
3 B! t8 S6 `$ k& _' `- W- Ug. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])
6 Q. ]: x' ]. f0 x
j. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
& `$ Y8 R  A; i, ~. ]21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
9 |. V- i+ R* I# s; l依赖索引
name = "Alex  "
for i in range(len(name)) :
    print(name)
( X9 a! P; \) u" ?' K4 p, A. _for i in name:
8 ?# H  H! m1 B7 I- K+ G    print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain']))    alex_eric_rain
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
/ v! D* z) a% wprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')      
print(li)
['alex', 'eric', 'rain', 'seven']
: S/ Z8 j' t, a3 mc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
  |- z3 t7 C+ Uprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
! s4 r/ }0 x$ \# V! vprint(li)
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
li.pop(1)
$ h/ u/ g  S) N6 Q" B0 vprint(li)    ['alex', 'rain']
指名道姓的删除li = ['alex', 'eric', 'rain']
li.remove('alex')
; D  K: w7 e  b) Qprint(li)
& e' v6 Y! R" B- O" z7 [5 o& qf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
5 d8 c( y4 d$ d  ~0 L7 tprint(li.pop(1))
; y5 \  q+ R! Oprint(li)
! S7 A+ ^; T+ B! t/ V4 P5 o
. n  o$ B  C5 Z2 Z& xeric
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
# y5 I# _" X9 V$ L7 {, N7 F/ `1 ?9 hdel li[1:]
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
0 V& F% S. z/ a, Dli = ['alex', 'eric', 'rain']
8 d3 V0 I. O7 r; e: }for k,v in enumerate(li,1):
3 }2 P6 z, `8 L% a2 ~0 l. V    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
a. 请输出 “Kelly”
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
# \+ c" F6 C5 Rprint(li[2][1][1])
$ @7 `. Q8 R9 Q- V( a7 Nb. 请使用索引找到 'all' 元素并将其修改为 “ALL”
li[2][2]='ALL'
print(li)
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
+ j! i) c+ R6 y+ Sprint(len(tu))
. }+ E0 R' X; }7 d$ u8 A+ Z6 Y6 qb. 获取元组的第 2 个元素，并输出
% \8 B+ U' |% Y( Tprint(tu[1])
e. 请使用 for、len、range 输出元组的索引
& X& ~/ q: r2 L4 A- f) ]; ^for i in range(len(tu)) :
    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
* m% e8 ?. Z$ R6 \* \. Ifor k,v in enumerate(tu,10) :
    print(k,v)
% X7 X  N, b: {10 alex
11 eric
: Q- T: y9 V8 ^. q! `' Y7 q0 I$ a12 rain
  [+ H- O$ d9 h/ b
+ O7 V3 u  T8 o( j4 Ufor k in enumerate(tu,10) :
: t, R* Q5 B/ h' j! M    print(k)
(10, 'alex')
(11, 'eric')
9 a# `4 e) X  T2 F3 `8 N4 M& e5 M(12, 'rain')
* B" F& d0 y9 L1 b, }* y

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

元组，不可以

+ l2 Z1 g$ q! A; h( J8 cd. 请问 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)
% Z# E  F  A- |% n' i26、字典
- e, R: p5 {; i/ z. zdic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
6 n/ C; u8 v! E' U' n! R    print(i)b. 请循环输出所有的 value
for i in dic:
4 g- ?; ~/ Q: Y) C/ m2 k) D" l/ g+ {    print(dic)
c. 请循环输出所有的 key 和 valuefor i in dic:
; ?4 @- Y# l- E. Y, F6 rprint(i,dic)
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
dic['k4']='v4'
print(dic)
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
dic['k1']='alex'
2 |. }7 d+ U! i: b6 |# i( r3 o* T% Fprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
2 V0 a9 {8 T( L# Q# H4 Xdic['k3'].append(44)
print(dic)
) p# A# {3 t( S$ u+ \" U* I$ J
- z$ \! G% p& s0 w$ _) o, T* \g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
. k4 o, b* A  W/ l. ^dic['k3'].insert(0,44)
/ g/ h& T+ y* K) nprint(dic)
! |: ^; S8 K0 w27、转换
5 r5 t" a8 n2 u$ y4 Ga. 将字符串 s = "alex" 转换成列表  s = "alex"
5 }  C7 p5 h- d* y. n, {. Y. Q
* v0 t/ a& j7 v- l: a6 p7 Uprint(list(s))b. 将字符串 s = "alex" 转换成元祖
* P7 |6 s+ X5 ]1 Qs = "alex"
print(tuple(s))
% _  B' j, G4 ]4 G5 h! J
b. 将列表 li = ["alex", "seven"] 转换成元组
li = ["alex", "seven"]
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
$ z9 O9 @) n2 p: w& \, wtu = ('Alex', "seven")
: h& M+ h+ p4 }# l0 k$ Sli=list(tu)
3 D. n* w& c) s- [print(li)
9 u) o, e  W' A# O
$ V- r2 n; S" b: \# M
% U" @( D; m3 ~1 d  W- A. _d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增

dic={}
7 _$ k4 |' h3 T( r! v6 z/ h4 Ufor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
7 G8 k+ N: @9 |' v& s$ b$ [    dic[k]=v
    print(dic)27、转码n = "老男孩"
! ]5 Q3 ]6 H( X5 ^& ]( ?6 X) _a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
a=n.encode('utf-8')   
  q& x' ~6 ?' Q+ Mprint(a)
b=a.decode('utf-8')
% C% \5 w8 x$ @' Z$ m/ P; ]: bprint(b)
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
print(a)
b=a.decode('gbk')
5 J! n- Z* B1 `( \7 X7 mprint(b)28、求 1-100 内的所有数的和
: O& ~2 c2 h8 X, M* W0 [# w/ V1 Wcount=1
: h8 r- p9 S) @' usum=0
5 E) a2 \$ `. c! W! Z9 p" p( Nfor i in range(100) :
    sum=sum+count
    count+=1
print(sum)
4 L8 a/ u- u! ~  a* p7 x3 N* }
count=1
" _3 g6 w% u3 |* W, y# H6 Esum=0
6 _7 }# o$ |4 {% j9 zwhile count<=100 :
/ B4 V6 X1 b: `& S7 A: t$ `, _5 H* S% `    sum+=count
    count+=1
; j. R& k: ]4 |# @print(sum)29、元素分类
1 R% I0 F; E! Z5 w# T) r; x% ~# Z  x* r有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
- p8 {& u) ~1 T7 j8 Z将小于 66 的值保存至第二个 key 的值中。
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
li=[11,22,33,44,55,66,77,88,99,90]
dic1={
4 l6 O% q1 O/ B; W7 r( [* [. X    'max':[],
9 V  o  B  z" {3 {0 \) k$ _6 C: B7 ?    'min':[]
}
for i in li :
    if i <66 :
        dic1['min'].append(i)
( E0 B+ O# S! c6 v* R    else:
        dic1['max'].append(i)
  }1 ^. f* O; H/ i; B0 h: jprint(dic1)

3 r5 C1 E+ }, d6 g% Y' J2 |9 n5 X---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
1 u8 N( C8 ~: L8 ^# M7 i