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、写代码
6 l, Q6 {) J& _7 Ba.实现用户输入用户名和密码，当用户名为 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) :
& d4 Q9 P2 u) m$ Q# O. p name = input('name:').strip()
# b$ D& {& z, H# l) V pwd = input('pwd：').strip()
. U5 {; A& v# O, Z8 o5 e; S; r6 x1 k+ ]: _( c# o: e9 B
if name=='seven' and pwd=='123' :
( ]6 R$ G; ~( d  d       print('ok')! N) S* a- |% Q" z! _& ^
else:
4 F/ N8 {% I/ W       print('error')
2 h. s/ Y% g9 b; s       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)  :+ P$ C) B" t/ ~, `5 S2 G% B' N
name = input('name: ')
) h  o) K1 |. @; j7 H1 J" H- G pwd = input('pwd: ')
2 m3 A  ]' d% n; b if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':% B1 e* e0 ]' S' |- A
      print('ok')9 n3 u/ M7 X8 P0 T3 H- C7 ?/ ?
else :
# r2 T4 `, A/ {  ^1 a       print('error')
" y* ~' |* _+ g8 G3 ^0 w       count+=111、写代码
! Z, D+ c+ `2 ]7 J+ 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) :, d5 r# N% R9 L' G$ g( @1 j, w
if i %2 != 0 :
: L) o3 _+ W. f! H) K. V       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 `% D- c( {- L/ q& j# V
if i %2 == 0:
- _6 ]. j' f! H- M& r3 n2 m: [# V5 Z       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"
# m* b2 _9 ]- x9 ^; W7 Z, N, Va. 移除 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# K" R+ c; }; C  U. U$ [for i in name:
' d/ M. S3 s0 w print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain, ~) P% h4 W" p' O8 p
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
$ _% X# E4 N) S: z4 j2 b  S' {print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
0 o/ B. R% {4 k: ]print(li)
% x2 X1 I* T3 a2 W0 a ['alex', 'eric', 'rain', 'seven']4 N% K$ t, \& ]. D# @; L
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
8 t7 d% T4 P7 o# a, _& lprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
9 z' d1 d0 E; d. t' gprint(li)
: K; B# a: [' J: S8 N& ke. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
4 C$ u! z& d2 C* vli.pop(1)0 {$ e/ N/ P" U9 C: W& p( L6 E
print(li) ['alex', 'rain']
6 P2 L# W7 @) E2 R指名道姓的删除li = ['alex', 'eric', 'rain']
& f% ]# f. c2 k9 |0 A, q4 dli.remove('alex')  p1 K! h4 B+ @$ N5 p
print(li)
7 `& t  k/ \$ E" n* h% af. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
print(li.pop(1)), F% X/ C4 ~, ^1 C
print(li)6 O- B1 a& A& t% @  @

& f) r/ h% z8 @$ t. _eric1 d$ F" E$ p6 n" m* ^: n
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
- X0 w8 i5 H( b% _del li[1:]
1 E  y. x, H4 Q' \( m5 |( l, Jprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
6 w# M. X% P. X+ Yli = ['alex', 'eric', 'rain']- n/ S7 s' U  v1 X! y
for k,v in enumerate(li,1):( k- [$ R( S9 E" f  H% s
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]7 Z! `* a/ }, p  S7 `
a. 请输出 “Kelly”
" j8 y2 Z" Z  _# T5 N+ C: }li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
4 m3 j" ?8 r7 E/ Y) Q0 N/ sprint(li[2][1][1])
% u' I2 J* R: V2 Nb. 请使用索引找到 'all' 元素并将其修改为 “ALL”. j' z- n+ T- K2 k6 ~3 F6 \5 z
li[2][2]='ALL'  ~" @; a2 X9 s( `3 o
print(li)" d$ T8 I) G3 u$ Q: T2 P
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain'), c, o0 M, @, G, `& I5 I4 H* {
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain'): T9 ~8 \% D- u0 j" ]
print(len(tu))
0 F. I' j9 l6 Wb. 获取元组的第 2 个元素，并输出
; H9 ?$ e  A( l! r1 m" I* ~print(tu[1])
" A0 z; w( u1 qe. 请使用 for、len、range 输出元组的索引/ P. j; r% I1 G5 c1 X" L
for i in range(len(tu)) :
" f3 \# B" Q4 l3 E$ U0 t, W: V print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
8 p+ R9 i$ _+ Q3 T( a, H& {7 Pfor k,v in enumerate(tu,10) :
3 l+ u; j, E+ m print(k,v)
! w7 m- S0 X5 {0 u% p10 alex
% J% N1 h- d( Z( `! q" V# w8 Z11 eric
: g' f0 X1 s% j# P- ?) `, h8 f( x12 rain
: H& j) E' ^0 @$ N( d6 V0 J2 J4 _2 s1 Y
for k in enumerate(tu,10) :
: ^% r- r" E* _' X0 D print(k)/ \, t+ `8 P* d5 Z9 R$ M" h
(10, 'alex')
4 q$ t4 p' t$ ?(11, 'eric')+ c% ^$ v+ r, L; W
(12, 'rain')- s8 I" V7 d9 D

7 ?% H5 V% D' g* }
1 R% @  S, v: Z. D2 s8 P' b  g1 \25、有如下变量，请实现要求的功能
- {. e% A7 j9 O0 |" Q) P6 M: n2 Xtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

$ l" Q. i' @' sd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
: k( G; {, s, q, x: V- stu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
  F* O' }/ k2 wres=tu[1][2]['k2'].append('seven')
2 V: h0 Q" G  [' G+ t7 ?' f7 v& Y% X" u
print(tu)
. E+ j& l. z# q, f$ ?& l% x26、字典
( ^* j* U( Q' f4 K( zdic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:1 ]: @  k: R1 ^0 x- g8 H
print(i)b. 请循环输出所有的 value/ S' t" d$ M  l3 d
for i in dic:
2 j6 d" o/ D. R print(dic)
# W9 k* q& U( L$ z! l& @, R! Oc. 请循环输出所有的 key 和 valuefor i in dic:9 y% w# n+ V# l9 X/ D- |2 Z7 q
print(i,dic)
3 p) f7 A, i& |. q, W/ C0 Sd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
& |6 I5 S+ |1 K+ ?) R5 R* F0 S+ Z9 i/ xdic['k4']='v4': o) c2 a8 Q& P$ d: y7 G
print(dic)
) y8 f, v+ o. d" pe. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典* i  d1 ?* ^2 c3 T% {$ T( `4 C$ ?
dic['k1']='alex'
  s+ L/ z5 P+ c! t: Wprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典$ H. t; q( q0 j- D* R
dic['k3'].append(44)! a4 P. D, W; Q( F
print(dic)
1 y& g/ l2 E" A2 g- E3 I- D% k! `/ u" K0 m+ Y' \+ b  o: E
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典2 M$ ]1 ?, p- M/ l& i/ l# Q: U% O
dic['k3'].insert(0,44), Z( l, ^( G9 v  H
print(dic)
" ~6 N- i+ j& s; g4 b8 v27、转换2 F+ k$ t$ l1 _) S
a. 将字符串 s = "alex" 转换成列表  s = "alex"# z. d) a$ X$ C  k! Y

& J& y" m( X/ U  bprint(list(s))b. 将字符串 s = "alex" 转换成元祖
2 T' g- V; N( [1 ps = "alex"2 ]: E8 D+ Z" ]0 k# @5 D
print(tuple(s))
# U1 [- F' F3 x% b: J* @; b" {
8 a9 Q0 M/ v. _b. 将列表 li = ["alex", "seven"] 转换成元组
. V2 T, O# J+ q1 t- q  W% hli = ["alex", "seven"]
) b, O8 ^  @7 M1 p, iprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
2 M- C8 \& l' L, p5 w/ C0 Q& l* Ttu = ('Alex', "seven")
+ q3 @$ Y- Y0 B- ~! x% nli=list(tu)! G( n( Q/ N, d& Q9 Q
print(li)
/ Y( l9 ^4 @5 e) Q. b2 H: g4 y
3 q$ }" P7 S! t- o7 z+ R2 ?# N4 K9 V: `' y9 [
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增% Q; o3 x* ?, O: s  g$ G: H* H

* T/ O: p3 x! T" D# }/ T* Edic={}
" r& z* [; E, ^for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
. V# \* Y- r5 ?& P dic[k]=v
& ]" v" Y  r4 M5 w- q2 I print(dic)27、转码n = "老男孩"
8 W' C& @- t" J6 G" K  j) Ha. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"4 P3 X6 {7 d# Q2 d4 F% l0 o
a=n.encode('utf-8')
. h" N6 G; v# t8 p( pprint(a)2 T8 G/ R/ Z' d; P+ E
b=a.decode('utf-8')5 Z4 T0 w9 P, o
print(b)
6 k- P; k! S# x; _8 O; _b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')' f: p& a) `# b8 G8 `9 O: P
print(a)1 k1 ?5 {5 [' e# K; o) F* t
b=a.decode('gbk')- n) g1 t* h; B% L% \2 C* L
print(b)28、求 1-100 内的所有数的和* y( t8 K- |5 g9 S
count=1
. f3 Y8 a5 [& fsum=0
* h+ K8 c2 A8 u$ Yfor i in range(100) :
! |' L# M+ L8 Z! S sum=sum+count
- y+ @& E; I5 x0 g8 T count+=1
9 @$ I4 f' S" d  s" G4 cprint(sum)
5 H) H: L! Q" }1 M3 k( q5 E, }/ m3 O- I9 K
count=1) I$ ^0 p- @% G! Y, U2 ~4 W0 J
sum=07 O/ n$ k) z* H/ w+ N4 ?
while count<=100 :
5 J  C. L; s5 B: i- l. s sum+=count' {* q! K/ B: P8 H/ ^* R
count+=1
, F  j! ~7 d+ {/ M1 R7 P  x7 O: yprint(sum)29、元素分类
$ u" L6 J0 F9 t* |" }有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
& _" \& L& @4 Z& Q. s2 l/ x# C将小于 66 的值保存至第二个 key 的值中。
) V6 f( D1 ]/ n即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
# Q6 \5 b& N! t; g. A& T  Uli=[11,22,33,44,55,66,77,88,99,90]
, n! M) j: u. O& [  g. Pdic1={+ C7 ?( Y3 T- a/ q% A* A7 Q, e
'max':[],
( U( J! f$ `/ i! {; [4 w 'min':[]
" [6 k+ n; L' h% K5 i}/ A$ Z: X' d! g4 x8 M6 c+ J
for i in li :
# N/ R4 j6 Y2 F. I2 X  P4 J if i <66 :
4 [2 S$ h0 p6 S       dic1['min'].append(i)
: E, J0 X+ F. Z$ E9 e+ k else:4 Q0 B) b  `; I
      dic1['max'].append(i)8 t+ M( M& P) Z) Y. S
print(dic1)
, L5 P+ F! e" h6 a# {" ]
. U7 L3 H. h. D4 D---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}" f) G4 r' ?1 R6 v, O* y

Python基础知识汇总

主题推荐