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 ~$ ~" K- y7 X$ G
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 V% Q4 [! `) }) \* N# ^% O name = input('name:').strip(); g* i3 ]) k2 S/ r/ H& _7 q
pwd = input('pwd：').strip()0 b' t' G% ]/ B: V' Z# J* y9 N

+ l! E/ u5 R% G4 b if name=='seven' and pwd=='123' :
5 Q" v" h) l  E       print('ok')
5 r) Q1 S; o% c( ~% \3 o: m else:
  O8 F7 w+ }; T( z% |. s1 U       print('error')2 b4 Q7 Z3 b5 c$ L$ o2 Z
      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)  :
" q6 j% \: H+ L. s- V  s name = input('name: ')
: `) x8 y7 h1 c$ ~2 \8 Q/ s pwd = input('pwd: ')! H" [9 [( w3 @6 ]5 z
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':7 J6 P) ~$ }% ]/ U9 O7 F
      print('ok')' E0 P- R. @' X: p/ m, N; o
else :" A, w, w2 `& P. x) L" J
      print('error')2 g( P, V& ^) g7 H% L
      count+=111、写代码
* W2 x. j( L, k3 w, G& Ca. 使用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) :
- Q/ b0 p+ P; M2 @5 `' P4 W0 N  L if i %2 != 0 :
: A, p1 u, M% t2 m! Q, F       print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
' H8 Z# ]! R' S( j% V8 z if i %2 == 0:
' G- h. e; N( l( |  ~( r) d       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"
! l# z+ r, I; O8 B$ v% v6 ^0 ia. 移除 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)- V: h; t1 ]; w! Z. K, L
for i in name:
# K2 U5 O: c5 y& S8 f print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
" w! R9 t5 t$ {( m. h6 y4 t22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']9 Y) b2 y8 x( K! O" i( m) Z
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    9 I, v. `7 G. o5 h/ `
print(li)
7 f8 M$ Y# V7 E4 R2 z ['alex', 'eric', 'rain', 'seven']
& u, ]# H. l% W4 x% nc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
( h0 U/ K" Z5 Jprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')( w4 Y" d: i2 V& G+ Q1 N
print(li)
& i- s+ _& u9 I. `- ze. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']; I; c% U$ Y. R+ z5 F* z4 o- M
li.pop(1)
' u5 I9 |4 J+ o+ \print(li) ['alex', 'rain']" E& i+ x. W% f% g
指名道姓的删除li = ['alex', 'eric', 'rain']
" t/ f( Y! G0 r$ `. |  vli.remove('alex')
3 d* u. F5 y7 T, b- t  f, Gprint(li)
# L2 t0 _: G9 C* n1 S/ ~% Of. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']2 c. i+ L) y2 t9 @( q% i: |1 g
print(li.pop(1))
& ^( x# Y1 L/ q. N! C0 O! @& x; b" uprint(li)4 C% y0 N+ i, a2 v$ s! K
4 O* [& s- a# w# X1 ?9 h) C
eric( Q) l0 e, @5 X
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']- o$ U% ~( C2 O% \
del li[1:]
1 i& O- n5 H: Oprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)/ L% Z+ O+ X' L
li = ['alex', 'eric', 'rain']
7 H& S3 y* R0 q; Nfor k,v in enumerate(li,1):
$ X' l2 m/ _4 n" X print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]2 a3 @. c) p! _* x8 ]) k
a. 请输出 “Kelly”6 |1 Q2 d: j& t) W% ~8 f
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
* Q# Y4 t* g) z+ e4 S% z3 p, bprint(li[2][1][1])0 Y6 o0 J* T7 g
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”0 j$ X2 Y  d8 O0 Y5 g/ p4 ^
li[2][2]='ALL'
% }+ }9 k; `8 {. x; u; ]print(li)
+ x4 x7 d; D" W  Z' g- x24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain'). M" ]% T8 N0 `& c# _0 ~4 Y, `
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')6 t: _& V# W, g( |6 m. T7 A
print(len(tu))  b+ H' w7 P( y
b. 获取元组的第 2 个元素，并输出
* t) \0 G9 a7 N5 r$ a( K8 oprint(tu[1])
: t& W5 ?5 X( d( j, Z2 T. G$ ve. 请使用 for、len、range 输出元组的索引
- _5 l) @% q& H, y9 f5 tfor i in range(len(tu)) :  y2 T2 k5 \7 G! s  R5 z
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)4 N$ g0 J% I. |% ?
for k,v in enumerate(tu,10) :3 g1 j' ]' Q9 L2 v/ a/ B
print(k,v)
, {+ ^$ v( D: g0 I% G5 }) f10 alex1 ^1 f1 C& ?0 m* d; s% k- U; u
11 eric
/ e; Q7 J: k( I7 Y4 E" |12 rain
, S7 e# s! U2 |' b6 g( Y
' z. v9 N' x! E2 G  `/ r; Q) }3 k' mfor k in enumerate(tu,10) :
' g" i5 A" r3 V! G print(k)
( w4 Y; x/ y( M' e(10, 'alex'); p* x. X, U" S+ C) j/ d9 n4 B
(11, 'eric')
# M4 A4 `! w, B& W3 p5 H3 ~# E(12, 'rain')
/ c9 V; b( w, h. D2 j7 L% x8 P" j
& i& F2 L9 |1 U8 e0 T( E3 x9 @2 I0 Q5 H( h
25、有如下变量，请实现要求的功能
! ]3 N. l, ~; c8 V: `& A+ s- _# |" wtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

- t1 [# }( X! D) K$ Cd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以0 p, m7 z1 {* }/ O/ ?7 g9 `
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
1 y3 r. ~2 b; k! Q* g  ~res=tu[1][2]['k2'].append('seven')( a; b  _5 w; ^3 u/ _( e' r; ^

. \. A2 ^, j9 T6 R' jprint(tu)
; }8 u+ i* b* |$ _26、字典- U, q6 ~% a( e% {+ o
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
  G- L' M# ~7 e/ k print(i)b. 请循环输出所有的 value% O$ n* w2 h* H; i# G. ?/ A, O
for i in dic:3 m  J# k' m; ^4 P3 ^8 {, h
print(dic)* Y3 |# ?( I, h) R# y8 N3 ]
c. 请循环输出所有的 key 和 valuefor i in dic:, P- h$ e8 N$ G" ?8 |1 ?' @/ v+ }
print(i,dic): J* I9 }$ X: U2 X' o
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典& ?& H9 F, N5 b4 s6 Y( @0 Y! Q  K
dic['k4']='v4'. J; L3 Y& A7 O: n/ O% c9 |/ b
print(dic)& {5 J1 g6 A: y9 E9 E* X0 K
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典: ]/ r, m/ h9 }8 ~% E. R; b
dic['k1']='alex'
- D$ L, `1 h' Y; ]/ ?print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典+ K( K, W2 _: H& W
dic['k3'].append(44)1 y6 w, ^& c5 [* b' D' f
print(dic)
& e8 y) Q$ G0 h4 A# Y3 k% x# E, V3 d6 `$ G0 {
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
: s" K! N3 n  `6 S5 m3 Z+ G, Xdic['k3'].insert(0,44)" B$ p& F( F7 ~8 ^
print(dic)
2 x. L+ u( f; c5 }  n2 ^% Z7 @27、转换
. o* _* `& m$ C2 N. s2 fa. 将字符串 s = "alex" 转换成列表  s = "alex"
9 A5 v% h' O' s" I! Q% q; H/ D& ?9 T9 g, K
print(list(s))b. 将字符串 s = "alex" 转换成元祖
; D! g8 k3 {7 Q$ Es = "alex"
8 r( ?4 x( v6 l5 I: [print(tuple(s))$ |5 J5 w8 F! x% e$ E6 A
* n: ?$ M4 N3 S# M# h
b. 将列表 li = ["alex", "seven"] 转换成元组
( O- ]8 C" x' ~li = ["alex", "seven"]
( G, g4 b, v. ~6 yprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表* `$ f( v& Q2 l4 h- I
tu = ('Alex', "seven")
# l3 J% O; y/ i$ v. \/ [* dli=list(tu)/ _3 _5 m7 @) e7 p! t. F
print(li)
) ]& |1 `1 s, @7 a- T) j# G# I% D% f8 j

  x) {/ e: _+ i8 S  ed. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增/ M# M- ~/ n  p, L; R6 b# Q

3 e9 M  D; o# c. @( f: B8 p8 i5 qdic={}  P0 s' H6 f" [6 j. C% \
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面- b1 R4 T* k% \. ]: S$ h& Q1 [
dic[k]=v
/ H. m8 H0 B0 d9 ]( X3 y/ N+ U print(dic)27、转码n = "老男孩"
- |' U1 V6 V; M5 |$ x+ a. U4 Ra. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
( J1 h, U% Z# Aa=n.encode('utf-8') + \0 s- ?( h# N7 ]. ~2 ?' ]$ `
print(a)) F8 F  e* Z4 U+ W* k
b=a.decode('utf-8')5 l- \& f9 ?5 l2 _9 O
print(b)
: }. I9 K9 U) u- r" Fb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')& f8 P% v5 S+ H+ Y
print(a)
* i0 D) n+ W1 Ib=a.decode('gbk')
0 @, f" t: B( Dprint(b)28、求 1-100 内的所有数的和% F0 {7 }8 k! k; L. P. W4 r
count=1
/ z1 _( D; S& _1 Z- Z: w+ jsum=0
& }! Z/ ~( k" i# h+ p! P  Ufor i in range(100) :
2 I; x- a( X- C$ t; o( j( y sum=sum+count' w% e! R4 n0 I  Y4 v9 ~. m( y' T+ {
count+=1+ C% s: Z6 v0 M% N- F8 r- }+ p( |
print(sum)" D) d7 e( c- k/ S7 E  T3 F

' Y/ E. B  ]* }, u6 @# L% dcount=17 G7 C  N+ v: t5 m
sum=0
% a9 G  T) E9 }, L" X; h- a: \while count<=100 :
6 Y* b9 z) F3 o# f3 w7 m* Z sum+=count: T+ \; i/ t' v6 }. v9 s, d" {9 c
count+=1
5 k/ ^% U# e3 m7 \" y1 Cprint(sum)29、元素分类: ~4 [5 ?. F* |! E$ a& U- w" M
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，& u  M4 O* c0 e- Y6 Q% e+ I. N
将小于 66 的值保存至第二个 key 的值中。
0 P( `. O' X* a4 o3 d8 g1 }即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}1 B2 l7 c' n$ u
li=[11,22,33,44,55,66,77,88,99,90]7 l- A7 G3 k* E; f0 i  O$ f$ C7 w
dic1={
- A  u6 U/ |0 a) ^8 Y8 R" V7 j4 H 'max':[],- X1 G$ X: f. a3 a; o- k0 [
'min':[]0 h! a7 ^$ a0 [/ Z' Y
}
9 G6 t: f- k% P' p' A6 _for i in li :( W( s9 [. K4 e( r5 X4 c& |
if i <66 :
% n' g) T2 O* `% P       dic1['min'].append(i)
' f7 t1 N3 R  D0 l else:
$ b" F: g; ]& N- c' @, {& d( K       dic1['max'].append(i)/ i9 _' X  A: z# m
print(dic1)+ l6 ?# Y( K+ R; _* L9 `' e7 Z

! e$ l; ]  b9 |9 J7 D---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
0 H2 f/ |3 K3 T  {

Python基础知识汇总

主题推荐