Python基础知识汇总

1.执行脚本的两种方式

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

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

2、简述位、字节的关系

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

: V( K# ?+ a9 ?- ]: U8 ?! h3、简述 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个字节代表一个字符，

. r$ w9 s; N, J* |( P4、请写出 “李杰” 分别用 utf-8 和 gbk 编码所占的位数

utf-8    是3 bytes=24bit

gbk     是2bytes=16bit

5、Pyhton 单行注释和多行注释分别用什么?

单行注释  #

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

! U: ]' R# ~% h6 y6 p- j+ W) w6、声明变量注意事项有那些?

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

不能以Python的关键字命名，

能表明变量的意义

8、如何查看变量在内存中的地址?
z=1
print(id(z))
: z) q' P- p1 F# t+ i4 a9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

7 Q/ ^/ Y8 p3 j6 g; Z* y# R* L10、写代码
a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
+ [/ G5 x5 N+ t) Tname=input('name:').strip()
pwd=input('pwd：').strip()
if name=='seven' and pwd=='123' :
0 C/ c+ l' _0 w4 B: M6 A7 G( k    print('ok')
else:
9 b( i4 I( q2 @" V+ d# e6 s9 H1 ]; e! q    print('error')
9 |& `( m& K. M* s+ x8 b+ l! T
% H7 L$ A/ F4 ?2 r) Ab.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
count=1
* A4 ?2 O7 e) V7 Hwhile count<=3 :
; x' l  ]% ^0 ~( q* T" w* M    name = input('name:').strip()
/ F: P& m$ i. a  p( P* t  J    pwd = input('pwd：').strip()

! l6 z; a' X: g5 t    if name=='seven' and pwd=='123' :
& F1 W$ [* j9 H; W- _+ m  w* d        print('ok')
& T* I( e5 F: j9 X; k, w9 Z    else:
        print('error')
        count += 1
for循环：
for count in range(3) :
. Z/ A* D: d, `; \( l0 E9 O    name = input('name:').strip()
    pwd = input('pwd：').strip()
: p& N& O6 `, _1 f
0 ?3 H$ u/ b4 P    if name=='seven' and pwd=='123' :
        print('ok')
    else:
        print('error')
        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
/ ]" P3 m" P6 |9 _count =1
while count<=3 :
: u7 }. [, i" q1 |* V+ ?" d    name = input('name: ')
    pwd = input('pwd: ')
4 W" E9 f2 c' R6 C0 n; m! m    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
& f$ l1 h/ t+ r# a- {        print('ok')
4 `6 Q/ I% o. s- y' ~    else :
        print('error')
/ ^, Y( ?' [9 e( ~. l- ~6 S) d: x        count+=1
8 D; w0 J. m# V6 zfor循环
for count in range(3)  :
- m: a4 u7 m+ s* v9 J    name = input('name: ')
    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
        print('ok')
    else :
+ V1 l. o) R: {; q: I        print('error')
& o" B+ s; `/ U/ U  u8 B3 j        count+=111、写代码
+ \9 J9 T/ Y. ?. j0 j" U! t% Oa. 使用while循环实现输出2-3+4-5+6...+100 的和
count=2
num=0
while count<=100 :
    if count % 2 ==0 :
; p7 h3 g- Q  k! c  y        num=count+num
        count+=1
    else:
        num=num-count
6 @( A5 D  R9 I0 E1 A        count+=1
5 B0 ]* F. h" {( Cprint(num)

b. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
num=0
count=1
for count in range(100) :
8 N( f: W. c* E  a    if count % 2 == 0 :
        num=num - count
" r2 {2 J% Q1 F. _/ W: l3 @9 |! \& k0 {    else :
3 v$ Y) i7 F) {, @$ M% ]        num=num+count
print(num)

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

count=1
while count < 13 :
' {6 P& x7 ~' N, T+ P    if count !=6 :
        if count !=10 :
% g# ]2 X) g/ l+ O4 R            print(count)

: _( w5 o1 j( c2 g- K1 t    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
for i in range(101) :
* S, @9 R$ }$ f! `9 c1 B3 _    if i %2 != 0 :
        print(i)

, Z- y8 K' h1 ~3 U% Y; P* Dcount=0
while count<100 :
& c8 f6 N; V# S, |    if count %2 != 0 :
        print(count)
+ [& B0 t4 @, D; T/ j% _: T    count += 1

e. 使用 while 循环实现输出 1-100 内的所有偶数
8 \, F* V6 a- D% G; \# B. c& hfor i in range(100) :
5 p' }# [3 p0 U8 Y6 d% l    if i %2 == 0:
3 L' `# }/ z- v        print(i)
6 |' k" B4 ?1 w1 P/ l
2 }% l; ]7 T* A6 hcount=0
while count<100 :
9 q2 G( I' q6 f" p2 K    if count%2 == 0 :
        print(count)
, L+ s8 s# s2 ~' y5 t- n3 G& k    count+=1
8 }! l; w* r$ t3 c
# J) `4 c2 L+ Z. ?, {12、分别书写数字 5，10，32，7 的二进制表示

* J" B: ?7 v- Q9 V6 [6 fprint(bin(5))二进制   0b101
/ o6 h. V/ _3 e8 _print(hex(10))十六进制  0x5
- r* z$ n5 B/ ]! N0 {0 l8 i3 k% [/ Y  }print(oct(5))  八进制  0o5
14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

$ }' C, E9 n1 F- Z. v3 i16、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123456 n2 = n1n2赋值给n1.指向同一个内存地址，
: P) m+ g8 z, {17、如有一下变量 n1 = 5，请使用 int 的提供的方法，得到该变量最少可以用多少个二进制位表示?

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

/ x6 U" I8 s' h& ~; @18、布尔值分别有什么?

False .Ture ,或1  和0

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

b. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
print(name.startswith('al'))
" ?5 y' [5 r. N4 h& a+ B: n8 U& Zc. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
, p+ }2 E0 _8 i1 {/ ~1 R: M) vd. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
print(name.replace('l','p'))   apex  
e. 将 name 变量对应的值根据 “l” 分割，并输出结果。
0 v* n* ]% @% x& g7 ]print(name.split('e'))   ['al', 'x  ']  列表

