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、写代码
. B" G& u6 e5 a, L7 O5 b& i" [, Ra.实现用户输入用户名和密码，当用户名为 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) :6 ~* L" c/ L. m1 p2 ?( c
name = input('name:').strip()
4 O1 a1 V# j2 Y pwd = input('pwd：').strip()
. V" f8 P" i" g- ]
! h+ Z; q0 v. G- ] if name=='seven' and pwd=='123' :
) k& ^) C5 N% ]% V       print('ok')) K( b. ^2 S4 b" k. q1 C
else:
/ N( v1 U$ E2 t% z       print('error')
4 K( _! ^2 Y  k       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)  :+ V: g- |- s) p2 X3 u7 B
name = input('name: ')1 P8 v8 m) I6 d" G% m' Y
pwd = input('pwd: ')
/ y7 x; U* {# ]$ Z7 h: U( T1 e if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
: Z1 e$ U& w& G# \       print('ok')
6 E0 l( ~* C& ~: T else :- P- E* _0 H# a( q: C; `- }
      print('error')' |  F1 h" v9 \6 z
      count+=111、写代码
% j' G$ V' Z( r4 Ga. 使用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) :/ d* z$ ?8 d& p7 ~1 ]/ r' N
if i %2 != 0 :
; L! V; X0 y1 a; }9 u% y$ I       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 ]/ R% K. } if i %2 == 0:
& p1 S5 ?  ~6 I% X2 O; 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 H8 _- d- `% k4 c" G
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)8 x5 T/ l$ t4 T; B( q5 I, \: x
for i in name:8 z/ x$ J& g: l% C. Y
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain# b+ f. ?7 @  b+ A6 O! A% L/ L" a
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']/ k2 P3 ^6 }, J) U
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')       |# m, |/ b* }, ^/ m6 |. n% q
print(li); h  }' v( N1 B# h; v! O! A1 ?
['alex', 'eric', 'rain', 'seven']
  l; b/ v2 \' M; `c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
