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、写代码
6 k3 P% ]7 r! K4 ra.实现用户输入用户名和密码，当用户名为 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 a, X% Q' j$ l/ d
name = input('name:').strip()0 D( c4 N9 T2 d. c3 A
pwd = input('pwd：').strip()
8 }: ^1 l! g! S4 |1 Y6 {5 B. m; K) Z
if name=='seven' and pwd=='123' :
% P4 C7 F2 R6 ]. d2 j4 X       print('ok')
, Y' F# D8 {* n* t; @ else:
, @4 V5 V$ {: E0 x       print('error')  C5 Q, c- t; Z2 B- i1 n
      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)  :' L, o9 A/ p$ E. C. B
name = input('name: ')
2 e$ t! x8 C" u' ` pwd = input('pwd: ')6 y! B  [* I/ ]" J; f* M8 A% B
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':/ O+ g+ q% [$ ~9 F
      print('ok')  A9 Y& \, p$ n, Y, R
else :
* O9 a$ I; H/ X7 b% A       print('error')7 F8 I" Y; Y! g$ g0 @
      count+=111、写代码, z6 _4 R" k) Z  H$ G6 a3 w
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) :
6 t8 j8 W  @  h* Y) ~4 h if i %2 != 0 :8 E" L7 s1 H0 K8 a1 d
      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 a2 J) k% g" F, }( n* ^
