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、写代码. O& }. L. Y# q7 e7 a" D# ^+ X3 s5 r
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 Z' n6 f( s; z- t) u
name = input('name:').strip(). d  n2 g% A  N" j8 A" D
pwd = input('pwd：').strip()
8 R; ~6 Q, Q* T9 Z9 M3 F0 A" R3 l. r6 b7 f' r8 B7 Y
if name=='seven' and pwd=='123' :
) @+ ^) ^3 l2 h% n$ p       print('ok')
/ C! _$ @  Y8 K, |2 t else:
4 v" W* J! W3 f( \       print('error')$ N) ]2 U! r4 {; l
      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)  :1 n( G1 A. E2 M$ y" k
name = input('name: ')
& L# ?& ~& a- S0 P. H pwd = input('pwd: '), a2 c3 p" G. O) k2 I
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
3 ^  H7 ^3 G/ |) q/ B5 G9 n       print('ok')( s/ w/ C5 J. N) \0 q
else :
% ~/ y7 F# v2 G0 D" W3 i3 W* L( q       print('error')( F& ~$ L: K- s" x  O
      count+=111、写代码
* M% v$ M, 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) :
+ v* d) l, M: E+ ? if i %2 != 0 :3 @% S  }" C9 w2 U" P/ W- \  g
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
* \3 C9 E9 f9 W- F: Z* G# C if i %2 == 0:3 N3 ], a8 G* r3 `
      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"0 T% U4 L# k$ [
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( u  t7 K& w. V( H% Qfor i in name:: n# F: Y" L, k6 `
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain9 p! B( T- ?. Y! p
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']; J8 `0 }  X$ B8 y& T
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    * s+ D& n, B0 |) N& {
print(li)+ M9 l" e3 P! P
['alex', 'eric', 'rain', 'seven']
, k" q# R' \. D' o5 f0 [  x) Fc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')! T4 K0 S* _' ?! G
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')& h" u; s/ C/ Y7 [. X2 G" J0 C
print(li)& W' m# j) F% Q( S
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
, A- ^/ \  R3 X: f4 rli.pop(1)
7 W0 L. Z/ B$ L, t0 B- L4 rprint(li) ['alex', 'rain']
% P  n& S/ B8 [7 H; D1 i0 ~指名道姓的删除li = ['alex', 'eric', 'rain']8 p% X# A8 j1 q; ~
li.remove('alex')
9 ^; U5 [9 `' ]/ Z/ Rprint(li)
$ R+ }+ p8 q: m2 y! H$ R( Kf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']2 M; ~1 O. |: O" \4 A, ~, P, v
print(li.pop(1))  V' m# y/ ]: \
print(li)' x5 M) p, z& v6 Y4 @

" a1 r* R: i8 w4 ?eric
: f' j  Q8 O$ F. x3 d7 G8 r4 ]3 m1 ]['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
9 o, z8 \0 `  J$ Z5 |! q+ mdel li[1:]
$ T  t' F# d6 Y9 Y: c9 ^print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)8 r' x) ^: y6 T1 v3 W
li = ['alex', 'eric', 'rain']3 I/ Z; F- j6 B" t  x5 K
for k,v in enumerate(li,1):
6 T( K" u9 e' @2 {+ C/ J print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]! E1 @8 a, X1 [. w, H. I: V/ y
a. 请输出 “Kelly”& B- d, Y3 i) G7 r  l3 c8 l
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
# `9 b% U/ G; b/ t4 pprint(li[2][1][1])  x0 v7 e6 O. H3 U
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”5 {' E, z5 L8 }& f+ k
li[2][2]='ALL') v7 A9 Y/ _0 }0 G, p. M
print(li)
+ N9 I: d, H3 x! Q4 x; e- v& s24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
% }- x( d  X; r: x  ma. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
# ]. ?- S' f& u/ c: O! }; c! O; w" Fprint(len(tu)); V1 o- O% k3 H, Y
b. 获取元组的第 2 个元素，并输出) Z7 O5 J1 t- p" |
print(tu[1])
6 A3 C, C$ O( n3 P  z( M* V" we. 请使用 for、len、range 输出元组的索引
! v7 B; M7 U# p2 K+ d+ U6 Yfor i in range(len(tu)) :' Z6 [  Q8 p& i% k. ], |
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)8 T) ]0 b; F2 i
for k,v in enumerate(tu,10) :
6 d# X3 V! f3 ?- s  |: j" }% j print(k,v)- R. e8 A3 e+ V( r: H% K. |
10 alex
1 n8 y4 ^5 g" Y11 eric1 |3 n( b3 _8 ~7 Y/ z! [
12 rain6 }- p/ B3 W) n% M/ m+ }

