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、写代码
. k7 j' ^6 F0 ya.实现用户输入用户名和密码，当用户名为 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) :
+ c- m( ^' @+ x name = input('name:').strip(); H1 i( X" {" D$ Q
pwd = input('pwd：').strip(); L& S+ d' z) Y7 J, _6 y

$ d/ H+ H# y! Y+ D if name=='seven' and pwd=='123' :
+ V' q/ r5 L! u! z       print('ok')
9 Y1 w; E) j4 P! V; G else:
, ]6 |7 A$ r2 N) J! h& ]       print('error')
" O4 L) G, `$ t' r3 }) ^; [8 q       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)  :# q  P( q' [( l$ u9 g
name = input('name: ')# L( g1 q3 L4 g( [& d
pwd = input('pwd: ')
8 b& x5 Y. f) n4 h# F; a if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
3 I4 O7 o; }3 i6 ^& C' n  q       print('ok')7 _4 M! S" J, K* `$ i7 A* X! e" o
else :" ]( a2 @5 F# s, o/ W, t3 I1 }
      print('error')
  d) Q9 _+ p' Z9 F3 R       count+=111、写代码
4 q* q' w- z6 t0 a& f( k5 Pa. 使用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) :
6 z- \3 w& p% G) l) h1 h if i %2 != 0 :6 o2 y( q, W$ i  B* c, F" W0 ~( k
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
, d+ K/ I4 \+ F! i4 {' I; C if i %2 == 0:9 K# T7 r7 a& q0 u$ g4 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"& T5 v& ^9 h: j3 P; r2 O
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): i' _, z. s. a( g
for i in name:9 J  z9 [5 w& ?" z3 B4 x0 F; Y  i
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain4 J, B, y& y8 x% H; Z/ Q
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']6 h- p! c) H1 C% |% A1 t0 z. A3 u
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
  u* I/ Q: m5 D7 {9 A# e: yprint(li)3 J# t0 y% w! ^0 p+ |
['alex', 'eric', 'rain', 'seven']
. {2 }/ k9 [9 Bc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')1 ^/ u2 E7 \0 t4 x; {
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')! i5 }" p2 z: m6 b9 L2 g
print(li)% y6 a% v) V! s9 U- ~: X" F
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain'], ~0 M; z" _; ], o( H7 Z
li.pop(1)6 p9 p9 r, U  ~% e3 [- g
print(li) ['alex', 'rain']
* d! S3 A7 K3 D指名道姓的删除li = ['alex', 'eric', 'rain']
% d. p3 M* {5 S& ?$ Gli.remove('alex')& u( F( h1 [: _% A
print(li)
3 i' O& r) |) ~f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
' t8 b) u) N8 p) mprint(li.pop(1))
: D/ `: U% U' Uprint(li)/ I. {, _3 g) x0 N& S- p
/ _0 a7 l  }( T4 W: \' }; E/ m
eric
4 g) x. I2 C! O: g  _, I* b4 u['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']% X  t% c) k# z" q9 n% w& Q
del li[1:]
3 ^0 \) {) }: P% D& n2 R& Bprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)4 z5 w5 s, q- ~8 E& Z! M
li = ['alex', 'eric', 'rain']
) x/ Y0 b+ ~% p6 O& c/ sfor k,v in enumerate(li,1):
. m9 I) Q* Q% E. n" G print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]% l0 v! C) o: f1 N* C, O
a. 请输出 “Kelly”( b. `4 i/ L3 u
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
: Q( u% n# {9 j: E/ Oprint(li[2][1][1])5 `0 f; A# f( j& b4 B/ N; Y3 U. A+ @
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”, G, j, ~6 N+ \  E" p
li[2][2]='ALL'
, M3 Y( f9 \+ D- ]7 D8 Fprint(li)
& ?9 B% I4 H4 r# p. h24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
+ }4 R- j4 Y3 W' N7 |9 `+ l# L9 R9 za. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
' y6 l0 q5 N& Q: f6 w5 |$ P8 c, Dprint(len(tu))
6 K4 Q; _8 r  \: K. X2 c+ o5 Hb. 获取元组的第 2 个元素，并输出, U8 u3 w. X1 H. F) ~
print(tu[1])# F5 I2 R: b5 N7 _% K7 |3 Q
e. 请使用 for、len、range 输出元组的索引( x$ s' W, M5 H2 O6 S2 s
for i in range(len(tu)) :, A3 V  {/ u  y% Q$ F7 n
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
8 y" q5 u+ F' \0 ~( }. D- yfor k,v in enumerate(tu,10) :% C1 m9 v# N# j7 x5 S
print(k,v)) H7 y) h* k; A6 U3 ^$ W8 S* n
10 alex
$ N: B* ]! g. U! ^* n  o11 eric
6 i3 }# v" T0 m1 W12 rain' N, x5 t5 H8 ~3 [- C8 J5 c
( b! e9 _$ n7 G5 L; B/ F& `( y
for k in enumerate(tu,10) :
' ^  k9 _" M- p print(k)# a2 @) ^/ L% F. \& p
(10, 'alex')& x* ~- p. z0 K8 Z3 l8 A: l
(11, 'eric')" V2 P' a1 c$ @6 h4 w4 {4 y
(12, 'rain')4 w: g3 }4 G. w3 u* M& R& M7 h
: {! N, \) I! L* t

7 `4 V, v9 h9 d: T% i1 f8 \25、有如下变量，请实现要求的功能2 A$ y  `/ C1 C7 y- D8 O
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
4 d' Q- V5 A3 a  r8 |
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
& g# j( `+ ^7 r% S5 m# b8 Ltu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])) D5 s* v5 j( Y) S& p& i, t# G+ {
res=tu[1][2]['k2'].append('seven')
4 H7 p' f$ c. Y# A! U
9 h4 p7 q- {8 p6 U' c0 g  {# Gprint(tu)# ]+ P) o) V3 R  H
26、字典- s$ q/ E( {- h( _  S3 v: H9 i# B
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:: r& G1 I/ `$ J
print(i)b. 请循环输出所有的 value; c2 J8 R% K" N  L7 H
for i in dic:
; b! v1 ^+ I$ I1 O" ^3 f! a4 a4 i print(dic), K8 V" y7 N# {3 I$ _
c. 请循环输出所有的 key 和 valuefor i in dic:# [! K, W5 L* S4 b: f+ E$ a( w  ^
print(i,dic)9 T: M: t* D2 G% b0 \
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典% _& Q1 L* T! z3 `. U
dic['k4']='v4'
1 c8 E" Q: Y" [7 e0 fprint(dic), F  V' c9 N+ S0 w6 s9 Y
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
( R& R+ Q* T0 E- ]+ p4 vdic['k1']='alex'# R2 l. }+ C; H- m1 T+ Z
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
( K* Y0 X+ Z. hdic['k3'].append(44)8 ^% a2 h4 z1 |0 @
print(dic)
1 z- p2 z& A/ }: n8 F5 h! D1 R! {1 K& o2 z9 b
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
$ N5 k# t  p7 c) u' N$ zdic['k3'].insert(0,44)
8 W$ l* n, A$ J2 @! ^" `print(dic)
0 N% O. U) q3 S4 V( H% _4 E27、转换" C7 W& i% `6 w$ e: y
a. 将字符串 s = "alex" 转换成列表  s = "alex"
0 Y* ?# L4 A9 y  I0 Q6 `5 b& S; q& @5 h$ a: e- N- q
print(list(s))b. 将字符串 s = "alex" 转换成元祖0 ~5 i  m9 ?' P
s = "alex"
3 C# @/ B8 m5 H# |" b) Pprint(tuple(s))* ?) h8 e/ l( ~: l* N3 j4 W
- a" Z: o- O* e. p2 [& z/ A
b. 将列表 li = ["alex", "seven"] 转换成元组
: w) x0 |) m( V1 m5 bli = ["alex", "seven"]* T5 `4 g0 P2 D' d  j; A+ Q" f
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表6 f& S. d. |* W6 |6 ~
tu = ('Alex', "seven"). S1 A3 x5 K. R1 V# y2 D# ~# _, k
li=list(tu)
1 n5 @% Z) @/ f) \5 M8 p& t8 uprint(li)
* ]6 W9 j! Q, k& ?+ g( F/ w6 E+ |4 O, ]1 W& G4 ^7 @
/ |5 s% k5 G2 J5 u; s& o. @' N3 g7 a
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
+ L  z# J! }1 o* ]& @6 |+ n8 y+ N# C# z9 g1 x7 g
dic={}
# }5 j( W, b$ _& \5 {" y! Dfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
/ _# ]; {# _7 ~  c. y0 ?  P& a; G dic[k]=v
& Z) @$ V4 d9 q1 C3 F$ i+ ]( ]: _ print(dic)27、转码n = "老男孩"9 B* S8 c4 Q  p1 t# K; M
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩", A/ R) |2 [  D2 q6 Z( {
a=n.encode('utf-8') 9 D2 V, y) O  d
print(a)
. X8 R0 A& L$ L0 s" nb=a.decode('utf-8')
" t; `9 a7 x, j7 i, \, z* dprint(b)
. w/ a! P/ j. M) hb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
- p: J) g6 b, Z# {print(a)# y, {& i: M( F7 B- s
b=a.decode('gbk')) M) |/ W: y1 k
print(b)28、求 1-100 内的所有数的和
: I( N2 H" N5 ecount=17 m% I% z( C+ _+ Y
sum=0
  i! Z5 g, x- R  l- P4 Qfor i in range(100) :9 I+ S$ @$ e# R' F+ R
sum=sum+count
! U, U1 Y5 ?- t" m& L( \1 X count+=1
3 u7 ~2 _+ V( z& |print(sum)
6 x9 h* p& E/ w! h
! A! y% I; y/ dcount=18 B: a- l* F6 H, [5 Q4 \
sum=0
2 \- n8 a; i. Iwhile count<=100 :
* q3 x& ~3 U* C, k  U/ a sum+=count' h7 p# A  Q- b0 I5 g
count+=1
/ z! [" J! @- W' u& u! r$ iprint(sum)29、元素分类
# G4 O8 x$ H/ P6 t8 \, p有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
将小于 66 的值保存至第二个 key 的值中。
; r! N- ^* Z: f2 k: S+ ]% ~即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}7 S0 _9 D1 c8 H# j* {
li=[11,22,33,44,55,66,77,88,99,90]1 S" V  X/ V/ f& S
dic1={
. Y. M7 @7 {- D# t( z! p 'max':[],/ {+ \3 @( f" }: K/ \
'min':[]3 ^  [0 z  M) H1 g5 `2 f
}
. O3 b) Z& W0 F$ k8 \for i in li :: T# f5 J2 ]* a
if i <66 :
9 T7 J) I2 M8 E4 S( \1 r0 e& H       dic1['min'].append(i)
+ b- p* _7 j1 z# L else:
! x% d" z& H  r- c/ U4 R4 N. ^7 P       dic1['max'].append(i)1 [  L  p8 G  [& P
print(dic1): E7 m0 q* m& m$ \) z
7 j3 i" R! P7 W2 ~
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
4 {$ x' k  O) c0 ]- u2 q; d

Python基础知识汇总

主题推荐