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、写代码( K% a! o$ v- }% O# }
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) :6 r6 `5 y) Q' a2 q
name = input('name:').strip()
1 b& R  @( Z; x) _+ l. U- V pwd = input('pwd：').strip()  q  E" j$ C/ N& C* M

" T8 F% F7 w8 I* y+ }  [- K) r if name=='seven' and pwd=='123' :* j  ~5 g7 v1 ~, w% m# m' Q! A
      print('ok'): \1 o$ i: @( M: Z6 p
else:7 u* o8 M7 @! K. D3 k
      print('error')
# t  Z% b- k9 w       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)  :: J( d3 [: Q# F: a
name = input('name: '); i; x5 F( L0 y! l/ b
pwd = input('pwd: ')
* A( ~. o5 d; g' ~' i$ V; n if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
1 G# p+ n+ K) W' e2 t       print('ok')$ E' Z& D/ p# ^/ d* D
else :/ `! W! S1 P' \4 Q( y) C
      print('error')
# j5 m8 T' [6 v0 E5 B$ h       count+=111、写代码
. w3 q- c0 `; l. r! R; K4 Ra. 使用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) :
- d" j* ^) ]3 ?6 v1 }+ W if i %2 != 0 :
( `# Q: G$ c% u" [7 [5 s1 f2 `       print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
+ y" z/ }7 X% c2 G0 P if i %2 == 0:( Y7 v  e4 _- e. l) f* E
      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"
