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

& l- c3 z% }+ @4、请写出 “李杰” 分别用 utf-8 和 gbk 编码所占的位数

utf-8    是3 bytes=24bit

gbk     是2bytes=16bit

4 ~8 R+ l( S9 J) I. Z- W$ o, H5、Pyhton 单行注释和多行注释分别用什么?

单行注释  #

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

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

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

不能以Python的关键字命名，

能表明变量的意义

& u+ x7 x% u8 ]" J. c# p8、如何查看变量在内存中的地址?
+ p  M6 K$ G# ~* H0 h* `; y1 L8 lz=1
print(id(z))
9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

10、写代码
a.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败!
, H6 p- V- X- {, d) k! `name=input('name:').strip()
( x. q( {" F  o; B4 zpwd=input('pwd：').strip()
0 i( a, w$ N/ ?if name=='seven' and pwd=='123' :
    print('ok')
8 r5 F% y7 H+ T- R' o) Belse:
: w% }3 B& }, M( H* Y3 f# i7 m7 K    print('error')

b.实现用户输入用户名和密码，当用户名为 seven 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
# ^  g4 _" P5 B7 k* t% n% pcount=1
- t% x( j% R/ `2 O$ ^! R4 ~while count<=3 :
( y! `% O* M/ f3 U, Y    name = input('name:').strip()
* ?+ _9 e& {( K: s) P( {: ?    pwd = input('pwd：').strip()
$ U' P* l* o& ~& @3 l; K
- M. h9 g7 X9 _    if name=='seven' and pwd=='123' :
        print('ok')
. u) D7 Y+ E, s3 @  E5 U3 G    else:
        print('error')
        count += 1
for循环：
for count in range(3) :
    name = input('name:').strip()
8 Q2 c8 ~/ G/ Z" x    pwd = input('pwd：').strip()
9 M1 w' V6 C, @5 `  e) q
0 }- O+ E4 D' y! d4 l4 |  k    if name=='seven' and pwd=='123' :
        print('ok')
    else:
- i5 T+ l4 ?% S  n8 T6 ]        print('error')
$ l2 `# t2 s+ |: H        count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且 密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
' e$ r" `5 j) K. w) Bcount =1
# k4 E% H! u* x4 F5 a" Vwhile count<=3 :
$ ~* _7 v* _5 u8 _7 _. P; q; _    name = input('name: ')
2 f2 t7 n$ P/ A  l5 U    pwd = input('pwd: ')
    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
, W1 R4 n( H6 \: i$ j        print('ok')
    else :
        print('error')
, g# Z" B! ^2 I  U. J4 P6 C        count+=1
for循环
for count in range(3)  :
8 x7 |5 f8 Q) ]    name = input('name: ')
; p4 v" z& n( f, `1 t2 Y    pwd = input('pwd: ')
2 E; f( K# F8 ?! f    if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
: z4 H: k! H8 P1 v0 r1 W' u9 o        print('ok')
# k5 H$ K# W  n: G    else :
        print('error')
/ A, m/ R7 K$ W1 O  ^/ W        count+=111、写代码
- H; F% S- X$ p& \" _9 B7 Sa. 使用while循环实现输出2-3+4-5+6...+100 的和
) p9 m/ |) X, i- K7 O* bcount=2
num=0
" Z3 L0 g5 W5 Twhile count<=100 :
    if count % 2 ==0 :
        num=count+num
        count+=1
    else:
        num=num-count
        count+=1
