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、写代码
7 h  J; X) `. Y0 \7 |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) :' Y9 D. L) c1 b/ y5 y- l5 U5 x
name = input('name:').strip(): f& O& K$ r$ H4 e  K& ]2 b1 o, h  {
pwd = input('pwd：').strip()
/ E5 \) z  J2 l: ?9 o7 |! ]7 [! y
! N* C8 m' u6 G/ Y3 F) j, _ if name=='seven' and pwd=='123' :
4 H+ g7 C! _2 K& o: v* i       print('ok')/ ~& }7 L  I  G* v; J
else:
7 ?  I& r; |; o/ A- b( ]       print('error')
0 n4 V( E8 L  v" ?       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)  :& u# H# q4 n: U! l# D
name = input('name: ')
* r* Q$ I; u; ^! ] pwd = input('pwd: ')& o1 B% u4 n3 I& a4 }. F4 t5 U+ \1 |
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
) f, l7 a+ b5 C  |+ L       print('ok')
' b+ O# S3 p! o1 V+ U else :2 p2 ]" G, }8 A
      print('error')9 L6 |6 x$ S5 v9 t: t
      count+=111、写代码
- ~! ^4 u% c* m# n/ h2 za. 使用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) :$ F- ~9 C7 F9 E3 i6 Q/ h
if i %2 != 0 :
% `6 N1 m) ~, C4 q1 Z" v; 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) :
8 l( O  b2 ~4 L1 t7 o1 g$ h) s; ?" y if i %2 == 0:# Q% I" _: ^) Y' ?4 K
      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"
) q; }) Y  D+ p& `0 b4 D; Sa. 移除 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 w2 Y: @, Y  t
for i in name:
, D+ ^2 b3 b8 o& ]% j print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain
% _; A: Q! Q2 O( ~22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']* Z8 g; C+ t' J" \) H1 V* E) [
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    $ @6 v7 _; c0 o6 f9 K
print(li)+ f/ ]( R6 C$ N( y8 X
['alex', 'eric', 'rain', 'seven']
% ~$ J! p2 _4 q5 A7 _7 tc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY'). I2 x6 d* A$ \# v; J+ _
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy'), n# F, `. k& ^9 \7 F
print(li)
7 ~2 p& w% U* S4 V# R* n, V2 b7 fe. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
! @+ T: `, M% Rli.pop(1)
4 i  @( h0 L6 m0 mprint(li) ['alex', 'rain']8 k3 z  c+ J3 Y6 v1 Z% }
指名道姓的删除li = ['alex', 'eric', 'rain']/ i/ P/ \$ {" v, Y& |5 R- B. T" N& `
li.remove('alex')
, q' i. l. L: Z, E+ kprint(li)
+ ^3 Z8 G, X% X  bf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
- v- {5 f7 j: s, pprint(li.pop(1))
9 d# j8 v% b! S+ q5 D1 F* tprint(li)1 y6 l5 ?0 t$ Q$ Z) x

) L3 m* o  B# G& Z; i* g1 Deric* G( U2 a5 H* G& e! W5 ?
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
: }1 }& z& ~+ y0 ldel li[1:]' g1 [/ k! H0 T. G7 X* X
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
1 ~( S& H* I! k" a. O7 L; ^* {li = ['alex', 'eric', 'rain']1 G8 I( ?1 {6 h1 P1 p/ Y( ?5 Z
for k,v in enumerate(li,1):
" t4 U0 {$ A% `: \# I print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]6 s! c( k/ s1 L* Q7 O! V; v9 \
a. 请输出 “Kelly”( Y! B4 S: T: d, G* @4 J
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
* m$ q2 s, V, S- tprint(li[2][1][1])! e8 w8 c: z9 }& @. Z, k% _7 I' ]. H
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
2 W' I/ m4 L$ _- M  _li[2][2]='ALL'
6 \4 `0 M7 f+ j& rprint(li)4 g& s) e1 d$ p& g
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
5 y7 V; I9 ?9 k9 q, E, q. {a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')- e/ ^5 F) ]5 ~+ u- ~
print(len(tu))
7 z6 X9 j8 j8 Y6 jb. 获取元组的第 2 个元素，并输出+ g- L- J0 Y6 ^3 s* [$ W
print(tu[1])
* X+ g8 V" {. d, m  ^e. 请使用 for、len、range 输出元组的索引! w$ b4 E( L6 [$ o" t9 r3 r
for i in range(len(tu)) :+ @/ x4 x$ z7 D
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)+ @& U  Z6 W; C0 _$ t- b; p
for k,v in enumerate(tu,10) :
, t, T& i" t+ Q  M8 g print(k,v)5 m  Z* n- J) G+ H% [
10 alex
# E, L4 v4 b- i6 H2 ]% T11 eric# Y( B% W! k+ E7 V2 F+ @2 f1 m
12 rain
' _1 B* Y) H* U1 y  A, ~+ a6 j8 q4 r/ S! X# I/ i+ w
for k in enumerate(tu,10) :
1 z3 ]" j% r0 Q print(k)
' p7 A. S3 P# ~. Q7 W0 n) A0 n(10, 'alex')
, {, i. B4 l' `) \3 Y- Z7 u+ P(11, 'eric')
# V9 H1 A( U: o7 _1 o$ s5 ~1 u(12, 'rain')7 b8 ~  r4 k' ~. H% f1 a