8 b, {+ j; {' J1 ~* @print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy'): `4 W% |1 k/ _0 c4 E6 N" V- j
print(li)
. Q. c- E) G" X- P! O$ s7 Q1 A, Ee. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
. Z! K8 o% O* w8 H7 t' Q+ Ali.pop(1)
0 l) Z6 W1 w8 A$ ^( @1 {+ g4 B# Zprint(li) ['alex', 'rain']3 q  z3 c6 n) ^5 D, T
指名道姓的删除li = ['alex', 'eric', 'rain']5 }8 ^' b  P* O
li.remove('alex')" w8 R2 j5 v6 L; V: K7 @  X0 `
print(li)
. g, V6 s: K  A: Zf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
# R4 P2 F  q/ L, ?/ }, l0 ]print(li.pop(1))9 V, q3 ^+ f! r6 p( p. H2 D
print(li)
# `" U9 U3 M# ^8 p1 p
0 R9 r( B- b  A9 |4 D3 e3 i- u. \! Weric! Z+ E& N) H& w# M2 X9 ]7 `
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']  |9 O# T, R4 m4 x* D9 w1 U7 A5 |+ q
del li[1:]
. K: U4 C6 L' }- iprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
0 T/ T5 Z% W0 @) P5 b, S- \' ili = ['alex', 'eric', 'rain']
2 Y' o! C: Z# _1 U6 _3 tfor k,v in enumerate(li,1):
1 B; O' E) A+ c0 {1 M. b5 i' s print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]8 G, n/ V4 P9 `! @
a. 请输出 “Kelly”
1 c5 d6 O: O+ @li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
6 L: R  U$ N# O0 o$ `. N1 ~print(li[2][1][1])
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”2 D( l0 t% M: R. m2 x
li[2][2]='ALL'# g; b* [  i- a8 M+ A6 V
print(li)
2 h, H, K- y( M1 [24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')) e; G1 m" M1 k0 {
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
6 i- U" R! Q9 {2 w: a! X. Z; Sprint(len(tu))
/ r' ?, H* s9 F! J& Bb. 获取元组的第 2 个元素，并输出9 U! i3 x2 H1 P# }
print(tu[1])9 S3 K$ x! U) V+ |+ _1 q2 o; j# n
e. 请使用 for、len、range 输出元组的索引7 Z5 _0 ^7 D0 _$ d% m
for i in range(len(tu)) :
& v* y  q" X' m' Z! S print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
, [: C# W  V& t4 |for k,v in enumerate(tu,10) :% W% P. u, \7 {7 L% S# u
print(k,v)" ?! |; a* p, r/ A/ {
10 alex' ]5 O2 a- X- K" R8 p1 j  q
11 eric4 y/ _* ]4 a0 W2 r
12 rain
" Z/ ?  F0 C( z1 v8 F' f- B3 Z$ s4 D. f: B- K! a
for k in enumerate(tu,10) :  {% D: o3 D6 a
print(k)
7 Q- C5 O! o9 j4 ~" a; L, p: }3 H(10, 'alex')
; P& I3 J" I: g5 u9 o3 e(11, 'eric')1 ]1 N6 d# u4 k$ |+ B
(12, 'rain')
; `$ E6 v* {. l  d  e7 l1 N5 d5 b& H* [! M; ^! b

0 o" K, b# O! p, y5 u# ]" n25、有如下变量，请实现要求的功能
, o8 `$ @' D7 n2 Gtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
% r/ Q- g1 w% b1 z( I* e
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以  `) D$ n1 c/ A/ D' L
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])! [! z# N* v' P" x5 ^* t
res=tu[1][2]['k2'].append('seven')
9 Z* j5 ]; R2 s% S/ i  j9 a
$ H) G) T; q& G$ n$ {# Hprint(tu)
/ q+ g! D7 x# J2 x1 E26、字典
7 D8 ]8 Z" {" G) z5 E( S; T2 A! a# Ldic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:! P. D! w+ k. ]/ {7 G9 a6 I* q& t
print(i)b. 请循环输出所有的 value' G# C! C$ b( G# |( ^$ i1 V
for i in dic:
" Q5 o  O2 |4 W. m print(dic)0 B" B, S8 |; u
c. 请循环输出所有的 key 和 valuefor i in dic:
0 i- }- z8 i4 o8 T2 e; |. Gprint(i,dic)7 W9 C* o: ]  ]
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
1 e5 J% V2 B& p& K5 T0 Xdic['k4']='v4'
6 W& H8 e5 w1 P( D2 ~+ z; Dprint(dic)
, J; p  U( r8 K* a/ ^1 |" x0 Se. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
1 M7 c3 |( L" v* Ydic['k1']='alex'
& j% `' J. Z! I/ ^; rprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
' w  _, z/ V( xdic['k3'].append(44): v# k) d5 W$ T& ?$ g2 Z  Q+ a
print(dic)* `& {/ J! ]: Z& R6 [7 a

  T% H! o+ R  H3 J, J% Vg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典6 J( g8 l/ l  e& \- P) `
dic['k3'].insert(0,44)
# n+ b/ A) _0 X. W0 pprint(dic)
  c* F3 n: T# F7 G. p$ j# x27、转换
( K7 \* M: C3 V. Oa. 将字符串 s = "alex" 转换成列表  s = "alex"
3 u) G8 \. v3 \, l/ }7 w7 D7 G0 E
print(list(s))b. 将字符串 s = "alex" 转换成元祖# m$ v& S. d6 H# V
s = "alex"
( C- [9 i; y5 u/ X+ Z) p/ gprint(tuple(s))
* @  L; }& l/ ^$ s4 l7 V
% _: f3 n! i( U5 m8 w' e" p/ ~b. 将列表 li = ["alex", "seven"] 转换成元组
$ j$ c/ p( r) e1 jli = ["alex", "seven"]7 S* N- k* p+ ^  C4 \5 f6 j
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
) f' M. c3 F! Ltu = ('Alex', "seven")
, R! X/ e& K4 d& X4 Bli=list(tu)8 o8 o$ Q# F; m5 x3 u+ @
print(li)
' A, D0 {0 t* x0 I' c( K+ M4 ^. F( b/ E7 a9 u# f% x( Y

# Z3 ~$ B* _9 c( vd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增/ v8 ~: k& a8 s& S/ E+ J

" q' [) U4 p, \dic={}7 k+ W7 X. C3 C
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
( z% [5 c; t$ |* C dic[k]=v( \2 r+ y- Q( y% i/ A# w! O
print(dic)27、转码n = "老男孩"
. [, z; g5 o7 q/ aa. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"$ B: {# @% a" T
a=n.encode('utf-8') ) g: e/ E  j% V: i4 c" D
print(a)
# o4 Z9 B' N: Y- a1 P  |b=a.decode('utf-8')
' Q$ i2 C% E1 |. i; T& Zprint(b)/ I: E/ O, b2 l8 F
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk'): E5 r; G( a$ F8 ?
print(a)
  ~* ~; d/ `3 [1 F5 yb=a.decode('gbk')/ P/ G/ w7 Y: y5 K7 f- r
print(b)28、求 1-100 内的所有数的和
) v. n, L# u- {5 A1 jcount=1) I2 x: p8 k# f9 G
sum=03 u& ^1 j' v5 D
for i in range(100) :6 i% }# G- M5 Q4 s% E2 S
sum=sum+count
2 y0 S; K3 J0 `3 a$ | count+=18 N4 W4 x/ Y6 j: ~( w
print(sum)8 V$ q3 g( ~6 q8 W3 E
' \( V: u" k8 L, T# o* a
count=1+ u0 ~3 d$ o5 Q6 f  I+ P8 S
sum=0
' V8 ?4 b3 I- }while count<=100 :
- V, s# Z9 l# R0 }! @+ Q sum+=count) @7 U8 [+ m4 Y0 o! Q. H
count+=1
2 z; l4 G0 R3 Dprint(sum)29、元素分类) @! V; [9 e  i- s) [
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
1 Q, ?; n' n! }3 ]将小于 66 的值保存至第二个 key 的值中。6 I: _* t# p& @- \( s  G$ h% T1 u
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
; S7 T& i- o. \; Yli=[11,22,33,44,55,66,77,88,99,90]
" U" m9 F4 R- t6 b; A3 P: Odic1={
! h/ h6 H& }1 ] 'max':[],
6 ~8 r: d8 c5 s: R2 h, s/ G 'min':[]
" e/ B1 o3 l4 K5 l5 F}
. O$ |5 O- N/ }6 m( d6 ?3 }" K6 kfor i in li :* r+ R& q/ v8 f' y- i4 ~
if i <66 :
( `* y5 ^- q  Z       dic1['min'].append(i)
+ O7 C9 v6 |+ c1 h4 A& b; F* o0 p6 L else:
) e# K* R* i! Y/ Z1 ?0 t3 I. S, Q6 i       dic1['max'].append(i)
4 H5 a$ ?0 T0 t( yprint(dic1)3 s$ r- H: I5 i( f" ^, K+ n

% d& |' _2 g* m! h2 }, q- x---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
9 P* r/ z% [! w4 W  q, W

Python基础知识汇总

主题推荐