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、写代码& W, E+ b$ ~; p: H
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) :
7 l; }4 z, Y& K) E; } name = input('name:').strip()0 y0 {6 ?$ ?+ V7 q  ]
pwd = input('pwd：').strip()
& ]8 \7 j( m* f$ u  ?& v- e" t6 |, V$ V! G  K6 r/ S
if name=='seven' and pwd=='123' :0 Y+ ?1 k7 L5 F" P' L1 V! Z
      print('ok'), g/ @$ Q0 h2 t1 h) S6 M
else:; s6 y5 Z; I" j" p
      print('error')% S* E( g# f, {, ]
      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 J; ]6 h' b$ w! }" O" h
name = input('name: ')0 U. E3 U+ U0 N+ k
pwd = input('pwd: ')+ i+ c6 z6 v+ _8 H; n! p/ W4 }' a
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':7 j5 t1 \% p$ H- M/ }* t
      print('ok')# z* C! g1 {, H5 s
else :
$ G% _9 B/ f2 ]       print('error')9 v" D6 N# f; J7 o4 o3 f" d
      count+=111、写代码( a( \+ a) {1 h; ?1 S7 K1 n/ Q4 F
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) :3 F0 x) I2 g( q; C+ y& _5 q
if i %2 != 0 :$ i0 M: p- n/ h! s* x7 O$ R, q
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
* O9 m, g& N5 I2 v. |3 O, v if i %2 == 0:7 |! e# ^/ c5 u- h* |* z
      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"
5 A: w/ b$ J. [2 H7 o6 o& 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)
. x4 P2 l. J0 y+ E( a/ ifor i in name:. W$ I% M& i2 A4 m
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain, f0 X: N+ K( ^0 ^1 P) R
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']& t2 L& y& R" G3 R8 I* [: \
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
5 w+ h# }! i/ B# s- r1 l* xprint(li)6 m- [# D+ h2 i- B0 h7 [! g3 n2 z
['alex', 'eric', 'rain', 'seven']
9 x$ H7 ?  L" h& h: x! b( ac. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
. P8 C1 s% i! \0 w& xprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
+ c9 w1 i1 z% j+ v: X0 iprint(li)5 W$ a$ k! t  K  _' f$ \5 B8 X8 S
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
3 r+ r7 _! }# F* I) ?( e; s: j. Yli.pop(1)( F% U2 \+ }9 Q# v  W5 R( O- C9 l
print(li) ['alex', 'rain']# k+ E8 \6 ]8 g9 U
指名道姓的删除li = ['alex', 'eric', 'rain']( j0 Q: V, H) h! B& [% c
li.remove('alex')  c0 J/ |  z* E; B2 |) L
print(li)
3 J' j1 g2 ?) G5 ~; Hf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']* ^! `$ J  }$ e
print(li.pop(1))7 U) `. W2 y1 W. o6 m& }& O5 O
print(li)
( u2 U9 Z. m' [7 Q
5 d/ F$ K: c3 ?7 feric
( E, r" g, Y7 W0 z( M) X( I['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
1 K* ?$ d8 F7 r. L6 U! u& T0 O0 tdel li[1:]4 U$ Q5 j6 N. k! u$ q
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始). z, D3 R' j0 W' ?. D9 A; ]
li = ['alex', 'eric', 'rain']
- n8 k) t* c  P' hfor k,v in enumerate(li,1):, D( ]& H4 {: F2 b
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
( C5 Y" R' N$ ?' n. ~+ Fa. 请输出 “Kelly”: ^) d+ P- k9 k6 V% C) |
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
) Q/ O( V" D5 Eprint(li[2][1][1])2 m. b) y: d) T5 k. P8 p1 a$ g* |
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
0 d7 a2 B, r9 fli[2][2]='ALL'
& e0 h: m% K' X: oprint(li)
) ?% {8 H/ d4 c/ d( [7 ?$ i0 T# U# ^. N24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain'); y  Z: e: r2 a3 o. u3 C
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')( e4 f3 F' Q4 I! k
print(len(tu)); ?) U4 s8 ~* S8 C
b. 获取元组的第 2 个元素，并输出2 K1 n) t  V; W; Z5 a
print(tu[1])
: j. u( o( i0 w& x3 pe. 请使用 for、len、range 输出元组的索引
# R+ y5 Y8 O2 ?' S" @" kfor i in range(len(tu)) :8 Y+ _; X) s- m  b1 t' P
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
, W( O! a% {! \) p) k  M( O; J- _9 [for k,v in enumerate(tu,10) :6 E" z  _; p/ G. U4 i/ ^3 e
print(k,v)- j# u: U8 [1 |: Q  j4 j. q4 }8 [! |
10 alex( D7 n3 S  c. A8 O
11 eric0 h1 K9 }* q0 B  g1 S( G
12 rain
! @" A8 }  W+ i  d* L$ i5 }$ x6 B, V0 W( ]% S+ }
for k in enumerate(tu,10) :* y) ~0 G% s) o, S7 M1 G
print(k)# [9 K1 M7 ^5 ~  t7 w/ u2 ?
(10, 'alex'). o2 n& J9 t: z% n. p) M/ I
(11, 'eric')
0 n  T- a3 @  {" G# O(12, 'rain')5 A5 [/ S0 @  p6 @  Z) l0 G

$ c& B4 u+ N0 V, U* X$ t9 f# f' S7 j$ O$ `: z( H3 f. T
25、有如下变量，请实现要求的功能
. H- i; S( y) x- J) g5 a, V" xtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

; c6 O- @, H! N) m& J+ G8 @d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
7 n0 T# s3 t& L: i8 X, Rtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
  y) E- G3 e9 M# O! B+ x, ?- \res=tu[1][2]['k2'].append('seven')6 ~; }4 o+ b; m6 p1 p- P5 T& B3 B

# e% ]5 V* ^7 x8 c  ]. W1 f' O4 ?print(tu)
  u# U" R1 s  ^1 ^26、字典
" v( F6 a  s8 j1 Zdic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
3 o" ~% p, Y5 k' O/ S print(i)b. 请循环输出所有的 value* k( G# W+ Z, U8 X; z$ y+ s
for i in dic:
% h! A" G+ H6 M$ E8 v print(dic)+ x9 f) E& \. f8 o' u  T
c. 请循环输出所有的 key 和 valuefor i in dic:
# K9 q- t' U: n: ]5 @% ^/ F4 Eprint(i,dic)/ v, W0 @- L# a$ z* V# e) ?+ k& S
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典  u/ c4 r- h3 f) o- t. a* X
dic['k4']='v4'# \2 D% _  W7 n! s  G0 f
print(dic)
8 ^1 @  r. Q8 W! be. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典+ O% j: Y' g4 b0 U4 e
dic['k1']='alex'
- S( ?, _9 T3 m8 u/ cprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
& j5 r: x! e$ e( j% adic['k3'].append(44)1 s# ~/ Z4 Y5 [6 s5 @' N9 J2 W
print(dic)
% ?  R+ l7 q8 P8 j- F3 {4 z& g. {# O7 Z; @
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典- v2 Q* D( H( G3 y
dic['k3'].insert(0,44)
: W& a" r# A, G) D% v; D/ {print(dic), U, b% E4 K9 q" D. ?
27、转换+ N0 a$ h8 f0 b$ E
a. 将字符串 s = "alex" 转换成列表  s = "alex"
' I5 N) }$ T- }: D) r" m! n0 j7 b; i1 }/ h& i
print(list(s))b. 将字符串 s = "alex" 转换成元祖
! E* ~# I& g1 ]. F& d! rs = "alex"
( a' P, r9 {; m9 u  a" m- l2 Cprint(tuple(s))3 R1 q2 s) a8 i. e& Q6 ~% |1 e

2 q6 \- ]" }- ~: w+ L. @" kb. 将列表 li = ["alex", "seven"] 转换成元组+ B$ D7 d& [. V
li = ["alex", "seven"]$ j  }2 e4 d; T* k
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
- Z2 e8 W2 ^8 j0 Ttu = ('Alex', "seven")
" k3 o& q& u2 u4 W  X7 z$ Cli=list(tu)
6 N5 N: f6 A: \) Wprint(li). Z6 z! X7 o3 y+ M

, M) B6 a$ q; V: u: z/ `. _9 x5 ^4 O: U; w/ J
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
4 K- H* J2 k/ V* b/ g( p- t) x1 W, u) K' a/ M! j  z0 k% P
dic={}- O! ^: d% g" H, W0 E( _  e
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
& B6 ^; b( X3 b/ Y  y dic[k]=v! O: I4 b2 K$ T
print(dic)27、转码n = "老男孩"
! |; H7 x( I% ?5 pa. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"% n2 d1 o$ e; Y8 z4 X
a=n.encode('utf-8') 8 h, h, g& L- t- ]4 ?
print(a)
# ?& r" t5 M# A. c  N7 Kb=a.decode('utf-8')
1 S/ W$ w" `. a# Z& u$ D9 z; cprint(b)9 ^# D/ D* n. w" s. x  F
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
) X# [8 C. X2 `; g1 ?print(a)% V- f. y  n! O6 O6 d2 h* E* M
b=a.decode('gbk')1 y: s6 @* G. W* x
print(b)28、求 1-100 内的所有数的和0 {7 F/ `7 z* T/ S4 J
count=1  h" B! w$ k* \: q( o7 U
sum=01 a# g% S) t# e" |; I
for i in range(100) :
, [& X( `3 I2 c  Q( G+ C! \ sum=sum+count
' X- }& x+ i  @) Y9 w count+=1
+ e" B! p+ N3 L: r9 j$ i' m2 Jprint(sum)
0 U2 K* A5 d; T# X( t6 x! s. \0 i0 @- t
count=1
+ F4 h3 E4 y9 a: s, v5 B( Q  ^sum=0: D' ?5 {, _! {9 d7 Y! `# C! t& V
while count<=100 :. y' I8 O8 {) }% m
sum+=count
2 |( J  i3 _- i+ d& l1 s count+=1  g; _4 _7 W/ q; O" j: H# e) W
print(sum)29、元素分类/ E& W( J2 [4 r
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
! s* d# o6 b9 x) N将小于 66 的值保存至第二个 key 的值中。
( i$ E" W9 d* G  K  P2 Q即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
, h7 c0 Q# L4 |: D; J# @, Vli=[11,22,33,44,55,66,77,88,99,90]; u! E: i8 r. e. p
dic1={
8 b/ `, h2 b4 M. V4 t 'max':[],
" i( {3 s) l8 O 'min':[]
8 F+ J  b" \: w8 S& {}# {6 H9 ]4 w$ D
for i in li :5 `. r  _0 \6 c" Z/ X+ s+ M) _
if i <66 :
8 n+ y) ?7 K$ D+ S) W3 G; o       dic1['min'].append(i)
, D5 v) q8 M9 [" O6 M2 p else:
: b1 w2 F% a6 q. N1 _) q       dic1['max'].append(i)) n) D5 \- c( G7 j# z; t  ?, R8 v
print(dic1)2 e  ^; P" x1 S7 o+ S4 h% s

4 F; W$ |$ e% z4 H9 f---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}0 ^& \2 r5 K. U( R0 p

Python基础知识汇总

主题推荐