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、写代码' f( e1 d' `/ c
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 X' n/ L# I6 ~* n$ _ name = input('name:').strip()$ R; W- E/ r( x: H1 {2 a! g
pwd = input('pwd：').strip()* Q& L, {2 U+ a4 _7 x
( ?" b' a% b3 x5 X) [% H( R
if name=='seven' and pwd=='123' :
2 j% g, b7 E- t- c* f6 m       print('ok')4 F+ x, K' s) A
else:
1 }! l4 {9 n6 G6 _" g       print('error')
9 ?6 n0 k: `" I1 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)  :/ O) \, a7 o: o- a$ g
name = input('name: ')! ]* S; {9 U9 J' z3 x# D
pwd = input('pwd: ')
7 \, L3 ?; _9 i' z if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
& D8 i7 c2 M  [7 K- N       print('ok')+ \7 O. \# x8 c- I# S
else :
7 t8 Q$ Y$ ]+ {1 o( M8 ], p  \       print('error')
2 C, h" `, _0 N  H% z       count+=111、写代码
/ e2 D) L( ~9 C( d7 C* E' H5 ]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) :2 W* y: y" a( T0 Q& M
if i %2 != 0 :
: ~& p! {4 T  I) Y0 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) :
6 e2 d# w$ A0 f" e if i %2 == 0:
9 Y5 P8 H7 Q1 V) }: j" V  n" Z       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"! k: f6 S# s( }* ]
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); ^! v1 Y1 z* H: [  M
for i in name:$ G, n# ]8 l. n  |8 t0 c6 R3 p
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain7 {; }4 {1 d( N- Z# B  F  j
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']- s( H( B( {! c4 S1 |! V0 l
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
. K8 s, X+ e8 Mprint(li)
1 g0 \. l! g# {& j ['alex', 'eric', 'rain', 'seven']
  @) x0 I0 l; r2 A9 _. uc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY'); k. }6 j& `+ F
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')- X# G. p: K) \- l
print(li)
4 p9 ?* ?4 Z+ F- R# ?' u. o* R' j9 t; Ze. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
" o5 l, ~- F3 Z  u/ S1 A5 d2 Hli.pop(1)
" |; Y, K8 V: V# pprint(li) ['alex', 'rain']! b5 }( L! t/ U, x
指名道姓的删除li = ['alex', 'eric', 'rain']2 t! i7 m8 q2 B  O
li.remove('alex')
( V4 P) T& c- Q4 v+ _print(li)
4 n! C1 B3 t. E! p- e# ^9 Uf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']  O9 t4 }) z3 V
print(li.pop(1))
, y+ K. ^; c$ _5 Wprint(li)# W& W2 d/ p7 a+ {
6 D3 a1 D, n2 r3 }2 a) [
eric
4 Y3 `5 [3 N2 T9 o['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']* T# E/ U: p5 p2 W6 d
del li[1:]/ }( `( `$ y: N8 p
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
! G: E5 Y/ m0 A5 b* ?li = ['alex', 'eric', 'rain']
8 }( C+ {  v3 O6 I9 q: Tfor k,v in enumerate(li,1):: z: d( B' o4 z9 v" C7 O* u6 H
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]9 d/ K! @0 I' y
a. 请输出 “Kelly”
' {# ~" w+ Q& Q% W- J! Qli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
. r* Q9 @0 |9 g2 u8 G8 hprint(li[2][1][1])
1 g7 V: O* z3 q; R' C# Vb. 请使用索引找到 'all' 元素并将其修改为 “ALL”/ j2 ?3 d7 G+ z6 ~" U) Y8 R
li[2][2]='ALL'
* T6 M9 V  s+ s. Gprint(li)# w, {# M  e# F; g' x& F5 h
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')! b* m& k6 O$ s; ^- M
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')- q0 h0 G; l# _+ P
print(len(tu))
# [: i4 s- G0 L: }% l$ eb. 获取元组的第 2 个元素，并输出7 M# T# Q9 L3 U
print(tu[1])) a# h$ c% U& s$ W
e. 请使用 for、len、range 输出元组的索引
% S: n2 m. E, `3 x) ]* r7 T( t  Ufor i in range(len(tu)) :( V* {: j0 y; U6 L! O1 M, T
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
4 u; Y; q0 p& n3 \, z9 Wfor k,v in enumerate(tu,10) :$ P8 o( E1 t' o& f$ j  Y, E
print(k,v)
& w% g( L+ S& B% U10 alex
. e7 }4 r. [. s7 _11 eric
* ~  h- c6 Q8 a+ ^, P# W12 rain
9 X" q; P7 ]/ c" B3 c% W/ Z
+ Z% |/ r  s- ^) |( f; gfor k in enumerate(tu,10) :
* T' m1 \/ g# l7 g6 c print(k)' R8 E: f( Z- A) W; W
(10, 'alex')) k) w# @' a: a! [" r! A- t
(11, 'eric')
6 l0 B/ I9 n7 k8 Q, Z9 E. e(12, 'rain')
3 i$ w' V  K: W0 O) Y
# M( d% R/ B, E8 L5 V/ L6 Q0 Y. F/ S0 p
25、有如下变量，请实现要求的功能
0 I' v! a+ m9 \4 otu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
- H3 q- e" d% b# s' M9 h* }
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以9 m( w; L" K* z6 t7 A/ D$ K
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
* ]/ R* F& i! u% ], [& i# rres=tu[1][2]['k2'].append('seven')4 ~$ R- G) p& u5 ^( I  B& X" V+ w

7 z6 |/ O& Y# }print(tu)* H0 r. I& d  T' p3 R! F# U
26、字典3 W8 Y2 x) z& G# O! ?- C. \9 j3 {
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
1 a1 _( ~7 c, d% V print(i)b. 请循环输出所有的 value& [# N4 Y3 t- w6 s1 w. b) d
for i in dic:$ v' O; ^- t7 F9 J
print(dic)% J6 E+ ?* P0 r* }: p8 ?
c. 请循环输出所有的 key 和 valuefor i in dic:
* Z' G; x; c  a5 Rprint(i,dic)
# c' j* p$ b" O! {: Z: U) |d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
# o% i& J- ^+ X% Z, zdic['k4']='v4'/ y7 I) D" ^7 r* t/ d
print(dic)
8 m" C& h0 `; @4 F; Z4 a  U$ {e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典4 U/ F! ~7 d: v2 t
dic['k1']='alex'
' B0 N, n. r! |# ?  o- Yprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典  w1 X2 b0 h  R' u/ H
dic['k3'].append(44)
; a6 W6 a, H5 B% l( ~print(dic)' g' O: p& z0 V8 G; X
$ N+ u5 r" U' H7 t
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
# m5 A& d2 x7 G6 {dic['k3'].insert(0,44)
+ E" L; ?, Q, O+ D2 xprint(dic)
1 K5 w4 G) B0 z1 y3 P: I7 P27、转换2 @8 ?  b7 b3 G1 j
a. 将字符串 s = "alex" 转换成列表  s = "alex"3 o; l! }* O5 u, n( `
5 K2 n) u2 \7 n' q6 \% e# s# r# J
print(list(s))b. 将字符串 s = "alex" 转换成元祖
8 I4 |1 R  d( c$ N; M9 Ss = "alex"/ U5 ]. N; |1 W( j) z  W- `# b; P
print(tuple(s))
* w& g" t5 A5 F" k6 O
1 g* E: j! N( I) \" k( ab. 将列表 li = ["alex", "seven"] 转换成元组9 }# p9 {) ~2 v: A
li = ["alex", "seven"]! ~  K: C; t5 c  k/ m
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
* m9 c, f/ E' Xtu = ('Alex', "seven")
: q" f( G4 {# O/ q4 C' B) Wli=list(tu)
- ~* W& |1 ^5 W( f7 _6 Tprint(li)
9 E- B3 @' ?/ y8 }, {5 F3 a9 }, C0 \& g7 ~8 ^
5 |+ `- A9 V# Y. j
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
2 n) I) ]1 K# c: _# L+ L  j( }' `, g6 e( P
dic={}
5 h8 X# |* Q1 V) }+ z5 Vfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面- X  j. a' P% r% _+ m
dic[k]=v
2 r( P% _' O5 u; q2 q# A  n. | print(dic)27、转码n = "老男孩"
# }! M  C0 a6 Y$ Pa. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
" J8 `1 \/ h0 |( B7 h! ma=n.encode('utf-8')
% U4 w, E4 t0 H- G2 }& kprint(a)
. _7 e# Z' X8 j5 d0 o& Nb=a.decode('utf-8')
# f3 s* C' g0 L% Q3 ~7 N+ p0 p7 Eprint(b)
+ ]  \0 O: D  G- E" O  xb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')  B1 S! E' A- e
print(a)9 S5 e9 [- S+ w" Q8 {/ c' _
b=a.decode('gbk')
" F2 i: A8 `" v. B$ c6 Pprint(b)28、求 1-100 内的所有数的和
! m. k2 V2 S# z0 M8 Kcount=1
: H# T$ B1 Z% l4 Q+ g0 lsum=04 ?! F/ x9 j% p, Q2 j" i+ I1 Z
for i in range(100) :; m1 I6 y. l% _0 a' l
sum=sum+count
, `- W7 x% I" H* W8 H; {# Y count+=1( \8 Q8 _* {) s" b8 _) D
print(sum)9 b6 ^# W' R. h+ E$ ]8 e

0 H. m3 u% X/ B$ G$ R- Zcount=13 a# U9 m# T8 O. L
sum=00 \$ M7 Z3 |" p/ {$ t6 t
while count<=100 :: s$ R& {7 Q+ c3 X- F, V( z9 Y
sum+=count
2 v" w+ O5 d, T! l) p/ i count+=1
2 N$ j4 r) {; s- Gprint(sum)29、元素分类
; g8 {) K* W: ^- z有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，9 X# E# G8 H) {: Q& E# B) b
将小于 66 的值保存至第二个 key 的值中。2 o" U) M1 R- H& o4 Z& S& ]
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}8 c% {# q0 v6 V* u% {
li=[11,22,33,44,55,66,77,88,99,90]2 R$ u3 P0 k" }( k6 f% a: M
dic1={
0 |) G; C8 v6 E% M 'max':[],
0 S: Z9 r& i! T% ~( Q8 w 'min':[]
: _, y4 h* D: k, ?. D}
( t6 r" D2 k6 W$ L* l" bfor i in li :. r2 y/ n% W+ d0 v  |6 x1 @$ e
if i <66 :( M1 n' x  b5 F2 h
      dic1['min'].append(i)
2 n9 a9 _3 S# n; w4 `( e+ e  O else:
+ |% @7 J% m* M& C2 e5 ]       dic1['max'].append(i)
* W( N9 m4 [# W8 t4 b7 S# x: S6 Lprint(dic1)0 U% G2 l' X. @% [2 V

& R6 N9 o3 n+ C% ?" P  `---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
* @4 U* n+ F# w; H1 H$ a  a

Python基础知识汇总

主题推荐