Python基础知识汇总

显示全部楼层 · 2019-6-11 00:22:31

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

4、请写出 “李杰” 分别用 utf-8 和 gbk 编码所占的位数

utf-8 是3 bytes=24bit

gbk 是2bytes=16bit

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

单行注释 #

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

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

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

不能以Python的关键字命名，

能表明变量的意义

8、如何查看变量在内存中的地址?
z=1
print(id(z))
9、执行 Python 程序时，自动生成的 .pyc 文件的作用是什么?

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

10、写代码# ^( A8 T9 d' P& O) q; e+ r
a.实现用户输入用户名和密码，当用户名为 seven 且密码为 123 时，显示登陆成功，否则登陆失败!
name=input('name:').strip()
pwd=input('pwd：').strip()
if name=='seven' and pwd=='123' :
print('ok')
else:
print('error')

b.实现用户输入用户名和密码，当用户名为 seven 且密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while循环：
count=1
while count<=3 :
name = input('name:').strip()
pwd = input('pwd：').strip()

if name=='seven' and pwd=='123' :
      print('ok')
else:
      print('error')
      count += 1
for循环：
for count in range(3) :5 ]4 _7 i2 V( ^
name = input('name:').strip()  ]9 l9 I& P/ l: ~% J9 s% E1 Z
pwd = input('pwd：').strip()
; e# [( g# X5 z, Z8 ?* l- j' j3 B+ c) N8 c& R$ O- w
if name=='seven' and pwd=='123' :" |1 j) |# W( P* I0 @  i* l* V. V/ X9 z
      print('ok')
