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、写代码; u" g8 f  z6 T: N+ ^! R$ l0 U# o
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) :/ u. I9 M7 J2 }. ]8 ?
name = input('name:').strip(), I" _0 l& F; \0 a: L- s5 f
pwd = input('pwd：').strip()3 ]0 g) ^1 s, V% I% @# S

0 _% a6 |. y4 u: D7 C* j- @ if name=='seven' and pwd=='123' :: K* y0 u  r+ r# Q
      print('ok')
' R( n' X3 G- \2 i  q  _ else:
9 _: o- S% l9 M& y( u       print('error')7 [) P, b. u3 w6 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)  :2 v% F9 h+ g. f: j! @
name = input('name: ')
5 I! A. k. a; l+ d, U2 \0 D' T3 h: ] pwd = input('pwd: ')/ l! g! t9 p9 c1 A6 q/ T
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':; I6 ~( j# }7 E" w) X
      print('ok')
9 i5 J2 ^' I' b else :3 x4 Z$ u1 o1 I
      print('error')# L; v6 e9 i8 T& J
      count+=111、写代码
$ n/ a/ J- R' O& m9 [: k6 g' ma. 使用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) :
# ?! V/ c  t0 S- k& X' p if i %2 != 0 :- b! h2 y4 z; V& |
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
+ c# p7 P, q$ n& O1 j if i %2 == 0:. Z) L! U/ t1 u
      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"
& \' e- z* p2 a/ H8 t/ N5 X8 Z0 P8 X* ^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)
5 f- a- P; E7 zfor i in name:  k, r% G  r: F+ i# ~
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain, p4 f% e+ h7 F3 }
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
+ ]5 @6 O- v- r/ zprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    5 _+ d( }; R/ Y; V) o2 a
print(li)' W; u' G. q& Z, _' f
['alex', 'eric', 'rain', 'seven']
2 U, n0 T1 V7 G0 T. C4 @6 Lc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
6 B5 f" o6 S1 P) c0 vprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
3 ~; P/ [  R: g; Eprint(li)
1 A; L2 m2 u. Ie. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']" F% ~5 K- D, a/ o3 B+ Y. ]9 |
li.pop(1)  ~5 J, E/ Y7 q) I# k6 l
print(li) ['alex', 'rain']/ h& b6 h3 Y+ U+ q
指名道姓的删除li = ['alex', 'eric', 'rain']
; C& a* e2 {/ U, L3 w' g# j, X& Gli.remove('alex')% T, ?6 p( ]; L
print(li)
9 q# G+ \/ u2 H4 W6 Cf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
6 f" D( n6 ?' R) H+ kprint(li.pop(1))
+ c7 y$ W7 w* g7 O, Z+ r5 aprint(li)
) [# i0 F. Y8 w2 u. _9 V; @+ V( U
( M% i- ~: t9 h" z( Jeric
& P4 Y6 e1 L! x% d* O3 R! q['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']+ y5 ~$ I6 K1 k! ]6 h$ X- Y
del li[1:]
8 N4 s* O, R; W. ^" u4 N- [" d0 [print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)  A+ ~+ m/ w) H9 j0 _4 q
li = ['alex', 'eric', 'rain']2 L' F3 k( l: G6 M
for k,v in enumerate(li,1):
% M) c: U. E+ Y, g% ? print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]) e- _3 E" {, h
a. 请输出 “Kelly”
  ~) r) z2 l2 ^li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
