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、写代码
) J& {# _" s& U7 }* B( V+ O+ Za.实现用户输入用户名和密码，当用户名为 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) :& t0 Y/ v) s& R6 a9 B/ \" \3 N
name = input('name:').strip()
! _2 p. K0 a7 p2 ]: ]6 f4 w pwd = input('pwd：').strip()
4 W5 f/ n% P7 s" j- J8 d
* r; G$ V9 ]& @2 b if name=='seven' and pwd=='123' :. ~1 |1 C1 h4 y6 {" T! R  N. o; z% p
      print('ok')
# Z( \. ~* G4 N3 T, J3 j else:
$ o, [7 V: ]2 U. ]       print('error')& ~& m1 T. J; p( ^9 ?7 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)  :
. m* I5 q6 T9 F) V name = input('name: ')$ j# B& F0 Y7 B  e' y/ C4 S0 f
pwd = input('pwd: '); R9 e9 _$ G6 S* B6 W
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':+ {7 v: K* t, [( g* A
      print('ok')  B  m. p2 q4 s* Z& ]2 e
else :
! r3 A/ b. ]& o- F' d. @9 Y. G       print('error')
1 J* k# o9 {9 I9 a       count+=111、写代码$ T( U9 F& u" x  E; K4 d% w
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) :- f7 e8 H- S" {% D( X" ^
if i %2 != 0 :% H$ }. `! K4 S7 m& h$ q4 e
      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 y  o$ x3 l( L* L# B, @1 ?8 z4 k/ A, u
if i %2 == 0:
8 x- f! _: }3 b9 P' G5 {% ^" ~$ M       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"
/ B7 ]  Z( H% C7 la. 移除 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)) y) R, J* L/ y9 |# O
for i in name:
% H, W  u7 B. ~2 G print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain3 d$ m* H( Y  Y8 |" Z4 x3 z
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']+ P& v4 P$ D/ r
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
8 U4 Q* T6 \' i" mprint(li)
$ n! P' ?1 ]6 e+ R% r: ]3 G4 `/ g ['alex', 'eric', 'rain', 'seven']' s$ G: Y2 U) r3 L" m  r8 N
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY'). P2 r' m3 ~  l, S' {) s6 T$ l
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
' B- M1 {0 b6 f  t7 p# h( w+ zprint(li)
, Q3 a  J2 h0 C$ ?3 n( He. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
7 N# Y3 E" D( U/ `7 v2 Tli.pop(1). ~7 d* w. d+ b
print(li) ['alex', 'rain']
" c1 y* Z! C* p指名道姓的删除li = ['alex', 'eric', 'rain']
" K, f4 J' w- S$ Qli.remove('alex')
& P; i$ _- n. G9 V/ z* Rprint(li)! G6 S! h3 H8 W' G4 Q
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']# b* Q$ y1 ]- M8 W* a- x5 @
print(li.pop(1))
& n: O+ q$ B, {1 o% E, rprint(li)
$ B2 D8 A0 g: I
, C: J4 q8 o% @& u. J/ Peric* K0 r$ R, K& p8 ~- T: g  I
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
1 n+ O8 H$ ^, N' H  sdel li[1:]
6 g  O/ T% G7 ?. w2 w' yprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
+ }$ I$ o( k; Q' }1 \: E* S3 q- H- Lli = ['alex', 'eric', 'rain']! X1 e$ j1 s# D/ W
for k,v in enumerate(li,1):
0 y) l) L% o, @7 P, l) B. V print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]1 E/ w3 T+ }3 p7 q& m
a. 请输出 “Kelly”8 ~7 b: q1 c8 A+ k* M: {. B0 X9 r- R
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]* ~/ j0 \" V5 S6 D% c. x' v
print(li[2][1][1])3 [* O3 l7 A0 S
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
5 @! N6 `; r3 ~" }/ O: A, mli[2][2]='ALL'6 H& G3 t% |+ U0 i# b6 m" Q
print(li)
3 @9 Q0 e; @4 g( e24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')  w# d) S! l& \
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
% Q3 O' p' ?6 w$ l0 mprint(len(tu))- b5 |! E& A# }& ^& v6 i
b. 获取元组的第 2 个元素，并输出; R) h7 c0 g7 y
print(tu[1])
" [5 o( V: f+ C; \- a3 b* Te. 请使用 for、len、range 输出元组的索引
. H- }  R% R6 u- g8 X& Ifor i in range(len(tu)) :
2 A' m3 E+ M% H; B9 s print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)' L/ D6 ^3 p6 y  d
for k,v in enumerate(tu,10) :
* J+ ]- I8 [5 V" g3 L print(k,v)
6 f4 G: ^% F; C9 F) k1 t7 v10 alex3 }  s) r6 m4 a  Z: i7 V, w. J/ g
11 eric
1 b; N  |" h! j; v( U* L12 rain
+ {6 o9 N. A3 p( C7 c3 ]' b% h" v, p8 Z7 D  m0 n! v
for k in enumerate(tu,10) :
* F% [$ u6 S; R. b% D print(k)+ l- }" u( i- m4 {. b
(10, 'alex')( a  x0 |. t" w" ~
(11, 'eric')" w) f( Q1 A7 d1 ~
(12, 'rain')6 i; X7 ^2 h0 J. T0 ]( t
# e, }: a( u5 U( ^- i, W

4 v  e* D% ^, ]& T0 x, o$ G9 Z, u25、有如下变量，请实现要求的功能) s$ ~; A4 c7 ]8 d, E8 }
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
5 F1 W: Y* X# _# _& @
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以; O) i, Y4 v& _- Q+ ]
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])) [$ m9 w+ }: C6 x
res=tu[1][2]['k2'].append('seven')& S  `; e! P  {4 A. p0 }6 t$ E
7 ^( d3 h8 f3 M- v/ a, r
print(tu)
8 a. ], U" y( J26、字典
+ v7 R% D' S8 c0 ]  ?dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
: s7 w% U: I. h" x# l- `' u% y: c print(i)b. 请循环输出所有的 value
' o& k4 P3 F/ k6 T- ^# g. H4 b0 Ofor i in dic:
8 a# s! i& q8 L" J5 z3 Z print(dic)  G# ^( h0 Z* H3 t( ~3 E$ S
c. 请循环输出所有的 key 和 valuefor i in dic:$ n$ h) v: q9 @$ `8 q7 X
print(i,dic): O. X+ ]& ^$ Z: P" j) F$ |
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典$ f( L+ u- E3 p# W
dic['k4']='v4'
/ u6 J" \- P2 Z/ d  G, aprint(dic)! j0 ^, q2 c2 J
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典5 S7 K3 H% N' u! @! C
dic['k1']='alex'
9 q) r% m: I) ?4 O! hprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
5 t: i. E. T2 u( @5 ~$ C/ Idic['k3'].append(44)' `$ G4 p- n' h* J1 J* ]& a
print(dic)
- u6 V# t( z$ o) q/ n
; f) A2 T$ n7 V+ ~; dg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典, ^- W0 W/ s* R! I3 z5 W
dic['k3'].insert(0,44)# E0 ?* p1 T) V8 b4 _# w
print(dic)
" W% ~4 y  d: B6 T; H27、转换5 A3 k4 O) [/ u
a. 将字符串 s = "alex" 转换成列表  s = "alex") r  E; r; h1 ?. R, S& k

