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 I% }9 a- }9 S: ]3 p, `
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) :
' s6 o* F; I  p) {3 @ name = input('name:').strip()4 W# d9 @9 o6 D# _0 K! V
pwd = input('pwd：').strip()- J1 ^# |% _( q

6 Y, E5 ~# _. N' h if name=='seven' and pwd=='123' :9 v2 D+ r1 m- m5 b; B) P
      print('ok')
+ Q) f6 H9 k8 D- ~ else:
+ ?8 y8 }9 G- V; t9 |5 L9 {, a4 A3 g       print('error')% R& {' @1 h. T/ V2 m' x% t0 H6 d- U( x
      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 S, p* `0 E4 L5 j0 a' f( q  V) g' { name = input('name: ')
- A; I4 f, s5 o/ K pwd = input('pwd: ')
4 e. O6 [" x+ K3 B: {: ^ if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':4 K: v" v! H6 W6 X9 J' |
      print('ok'): ?) i& B  c% O1 k
else :
& e. c4 t2 N1 R- P! n# V, f  R       print('error')+ P8 D! V; d; y3 k4 y4 h* R
      count+=111、写代码
( \) d6 t" F4 I5 d- a  K, Ha. 使用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) :
$ x7 n: ^& j2 o0 H; c4 ~4 O if i %2 != 0 :/ g: f( u  _3 N# B! Z4 E, r1 @
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :( W) l4 b7 F  r6 F, x/ n' ~3 `
if i %2 == 0:
  T! V2 m* H4 A) _- [       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"
; t  D/ F' {' [! ], Oa. 移除 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)
' t8 d) A  k3 Z  z$ t- kfor i in name:5 |' B4 g% a8 E" Q' ?; x3 l
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain9 G: q$ |2 ]/ G/ a# V6 F
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
) d/ H2 i/ ~& aprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    7 p5 N- v4 O: E0 e& a  F, Z
print(li)  H9 e$ H0 p2 [
['alex', 'eric', 'rain', 'seven']0 A% x" a+ R& J" N& f! g
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
1 \' p9 r5 t& @1 ^7 L7 v. yprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
) x1 \2 t, ?8 [) lprint(li)
+ b4 M5 g8 d5 V' j4 N! Ye. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']: W. a, M: F5 ?
li.pop(1)
1 C7 ^9 `  J% w+ |2 Z- U0 Xprint(li) ['alex', 'rain']
7 I: u# E1 ~8 N0 a8 A指名道姓的删除li = ['alex', 'eric', 'rain']* e$ J9 k' m# ]) h
li.remove('alex')
9 J# K( f( O" fprint(li): {1 c/ j" s6 ~! {" L1 w% t
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']# M0 }- ~' B7 E1 u1 U
print(li.pop(1))
0 J9 _. G# X- {9 ]$ Q: A3 uprint(li)
" w+ V+ m7 f8 J+ A- M9 Y  A1 j' |1 X% p# |
eric. ^" g! Q* Q' ~) |
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']) I; t0 B$ O" c) j7 ]
del li[1:]
; I6 y) n5 O6 ^) ]print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
" E( P8 M* s- k! S: R/ t, Xli = ['alex', 'eric', 'rain']2 f* |* r/ z: |* K% {
for k,v in enumerate(li,1):
' n# l7 |7 }4 U* ?( q: j2 d6 B' Z print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
/ Z- B) R% [. n$ j0 b9 ha. 请输出 “Kelly”
. B2 J1 t* \- q0 r  Jli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]7 h' C! l# x/ d$ y1 C  q
print(li[2][1][1])8 r7 b' l" N* ]7 h2 F# S
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
% g' M2 u6 B2 `- u6 `0 ]( \li[2][2]='ALL'+ w# F( ~6 }3 {3 ?' D! o" F
print(li)6 M: z' m; f- f" O. h
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
7 G. A+ V' c( |. {4 C0 V* aa. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
5 p/ C2 x" d$ y( n, G# @print(len(tu))
$ j0 x" m& q$ n# Q) O  {2 nb. 获取元组的第 2 个元素，并输出* b7 ]4 H% Q) v: L
print(tu[1])
$ N# k5 w0 X) M5 [e. 请使用 for、len、range 输出元组的索引
* f! }, k" H# v1 N- O9 v- f) _* ]for i in range(len(tu)) :2 m0 G. w% P; h* {# j! I
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始), \9 o. ]( c$ F9 [+ Y
for k,v in enumerate(tu,10) :+ d# Y$ O  Y% `4 [3 S8 R
print(k,v)
7 P2 x0 F, [1 D9 Y/ J  D8 ~10 alex; \9 O# y0 n. z' Y/ j$ ^
11 eric
* K5 V4 K$ N3 [+ v. k12 rain
/ V5 A3 P& P" W4 U8 F2 @$ |5 v- k) X: M2 r& A+ z& L  w% Y
for k in enumerate(tu,10) :
6 \# c1 J5 Y3 y2 ]' v/ g print(k); q/ y$ o3 Y# W) A( @
(10, 'alex'); P! H* R0 `5 a6 P
(11, 'eric')) `: N1 m8 {3 g; s  P
(12, 'rain')  \' D# h5 s1 D8 ]0 x: J1 y

% @$ N6 G2 m" u- x' z8 m0 c+ \' @  W
25、有如下变量，请实现要求的功能. d/ P0 ]6 V3 j9 T2 U; P; o
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
8 d9 m2 D* l$ J. l0 J5 R. i
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
: v1 s2 q2 T$ {5 Vtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
4 S! F0 ]4 I) Kres=tu[1][2]['k2'].append('seven')& \) @& W5 k0 i( n$ ]3 d$ U

2 W$ v' V& l2 z+ ]% Vprint(tu)
1 l# f3 i! V* O: n% t8 M/ D26、字典$ v4 h! ]4 \( f4 b8 B/ e4 ^
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
+ o, d4 V' [! L7 v( t8 @, m! K print(i)b. 请循环输出所有的 value
  ^2 {% x% P( R# d  y5 C6 m$ Dfor i in dic:
0 v  E! r5 s3 g, S8 V# A print(dic)
# a6 F0 Y4 E) r$ w* o* d" [) F3 fc. 请循环输出所有的 key 和 valuefor i in dic:
; a. W" D, \  h# wprint(i,dic)
) L3 e. I/ O9 w; l+ N0 Xd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典* J# B  C" R3 b5 T3 n: A
dic['k4']='v4'
+ r& Y$ O6 R& E" i! V% zprint(dic)
) h) U3 j# K7 T( Ye. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典2 o; n7 e& b+ p9 b2 U" o3 y
dic['k1']='alex'  e" ^7 e  y2 y' n1 m$ i
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
) D7 l! U$ X- K: i7 G- ]dic['k3'].append(44)
! K* T9 a/ Q. [8 u6 S7 xprint(dic)
" ^; _7 J; S) P7 G6 g
# |* c5 X" L) h/ ?' c. D2 Ig. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典( p1 |& r+ ~/ M
dic['k3'].insert(0,44)3 E# H  A3 J8 a3 S0 v
print(dic)
/ I7 C* g3 v9 g1 h& g7 U27、转换
5 Y) Y5 t; _. ]) Aa. 将字符串 s = "alex" 转换成列表  s = "alex"4 x" A5 c3 t5 u( c5 d1 g