# E6 A& M+ d: d/ z5 [- C" l4 F' \" sg. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])
3 X6 W% \! |$ c5 t  g
j. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
# Q% W; F0 R$ x# S2 c( @, q依赖索引
name = "Alex  "
" }9 [- J  y! d; L' b. xfor i in range(len(name)) :
) D3 ~* o& V5 p    print(name)
for i in name:
: j" X, c; S) r* d+ o4 ]    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')      
print(li)
['alex', 'eric', 'rain', 'seven']
+ @4 _& g* P3 f% {' b  D  Mc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
, `' n& K: [" w. n7 Uprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
print(li)
' e1 q7 h" R: H; L. p; re. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
& S. W/ r1 [: P* S, u  o- gli.pop(1)
% C. t  k9 t5 M+ s* sprint(li)    ['alex', 'rain']
指名道姓的删除li = ['alex', 'eric', 'rain']
li.remove('alex')
print(li)
# {' g7 `9 Q) T. F( N+ n# Df. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
print(li.pop(1))
/ a( r+ ^9 w* |/ v6 U9 y3 @0 d8 xprint(li)

1 f5 }; Q0 K, I! Eeric
['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):
' i4 G. K4 `4 w5 f* K    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
a. 请输出 “Kelly”
& e+ [! x1 F; Zli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
7 J4 I9 S  u5 x+ R9 p' L! i4 wprint(li[2][1][1])
% e: k9 J6 s" f" o/ Cb. 请使用索引找到 'all' 元素并将其修改为 “ALL”
li[2][2]='ALL'
print(li)
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
print(len(tu))
7 ]- f% D, c8 g/ y9 s6 E4 cb. 获取元组的第 2 个元素，并输出
( F( E  O) ~1 o, }) h$ sprint(tu[1])
$ k  w3 z. a! Se. 请使用 for、len、range 输出元组的索引
4 I$ g& b2 H$ T! M: ofor i in range(len(tu)) :
  T: \" I1 S. `2 R0 s2 f    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
7 W: \% w2 Q5 H$ I; g8 c, i- Ufor k,v in enumerate(tu,10) :
    print(k,v)
10 alex
, x# R; M4 g) }7 Q  ^; X/ i11 eric
12 rain
0 w' r/ _+ _/ T7 O* ]) \8 ?$ ?% p3 u
for k in enumerate(tu,10) :
    print(k)
: _- C- F2 _- Q% b2 J9 P(10, 'alex')
& \! N" ]: g7 i: N: I  J- |' k(11, 'eric')
(12, 'rain')


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

元组，不可以

d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
  v- Y( k% O( I% ]2 ztu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
1 z+ a! z! `) e# o  X# y2 Sres=tu[1][2]['k2'].append('seven')

print(tu)
26、字典
' R$ A7 r5 @* [6 h. Fdic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
, [! O, g' {7 W# V. C    print(i)b. 请循环输出所有的 value
for i in dic:
    print(dic)
1 a, i/ A6 W2 E8 J8 Ac. 请循环输出所有的 key 和 valuefor i in dic:
, z& v/ w: [1 D7 W& y1 mprint(i,dic)
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
- l! D/ p* k: F+ T7 C  g# s; Kdic['k4']='v4'
6 K1 m0 h- d' N: x1 tprint(dic)
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
$ r% |& t" G5 l9 k0 pdic['k1']='alex'
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
dic['k3'].append(44)
print(dic)
6 [0 c: Z+ V5 _  M8 J
+ @3 O6 p+ E. v* H! W9 f: Fg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
! }8 g& v, H6 G# n+ l( Xdic['k3'].insert(0,44)
6 C7 N, s4 Y- q% h% _& L2 u6 xprint(dic)
  T& L. S, J- k% L: x3 j, A# T- B/ l27、转换
a. 将字符串 s = "alex" 转换成列表  s = "alex"
1 V" S* S( \7 T, M6 V# a
5 D  [" k, d0 u2 o2 h# |print(list(s))b. 将字符串 s = "alex" 转换成元祖
s = "alex"
) C1 Q4 r7 n1 `! t  J0 }print(tuple(s))

6 ?  g: p- w  u" Jb. 将列表 li = ["alex", "seven"] 转换成元组
li = ["alex", "seven"]
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
tu = ('Alex', "seven")
  |. C# G; T: h( j- \li=list(tu)
print(li)

8 f. P5 [' i9 j& p& I# _1 X
0 b7 q6 |8 }0 M+ qd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增

2 c1 Q: z% S$ [) B) fdic={}
# L3 K- P: v. L0 @for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
    dic[k]=v
