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、写代码7 H* V+ a4 q. n; p# d
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) :" ~2 @0 J2 T8 `# H! }
name = input('name:').strip()0 o. N& P; ^1 b( n# B) \% `1 B
pwd = input('pwd：').strip()
* z5 g* y* R: N  L  v- l: B6 R
7 x& s9 X$ z8 w# v3 F! q. o, e! } if name=='seven' and pwd=='123' :
5 b) R, D) p1 `  [5 D2 [9 L       print('ok')2 X4 C( E4 X! Y: H
else:- |4 J! r: w9 c4 Q1 E& Q
      print('error')( z$ {6 T* W- w& u! N
      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)  :) ^/ |. p1 a4 ?5 O! J' \8 C
name = input('name: ')  M: u9 e7 ~: T7 _. Z9 h$ `
pwd = input('pwd: ')/ J& D7 o9 O" J  q. N4 t' z. g: g
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':. K3 ^+ c) n7 r+ ^  z
      print('ok')
- f# V$ i( D. b" |2 D, W- m else :
3 I. g* {" W! B% q( Y9 i9 A1 w       print('error')
7 Z, R: X) e0 \. t6 S* O       count+=111、写代码
" l0 R9 e: r: `2 U6 R/ C5 ?2 E6 I8 {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) :, X) Z' e" \. t5 T6 P4 }
if i %2 != 0 :
/ m) m: p- N% b( q( n2 [" o* b       print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
) m! {. p$ C& I; o, { if i %2 == 0:
: [! s2 B/ z+ i2 `       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"2 Q3 G  Y5 z6 Q. N  y. c
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)( \! w. n" z$ I" H/ ]
for i in name:. C- N3 u& T) a. q: Y3 m
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain7 k5 E$ j: {- R! X5 h# q5 O7 P( S
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']8 e( P0 D6 R% p  b. {1 ]
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
- E! F* q' Q/ E5 t! k2 sprint(li); e* T6 o2 R( r7 x5 h
['alex', 'eric', 'rain', 'seven']
, h( f" p+ @3 x0 Pc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')3 G8 K+ l+ _& ^5 Y6 R8 n. p/ X5 q6 {0 n' S
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
* A" ~6 [2 R: I7 `( vprint(li)
4 @2 c- S# A4 Je. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']! Q7 t! q: n3 N- ?
li.pop(1)5 P" ?# c+ n, O% x+ B, y1 r
print(li) ['alex', 'rain']
$ H4 U' z. u) u/ I- v指名道姓的删除li = ['alex', 'eric', 'rain']! I  t6 t% ]0 I; D4 F. ^2 t
li.remove('alex')! C0 I/ C! X, Y! ^
print(li), b  O9 ^% x" k9 P9 q5 ]$ A, y
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']3 l  d( ~0 k5 k; ]+ f2 k) A9 t0 s
print(li.pop(1))
& B0 o. B2 _0 m" |4 Cprint(li)7 T1 ?6 ?$ x2 Q" k$ a. ~

* K7 l) n0 G9 k0 @  f, r% Oeric5 q4 U9 E0 n: f: b" u' j8 k8 |2 Q
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']2 D; N! x& u8 h5 N2 S
del li[1:]
; U' L$ e: a" X: ~9 W- jprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)) {% Z) w: K6 z
li = ['alex', 'eric', 'rain']
2 r% w: e8 r$ s) dfor k,v in enumerate(li,1):
" l. n9 y# c: { print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
1 J* x- B. ^! N& V3 |' y+ w% g' za. 请输出 “Kelly”
" R9 F9 _! B, N+ |7 @li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]3 B5 T; h# c! l' `! p0 L3 |  ~
print(li[2][1][1])
  g8 t/ D; k8 e! t- ^, |7 xb. 请使用索引找到 'all' 元素并将其修改为 “ALL”, W3 o# V( Q  X. i. G
li[2][2]='ALL'
: T- a* q$ r) X8 N. O6 Y7 |, A+ pprint(li)8 @/ X3 a% d3 T5 Q( r
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')0 v, I* ~5 {: Q9 j8 S0 ]$ K) f) i
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
) P+ u% [' V) {print(len(tu))
- V7 Y3 e" k  tb. 获取元组的第 2 个元素，并输出. _  u& R& \5 b  K- d! K/ n& U
print(tu[1])% Q- K+ T# B& l1 m. L7 g' g
e. 请使用 for、len、range 输出元组的索引
6 E9 [! z# m4 ]( E  I0 V5 Gfor i in range(len(tu)) :/ ?) ?* V: o  |/ e' c
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
: F5 d, \0 o1 I2 T  Y% bfor k,v in enumerate(tu,10) :
8 _" e" B+ Z3 ~1 R1 |) h print(k,v)4 f' {9 ~' k7 s, u5 B. C
10 alex
/ r3 g! V( }$ I0 D( ^* X0 o11 eric& y- h- n* V3 L8 ?
12 rain" N7 h" |* h3 _, A! h6 y. ^
+ }# \$ x8 R$ i' Q! `; g# F% O3 ^
for k in enumerate(tu,10) :% @+ I/ w1 a) D; ]" w! a# ?
print(k)
% M9 Z4 `# {; @  A(10, 'alex')
3 s& C9 ^4 Z7 ]; h2 w(11, 'eric')  \7 V& |, x' }  v! E
(12, 'rain')
2 k' W9 n! W$ D3 I. s, K) p7 x7 b2 b

8 }; Y2 I' K2 E' ~! W" B25、有如下变量，请实现要求的功能+ m5 F% f, L0 f) ~# n" _
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
. h% f- `# _  I5 B( P$ R; ?% T
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以! C, h' y* v. _$ K3 E
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
! l0 K2 X% X1 @8 w  Wres=tu[1][2]['k2'].append('seven')" ?$ Y8 Q, p% i* H3 }' K, l
0 R- G$ W- i- X! [- O
print(tu)3 ~+ E; ]0 q* _% B9 _4 O( @9 }
26、字典
0 W' O; Z' b5 Tdic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:! R) B* G* Q0 Y
print(i)b. 请循环输出所有的 value
6 a$ G# @. T/ a* O+ Pfor i in dic:
1 {& @0 I' |+ F" ~0 L4 u* Y print(dic)
5 I$ P. q1 v# D& ac. 请循环输出所有的 key 和 valuefor i in dic:
! U5 W6 }7 J7 a4 _. Gprint(i,dic)
( g. U% n0 m; g: Id. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典! n- P" _4 w, D
dic['k4']='v4'
, D) ?( h9 K7 d/ iprint(dic)
, f# J+ z3 l/ O( h8 k7 x" ie. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
6 s8 n+ p" u0 Y3 ydic['k1']='alex'5 r+ q0 f+ o# Y$ I
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典. O+ j0 J4 O7 b
dic['k3'].append(44)
; G2 w1 M' @( Yprint(dic)
8 n% ^  @3 h0 n0 g* X$ d9 T7 u6 a, m) v
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典6 D4 u7 D2 m% m# j3 u4 a# w- i
dic['k3'].insert(0,44)
" z$ j9 w. i2 d# i1 `print(dic)
3 O( b' r: v3 C# X2 e$ l27、转换$ i, S+ M  X* c: u% b5 Q) P2 r3 n
a. 将字符串 s = "alex" 转换成列表  s = "alex"( K7 D& x$ x5 F4 N3 v

0 Z9 y. d2 i- O/ y! ?- K3 Pprint(list(s))b. 将字符串 s = "alex" 转换成元祖
% p; g6 ~! k" Ms = "alex"* E1 r- A5 T; E1 t+ U/ \
print(tuple(s))
3 R# P7 q5 R5 S5 S1 C
b. 将列表 li = ["alex", "seven"] 转换成元组
9 C% p# G2 p6 \: Ili = ["alex", "seven"]9 E8 c/ d. a5 u2 T
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
! h$ a# p; _4 O$ d9 ltu = ('Alex', "seven")
8 u' K; L: {! C6 F' o7 |+ Yli=list(tu)
: }7 W, L& Q, q8 I, @; y- @print(li)8 Y2 W6 b& ?; y3 u7 I. b' U: D0 O' y

- a4 o; p3 V; D* v: V4 A; T. k) b& {" V
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增" L0 m* v2 \3 V1 k
# N% Z% l: p% k. l
dic={}
+ r) C* r0 L8 {; L! J5 _for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
& Q7 T8 u0 V! ]* z dic[k]=v
; l4 h# x; Z3 R( d print(dic)27、转码n = "老男孩"
' {( o' L9 z0 z/ |7 G" A' z- M" la. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"$ ?+ ?" J2 v8 M
a=n.encode('utf-8')
2 S; z5 B& p* _8 g1 h# {% lprint(a)
1 O4 `3 ~+ V6 @. p: lb=a.decode('utf-8')
9 w+ L7 e7 q% f! C  n2 bprint(b)/ e6 F) f+ y8 w
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')* G- E7 P1 D1 G
print(a)7 L" E/ Z8 y3 P3 |
b=a.decode('gbk')
7 B0 |  m7 t0 a% E, lprint(b)28、求 1-100 内的所有数的和
! ?  ^: i% |5 Q  kcount=1/ {& o$ e) w2 r
sum=0
# y9 e9 }- V$ A9 tfor i in range(100) :( j% j( j7 a1 s0 t
sum=sum+count5 M: R8 v) Q& T+ x( D. F
count+=1
  t$ o( W/ M6 O9 |/ h6 s" M8 ^' ?print(sum)- Q( o. u6 L9 i+ M7 u

- @- A) |' A( o3 ^count=1/ p5 c! ~% S3 s* K3 U: ^! Z
sum=0/ y9 {6 M" r  j0 l0 o
while count<=100 :' n: m2 Z, p, B" w: R
sum+=count1 V$ F4 N3 r  j! k; u3 K7 u
count+=1( R. K+ u; W" c  k2 ]0 B
print(sum)29、元素分类% y2 i4 V5 w. Z
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
! q* o6 ?2 H, R/ ^将小于 66 的值保存至第二个 key 的值中。6 }% X$ K" f+ H& h/ K
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}: t6 k! i  X  l0 H7 W
li=[11,22,33,44,55,66,77,88,99,90], `. T% [0 b+ S) J( R
dic1={$ k& ~* A. I- ]( R  `& ~
'max':[],2 S: }  k% W9 P
'min':[]
; N& r0 k9 {  v0 P) k9 I- K}+ P" ~1 T( i4 _4 ?
for i in li :
# ?3 w# i) g+ r9 k+ B% {  t if i <66 :5 M) e3 V: R; P7 t8 r
      dic1['min'].append(i)
& q# Z7 j; f7 E else:
! S2 [$ d' d0 r- j% S8 E" n& G       dic1['max'].append(i)2 a  |3 {# q6 T3 b
print(dic1)
' E9 ?# z! @9 f. Z. X: A. H2 t2 u* X& I) k1 H
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
* T, f0 G' p: F# {& c' I. j

Python基础知识汇总

主题推荐