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、写代码
1 x8 R1 @  U6 h  f2 m8 Q2 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) :
( s0 D4 K9 @3 @' X8 l name = input('name:').strip()
" n( ^  {" [( l pwd = input('pwd：').strip()8 C" N- h! P: ?0 o. D5 o

3 C! D" Z8 B% Q1 i: b if name=='seven' and pwd=='123' :3 ~! ?; k! `# c# [; M
      print('ok')
2 f! e1 U5 k. ]1 M& H else:
/ I5 U- \1 B( ?* s. C: H       print('error')
- v4 o6 R7 c" ^4 R% {       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)  :
: ^& {+ ^5 h3 G- }( P8 i name = input('name: ')5 e5 v' a  d) K( \: {, p6 A- A
pwd = input('pwd: ')$ m/ K+ s& _2 Z$ {( C% H8 k8 P7 h
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
9 [; V# [1 {1 I       print('ok'), v1 N+ }0 c: w* E, M8 g$ a  w
else :
! f- m9 l/ Z- K8 _2 _2 }( G6 @       print('error')
* W* H+ v3 h# O4 K       count+=111、写代码
' z( ?* z' \. y9 E) ka. 使用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) :
% x+ S3 p' t( T6 L- H  X if i %2 != 0 :/ H7 L  E0 l/ G3 b. |
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :/ u0 K1 H6 {+ y$ @
if i %2 == 0:( w6 S8 W$ r0 E2 ^) ~
      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", r* j* K. |; x0 m# S2 j
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)
1 f2 M! d. d" [5 G; x6 I) r; Ufor i in name:
4 ~, o3 [: n: U( |0 `" d. G print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain9 C! O" r) D) t6 a) x1 R& w, M$ U5 H
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']6 M5 Z  z7 b& p( g. r: y& a, |
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
: O; W7 m, b* C9 \( ]print(li)
- ]: v( i9 Y$ l ['alex', 'eric', 'rain', 'seven']* y' V2 n2 A+ V
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
0 }# m$ G6 P' x7 R/ rprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
% Z, C2 Z) p: I& tprint(li)
2 @( H$ y; Z  X3 z5 @$ X* d/ Fe. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']6 T4 ]7 N# B* N& m) o! B
li.pop(1)% h$ H# |0 V/ l$ X% H1 ]
print(li) ['alex', 'rain']
& U3 K# f- J+ g1 v; q: Q指名道姓的删除li = ['alex', 'eric', 'rain']
! J# ?# x- `- v5 A$ ~/ wli.remove('alex')
: j  h7 }7 e- m9 b! c. `* Q5 Q& y9 ^print(li)
8 V+ V/ s( `: ?2 A3 c8 F' uf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']& E) x& B) J/ t+ r3 [8 L
print(li.pop(1))
5 H/ v) A! O2 u) C$ ]print(li)1 p1 ^; G* Y0 ]" ]2 _2 K
8 x3 K3 L: u' X  H
eric7 G( X+ O  L3 M3 K- H9 s
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
$ s! s3 A- V$ i9 g, ddel li[1:]
, |2 `! G5 \3 dprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)% d: T& Y& x& Q+ p/ H8 U5 N: }
li = ['alex', 'eric', 'rain']
3 L8 Y1 D% ?" c8 n, n% B4 \$ }for k,v in enumerate(li,1):
' K. q, u2 x! A+ Q' ]) R4 ~$ T print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]+ z. Q" U. Y; }
a. 请输出 “Kelly”
6 `0 X: D+ ~2 j1 g7 ?2 G' f# xli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
( p+ U' W- }! O# I8 V; tprint(li[2][1][1])1 U% d6 @& g: J; _  P- [
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”& F* d0 `. H' V
li[2][2]='ALL'- Z2 s& i2 d  r8 w: q9 w" O% ?
print(li)0 B* k. G7 v+ R7 |0 \3 O
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
! S9 w) Q3 l& l$ h1 [5 c! P: Pa. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
# I) b5 h: ]; Q  oprint(len(tu))
! s0 M5 G" P" o! [b. 获取元组的第 2 个元素，并输出
; I6 W2 t% w" L  X7 ~3 \3 e. o) Sprint(tu[1])
* m( O( j7 P7 @' F% N9 je. 请使用 for、len、range 输出元组的索引  z7 m4 U9 S2 N# G3 H
for i in range(len(tu)) :( |' Y+ X1 b& u& d7 l
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
( k% o& j) e, i( _2 {. b0 O* Sfor k,v in enumerate(tu,10) :) d  y8 n) {# o5 Q9 x+ K# x
print(k,v)/ I! e; w' a" \( k' `+ V( ?
10 alex
) R; n5 Q5 o5 k% M+ j11 eric4 z5 X9 `1 a! N4 \' r! j
12 rain9 p# e( N$ v6 l/ [: U* J" D
4 L6 \3 \' Y( Q4 A9 Z! y$ m9 B% p
for k in enumerate(tu,10) :* k' w' U( Z; Y7 [
print(k)
9 Q( o. i, T- z- M: X5 q6 m5 T(10, 'alex')) W5 A, M  N  @; e+ d% j
(11, 'eric')% i9 K0 ]' k% z1 c1 X0 I0 _+ J
(12, 'rain'). u* p9 y  {1 n, |6 M2 a$ o
( \. \8 o- ~( ]5 S9 E+ Z

6 j% ?; R6 ~/ Z9 i. B+ l% r$ T25、有如下变量，请实现要求的功能% x$ }* b: I2 N+ G
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
- C/ @% w/ l/ E& p0 `9 `- ~
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
* o4 H- i+ q3 E! vtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
% V" Q/ t8 H& G7 @# l* qres=tu[1][2]['k2'].append('seven')8 y$ u/ j, `6 i( a3 v

) }9 w& ]: y( k" R5 r+ r5 Lprint(tu)
, p% R7 Z# Z! o0 z/ T26、字典
5 G, t- X' L+ ?dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
3 d3 E% Z2 f. X' C! v1 g3 {8 S print(i)b. 请循环输出所有的 value
. P* _0 x/ m+ v3 q& }$ E6 ]/ j3 Wfor i in dic:& o0 U' i4 i1 t$ L; w5 D
print(dic)0 L4 e3 c0 O! n7 V
c. 请循环输出所有的 key 和 valuefor i in dic:3 x3 M7 G! d9 {' k9 l6 _. c
print(i,dic)
4 D( M! s  R; K2 V- a3 Wd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典. ]* ~6 _2 G+ U  m" j  f( ]9 O- \2 `
dic['k4']='v4'! i: x6 ~9 Q& I4 c
print(dic)
. }/ Q0 T! j  [0 ce. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典8 |! k, u2 d7 @
dic['k1']='alex') @+ [- x0 ]7 I( @+ E
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典5 i9 k8 u: v: b
dic['k3'].append(44): \3 _* @3 ^! A  u- r
print(dic)
% y+ z) v# n  |8 u: ~2 Z/ n. H( \* q
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
& X' b0 f9 X2 o; ^" q6 |$ cdic['k3'].insert(0,44)! v  i6 i+ ^7 e8 u2 t- y% a- ]/ G. K
print(dic)$ n* Q% h/ G. q; t( s" t5 L
27、转换
" o% ^) ~9 F! ^( T0 b) [: ~a. 将字符串 s = "alex" 转换成列表  s = "alex"
' D8 y( {* d. S7 C- A9 E& j& C+ P
print(list(s))b. 将字符串 s = "alex" 转换成元祖
3 [! M4 @( @( ^" x- W% Xs = "alex"
" ]: H( M' S) F+ G1 p. z/ Qprint(tuple(s))
; o1 Z" U* j& N* d( r' V" G0 y' Q$ q8 a
b. 将列表 li = ["alex", "seven"] 转换成元组
8 ?8 `7 j* O' |4 W: ]$ j, M$ Cli = ["alex", "seven"]
. i" U6 p1 t1 |) X. F! k$ wprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
/ @7 o- ^  l& N; w$ btu = ('Alex', "seven")% T4 |" C: z* T+ {/ V7 }
li=list(tu)
0 K- _" A# q( v# I1 j4 Qprint(li)! y" s, q, t+ s  O4 m6 B& @, |  j

1 B" w! q5 E4 k5 @
! I, Z5 j* U/ v. X* Vd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
9 i* f  n/ y. \6 V4 z' _
9 r3 E) h8 Y* edic={}# y9 c1 P' _+ g: q; R3 j; _0 P. _
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
) \( q+ R' R: i dic[k]=v
7 [7 ^% S2 ?6 l, W. J; ^6 x print(dic)27、转码n = "老男孩"8 ~7 W8 I0 r& D6 l1 f+ M, x1 D0 ]
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩": h1 g2 f4 O3 m/ x+ k) g0 B' }! ]
a=n.encode('utf-8')
( q0 Z, k7 B% P) c* _/ \print(a)
) O1 X3 G9 Z$ e) q- Q2 U8 vb=a.decode('utf-8'): Z) j) C  |5 u* ^
print(b)
- z- M$ {- t/ W) h# g0 A: W5 s! z/ cb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
$ \$ ~2 e9 _% S! Q6 V, n: i' [print(a)0 |. U, k5 s# Y1 T3 U4 i
b=a.decode('gbk')
8 X& E7 g% B; W2 b; }6 C7 q4 o4 yprint(b)28、求 1-100 内的所有数的和
; R; M9 o$ [' c' ]count=1
2 |% x* _* s4 t7 c5 P) Y  Z9 Tsum=0$ `, q' R$ u! m, s8 C1 H
for i in range(100) :# T* _& e; ^" q# Z. B4 J
sum=sum+count( T) u! O. j  {+ Q( J# ^; M
count+=1: ^+ o( K1 |5 e, \0 c
print(sum)
3 ?% r$ k9 p9 l: k& N, l/ @6 p- |& J4 u8 B
count=1
7 k' q. Y+ {+ C9 y% Y3 {2 b8 H0 nsum=0
0 V0 ~* U7 N. z  h* M( qwhile count<=100 :
! N; e6 i2 m% r& ]6 Q sum+=count
, B: {5 V; g5 a; i' G) | count+=1' S! b' n/ m2 E
print(sum)29、元素分类+ X+ |" N3 [% e5 r+ i7 j6 W5 k
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，6 n8 F- G5 {* j3 [* o
将小于 66 的值保存至第二个 key 的值中。$ ]1 K' d/ J* D. j3 K* f0 z
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}2 M5 a; a/ D* \; N+ g* a- @
li=[11,22,33,44,55,66,77,88,99,90]
1 c: r: N* O& w2 i# W% }! s! fdic1={
8 J" @, P7 `1 v 'max':[],* u/ M, J0 J5 F7 m. {! c8 ~! F9 ~
'min':[]$ l" }) |( h' O! D
}
6 l9 E- r9 c% Y" J$ afor i in li :& T+ e( Z8 W) B2 R
if i <66 :
$ F8 b/ L2 Z& {$ m7 ^7 M( m       dic1['min'].append(i)  K4 ~& I3 M( ?" f- y" _8 g0 ~
else:
) i  Y5 o+ T# g- _: z2 s" h       dic1['max'].append(i). Q8 d& T  v# F. Q" b% R5 D
print(dic1)
3 B9 e7 m( P' Q& I) p) d  }6 O# X
6 g, d5 f0 S+ V+ k& `  y---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}$ N3 d+ N8 C' w9 f

Python基础知识汇总

主题推荐