& \7 `& n5 N2 X4 Afor k in enumerate(tu,10) :7 g. ~4 v% G  I* d2 j* S
print(k)
, s; k" }. a4 _(10, 'alex')
) S# z8 M; U. v(11, 'eric')8 y7 \, I; _* _' T4 K% _
(12, 'rain')
' c; K5 L- k6 @& X( \1 Q/ ?/ O
9 r! U' C3 q/ j
0 Y9 h: y5 }% U  y# U& _25、有如下变量，请实现要求的功能
8 |5 g+ @" h- Mtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
& f* ?* h7 b3 s7 ?& z9 x# t& G! K2 ]
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
. `" y) \2 \" X3 b  g/ c% ?; Ftu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
# [8 H3 |& `5 V2 y3 d9 Lres=tu[1][2]['k2'].append('seven')3 O1 A: @: z6 ~2 R
2 f8 `7 ]5 R$ x- o9 X; q
print(tu)0 S+ a( y- i& q4 F1 V; t  {
26、字典: i& q) t4 K8 ~" a5 d6 D* }- `) C
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
# l2 N+ C" x' H print(i)b. 请循环输出所有的 value0 `; O4 f1 l& t' g0 [
for i in dic:# l5 T1 f/ ]! j% F. y/ f, s% L
print(dic)- c9 a; D/ C; U& E$ n
c. 请循环输出所有的 key 和 valuefor i in dic:
* x2 F3 l7 B( ^: pprint(i,dic)# R) D/ A$ p$ }; Q9 |" t2 W
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
2 o2 r- K2 }0 J; x  Xdic['k4']='v4'
# ~) w, ~) m# z* a4 @4 }% q8 {print(dic)) P5 K  g) q- k& A) v* D) h9 n
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典# M" @+ u$ U" P
dic['k1']='alex'
! [5 L* }- A# g! D; P% P, ^5 Aprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典( D, S. p! Z: W. x
dic['k3'].append(44)
print(dic)( ^) }$ W2 Y: t: d, ^) Y" p9 X

; d- F! h. O2 w& h' _g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典6 J6 y; K8 @; {6 h5 q0 A1 P
dic['k3'].insert(0,44)% E8 s6 u% b. W8 @/ [$ _" N
print(dic)# W; {) w9 @; A% i" h$ G4 }9 e1 g, d
27、转换& E+ X. A! ?# v- ^- Z
a. 将字符串 s = "alex" 转换成列表  s = "alex"
4 G" d; U  o, N4 n: h
+ c8 i8 Y6 }& V+ j. Sprint(list(s))b. 将字符串 s = "alex" 转换成元祖
3 d. k! H& H: v% @3 {/ S% ns = "alex"
3 g8 ?2 e5 J# X- t1 a( ^2 Xprint(tuple(s))
2 L% D0 ]: ?  k; n  S* l5 |) Q5 L; |
b. 将列表 li = ["alex", "seven"] 转换成元组
! m  `  r, z6 c' q0 Fli = ["alex", "seven"]6 z$ @2 s; T& `( z% T
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
2 J+ V. w8 O$ \9 f8 @tu = ('Alex', "seven")3 ^2 B( R: L: y2 M! u' O
li=list(tu)
2 \% D* m' z# {9 Bprint(li)
" E8 Z4 z9 B! \/ B& a7 `
/ W( o  o. T6 U. r3 q/ j* {# f7 j+ Y5 ^( h  r
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
2 E1 \/ Z* \1 k% v: R8 Y, x! W" b3 K- J  v
dic={}
' K8 y, J0 J" i! Z* Dfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面0 }; t8 _$ |% C7 l! p* b
dic[k]=v
6 b# I4 Q: k, v- }' t1 a print(dic)27、转码n = "老男孩"
& r4 a: n! s' O% u3 h, S' Aa. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
+ L2 h( q( h- A9 ]: }+ Z1 [a=n.encode('utf-8')
0 e; g% ^4 y4 n3 x6 `) hprint(a)8 P1 H4 |8 w) K
b=a.decode('utf-8')
/ A% t8 ]! D0 z% lprint(b)
  p0 c* a: V( j& D9 ?8 \: e; Xb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
& f- w# ^8 I* i' Iprint(a)( n. H9 ?6 @  C+ \, Y
b=a.decode('gbk')
3 p: k5 U* F' U4 o! b: B0 Uprint(b)28、求 1-100 内的所有数的和9 u9 j" e7 P5 b3 H" Y
count=1$ T$ t! X" S. G- G" X8 I
sum=0
% S. w# i& r+ Z- k: Dfor i in range(100) :
+ a. f1 U  u3 h7 b$ @* @ sum=sum+count: }) @2 w5 W' F1 i) a3 E# P# T0 C
count+=1
$ i+ f# O* S5 k: E  J0 T* Kprint(sum)
1 v" O+ r3 ?, y
5 p( |0 k1 N6 x% w, }9 Fcount=1) F  H. m# P$ Y$ x) Z
sum=0
" \3 G( r1 d: I, x) Zwhile count<=100 :4 e7 p0 k3 r& d- j: o
sum+=count( {( N8 I+ w+ U) b+ m
count+=1: u0 W* o$ M6 J0 R
print(sum)29、元素分类
7 a# |' @% Z2 S: k有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
- `; }. p8 H* Y" r/ Z将小于 66 的值保存至第二个 key 的值中。+ V4 J7 o# G0 f. y$ P  G4 H2 N
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}3 j& T; ^3 J! B* \: ~* U5 G
li=[11,22,33,44,55,66,77,88,99,90]/ n' S. `* R# S' ~# e+ D1 M
dic1={
8 r% ^; c0 g/ U6 L 'max':[],
- P+ S- K8 J( s, P+ q* v( \- I 'min':[]' o# a* S  Z& X+ Z
}
* o, o5 f/ i; afor i in li :$ Y  Z* v4 b  T9 U  ?
if i <66 :3 J# F0 X; I$ f/ ^
      dic1['min'].append(i); q+ c# [- Q2 t& W1 O+ \0 k% v
else:
* j; N  p4 N9 Z" X; Y       dic1['max'].append(i)  r$ r* e/ k- |
print(dic1)
; W+ F; m, O# h: l2 l% O) H$ g# w
$ X# I/ ^/ a) V/ J  ]; O+ N---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
: R' k5 `2 r+ n% G4 y+ E

Python基础知识汇总

主题推荐