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、写代码
& Z) A- {- j2 T! G$ P+ Xa.实现用户输入用户名和密码，当用户名为 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) :
. S  y% t# _2 D: \) _& ` name = input('name:').strip()
. {% p  ~7 Z2 h  n pwd = input('pwd：').strip()$ e- p5 y0 ?$ K' n! `  W7 h, l

3 d& u8 y6 c) ?. H8 D6 L/ X if name=='seven' and pwd=='123' :' p4 k" a# T* ~- [
      print('ok')9 c% |0 ?" T/ h, d, r
else:" j  C# f1 {3 ^# \9 ^1 r4 E
      print('error')& E, z( X% S" i' o7 t5 t
      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)  :
, N* G& W0 Z( C5 @; W2 J; d5 @2 a, q name = input('name: '); h: V0 K0 R. [1 i
pwd = input('pwd: ')
1 ~: w0 J. @: m9 b! R, R+ M* L# ` if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
! u3 X( h% z+ |$ l       print('ok')( z- S! v" a* l* _
else :
) t! p* Z4 _9 H  ?7 \" \1 R  N' C       print('error')1 L# g$ ^6 U8 q3 F- {) Z; V
      count+=111、写代码
, S$ c7 c1 W+ n  G1 Na. 使用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) :3 B) M/ h8 {# F8 W" D7 R) H
if i %2 != 0 :2 n' d6 A2 t& c9 B! i
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :, A2 W4 {* B! j5 r9 c
if i %2 == 0:8 f3 ]# i7 W. @! F# K: r7 I
      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"! X  A3 V9 Z+ Z
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)) f. C+ \/ h1 `( ~7 ?( O5 |( J
for i in name:: |5 t6 K% ]. r
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
+ A! `4 D3 a. E, ]0 m. `0 U22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
% O: ~$ p! v2 yprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    , `3 f+ i- [- d0 f$ ~9 a2 U
print(li)
6 F$ Y5 G5 Z- Q ['alex', 'eric', 'rain', 'seven']
9 X4 g  d6 E+ s" g6 K: Wc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')2 {2 e  D* R7 B+ D# ~# f% @* `
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')" C. a' I' L) x% z2 \& u: b, s: _* j
print(li)2 A9 [) E# a- ~) L4 T: E
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
5 w2 V1 m0 j6 k# {9 F' Kli.pop(1)1 O/ `+ U% h' u
print(li) ['alex', 'rain']: Y1 p" X, b& r: E
指名道姓的删除li = ['alex', 'eric', 'rain']/ ~( s( @4 ?& c1 x( z# @8 `
li.remove('alex')
3 k% B8 y, y; m) x" Q" b7 A5 P, Kprint(li)
0 _1 r3 Q8 h) }f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
8 @' P+ Y& {" H6 aprint(li.pop(1))
2 b  G; i. d: m4 E! B, b% `print(li)+ R( d8 j, E- y

1 J+ r" S- G% E; S" xeric8 V  }. R: W1 L3 N7 I" p4 f) ~, D: Q- Q
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
& F- k, g& ?1 O" ~9 y' Adel li[1:]
6 F" Q# T5 z2 f5 z8 I" W7 V/ C2 iprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)2 ?! [1 S% e/ f1 U6 z
li = ['alex', 'eric', 'rain']
/ W4 ^8 q- E9 L. ?2 H6 A2 zfor k,v in enumerate(li,1):7 t( v* V2 |6 w- \
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
- U. ^- f+ k- b+ e: ^& U7 A. ha. 请输出 “Kelly”; |7 k$ u* C7 u% X$ X* q( t4 i/ }
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]% w/ ?) C' B8 f5 _% j
print(li[2][1][1])% ^/ A: x6 s' r/ o2 `* {% A, }/ e( k
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”+ A4 u0 f: f/ G0 m5 o0 L
li[2][2]='ALL'
! C; [; E9 x1 |: ?. xprint(li)
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
4 O! W& }& f( u! ?5 V" ?print(len(tu))
- H! k6 w9 |: l, m/ S9 m5 \6 P6 Vb. 获取元组的第 2 个元素，并输出7 K% e& y% m& f2 H& `, _$ W1 k
print(tu[1])% T( _5 A5 M7 n- a; }. R( X
e. 请使用 for、len、range 输出元组的索引
6 |0 J) ^2 J3 t2 T3 efor i in range(len(tu)) :$ [; D* `' E( D
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
; K9 o; X+ B, o# \) y7 T1 b" W1 {8 wfor k,v in enumerate(tu,10) :6 g$ I7 L+ ?( b; A" c' T
print(k,v)
! I2 |0 r# \: z$ R10 alex
- r9 @2 W1 B- O; n11 eric' I# g# Q, y" x
12 rain0 a/ G' V" @- Y- s% p
0 f) U1 N* ?  ]9 I
for k in enumerate(tu,10) :
- I- J, E( f/ Z6 d% O print(k)
: i- r/ ]  ~/ r3 A* o% I(10, 'alex')
6 L6 m+ _" r0 z7 |% J$ y+ q(11, 'eric'), J3 _$ D( I3 q7 Q5 l1 m8 p  t- y
(12, 'rain'). B0 ]$ I. q% Q/ o6 I) X
0 Q: _9 b) b  E6 s3 X# C5 ^

* H. d- z) E* @8 U  n7 n7 A5 v25、有如下变量，请实现要求的功能
- f1 T) Q( L  G1 U+ Z) U5 R, k! ~tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

