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、写代码& T7 V1 E4 I8 i& s# u
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) :
$ {# P& n0 N& V  K name = input('name:').strip()
7 R% q7 I6 Q1 w0 i. X; P8 d- q; e8 b pwd = input('pwd：').strip()7 z4 P, B) a) z# \0 O  F* p
- h# x: c: t8 v6 G3 D. `% W4 P
if name=='seven' and pwd=='123' :
7 D* h( d% P. j       print('ok')
& f3 D+ e2 i. X else:/ h4 G, A; K. X
      print('error')3 u' g6 y  w6 S! G; }
      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)  :
6 X8 ?9 i; g0 o$ c. [8 k( V name = input('name: ')( N, O) H7 k: |2 D
pwd = input('pwd: ')
9 z. u# H8 V& y2 s% ] if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':, t8 j8 a, s! W' @
      print('ok')
4 B3 `  v, N7 g* G8 Z else :) s' \1 U) c( Z) h9 \$ C" C
      print('error')9 p. W: `9 O+ U0 R8 ?
      count+=111、写代码6 Y5 G* V$ J4 m9 }# @
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) :, \, X5 r; ^/ }1 C. c5 ^
if i %2 != 0 :
: @& o4 B' C9 R& L3 m( }' A       print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :9 f) q1 X: O; q. H( A
if i %2 == 0:
& t7 |% M; Y" K1 X4 M2 [; @       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"
- N" ^7 C$ H- e. ?* }' _' D+ ?$ fa. 移除 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); Z; V: h) E- M2 e+ M
for i in name:9 _1 E' X) ^% E0 D6 N
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
$ u$ Q2 n- t1 s7 W22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']" K$ V- m4 \+ ?# k" r8 Y. h
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    & u# g4 }9 e* v& y; t$ _; B
print(li)
% G% h  S9 |% _. y& x5 I) _ ['alex', 'eric', 'rain', 'seven']: j& d( Y' f5 ~0 f" D
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
% b/ e" Y3 U; Q4 G, W( n1 Zprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
) i  O8 C2 I$ Zprint(li)1 u# r' G  z$ I* c* D2 ^( D
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']+ i: C% W( c! M3 d1 Y) l, S; K
li.pop(1)
% X- P! d9 ]0 v/ _( sprint(li) ['alex', 'rain']
, [- q; f8 j9 D; k! E+ l& x, M( }" c指名道姓的删除li = ['alex', 'eric', 'rain']6 b" Y& \5 m, Z& H8 H7 q+ p. ]1 S' i
li.remove('alex')
+ S/ L1 x% g, Y1 p$ p" Kprint(li)4 s' U: q$ B6 ?: `; U2 b9 a+ L
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']* s1 D: M9 a5 U
print(li.pop(1))
+ F6 ]: [! i4 D  T/ u* b0 t; [print(li)5 R3 j9 C, M" s. \& p) i. t1 S5 a/ @
. Z  T' \' q6 e# \# C, d+ M  s
eric
" h8 p/ b: y5 u* h- c( C# Q['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
3 i: F4 _1 z$ W9 ]del li[1:]! \( Y% h* |. E
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)4 m" h- D9 m$ x5 x7 O( i# x% w+ d# D
li = ['alex', 'eric', 'rain']
- f: U! \; {: T( j. nfor k,v in enumerate(li,1):
) f" v0 m0 v5 [, E print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
$ W: A, n4 G5 w  a% S* C: Oa. 请输出 “Kelly”2 ?- P' c) b9 N! G
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]- c* ^/ w7 o/ U* [9 Y% n
print(li[2][1][1])
! f, n( T7 D& A6 zb. 请使用索引找到 'all' 元素并将其修改为 “ALL”
* r: i  C& Y. i  W6 @) qli[2][2]='ALL'
) ?( X: U' J& l3 nprint(li)) R+ J+ m/ X8 z, p3 Q0 W
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain'), E3 H. ?7 o' p
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')5 J6 s, U0 ^: B5 O, }; k
print(len(tu))# q8 t2 }; u. p& Q1 O  C; a
b. 获取元组的第 2 个元素，并输出
( g! w/ m; i4 f" A, n: Nprint(tu[1])0 ~+ [* Y' j, a/ y3 Z
e. 请使用 for、len、range 输出元组的索引
3 f: j" \& z) Cfor i in range(len(tu)) :
2 \0 m% l, j# G, Z print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)) ?0 ~) C9 ~0 \6 W" U. H  f1 n
for k,v in enumerate(tu,10) :" |0 k: _3 P- J, ]# S
print(k,v)
3 C; e7 P4 ~" s1 x, y" n. L10 alex. h# `- x7 R% X2 F4 m0 O
11 eric5 @4 E. o% h3 i( R, W1 a" T
12 rain" P2 i9 h- _7 X9 f9 r

9 w) P. A$ |5 ~2 n2 ]8 Q0 Sfor k in enumerate(tu,10) :
3 z* G* S2 F0 w7 N2 M2 [ print(k)
5 Q! n$ n! Q8 S' C+ g- [% d& H(10, 'alex')! x8 q) n6 Z: {) w- `1 c4 A
(11, 'eric')$ W; V# t( r. j# M
(12, 'rain')& W" F+ U/ e* X: x: ~

& o6 p1 _4 N* I8 B- p( P& T2 N1 n+ y& h2 f- \0 T: f
25、有如下变量，请实现要求的功能
% P) v* A' p, _9 @tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
7 z0 v: f) M& Q  ?% _  J& n5 S
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
+ S* K$ E0 u9 otu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
+ H3 R8 G4 t) Mres=tu[1][2]['k2'].append('seven')
' u: o5 G, B6 \) ]' M+ y1 |! b" X- b/ W% w) ^
print(tu); |/ x1 i' z0 \, B
26、字典. F6 g8 h5 {' l  v  k1 T
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:& I6 ^/ W2 @4 V- _# f$ x6 b
print(i)b. 请循环输出所有的 value
for i in dic:5 ]; p2 R+ h# ?$ E( I
print(dic): w: H. _( E* @* t/ s
c. 请循环输出所有的 key 和 valuefor i in dic:7 Q& r  B& m3 K) ]9 q4 ]) y# @* j8 Z: y
print(i,dic)* b8 d: k4 C* f* ?9 `2 }
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
' z2 g+ l6 Z& t% ~* q5 `& l) _- {' ~dic['k4']='v4'
8 H- s' g9 |+ n0 j( ]( h6 Oprint(dic)
. C$ ^3 m2 u4 H5 S" l5 {/ qe. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
  x5 D. a' X' v& E6 rdic['k1']='alex'
6 H. j# W; _+ n8 i7 S/ |* Q0 X4 G+ Eprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典+ J- Z3 R8 u1 Q) b
dic['k3'].append(44)
  A% H" P: Y: K! D: f. Iprint(dic)3 z& f6 B0 Y: h. o; H2 ^. `% S
( Y3 w# _* U/ H" Y7 T" b
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典9 e8 u0 ?" _; |; w. B9 o6 C
dic['k3'].insert(0,44)0 o4 C/ \" E# Q& _$ r% V
print(dic)
2 l0 f5 _8 z8 P; O6 K' s8 \) W% Z2 ^27、转换
" H, ]+ t2 s" B) W  p+ M, u4 Sa. 将字符串 s = "alex" 转换成列表  s = "alex"/ p/ X; R5 L3 M, f' J- m" o2 P4 [

5 z0 D; Q5 H0 f$ V- O) E, b5 k& _print(list(s))b. 将字符串 s = "alex" 转换成元祖; n/ }1 [/ k5 B( z+ G
s = "alex"
( Z3 @0 s  f# m& Q: sprint(tuple(s))
7 [- t7 k; x( O, ~' Y" K4 b! p) U4 e* G
b. 将列表 li = ["alex", "seven"] 转换成元组
9 ?' E* U( p# ~' r% s% E+ e1 ~li = ["alex", "seven"]
$ I/ o4 E) \6 e3 |3 Hprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表$ p& j8 M/ c7 N, T( w; U' g6 J
tu = ('Alex', "seven")! B0 C. L7 D' e( T
li=list(tu)8 O* i/ o  d$ t2 M0 _( F# T
print(li)) q% C- y1 [" P7 @
  [0 y3 `4 l9 z, |1 D1 ?
1 ^! X6 |' q. A2 Y; w- Q
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增; E  D# V5 T) n/ `

- H. |: A* A2 @' g  s) S- edic={}
$ A) j7 k/ |; O8 Q% D. vfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
! t3 d; ^* p' {) t: y2 {5 s- p dic[k]=v
' |# h0 ~: w+ ]/ J5 h print(dic)27、转码n = "老男孩"
: {2 \: U: I: V/ Na. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"0 ^+ G$ m4 N7 F
a=n.encode('utf-8') ( J% ^. ]# a6 ^5 _1 [. R
print(a)* D( J; M2 b: V% P# F5 e8 Q# @
b=a.decode('utf-8')
5 k2 p7 R( o4 G* h7 V0 t. bprint(b)
  w1 Z7 a+ X: O  r! F& t; nb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
$ p/ s' r( Z# E" b/ |7 Nprint(a)
4 Y$ y/ Q# W0 L4 ~1 Qb=a.decode('gbk')6 m$ G* W- t2 b2 `+ y' v4 f9 p" @6 D
print(b)28、求 1-100 内的所有数的和+ J: \1 f6 }' Q+ T4 S; G7 ^- G
count=1+ K7 d# ~& R0 S2 X0 s* x
sum=0; O( ]5 r- z# }- w- i3 g# x6 {
for i in range(100) :
4 e7 a* g7 Q; O* I sum=sum+count- T& q; U6 V% W  |7 |2 p
count+=1
: M$ c( ~0 h8 `, {' h; @7 M; Jprint(sum)
0 Q$ U& J5 U) V1 d9 K7 l+ H6 i% J; q% |- z, k! z$ \8 H
count=1
; Z! N4 v+ C1 R0 B; ~; Asum=08 A  h2 }2 |$ D1 q  Z; i
while count<=100 :; \8 M6 S* G& [2 X6 W
sum+=count$ G+ I; g4 H* m& D
count+=1
( L6 d5 B" _6 |5 Z. n/ M1 ~- ^* Y: Uprint(sum)29、元素分类
; |$ w2 J8 C) K& n有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
2 y) T2 o6 S) q将小于 66 的值保存至第二个 key 的值中。: n, O! }' V8 J( W
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}  }% d- R: F* `
li=[11,22,33,44,55,66,77,88,99,90]" \4 U5 V  m, H: B* k/ m. E; ~
dic1={! T$ q; K3 v8 b4 B9 P) j$ e
'max':[],. ?; m. B  _* P( L0 H
'min':[]+ @; z7 v/ S& K
}
$ ~# |9 J: G- M0 ^) ^for i in li :
; ~# J# V7 E$ S. e& w if i <66 :
$ }; ]9 ]5 b. ]9 T2 v/ S( B; R& C       dic1['min'].append(i)
: T2 _( G1 N) J6 F  O$ M" w" g: S else:
2 H+ l) \4 W# i) |6 S2 r       dic1['max'].append(i)% O, @2 k1 e; p: l
print(dic1)6 H; x# e5 h4 l8 p2 r' u

& m8 |: A/ V$ V---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}* W! M  |4 p0 W) w

Python基础知识汇总

主题推荐