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、写代码; F1 G" ~4 U  g, N, `
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) :
  Z2 d+ g) {- l; e4 Q% P name = input('name:').strip()
; H$ y2 m8 j7 }0 g pwd = input('pwd：').strip(). u. B: ]0 y; V4 O$ \' e6 b7 [

/ J6 |' v( C% w  K7 @( s/ n% g1 k: B if name=='seven' and pwd=='123' :
4 I1 J% ~' n0 o. L- {$ w  X+ M( W       print('ok'), E4 }" l% Z. r. t
else:
6 s9 p! a; |" g/ t# f       print('error')
1 [$ F' h/ p) {( ?+ }8 ]' [       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)  :! b* P( G& K# L, Q; ]
name = input('name: ')# b8 z" I- L/ t! k; u) E
pwd = input('pwd: ')7 ]/ y0 H% U9 m# B
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
) D, J$ X( L( d3 A4 h. o8 m       print('ok')
" C. P0 K5 Q: ~, \: Q else :
4 A4 C! e0 B) J" q9 K7 w+ q       print('error')8 \) H0 V, |( B6 V* ?: ?7 x
      count+=111、写代码; G# C% [5 A; x: m* @
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 n8 ]) I+ P* I9 K& n if i %2 != 0 :0 Z/ l+ I* }/ E
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
4 l$ ^5 [1 C2 w if i %2 == 0:
8 N1 P7 I5 l8 Q. P% H% U       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"
. l! W* P7 i9 o; 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)
! f9 D, C/ s! g( M) a  sfor i in name:1 K3 {; A% q/ ^  D6 O
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
' r3 Y7 Y0 y( m: A7 {0 T# w22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']* `1 @/ F8 n! N, k% M; g& Y
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    1 q& _1 C/ t$ K, p
print(li)
6 h( }, A6 b' `/ r  o* k ['alex', 'eric', 'rain', 'seven']" s! D: `1 i+ I& K8 f) W0 w
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY'): q! g' f1 A+ K/ A5 v+ z
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')& q: z) \6 S6 N* z/ H# b) f! w+ F$ b
print(li)7 r! c. Z' b" D( m% k
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']1 X. M$ O% v+ l" E1 E6 a
li.pop(1)8 i* E8 Z; ]( r6 F9 o: ~1 q* F1 x
print(li) ['alex', 'rain']. Y4 M; v; x! K- w# U, N
指名道姓的删除li = ['alex', 'eric', 'rain']
1 k4 x: S* C: @) s) \6 i' fli.remove('alex')
9 D: _) A/ e. j$ ]' T9 z( _3 sprint(li)
8 r) A. t1 l3 |9 Of. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']7 b& z2 g$ J/ h6 d# y3 R% |, i) Z
print(li.pop(1))# p, ]! M6 `# F* `* N
print(li)1 C# E( u' x  a$ H1 E3 J  ^4 Y* {