3 j+ u$ V2 K9 w1 o7 h7 g9 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)
' \0 @, e$ E- c7 V9 C8 f" T* [4 sfor i in name:
" S9 ]4 L4 x8 |+ C. p5 a$ x- t print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
6 I9 ^7 `  r4 C& H5 u22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
* t$ q1 B6 }' \; Y1 Eprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
" j/ p3 j2 `" Z' Y' h4 F, M$ Rprint(li)
$ w! H  P8 |. u! n! g0 v( U5 a2 N ['alex', 'eric', 'rain', 'seven']7 A! |0 g/ ~: d) l. x- F- j
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
7 a% R) W. v* l9 P& m% Rprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')7 e, N/ l* w* a* t1 K2 L+ z
print(li)/ h7 i% E0 |8 q
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain'], r1 _* c8 e7 h0 X
li.pop(1)) d' _, I6 U6 u
print(li) ['alex', 'rain']) b4 L- |3 F" K+ M9 W7 u
指名道姓的删除li = ['alex', 'eric', 'rain']
8 i# V( R7 K$ Z! k: cli.remove('alex')
3 S* }( f/ q) O1 E# g: Z0 `: Xprint(li)* X" X, ^4 J# g8 Q2 ?/ R8 j
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
- O( q  D1 g  k8 X* H9 S' sprint(li.pop(1))8 G2 V" B# y1 O/ K) [) ]
print(li)+ I7 Z+ m5 B8 I
2 V) T& U: M# H' y3 K3 |2 m3 r; n
eric
4 n. G1 H6 B0 e  \. d['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
$ L2 H  d# F7 L! Ddel li[1:]' l- d+ r/ G  e8 A9 l/ K' r6 P
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)% g1 V0 k  a/ V
li = ['alex', 'eric', 'rain']! R1 I/ l: s. p/ Q: K/ z2 l. p
for k,v in enumerate(li,1):
% A& m( h3 W! o. e: z& h8 |* F* F print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]$ B1 J0 ~# z) f1 Y; w
a. 请输出 “Kelly”
" _3 [9 h% j( {- zli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]! ]  M/ w( p. g4 _3 r; V" P9 x: k
print(li[2][1][1])3 v5 S6 p* h3 l$ ~6 m
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
2 e' F& S, \1 H: l- _/ D+ Zli[2][2]='ALL'! i% ^6 V% l% F+ X. M- j4 c
print(li), e8 E' o, O* S1 X4 h+ [1 {
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
; B! K+ i5 p8 X+ @a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')5 [5 f& m+ _8 c7 v- u. l- C; y
print(len(tu))& I- O% |4 `3 W4 P: @
b. 获取元组的第 2 个元素，并输出
' M8 v+ R0 ]! l1 c  Q  U, mprint(tu[1])& Q0 X! ?% R& x# S' W* n
e. 请使用 for、len、range 输出元组的索引% m+ q% X7 Z: e+ u* @
for i in range(len(tu)) :* d7 a( D7 S8 Y5 F4 v$ R
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
4 q" _: U1 F+ o+ x5 t1 S; E/ Tfor k,v in enumerate(tu,10) :
! m+ m% [, Z# ~+ R7 N print(k,v)
/ S& _& x( y4 V- @2 ~0 E, O: B10 alex
# _  `; W& d6 N, J. b* ~/ R11 eric$ X5 x, \# X0 A& M" Y1 G9 X
12 rain
0 N6 e- {" S% G
- y$ ~! r- F( {8 h" P: s* u. H9 n  jfor k in enumerate(tu,10) :' P- b3 s) M& |4 r/ u
print(k)$ ?) `! G$ Q- b8 V
(10, 'alex')
$ ^% v& p; w4 \) a(11, 'eric')
$ Q2 p0 |9 u# P  U+ s- a6 ?(12, 'rain')5 D3 t7 l, v' G5 R+ h7 d8 G

# I7 J( I1 z8 ?: y% ^3 N1 I8 O9 Y; r4 G$ o2 d! x
25、有如下变量，请实现要求的功能& y; A  A6 j( ?" k+ g8 T6 }8 {
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
5 J' \* R* `0 u
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
% e/ S6 g: y& Q1 ^/ R7 etu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
9 s2 }  S/ g4 ]  ~/ p( Ores=tu[1][2]['k2'].append('seven')
$ o$ }4 z0 v* h: R; c" z3 s5 T2 j+ Z' B: U
print(tu)% X/ A9 q7 G  C. E1 ~3 D
26、字典
- ^$ h& R$ D; Ddic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:! F$ r2 S" |6 `+ G
print(i)b. 请循环输出所有的 value" ]/ b: E, p# b( G- K- _
for i in dic:+ {3 A# e4 ^7 r% m8 i
print(dic)
2 c' K* e: c* F. v3 I) |6 P  vc. 请循环输出所有的 key 和 valuefor i in dic:5 \3 g* Q5 ]# D# d2 J  B; d0 t
print(i,dic)/ f4 A; y- u2 v0 a  Y: ^
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
5 Q( g3 t' z" V" T  Fdic['k4']='v4'
4 |- g- }; J2 ^print(dic)
* u6 n) `- w3 O9 Ye. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
3 H% V# T! s% k2 {5 Y5 }0 ^1 {. n+ l# pdic['k1']='alex'( e+ r9 F' k# F/ @- X+ K
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
* ^2 ?, U$ C, l3 ~7 G" sdic['k3'].append(44)
* v/ O, ?4 I: K8 \print(dic)
- O5 A& j% g; l
/ V9 L1 X* |1 g0 |1 Y0 dg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典0 @3 }1 E$ i' m  ]& A. G
dic['k3'].insert(0,44)
& A( `! r# g. v" C  |print(dic), D) a0 E6 f# ]$ Q
27、转换
4 i# D6 u$ q' g0 ?2 @- Y7 d$ Ga. 将字符串 s = "alex" 转换成列表  s = "alex"+ B2 R- [0 N+ O* R6 a. x' I7 j$ s! O; \
0 K$ T! L7 I& Z
print(list(s))b. 将字符串 s = "alex" 转换成元祖3 H7 @: w8 T# u
s = "alex"! j( X9 T6 I. O0 n
print(tuple(s))
% c+ f7 ~4 R2 D0 d: {
6 r4 Z8 P( f9 Xb. 将列表 li = ["alex", "seven"] 转换成元组7 ?% ^, H4 ]! I7 F) p
li = ["alex", "seven"]
/ G7 c1 x7 N8 A% L8 Q8 U1 kprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
# ?2 A+ G4 \* S& G$ K; ^5 l6 vtu = ('Alex', "seven")
" Q" r7 a; A1 [. z% d( lli=list(tu)9 v, ^' i0 i6 o7 s: u
print(li)
4 x& k, N0 T5 P
% K2 p7 N+ [, S$ j) W
. Y8 `/ P1 Q9 I& h& ed. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增& {; h- ~' @  z) J+ S+ O, R

5 Z  V# ?! I! p9 Z/ F5 k4 N  Vdic={}
6 c& Y* R* t" g" ?7 dfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面8 _: ^. W: ]9 x3 F8 F) k) g
dic[k]=v
  N+ A- o/ R8 i9 e$ D" a print(dic)27、转码n = "老男孩"
9 C4 g: a/ a, w& U& M! I( Da. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"8 o6 m% g# U4 ^  U
a=n.encode('utf-8') & Z2 _2 X7 U2 d+ o$ R+ x% y6 J
print(a); [! M$ }) e* |# \
b=a.decode('utf-8')- J) R5 y$ i+ z$ B; x+ S
print(b)
3 B, E5 B" {7 S0 ]b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')$ w) J% L& O& r: E4 P
print(a)
, [7 e: F5 n3 j$ j( ^7 R+ G+ Y  K( ?b=a.decode('gbk')
; e6 A' g& j) l7 R7 O1 N$ {print(b)28、求 1-100 内的所有数的和
+ Q+ A$ {7 v2 zcount=1
$ r4 a& \$ @6 W4 q: _sum=02 y+ E$ R$ K) B/ g0 X' j; e( b! \# O
for i in range(100) :2 O  w, r4 W9 c1 Q+ ], [
sum=sum+count
3 G5 u: g/ I: c1 F, }6 h( e/ a count+=1
# o( x; e$ q1 ^) A) C7 w' `print(sum)
3 k( J" K7 j' J- ]1 g* ~, ]" r5 N  ]* e7 v
count=1/ A3 J! ~3 n. k+ \; _) p
sum=0
1 n/ R9 j: ^- ^5 n" o/ e6 g+ awhile count<=100 :, }- N& T9 {3 _8 d
sum+=count* e. Y3 `+ A( z# D
count+=1
% B  j; }, n# T" mprint(sum)29、元素分类' I% k, s, r! u4 l: J
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，' d3 Y( f& j) ^6 F3 A$ G: r7 D% v/ f
将小于 66 的值保存至第二个 key 的值中。. ~# K6 V5 E/ E/ g! ?
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
$ W2 ]4 \% O$ Z9 Nli=[11,22,33,44,55,66,77,88,99,90]' W& m- @2 o& W0 ]6 n& j7 O6 N
dic1={. m) i' x6 O+ }& G1 r
'max':[],
1 [' ]& y: u) n9 v* p: P# G 'min':[]
, Z6 Z6 N. I4 I( y: C. [# X: P0 z1 U}) ]6 U- @8 ~" o! g6 Q
for i in li :9 @8 m8 x* R7 P, ^1 p
if i <66 :" D, W4 b, l+ {
      dic1['min'].append(i)
- n/ s$ x) E/ p3 q+ j# }+ { else:# |/ H+ ^. `2 e$ X& N, R" ^
      dic1['max'].append(i)  b4 a1 F3 S1 a1 L" l/ `* ^
print(dic1), R/ I5 D1 @( Z, M! _% v0 b0 t

. H7 z6 O# _/ C( X$ Q) T1 O---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
9 _% Y- G* U/ a/ B8 V- p$ g

Python基础知识汇总

主题推荐