2 Y' `. U) x4 P' s4 q" gprint(list(s))b. 将字符串 s = "alex" 转换成元祖  M+ @* a: x6 N% O4 ?
s = "alex"
. e" }- w- i0 H+ A% tprint(tuple(s)), l0 z' x/ E: A7 Y0 N6 V! |; x$ W1 f

. Z( e  U$ A; ~b. 将列表 li = ["alex", "seven"] 转换成元组* T: b. A1 G- q9 s5 |+ w7 T6 B, ]
li = ["alex", "seven"]
7 C, A- D/ U4 ]# uprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表4 G6 ?+ U, w3 E- M; ]3 d
tu = ('Alex', "seven")
. G+ p9 |: [4 F* h% S: u6 g! hli=list(tu)6 p) O; {) f' G6 a+ m
print(li). [7 `- E2 D9 c

7 l  O4 D" n0 [- \, D8 Q- Y& l* A( V
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增9 C, r" X( d% m: v- e' Y, U
  R& P! p/ V9 z1 k  N0 l
dic={}+ m3 u1 E- [3 C
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面( B2 v& J5 _7 h* k% i. X+ D+ L
dic[k]=v, y. e: O7 _% i" u
print(dic)27、转码n = "老男孩"' W. ]$ ]& S' ?3 W" c8 E9 M$ u
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
+ P$ U- u6 S& s, G  za=n.encode('utf-8')
5 U- G" Q2 \9 U; |) \9 L. i3 sprint(a). `9 e6 C" ?3 P0 J! W7 |
b=a.decode('utf-8')5 @9 }1 X" q; W$ Y
print(b)7 K' f5 n+ q) Y* x# q
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')9 E0 x! ~0 Z; F3 [, B
print(a)
; B( p* N4 B5 s# Z( }b=a.decode('gbk')3 }' S: i4 l% U' _+ h: R% r' x
print(b)28、求 1-100 内的所有数的和
3 E  h8 {9 y: E" u8 l4 vcount=1: i2 k8 c1 Q2 S3 d. G1 t6 p
sum=0  P% M2 G- x. K/ n
for i in range(100) :
7 ~% ^! h0 e' m/ U- L7 V sum=sum+count
7 x" r& [- V0 l, ^( i* |( U5 w count+=19 {2 X" F6 f4 j; W
print(sum). J# r2 C; z$ Q9 r+ O' V

: H2 O5 u7 L4 k) s5 Kcount=1
+ w  S8 j1 Z7 V& j. ]3 asum=01 |5 e& B$ Y, J: e$ [2 e% p' E- q
while count<=100 :
3 u7 v8 X! _4 j7 R) H% @0 d) U sum+=count! V' n7 Q' J: Q
count+=1
$ M( B; h9 J3 {( ^3 v) V" _3 f. hprint(sum)29、元素分类: m( K* m; W2 J  U
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，* j) s  p% O  ]6 N# p$ K
将小于 66 的值保存至第二个 key 的值中。/ U& ^7 l: q  L2 D3 _2 D) l
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}) _4 i( b; h  g/ p' O# L
li=[11,22,33,44,55,66,77,88,99,90]4 O5 f& o, ~, o& L  U' Y
dic1={
# v( E  Y4 v  Y- x! Y# ]9 s 'max':[],
. C. f. |' w0 n, {0 I 'min':[]* f1 v" J2 h1 `, B
}4 T$ q- d* w& P* Z9 z
for i in li :- P* x( b* j1 j; U# y: T' Y
if i <66 :5 j+ w6 Y: }5 W% @, G# o  Y
      dic1['min'].append(i)  w- P1 ]1 u% Y, X% ?
else:
      dic1['max'].append(i)
& N' M  P# a% @4 ^8 [print(dic1)
0 P3 D3 M( S9 s: j# w/ M& O5 s+ n$ C1 @4 p1 u8 z) Q6 h8 I
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
9 ?4 [5 y$ U! J

Python基础知识汇总

主题推荐