" i' H, n/ F6 _. {
) B3 f3 v  Z# V9 t2 [7 o1 a25、有如下变量，请实现要求的功能4 P. `7 t2 v! J/ A" y0 j
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

$ D" [9 ~; P& A2 o8 }+ Xd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
# h# @( }$ K4 a) J& z3 N  s0 ltu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44]); E, f+ ?8 ]4 B
res=tu[1][2]['k2'].append('seven')
, Y" ?$ H, u  v' ?* {' n) `, b* k6 @6 }" M3 E$ V: b  a3 V5 q
print(tu)
/ C$ s+ u# l0 Q' H2 R" p0 b26、字典
# r8 J# g, y/ I& ~, ?dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:3 z3 A" i' z2 |5 B0 z1 ^
print(i)b. 请循环输出所有的 value% l6 r( Q- V6 n; m& Z5 d  L2 V
for i in dic:# i9 B, K0 G. P5 n# u
print(dic)
- |: q; a" s% D7 Q+ i8 f2 S, Dc. 请循环输出所有的 key 和 valuefor i in dic:& J8 R1 v" g8 G! n- }" O, P' ]
print(i,dic)
  i& [' n7 y. D4 \d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
/ {/ c) k7 q4 Ndic['k4']='v4'
" [- K2 X" ?& Z8 z) I0 Aprint(dic)
6 v3 d% z* k* G4 G9 I4 B" C) Ve. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
0 b4 P& {5 C" V6 Idic['k1']='alex'
" ?9 s5 ~3 K2 Fprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典6 R) N8 r$ Z0 A* n- m; b# @2 G: c
dic['k3'].append(44)
. M# B; F# O* B: N; ^4 Xprint(dic)
4 q% J. g% {' j" R4 S) ?, q% U& c- j# U  I6 d2 r
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典$ A2 x" ^8 z# H8 K9 _& ?/ [9 V* R
dic['k3'].insert(0,44)- S) [& Q# p) N$ t1 c* Q
print(dic)5 Q% P* ~( }0 ^+ M: _$ c7 Q8 B( n
27、转换
0 W8 Z$ K: f+ R. @3 N4 r3 t% }9 ]a. 将字符串 s = "alex" 转换成列表  s = "alex"6 Y0 \  d/ Q: h8 h/ \
  O# X7 T: H' j  Z3 n' T# A
print(list(s))b. 将字符串 s = "alex" 转换成元祖
" F# u* B- t- Ds = "alex"0 w, @0 t5 \# Z7 i& x3 y$ D, n% n
print(tuple(s))
& ]% _9 N' X; E9 D* J  O4 p# ^' W* t4 g& R/ e4 ]
b. 将列表 li = ["alex", "seven"] 转换成元组
* H- k* e  i# C; p: s, ali = ["alex", "seven"]
$ ^' c* t' `9 }! l4 e! W# c  Gprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表& w" [# o4 h  V' @* t' K
tu = ('Alex', "seven")9 r9 b: H3 |6 j& [) I
li=list(tu)4 y8 @0 S, `; z5 M# f- Y
print(li)
5 g1 o# L, R; d2 r5 |* I6 h  j- J7 L% h1 H

