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、写代码
  R1 c/ n- N0 A: |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) :4 ?% V4 K: B) g1 h0 _2 n. ^- z* c
name = input('name:').strip()8 p. m" j2 d& w' p. [- u" i
pwd = input('pwd：').strip()8 a5 J, y; f1 p. o8 P7 c& G: Y& ~
7 T' U& T2 O" _
if name=='seven' and pwd=='123' :
: ?( z1 Z$ H' A* A4 I% t       print('ok')
8 ^/ S/ P. ^. F% i) K! m. A else:
( y5 l6 n4 B4 W       print('error')
* K% u: t8 `) Y4 t5 q9 ?3 b       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 {' n% E8 ?) j7 c) [7 e
name = input('name: ')
, e$ _4 ?& {  `9 H pwd = input('pwd: ')
- J) X& }3 g/ B& V. S/ X  H if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
. m  N+ x. H/ j  G! I' P! R       print('ok')
. O6 n# p7 a8 v0 g9 W2 } else :$ a' n* c1 n$ g& @1 n- J5 U
      print('error')7 h& u' `! Z5 _
      count+=111、写代码
* B2 m( h3 `# p6 n2 V: t$ C/ va. 使用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 o1 P$ H3 \7 b# ^5 A: D4 i if i %2 != 0 :4 Y- k, f9 w- t( l  _
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
; u7 X- A$ Q" ]4 @4 Z if i %2 == 0:
" d" y+ ^! {% V/ ~( f6 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"5 j; ^6 m! F7 O8 @% S) w/ s# Y
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)+ [: L7 e5 m7 C% g
for i in name:5 w% |2 m6 M& [. s
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
. O" B$ B6 B2 {6 ~22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']5 d2 H9 J8 v, b/ w. |9 G& E
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
& i" Q8 J: ]7 C: l6 _( W5 Yprint(li)  U% o# m( J9 F& Q% k# {1 @% ^; f2 J
['alex', 'eric', 'rain', 'seven']
" q$ T( H* F, R& ^, O) Rc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')' O! w5 k  O, N% X4 t
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
, b/ y9 Q4 K8 z( O" [! I) e2 Fprint(li)
, r  @  P" T4 I, V' |2 }& \" Se. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain'], u7 X+ ^4 [' |# c
li.pop(1)
. q0 A, o* U9 \# Q: }  }% ^print(li) ['alex', 'rain']
4 [# M; \7 F# ]3 F) ]指名道姓的删除li = ['alex', 'eric', 'rain']+ i( ~1 p9 S5 c/ B
li.remove('alex')
& g# k; [1 G/ B6 i- p- Qprint(li)0 U. X0 `: J% u" t& N' y
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']' L; L- i6 ]$ L! j7 Z$ H
print(li.pop(1))
( {* I/ \; I6 z; Dprint(li)
. N- w+ X% ]' U) `/ ?* [3 a* a0 p2 g
eric
7 ?; S+ W8 k$ z' i0 N['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
0 D0 g4 `9 Z# ?% \5 ndel li[1:]
! K* G" t. N: N9 G6 B3 _print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)2 r$ n3 Q% }7 y" R5 b
li = ['alex', 'eric', 'rain']
; x- Z4 Y5 Y& W& |. I# Zfor k,v in enumerate(li,1):
5 o1 q2 F6 e' V) d6 A print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]) P$ V3 @. Q" D9 |7 p, M( v
a. 请输出 “Kelly”( _3 J3 V! t# O( a7 H/ _$ x! d
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
3 W$ [3 |" h. F( Tprint(li[2][1][1])- o% f; d! S) ~) t+ B& R
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
* X. s" _' C. R: w: B: L0 p  Dli[2][2]='ALL'
' S8 E) E% M  g% tprint(li)
5 x6 s" A9 a, l. g2 l) }+ T% ~6 I24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
* g7 ^$ d) x% L) u) s, [a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
/ f5 |" y8 c. }0 C( Tprint(len(tu))/ Y) z) v3 ?1 j5 S" @# E* o8 \
b. 获取元组的第 2 个元素，并输出5 _: T1 O. x7 s! q4 |) k
print(tu[1])* v2 {* p$ |6 o6 G
e. 请使用 for、len、range 输出元组的索引
- G: r! c6 L5 G3 m, u: n& {for i in range(len(tu)) :
$ s4 ]) V  \) } print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
$ h0 ]9 P7 P7 u: Dfor k,v in enumerate(tu,10) :4 f6 n2 H! ]6 `( I3 v. |
print(k,v)  z% L3 t. E8 C- B) h* u
10 alex
* X$ f3 j% b$ m6 B2 C- d11 eric- D  D7 P6 X* d  W- m
12 rain
/ s/ e6 f6 m: q. M" ?) {7 f/ ~3 y/ B1 {9 x  K
for k in enumerate(tu,10) :
+ a$ V' H5 U- h* x- } print(k)4 w7 G9 v* p5 i7 q5 t
(10, 'alex')
$ X4 n: N  ^1 ?4 \6 q. f(11, 'eric'): Y3 ~2 O9 w7 O3 J
(12, 'rain')( }" e5 S  v6 ?. \/ L- f

' b, L1 p2 p% [) n
* {# x/ Q2 M' S( T/ @- B25、有如下变量，请实现要求的功能
6 ?; y" g+ z% Y. @) ztu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

/ z, D, s& E  q  c  U8 ?, O( td. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
8 t1 r. P9 Q0 f9 M" N1 y) v' F& ttu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])/ C- B' G! w- e7 B
res=tu[1][2]['k2'].append('seven')7 L* s  C; G9 ]. R
. S" V- Y2 U; {+ }, v9 g8 C' i
print(tu). M) p0 G3 p' k7 ?+ c
26、字典
5 E/ I1 ^) R* H% |8 Odic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:0 }2 u: _4 P/ g  R
print(i)b. 请循环输出所有的 value
/ b7 Z! G  j0 o. f9 Cfor i in dic:
. A0 m4 {2 G1 \, N) P3 O9 \4 d6 [ print(dic)  A& J1 j  r5 Y* c4 M# u+ {6 B
c. 请循环输出所有的 key 和 valuefor i in dic:
6 S$ c  N2 p  e4 \; y1 _print(i,dic)6 t+ v' i. W+ s( ^: V$ m
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典. X0 {2 M5 q6 X8 W
dic['k4']='v4'
- E. v8 M3 i/ b. x" K0 W3 @6 sprint(dic)
3 _! W2 n/ L4 \% u$ P3 H0 xe. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
7 H9 P, ?4 w+ ^% J) O7 E, pdic['k1']='alex'
; ~8 ?5 k; I: N. P2 a2 o4 \* R7 Uprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
: N, X# H+ C0 e" S) sdic['k3'].append(44)% _: F0 c7 |* ^: m; g
print(dic)
& \; s1 j. v& }+ R$ j0 i2 B
4 ~/ ?2 l8 m2 S7 Dg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典  P" c5 [% V  P
dic['k3'].insert(0,44)
  U0 W" G  \: D( Z6 g6 A' C, Iprint(dic)