9 Z( q1 a5 I! Z0 zprint(li[2][1][1]): j& ?2 Q: B3 J2 M
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
; ?1 W! x) M9 h6 N$ I( s5 Wli[2][2]='ALL'+ t/ S! i5 k3 X* Z8 k4 l/ {! _( P
print(li)
# w! A7 k  G5 _0 [24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')2 C& N/ E, k- E5 `8 [
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
" H* Z: w) v3 u. U9 Dprint(len(tu))- E8 Q3 j. k. z, U5 H
b. 获取元组的第 2 个元素，并输出
" x2 r% p8 [) K1 O$ Cprint(tu[1])# f; H8 G! v4 v- L- e
e. 请使用 for、len、range 输出元组的索引
, D2 h5 a6 D+ t% @, r  ffor i in range(len(tu)) :
. ~8 L* d8 P. A% z9 e8 T) M& E9 l print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
+ w% A& ?+ ]* Sfor k,v in enumerate(tu,10) :4 p( J2 ^% O. U: E
print(k,v)0 @1 Y0 M% `: q
10 alex+ U/ y/ B; X4 ~+ ?4 U% ^( S
11 eric6 R5 d9 |, ]: L- }; Z* t
12 rain
( j: S, ?3 k6 P4 h% E+ }# N! x
: X) C  M( ~* c( J$ t6 ?; U7 e* Ffor k in enumerate(tu,10) :
0 N' e" f1 T9 x: u" _8 }  c print(k)
9 n( I2 z- Q( }4 N! c% ?(10, 'alex')
' n9 ~7 h  H3 J- x) k(11, 'eric')# y! [8 a- |+ J+ ]' z. v- y) q& N
(12, 'rain')0 K  q# J& ]- t3 p8 v: ~* e

: u0 H3 a5 s' |" h
: a* g; w7 t# W& m6 E* A8 K25、有如下变量，请实现要求的功能
: {5 ]1 F; U" f7 ltu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

& X. \1 ?& [. Y! b: T4 p1 kd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
9 \* N+ O! U4 ]8 K# p3 |! Y6 ttu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
# Z) h4 N( \  o6 Hres=tu[1][2]['k2'].append('seven')* U- d# @6 _9 a) [8 \- F

, k/ Z" v: o( M; V2 h. O0 ]print(tu)" |! B& F- L+ r0 u  Y. }
26、字典
7 O7 D, H& A# m( F" i3 ldic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
print(i)b. 请循环输出所有的 value* j# k: `" |: b/ x8 Z. y& O
for i in dic:
3 Q/ D2 N; {  J( v( \8 w  o7 l print(dic)$ y- n) z8 d' l& Q& E" p
c. 请循环输出所有的 key 和 valuefor i in dic:
$ J0 l9 j9 H* o$ {; P$ tprint(i,dic)
6 r6 k* T/ K; L& j: l# a) yd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典7 n$ `6 n6 ~) a( T  G  K7 o
dic['k4']='v4'
9 [: d" ]; X9 ~1 M  ?: pprint(dic)/ E  C5 @3 w) k% W% m
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
0 m5 a8 u0 q) p2 \3 gdic['k1']='alex'
; K2 l! q% [0 t  s& Lprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
' f, u0 U0 m% [# v- Tdic['k3'].append(44)
/ ?' [) D% y. B2 }+ cprint(dic). n* V; o/ ]3 T9 p& i7 {

' f; s& E( }1 s' A0 _0 [g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典0 ?( {7 n3 @( t& `
dic['k3'].insert(0,44)! T- f9 l1 N. t. `6 e5 I" x& n
print(dic)
% M" Y6 Z3 D2 R' r2 O27、转换1 \* C! |9 T6 V, Y. b
a. 将字符串 s = "alex" 转换成列表  s = "alex"  w2 ]; B% F6 l  h2 y$ A, P
6 Y3 L* Z9 s9 O" ]
print(list(s))b. 将字符串 s = "alex" 转换成元祖) U6 D8 Q7 l: o3 Z! K
s = "alex"
. v6 \# E9 N0 u% X- b1 f6 n3 lprint(tuple(s))
8 ~" T6 ?. d# t% s: K" e
! `5 L# F8 K1 s6 {$ M% k7 ]2 nb. 将列表 li = ["alex", "seven"] 转换成元组
7 A7 ^$ n4 d, H1 ili = ["alex", "seven"]
' ~$ O* P+ F9 N! Y( Pprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表7 F- K7 G, m3 N) a& y2 a* [) q5 {
tu = ('Alex', "seven")- z& w& p3 Q# P
li=list(tu)5 K7 X6 h7 L& V' f2 L/ G- Y
print(li)
3 ]# i2 @) Q* @) V+ `9 e% r
4 S/ c: X+ h% W- u! W/ P
1 M; ~& s, ]# t& Xd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增% }1 ?6 Z& ~6 F2 h( C3 I

5 |+ a# K& v2 }dic={}0 P6 x1 K' C) `! p
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面& r# h1 T6 l4 \
dic[k]=v+ \. z3 \( l8 Y! D( N
print(dic)27、转码n = "老男孩"4 O7 Q3 h  b6 |5 M9 g  E1 f- r
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
5 _/ l3 z- X; xa=n.encode('utf-8')
) ]: _! z* f0 R/ Y+ wprint(a)$ ]# h3 @; s/ o/ G
b=a.decode('utf-8')
6 K, d/ B9 b3 G- E( A( E; Jprint(b)8 \8 [/ f( W- o6 @2 C2 V8 _1 \! h
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
) b% r- \; n1 G4 Z8 qprint(a)
' F3 m7 E2 d' wb=a.decode('gbk')
+ }! @, o8 J* S" L5 T% vprint(b)28、求 1-100 内的所有数的和! S4 g; {: }' I" ^" x
count=1
. j% M  B, Y# B9 q3 E8 c. z& a- msum=0
& S; W/ d% U% ?4 _9 F2 _/ P$ afor i in range(100) :1 t; N1 B" B) k& f) L) o
sum=sum+count0 M. l) p; Q* b6 I' u: O
count+=1: \6 K2 U# U6 e& {
print(sum)
# \+ G6 z0 {9 I" C- o7 S  p# W5 D# |  B4 d. Z2 c
count=1  @8 J. W* ~( P2 s2 r) X: ]9 H6 y
sum=0
7 P( r/ N. f! n. O. {9 `7 B2 Hwhile count<=100 :
. M; H% m9 P+ u/ ]5 H sum+=count! t3 l1 {7 [6 z( D2 ~
count+=18 m5 I; P0 P6 s$ D& z
print(sum)29、元素分类
' @* M" q5 e# c( Q/ w有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
4 v8 ^4 L& [, ]+ E将小于 66 的值保存至第二个 key 的值中。" ~* r$ `, L: B
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}* r- k* ]8 |* T) E' L) e( `5 r
li=[11,22,33,44,55,66,77,88,99,90]# Y' r4 {* x: m
dic1={
9 \) E4 i( Y3 n% y1 |. P4 h& y0 c+ R$ _ 'max':[],
% @, V, Z; M' f8 ]* X6 X) O/ } 'min':[]3 A2 ^$ \0 W9 B" Z5 o, E7 [' ?
}, m! b( W7 A/ f! p/ \0 \
for i in li :
: O* @0 B; B; a if i <66 :- t+ k2 n5 L. N+ {  N( Y9 g1 E
      dic1['min'].append(i)
; w+ r6 S8 O1 a: b0 n) o/ l7 B else:/ `) @2 C0 g5 n* J. |0 {
      dic1['max'].append(i)9 H0 v$ E4 V" I, p. }5 V
print(dic1)6 A! l  A( y6 w8 F% R' W% j
; q+ k% F  u: c( d' B  k: |
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
2 p  _5 U1 [8 @7 y

Python基础知识汇总

主题推荐