print(num)
" N( O* E7 e+ S/ i
b. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
/ k0 ~( J* R+ J' ]6 c- U6 J  a( h) p$ W num=0
0 R  Q, M% R" y2 Mcount=1
for count in range(100) :
    if count % 2 == 0 :
        num=num - count
    else :
3 K6 F& J$ A, x' ~4 P# {7 }        num=num+count
print(num)

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

5 L3 \4 Z% U2 i, v9 gcount=1
while count < 13 :
    if count !=6 :
% x- C6 I/ l( c; Q/ ~! T. b        if count !=10 :
$ I6 \  M- b$ C1 d0 I. f            print(count)

0 X9 n, x  `. p3 |% x5 d2 a    count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
for i in range(101) :
/ r; v! Y2 ^: w# x  ~. k$ d* v    if i %2 != 0 :
        print(i)

count=0
while count<100 :
    if count %2 != 0 :
3 N' K1 L' B+ {' M! d0 w! D        print(count)
    count += 1
: k8 G* E! T+ P% R$ \% u" ~1 q
e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
    if i %2 == 0:
8 m2 V% y* ~% j- K        print(i)
& W- W1 g9 u4 S- j
count=0
( F$ v" s6 I: s2 O1 Q$ kwhile count<100 :
    if count%2 == 0 :
        print(count)
    count+=1
$ Z0 t: V3 H) d
12、分别书写数字 5，10，32，7 的二进制表示

print(bin(5))二进制   0b101
print(hex(10))十六进制  0x5
print(oct(5))  八进制  0o5
6 U5 E+ v. `. x4 p# A& }14、现有如下两个变量，请简述 n1 和 n2 是什么关系? n1 = 123 n2 = 123

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

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

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

5 H* |5 W! \3 W8 P
18、布尔值分别有什么?

False .Ture ,或1  和0

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

1 t" X/ W' X, Q' t. y! c, ?: jb. 判断 name 变量对应的值是否以 "al" 开头，并输出结果
print(name.startswith('al'))
c. 判断 name 变量对应的值是否以 "X" 结尾，并输出结果print(name.endswith('x'))
, T( W" W# T% gd. 将 name 变量对应的值中的 “l” 替换为 “p”，并输出结果
print(name.replace('l','p'))   apex  
e. 将 name 变量对应的值根据 “l” 分割，并输出结果。
print(name.split('e'))   ['al', 'x  ']  列表
& K  t  Z1 O+ A& D9 h+ h' k3 T
# d) L! D+ P  c) e$ ], wg. 将 name 变量对应的值变大写，并输出结果print(name.upper())  print(name.lower())i. 请输出 name 变量对应的值的第 2 个字符?print(name[1])
4 M( W1 N% l0 p, m
! K, i% Q! h( zj. 请输出 name 变量对应的值的前 3 个字符?print(name[:3])k. 请输出 name 变量对应的值的后 2 个字符? l. 请输出 name 变量对应的值中 “e” 所在索引位置?print(name.index('e'))
21、字符串是否可迭代?如可以请使用 for 循环每一个元素?
依赖索引
* i& Q2 ]( m* J# P9 Kname = "Alex  "
for i in range(len(name)) :
    print(name)
5 T" P: t9 i$ _: ifor 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')      
print(li)
['alex', 'eric', 'rain', 'seven']
2 r3 R% A) A2 [7 Q9 [; yc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
) c7 S3 C1 R( `) {! q4 ?$ ^print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
print(li)
2 i- Z2 d+ }7 M7 N$ Fe. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
, O$ }' c4 p: ]2 Mli.pop(1)
: Y) e, W  C+ Z. v$ ]print(li)    ['alex', 'rain']
指名道姓的删除li = ['alex', 'eric', 'rain']
li.remove('alex')
print(li)
2 T* Q3 n+ Z/ {- {/ Tf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
print(li.pop(1))
print(li)

eric
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
! d$ T3 Z" H6 E' v% d% r' |8 wdel li[1:]
9 ^( p* u0 f6 U- ?3 Tprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
li = ['alex', 'eric', 'rain']
2 H3 X8 C7 ~$ ?* r+ b4 ~6 vfor k,v in enumerate(li,1):
    print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
* ^6 S+ t( t: e  W1 R, s  {/ S! Na. 请输出 “Kelly”
+ X5 ~0 R! Y( x2 i1 \4 \li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
print(li[2][1][1])
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
li[2][2]='ALL'
! W) R4 Y9 B4 [, I: ^8 a! G0 x# O5 \print(li)
  A7 w2 u7 Y5 o$ b5 J+ z24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
: v# U$ S: e+ s! T! w0 o, j: ^# G& ?print(len(tu))
b. 获取元组的第 2 个元素，并输出
print(tu[1])
e. 请使用 for、len、range 输出元组的索引
' q' W0 _/ V% O7 j, `+ s* Q9 cfor i in range(len(tu)) :
: x6 d# u) s- ~7 a; |/ p. d    print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
for k,v in enumerate(tu,10) :
' [% Y$ v. y, H/ d  }% p/ s1 }    print(k,v)
9 w3 V" t4 i0 w9 `$ C1 ?! H10 alex
11 eric
12 rain
/ O8 B2 l, r% Z' k' G! w
/ n8 b5 i& v& Vfor k in enumerate(tu,10) :
    print(k)
) A$ G* f# D' W, v5 r, m- Y(10, 'alex')
& o; w( L, l. p. D) A(11, 'eric')
: ~- d; Y% h; G  B( z9 U(12, 'rain')
6 n7 f0 T4 i8 O* x  {' N0 R
% C1 R" e4 I* G1 ^7 W+ W% x
25、有如下变量，请实现要求的功能
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”

元组，不可以

, R4 ~, Q: s* T0 |; M, c2 id. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
" j/ i# Z& f8 P9 V! T, H' l% \3 htu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
res=tu[1][2]['k2'].append('seven')
1 C3 e. ]2 F3 {' n+ ?
print(tu)
26、字典
3 }+ J' _' \% |$ V- k7 @7 ]6 edic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
    print(i)b. 请循环输出所有的 value
1 t2 h3 c6 y$ Q3 sfor i in dic:
    print(dic)
c. 请循环输出所有的 key 和 valuefor i in dic:
print(i,dic)
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
7 _# B; S' C5 }, m0 y5 y& Gdic['k4']='v4'
/ G$ s; v% J7 j- u# R3 R; oprint(dic)
  P  A2 u6 {6 Ye. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
dic['k1']='alex'
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
/ m+ x$ H7 Q0 A$ rdic['k3'].append(44)
) G8 B" u+ V: e% C! \  R; _print(dic)
; |0 W2 [: H7 P- i5 a( H9 [
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
dic['k3'].insert(0,44)
print(dic)
0 J; O+ q& q$ _! y27、转换
' Y$ b! T7 x0 d  p) g' `" ga. 将字符串 s = "alex" 转换成列表  s = "alex"
  ~- n5 L. O1 d# h: H: d
8 G( e7 D. j4 w) K/ }) nprint(list(s))b. 将字符串 s = "alex" 转换成元祖
3 B3 e7 \( Q  w9 p& c, as = "alex"
print(tuple(s))

; K1 R; ~( H. Z. n) L7 {b. 将列表 li = ["alex", "seven"] 转换成元组
' m3 w" B: R* O& W6 dli = ["alex", "seven"]
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
; e% j/ F9 K, }- J% T4 z- ptu = ('Alex', "seven")
li=list(tu)
" r! j- N7 [' I" W4 L! Wprint(li)

  d% I; h" Q: a+ y. R4 c! S* H
0 w( |8 H1 D$ U5 Gd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
2 Q5 P( m- V% S' X9 M* |
dic={}
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
    dic[k]=v
    print(dic)27、转码n = "老男孩"
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
/ C! d3 U' o6 V3 ra=n.encode('utf-8')   
print(a)
b=a.decode('utf-8')
/ o1 c) C+ F9 Q9 [1 z% l3 I* Gprint(b)
! v- J' D+ p, G/ w: Wb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
print(a)
9 p7 Q" S; n  [' T; n) h  n; c6 ]b=a.decode('gbk')
# y  k9 W) K5 W9 p) `7 q$ s4 fprint(b)28、求 1-100 内的所有数的和
: Z. c' {( U  Y/ H2 C- F7 Mcount=1
& |, k, \. N/ R# Ysum=0
) u: T" |: t' \' afor i in range(100) :
    sum=sum+count
; z0 M( }$ W/ N/ m3 F/ ~    count+=1
2 _- c% l: _) D4 _4 ~print(sum)

count=1
sum=0
! T" M' p! N, v& }7 J. g5 A6 N% swhile count<=100 :
    sum+=count
, {$ w2 b$ u2 L  M3 W0 X    count+=1
( G/ I. c, e( m$ Z7 C& p3 _, l" K* Iprint(sum)29、元素分类
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
  W  ~6 @, [/ U( o. I0 n; u: i将小于 66 的值保存至第二个 key 的值中。
$ S4 v# u/ H7 i8 R即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
li=[11,22,33,44,55,66,77,88,99,90]
dic1={
    'max':[],
& l/ S" i0 X7 Q# R    'min':[]
}
for i in li :
; v4 ]- E. _2 K% w2 V3 t% L. ?; q( w    if i <66 :
        dic1['min'].append(i)
7 p7 B: _+ u+ b) v3 A; _, J    else:
7 I% t+ j% E) n8 G$ `        dic1['max'].append(i)
print(dic1)
; X* O3 _" Y4 X, \3 Y2 Q, w% e
3 \- N6 o3 d1 j, U3 n! R---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
1 T$ P% j& ~' \3 A" Y0 W. |" G& E