3 [3 n9 w: w% y" U else:, H; \0 C/ `. H
      print('error')4 n+ p# z; M0 b2 t: E- J5 z( |1 [) P
      count += 1c.实现用户输入用户名和密码，当用户名为 seven 或 alex 且密码为 123 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次while 循环
count =1
while count<=3 :
name = input('name: ')
pwd = input('pwd: ')
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
      print('ok')
else :
      print('error')
      count+=1
for循环
for count in range(3)  :/ C0 g, I; F; x+ f
name = input('name: ')& J3 d& y- w5 _+ P# x
pwd = input('pwd: ')
+ |7 U6 O7 K  g0 m5 P; ^- F if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':$ r, B; R! L: d" m) n! w9 b" q
      print('ok')7 q9 Y# n/ O+ S; p: p% z: ]: N
else :. Z, T% s7 `+ [
      print('error')
+ |( E9 U+ Y/ n' a4 Z6 c! h       count+=111、写代码
; s9 w& [& i. g; @1 x+ H& }a. 使用while循环实现输出2-3+4-5+6...+100 的和
count=2
num=0
while count<=100 :
if count % 2 ==0 :
      num=count+num
      count+=1
else:
      num=num-count
      count+=1
print(num)

b. 使用for循环和range实现输出 1-2+3-4+5-6...+99 的和
num=0
count=1
for count in range(100) :
if count % 2 == 0 :
      num=num - count
else :
      num=num+count
print(num)

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

count=1
while count < 13 :
if count !=6 :
      if count !=10 :
         print(count)

count+=1d. 使用 while 循环实现输出 1-100 内的所有奇数
for i in range(101) :
* b% c+ W/ f4 K% G if i %2 != 0 :
! L; a' G: n; E. k5 C; {       print(i)

count=0
while count<100 :
if count %2 != 0 :
      print(count)
count += 1

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
& K  |8 V3 o1 k( m( Y4 D- C, E8 j if i %2 == 0:, O5 f) y) ^$ |" d7 T  u
      print(i)

count=0
while count<100 :
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
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

18、布尔值分别有什么?

False .Ture ,或1 和0

20、写代码，有如下变量，请按照要求实现每个功能 name = " aleX"0 |7 C  |: J9 Y- T: _9 g
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  ']  列表

g. 将 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 循环每一个元素?
依赖索引
name = "Alex  "
for i in range(len(name)) :
print(name)) x/ I1 L6 N) }* m
for i in name:
1 `: ]3 |: o& W" L& x1 W- B print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain* g( T, V6 f* a
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']0 ^1 L! z9 S0 w1 B( Y
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
: A% a, u4 q" y5 O( @$ sprint(li)
3 \/ d! U! \* U1 `: M, S ['alex', 'eric', 'rain', 'seven']0 t0 ~9 d, i7 y
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
9 a, q( @, y5 Sprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy'): L6 q1 s) X+ y1 D) C; |
print(li)
8 E- K; V8 H% Xe. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
9 @" d4 g- g8 F" o; i' ^li.pop(1)
9 G! X6 B- N6 N- Jprint(li) ['alex', 'rain']
" \( V7 u7 J  F; T3 n( o+ b, |指名道姓的删除li = ['alex', 'eric', 'rain']
% a+ i1 _) O$ X) c$ D: zli.remove('alex')/ R$ f! l/ F; Z' J' M
print(li)' e2 I3 M6 z! P: r" ^8 @; f
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
) U+ j( u. J) A7 ]print(li.pop(1))
. F$ I, `4 {5 n6 m# ^4 t$ Wprint(li)
/ l/ K# o3 @6 U% Q4 H% e
1 f) i4 T2 |5 d6 a+ P8 e0 Leric6 H0 r5 Z1 k5 C) o
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
, f8 _# v. }8 O. N7 @3 pdel li[1:]4 N1 Y1 r; |) i6 J
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)' m& B4 e4 S7 I. e
li = ['alex', 'eric', 'rain']* t# m' B4 t: D- S# D6 d
for k,v in enumerate(li,1):, k, f7 l' G, i5 R) q* ^1 [
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]' u+ E' V; m0 K/ M5 s1 ?
a. 请输出 “Kelly”: r& b; o- ~0 A; f- v
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]8 H; H9 d5 ]% Y! M, h, I
print(li[2][1][1])$ k4 j  n& Z& H) g
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
# w; \3 F. ^" oli[2][2]='ALL'
, T+ A4 N+ _6 B# |4 z. `/ jprint(li), O/ |" R# J- u; e: \2 f
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')! D. A4 u$ x7 ]# [6 D" G
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
0 V& e% [# M9 ?4 J* _  fprint(len(tu))
- F. q7 u8 r! ~# ?b. 获取元组的第 2 个元素，并输出3 k3 K! V. Y0 ?1 b: G0 d
print(tu[1])* E1 U7 z1 Z  n6 g3 q" j
e. 请使用 for、len、range 输出元组的索引$ j0 [, m8 `5 J+ U" l
for i in range(len(tu)) :& {8 b# ^! [/ x! ?+ G: D) r" k3 W
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)& D  X  z9 I# H1 B: E# ?. S
for k,v in enumerate(tu,10) :# n8 U6 w1 a+ a% i$ J4 x
print(k,v)6 \, Q5 S8 A  u: G
10 alex
; J* g) P+ t4 m( D11 eric
1 A, L/ \7 S2 H" K4 z3 T0 H12 rain
9 W% S+ G- u2 R  ]0 b, n
" h; L% U0 R/ ]for k in enumerate(tu,10) :! G. h6 R9 c5 V7 N2 I
print(k)
1 H* g1 U5 j5 Z  I# J7 B(10, 'alex')
2 V6 b2 @& \) }(11, 'eric')
9 y3 S0 S4 |, j# T. g, b/ b(12, 'rain')
" U. r3 K' N+ ^! F; @* |: A9 a8 m7 r+ }$ O! u

6 m$ r' R$ b1 b25、有如下变量，请实现要求的功能
) b! U# E( ^  b9 u) Vtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

+ ?1 ^7 s$ u+ ]2 W0 v4 U& ^d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
% t: f% w' H5 S, |$ mtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
0 G4 K' ]8 V7 K  |" D* R$ qres=tu[1][2]['k2'].append('seven'); A5 \) L/ b" F' S! a# o# ]
; f  e2 z& }: B4 P; Q0 w% l
print(tu)
+ [% ?0 Y- v) ]26、字典, H; g% x- C# T
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:+ \7 K+ {5 C$ w# W
print(i)b. 请循环输出所有的 value
! y* z2 [- }/ d: V# z, Vfor i in dic:: `* h) K% v2 x3 U0 o
print(dic). y/ n, d* w( ?& ~6 b
c. 请循环输出所有的 key 和 valuefor i in dic:8 c2 F9 Y- q  ?
print(i,dic)
" I4 L; C' Y+ J) A, @' g) xd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
% Q9 V6 a1 I7 I: zdic['k4']='v4': y2 d8 f( ^" K4 D1 u( {! g0 |9 t
print(dic)3 g7 B$ W( D& @, }1 \& z) P, X3 O
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典" E/ r  W& W" |% K
dic['k1']='alex'; V# \" b. h3 E  b4 _1 H& q
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典6 X) n& z1 p9 c4 l5 J. T
dic['k3'].append(44)
3 y8 z2 j: g$ x$ L- F  Tprint(dic)
& {. E" G* _: {
  p7 X7 a, k7 s/ _; ~3 wg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典3 H3 V& Z5 @8 T6 |) d% [3 {# U
dic['k3'].insert(0,44). Y, P4 x# p- l$ j; X- o
print(dic)
6 }1 {, w. L9 i27、转换- U# i# R( @/ v9 B$ C
a. 将字符串 s = "alex" 转换成列表  s = "alex": x3 R$ \1 j3 v- y; c* h$ [

1 ]% \  |! K7 |0 y# Iprint(list(s))b. 将字符串 s = "alex" 转换成元祖, _# O: d( O& ^, W9 o0 p
s = "alex"
6 D7 |' e' ?' I& w8 y. e' G  nprint(tuple(s)); P6 K; p4 G, X% P6 c+ B
0 n% S  n+ Q/ N3 P2 E" p8 H
b. 将列表 li = ["alex", "seven"] 转换成元组
5 T9 x* L$ ]# H% z2 G7 u9 u9 ?li = ["alex", "seven"]
; c4 }; ~9 J% I5 |; p1 Jprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表" f0 {# a" b) _
tu = ('Alex', "seven")' L$ _% @. G8 w/ O
li=list(tu)
( {4 J. f8 Z. j+ u/ `. Qprint(li)2 L2 g0 o  d% r0 n$ J

1 c9 O9 L8 B( t; h2 b7 l5 ~+ [5 G! W/ D% y; q% j
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增' v4 }' N' y- e/ @9 _& P
2 G1 E3 K* S2 I# q
dic={}; a4 k. {; G# `; A
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面. N1 b' E# h1 J8 V. `9 L4 l6 e# O
dic[k]=v- ^" B& i7 z7 P- x
print(dic)27、转码n = "老男孩"
  q4 m1 n/ s& B3 u5 ?, |& na. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"( S9 k$ G6 p% O5 G2 a4 G5 d( {, O
a=n.encode('utf-8') $ \6 Z, \1 Q3 B# j
print(a)  q+ E! D# x9 p' d, L
b=a.decode('utf-8')8 t/ Y5 d$ m  {
print(b)
) C9 B( x8 }  Q: xb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')  [, }, C: X3 C* }1 d' ^. n8 o4 }
print(a)" c" {" F" n  v3 V: n9 S# ?
b=a.decode('gbk')
7 j, T! I4 l2 n  o( k0 mprint(b)28、求 1-100 内的所有数的和7 G& Y, z" V" @2 h
count=1
4 u3 a9 y  t0 N& y7 F) \8 l8 S9 @sum=0
% E+ y1 z$ C, P, r3 F: l! hfor i in range(100) :
/ L/ w& P2 I- t! ~1 W6 v7 ?5 O sum=sum+count( ]& m! c8 |# E" Y+ k
count+=1
5 e5 J/ m) Q2 `print(sum)
( B' ^, @1 w9 |0 ^7 R. H8 S
! `" }1 ]8 z; \8 M( qcount=1
5 A4 g% O# b7 `% ^" o) msum=0
3 q% p! J% y1 D' X' Swhile count<=100 :6 |/ C' c1 |0 |8 }7 ~! i% e
sum+=count
" w! D! J7 B9 T( t. Z$ Z* S5 V+ `: R count+=14 j4 f4 I& |) L
print(sum)29、元素分类! J+ ^  L3 H" J6 ?$ Q" ~8 q
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，1 k" i0 M9 K2 H; H" v1 I
将小于 66 的值保存至第二个 key 的值中。% i4 a# t2 X/ r2 Q7 Y$ B% H7 }
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}' c# k. j6 l+ ], u
li=[11,22,33,44,55,66,77,88,99,90]' A; L2 a% L! k2 a7 u
dic1={- |- A5 t. Z7 B3 i8 _1 q6 {6 |
'max':[],: y4 x+ {3 ?4 g7 [
'min':[]- ~* o/ ~- K7 S. D1 z: M
}/ V: c* a/ a7 T! @4 k& c
for i in li :
- k, d% g. t! G0 h if i <66 :* U/ {, F& J5 ^; k7 D5 ?
      dic1['min'].append(i)
4 q7 b& A( C5 ~: V else:* Y0 j$ t1 ?+ W" e. y, r0 ~; X
      dic1['max'].append(i)
) B! N  Q5 M& c( `+ z# ]print(dic1)- t% M4 i4 x2 s7 [4 s

4 I+ R2 a2 d9 q; ]4 n5 @0 b---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
. K6 p. R* ]. X' h

Python基础知识汇总

主题推荐