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、写代码
* T' q5 _1 V; y% e' I( ~& f  a% X; ~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) :/ N0 k' t/ N# Z/ E/ @
name = input('name:').strip()
4 K: h+ _3 E  o* h2 P pwd = input('pwd：').strip()' _5 T7 h6 e0 G' ~" R" j8 v; u9 A9 u) q

, B8 k/ Z& g* L# ~9 w1 k if name=='seven' and pwd=='123' :
+ m- V1 \- |3 t  ^9 T0 R       print('ok'), ~+ G* p6 q2 O" Y+ S
else:+ @4 o" E3 k7 Y% _/ Z" h
      print('error')
- r! C/ W2 _1 |1 T6 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)  :
5 q8 B/ x) m# Z+ E name = input('name: ')6 e& Y: O6 }; ^" P4 l$ p. v
pwd = input('pwd: ')
8 y$ W0 D4 t- P if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':& ~; q* S3 U' c7 M  @
      print('ok')" P8 h# s# M( T5 a7 d* X
else :4 [% T9 G. z" @. R
      print('error')
& x, U+ k# M6 W# H2 i6 Y& Y       count+=111、写代码& _" @# q( ~% }8 p' V8 }/ l
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) :7 U2 \8 I$ u" P. q
if i %2 != 0 :  w6 {2 G  ]& |' x2 V3 K9 L, Q
      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 Y5 t4 z! l: I3 A