3 k/ y1 H. e; d/ F) k# E# ~# w/ vd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
" j7 \4 I5 I) _8 Q9 f( ]tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
/ X  {/ Z! ?  s3 ~; x! k" xres=tu[1][2]['k2'].append('seven')! v! s' n4 l/ {  C7 Y- T; g
! J4 X. ~; }, B9 ~. v+ e
print(tu)  `' e0 [" u' u3 L
26、字典  D  N  x  h3 n( ]9 y5 K
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
( S" D$ c, `; i( r3 V9 G print(i)b. 请循环输出所有的 value# r2 W3 \/ y- Z
for i in dic:
6 }% u6 J; s2 v print(dic). Z8 y! u# ?# C6 E, y
c. 请循环输出所有的 key 和 valuefor i in dic:/ \: i( H# a4 D' f5 ?! I2 J) E! F
print(i,dic)' Q$ J3 D/ G. Q* E- ~2 I' p
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
  f* f; y* M( d$ \dic['k4']='v4'% I$ o1 i& T5 `& N: v% S
print(dic)- J* d+ ?9 S0 `2 b2 K+ b; x! d3 B
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
) b/ @1 ]& W: w* W# udic['k1']='alex') m, g; d: u. ~" W" n; E+ ^
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
$ R: M+ O6 L0 _2 p0 k$ C4 gdic['k3'].append(44)7 t1 I' n3 q, }& j: y. v) m
print(dic)* r9 ]' j! ]+ `7 O0 X1 F) ~$ b2 D

5 Q% k, p4 r5 \# t" ?. qg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
$ X0 _, Z% t! i1 e! G) f1 cdic['k3'].insert(0,44)
8 i6 k4 [' {' B0 T* s3 Qprint(dic)$ f& {& }. R! @# U6 K- M
27、转换
5 B5 `: `5 m- g, P$ A5 L7 g! Ba. 将字符串 s = "alex" 转换成列表  s = "alex"6 U/ U- F7 i( W) x& J7 ~( M
! L! i4 }. W! ?7 z2 c
print(list(s))b. 将字符串 s = "alex" 转换成元祖% H" p( e4 v6 ^6 g; k4 n2 o1 C
s = "alex"
) M: X; a$ `. r2 s* `% qprint(tuple(s))
* Q/ Z# B0 Z) T0 D. r2 x- D$ v) q
7 N: [, r( [7 d- ]4 Ib. 将列表 li = ["alex", "seven"] 转换成元组$ R' X8 }6 x3 g/ P. V6 e
li = ["alex", "seven"]
, K2 h/ T0 {+ O& \; n9 q  `print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表4 G, t1 f2 l% Z6 I5 Z+ Z. E4 I0 u
tu = ('Alex', "seven")
4 y1 @6 a& B7 @7 yli=list(tu)2 P  X. K1 S& k* U
print(li)
2 [! e  n( V; L2 V3 b" e
0 `6 S, A3 n( Q, C8 N! F' z
0 H% x# Q9 q( Z1 Kd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增0 n1 p7 g2 D4 F1 X. j" S
/ f, v6 X* j- Y
dic={}
# F6 [$ R; r& [% s+ Nfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面* ?% v. {, }3 l: }
dic[k]=v8 d7 z: X) A- I# U1 Y- n7 l' d
print(dic)27、转码n = "老男孩"/ C9 V( z1 `2 Q1 p
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
8 B8 X* x2 N# u4 Ua=n.encode('utf-8')
, P8 A$ _' t5 U2 i8 k0 y6 I) uprint(a)- p: u$ L, a3 j
b=a.decode('utf-8')0 l/ I! N' f- n2 _- Y! k# }
print(b)$ W% U  N) q/ k$ @! _% i% ^/ Z9 `1 I
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
! a0 I% c" j# ~" f1 c9 ?print(a)( p* k2 l! P" ?  D( F* Q
b=a.decode('gbk')5 n8 a5 H* _1 l5 U6 C# g
print(b)28、求 1-100 内的所有数的和9 C, s! n! H9 B. m$ w
count=11 J* s3 g7 t9 N$ h/ T% P
sum=05 v; u: N1 m$ V
for i in range(100) :
$ k/ m% u8 {: e7 h4 X- k9 ]- C sum=sum+count
  L7 x! {" H& s count+=14 g% J, S# K( h; Y$ L  o
print(sum)6 U  K" x1 ^/ i( k8 R, E& N) g
0 Y2 f9 E" d8 `! I. e
count=1
. z6 p& q* g, a7 x1 o1 X4 J8 t( ^sum=0- h1 E* s* u# M# s+ E, R* m
while count<=100 :& _. a, p, i, I" j8 Z4 p: ]3 t
sum+=count; z* x; T1 ?1 O
count+=11 c( M$ G) |4 L9 k
print(sum)29、元素分类' n& O! g& l2 b0 U8 N3 K
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，% l, w$ u2 s" j2 k- O
将小于 66 的值保存至第二个 key 的值中。
* B" h3 U3 G: s即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}  K7 f0 X. I4 F% L
li=[11,22,33,44,55,66,77,88,99,90]
% R$ l# k6 ]- wdic1={
$ _* c' I! m& T2 U2 V4 j 'max':[]," ^5 v) n  N$ ^8 b8 f
'min':[]) |3 \4 P) `4 a& P
}. h0 _- n6 C; p
for i in li :" ]  c6 O5 L/ u- ]
if i <66 :
9 `! Q7 B4 r8 A# ?! y9 l$ z       dic1['min'].append(i)
$ ]  M; h( r0 k else:+ G0 S; P. p' A4 Z* k$ z
      dic1['max'].append(i)
1 C8 B9 R$ e; [& o3 F6 ~  {print(dic1)/ A3 p- l& r( L6 F# k
2 `& P+ P9 Z( c  U& P/ ?( p
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
1 f4 {' o* h2 y! r8 x

Python基础知识汇总

主题推荐