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、写代码
/ u( L+ D% ?% n6 M) {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) :
9 X2 K- L; N% h& B0 b( P0 S. K name = input('name:').strip()
7 ^% b0 k" ^! Z8 G1 h7 H+ s pwd = input('pwd：').strip()# \  }+ ~; V) p1 E

/ j9 j! t- K$ D3 M- i2 t% p if name=='seven' and pwd=='123' :
, c( `& |) Y, ?       print('ok')2 v8 K% ?# Y# A( S2 W- e
else:4 t* w* o# y% t4 T  y& U+ x
      print('error')
9 ]; p, }; s" h& G% o, V9 F$ X. }       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)  :& ^2 ~$ @+ F! T7 Y
name = input('name: '), m  Q- \, G2 [/ {. t) p
pwd = input('pwd: ')
: R$ ^  h- h( B( V' j3 \ if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
  f: e5 B5 d3 X7 @6 `       print('ok')
0 Z% Q7 o; ]& U5 o" Y' K else :
- Y0 b1 G. E* p       print('error')
/ }) t( x8 V4 f$ `  d, `       count+=111、写代码
3 ^6 z4 u$ h. ba. 使用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) :* _# ~: k7 y7 x" ]3 n7 b/ H
if i %2 != 0 :7 ^. L) r8 W' a5 p3 ^7 d
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :! c3 l8 S# [& N; D) ?' R; p$ o
if i %2 == 0:0 l$ t: S  d) w2 N; y
      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"% O; E! d7 s/ a! e$ p
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)
: g/ Z6 H1 {: K" y, gfor i in name:7 {0 h( F2 s/ F; ?8 K% Y' R
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain9 C' B# }, ]' {4 e9 @5 D
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
6 O$ U' ?' U) Y2 k: J2 cprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    1 K4 K2 r- q, I1 O' ?' L) D4 T
print(li)
+ P1 h) j& k4 [4 v" j ['alex', 'eric', 'rain', 'seven']
/ {  t1 E( x7 ]3 j) q& E; e, xc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')( Q* m" X! D1 @" Y
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')8 S! c) \5 P. y# @  {
print(li)& Y6 q( Z  h/ S, i: u
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']: O; h9 H+ B8 g) f* C+ n7 Z
li.pop(1)
! ^2 D5 b% ^; t$ mprint(li) ['alex', 'rain']
# ?6 Q1 u6 x1 c: @- Q$ o指名道姓的删除li = ['alex', 'eric', 'rain']
6 Z$ V3 Z* k$ U/ cli.remove('alex')
7 [/ A+ A: c; X+ h7 ~- H* tprint(li)9 N& U& r5 [% D
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
: \2 r. E* Y0 T& v9 d4 Kprint(li.pop(1))
. ?: P1 u2 C. k7 o" _) Oprint(li)
9 l1 Y7 _+ r; Q% ~
3 i5 x4 ?6 o5 e( G- n9 Feric& M& }: q& }( t+ y' V! E! C
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
& E. Q: F& i3 v1 z9 q/ {& Tdel li[1:]7 k+ b! ]+ m- T) G% t5 s* K& b) c& Y
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
3 s5 Z5 |6 d% b8 }7 C+ J. c# @li = ['alex', 'eric', 'rain']' \$ e0 w& @1 f/ M
for k,v in enumerate(li,1):
6 V2 T3 g2 X% u print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]  U: _' A& l+ L. r) z" b/ ]
a. 请输出 “Kelly”) ?' C/ E: _4 |! ~
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
( T; ^  ]+ f9 b/ @print(li[2][1][1]), e" X0 m& K( a# V5 J+ n
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”, N) \- u8 E, d8 R( v0 h0 E2 }* V
li[2][2]='ALL'" [  O+ a& l1 S" F" C* S  ~
print(li)
$ ?$ {+ N# m4 \: F2 Y7 A& R/ E24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')4 ?7 h9 J# ^$ g5 R" }3 h7 @7 j, b
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
, N# ~# ^) C4 @; rprint(len(tu))
4 B2 h6 z1 R3 i% Y7 e7 f, F2 tb. 获取元组的第 2 个元素，并输出; L3 D' y6 p; Y+ B7 L; y! t
print(tu[1])
' ~+ N1 c, q+ Y' N$ q5 {7 Qe. 请使用 for、len、range 输出元组的索引) s# ?' j7 f9 @/ @1 C4 _
for i in range(len(tu)) :8 Q( n: g  @9 P/ s
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
0 K# e; v8 ~5 T6 S( @for k,v in enumerate(tu,10) :: ]; S1 N6 _  }+ X$ [% E4 b" ~
print(k,v)- L5 P" A* r* G) g
10 alex. b. ?# `- d* ^3 d* g
11 eric  W3 X7 D2 J2 c$ V) @# c6 p* u6 ?
12 rain
: [' M! s; w) e2 E/ A$ Q: K  h
" ~/ Y/ b2 _& K# @4 R# t1 `for k in enumerate(tu,10) :
$ \. i# x9 N3 i! _# N print(k)
! p4 c$ J  p" H6 L8 w(10, 'alex')- q) L" d" K9 _- A2 ]
(11, 'eric')
2 V2 E' v! Y6 l0 z: Y5 V8 ?(12, 'rain')
- O2 V" }, F8 ~) ]& @3 W& I; h% m( [# B; \. W

: x. ^* R3 o! k25、有如下变量，请实现要求的功能
$ z/ A! ?. p0 ]3 U5 m1 O1 t6 u- a( _tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
  e9 j+ A$ b1 {" p
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以1 P; p: x" ~3 s1 S" C+ |5 I
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
9 w1 K) U5 a' U6 `; kres=tu[1][2]['k2'].append('seven')
/ C  t6 m0 U7 T- B9 K2 E% \; y  s! T. D7 [1 t, ?1 X  Z
print(tu)4 v7 S* G5 y, C/ `& U# O# ~
26、字典
( y. p8 J( j. S! n- e- ?6 }dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:9 w( _" j8 [3 ]- Y5 O9 o
print(i)b. 请循环输出所有的 value
# ?' F( b/ ^' Z/ p' \/ ]for i in dic:
1 a7 o! Z$ B: {% r8 } print(dic)! x# U& ?& Y+ f4 c
c. 请循环输出所有的 key 和 valuefor i in dic:) B! e# z$ f* E6 d% ^2 o5 B2 n
print(i,dic)5 ?: {! P( @, ]  G
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
: B, C* T. k! H2 mdic['k4']='v4'2 _/ x) u! u  q- o6 r3 g* X; j2 n
print(dic)  W* S1 B. y) k# y# {
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典: u% k1 b) ^6 P% r6 D! J* i
dic['k1']='alex'
2 s  y8 W, f! a8 }print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典0 T9 j$ w1 D9 ]! E, f" f& @
dic['k3'].append(44)5 J2 A# }& }) x2 Z1 x. Y8 y# y: @3 F
print(dic)
3 p1 ~, W" i5 j: \; i
) d: N- y% _! d; b  }' Kg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典* \& x- p$ V, a; l6 ^
dic['k3'].insert(0,44)
8 P; C8 j1 ]/ B3 b- Vprint(dic)2 C0 Z0 j5 {$ d0 G: U! t
27、转换
6 @. e8 ]7 Z; La. 将字符串 s = "alex" 转换成列表  s = "alex"$ B4 [6 e/ a5 l! y
7 G5 |( v1 Y9 ~! g2 E. z8 H
print(list(s))b. 将字符串 s = "alex" 转换成元祖' W8 |% @( x8 x" A: D; e
s = "alex"
: w4 U7 W! t1 q+ v0 p$ }print(tuple(s))
  U% F- x0 P. x8 m" m: O( D# z) r. X+ Z8 d0 B' C
b. 将列表 li = ["alex", "seven"] 转换成元组2 e. f  b& A1 R& m7 ?
li = ["alex", "seven"]
3 Y# n  z7 g3 a  R! ]print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
) |4 Z! |$ `7 a/ _" U5 {2 T0 W9 dtu = ('Alex', "seven")
6 S& ~- W; t! h! |0 G0 G3 ^li=list(tu)% I* f1 z* S6 l% U: c. [, q
print(li)
0 u2 y% ?  {9 ]! c3 |) A. [
0 V+ k) K; E) _! m
$ O& {3 s2 ]- {( e/ |d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增) U$ b+ ~' {- W3 f2 n
7 [/ c$ \/ v$ E! x0 a* ]
dic={}# @  Z& g' ~5 V+ h
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面8 G0 ~7 ?3 y- |: x
dic[k]=v5 o8 ~" N" _8 [/ o: ]  x
print(dic)27、转码n = "老男孩"
6 E3 T1 d8 _4 N4 l2 b- M+ ^a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
) B0 p2 d# T. u1 `+ Va=n.encode('utf-8') . Q* k7 j& w! i3 h/ s* e$ }
print(a)3 z& j2 |. j! D, \& d# @8 Q  p% }1 ?
b=a.decode('utf-8')( J3 J; G& a/ X1 v
print(b)
- {2 s% U/ a( r; y7 k* Y! Bb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')1 e, }4 Q! P9 Z1 I, ]
print(a)
* @/ M/ l9 I( n6 e  z) Zb=a.decode('gbk')0 @1 B( g" \$ |; m" q8 r# V$ a
print(b)28、求 1-100 内的所有数的和
; X1 ^) u! O) s5 l* y# O& Pcount=1
) T# A/ y0 l& `. s7 a4 b. k$ \sum=02 W1 z, }4 M  t- L* c
for i in range(100) :' W' Y% s9 o! a: Z: b5 b+ p- I
sum=sum+count
: E! z# j' x5 z$ B3 l, T count+=1
: Y' [3 M; w/ O  }5 C7 ^4 gprint(sum)
/ w+ ^) K. \6 j$ i% t) h5 ~2 e; X: i; z' S# J% j" M: z4 S8 e
count=1
! B. p1 i1 M3 A. i* o4 V& G  Gsum=0
1 B! N. ^- q# l4 W4 f3 Zwhile count<=100 :# w) K3 I  i8 h9 L& {% A" `- n3 r
sum+=count
2 D( t- n4 r) I count+=18 V( G% |. p2 v4 d' f! D
print(sum)29、元素分类
6 U: L/ j. T& Q# e' P% S$ l( \有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
( G8 d' f2 t# B' K7 |) P将小于 66 的值保存至第二个 key 的值中。9 Y0 A8 }" x0 J% _3 j. G1 E* G
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}2 d2 c& E* m0 U: n; ^% X! b
li=[11,22,33,44,55,66,77,88,99,90]" G3 G+ F# [/ u6 i" V. U9 m( I' x
dic1={2 L6 i7 ]$ A/ H* Z1 }2 B! M* s8 @: P
'max':[],4 H+ ?. Q! r0 q: b
'min':[]
, b/ M) p: S. `8 V' V+ D. m6 h}' o  K% S: ~( j- z
for i in li :) ?7 z' i9 J5 `: n7 K7 K
if i <66 :
7 ?8 ^7 I8 ?" Y6 U  F       dic1['min'].append(i)8 n3 [' d- N  C8 B6 E& S
else:
( _( G, Q4 K; T8 h! n7 C" [       dic1['max'].append(i)
) m8 k! v) x+ `1 ~5 \* e, Sprint(dic1)
+ w( e$ u% k0 T4 p+ i6 l, N- _; a/ d2 ^' p) y" o! [* a4 u# f- X, O6 s& P
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
4 U9 _7 C7 ]6 A$ Q5 H

Python基础知识汇总

主题推荐