if i %2 == 0:
( F( K* @; Y, l, B3 B9 Q       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"+ l7 V1 w2 k3 m9 S! f
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)
" j0 j, l/ C1 ^( Afor i in name:% M. ?& l0 Y8 P. x% B
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
7 z7 N, ?! j, `6 |; G& R: A22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
$ f6 L  [* z; d2 }# V: }print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
$ n% t+ S+ L$ u9 {% s' f) c6 Wprint(li)
% `! G3 l0 N: w$ h: ` ['alex', 'eric', 'rain', 'seven']
3 M, T7 u4 `+ ]2 s0 c* _c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
9 S) b2 y; k1 {$ yprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')( K  e* _/ ~8 s! ]1 ]2 ~
print(li)1 o6 ^& i, D7 {. b1 ?0 a, y
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
( H' A% M, m) \1 Yli.pop(1)
  O5 _0 j( C$ w9 `/ m. A7 Lprint(li) ['alex', 'rain']( E, y0 T' Y9 x
指名道姓的删除li = ['alex', 'eric', 'rain']
" ?% g2 y& a0 u$ O8 V7 O( ali.remove('alex'); S: S+ C) A4 k& O  v  W1 o
print(li)
( I) c' {2 l1 q; z0 c) z' `f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']( x' p) _, {' J" U+ q
print(li.pop(1))( M" G* S# E0 e8 j& J
print(li)
7 o4 y2 j4 s( i& `( H1 G9 b5 S
* p- h+ w5 T' K/ O8 Q# ceric3 q1 h& S# X: a5 j9 H
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']7 r7 x" h; f, g7 \6 d# N, B3 z; J8 v
del li[1:]
1 H( I% A0 E: m) `( sprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)2 S0 H0 b( w: g' x& o- A
li = ['alex', 'eric', 'rain']
" r, w7 r; ~* }3 R* wfor k,v in enumerate(li,1):
8 T/ f: b9 N2 L# v, c; T! b print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
% T( p$ r, Q  x$ D5 O- g8 A7 Y- oa. 请输出 “Kelly”; I3 v' T% m& ^, _
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
9 H+ }+ _6 |0 c' c4 k1 _7 {print(li[2][1][1])$ w3 T, u1 u7 d* g+ e
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”$ c. s  E$ X4 J7 k
li[2][2]='ALL'
/ k; s& j* _5 Kprint(li)
' s4 k8 R" ?6 ?. \$ U5 Z4 v24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain'): b; ^  X; i" [2 a1 s
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
" b' X; @0 F, f3 V7 E' ^5 o, j- P2 jprint(len(tu))  z3 r* G; @- X: g$ p8 a8 H
b. 获取元组的第 2 个元素，并输出3 l( U- [- z3 \: S
print(tu[1])  l1 T/ L; @$ `1 Q- C7 L
e. 请使用 for、len、range 输出元组的索引  Y1 r. w2 @  U
for i in range(len(tu)) :
9 X. L4 {% `5 t5 F print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
2 T0 r, {$ d. a6 C$ Z% dfor k,v in enumerate(tu,10) :
& c; I6 d, ~, O  N- _: T* h4 ? print(k,v)( h; |& u2 o+ g: L
10 alex) s1 [# J" G+ _
11 eric  ?( e: `- m# `% I) o
12 rain
  P( ^8 X! ]8 _; P4 O; A7 H: R/ M5 v/ ?( z5 w+ s0 t* x
for k in enumerate(tu,10) :
% z3 ?; _1 W' g2 o print(k)
+ }8 \$ ?2 o: z$ Z& g2 E( Y# @(10, 'alex')
4 t4 M' ^9 b$ C5 m2 v4 K3 _8 [(11, 'eric')6 h0 e* \5 o$ I4 h
(12, 'rain')
, M, O7 _1 N9 y9 d+ s
0 ?- @. ^- J* ^3 N, z. x0 L9 V9 N
' [0 w4 \0 \3 ], Z. [; M1 e25、有如下变量，请实现要求的功能
! C( k$ l  a" o: m, Z- Ytu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

9 G% U1 h- L' N# T2 i/ ~! d+ fd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
: G- s! {& t( m4 Ltu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])0 {6 X8 B# z* P  u
res=tu[1][2]['k2'].append('seven')* d) Q- c+ [# d1 ?0 c1 s
$ i6 V& ?0 L/ C) \" R2 W
print(tu)% Y5 `, [& L" I4 W+ Q6 y  y
26、字典% g" P' z' x# z- M& q
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
; h. m, H% [* X print(i)b. 请循环输出所有的 value
2 a% M, D/ C* c' M7 e9 j% H( Nfor i in dic:" e$ v3 ?8 X# U. |! b$ d& V5 Q
print(dic)
/ A" a; R) P! @c. 请循环输出所有的 key 和 valuefor i in dic:
& D3 I3 O, D3 ]0 c: r2 u" {print(i,dic)
" w8 k/ Q3 ]: M* Kd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典% N- g* k% }# ~' f( p$ U% d
dic['k4']='v4'
, \6 f' D% @8 ~5 v' o0 U- Pprint(dic)
% ^* x5 v& J6 l* S, l6 Q4 q6 we. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典& ], Z$ c3 t  {# N1 X
dic['k1']='alex'& H$ ]+ V, l% q" A8 K! C
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典* K: D9 e3 i# A) m
dic['k3'].append(44)
( R/ m3 ^9 G3 @print(dic)7 y, W; h% p5 m$ {3 e/ m/ ]
5 u/ R7 I8 X9 H' O3 b4 L6 }
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
" |; I4 d2 x4 }: r& D. r7 O# m/ Ydic['k3'].insert(0,44)+ G$ }1 B+ G4 W( [1 {: z
print(dic)
" g- K7 s' s; |2 K, u27、转换
: q; y( E* ?# u, X: Z9 Y6 ~a. 将字符串 s = "alex" 转换成列表  s = "alex"( J& x5 g7 e$ R$ L% D1 p& @

9 R% n; g' K3 O" n% ^print(list(s))b. 将字符串 s = "alex" 转换成元祖& X" T0 I, Q8 [0 G, p: s1 I6 t
s = "alex"" N6 B. W0 i- x2 T  H% f
print(tuple(s))* `. [( C2 q* n' ?+ }: \

' q3 U7 ~# r2 S% Q9 F2 Bb. 将列表 li = ["alex", "seven"] 转换成元组; n+ W" w7 b- Q0 W2 {3 r# Y
li = ["alex", "seven"]
, z9 Q2 z% ?8 o5 s6 T/ K& m& qprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表4 o8 I$ P( v) @' ?5 a+ ]
tu = ('Alex', "seven")
7 F( W) h* b$ G3 z2 H% _9 z* Hli=list(tu)! G. P" O" [+ M6 V! {2 |. n0 a
print(li)
1 ^4 f& S- r, V$ D; x' f1 K' k3 ^- l6 q0 T0 A- Z; P

9 F/ h) M( B* p) ed. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增6 J! W' @; j( Q8 ?! W" E

' l6 A/ T3 i1 E* _dic={}
! @8 C+ Y8 D: m1 K  K2 Wfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面( _. C! A+ H9 C. D
dic[k]=v& ~1 D  z5 C) Z' l' ?% f
print(dic)27、转码n = "老男孩"
; x$ l4 P/ T( q( Z* za. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"/ K& W1 U6 s) H* A3 h3 @7 _. z! \
a=n.encode('utf-8') * s2 h5 z& P7 B( E- M: S
print(a): t, z# k8 P0 X. y, Q! m; L- \
b=a.decode('utf-8')
/ Y, p* Q2 V. K; ]: C/ [print(b); ]- I; D. a! _" ~
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')) ]1 p( n6 Q* e
print(a)* [3 r' e4 a& o; y) e
b=a.decode('gbk'): Y9 v$ l# u: D2 M- ?9 j0 L1 `
print(b)28、求 1-100 内的所有数的和6 g9 ?, I' ^& i4 k* y3 W; a3 d; |
count=1
7 ^. h( S' F) Vsum=0
$ I4 K6 p" ]- x, k  Efor i in range(100) :! v( J% k! |# y( [' @
sum=sum+count
7 c6 R, ?) V8 D9 o count+=10 _6 w1 P" x3 m6 p" M" h+ z/ G
print(sum)/ ~# f7 Q' ~# b5 V

5 N" R: D; u$ `count=1
* V# @1 q! {' Z+ O" Jsum=0
7 K* |% x& f" j- S' j  G+ x! ~while count<=100 :) c  E6 h; `  h: N  k+ K
sum+=count
7 S1 V( A+ S; k1 `" r count+=1" [% l* a& A; |- t# I- ^' I7 t; J6 f, s- |$ L
print(sum)29、元素分类. ?+ s- H: V* f# R5 J- _: O: u, H7 B
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
6 ~6 Q9 s6 r) \- U$ S) t1 W将小于 66 的值保存至第二个 key 的值中。
8 D! g$ b, C' [2 \4 h即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}% w2 F) _- k% R
li=[11,22,33,44,55,66,77,88,99,90]
0 e1 N9 \% \* a1 fdic1={
* S/ X4 D4 D& B! }* s1 H$ Z+ Y& D8 O 'max':[],2 ?% X( \: D' U  M! M; d+ B1 z
'min':[]
; M$ L. N8 r1 O$ a& i  m! z; o& W}
# ^: U9 G  c$ y% w: t7 Xfor i in li :
6 m5 y! k6 G: f- c5 w' V5 l if i <66 :
$ H+ Y( X0 Z+ r3 e       dic1['min'].append(i)1 u* N% }" R  N0 u- X6 ]
else:' |+ ?. u& `9 a
      dic1['max'].append(i)( w5 Q. P# V' w. y8 x" k
print(dic1)
8 w0 T2 K! V: r0 D1 _5 q  a
7 P. A6 C6 Z4 n) \---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
" H: B! S7 N2 B, L& d( Q0 _( I

Python基础知识汇总

主题推荐