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、写代码
, L. n# [/ \, f0 [$ @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 `$ S/ k0 g" d; v+ y- F: \ name = input('name:').strip()( m- F) Q: f! I, j% p
pwd = input('pwd：').strip()
, e3 y' u9 R1 V+ h: B1 O+ Q
: |% J4 c7 q' P: d3 s if name=='seven' and pwd=='123' :8 W# U+ X# S; ^* b+ Z- t2 m
      print('ok')
. ]9 J4 ^! _4 ~- m; u" @5 t8 t else:0 I/ r; G9 S2 ?5 r( S- l
      print('error')) q. k, Z, f# Z$ Q+ U9 ?. z
      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)  :
. `  p" c6 x6 g/ O7 |1 _: M name = input('name: ')
: b6 V1 P' n, o) M( P# z pwd = input('pwd: ')
. [. P. N( V% c! f; B1 {/ n0 [ if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':3 _" V) F8 B, Q  d0 V  r) r4 s
      print('ok')
2 p: U2 q* X2 ? else :
; h6 D# n) ]# E% X       print('error')
, S) x" M& R% V       count+=111、写代码- e9 E$ [7 N9 ?& @
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) :
$ D7 @5 ^* S$ I4 C& D if i %2 != 0 :6 q" Y: e) r6 q
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :* G3 y( z7 ]+ _- |" Z- F
if i %2 == 0:
0 V8 l0 M2 f5 f, e& G2 T       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"
( n- Y, R. l4 S; U8 Aa. 移除 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)
5 a0 _, L; k+ I  S6 |$ b) lfor i in name:( a6 o% Y* F- ?0 f
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
5 p0 n( j, t0 E3 Q5 G% ]22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']$ ?# }* C% l+ L$ E
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
, m( O$ f% }% Y) G2 fprint(li)
" m* w* f, f  a9 T: g1 I ['alex', 'eric', 'rain', 'seven']
; \$ T7 v9 o5 E" P4 g+ Cc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
+ m5 `+ z% O- q8 B/ p$ Qprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')) W: x2 B: `. O; w
print(li)
9 `: p/ r1 K9 H, D# Q; a3 Oe. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
" p1 r$ F0 b7 p' a! e) V) Zli.pop(1); r8 [. B" {- A5 n- ^5 j5 p
print(li) ['alex', 'rain']/ X% k' {# S  O- P' P9 {
指名道姓的删除li = ['alex', 'eric', 'rain']- [& N( X' ]6 C6 ?* U
li.remove('alex')" M, ]1 R' b4 G7 s9 C0 q. B
print(li)2 U/ _2 m  [4 j; \: L
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
' b  T" B2 D2 \* Y, }( D5 m5 q. hprint(li.pop(1))5 [1 U) M( r0 t8 P6 `3 _
print(li), d" m- F' D& M4 s( F! X
2 l8 s; T" `- F: a: p# k; p
eric& t- v+ }$ N: x2 H
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
5 {1 ?: A, H# y8 M1 C. |: Bdel li[1:]
/ c+ M8 `  D$ ]" F  u, eprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
, }1 i8 [; I( Q# E/ p/ n( B' |li = ['alex', 'eric', 'rain']
. D$ W: l5 `5 V$ q1 {for k,v in enumerate(li,1):* d; G5 l; G1 y7 S* z5 `8 V/ R- B" D
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]* R, u+ Y. W! d. p( _
a. 请输出 “Kelly”
2 ~! |) S# ]1 g0 rli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
- U8 ]- K: o! }+ Y8 Bprint(li[2][1][1])
* D- v  U$ K9 R6 _& e7 mb. 请使用索引找到 'all' 元素并将其修改为 “ALL”+ e, j& W- |2 U
li[2][2]='ALL'
% M9 F( [" X" f: j  W& A5 fprint(li)
% R# G. m7 _4 _5 f6 I24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')( t+ E( ^" X# b- i: z. x6 M
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')" E  @" a6 f+ w* [; l5 v7 V
print(len(tu))
6 @3 Y# x; m# @" L) [1 sb. 获取元组的第 2 个元素，并输出
$ ?4 i9 M2 }) b- d: n" |- yprint(tu[1])
* e4 m/ F, V7 ^5 t0 [e. 请使用 for、len、range 输出元组的索引
2 {' M3 K. |" L" E: ^8 L2 Afor i in range(len(tu)) :
, r# {; P  `( m1 q" u print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
: A4 K# ?& I9 c( {& t0 Z! D; {2 Vfor k,v in enumerate(tu,10) :
5 u" L# s: R7 E, Y$ u( Z print(k,v)8 ~. L, ^) s4 T8 F
10 alex. y/ a0 H/ M, r: v) z) W5 K
11 eric! o; d+ i4 {/ y# ?; a
12 rain2 T( `1 b! x! i3 x! e
1 J) e* b: d# R, R# N: ]7 Z# q' y2 m3 P
for k in enumerate(tu,10) :  k+ _+ D3 f3 y7 V
print(k)$ {) ]) a: q2 C0 L
(10, 'alex')
, J* {$ Y8 p/ Q: t/ z5 D(11, 'eric'). W3 B8 p9 [$ I0 z2 R7 ]
(12, 'rain')
0 C* [8 ^" T: \5 B1 _9 w; \/ `! l! F% S" j
! s% O1 Q2 W+ \
25、有如下变量，请实现要求的功能
+ I# L0 s9 K4 [' d% m8 p6 Atu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

- V6 N# J7 [, m* ~6 $ N' qd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以. N( [% f* M. t1 g" a# w* j4 X( \0 K
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
  C! F8 v5 f: G/ S# d- k2 y( e% _res=tu[1][2]['k2'].append('seven')
! W! D. ~% C3 P5 C' ^9 Y7 ]/ q7 q
7 {( i! |% N! Y) I/ `5 Pprint(tu)
$ `% a. _. E; A% P" B26、字典
; |; f. G) v" i5 b7 ], H8 H$ Kdic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
# c4 W. p' M+ x3 ? print(i)b. 请循环输出所有的 value
9 b( C4 m$ W( x/ Ifor i in dic:
# ^5 Q5 j. T8 o# N8 @ print(dic)+ R0 C: q$ U, L
c. 请循环输出所有的 key 和 valuefor i in dic:0 c, i) K* m2 _1 m
print(i,dic): F% ]3 _8 n3 y/ _
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典5 q5 x; A1 ]' I6 I- I
dic['k4']='v4': W9 $ b  x) o& F: [9 o
print(dic)+ l9 g: y4 Z! [7 f6 u. u0 g
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
" u3 v3 c8 S8 _4 Gdic['k1']='alex'8 v* L: M  g6 Z; ~; p2 h
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
0 ?1 C. {' O- u$ v/ Ydic['k3'].append(44)) o0 @2 x# h5 K2 l$ Q3 ^! t* {
print(dic)
& Q2 i1 v  j0 P! b7 K' J5 V9 D/ I3 B; X! r* t- r& D
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
4 P1 F  E7 I* a5 c+ l3 Z# z0 n% rdic['k3'].insert(0,44)
3 y' R4 j* a' k6 W; o/ hprint(dic)0 y, L/ y! b- B6 e3 _$ u0 f
27、转换: b% f: \) y) J( C3 e8 w$ p
a. 将字符串 s = "alex" 转换成列表  s = "alex"
0 y! D+ E, |" J' W. z0 Z2 l4 @* B2 I& J1 [
print(list(s))b. 将字符串 s = "alex" 转换成元祖+ P* ~# t& l; g/ W( Y5 g9 Y
s = "alex"
" k: z& \8 A* F  |# q) O0 a& Pprint(tuple(s))0 @& B; X9 z, d; m9 A7 G- M' z& H# \
" v" t$ R" I: m3 d$ Q
b. 将列表 li = ["alex", "seven"] 转换成元组: b& r1 S1 M! O0 y6 C# @5 z
li = ["alex", "seven"]. _6 }$ `3 {  ?' P' c  y& p6 o" U
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表) O; |* x- P$ s" `$ r3 c
tu = ('Alex', "seven")
* p7 Y' G$ k2 x- rli=list(tu)
. V" N; U3 T  Y4 C2 m) Hprint(li)
- K/ ]' W9 J$ K# J: v
, Z0 K$ A, Y& t, i$ s/ V; _
" x/ [1 K* b, c4 f7 Ld. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
& {0 q1 C' b: ?
4 t4 G, s0 m. z' k/ Pdic={}
0 o# M. `. d8 A1 ?for k,v in enumerate(li,10) :----li要放在前面，序号放在后面. X6 \& N! k  z" X6 a& E' O
dic[k]=v
$ x1 Y  S/ F! ]3 S0 s print(dic)27、转码n = "老男孩"
0 {& N! p, ^( z' L$ ?9 W8 Fa. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
% h- P2 g: F" Ca=n.encode('utf-8') ! \0 }+ Q5 N4 D$ L( m; v) v0 i# p0 r
print(a), s' e, e( n3 A* n4 J% h. {$ W: }9 c7 l$ v
b=a.decode('utf-8')
; ]& {" J$ ?1 |3 A# jprint(b)
  Q7 S6 z' S! s! U! Sb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
2 @9 E+ g8 T% L! T1 i3 yprint(a)) {( p4 m2 G. Z3 T1 F2 w! e
b=a.decode('gbk')& k# R+ V+ v; C
print(b)28、求 1-100 内的所有数的和
1 x& A, U8 a7 x1 wcount=1
0 J3 S- ^) \. q3 wsum=0
- l+ `: e, ^  `5 A$ mfor i in range(100) :$ Z7 y  P! c; ?& ^2 E; G
sum=sum+count
4 e* U8 \! X/ R count+=1
* o% Y) m1 C9 S. rprint(sum): q& K( i% i' M9 c! M
* v( x. S$ x# d7 Y
count=1# o- c0 P7 M0 Y/ o% L9 ~
sum=0
: g3 W! O- v' M$ ]2 g7 ?' o, K% Rwhile count<=100 :
5 N6 u$ o) w9 y+ K" N6 } sum+=count
3 J. N% p8 u* B8 K" i/ S7 { count+=1
/ |; b' K6 u' @5 E5 _print(sum)29、元素分类) d) Q+ {6 A) O3 M" S2 q
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，, k. t" D4 e0 B8 A$ r/ |
将小于 66 的值保存至第二个 key 的值中。6 b- ^3 k7 e5 a
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
" E$ I) Y: s6 U( Xli=[11,22,33,44,55,66,77,88,99,90]
& u* h* Q7 K5 v: O* D2 t; G$ X3 [( Pdic1={
: v  M. F2 t/ U4 s0 c4 @ 'max':[],
( |3 S2 G8 z7 s& k 'min':[]
! f- B3 N$ V2 b& y# r}
. b5 B$ w, L* f5 Vfor i in li :& t$ `3 }; ^6 A
if i <66 :8 h+ i; Y3 Y/ Y3 i/ q) L( \
      dic1['min'].append(i)
8 p8 }6 S/ Z/ Y" U2 v else:
5 z1 S9 l( v3 }" z8 N       dic1['max'].append(i)5 O. a+ o* y# X' c
print(dic1)
6 k$ i4 u/ T1 D; s2 m9 d1 h7 x
! {% G0 w# p1 |+ f' _4 ?---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}1 J7 c# l: q% l' M+ ?+ P

Python基础知识汇总

主题推荐