! j+ F# k- I2 M, D3 \$ i: q  \27、转换
* ^2 A3 P' d* Ba. 将字符串 s = "alex" 转换成列表  s = "alex"
4 K+ C3 p: w: o- x+ R6 y9 R9 H9 P' P1 I+ ^& s9 X3 [% M
print(list(s))b. 将字符串 s = "alex" 转换成元祖' t1 q, u+ N0 K/ {7 l/ }' z+ O
s = "alex"8 p# a$ |, H. f" t' ?
print(tuple(s))( K/ A, `9 }/ [
$ }4 p/ K8 S( ]3 j% j: g7 e, x$ u
b. 将列表 li = ["alex", "seven"] 转换成元组
7 B& f7 o' T, A' Rli = ["alex", "seven"]
( S4 J1 ~6 {7 _* ^print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表" T; S4 B: F& W' l9 ~/ _; s% }) Z
tu = ('Alex', "seven")9 a6 W# k1 d  l$ I5 p" s  @5 R9 t
li=list(tu)- J$ {- l4 \7 |
print(li)7 x) V, D7 ?0 j- h( k% @* z
( }6 A- q6 O4 N# r; z
# a/ j  U- }; T. s0 o" F; k. N. N
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
) c6 b- D% V+ I( L& [: Y3 B
! T; S  b$ j5 e8 odic={}4 N6 u" B: H. T# v6 t/ Z& y
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面) g- r" E8 i! h, T1 h
dic[k]=v
. d9 y6 ~- h& l8 w' m% a% @ print(dic)27、转码n = "老男孩"! m# [8 u1 F+ r7 i6 H! m
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
; i$ {' y5 q" C- _" U7 b. Ja=n.encode('utf-8')
8 y  [9 Y# i1 ]% d; i2 ~6 y0 Q- l8 eprint(a)
9 e$ w1 r' ^& \0 t+ C) x; Rb=a.decode('utf-8')& J0 Q1 }* _- u. _0 E6 @3 E2 K9 y8 A
print(b)
* w& y2 }/ ]! K6 l3 P; }3 f5 y9 z. ~b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')* A+ I8 H3 V* ]
print(a)
5 N$ D+ A, ?; h6 }2 y6 v1 Qb=a.decode('gbk')) P" |: T* q! s
print(b)28、求 1-100 内的所有数的和# i* Y! y; \: K9 B! O1 W
count=1
. ]6 C1 S: T7 P- M: o/ g: e& x+ }7 Osum=0; [1 L$ T6 q) M3 l& [# n, i
for i in range(100) :
5 A0 D# D# ]2 Y, q5 u5 | sum=sum+count3 ^& h( v( k. p3 n! W% D
count+=1& X) d: n! O  i2 w4 b8 I
print(sum)- O6 Y# k. h1 j& J2 i

4 r- O0 F- j& F, p4 S# B! K( dcount=1  x" t# A) g  M' F4 H
sum=0
. b6 Z" q# K& g0 t4 ywhile count<=100 :) N* |& Q5 l/ P/ F; o7 E, g: P
sum+=count2 N% k8 b2 s: c: i
count+=1
0 ?6 X6 J; U! v( m7 J2 gprint(sum)29、元素分类# J8 |" ]; k( W* j" }% J2 |
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
0 i% t  F6 W" l* D+ f5 T) y" v将小于 66 的值保存至第二个 key 的值中。
; L( ?% _* m9 W即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
; _* \1 ^8 o8 Ili=[11,22,33,44,55,66,77,88,99,90]7 {- s7 J8 T" C2 l
dic1={
! ~8 ~- I- I7 q9 p: s4 L( I8 r: L 'max':[],
6 ]* U, l9 n1 [$ B1 q3 Z 'min':[]
& B. V( f/ }% j" y2 r* q}; N  I: \7 i* H' _( E5 e
for i in li :
' x' g+ o8 ~+ G$ O$ P2 C if i <66 :
3 O! o" x6 {/ j  I       dic1['min'].append(i)
( q3 Y2 v* C, p2 N+ R" I else:
& ^, p' U. w6 N/ A       dic1['max'].append(i)
& [) M0 d, o& E% ~print(dic1)6 U/ o( s; R+ [* ?

0 |2 f. e1 u/ x---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
5 }3 ]8 c# @/ M

Python基础知识汇总

主题推荐