* n( h) i9 i) e/ F4 P0 H  h' Q    print(dic)27、转码n = "老男孩"
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
a=n.encode('utf-8')   
+ d1 v. n1 \& g7 s! Hprint(a)
b=a.decode('utf-8')
print(b)
, W1 t  h& o2 H# G8 M  {b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
print(a)
# k3 v* K) @$ v  z6 A4 F' ^b=a.decode('gbk')
) ~2 k4 Y7 C0 v. D, g, T8 p7 S" fprint(b)28、求 1-100 内的所有数的和
count=1
sum=0
; G1 A+ c8 l# R! q: M' ]for i in range(100) :
    sum=sum+count
    count+=1
print(sum)
: N8 s! j. ^7 Y( v8 k& h& @
count=1
2 |" N. |* E5 n+ Z: [* ?- isum=0
while count<=100 :
    sum+=count
    count+=1
* G( g) b/ o  B/ J6 U& G6 @print(sum)29、元素分类
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
将小于 66 的值保存至第二个 key 的值中。
& q# G' v7 [# [6 R即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
+ Q; s' k8 h& k+ y, x* Y$ rli=[11,22,33,44,55,66,77,88,99,90]
  u; h: v6 U# U. T3 `" Edic1={
    'max':[],
. n4 ~. ~: ]& c    'min':[]
! p' T1 ~) ~( z$ F}
, s& C* D# v, S3 d, D. Cfor i in li :
    if i <66 :
        dic1['min'].append(i)
  k. F( Q) f) l) ]; C  Z9 R; }    else:
        dic1['max'].append(i)
& ?! c" C9 d4 q5 y8 Hprint(dic1)

---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
8 c5 m( B& s- Y# p/ l