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、写代码
& [/ i0 |% l: h- r8 Aa.实现用户输入用户名和密码，当用户名为 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) :0 n. N0 S) Q! l
name = input('name:').strip()
/ ^; K  Q2 V' f; ~/ G1 s; L* [) ]3 F pwd = input('pwd：').strip()/ y& X4 U( S9 N! m" I. U
5 ]7 }3 J+ e+ j, D- e0 V
if name=='seven' and pwd=='123' :
. a* I: W  ~. c/ F& f       print('ok')7 W0 Z, ?. C0 j5 n5 c$ x/ b
else:; m3 _% t8 H4 U1 Z3 y
      print('error')
0 h7 C- g( O' G8 o9 Q6 c- ~, ~       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)  :8 \5 S3 n1 O% x% U
name = input('name: ')9 `' Y/ F: r' w" u4 T5 R* t
pwd = input('pwd: ')
3 [2 D7 U* p7 K7 D: k7 c2 D' T if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':9 ~  L' o1 q3 I9 L5 h9 j% x
      print('ok')
. H/ m- `% g! u8 B# K0 V. h else :0 j) O8 x; G3 t+ w2 Z( D
      print('error')
2 n; J) ]  f0 y& N% i       count+=111、写代码
% O9 D4 N3 D0 T* Q; N/ Ga. 使用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) :
% c; i) w) D- `$ W; S  } if i %2 != 0 :7 C& t# v. q" 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) :
2 y8 |' v$ Q: T" _0 Q% p$ l if i %2 == 0:
0 h1 `/ d' T7 P' b       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"$ K# v8 i, e' c. w% ^1 U
a. 移除 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 a, }$ G8 z. o1 S; Nfor i in name:6 n6 s4 o) g7 p' J2 D; e
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
& b5 p6 r/ ?! b4 O6 \22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']. R' F/ I% K8 u/ Z, Y1 i
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    3 i. Y& I" `; K7 G6 U( _& p- ]/ D
print(li)2 n. D6 y1 F  B. S
['alex', 'eric', 'rain', 'seven']- [2 e# n% u- e, ^* @  y
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')# g) t1 l& |0 ^: m( r& m
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')0 I. n8 |. z: `/ }5 `2 N
print(li)& ~8 e( s: X2 L
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
6 Z( `3 Z0 }" bli.pop(1)
9 A# o5 ^8 b, ~print(li) ['alex', 'rain']
' u: n; p7 l1 c& }8 A3 D指名道姓的删除li = ['alex', 'eric', 'rain']8 Q! R2 |. W% J
li.remove('alex')3 U# ?) `" Y: M* K
print(li)/ F+ w8 h' p8 R& @
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']6 V2 x$ _. n) \6 N! E* @" o
print(li.pop(1))4 O" q# P; r+ U$ ]. F+ ]
print(li)
. Q. i% ~& k- f" e
6 z1 x: R. c4 O6 M1 z2 }# Zeric3 m# Z. j$ e1 h! U& G
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
7 c/ N! K5 V$ c! x9 r' ]9 Ndel li[1:]4 P1 q. K! X6 a3 t5 `
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始). P7 N* x9 F  W  U
li = ['alex', 'eric', 'rain']2 q: z; C+ z! G
for k,v in enumerate(li,1):6 I, ~) @2 p; C, p; k: K* N
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
: N# v1 t2 U: \3 d/ R4 Da. 请输出 “Kelly”( h# q7 M; ^" B0 ^8 W- [! q% l
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
: J) ~: D: ]- w+ ^  J$ Xprint(li[2][1][1])3 m. e% S. _8 V/ O3 O
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”1 B; Q) C% g# M1 |* M! y* o
li[2][2]='ALL'
% Y" q2 P; M. L7 H5 Pprint(li)
. ~! W: i5 `1 Z' L+ r24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
: R+ H/ M5 Q- A! i2 Ba. 计算元组长度并输出tu = ('alex', 'eric', 'rain')9 ]2 g- p& f8 [
print(len(tu))
- O1 r! \6 \$ u: ]b. 获取元组的第 2 个元素，并输出) @3 W; q2 c2 c; O
print(tu[1])
7 x  n4 N: m; h( P! je. 请使用 for、len、range 输出元组的索引
& i. X9 k! R6 V: g- C+ t6 Mfor i in range(len(tu)) :0 i* s! x9 z* r( P8 z6 b0 H# \, W
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
. b1 i# Q5 }4 I1 V0 M/ a2 wfor k,v in enumerate(tu,10) :" U$ ?* F  j% o# v
print(k,v)5 I& x) K" n& {0 F# Z, R
10 alex2 w5 B4 \$ Y# y2 Z: n& [6 s& c
11 eric* U. s4 C$ L" p2 w8 `
12 rain' d% w7 u" H/ N3 ]$ V* U+ E