if i %2 == 0:
: Y' a" A, N: J' E' ~' `       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"# h: N% w! Q9 C" s! ^- S8 ~
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)+ K% ]1 ]+ d" u: @5 s
for i in name:7 n3 w2 S+ F( Q4 {
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain4 c3 H2 ?9 h, G
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']0 `3 a$ z8 Z  J. `2 V7 v( l  {5 }
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    2 Q( M  Y. Q: M% K; @' n
print(li)( w% `) G+ z+ v; ]; x: t
['alex', 'eric', 'rain', 'seven']
4 H4 o, }2 n. H, \9 k; x% ]c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')$ P/ H" i3 d( U/ [8 b
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')5 N- o0 l& g* f0 m
print(li)
& K; G% g$ G( M6 Ee. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
8 @' B0 _" `# Qli.pop(1)3 ^% f* a* X- j- }1 ?* t' m; L  N
print(li) ['alex', 'rain']
& m/ H" M* \* n5 z+ o指名道姓的删除li = ['alex', 'eric', 'rain']
8 Z+ m1 _5 c3 W# G) ]  g  eli.remove('alex')) i# F# G9 H4 Q* N* u
print(li)& g' M( G# \% K8 W) J/ s  l7 C
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain'], Q6 b/ J  D2 M5 Y# ]" b, M# V
print(li.pop(1))9 [  X6 x0 i+ ~# K2 X2 l+ o
print(li)( g* ?0 O1 }4 N" D4 `  B

0 {2 H6 e5 G; y2 R( Xeric
+ P/ r# E) G/ k9 |3 M['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']. c' k3 k* P. g& j5 o% t
del li[1:]
- J; a4 I; G' Q  J& |& ~print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)/ q+ \7 t7 _2 E! c8 h
li = ['alex', 'eric', 'rain']
7 }/ J% J2 w! C" e9 ifor k,v in enumerate(li,1):
) r, O' U5 }8 z0 M. g print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
" b6 ?; l8 c" ?! Ca. 请输出 “Kelly”& ?9 p7 j! y, D2 ^  U  ~
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
0 [5 _. N1 H( H3 a! J, P' Xprint(li[2][1][1])+ U1 V4 L: ?9 n
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”1 v7 e) }& S2 ]5 V
li[2][2]='ALL'% \$ @, v0 ]# i2 |" n
print(li)
. o5 ?0 P6 C% |+ S" C24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')& }% ]/ Y, Y9 p6 X" g/ Z
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')" `/ a! \& Y8 f/ R6 }) `
print(len(tu))
9 h6 _2 x& L& a2 t) Hb. 获取元组的第 2 个元素，并输出* W  Z& ]: T4 j5 t8 B! p. y& O
print(tu[1])3 e- q9 o/ v, I$ U, ]. s
e. 请使用 for、len、range 输出元组的索引7 @- M! w; U8 q% b' e4 D7 P- K9 j
for i in range(len(tu)) :# I: j1 U2 j5 O) P, \7 h! ]
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)' \1 x) j/ Q6 ?
for k,v in enumerate(tu,10) :/ f9 D6 q$ H) ]! Q5 P& g% J
print(k,v)0 a0 p$ l  f% O1 b- s
10 alex
3 {) W6 y; x6 u1 U" D3 H* g11 eric7 Z( i: Z$ J4 P% a
12 rain
8 J1 B9 ?6 _1 `5 m8 _
5 m6 H# H0 E$ [for k in enumerate(tu,10) :
4 D* P7 B4 r7 b print(k)5 G5 v' u1 q6 I; ~2 u+ V* @; G
(10, 'alex'), j3 [4 p" F: z/ _/ g
(11, 'eric')
) [8 k5 |& C/ S" y(12, 'rain')$ P2 t# H+ E. w- v* Z0 t# u. T: Z; a+ l
; W" \2 H+ o' D

  \$ c. H6 \' @. N  e0 H/ Z25、有如下变量，请实现要求的功能
# e$ C9 p. _0 _2 `( I7 htu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
3 I% P6 o+ G7 e9 t& D8 h
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以- B  B9 a3 [+ {+ {4 T
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
0 g" R) {+ v. }. Pres=tu[1][2]['k2'].append('seven')
( a: Z* w+ b( R  P- `! Y- G3 }! ]
print(tu)
: O# g6 N) E$ W/ [" l+ L26、字典
1 u& q. C, y8 Q- J( ddic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
5 n" t0 r# N3 ~  l+ v# ~6 D print(i)b. 请循环输出所有的 value
2 {8 |. t, n  f2 _% }5 B* yfor i in dic:! I6 S% a# P" C! Q3 q
print(dic)) k- u( d0 e9 H' M. F5 J/ }
c. 请循环输出所有的 key 和 valuefor i in dic:
' h/ P" R2 t$ ?$ F" I0 Nprint(i,dic)- x0 a2 x+ F/ c* f' |+ A
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
8 N- r, Y. m+ t, F' adic['k4']='v4'
' y3 C* y/ e- Zprint(dic)
. e' R. C" Z3 q8 O8 l9 Q' k6 ~% ge. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
! k1 Y4 }: K3 q/ [6 o4 F2 ^dic['k1']='alex'
" m" L5 y' E# {/ rprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
, K" o4 m0 u. A  {8 Ldic['k3'].append(44)
* }( t; d9 l( X, ^5 }9 E0 C' Sprint(dic)
9 b; T2 _. t4 C  Z+ X  A
* ]  X; U  [/ K' P5 {: L) kg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典& S; w$ {/ z* Q0 _: n
dic['k3'].insert(0,44)
; g' @* ^/ g- S3 G6 H) ?% `print(dic)
# I# s# \- s; @  ?. ~+ a27、转换
9 n8 D# g0 y* y) n( Ea. 将字符串 s = "alex" 转换成列表  s = "alex"
5 e! s2 |, n% D2 H. U; l$ l, |5 T& ?1 Y3 Y
print(list(s))b. 将字符串 s = "alex" 转换成元祖
7 q' \1 ?5 j* E7 y4 Cs = "alex"# f+ y/ |- B3 v: K) `/ {" C9 ^
print(tuple(s))9 @) C0 B) U2 U5 ?) h+ k9 G
7 @+ h+ f1 v* I" B; o) X, K' Z4 B
b. 将列表 li = ["alex", "seven"] 转换成元组
" V/ X! j9 }9 H+ V2 ?1 h2 i' ?li = ["alex", "seven"]' B$ i2 R  t% w! X% f
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
- B+ ]: d" U" m+ j) f# ^tu = ('Alex', "seven"). I9 r* f3 |0 K4 U/ ^
li=list(tu)
& Y9 ]7 F) P; [# Z/ N# m$ Lprint(li)
0 f; K# R& m! ^
/ b; v7 G$ l* [& w' ?
& F- a6 |+ m  V4 vd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
  J6 ~3 y9 S, u- a
# H$ x& X( y5 b' S; s; tdic={}" U  q+ r( g' D, B
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
( K+ S% L1 G) D, b- F dic[k]=v
! x0 h: s( b$ @  r. T8 h, k print(dic)27、转码n = "老男孩"6 q4 R+ O9 }% M) n/ ~
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
* l* ]/ D. j! y+ }& r1 wa=n.encode('utf-8') 1 O/ |  A* ^% `. a, U# m2 _
print(a)
( @& F- J7 G: Kb=a.decode('utf-8')" k  z" a( X7 D' g# j, d9 Y
print(b)
. u4 V! m% l6 R  ], ^# U) ]4 {& db. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')$ i+ @+ N; C: d" a
print(a)
3 ?* p+ y; C, E0 bb=a.decode('gbk')4 Q& [6 ~0 a7 P7 Y& Y
print(b)28、求 1-100 内的所有数的和8 Q8 g  \: \& Z6 _8 J  k5 h# m
count=1
( y3 }1 |. {2 Y/ [5 b/ ]sum=0) t- b) ]& W1 U, P9 {
for i in range(100) :. Y# s  i4 @7 k  V
sum=sum+count% c: ?! E0 e" u& N! S9 J% Q4 t
count+=1
& S' H% q& ]/ l9 `" {print(sum)
6 m' l$ F5 I8 p7 O4 d3 a" P+ E
count=1; W" \- T$ o, Q* X, O
sum=02 `: x9 D0 a' E" X# z' s
while count<=100 :, j! `$ C& d0 S* V) [: V& b" x( e
sum+=count
8 n% F: Q2 O3 `+ |! \. W. x3 l count+=1. d+ W& F# L4 s# ~- O+ H% K
print(sum)29、元素分类
, M( H5 R5 r# j$ w# N" U5 e' ]有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，5 `, g2 U0 V; Y/ A. |7 _. f
将小于 66 的值保存至第二个 key 的值中。
5 t& p" A3 T) G/ `* E  ]! Q3 }即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}
3 f2 `3 k9 }. R8 @/ @0 z7 \3 Gli=[11,22,33,44,55,66,77,88,99,90]
4 L, g$ w6 q% L; d% n8 ?  d; Vdic1={: k7 a$ T( m/ n/ o0 ]0 J: |/ ?
'max':[],
0 z8 G2 J( l, z2 H* C 'min':[]
5 m" H/ Y" H( [& A7 |: D}
6 S8 S2 _$ j9 W, V* ^  b+ [/ I4 ifor i in li :' E1 B& [, E' _+ C
if i <66 :! P( U4 y4 x2 n
      dic1['min'].append(i)
( a0 c5 H: `9 D7 @! \ else:9 S# L- r/ f0 P5 q* q
      dic1['max'].append(i)
4 k: H5 m4 l! fprint(dic1)1 A* b3 v; F' v2 {0 y' o
2 I. C& r2 ^# M9 t& F: W( E! j. ]' _9 Q
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
7 t4 O% {3 L9 `  I" n

Python基础知识汇总

主题推荐