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、写代码/ M- }& n" N7 `$ {; ~, S5 {/ F
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) :
3 `6 z; S+ t) Q3 j" C# c name = input('name:').strip()) S% t' M: x2 ^* e# [+ O% V. ~
pwd = input('pwd：').strip()
/ {- v, i* ~/ R& P% [' a7 [% Z! F1 @  f9 j# H- M5 g) _% h
if name=='seven' and pwd=='123' :
& E. ~6 J# Y6 o       print('ok')9 _2 K7 r6 m, Z' v! k' `4 `
else:" E4 v+ h  Z2 n/ |2 \9 ?
      print('error')
7 x% G# |5 `0 y4 @0 _5 p" a       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)  :# g5 \, z3 X7 y# F
name = input('name: ')
) B, V- W- D" G& \5 {3 C! p/ e; ~4 o pwd = input('pwd: ')
( c4 @! ]" x$ g if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':8 D6 k) |0 W9 R4 j0 t, s
      print('ok')$ C& _" z; {/ B9 S* ]+ A; s
else :
: o+ ]( r4 P/ h4 Z; M3 [% T       print('error'), l- p9 R8 {# y3 o  Z8 U3 K
      count+=111、写代码/ z8 ~$ n7 o- c
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) :% f  Q" m1 U- ^5 A- Y4 ~
if i %2 != 0 :$ X# l$ k) T# q: P1 Z( 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) :1 V1 m3 V% J! c$ J9 K. J; y) f
if i %2 == 0:& c; Q0 b& x' c
      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"
5 w: a# O/ d5 q+ U  c5 ra. 移除 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)
1 T1 a2 `2 C2 Lfor i in name:
# v4 n! S0 E! J print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain4 S+ }2 j" L. t- Z7 @+ _
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
% J% ^4 O0 u: B0 P+ h' `9 `' v) cprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')       c- {  S8 `$ ^, p% q
print(li), F4 v- }& d; F
['alex', 'eric', 'rain', 'seven']( j+ t; x# u& R7 D6 H
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
0 k1 e9 O" D' R3 w" t& f& xprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
$ B5 b8 K1 g- b/ O; t( M/ Iprint(li)
  g# q# b: \5 e2 B* M. ce. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']8 a" v' v: _6 {* B3 m7 M
li.pop(1). g$ q6 i0 T8 _+ t/ G7 {) ?
print(li) ['alex', 'rain']
9 Y' h2 s$ w0 t8 e/ Q指名道姓的删除li = ['alex', 'eric', 'rain']6 B1 ]2 N3 ^. ?6 }
li.remove('alex')
( f& _; V! P5 H7 s( A: }/ Z" K) a" Fprint(li)
* w; M+ n- C/ l( `f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
) b$ s0 g0 J7 F/ ~0 W' {. p& hprint(li.pop(1))
  ?) T9 z, {/ x$ w8 Jprint(li)
7 J7 E+ b2 \! Y7 C9 b6 u: F4 x4 P* y
eric
% D0 X- y7 n5 I  a['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
& y: I6 }! s% i1 _7 p, J, zdel li[1:]
# v# q' w" X% y3 F' cprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)# G& H6 c  o- Z# V
li = ['alex', 'eric', 'rain']
; ]1 B: @% A! j% P1 I5 Nfor k,v in enumerate(li,1):
* Y% T- L/ }4 \; P  G. I" } print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]/ m  Y. u( |5 ?# I; m4 E
a. 请输出 “Kelly”6 S4 R- d- l/ b' m
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]5 U' Z; \! O8 s6 R" p
print(li[2][1][1])
7 b7 H+ L7 d' h( ]9 K' rb. 请使用索引找到 'all' 元素并将其修改为 “ALL”
3 h  }% i! {+ K/ z4 x3 B( |9 zli[2][2]='ALL'3 f; w. `* d+ b! b/ B
print(li)  W2 Q- s5 V9 t" H
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')6 g% P8 |& B; j+ e* h# t  G9 H
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')! N+ J; z0 U2 H; @
print(len(tu))
% b( K5 d" E5 O8 o( `b. 获取元组的第 2 个元素，并输出- v! Y* _, B* y! {6 V% X4 O
print(tu[1])
7 O6 P9 E7 c: ge. 请使用 for、len、range 输出元组的索引
- y6 }3 ~5 m: `for i in range(len(tu)) :1 t" Q2 g! Y. z% u- c0 y4 [2 A
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
% z. Z( V' s. f8 C; C1 G7 |for k,v in enumerate(tu,10) :
! A8 U# l  q- @) M print(k,v)
, \% S7 w  `0 k9 m7 K10 alex* g6 a: w- h- G! E) F6 d: s" i
11 eric3 ]4 o' g( R8 V7 e
12 rain
. Q' J1 B" w) t2 T, U
1 W7 E% x/ t9 _5 |; D; v) k, [1 @for k in enumerate(tu,10) :/ `4 h4 [) L: o
print(k)
# c# b1 ~3 T* `(10, 'alex')  m: g! x9 n0 z' n1 r- v
(11, 'eric')8 D. }. W: T$ `- N8 [/ G0 Z
(12, 'rain'): j4 W- [4 P& e
$ A2 r2 L% c% H4 y4 M  j

1 Y' z* f" w' E! J# w, a+ `" M25、有如下变量，请实现要求的功能1 A  a: b4 U8 u4 @; j2 t' h: [
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

; N3 h7 c: X: ]d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以4 u  w6 P( Q0 \) m8 ~/ r( I
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
) d2 U. S6 m: T9 h! w2 Ures=tu[1][2]['k2'].append('seven'), a" m+ ]. \& e1 ?- p: O2 H
! X0 ]/ Q) M: F2 u
print(tu)1 f) j- b5 [/ |& d/ t+ e7 k+ G
26、字典% Z" m$ p2 v9 o- u) F
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:3 C, R5 r! `( @8 r% l: M8 m. t, o5 ~% d
print(i)b. 请循环输出所有的 value
% _, M/ H0 [$ w3 n2 ]( w$ Sfor i in dic:# t+ I6 y3 s: p# x) I# F7 P
print(dic)( G6 F, J! p" y7 o4 |
c. 请循环输出所有的 key 和 valuefor i in dic:
0 J3 w* b9 d1 n1 {* wprint(i,dic). H2 Q( \! K7 d4 ~- ?
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典& f" `  j2 B6 E; f2 E8 C7 [
dic['k4']='v4'% r, ~- X6 G0 c/ ^8 D1 _' c
print(dic)
- s) I8 x1 j1 e! ]" S; be. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
& l  e8 E) ~/ S5 k' Z: pdic['k1']='alex', o. k4 b: k& \
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
; z9 I& b1 }: b9 M6 z' S" ]: _dic['k3'].append(44)
7 Q1 F+ K; Z, Z" j* _6 \print(dic)
+ ]' ]  w  E4 c4 F8 W* i+ ?
. m- u3 T, K6 P' `1 bg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典; I6 H( V- G% T, h$ J
dic['k3'].insert(0,44)3 `# S# y0 v( y! t3 g2 j5 M* b
print(dic)) g* `9 V" z/ r
27、转换
& q2 h# l5 h% X4 O# g% I. fa. 将字符串 s = "alex" 转换成列表  s = "alex"
( D4 b$ F0 l. b: s' m# u) N6 b" _& U+ X# R- N/ w+ V
print(list(s))b. 将字符串 s = "alex" 转换成元祖
$ E& {9 Z; ^  Bs = "alex"% t+ A+ ~# ?" T2 T# n% Y, H0 X
print(tuple(s))
2 ~$ z7 s, Y* @, U9 G' ]
6 z# n! H! P4 [# ?b. 将列表 li = ["alex", "seven"] 转换成元组  K& H- T! }5 R: W
li = ["alex", "seven"]
# S3 y3 ]& d3 M1 H  C2 U. j/ w0 wprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表6 W7 i7 \6 K! g" {* d9 u' \( P, c
tu = ('Alex', "seven")
) N" Z, s: _5 x% ?. n$ Wli=list(tu)
8 @  U. D% X2 \; q; h. o+ fprint(li)
* f4 h$ r2 u* s3 k4 g0 M  j
* H2 j2 b( K& `+ _$ X0 m6 H# j* F7 |+ L  s+ c
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
- ^9 G1 S" s  c' u+ H9 r8 ]  V+ `% ?
dic={}
1 p/ R4 l/ S9 Zfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
' F8 l1 v6 X- W1 G dic[k]=v
5 l" \5 n' R7 _& G5 K" P print(dic)27、转码n = "老男孩"
; [1 F' h7 H% c4 j4 S9 da. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩") u/ h5 x: E7 O; y- B9 P
a=n.encode('utf-8')
) u6 b; @) q2 r/ N% b& ]: fprint(a)
3 P" y1 [4 v/ L& A; Yb=a.decode('utf-8')/ F4 z' M, ]+ ^* @) ], p
print(b)
! [3 c' S( y" gb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
) |$ D4 @; n, N0 B- vprint(a)
1 M1 ^. n. |# N2 fb=a.decode('gbk')
& x, R8 e, F, f/ l' cprint(b)28、求 1-100 内的所有数的和
5 D6 ?. h6 C3 {9 v# @1 b+ _/ dcount=1+ L6 d4 Z) N1 Q, s
sum=0
0 |' z6 D# |, L9 O$ D, ]* {: ~for i in range(100) :
# R4 T: J: B( ~9 a sum=sum+count$ o2 q$ ~0 i/ k- ~, t
count+=1
4 B5 L+ y3 W& M9 F* g0 Zprint(sum)
4 r: S5 H. |4 f; h* E6 K
0 u5 c1 l2 I. g/ L- O9 U6 G6 l0 u' Ncount=10 M' [" l+ o$ h$ I# V4 t# z
sum=0
9 N2 @7 `  q/ e& n. _* I3 C; `while count<=100 :" v2 N! L' d. {
sum+=count
3 z/ `* f4 e0 R7 M count+=1
$ p9 ]$ Z: k1 ~' X; I( Tprint(sum)29、元素分类- }- {( \9 T: t3 ?. |
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，" W: M# B2 s+ [7 P) e
将小于 66 的值保存至第二个 key 的值中。- y+ N$ O6 F0 V1 M' M
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
1 F/ Y; T; f1 J$ b, d" e% q# C" Vli=[11,22,33,44,55,66,77,88,99,90]- z6 ~5 c" r. @  z
dic1={, z! ]1 ^7 X# g5 I; ~
'max':[],8 _3 _4 a  V, t; ]
'min':[]
1 }& q  K, H0 G. w5 I- z3 d}( e0 n: X/ z/ C9 |) m
for i in li :) i# I0 g* `2 e; N- C4 J( k4 Q; Q3 S
if i <66 :+ k: Q3 Z$ L9 y/ Z& J
      dic1['min'].append(i)
) {# j" o; V+ A else:
: q6 [6 U3 j; I       dic1['max'].append(i)
( s) D% R9 @, D$ e* A& sprint(dic1)# E' T! Q& I  T* N( G

, e% k0 z" E5 w9 l6 ~5 N---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
3 z/ Q  n7 ~6 v+ r" H9 N+ Q2 [) Q7 G

Python基础知识汇总

主题推荐