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、写代码
7 _) M! U( _! k$ u1 u$ ~! z" {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) :% U0 h6 F  |5 U, n
name = input('name:').strip()
" U1 d2 o4 G8 a; H5 T/ _2 N pwd = input('pwd：').strip()' y3 q/ W6 q* R8 d) ?

+ m) U: }7 P' t: e8 S# v5 i if name=='seven' and pwd=='123' :
; l1 ~* S- X" M3 p; u       print('ok')
; g# L' E# [+ k' C* [! M else:
& h& b: U/ h) p  K4 B       print('error')$ s( Q8 p9 c) 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)  :6 P3 L' F8 L6 ?. V' z. ]  _3 N8 S0 X1 \
name = input('name: ')5 L# \' \  [7 }! R% k' \
pwd = input('pwd: ')
' O. Q7 y7 C. {% v3 R if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':: B. P! `; W" u5 A6 y8 X
      print('ok')) I3 S$ f) N) |7 p8 e6 i
else :
- h- a& i, x, b) G. q4 ]/ Z! l. N       print('error')
3 {$ ]5 e% n$ u) {5 E       count+=111、写代码! T: u! w2 b' a3 L  |+ w! q
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) :; a0 r0 G1 o0 Q2 t9 i/ m1 U
if i %2 != 0 :: [3 }0 v1 L, l! C, I  k5 x
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :/ R+ D5 Z/ m9 ?% g( W4 X
if i %2 == 0:+ j( _) {! w& {* e" C' Y; P# ]
      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": F$ \0 Z8 j" \9 ~0 v" a
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)7 ~2 ?- Q. W# K- M) h! ^0 J
for i in name:
, \! R: w$ W; s6 v( O& I print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain7 n7 M4 _7 `2 Y% w/ K
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
( C* @1 R7 h4 y" o+ Mprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    3 y7 t/ t% J+ Y' S+ Y
print(li)
! I; B0 X, ?2 Q6 L& v ['alex', 'eric', 'rain', 'seven']4 Y, I- B4 O4 N! N2 T
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
# i# R- W/ E& A) ]  o% hprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
7 ?0 E: I* R' q& Jprint(li)8 ?5 F+ ?7 F  T% b4 B
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']7 M- J4 X9 u2 V
li.pop(1)6 x7 f) B# ^" u3 ]. L
print(li) ['alex', 'rain']
7 L7 D) f1 c: {$ t指名道姓的删除li = ['alex', 'eric', 'rain']- z* B- y  U$ H0 }$ v9 Y' k
li.remove('alex')1 F: q" d' ?: C$ W  g
print(li)
& G( e7 L5 |/ l5 P7 f. of. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
8 m, Q6 d( E2 s" Hprint(li.pop(1))
, A* O+ y- N, _' ~2 E3 Aprint(li)
% \4 N* z0 O) O
& @# H4 {9 R& F% p$ L# Q7 }eric
: z0 }* t# Z" S! r# L['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']% t* ^, ^' l3 p- h1 C1 W+ R
del li[1:]
, ^3 G: X7 d# k6 }6 tprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
: o$ Y. S* V/ I3 ]; Pli = ['alex', 'eric', 'rain']
6 X; M: |; }) N* w& mfor k,v in enumerate(li,1):
) x% H' Z7 t: M' n; T print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446], h) \4 G5 {! r! H$ `4 B
a. 请输出 “Kelly”
3 x5 S* Q  O- M( {4 n# vli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
# W. F; [/ {! b# Eprint(li[2][1][1])
) U; c' D' v8 S4 e6 ]b. 请使用索引找到 'all' 元素并将其修改为 “ALL”( y. D' u# T# u$ `$ A2 Y  Q" N; c* I$ \
li[2][2]='ALL'
5 o' K/ w& M* O# F. g& qprint(li)# T6 l2 i& }; B, _2 H
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')5 e  y9 p( F  N* a% b
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')2 }+ C$ @- y# L
print(len(tu))
2 x1 v. g, |" L6 A! j- e' ^/ e7 {b. 获取元组的第 2 个元素，并输出; B3 M* Z! p: y  Q* j6 k4 x
print(tu[1])9 E# T2 c0 o) ^. i1 F; o8 D: a
e. 请使用 for、len、range 输出元组的索引4 e% u# l3 o+ \1 y
for i in range(len(tu)) :6 ?- G7 v% J7 ^( r
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)# l6 K; D% X1 k7 {# z7 o
for k,v in enumerate(tu,10) :1 [' u. }1 V6 s
print(k,v)
# W' O1 A5 @- d2 W10 alex
/ c- l! a& I* o% y' y4 c( u! p11 eric
: z# R, Z* I& t; f' y- b: q12 rain! y# x: ?& R0 ^8 [' O2 S

0 w) m% h7 b+ B0 B" Wfor k in enumerate(tu,10) :
5 Y' R& O5 v( C9 Y print(k)4 D3 d- N: R0 B) ~4 S
(10, 'alex')
- B3 h' h/ j  y+ d(11, 'eric')
3 W$ W' w* P, ~0 Q, n(12, 'rain'): g! I2 k: U1 |  e
3 s- m) ^: B- U
$ w1 }' t/ a& j9 M( {* }
25、有如下变量，请实现要求的功能' b. @8 }) v! @. z
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
" r! n( F$ C2 m- W+ x! \8 ~
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以- w- H9 d$ f$ r8 p  O2 E" c0 U
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
! T) k( ?8 k8 ^) Vres=tu[1][2]['k2'].append('seven')
0 G/ q- ^: y* A# Q5 d! |" r6 K$ d  q8 }( l$ N- v6 Z
print(tu)
* \1 e3 a7 A9 ?9 u3 t! t) Y8 k26、字典
3 H0 h2 R* \$ m  u) ]1 D( P& Jdic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
- k) d, J/ S# b" ?% N9 Q( e+ B print(i)b. 请循环输出所有的 value
: K! X# }- S& f, x0 xfor i in dic:
( O5 o0 U! A! \ print(dic), _+ H4 }3 L3 d0 b
c. 请循环输出所有的 key 和 valuefor i in dic:* E5 T1 H; `) x8 K. g
print(i,dic)4 l% Z: u( p0 W% S
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
; _) b  B, o3 r2 Fdic['k4']='v4'! Q/ d; s6 e2 V& n# a9 [2 C6 ]
print(dic)* H4 |. L+ ^3 N* H
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
# s5 O& T- ~+ }' _7 h) pdic['k1']='alex'; r3 L3 {( N+ H9 m
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典. D0 @+ k1 v" ^. f9 M
dic['k3'].append(44)  P5 S+ F. W  Y' j
print(dic)
  {' t- |9 |- A, i) x" B, _, w& ~4 S$ t; d; _) Z) ^2 _9 T
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典# U& C- @  a1 `/ k4 y( X5 O
dic['k3'].insert(0,44)
. {8 g; e# ?+ }6 vprint(dic)7 H" c6 Y8 U+ k( S
27、转换0 k2 J4 y6 P6 d+ s! E
a. 将字符串 s = "alex" 转换成列表  s = "alex"
, @4 q, B) Q. ?) k$ S1 x( R' Y7 x/ s& `( r! @' K0 F
print(list(s))b. 将字符串 s = "alex" 转换成元祖
  h' `- C% X% _9 t8 j: ?' _s = "alex"4 B9 H0 |. h; \9 Y  D9 y& k9 y- w
print(tuple(s))+ u% J8 k: ^7 p6 f  a, h3 T9 F

. t3 G) I% }4 d, W9 A, Ab. 将列表 li = ["alex", "seven"] 转换成元组: ~( r. ]7 f! r3 M# j
li = ["alex", "seven"]
- y* U+ X' }% |print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表2 T8 V0 x) V& @- m: z+ l
tu = ('Alex', "seven")
/ ^! ~9 f7 m0 Y2 Xli=list(tu)
: K0 |, j: x2 nprint(li)
; e$ I5 C5 E( ]+ E
7 L/ z+ D3 @5 r" e
5 |2 n4 G  A5 U1 Z8 x1 Yd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
/ a3 B3 i/ A3 V- {0 |$ @
  A7 e, {1 c7 M$ m0 F" V9 Odic={}. M; E, x7 l- U$ _; C
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面! [, n2 h6 K5 H1 W; k1 P- A2 X
dic[k]=v: ^5 k4 Z" B+ F) c# c
print(dic)27、转码n = "老男孩"
4 N/ U# I. D- r6 w0 v# l# Ha. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
( h* F) r6 k# K# o+ @a=n.encode('utf-8')
. H4 z4 A2 u  m1 bprint(a)+ }3 {9 B# u' J  G2 q9 {% K) w2 `% I
b=a.decode('utf-8')
0 p8 g! _/ j2 Z! v' a$ Dprint(b)7 ]% a6 n. B8 i' Q% ~$ @0 a5 f+ d) Q
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')9 F; k& ~& g  @2 G& A
print(a)
4 e  _6 ~! B, gb=a.decode('gbk')
2 `; q5 T) l+ g0 |/ }) s8 ~* }print(b)28、求 1-100 内的所有数的和4 Y. n9 {: k% N" e8 Z: h
count=1
- g1 y. V2 m' Isum=0, A8 x* \/ @" {, E- L5 C- g
for i in range(100) :5 g6 J+ c  l/ B5 _! q2 D
sum=sum+count0 ^  q8 }& c* [4 t
count+=1
/ S1 s+ g8 o/ f9 Zprint(sum), e. t+ `( `) P" X# H
1 W" E& v* Y; |/ `5 P
count=1
0 D1 p, J: N" k* jsum=05 k, n3 r  u- y; ]9 t1 r
while count<=100 :
$ S! @1 z( q) M) G' W6 g sum+=count
. b$ K5 M" u8 _+ ? count+=19 X- {; r3 x. m0 T
print(sum)29、元素分类
- f, \+ m2 v2 i$ }有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，4 X6 V. j; c  v& D/ m
将小于 66 的值保存至第二个 key 的值中。
$ N2 @# S- O! Y8 |即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}# ?4 y! T' R9 \# Z/ `  V% O
li=[11,22,33,44,55,66,77,88,99,90]
; K3 r2 ?1 o( I2 I4 g- Udic1={9 m6 v9 L; d8 c4 l' ~" X
'max':[],, ~% @* E2 Y6 K. u% v5 L2 q- L" y( S
'min':[]
# s+ m+ T+ ]/ [9 x0 K) R}& a7 \. f* B$ _1 j7 P% H7 t: w
for i in li :
. ~" W( [# q: C* \ if i <66 :5 E  z; ]! P; B
      dic1['min'].append(i)% u. o6 c6 _8 ^8 g% r
else:
/ ]" f$ q  L3 L; p3 e  P       dic1['max'].append(i)
! g! S6 K# [8 n- S, G0 @- `print(dic1)9 W/ s$ e" k8 M- h/ Q  r8 ^2 j' P

4 G! t, ~8 f  r1 ?) V  ^( {1 c---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}1 j2 l2 t$ I4 p

Python基础知识汇总

主题推荐