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、写代码
+ d7 ?, Z$ |' p, v" L/ p% Pa.实现用户输入用户名和密码，当用户名为 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) :
/ P. Q. V# o- H$ d' T# j$ G name = input('name:').strip()" |; Q! ?5 f: e
pwd = input('pwd：').strip()5 f: k; F$ p4 o. M& |8 F& w1 g

0 a1 L( }, o/ P6 b if name=='seven' and pwd=='123' :
( A% K& _/ R3 S; y! y' F! Z       print('ok')
9 |1 h" q* Y% ?9 \3 K else:
& D& N1 [/ _- a) h0 n       print('error')
3 i. b/ R) Y  z9 S& \6 d! p$ Q7 D0 [       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)  :
5 ]" i( G+ m# L* Q" |2 @ name = input('name: ')
- e9 X9 R, W- ?/ ^; L  y pwd = input('pwd: ')6 e7 c+ ^& k: a( O2 o+ Q
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':  G5 p, x9 o4 i9 I; E0 C2 o
      print('ok')3 m8 k+ S" y. \. ~- {
else :
. i  w3 A& d  K       print('error')
$ l# D$ s- ~" s. n       count+=111、写代码, f0 r; U8 O: n$ B- q* |- H6 Y( P* i
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) :
' t, ^. {7 w' _6 D if i %2 != 0 :
; Y4 e9 Q* s5 ?7 n6 \9 c# G, p       print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :$ h& z$ }: {: d2 _1 X' X
if i %2 == 0:7 U  g. l& i$ V, @
      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"1 z) Z8 D" Z# i3 N$ }" S
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)
! D2 k* i" P1 v; qfor i in name:
1 V7 o4 R4 T0 E; R print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain6 O# F/ i3 ?# h/ v; y# D2 M
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
' R% X1 s$ @$ h. j7 O; |, Jprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
" B! ~1 _4 l+ F$ _* M% }$ Kprint(li)7 z$ ^' f5 j' z6 U3 e
['alex', 'eric', 'rain', 'seven']+ K( `* M6 i. L0 r  |
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')* {( }4 W1 }$ n: ^- p
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy'); J4 Q# e( d3 G+ k! \1 n0 C0 R4 G
print(li)
$ K  N& N. q# w, He. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
" ]" W: V- @3 j, `! ^! ]li.pop(1)
# x9 I! V. I2 k* o- L7 |, }& Xprint(li) ['alex', 'rain']& P/ D& K1 d: a/ f% P- o
指名道姓的删除li = ['alex', 'eric', 'rain']3 L& J4 g' T3 O8 ]( b
li.remove('alex')" g  ~+ h* j# R8 s. F6 b/ @- {
print(li)
: `9 L% w" H! S3 G1 ]; of. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']6 A4 A. Y" ^7 i# n8 z  n6 ~
print(li.pop(1))8 g# S- K7 X* Z2 c! c& B, A3 [
print(li)' B- n0 R7 G* Y+ f

# w+ a9 `. y" d% P* jeric3 D8 k: ]; T5 z& O
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
% I; {4 R/ o8 M( {# V6 {% Sdel li[1:]) M/ s8 w4 N; O: a( b! m- R
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
! Q, ~7 @, [, w: D) Oli = ['alex', 'eric', 'rain']
' D9 k4 @# w! s6 K- N/ R2 Dfor k,v in enumerate(li,1):
: [/ [( T* g3 Q( | print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
' n9 p2 e8 g; U: K1 Va. 请输出 “Kelly”- X+ O4 X1 K8 E4 L. {1 e
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]8 }% h- N% G) t3 C6 J3 l
print(li[2][1][1])' {# t+ _# r5 z6 {+ x
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
. ]5 Y- a; `# c! r* u2 lli[2][2]='ALL'9 A- {1 B  k' O4 e
print(li)
& h6 H" b8 f# ?. v  O24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
  z3 g* b8 s! o' C9 p# Na. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
% R$ {3 ?9 v- B" W) O! K1 X; nprint(len(tu))
/ J$ l4 J6 p; P/ q0 c0 |b. 获取元组的第 2 个元素，并输出) r8 L" |1 S1 \7 `6 z2 f. X1 F
print(tu[1])
3 E, x' R# ~! n  T1 te. 请使用 for、len、range 输出元组的索引& ?: Q! ^# ?3 |5 o! j
for i in range(len(tu)) :
/ d' j# O/ N  T8 Z: P7 t4 H+ w print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
5 ^0 I1 V2 U1 b* S0 j  R( ?for k,v in enumerate(tu,10) :
8 Z+ o3 M* P& S) n print(k,v)9 ~0 V. y" k! y7 o) e' {
10 alex6 X" L& R5 y7 O
11 eric' f! m8 {( @4 D, ]- a
12 rain
) C* y8 K6 |% s, ^3 p0 k: s% e- }3 k% g8 {; Y) ~4 [
for k in enumerate(tu,10) :1 a2 U5 E4 ]& g! \! w0 t
print(k)0 U" S1 i- }5 Q3 C7 P$ V- P
(10, 'alex')
% H0 e6 Q( e/ F0 j! [- b(11, 'eric')+ ^+ D- p- P8 P4 c% \6 K; _/ Z
(12, 'rain')& o9 {# Y* ^' w! D: o/ k9 C/ `# p

- V/ V' {# i/ ?" X0 e9 w# ]
: S! R9 r# H, ]25、有如下变量，请实现要求的功能
. H6 E' v6 G$ P0 n" xtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

& I1 a1 h6 E2 h( Vd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
, A% z1 p6 O" k! Mtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])6 C8 @' o+ @; f3 D9 Y' C
res=tu[1][2]['k2'].append('seven')/ O+ g2 O3 z9 s0 g! W2 Z  u0 ^
+ Z1 w8 E8 o- b2 h. f% q) {
print(tu)
2 @5 T7 F9 X6 `26、字典: @' U9 t2 J( j0 H# I+ s5 V- g
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:3 A. z6 Z" h0 {) F( r" O* A
print(i)b. 请循环输出所有的 value
4 B+ h0 l2 N) sfor i in dic:) |8 S: R3 K1 o0 c8 x6 Q' A
print(dic)3 b% ~9 x# t+ r( z/ ~$ m
c. 请循环输出所有的 key 和 valuefor i in dic:
! s; H: u# o) N# gprint(i,dic)
4 Z+ u( J, B' sd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
9 `) i/ [4 z9 f3 q( m) w, J! @! ^dic['k4']='v4'7 T1 ]4 f% v7 g, ]
print(dic)
$ q- Y; O  y' U$ J; He. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典4 i; |7 n# A9 w0 c5 y0 S/ U
dic['k1']='alex'
! u9 V6 ~/ o5 u. Z. M1 ^: lprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典7 M. W1 I) d4 f! K! H" R$ K0 e) s
dic['k3'].append(44), `; c' N% j$ f3 }- w. M1 k: x
print(dic)
3 O( j6 t, D# _4 o4 l1 O- k( F7 I( E: u3 N( E( m
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典& R& n8 Y2 v4 _% W+ v
dic['k3'].insert(0,44)
# I7 g& i3 {* zprint(dic)
( M9 X6 W* S+ W( `3 b2 f27、转换  k. f- o" H6 I. x9 Z$ R) q
a. 将字符串 s = "alex" 转换成列表  s = "alex"
( K/ L+ [. p+ I7 E- D- a' u5 p- G& x! y( R0 b, c/ v- Z
print(list(s))b. 将字符串 s = "alex" 转换成元祖
! ]# Y5 G/ _# ?4 t4 zs = "alex"1 |# A! D; z, A* b4 v0 i( G9 V4 m- H
print(tuple(s))
: Z* K  o0 s+ s2 j3 b4 g
& r5 u' z$ z/ Mb. 将列表 li = ["alex", "seven"] 转换成元组
. f- k1 B3 ^$ M- S  v1 t2 f; c; ?li = ["alex", "seven"]2 `! J2 |2 h: p) l' y) ~
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表2 B0 j! Z% h& Z$ ^  L
tu = ('Alex', "seven")' Z6 C# H( B9 ]
li=list(tu)
1 ~6 {2 q' f7 e$ dprint(li): u% g( g. I* g* `- N

. p$ z' X* n5 r1 \
- w$ z0 A2 |* r' ?d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增; G5 g/ N3 B; r3 b' }
! H' A- Z$ k2 u, e
dic={}
! [  @% s5 f9 m1 d/ g/ Cfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面- _: Z7 F& q2 x- A
dic[k]=v% B6 ~( t: K- \0 z( F0 P8 ~3 U+ Q( b+ q4 t
print(dic)27、转码n = "老男孩"8 I8 |& d# J4 |" k8 z0 f
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩", ^/ G- h+ h0 T7 T# v, B
a=n.encode('utf-8') 8 r- q5 O' h# n/ s9 d0 x. q
print(a)
" ]8 o5 U9 b8 A5 U) Nb=a.decode('utf-8')2 v& b0 S) d4 t: E5 w! v
print(b)
7 n' y8 V* c( ]: C8 ?2 `b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')6 H$ e" R6 O/ T3 g( K  U; [1 f/ X9 i
print(a)1 o6 U( ]; [, g7 R2 p, a" O
b=a.decode('gbk')
- q9 @3 W- T8 X: u* Z3 T- Iprint(b)28、求 1-100 内的所有数的和
) j" E. j' T; E6 v9 Ocount=1
' F# N& X% [3 r( z$ D- w2 Osum=0! r, v) v- u3 G0 T
for i in range(100) :2 v4 f- D5 l9 R
sum=sum+count
% _7 a( F- ]+ W- w" w9 z7 _ count+=12 s! |* I6 e3 D. e' Q) G. q
print(sum)
& [5 t7 F0 n7 L* M. C$ x
# y& y# @: `- X0 b7 R, s, e7 I! Mcount=1
/ I: J0 h4 _" Z- f1 Q0 Z( Ksum=0
+ |7 |' S7 c$ n5 G; Swhile count<=100 :
, v  A, U! a. P1 r2 a sum+=count& Q$ z* K0 G2 F' q2 [, w. Q' H5 h
count+=1
# C$ x& [9 u* F+ eprint(sum)29、元素分类
& a  h/ g( m$ J0 ^. q; d有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，$ w6 b) s; m( c/ ?$ s
将小于 66 的值保存至第二个 key 的值中。
  [: i* D/ e( i5 g9 Q即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}  c6 X. j: q. ~( z
li=[11,22,33,44,55,66,77,88,99,90]
: n3 u  ]2 O$ C7 i' M+ [9 Ddic1={" ]5 o4 y2 E; ?7 i
'max':[],1 N$ _7 x5 @; @' ]1 f" G
'min':[]
: b: }) _( h4 c5 w" l- p; Q* {6 O}
: s  f0 q2 N8 g$ ]6 Sfor i in li :
, J+ g- m1 \+ S if i <66 :
" z  D& h, ?6 Y% O0 n       dic1['min'].append(i)" d2 M3 n5 E' [
else:
3 o/ Q$ Z) k( w  p9 H+ N! W; z       dic1['max'].append(i)
) ^5 S' t7 [8 m7 [$ A3 L/ \) Yprint(dic1); |- v8 I5 C  m" T

) t7 }: Z( Y* H* `---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}- z" n1 m- ]: l$ C: S6 Q

Python基础知识汇总

主题推荐