, u( J, \& _  z8 l( V9 m- A' X4 vd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增7 c! q% W. L+ ^

3 |: i' [5 V3 B; w. x( V3 n2 ddic={}
! ]' v) a- M" a1 g" Ffor k,v in enumerate(li,10) :----li要放在前面，序号放在后面
3 V( B2 z/ c; ]9 K dic[k]=v- x  R; C; i% C, ]6 H
print(dic)27、转码n = "老男孩"
8 `; R4 M" h8 \: [# V( Qa. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
: P5 ]3 b2 r- p7 a. r" J+ ka=n.encode('utf-8') 7 e# T; D9 w9 [2 \# b( ]
print(a)
; \; M% ?. Y! _7 w) e( r& `$ ob=a.decode('utf-8')1 M) I8 e' i- n: o( Q7 {" Z
print(b)
0 g& n9 M& c- c9 ?1 I  }b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
& \. X8 L( U, ^. w1 B7 Hprint(a), b- j- e% c4 k: D5 I/ Q
b=a.decode('gbk')& V( x( I$ H4 E1 `9 V7 ?
print(b)28、求 1-100 内的所有数的和1 e7 h1 y: g3 D5 r( R% O1 @9 c
count=1& L4 k' \2 m: U: b$ B) I" T9 r
sum=0% A9 N* l8 }( q  z+ Q) z' V- h
for i in range(100) :
% L; P: Y- s' A& W* b4 Y sum=sum+count
7 {, ~9 e5 Z) E+ A count+=1
( p7 T& C$ Y9 v# }3 K3 K- Zprint(sum)! q- t) m9 Q6 F2 B0 @

( X/ e# I+ o5 y8 K, Y( C- Xcount=1
8 P' M6 k( i2 I: d" Usum=0
7 G  Q) ^& Z4 m3 D! a5 Qwhile count<=100 :5 }  ~- v- M- ?" B" }
sum+=count
/ j: {3 o" j7 f; r9 Z4 W count+=1( `) u- z$ u3 g) ?
print(sum)29、元素分类$ s* C0 |# `- n! H# l* s
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
6 c1 u3 k$ c( S' \3 s9 x/ o将小于 66 的值保存至第二个 key 的值中。
: C2 ~2 h1 G$ u, H; Q: }即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
( A8 D$ P) _, N+ g& n# sli=[11,22,33,44,55,66,77,88,99,90]
; B, l  V0 ?0 @8 m$ c3 g" W+ edic1={) o, r3 q$ k( R% d9 |9 Z
'max':[],  p! B" j2 E4 m8 V( c! U
'min':[]- w3 w) f! N7 e! s0 ?
}* `5 H, @- w  f! E
for i in li :
. J( F7 V! R! }8 d' u if i <66 :
  T$ H% c7 ^& f4 W5 f       dic1['min'].append(i)% b3 Y5 i! w! y# U3 @
else:
* u7 t! k: c; n       dic1['max'].append(i)
2 C6 f9 I2 ~1 }" }print(dic1)
1 \" b* U3 L" j8 Q0 z8 J: \/ y6 f& b% v: H8 B/ i3 Y7 w
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
3 {2 U( T$ {  X- T. w4 `

Python基础知识汇总

主题推荐