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 p6 q) S3 {2 a! b% R
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) :
  D+ j8 j, J* B: k/ V/ } name = input('name:').strip()
# [$ x/ H, q8 x6 e/ p1 L pwd = input('pwd：').strip()
. N; X/ Z4 W+ z% F8 a% e7 P( t+ l- v5 j: }% q2 e; E
if name=='seven' and pwd=='123' :$ h9 N6 o- ~8 |* U) k
      print('ok'). Y6 B# K% f3 w
else:
; G' `( }/ D( a2 N4 k- |4 j       print('error')
! Q* y! t/ g0 F, `  n* D! D( [       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)  :
! B* W8 x* q4 @1 x. f2 n name = input('name: ')
. {9 Q4 F! c& L2 C! M& k pwd = input('pwd: ')
9 j0 ]& g+ P: a" X if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
1 Z# T. T0 T0 F' s  d       print('ok')* z+ z* C9 |  I4 l9 {5 i
else :# C2 {! `/ I& M$ H
      print('error')
0 ~% c: U9 ^- N! J6 O       count+=111、写代码
0 U& V2 }( J* P( e' X  |+ Sa. 使用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) :
; U: X5 n1 w7 g, L; _ if i %2 != 0 :
6 H+ }1 I2 ~/ P, b! r       print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :; W1 Z4 M' f) C
if i %2 == 0:9 B, o: I$ o9 T( c
      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"
7 U, U& t4 I1 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), d0 Y  k' b9 \: J
for i in name:
- s% |0 Y: p  @8 W, Y print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain. `$ m* `! F' Y
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']$ e8 o- T1 {+ K6 m) y
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
( X' o3 ]9 a! e  {1 J+ }print(li)
) x7 l, P# Y5 N6 w ['alex', 'eric', 'rain', 'seven']4 \7 B" j+ w+ R. O2 e
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
* n' i5 N; \* ^8 u! E2 Iprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
" J" {, q6 O6 }, I, M& N: `print(li)6 ^' Z# Y7 E" Z" G& k
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
" p6 ~+ L' j; t! Oli.pop(1)7 E; Q, J! x3 `6 V3 w
print(li) ['alex', 'rain']
指名道姓的删除li = ['alex', 'eric', 'rain']% J8 w1 P5 `. r, N' L* s
li.remove('alex')
+ Q6 f+ G0 e( T! n" p! o4 Kprint(li)* U. ]% x& X- ]* \
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
% J9 T& v2 x# M( y: X/ p$ fprint(li.pop(1))
) N  T. b4 h) p3 j2 H7 c7 k1 B/ Hprint(li)
. _1 c' [4 F6 l7 x. H" i/ z# [' S; V9 d0 H9 e3 |+ B) Y7 ]
eric. c4 _# E, |& m9 h' W! ^
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
$ n7 ]! o9 {+ w2 s) Y4 wdel li[1:]: N8 R& T" _( n2 v6 x9 u  ^
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)- o- J" I: b% P! D9 r) w5 A
li = ['alex', 'eric', 'rain']' y+ @! H. g$ W3 d4 N" L9 h! Y
for k,v in enumerate(li,1):7 Y( m- W8 ]* `& a3 {) ^! r4 Y
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
0 U. `) O* V/ ]8 K# l- }% t* X/ Pa. 请输出 “Kelly”, P% Z+ Z$ S7 h) x
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
+ N1 t' m6 P6 y/ l/ r0 Y7 w0 Tprint(li[2][1][1])
+ x; F3 ?+ N5 Y7 d3 V# }4 Z" q% Y, {b. 请使用索引找到 'all' 元素并将其修改为 “ALL”5 r+ }8 d% Y6 L" x2 f; j
li[2][2]='ALL'% z" I% w, ], Y" s  {
print(li)
4 l7 y/ ]0 L( A) p, g1 S5 V24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')& Q* A. G  _' J& N- |4 o4 Y! V# l% c
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')7 B, A% |* T1 j' N7 ]  e" X- u
print(len(tu))2 b5 g+ k# J( e) @* z" ]; \
b. 获取元组的第 2 个元素，并输出) J2 X" s/ R5 R
print(tu[1])# T7 S: {/ l8 J4 _
e. 请使用 for、len、range 输出元组的索引
; t, C' [$ I+ C% N8 \4 v/ V% @for i in range(len(tu)) :
$ _+ n: T6 l" X- D$ ? print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
8 u2 m4 w) x; {8 l  ~for k,v in enumerate(tu,10) :3 p7 e) \: Q8 a# o7 \
print(k,v)$ a$ ]6 u: l% C2 a. @+ @
10 alex- `6 |9 M$ p5 j8 B3 Y) K
11 eric7 c  v  s; r, ]# Q7 i5 ~
12 rain5 B/ \0 w$ _- h3 P
1 i6 F' m( C. X) C4 E% R
for k in enumerate(tu,10) :8 r; c$ Q0 {& P# a2 v
print(k)+ d- s- {" I6 b% n3 {: [* {
(10, 'alex')' o- L( V9 T0 ~" z4 a! |# }8 M
(11, 'eric')
% H. |' @* s1 P* e(12, 'rain'); l/ ^8 G6 ~" l4 Y- F& a( d

& f4 Z+ ~. e$ Q' R5 B# ?
4 n& v7 l# d% u& s% H& r4 ^" i2 f25、有如下变量，请实现要求的功能% B4 y8 V( C" Q7 E$ M& n
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
1 t# @( ^5 S( c% b0 `% h
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
  h5 s8 g& P9 R. g: e1 |* `0 @. @8 btu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
+ |! E1 l  O: G  b4 g- @7 N1 Ares=tu[1][2]['k2'].append('seven')$ q" A: o8 @& P2 z) X/ B

5 ?& y; y+ _* {- j, ^7 j! cprint(tu)# D. j& t/ d6 k6 \* [* H
26、字典8 K. D+ B0 p8 l6 Y' @) D9 P9 ^
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
: S4 y& n# ?- I6 v  m' O; `; W5 ` print(i)b. 请循环输出所有的 value8 W; b8 p, D7 i6 D3 ~
for i in dic:
! {- h) u2 z; j' Q" E: f print(dic)
$ ^4 ]6 p2 O7 o# J5 uc. 请循环输出所有的 key 和 valuefor i in dic:# W; u' b5 h% n
print(i,dic)
# l5 V8 |! j  w, P4 o' U5 md. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典7 b- `( j; z# a  g
dic['k4']='v4'
' H1 L9 H  q0 b" X- x1 E' ]print(dic)' q/ @$ n% G$ K% r
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典  M4 B  b# o/ S$ u0 a
dic['k1']='alex'3 v& K; s+ V* c& m
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典. x% S% E# q: d- v9 v/ I
dic['k3'].append(44)
: o. |, H& Y  e$ j0 v0 D) q- kprint(dic)
: R# |, s6 Z/ L9 B9 v+ l' n2 z- K0 N4 ?) a6 h# z
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
( Z3 _4 \6 H  ^6 f; }dic['k3'].insert(0,44)! m3 x7 x' y" Q  d
print(dic)
5 ^1 `  I) _1 o27、转换; x# @* J, n# O1 y% L/ c) X  W
a. 将字符串 s = "alex" 转换成列表  s = "alex"8 C6 c8 ^% U* }: B; W

8 \  W- ?$ P: K# ~1 v( tprint(list(s))b. 将字符串 s = "alex" 转换成元祖
/ M6 h# B' F4 a% ^8 R$ [4 l5 G$ Zs = "alex"! _: _$ G8 X3 L; c: T* p3 S* r
print(tuple(s))2 j: g5 H( ~. E3 M
) C  t; N+ h6 ~
b. 将列表 li = ["alex", "seven"] 转换成元组  e, e. w; _$ n
li = ["alex", "seven"]4 P+ h4 y) S6 J
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表  j: G* v# f9 ?1 i( g
tu = ('Alex', "seven")
4 z3 {# I2 n& b, ]$ \9 N' sli=list(tu)
% {, h% ^  x3 W2 Zprint(li)4 \1 T+ j9 Q: c& Y3 {2 h
" n/ f  ?7 A- Y0 s' O8 u

5 p, s+ B) N1 G/ k6 U: Cd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
# z  ]8 o- A+ ?0 }5 q1 N/ @1 z: y1 U3 W
dic={}8 ]8 S  I' x/ {. X
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
$ E0 v. H/ U. {, n dic[k]=v6 B$ c+ L7 k% O2 E* @
print(dic)27、转码n = "老男孩"$ r+ T& Z0 @* Z3 z1 U& G4 G
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"8 J7 p0 Q- p. _. u
a=n.encode('utf-8') ' S( Q, p# Q: L4 q9 a2 ~
print(a)
% Y8 k: |4 L# h2 \4 e0 ?b=a.decode('utf-8')) Q/ n; C3 W! r4 h+ b
print(b)
' w- j/ g+ m% [/ Qb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')' y1 S) {, w2 c. ~& l8 O
print(a)- r5 N# a  G5 q! ]
b=a.decode('gbk')' O  j  y  X7 w* }; x
print(b)28、求 1-100 内的所有数的和
( l+ P8 ]9 [9 {, ~+ H7 j# i4 x# ]count=1( {. ?6 t2 A# w5 C  Q" z
sum=03 D: U6 a4 A: `9 l2 W
for i in range(100) :* B3 m- K( E1 {  V
sum=sum+count
0 \- ^, M7 q& Y4 ~; D. }5 F count+=1
( B2 j* c; L% L+ sprint(sum)
9 k4 u- M( E7 m" A6 F: p
1 q, g& h. u3 [* X. ]' |count=1) U5 w# V+ q+ r+ u: m
sum=0' B! N. R, G. ^) N! c9 r* ]
while count<=100 :. @) T1 }3 D  G7 n7 n7 \" H
sum+=count
; A9 |4 y5 t  G5 Z count+=1- S; v+ \# h* ~. m9 D) Z4 e
print(sum)29、元素分类
/ B  e. o( i4 I有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，4 D, t3 o- {6 U% Q& z* u
将小于 66 的值保存至第二个 key 的值中。& }  F4 S* s  q7 l. ?3 c
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}8 k5 |' P# |  t0 R$ A
li=[11,22,33,44,55,66,77,88,99,90]4 v9 J- _% ]* R5 \, m6 k( x/ C
dic1={% R9 s+ c& [3 M2 G5 A+ O
'max':[],0 g7 x' B% I5 H& |
'min':[]- t0 A+ g9 i- a- z
}4 _: w# E. m% i/ B3 y+ g
for i in li :
6 R- W" |5 m& x/ \$ { if i <66 :' |$ B# K' d! R2 E3 H! b, d
      dic1['min'].append(i)! _1 Y- q9 @- K
else:4 c* o# C2 R- L  t2 E
      dic1['max'].append(i)
, n5 O% S' o0 ?print(dic1)$ P. n2 j6 Q0 D! }( Z+ H
# r2 c6 @* h# @& J7 y0 J
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
- R( q( M. l- d' _/ I2 B$ _

Python基础知识汇总

主题推荐