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、写代码+ P  ^" d1 y* Q( e' S( c' D1 X& ^5 C2 ~
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) :' u9 I4 G0 B6 A
name = input('name:').strip()& _- \1 d' q# x5 f. V
pwd = input('pwd：').strip()
- q# _! B8 T, |- J; k$ E7 r, K) S) K% d2 s: x
if name=='seven' and pwd=='123' :0 c2 O8 Z$ ]/ w# Y; N
      print('ok')1 O1 m( _* ^2 X7 V# U
else:
; y/ W0 w0 A; S8 _$ n/ s7 N       print('error')" ]$ Q* G% g5 A5 `' M2 [) M
      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  }2 B) a5 I+ \3 Z9 N. Z& s" j
name = input('name: ')
  c# I; G  a+ o6 C" ~# W pwd = input('pwd: ')# U' B  M3 r$ W" h7 S: o9 j
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
2 R6 [$ i) O' j0 R3 i. h       print('ok')
8 h+ n) ~8 \: l- y9 F8 L else :
9 g( n5 s: C: C! g2 X8 K# s       print('error')
  R0 L8 R  D: c4 G+ x8 b1 }3 Y. V       count+=111、写代码
1 S7 V% K: p4 {, |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) :5 g% p+ `( s) J; D) i6 z
if i %2 != 0 :
4 F  T6 c( O' v$ s# n+ J) T       print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
; a9 B4 p& `& r1 F4 z* v2 } if i %2 == 0:
+ N% u# n3 b% k3 _) K       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"
8 b& v4 ]2 t! P2 D  d& q8 d6 q8 qa. 移除 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)5 H: L; w# B: w
for i in name:, p! U) w) b6 @6 _+ U
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain3 d; \0 B" x; h) ]( `8 C  a0 y" A
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
. C5 \! y1 p" x. v1 v: Wprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
- S/ \$ e( D0 f& j2 e3 Iprint(li)
5 H( |1 k  `$ O% i! L! S ['alex', 'eric', 'rain', 'seven']
* z5 ^9 f! C0 R! L5 n  G8 q' y0 fc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY'), e2 t3 ]0 C9 ^0 ^& ?" ^6 t; T
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
/ u5 j# I! `- N# M4 l9 ?/ ~print(li)
- b1 h" q) {3 g0 A' le. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']: a% o. y$ |" \  @
li.pop(1)
' h) l# r, n, |1 hprint(li) ['alex', 'rain']8 {8 i2 c5 K7 _: l
指名道姓的删除li = ['alex', 'eric', 'rain']7 p. i6 k" D6 ^& ^, m3 I
li.remove('alex')6 z* G6 b4 n$ c% Q( e5 V
print(li)8 H% y  `. s* X- R
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']* a3 K7 u+ T; u, B6 |
print(li.pop(1))
5 I" x4 e" E! p# D# P1 K  }print(li)- k" w* T, e. C: q
, |0 i. E( s7 \$ |) S. L, c0 r
eric0 v) U$ R1 }/ u: c' c8 W) d! B; v
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']7 P" i( n% o% u6 E7 P- L: K
del li[1:]( N* t; y- ~$ \* B8 F( F
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
6 W* _( N0 j" ]9 a! Ili = ['alex', 'eric', 'rain']4 ~, R. k% A* C" p& f0 M6 |1 i
for k,v in enumerate(li,1):
) M6 O3 H! D' l2 V( [ print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
$ j  A3 b) v1 Q( G: }6 ca. 请输出 “Kelly”4 e' C" t6 E$ l9 z
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]" O# ?; @6 Q  ~; w
print(li[2][1][1])0 I  n- m" r, f+ G
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”, d/ ^# V5 t( P8 W! l0 x" @. b7 _$ e
li[2][2]='ALL'
% E/ V+ e/ N, K4 ^3 R2 I9 V% `- gprint(li)
8 l$ I1 K" b* Y/ z6 g3 Y" W24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
, g; Y% l- N; L; y* h4 A6 Ua. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
8 f2 x: |# x1 [print(len(tu))
9 P! j, Y: V1 H& a: Pb. 获取元组的第 2 个元素，并输出/ K2 Q! C5 I% j; a- D1 C
print(tu[1])7 r( s. F% w. f. _4 @, g/ N
e. 请使用 for、len、range 输出元组的索引# J1 Q; K* x1 S$ k+ d; l# k
for i in range(len(tu)) :" ?. f2 w! `, e! g/ Z& k
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
( h/ c+ [5 v$ ?$ Qfor k,v in enumerate(tu,10) :* g) ^- e) W! N, M! L$ C
print(k,v)- o9 D0 B. V/ S
10 alex
6 b4 V) T3 @" y& G4 c11 eric
" |; H5 g' [8 s' Q: W: k12 rain
& X7 y7 d$ X" U6 B8 v/ L/ `, A( O& i# B, O6 d: Y
for k in enumerate(tu,10) :5 T; {+ Q7 b, J7 k6 q/ P! S1 s6 S
print(k). e$ v. ^8 i, u8 i/ m1 X# s7 f
(10, 'alex')
8 w& e5 @: R5 m: _(11, 'eric')! B8 N! f1 D* [+ a8 m' R
(12, 'rain')
0 ?8 q) i# r8 j: C: V
4 b! Q; j# q) p( |( @
, E' k7 K% f7 e6 A- Q- V. W25、有如下变量，请实现要求的功能
2 j! t7 m1 n0 Z8 q* p' j7 _8 ~* e3 itu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
4 @9 E5 {- }3 @
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以4 m# J5 p0 s6 _- t$ o) _
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
' t6 R" K) J* H( W" B8 i9 yres=tu[1][2]['k2'].append('seven')
" Q/ n* G( b1 U: {
: c/ U- N" d5 u4 c" Aprint(tu)
) P, A0 N5 W: f* N0 }/ ]# J4 ^26、字典
/ ?: p( E6 V: B% W- ]7 n1 Pdic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
8 b! Y4 b2 Q, D) l: ? print(i)b. 请循环输出所有的 value
. b* `  u% o3 m" Qfor i in dic:
1 X7 z3 n0 S$ X9 e. g5 o% Q  }3 X/ K print(dic)
  l4 G9 r5 ^$ u* A9 C5 W. ]* gc. 请循环输出所有的 key 和 valuefor i in dic:
8 c& L9 G- a' h" ]print(i,dic)! ^, T$ |  T  b  j
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
0 j( f2 C4 n2 c/ v& [% E! udic['k4']='v4'& U* _5 S. }; I
print(dic)$ ~/ ?: d( s. L3 G9 u" c1 W7 {8 o
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
" O. [- u6 s: U! D5 Jdic['k1']='alex'. D2 Z. i' U, C  X6 V
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
% I- i! v# e2 i' K9 I4 Cdic['k3'].append(44)8 p. Y, J7 `" S' H9 p
print(dic): s: t7 H/ [* ?2 z/ Q
2 g% F0 n4 M" Z/ a
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
8 G# v. d. M2 e1 p8 I, ydic['k3'].insert(0,44). S- K5 G2 f/ @: G3 ~  Q9 j8 o
print(dic)
6 o& J& B0 M0 e" f9 F& N27、转换
& v' C. J- n( O/ @& Z( @a. 将字符串 s = "alex" 转换成列表  s = "alex"9 U& q5 [9 d  `9 ^5 ]* s; G- m
$ R; {5 W* {0 Y7 Z8 D0 q
print(list(s))b. 将字符串 s = "alex" 转换成元祖2 \9 s6 E6 R9 g8 ~& O
s = "alex"
) S( v5 H/ V/ M, C) b! mprint(tuple(s))0 X+ J8 H+ F" W( K6 f  N5 b1 B2 D

' S, L8 z& N9 J+ rb. 将列表 li = ["alex", "seven"] 转换成元组
  x" C" {' Y$ E. z( E- Gli = ["alex", "seven"]
4 L$ v' @' I" ?1 x& H9 Rprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
  ]' Y4 w5 C& V. `% R# C$ Ptu = ('Alex', "seven")
1 y( L, P7 z1 r% k8 g/ }li=list(tu), y( M7 S9 ^( F+ T2 ~
print(li)
& @" s* P* K* O( V" Z* j4 d3 E. A8 D) C
- z& n* \- o( c; M1 w/ a
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
% e7 A. }' r) n# Z. b
3 M$ W0 }. n- p  @dic={}/ ^1 @2 z; b' n1 ]! }& ]% a5 ]
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面% f& G4 [/ z8 h7 b4 S
dic[k]=v( n9 [; _8 A6 |) K" H/ }( V5 N
print(dic)27、转码n = "老男孩"& I8 V/ ^4 t( T' K4 o8 y9 J+ i$ P
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
# l. A" k- `* m1 v2 I' da=n.encode('utf-8')
) p1 D4 q3 T6 B/ h2 f! Eprint(a)
' v  F: [8 b% a& I3 Yb=a.decode('utf-8')3 z- s! h" f: T; r$ V
print(b)- p$ j7 v* q2 O* x. A7 M/ J
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
9 C3 k$ o+ c: z7 x& ], Tprint(a)/ B) [6 L+ Q* v7 f, Y6 d
b=a.decode('gbk')
7 C1 N& U6 L" B+ r$ ?- P! dprint(b)28、求 1-100 内的所有数的和
" B9 ~" u' i3 C( Jcount=1" A! K4 \5 {$ y5 s+ W' X$ x
sum=0( K6 G# a- N7 g: U
for i in range(100) :" s. F; [7 ]6 Y8 j; @; O
sum=sum+count0 U2 t1 C9 G6 W& n0 P8 }& }8 @
count+=15 v% {, y2 R" Y! K8 \! J1 h
print(sum)( Y. a0 x5 E3 a, o; U$ ]9 p

, B/ [, a$ F1 N4 k% |" K! S# Gcount=1
2 h( s9 |* R* a) D) Psum=0
6 K  B: C* U, K2 Q% qwhile count<=100 :
/ f' ^0 b0 {" \ sum+=count8 C. ?9 m$ e3 V& V* {; w
count+=1
: L* J% u# e7 M6 `2 ~% zprint(sum)29、元素分类
. W/ f2 l# Q0 j1 e有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
/ Y: q8 D4 N7 u- r将小于 66 的值保存至第二个 key 的值中。! i* A5 K6 w' \1 B
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
9 {/ f+ J$ b! E( P: G" B% hli=[11,22,33,44,55,66,77,88,99,90]
8 X2 ?/ U) c+ s8 M1 P  m2 edic1={
: k" I$ w' z: o$ F1 v, E, j 'max':[],* T- n& R0 F7 E! H
'min':[]
* w: q# w+ P& X2 }0 ~* [}( B9 y. s3 `0 I, Z2 C: F
for i in li :
7 R7 K, i9 J* y4 R. [6 Q! G8 i! @ if i <66 :2 E/ S, l4 P/ u( _- h+ R( L$ p
      dic1['min'].append(i)5 T- Q" Y& b6 {+ Y2 S: ]- Y
else:
* \; }7 `$ K. S       dic1['max'].append(i)
4 P* e( l" Z; T0 m/ D2 J8 D( Fprint(dic1)
  Y3 m" c2 t" d) {+ R6 u
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}6 Y7 C7 n" b) Q. Q# w2 _" u) H

Python基础知识汇总

主题推荐