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、写代码3 ^! M1 E; T$ n  g
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) :( m& s# l# X+ N4 d' n+ `
name = input('name:').strip()
5 `0 M5 P9 H3 c1 G. U, ?% x! p/ T+ T pwd = input('pwd：').strip()
/ E4 c4 G: W9 u% S
/ |( ?0 v" B, S7 y  Z8 W if name=='seven' and pwd=='123' :* W9 I! }4 F! s# U
      print('ok')/ x' C  k* t6 P# u
else:  `1 m5 O- T/ o; p% g
      print('error')' k$ q# Y& s  J: M6 N* }
      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)  :
/ T. W3 K1 h( U name = input('name: ')
) _$ \- y% I: ?2 _% z pwd = input('pwd: ')
  X: i( j" L5 p( i0 o if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
2 h2 D( \% O; r/ B; h( i. _( J       print('ok')
" @) S' h+ ~/ H% ^ else :2 i' B, B1 s& u% a! U: ], ^! A
      print('error')
+ Z9 ]1 D0 Y% t. @       count+=111、写代码
+ {/ y2 V# Q+ G9 K# v9 {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) :
6 }7 \: C+ I+ C  F if i %2 != 0 :
$ c- ^, p: B* I. o/ n       print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :  ?2 z7 C3 z3 |' J. t" W
if i %2 == 0:
+ U( }3 V3 T, O7 ~. [       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"
- ?; {, A" j3 y. p% q+ wa. 移除 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)
1 V: x0 }1 S; j( Z; I) Yfor i in name:6 q+ R+ {  l9 o7 b' H
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain& w: e+ P3 G) l9 i) I" f
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
' y7 |' }5 o5 B9 y* o- Zprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    8 H+ `7 o: {9 @% ~& J
print(li)9 X5 r- z1 W$ x0 U
['alex', 'eric', 'rain', 'seven']+ a0 m- z+ T* F8 Y3 k
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')9 K. P7 \. Y0 d
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
, K0 F8 [6 W/ G. U: Yprint(li)" `4 e% u: s' ~9 w0 P$ }- `, g8 L' H
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']0 Q& V4 Y' ]0 Y6 g7 ]0 z' ~5 a
li.pop(1)
( P1 A5 S5 h2 f* D; rprint(li) ['alex', 'rain']( B* ?$ X! B& D! y
指名道姓的删除li = ['alex', 'eric', 'rain']6 c- T/ M7 U: ?: X) Y' q
li.remove('alex')
. A$ W$ I/ c- ~$ u& p; iprint(li)2 K- ]  u( b  }
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
3 i8 J/ b  Z! ?3 W; D! O$ g  }! Oprint(li.pop(1))
! C6 N) G. c  i  i2 Nprint(li)
' h- U4 a/ F- |! i7 t- n5 Y$ S% R3 ]  z# n% M* l" O3 b
eric
0 d, I# ]4 y) t' A  g['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']2 ?6 C5 J. {) r2 q, \* f
del li[1:]
; r2 }9 H0 ?1 t" d6 ~' A0 N' Zprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)' P  u9 \. c2 Y7 S6 \
li = ['alex', 'eric', 'rain']
, G( f  |. i$ _8 cfor k,v in enumerate(li,1):
' \2 T) B: r! a& I: m print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]  g1 p& [; A7 Y% R
a. 请输出 “Kelly”* C  s. ^2 O  g6 S5 d
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]. ~3 C' J; f/ P1 Y6 C6 v- E1 P# h
print(li[2][1][1])
1 X+ P% G% ~8 C( mb. 请使用索引找到 'all' 元素并将其修改为 “ALL”) m5 {# y3 I' E/ t
li[2][2]='ALL'
* A- b$ d6 s, Y2 y3 E4 ?print(li)
5 E7 w" j' b  g- d24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
$ V: [4 T% d" Ba. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
1 z2 d# ]+ Q; ?8 x" m: D6 dprint(len(tu))
+ }4 U' R4 o/ q* O! Ab. 获取元组的第 2 个元素，并输出7 {9 v/ r! A' r* G
print(tu[1])) m7 q" x% w) H9 e# y6 T6 B
e. 请使用 for、len、range 输出元组的索引6 ?" k9 T7 T' {: P+ y
for i in range(len(tu)) :, M" k( B; h1 I1 m4 B
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)8 W: o0 r% Y2 w3 c& e; A
for k,v in enumerate(tu,10) :
3 @  @* j) u; f4 G2 m print(k,v)- ?  x7 Z8 T9 w$ m1 w) V: m) O, N
10 alex
* W2 s5 p2 f2 A11 eric- S( e, U+ G, f- e; H
12 rain$ O  N8 P! |# h6 O
! R! @/ q; Q6 q6 v( Y% I/ F# @2 {
for k in enumerate(tu,10) :6 L% A+ Z9 j. x0 ~
print(k)* n! n% c5 n/ q$ ~$ o8 }8 o
(10, 'alex')2 A" J2 o4 r8 i$ `+ C0 `
(11, 'eric')! h% E8 o) L+ {6 X4 }: D! W2 c
(12, 'rain')6 N3 {: O* @; i0 y

. ?5 ?0 V0 y3 c2 o9 q6 z+ O* Y( ]: g2 U# j
25、有如下变量，请实现要求的功能; y* d0 O% a$ Q; C2 q* w6 V: R9 P& |+ N
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

  A% E3 j* v1 F6 T2 c0 Q* @* od. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以! b1 G4 d! `8 c. y1 F3 O( j' G& n
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])) M7 `9 Q5 L3 S) L
res=tu[1][2]['k2'].append('seven')
6 r/ W  H2 s% H# }0 ]( R0 i( f4 G9 ~) g; v) Q
print(tu)
: M2 f3 _% j1 x/ ~8 F26、字典& _8 V: \; H3 D" y
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:) G5 `+ V: V: {, E1 \0 @
print(i)b. 请循环输出所有的 value
! x9 W, H/ g: x, |: ]' jfor i in dic:1 v- \$ m/ L0 j' n
print(dic)
. y' w' o8 ~: L) Nc. 请循环输出所有的 key 和 valuefor i in dic:; q! K) {, J' Y7 v% `* C: X9 G, q
print(i,dic)
; D! U0 t$ F! i# ^7 _; [* E- Rd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典9 J* n4 v  g1 q: a
dic['k4']='v4'$ I, v) X9 u2 _
print(dic)
- {8 P; r' n. o# k1 z$ ?e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
# T! I3 I. ^  C* m9 b5 y+ Ldic['k1']='alex'; P2 A5 J$ \5 n0 F0 K
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
& M# m) q, w- y$ ?" Qdic['k3'].append(44)
2 m( R2 g: P( h7 tprint(dic)+ Y4 K* [: N- b/ X( k3 r# g
( I5 B" L! r! K1 ?) K
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典$ R2 i# B( k4 I$ U5 W7 u
dic['k3'].insert(0,44)5 N* o  E* G. ~
print(dic)
( S4 r& d: ^$ e4 Y% Q27、转换
' a8 O; i/ W9 \. j2 J6 l  Aa. 将字符串 s = "alex" 转换成列表  s = "alex"
* ~4 E0 \5 ^% n6 @8 V
- H$ L- }( r1 dprint(list(s))b. 将字符串 s = "alex" 转换成元祖
+ o0 K" `. @, x& Es = "alex"
/ |. M& I. h! q5 T1 _' s7 ^print(tuple(s))4 @8 {% C8 `0 b/ ~

& \6 g$ \. G/ J: m8 }. q5 jb. 将列表 li = ["alex", "seven"] 转换成元组6 u: ^2 Z! |$ Z9 K, D
li = ["alex", "seven"]
7 H( ]/ v. B% ~1 bprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
1 B6 [# t5 |/ x* V5 Q& e" Y; htu = ('Alex', "seven")
1 q0 v" Q& N: \! |) U* k6 U4 bli=list(tu)" @1 _5 z+ X0 ~
print(li)
& u' }# s* Z1 ^$ Z, {: P, o3 _7 n; ~  M) N9 [4 L& p* M

$ R0 V/ c  H/ t& _5 c% Yd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
, V$ Q0 O, H) ^1 M& |0 m. ~6 R# V  G- L4 p( z' a- [+ F
dic={}# _# S- x! d- K7 A/ W* [7 V
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
" v$ M2 P" X  d dic[k]=v
7 V3 k' f& k, @7 w3 s print(dic)27、转码n = "老男孩"$ X  `& ]+ \5 D
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
6 ^! v( l* m* Ha=n.encode('utf-8') # ~: m, D; O. _0 V( i) J1 b1 s
print(a)
+ v- Y6 S' Z& i1 n  d- I( Tb=a.decode('utf-8')  m$ G& }. Z1 E, `8 j, O
print(b)
8 ?+ z5 o0 {0 ~9 vb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')8 Q* Q( T5 M2 a2 i% `9 s
print(a)* f% [  _' G$ `4 ~2 v6 Q! ~0 a
b=a.decode('gbk')+ S1 T) S$ c% ]
print(b)28、求 1-100 内的所有数的和
# C2 |8 k  i: {8 i. zcount=1$ h6 [& `" G( h, N+ P& I3 p& o) p
sum=0# w6 Y( a$ X2 M
for i in range(100) :& y) D) x" M& y+ v
sum=sum+count
5 v  _! D+ |* s2 h8 S5 Z3 ] count+=1
2 H2 z3 f3 B' n! G: a! B2 c5 V/ w/ r6 ^print(sum)
. E$ _: S  V( R( a! q
/ u. y8 W9 X; `count=1& E- [: u; N, h& y. q
sum=0
9 p- d! o4 B# Q$ Xwhile count<=100 :
6 i$ l3 U" g. b9 }. @9 K+ P% f sum+=count4 n. m) J  n& j7 P: ]& Y
count+=13 ~0 U* e3 F9 \, m0 X+ ?
print(sum)29、元素分类
8 l% D9 Z# [( P4 ~* O7 |有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
- C: y9 q' P' I; [将小于 66 的值保存至第二个 key 的值中。
: i$ _$ U. O. B" ^4 K8 t$ t即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
$ T$ Q; a$ J% {$ s4 {+ jli=[11,22,33,44,55,66,77,88,99,90]
8 {2 J+ O3 I( }% o- Xdic1={2 _! D, H) B- [# \. N9 V/ D
'max':[],
& v% u& a  C6 ^! R$ Y 'min':[]
& n+ G- q. F) D. h}" K; B  B. k2 t& e5 L  K
for i in li :2 m2 Q1 Y& A3 O& J* a
if i <66 :; h+ u3 z3 m' v9 T- P* T- z
      dic1['min'].append(i)" z$ q$ P/ ]* z6 R, p
else:
6 L! P1 U8 x. p; _0 R" H       dic1['max'].append(i)
) y. V+ H1 u1 I( \& Fprint(dic1)8 @2 o3 X2 \2 p, v
; _9 |& n2 o5 x5 R& G2 M( _" \
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
( g* J9 m. H" [  q# ?; z, ?

Python基础知识汇总

主题推荐