/ B5 u  \& q8 V, H, F% Z* r- xeric5 \) e( C) K# t& J" Z4 {
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']5 \, L, I" A$ N4 a9 t4 S8 H
del li[1:]
. z3 X8 O9 m# Y6 sprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
* t7 x+ X' ]1 I( P7 p: oli = ['alex', 'eric', 'rain']: r$ `" l# e3 U
for k,v in enumerate(li,1):# R# a$ |) H0 h3 T* T3 y. ^
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
+ o+ J; m& q- a- P! [a. 请输出 “Kelly”
4 j( P* _9 O- d; |; rli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]8 ~9 N6 O' S3 a6 m7 c
print(li[2][1][1])5 ~& v; A7 ?8 d& Q
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”2 t- n7 L$ K3 ~+ t9 G
li[2][2]='ALL'
" z$ }* Q9 m+ U8 R9 Yprint(li)3 K: P. U5 v( }1 U
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
* z3 K6 q1 k. P1 |9 z9 q% N2 }8 Ua. 计算元组长度并输出tu = ('alex', 'eric', 'rain')) n% H6 F7 K/ f: O/ c0 s( x5 D
print(len(tu))
* u0 y7 I0 A; }( o0 Vb. 获取元组的第 2 个元素，并输出( _& I3 y7 ?* Z9 h+ a
print(tu[1])
5 S; d4 ~; z, v! B$ v1 }e. 请使用 for、len、range 输出元组的索引  Y/ ^3 @" N3 Y, r" s
for i in range(len(tu)) :
! [0 P4 {% v1 a8 _ print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)& `: D  x% D5 N3 b
for k,v in enumerate(tu,10) :- b7 [3 P8 _+ W+ T
print(k,v)
$ O1 m- e6 S1 B$ D0 N5 o10 alex& ~* v2 _! w/ `( u& m7 L/ ^
11 eric) r/ I0 m  w" r* t
12 rain1 D& J) T$ A* T. U  y7 |- @6 J, G" c8 d
; o1 k  {7 ^$ c/ l0 W
for k in enumerate(tu,10) :
0 B" F7 l, G% a" Q; B& l. m2 L print(k)% g9 p  k! W, b3 r
(10, 'alex')
4 M7 h+ l3 f0 H(11, 'eric')
* I$ `! D6 `- o, _0 }3 b(12, 'rain')
7 _! X0 N" o9 I8 g  g- s: R- u3 n" ^5 |& h

) c. O8 Y& G% r  a+ }3 @25、有如下变量，请实现要求的功能, H* C$ O5 A" N, u3 `& A# B" p& `
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
$ Q3 ?9 T; W# ^2 x. c% |3 e
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
; N' p9 `$ Y0 C% H. H$ C+ Ctu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])9 Z* @9 P* C+ B; J
res=tu[1][2]['k2'].append('seven')8 d3 @+ G4 h+ N' I- M$ Y
) c( W& v2 [% Q. \" g8 ]
print(tu)) V6 \) ^/ c0 C2 d# q
26、字典
8 I# h- V2 c5 n& x2 `dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:" B; s5 V/ O# H/ t
print(i)b. 请循环输出所有的 value& Z0 D" b0 |; D/ @
for i in dic:
7 o- Q+ U% I; Z$ n7 s4 Q print(dic)
/ G/ p; Z0 I) q6 ^9 b4 G- Gc. 请循环输出所有的 key 和 valuefor i in dic:
. a: b8 V3 `! nprint(i,dic)
- s3 n/ ?  |/ q, M* h! Q+ Ad. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典: E; p( `- U- i. J& [: r' s( U, s
dic['k4']='v4'
* o1 F" u' M9 X. ~print(dic); ^! O9 |# u% {$ Y7 o& I( ]
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典5 e. Q4 Z& X! o7 Q
dic['k1']='alex'
$ m' x% D' G! D& ?# U$ S+ tprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
  j9 E' U; ~0 ]% W" q' Xdic['k3'].append(44)
9 [) P* c5 H) O+ b$ _print(dic)
, [( c$ h7 F8 ?1 G# ^3 k7 G5 H6 k- v
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
( U, e4 n# e! w7 [6 O! _+ ]8 O2 _  Ldic['k3'].insert(0,44)
" s$ _6 j' N# o" g4 y. s- Dprint(dic)/ J: j' O* l. w9 \  \0 ]7 C) @
27、转换
! T  m# e, {# Z+ g! q/ @a. 将字符串 s = "alex" 转换成列表  s = "alex"# S% n# W2 D! C$ ]1 b( g3 R# s( x
" W  `) d6 n; c- B6 b
print(list(s))b. 将字符串 s = "alex" 转换成元祖# M, F- {( z% ]' k3 |
s = "alex"
& p/ W  O: J8 Q% T. `$ a) \; ^0 C' Jprint(tuple(s))
5 b( K& ~2 I, i" ^, j$ ~. f8 f) W9 m( N' |# ?' y' r
b. 将列表 li = ["alex", "seven"] 转换成元组
9 ~" Q6 J3 Y$ K$ vli = ["alex", "seven"]
# ?0 _3 ^  T9 c) Z" t8 |/ Y+ Z( nprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
; [$ g$ I" _; jtu = ('Alex', "seven")& E0 _' g: c/ A2 [8 G2 `* q* @
li=list(tu)8 k  r% J1 n: O5 r! k% I
print(li)
( l6 L! |5 y2 M$ F7 j& e8 E) S( }4 @7 H
7 G! {! |! S4 u, `$ r8 P4 O' c8 {
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
6 T5 g  G+ q  Z" Z; s3 J% \6 E8 ?, F, Y- \: U6 }9 r- W
dic={}
6 Q/ h' L5 u7 n! U( [. B" [- mfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面! [2 ?* M+ \- Q/ D2 J* d4 B
dic[k]=v
9 A  f* C% m( \4 O% M- x# H1 j print(dic)27、转码n = "老男孩"9 x8 H$ A* D' R6 E/ e' M( B
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
* a) p; j; k' l% O+ _0 Wa=n.encode('utf-8') 3 R3 F3 t5 ?$ A' ?. n
print(a)
+ A4 ?# R" j% s6 b! O4 Sb=a.decode('utf-8')8 y6 g  v2 H" k3 _: f) `+ q
print(b)
- p. n) v6 O1 y& w* v# x2 e7 ^4 Qb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')# j1 X% r! v# z0 V# P
print(a)$ R# @* S7 z; |
b=a.decode('gbk'). R6 P2 E% G9 W, [
print(b)28、求 1-100 内的所有数的和( ]+ R, O& N% N2 o
count=1
: o, l6 k4 C" U5 y" F  _* ssum=0# [4 ~4 k& X+ S3 d
for i in range(100) :
8 K3 ]2 s1 y1 E+ r3 b+ N5 c sum=sum+count. Z. Q  D# Y: j# [: u8 ^8 q4 V
count+=1
0 w9 k: o' p# M" q8 |6 K3 nprint(sum)3 F. R4 l8 D, y+ s7 {
% c, x! ^, ?' R% _8 F  j+ c
count=1
9 i7 x5 q7 O& M2 K7 }sum=0) W6 H2 g8 u9 z, F) g' W! g9 U! x
while count<=100 :0 g+ G* |5 c: G* h
sum+=count
/ b( v/ h% y+ d. n& f+ j3 W count+=16 N& b& e% ~3 F1 w; K' F, K' f
print(sum)29、元素分类
8 w; J0 ~: f& Q2 u3 P有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
. ]" F' k# P, Q; `: ]将小于 66 的值保存至第二个 key 的值中。
4 ?; U6 [6 L! W% d; K即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
# V9 `3 d4 T6 s, w: {+ u6 Sli=[11,22,33,44,55,66,77,88,99,90]% Q, }" c% _. {6 r' ?. O( c
dic1={& Y- f+ w8 I5 d' e" \
'max':[],
5 F! F2 u2 U9 g" c2 S, j 'min':[]
  v( r- y; V# x0 o- ~}* `% Q# e8 w; v
for i in li :
, b* d+ p: v: u3 l$ I" c- x if i <66 :1 ?+ c, U! l4 |  o
      dic1['min'].append(i)3 Y9 S5 B( U/ `9 n3 j+ o4 c
else:, F# Q) ]( m/ f
      dic1['max'].append(i)7 x+ }6 Z8 ^* J$ l2 D
print(dic1)
/ `1 ?: S& \) V, ~/ V. \+ R+ ^& @2 P* H$ M4 ^. d
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}# C7 A- Z5 B7 L2 c0 x0 S! N+ ]

Python基础知识汇总

主题推荐