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 ^2 F/ b( c" 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) :
8 j; w* }' U, J, V& i$ S$ v name = input('name:').strip()) _6 s7 G/ V. G( Y; R7 s, g
pwd = input('pwd：').strip()
$ S% `; R" F" E  q( `9 @0 s
+ z, r, Z. I" a- ^: u if name=='seven' and pwd=='123' :
/ g# m3 ~  [" A( {6 ?% S       print('ok')
) ^( S; G, d& m( e1 P3 @ else:
8 G& d8 t% A) G       print('error')& \% a, G: X- i- o) z
      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)  :9 \, c( D! ^& _0 [
name = input('name: ')1 `/ T6 \! i" C# g& Y( K9 h0 X
pwd = input('pwd: ')
  w6 o- R; l' x5 P0 P0 c' G if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':4 {) q  ^) z7 t& ?5 z, t5 a$ B
      print('ok')
0 I& d  Y$ g. n( X) m4 u3 o else :
# M1 @6 W! D8 R) U: B* f2 W       print('error')
7 q$ G* Q, R3 I& _! R' Z       count+=111、写代码
( R' p& b8 |6 W5 {8 V9 wa. 使用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) :5 R& E0 Q( u; `- r# ~: I! e+ E! S
if i %2 != 0 :
# w  o6 i9 j& Q) q- {6 q- j       print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
# t% q2 |  M7 J/ R, {! ?$ ~ if i %2 == 0:! [" Y' j* ~: ]  I6 d# D! ?; _
      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- z5 V- s& E( _6 N6 Na. 移除 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); L6 k8 a! c8 c7 q3 b) {7 m
for i in name:
4 k6 Y; l/ S: b2 S0 g  C9 j* t print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain# @* t, N0 K, Z0 t0 I
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
, o- e. S6 I$ b3 V% s, Aprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')       V! ^! o1 |- `: r
print(li)
( B0 d0 q; t) b  \0 k. C ['alex', 'eric', 'rain', 'seven']
: {; B1 r4 [) h0 A* Z6 J* lc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')' Q6 g4 x. V( J' H& ?5 h  e
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')5 E6 M) G* n6 o
print(li)$ \3 v. W8 t0 S, ^. y0 f0 j- G1 D6 T
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']# d' `) r5 Y( `" C% {
li.pop(1)! L2 Y, Q& u* e4 s3 C! L
print(li) ['alex', 'rain']
, U, Y8 h/ B0 Z1 @6 J/ C指名道姓的删除li = ['alex', 'eric', 'rain']. M7 f6 H) ]7 P& L
li.remove('alex')& U* ^9 w  I5 L- I5 h7 M
print(li)& a' S9 e) s* o3 G! M
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
' ?& Y9 K) b  w% C/ eprint(li.pop(1))
4 X. m* S8 [0 M$ I* q7 _print(li)7 j; s. _$ h) L3 x. w$ s* R
. O. B7 P6 `, ?* v$ }
eric! D" S7 X. a% {7 b$ \
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
' @/ S# U6 ^# odel li[1:]- K0 g: Z6 w- P5 E
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)/ ]* U# `5 _3 P$ Y
li = ['alex', 'eric', 'rain']
, M" O% u3 T8 x8 zfor k,v in enumerate(li,1):6 I- l  b6 P6 e7 }) o9 N
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
6 g" J  i) @2 k4 }# F! [a. 请输出 “Kelly”
3 N. C( |; N6 A& c  }+ zli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]2 y2 c% k: G1 D
print(li[2][1][1])" ?% @. V: }" X: ^
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”$ w5 `+ s8 @% ~: _/ e) ?0 k5 p, Z
li[2][2]='ALL'
: r) T+ y0 u" n  k8 r" ]print(li)
+ c0 }$ Q) Y3 X: u! c24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
  m$ ?  l2 r. w% _- S* y2 Ra. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
4 F6 q0 v3 H$ |6 ?8 S5 `" yprint(len(tu))- z0 B. y/ r5 z) ?2 `5 b8 o% l
b. 获取元组的第 2 个元素，并输出& K5 ]4 I- T  s, ?8 X* g! d" O
print(tu[1])
  _+ C: c- Q5 w& c( {3 Te. 请使用 for、len、range 输出元组的索引
/ h3 d0 O3 v$ [for i in range(len(tu)) :1 p* m: s8 O1 G& p: K/ A
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
& H! `' J* f% d0 h' x. vfor k,v in enumerate(tu,10) :
2 l/ F$ d. k, | print(k,v)3 K3 }. R. y1 Y. d, j) O5 j9 M' A
10 alex( O( N2 Z- [/ u: I+ M
11 eric; d) b: p4 N0 [  X3 {- Y, z- I5 J
12 rain1 l# y3 e( h" e" }0 L

3 f( Q7 m2 Q) z( W  R8 Ufor k in enumerate(tu,10) :
9 H; x0 I' ~6 |7 E print(k)& y2 u, C1 s1 g& W' `
(10, 'alex')
' x% n9 T( Y; v8 B0 v(11, 'eric')
/ D) D5 q+ o) Z$ d- K! Y(12, 'rain'); c% Y8 O' J9 r1 [9 a& D  i# C

: H6 g6 Y: D% \( s6 B  I8 y0 O* o/ m
25、有如下变量，请实现要求的功能0 k9 J/ l1 ^5 a6 W2 ?
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
1 K9 z7 N4 r% ?/ s+ B
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以  a5 _) H6 g( R  ?1 P% J
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
7 p, u( k2 c- g( C5 q& Z# wres=tu[1][2]['k2'].append('seven')+ _$ [$ w2 |6 m" P, O% |* D
+ o! r& V1 _7 ~: c
print(tu)
& q4 ?2 B  t- F5 P26、字典
% R2 Q+ Y3 f  K/ _* Bdic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:" d6 i) l. L( T% C9 r/ d$ d$ Q
print(i)b. 请循环输出所有的 value$ S* s4 Q  d' }* Q6 ]/ }, U' v# U
for i in dic:
" ^7 C: F4 |# @ print(dic)* J$ C, S4 I! S% A2 J
c. 请循环输出所有的 key 和 valuefor i in dic:
8 p+ |0 w5 N9 v5 J. Pprint(i,dic)
- `' }! g: u) e1 kd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典: z+ w0 K9 v+ X/ J$ J0 f& V: }
dic['k4']='v4': \! B* c* w- n6 R6 i
print(dic), |3 p$ F  f! {; d+ y; M
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
9 e. \1 V8 [- D- ]dic['k1']='alex'
$ R0 y. Q, u6 }' W: F+ ~9 g) Dprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
/ U5 {+ e( V* w( _* K* Ldic['k3'].append(44)( R# W0 A) W" @1 t7 q8 I* q
print(dic)5 b  Q" w( }5 T; O" o7 @' O1 T; e
6 d2 K1 \' W9 Y1 ?
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典" j2 ]1 ?8 L( \
dic['k3'].insert(0,44)# A) F, p, G( E" d
print(dic)
% D3 D0 j! x( v% V7 G$ p27、转换
- L; ^4 R9 {, U4 u9 K/ \( L+ A+ Ha. 将字符串 s = "alex" 转换成列表  s = "alex". ?5 D4 s1 w8 K+ _

- _% W" J7 E' R% C1 [4 \print(list(s))b. 将字符串 s = "alex" 转换成元祖# @& ~1 s! e: O- i
s = "alex"
" y) Z) V4 s9 |; |' @3 Jprint(tuple(s))* W9 L7 J# d! c& k9 }& a6 R5 t

- _' O/ }" o- ]2 v3 j7 Db. 将列表 li = ["alex", "seven"] 转换成元组9 G3 M" Y2 m9 V
li = ["alex", "seven"]
2 W+ W& U' d* Y7 Z0 I1 t; Y: qprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
8 _0 w- l5 \- O' y# I; f% y# Xtu = ('Alex', "seven")
1 z& V' R  ^7 x+ T, x0 Q. c7 hli=list(tu)% p; S. G& t; V9 O& e
print(li)
  Y9 b, `* w, Z, P) p% \
1 D5 f( q& \: w; `* U3 Q% _2 J) k6 N! N
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
# g, ?! z$ r0 ?7 W! j
$ G+ a. {/ I) R, T2 H0 Vdic={}
2 t7 g+ n* ^& E- f7 Y7 d- tfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
: L8 G' v- P5 S. q: D dic[k]=v, P4 h% q  D' e" M% l0 q3 A  j
print(dic)27、转码n = "老男孩"2 n+ ~2 I' b& [' ?6 X. f2 P: [6 v* b" Y
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
! A# g" X  ^/ H+ U4 [a=n.encode('utf-8') ' \! p7 H  K6 J7 T& x4 v
print(a)
# o: g6 b. }, G5 U/ J( j, Cb=a.decode('utf-8')
' D! T- D6 `! A5 G7 ~print(b): f* _! K% `1 S6 g- z/ P
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
- o* ?6 m  ~; Z6 w, \" Vprint(a)
) V) F6 ~3 \& L( l9 f1 B# kb=a.decode('gbk')
8 r$ V; l! R: W+ Eprint(b)28、求 1-100 内的所有数的和
1 \" {+ K/ E, f. {" R" [7 qcount=1
+ i6 u1 ^% L. s# _% ?4 Gsum=0" M7 y$ t) t3 D# \$ V% G
for i in range(100) :
. J* @3 K1 s3 i sum=sum+count
0 w' t3 I: V8 b  n! n3 J count+=1
" `. D! M& F( g5 m; H7 L5 Nprint(sum)
- ^: ^% G( D7 G2 B- [9 P( @* U$ X3 W. ?, l5 f
count=1$ V+ `; X8 ]+ H; n( j( G3 k( O
sum=0
8 y: P: \0 c& a4 U! O# hwhile count<=100 :
  }" ~0 y2 W( g9 F sum+=count
$ b* d  g! m+ d) i8 p8 } count+=1
% J9 A* T, p' ]8 Eprint(sum)29、元素分类$ J- S$ n  K% l9 J
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
& G. o  U) r, G7 o将小于 66 的值保存至第二个 key 的值中。5 Y; W' s! A9 h
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}2 }4 P7 |3 T1 w) _, l
li=[11,22,33,44,55,66,77,88,99,90]; C. |( o" ~, t9 K! `4 @( j
dic1={1 D2 h2 ~2 V' G$ e
'max':[],
4 W) T1 o( N" m" d4 h: O6 h 'min':[]
8 ^6 ?) F- ^; s& o& k: _}
- M) B3 _$ `# X; {" bfor i in li :" J/ d- P, d3 `5 _
if i <66 :. I6 b% ]; I( d, T! g
      dic1['min'].append(i)+ x' X* [! c+ N: B: f" E
else:  g5 }% o. P4 @4 E4 v
      dic1['max'].append(i)6 S5 V; S( n$ s; a: i* F2 ?: N
print(dic1)
- ^. d, g& T# e0 \2 m3 x9 W3 G" P9 l  m+ A
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
( U3 W# B# Y. E% @3 s- C- r9 z

Python基础知识汇总

主题推荐