2 p, D5 s; D5 aprint(list(s))b. 将字符串 s = "alex" 转换成元祖
1 B1 n) S% Z8 R8 ~' F  i# G" fs = "alex"
; l! X8 l5 v4 }+ _- Iprint(tuple(s))# v! f* J' I% Z! k, A( ^

7 D3 q5 E4 H2 h" P* jb. 将列表 li = ["alex", "seven"] 转换成元组
' w  F; W! q# b# j% fli = ["alex", "seven"]
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表$ p9 q* l; ^7 T  D* I* i+ S
tu = ('Alex', "seven")3 H7 s! f. g% ^  p
li=list(tu)4 q- [" z4 a$ f8 g" {: D
print(li)
# a5 q4 ~/ d- S; u) U( Z5 u& t/ Q
& q. \& _8 K- g. |" T7 O: |4 S' A  a$ X4 V$ C1 w' A9 T
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增  y0 F9 X/ T+ z( Y
. b: T8 E! @" i; f; s$ P9 Y0 n
dic={}- Y8 q6 H2 [/ Z( s0 |$ W) `
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面: w9 c; F" x! c! }8 S/ S% x. D6 P; e
dic[k]=v6 z  z' K. f5 H% q2 v3 B
print(dic)27、转码n = "老男孩"
$ d7 i) T- m' r/ }a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
: I  W+ f; f5 C: }" ]a=n.encode('utf-8') - l3 g. i) [) r' _
print(a)
! m& |7 K  W& K+ F" N/ Kb=a.decode('utf-8'); `3 D+ }8 n9 r, Z
print(b)
/ i5 e! Q4 G( D, ]b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
. G6 F- t2 J! Tprint(a)
3 e0 f1 V3 h+ p% @5 s- z. Y9 w3 qb=a.decode('gbk')
4 O: c# H" ?. D* w$ L. w- O' Zprint(b)28、求 1-100 内的所有数的和
8 R& p$ T7 B+ S$ L5 y9 W; ?) Mcount=1) u2 M) V6 _. w6 E4 e
sum=0
% P0 ~; C7 R5 [# d7 P' M( Hfor i in range(100) :! H; ?1 x( W  i. }9 U6 U# p
sum=sum+count; d! f' `% p/ ^  w
count+=1) B- L6 b- o8 E( s$ P- ]+ E
print(sum)
7 X) _' R: ^  J% K* d3 X$ z4 M/ d1 ]4 j2 S6 S
count=1* z8 \" z; p# \/ D: {& v
sum=0. J2 g+ x4 w  l7 z
while count<=100 :
; Y7 ~" n: P/ d# b sum+=count* P+ l, S2 n1 p
count+=19 h' L+ V8 I8 K) _- g( v* R# A
print(sum)29、元素分类  C6 J: C+ t9 M2 V
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
8 V7 q5 |9 l  Y/ @- F将小于 66 的值保存至第二个 key 的值中。
1 L& b1 ~* w+ B  W9 i' @" k即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}& v. h5 z8 z7 M! E* Q. q
li=[11,22,33,44,55,66,77,88,99,90]8 Z/ B8 j+ ^' k1 V
dic1={) V( h" G  ~' [4 |; w' {
'max':[],  [: n& q0 d! O% l
'min':[]4 N- h6 o! i" z# o# D# u% W# k$ ?1 p
}
/ `2 t0 v8 y5 X. K4 I0 Cfor i in li :
0 L, g+ R; W2 B% X4 k+ s( P% E8 F5 b if i <66 :6 g( |3 {/ M- R: F. d
      dic1['min'].append(i)* C* h" X" @) ?+ h
else:: p3 F! @3 D# S, y* g6 O1 W' Z# v
      dic1['max'].append(i)
/ x  R  k6 A; g7 c" J: K) B+ Hprint(dic1)
) \) O, c6 c0 s8 \" ?' F$ E6 E# J9 ~) F& f: I/ b0 e
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}! @% H0 t2 g' I6 c7 e

Python基础知识汇总

主题推荐