' ?4 y% K4 h. b% x) d# ^6 p5 Mfor k in enumerate(tu,10) :9 ?3 u9 a% D( r& t
print(k)6 j- i' Z* L! k0 [1 ^# a3 b
(10, 'alex')' q6 h4 I1 F' B( j
(11, 'eric'): y9 Z/ [/ d1 h" }
(12, 'rain')
3 h; @3 x* z6 d
$ v8 h1 G  ]& J6 K* S# p; ]: k# J, t2 I1 ]3 \$ V0 s
25、有如下变量，请实现要求的功能
/ z- `9 x/ T% u1 @, n. y" a+ rtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

  F. O8 u6 O4 k& T9 \' wd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以) y6 \: M! @7 V. B% H; k7 F
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
! S4 d, t' q4 x8 f# bres=tu[1][2]['k2'].append('seven')% T) m0 b9 H' v& a- ^
/ @1 T5 B; c$ @
print(tu)
1 L. b" a$ m2 i3 L3 S26、字典
$ l% S1 c" g+ q( |8 P2 I" r9 C8 }) ddic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
& D% f3 ?) ]/ O/ q: j) w* C2 m3 y print(i)b. 请循环输出所有的 value
" _- s7 B6 H% d; `for i in dic:* g% R- I, J% O* \
print(dic)
( }" U, a& A' B) k' pc. 请循环输出所有的 key 和 valuefor i in dic:7 M) x, t; X2 h1 Y  a
print(i,dic)
- s& A" P; `; p1 S  N! m  k: c# Rd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
/ ?$ |8 I8 @# l7 k2 R3 x- {1 h9 V2 jdic['k4']='v4'
+ R3 H: [- V. B/ H6 Uprint(dic)
; a9 f" C: u. p% v9 P8 j8 d0 U. {" ie. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典  i/ ~- D- T+ m& p5 f
dic['k1']='alex'5 K( M" z) c8 k
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典. r: K4 H# g4 T9 m+ z1 I( [: d
dic['k3'].append(44)
! E% v( d8 t1 |/ q9 fprint(dic)
2 [; |& Y) Y$ H; s
2 _+ O0 }' B; ?+ y% kg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典# R: s7 U( h: `$ w# J" b
dic['k3'].insert(0,44)! n" V( r& `3 A4 O: y
print(dic)
2 v( O) l: M; L" O4 {. E' K27、转换
/ d& }9 Q# j5 F7 `' w6 h" Wa. 将字符串 s = "alex" 转换成列表  s = "alex"
; f; Y- l* d3 C! u. f' e- k, f" e* z! }) @8 K. W
print(list(s))b. 将字符串 s = "alex" 转换成元祖
2 e9 O# n$ Q' T) v! us = "alex"
$ q% b0 L+ Y: T9 Q+ c; ?, b" ?print(tuple(s))( {) a: z1 O2 }5 n1 }8 p% F* ^

* k& H3 k0 W: \! y0 \( P) eb. 将列表 li = ["alex", "seven"] 转换成元组
3 ]6 W% Q1 d% K; d; v, n9 Pli = ["alex", "seven"]
# J7 Y8 B0 J/ K% r- fprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
; N* u6 @' ]; Ktu = ('Alex', "seven")
9 Q0 E/ |8 v; N, Sli=list(tu)
( u% Z, i7 P: wprint(li)
. M% \; R1 _! @! O, c, T0 n% Z0 e. R8 |  c- \- a1 J' l  \
1 A9 h6 O2 S" D5 w% j, R/ t2 J
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增0 `& x& y# g( m" P' g: Y9 s3 r
- y1 ^8 P; M3 _8 w0 t8 T& F
dic={}
- t: A9 B% P! l0 L1 P" x2 e: Bfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
: i( W* F! `+ v# `  X; s dic[k]=v5 ~2 x' Z/ g3 [# f
print(dic)27、转码n = "老男孩"; A0 N1 ]; w1 o. R! U) q, Q6 E
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
4 y( w& \* O) w* X) |( V0 T" h! C. Ja=n.encode('utf-8')
: _  t8 S' }" d- I) c/ u9 Z/ _print(a)1 D8 M) ], a' P; }, ?
b=a.decode('utf-8')6 `+ k5 T0 o, i6 H% u
print(b)
, U3 d8 `/ @# `$ {1 ~1 L1 F* S+ C: O- Mb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk'). v; s8 b' x, Z% {5 M& F/ \+ y) Q
print(a)
5 S: k% ?! i% i" R7 I3 P) Mb=a.decode('gbk')
3 d% B1 {% P' J. y( kprint(b)28、求 1-100 内的所有数的和6 g; Y/ o6 W- f5 o
count=1! D8 O7 h% X6 {% i; K& x
sum=0
& m- S8 a7 g* \% e% J3 a% a( Gfor i in range(100) :* ~) b9 ?% h4 M$ |* b, Z
sum=sum+count
, `9 H8 I1 H6 G count+=1
' U3 ^: c' o, k  [- [: Qprint(sum)+ N) f$ C: p0 H8 i* ^

5 e7 a  u% z" D  a3 {, N8 t2 hcount=14 L$ O1 F7 E1 y# Q6 G6 |/ I
sum=02 {. ]& R5 ^+ ]) ]$ [/ J
while count<=100 :$ H2 K/ R2 Q9 W% z3 y9 j; A! A
sum+=count7 R% m) j) A! A6 p+ f8 i: B
count+=1
( z! |3 X# f( hprint(sum)29、元素分类
; q( U; ?& ~  F3 }( t* z有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，) d" {5 Q4 `& b# _! O
将小于 66 的值保存至第二个 key 的值中。* f" R3 f3 y9 _6 ?6 _5 e% }6 X2 s; O6 M
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
  K  \0 K& c$ w0 Wli=[11,22,33,44,55,66,77,88,99,90]
6 o4 q" ~' S7 n- jdic1={
0 e* ~3 g: l+ N$ V9 N 'max':[],
6 v7 s: D- |4 g, y+ ? 'min':[]
# V2 B/ G8 x- l! K2 f- t}
8 Z) w: T2 w! E5 kfor i in li :' p" R1 z: m8 q( _
if i <66 :
6 |  _: y! F: k5 Q( r       dic1['min'].append(i)" `  P9 h  H+ F; ~0 {
else:
7 Q& [+ y! Q% Q       dic1['max'].append(i)8 c  ^$ U" }; n2 x
print(dic1)+ @: `# Y6 v+ f4 M; A& v
' j) x) a! b% S: w% v1 r+ s# X8 P- K7 o
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
$ j3 Z8 D% X- u# T8 C

Python基础知识汇总

主题推荐