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、写代码
! e) D, A3 c6 ~- D2 I7 na.实现用户输入用户名和密码，当用户名为 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) :7 Y7 q+ Y( v, N" _
name = input('name:').strip()) W7 ~* J, _5 s# Q& _+ H; g5 D
pwd = input('pwd：').strip()# d8 D$ |6 G( }' ?( u  O% `

: J$ y5 g3 w( P- l% C+ O, W, Y. ? if name=='seven' and pwd=='123' :
+ A- _6 j1 Z% v1 ^& W- @       print('ok')
( B: j8 `& M; r; ]: k2 k5 M else:2 w( F( V% z% E4 c7 ~1 q
      print('error')7 `7 {& y4 S* Q1 M  i0 {6 J
      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)  :
0 b! e6 |3 X: L8 F) K name = input('name: ')( B, Q9 R) x& Z$ A( Z/ v" b, ~
pwd = input('pwd: ')
- A3 ]$ W: g" H5 C; h& \ if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
0 \( r0 s% s9 Q- f4 J       print('ok')! G' u( t3 y2 C& _
else :" n" x' T6 W( |# _
      print('error')
2 x# g# Q- O$ C4 w* w2 s; X       count+=111、写代码4 _% S0 _- {; \0 ]
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) :
# F  o2 p- @" L; S3 x4 L! R if i %2 != 0 :! F0 D: C, s5 O/ Y8 N* z; 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) :8 O/ h, g2 t: b/ C
if i %2 == 0:' X4 m8 B/ I. ^5 p, D
      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"
4 P' C8 \3 a- N3 b/ Ua. 移除 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)
' [* c1 C/ N9 r2 |" D4 r' I& Y0 Gfor i in name:' d+ a, a* g4 ^2 Q! B: |; T  m
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain; F3 g: T+ E6 s- E5 Q2 Z
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
2 k6 }) ^: I& ^/ `* [! O8 M! I; Rprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
. U* D5 q, I4 X2 s- }+ Iprint(li)5 }5 X/ Y8 k: o! n$ }) }* S
['alex', 'eric', 'rain', 'seven']  q: w2 F( x/ ~  ?' g) O, k
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
- |" O  {8 M$ `. u' r* kprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy'). e- p: b; [4 C
print(li)
, }9 @, C6 d; {e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']4 S3 ~- b3 `& T7 ^
li.pop(1)
9 i5 _( C: v) F- w. G! ]print(li) ['alex', 'rain']
8 n7 E" Y0 S7 Z2 I6 D9 i$ H# ^  r指名道姓的删除li = ['alex', 'eric', 'rain']
# U3 x7 ]' k! @6 `- {) N7 x1 tli.remove('alex'). S/ l' C8 B" \8 b! p' E2 p6 V
print(li)* g( t6 H- H/ x  z. H
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']+ W9 ]9 F7 D4 P/ C
print(li.pop(1)); Y- f& V, t; b, B% q# P) e7 e; S! a
print(li)5 C9 t4 u# s' R" j9 l
9 _3 I7 F, U4 u# |
eric8 g. p  Q. l' B$ ^* l  L" @. ^  |
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
3 V& \6 I) ~6 ?/ xdel li[1:]
+ R4 C0 Y- P( I2 Sprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
+ i* u/ E$ o/ z" W7 h2 l: N8 ?li = ['alex', 'eric', 'rain']1 I) q: U, z5 V( w
for k,v in enumerate(li,1):
; _6 E- p. T) E* ]3 Z3 M print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
! x: s0 r0 z. n' u6 `a. 请输出 “Kelly”; }5 i, L4 r6 Q
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]7 J- t/ y5 \0 b' x: K
print(li[2][1][1])' L. z1 Z+ `! R0 p
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”" u  ?& z, T# ?& N
li[2][2]='ALL') J5 Y! E; Y$ C  A
print(li)
* k2 l2 G% V9 i  {( m24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
- `5 g9 E6 m+ U  ma. 计算元组长度并输出tu = ('alex', 'eric', 'rain')6 G% A5 I& [, ?* G$ w) ^
print(len(tu))
# ^+ a8 f, h" Z1 pb. 获取元组的第 2 个元素，并输出
# ]7 L" o$ Y5 ^  U7 I! p7 V4 o0 X% tprint(tu[1])
! Y, @2 u+ M7 He. 请使用 for、len、range 输出元组的索引
5 y9 R7 m9 m$ sfor i in range(len(tu)) :
& x' m" e& |( Y# O" w4 }" O print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)1 K! S1 ?3 V, z1 a+ I
for k,v in enumerate(tu,10) :( [, |" [" O8 u$ k5 Q7 y0 |
print(k,v)
3 \4 D" t$ ]' x' J, ^: s) q10 alex4 W3 ?: _: w. O8 |% ]. t$ K' d! h
11 eric
: N" y! ^$ R, A0 i8 {  y' y12 rain
, M- r$ T& D2 w7 |: M: W. \/ s* b/ M4 x6 M. b! v6 |
for k in enumerate(tu,10) :
* E+ Y! y9 ^5 K2 C% Y print(k)7 d( J: ^1 H6 M( ?9 R* p+ U' k7 z
(10, 'alex')
" n5 j4 |3 i4 D" F% M/ \0 m. ^8 ]: S(11, 'eric')5 F. [, A, r. H9 [/ f1 W* o; [7 L
(12, 'rain')
8 \0 K8 n0 R+ ^3 M* c0 o$ U4 c
) v& j. h5 A0 z0 p+ J
# Z9 ^! N7 r$ v. B25、有如下变量，请实现要求的功能) }/ `- q0 J9 S9 H6 Y8 W, r
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

9 a1 x" E8 U! s* ?& W3 @' Id. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
/ ]$ J; H: n5 O" b" K+ v% qtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
! V5 ?& r7 X- kres=tu[1][2]['k2'].append('seven'), T; K- r; P, S# O* o
7 n. V, f& h3 ~: ~! [; B/ f" {
print(tu)
% d4 P* E* p3 t! m7 W# a26、字典
! x2 ?) i9 [+ Y3 Fdic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:- J& R9 O" W- H
print(i)b. 请循环输出所有的 value
& b) ^4 c& V1 Z0 l' S7 Lfor i in dic:  Z( c6 {- o! ^; d
print(dic)! _! e4 G9 \  }; W
c. 请循环输出所有的 key 和 valuefor i in dic:
6 ?% x& u" I/ c4 T9 w0 Xprint(i,dic)
; A: _% Q$ H% ?1 u2 U& a) ud. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
4 m2 r6 y9 `0 k+ D+ \dic['k4']='v4'  a# B+ O. `( K) Q; J+ c4 ~
print(dic)
" c& H# D  |2 [: L7 a; a6 J  be. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
2 \* h8 u! a( G' t9 O2 q! O: kdic['k1']='alex'( p! r# ?6 M; X: L6 k
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典1 G0 Z1 R% @- F0 P, v  v
dic['k3'].append(44)
# p$ E# ?' [# ]- Bprint(dic)
) g; k& ^0 t! X9 y7 W3 ]" D
2 C" H: B( Q) @' \) Sg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典* E8 ^' _! W3 H
dic['k3'].insert(0,44)# `" q  @3 N) w
print(dic)
3 Z. e, t% L4 U* Z0 F( R27、转换
6 K: k# m, B' b% ~# X# ja. 将字符串 s = "alex" 转换成列表  s = "alex"
( Y4 u" d  B+ l( r: Y- _7 D4 f6 E' B& n$ j! _% ^: L
print(list(s))b. 将字符串 s = "alex" 转换成元祖4 B7 P+ G: L  [
s = "alex"
+ R! w( j, q! j# x- f' rprint(tuple(s))& K( [9 E) S6 K- Y5 H" R0 N

3 {3 u8 v. l. C; \! T. \& x1 ab. 将列表 li = ["alex", "seven"] 转换成元组
$ m2 p2 I# ^2 q% tli = ["alex", "seven"]
& s* c2 J' A7 T) x! K( j# dprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表  C) s# t9 `* N, T* j" }, U
tu = ('Alex', "seven")" @& V& n4 @0 A. H% m  P
li=list(tu)  V6 t: V( u% V0 r& Q# Y
print(li)) r* _* e/ d+ h

! H4 T$ \/ Y- V, F
' ]' @/ ?! v, f% \1 l) Gd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
( w. Q0 P: w( S! \. L# t, W  ~& a
dic={}4 x0 v; t' H5 Q* l- M& C
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
% n4 n# w! m* X, W7 @+ j) a dic[k]=v
7 D% A- w3 A7 ^1 \. h7 n print(dic)27、转码n = "老男孩"
- ?) X# z' U; M1 q8 ~6 fa. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"3 {# z4 O8 H1 O7 E$ Q% u, A
a=n.encode('utf-8')    `+ p/ B2 a8 P! h' ^+ {9 W
print(a)! g( |) Q3 P+ n
b=a.decode('utf-8')- i& V) l+ e; a7 l
print(b)8 A9 v5 e& u% V7 _0 a+ `9 P
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
1 a9 B  l' o9 ^! b/ G& S/ iprint(a)
' N/ K/ v7 X7 o& E( W3 r( P( db=a.decode('gbk')  n# Q8 ]4 r2 O- i$ J6 V' |, [6 u
print(b)28、求 1-100 内的所有数的和
- P. ^% ?. n9 t% e' Tcount=13 y1 V5 u3 u  u) l# L) m) p  q+ J
sum=0* P5 R5 g. X/ ?
for i in range(100) :
1 A2 [8 I6 m4 B7 [% ^ sum=sum+count
( {0 N8 ]1 j; T! x3 B count+=1
3 O, {2 y+ M, c5 jprint(sum), j" a0 M8 z  d! Q. V* G4 g
/ R. y% s! f+ K5 |
count=1$ G' S8 F5 c- ^5 H% I
sum=0! P7 D3 p: e8 V! L1 o, g5 r# _
while count<=100 :7 ?/ `' t. v$ \/ B. \: Z
sum+=count5 Y' t5 A8 t# p- Q, w- W+ ?; M
count+=19 U- `5 k0 B" ]4 v
print(sum)29、元素分类
) x. x! e; a! D% s2 `" e  g有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，4 W. ?! V4 B7 T. m* N
将小于 66 的值保存至第二个 key 的值中。, c% z- y1 g2 V" w9 p0 {, I( i5 t
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
, M% U$ ~! Q. }9 R& Pli=[11,22,33,44,55,66,77,88,99,90]
% A7 N# Z( e* ddic1={
# q9 P7 C: n1 A( f8 M0 p) a& i 'max':[],0 X! Z. r, L  x% ~- T
'min':[]
: [% E$ t) }/ V  F) R0 [}. @, R  N7 k( m9 \! n9 |) k
for i in li :
- z! p2 t. x! z3 m) u if i <66 :
: J4 e7 `, u& ~  g5 N( O+ O       dic1['min'].append(i)" j* P' {: a5 I' O) r
else:( @5 {7 Y  J$ v( q8 j
      dic1['max'].append(i)
% y4 o; w' J; k$ Jprint(dic1)
# J% p- P3 q6 ^7 K: f+ ?' K
: S9 `3 H* k) D( S, a  T( A---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
8 t6 \8 ?# @- C$ ?" k& {+ P5 z& ^/ \

Python基础知识汇总

主题推荐