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、写代码
+ N* M* P, V7 L! |5 A/ qa.实现用户输入用户名和密码，当用户名为 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) :" K+ B( W# }# ?1 L
name = input('name:').strip()
  `- m  T$ u  ]# R$ b pwd = input('pwd：').strip()
3 i5 b1 G+ H  {9 t, M" N: O# {  s7 B& z& n8 v+ R, I- ^
if name=='seven' and pwd=='123' :$ Z: u! |6 X" y: G
      print('ok')% N3 ?. ?3 ?  I( Y9 p+ h% R
else:' @* ~3 T3 N0 W. F7 a& ]
      print('error')
- B1 \  u: D* Z6 r, 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)  :/ W) n; m6 G, [7 T) s  V
name = input('name: ')
) R- c. Z7 M  S8 `5 I/ K( T. {4 F pwd = input('pwd: ')
1 s- Y: x7 U! _6 K3 T if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
9 x# E: M7 j, G: q2 ~       print('ok')
' J& W8 l- S* _, t3 s) w5 _0 ]: A else :
, t- E. t7 {  l! d  o       print('error')2 b! I7 \! }1 N8 K7 _! Q* z4 w
      count+=111、写代码7 i4 X" m0 r. l+ E7 [, T2 ]/ g
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) :
. j4 D7 f1 l# } if i %2 != 0 :
  @4 h; S: T5 A$ O. ]       print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
! E" Z4 m; U8 B if i %2 == 0:
! A# B5 N& K) Q       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"% M7 y4 j; z, h
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)" {  Z1 V) E1 Y( ~2 c5 j$ j8 g$ Z
for i in name:* e/ G# v4 u  n3 B( a
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain2 V& D; M+ O9 L( J  s8 B7 n
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
2 V8 p6 U- i% @1 E  Cprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    0 O" q5 ^7 V. f" [* J1 B  `
print(li)+ p- O7 i1 P8 C0 X4 ^
['alex', 'eric', 'rain', 'seven']
- w/ s# f  t5 d1 jc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
# H( _2 U" Y1 t1 j  bprint(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')% L9 F0 k" k5 n
print(li)- X6 r. w7 w  D$ B- f1 ?: r
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
+ c: V/ w3 ^- _% M5 h1 T$ l) Jli.pop(1)
( J+ o; A- |" m3 W3 ^- lprint(li) ['alex', 'rain']
* x+ ]2 ^3 Y( X# a' c指名道姓的删除li = ['alex', 'eric', 'rain']
( R3 c0 a3 }5 M7 q+ H  Q1 Y$ |li.remove('alex')
* {2 N) z+ R. v8 {: z  qprint(li)3 {. k1 d# n, X' E6 X8 M. w
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']) J" x5 w, k/ q. M8 m
print(li.pop(1)): |  [7 r, c2 C: F5 F# i
print(li)
: I0 Z+ F, J& q+ @7 H9 u7 J8 @' L2 N5 A5 f5 W
eric% k9 [  [5 D6 ^2 J  r3 e
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']9 q) H1 S- u' j
del li[1:]' l3 M2 L3 v- H7 p$ U* y
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)& C9 ^6 c9 \7 g) X
li = ['alex', 'eric', 'rain']
) E6 T1 G3 Y1 o1 G: U5 \for k,v in enumerate(li,1):
5 G8 I% w5 n0 C# W' T, v" e; h, r print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
# ^6 ^7 H6 u" |# q! ]' Za. 请输出 “Kelly”: Z# r) b0 Y4 J) Z: {& P" p% |+ {9 A
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]4 g( Q  b3 e* b! P* T
print(li[2][1][1])
8 @/ M6 C+ a; Yb. 请使用索引找到 'all' 元素并将其修改为 “ALL”
' O- n7 e* ?, ^5 s& M# E" x4 S1 Cli[2][2]='ALL'
3 C1 L- H2 Q6 b3 L: |4 l: Jprint(li)' l- L! ^, m5 M0 Q
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
0 n0 n1 o5 r7 z; xa. 计算元组长度并输出tu = ('alex', 'eric', 'rain'). }9 C' E1 I+ P' V+ U9 d
print(len(tu))7 k6 d) n. a- w! n+ D& a* L
b. 获取元组的第 2 个元素，并输出  @0 }; J. z5 D: ^5 b6 b& x
print(tu[1])
4 `% ?0 E$ z/ b$ ^  Y5 Te. 请使用 for、len、range 输出元组的索引
$ L3 |! Z/ i$ n6 Tfor i in range(len(tu)) :( h5 w+ y9 E7 G( w. f% L7 M! @
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
: x4 [* B3 o1 w# F$ Ofor k,v in enumerate(tu,10) :$ g3 Z; U0 N( G  W
print(k,v)
# i# l( w1 w1 z# `9 Z! ^! M10 alex4 p/ s" J9 u6 O8 }
11 eric
1 D. m0 i+ I9 L12 rain9 S# \/ W, T5 L  @1 I
# h$ ~' L. q2 ~$ f
for k in enumerate(tu,10) :
, A8 o7 K& x$ n! t# Z print(k)
6 p  U( G7 S0 P* }  G(10, 'alex')0 B7 c8 L0 E* Y0 C$ N0 k* I4 |
(11, 'eric')  Y7 c, |; e8 r7 {
(12, 'rain')
% @% l5 m! R$ t. J2 V
4 Y: @, \( x4 ]2 {+ A8 r% Y
6 N3 S" H% q& O, }0 [# U$ x5 y25、有如下变量，请实现要求的功能/ n& L0 @1 |7 B; a* N) W
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

8 v5 H( D7 G6 sd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
1 K7 Q* G) E* r4 J4 j/ M0 [# ptu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
* X- e  d# o) A5 k% gres=tu[1][2]['k2'].append('seven')  D- h2 r& ^! I# a
$ n0 }2 @( u% M" e" y2 a
print(tu)' C8 Z' v# k% G4 D' k1 S2 T! B
26、字典
1 S' i* K! c5 H% ddic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
% [  k# v# O  C& z% J0 {. g print(i)b. 请循环输出所有的 value
/ Y9 a0 ]1 O0 s" O- @for i in dic:
5 r( z: k2 R) h print(dic)* ]% q. o+ ]& S) b
c. 请循环输出所有的 key 和 valuefor i in dic:
5 ~6 F+ ~/ l. ]! k( E7 sprint(i,dic)1 ~/ V% y- l$ V5 S1 S8 S
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典: K$ R3 ^, k/ b5 [. _! h4 B6 t
dic['k4']='v4'
# [+ _- r1 ~% ]5 eprint(dic)& F9 X# s' a' h1 c0 d
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典2 J+ y& @. F4 Y. N: O  o2 b- `
dic['k1']='alex'# X4 m) e" v+ E; g  G
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
: z7 c1 G9 d/ p* j/ g: s+ Kdic['k3'].append(44)
2 g9 C$ ]9 b; r7 E" q8 F7 Zprint(dic): K' R# p6 a: ~# \

  \* u2 G/ U8 I9 J9 Fg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
# C! K" Y1 W$ I, Qdic['k3'].insert(0,44)8 W* L. c6 Y3 e: Y) U" G
print(dic)
( P* d. |8 Q2 g, g" b: y27、转换
1 e% N5 j: d! V" C* X% A7 {a. 将字符串 s = "alex" 转换成列表  s = "alex"
+ f2 P6 h- G" f, a1 x
: ?9 S) F5 @5 S% {  l6 w! M, vprint(list(s))b. 将字符串 s = "alex" 转换成元祖
, L0 C; ~+ D9 @* zs = "alex"5 w4 g( \5 @) W. e! R' R3 I
print(tuple(s))) l' F& |  o  x  u
  ^8 N4 c6 y1 s0 u: }& N
b. 将列表 li = ["alex", "seven"] 转换成元组
- r; l: @0 \& v2 Mli = ["alex", "seven"]
$ S$ ], [! w4 S- [+ h1 iprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
) |5 F" M, v: a( [tu = ('Alex', "seven")' J; a4 o! @5 \" j8 y8 r7 \
li=list(tu)# ]( K* O4 l# G" h, I$ L
print(li)
, N6 K' A6 ^9 u/ r% w' z4 J" H% _
5 H) A5 t7 J+ }" ^6 f" y7 [' C+ k; n2 }8 q+ \) R8 {
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增: l! Q( m: n1 X0 J7 I

- Y1 L/ v7 P# s. N" H! |- `/ pdic={}, h7 \0 a2 H1 G
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面; F4 ^7 ?8 _1 y  |, ^" ]6 x. j7 |) Y
dic[k]=v
6 Q& R9 g. G4 b4 ?4 C* e print(dic)27、转码n = "老男孩"+ I: J$ z; t$ b& y: H8 N( h
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
/ z: I+ l& ^! }8 c0 Ba=n.encode('utf-8') - G& [* F* B- ?$ Y, L1 f4 z
print(a)
  }5 Y" c4 F8 k9 l& ?b=a.decode('utf-8')
! j# q& ?. j& E4 f/ I3 f# x7 sprint(b)
. V1 k0 R( O" J+ D5 b8 Yb. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
- u1 l$ z1 y. c% tprint(a)
1 y# \) z( N1 T8 h: l" b* a( j& qb=a.decode('gbk')/ L. `( K( i- W5 D3 I' l0 y
print(b)28、求 1-100 内的所有数的和1 m# b0 @1 L) D# q. d
count=17 v3 @- \, l& B; S. k  s3 e% a
sum=0
4 T" N5 R9 m' G5 gfor i in range(100) :8 r: H6 h3 Q7 ^2 u
sum=sum+count
1 v4 N6 w3 ?! a6 O' | count+=1% e9 G  V$ d  [, f
print(sum). m9 M( w0 L6 Y2 P" W

. X& P, v4 Z( K: O' m9 ncount=1
7 ?: R+ y  b' ^! l# {1 Msum=0
- o( f4 \) Q6 s+ j* Kwhile count<=100 :
& Q* @& d; \) O( j- i  D sum+=count0 R/ r) M, l0 D- c7 ?8 u- U# i
count+=17 [8 X+ U/ M/ h  f
print(sum)29、元素分类' a/ d8 }3 E, |" w
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
6 g9 O' m* h: I9 p# d7 _将小于 66 的值保存至第二个 key 的值中。$ K2 p1 f/ S, ]* N8 b
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}4 X. D4 _4 k- V' D1 v: \0 g9 a
li=[11,22,33,44,55,66,77,88,99,90]$ C7 a, c% ]8 u
dic1={7 k. F% o4 a: e7 J& T
'max':[],% J. v! @8 t' X
'min':[]
; r  B9 [* R" a& L. u$ i% }}1 M( R" J  f3 g) ^9 M  {
for i in li :( S2 |1 d9 d% _8 P
if i <66 :6 M! _8 [3 ~, R* }
      dic1['min'].append(i)- G. q0 {. e; J5 ]( {
else:
% l& }$ X% ]+ K       dic1['max'].append(i)
7 M7 u& K0 R6 W0 ^4 k; Oprint(dic1)
$ l: D5 |* @) K5 l
. X8 U& H* }: m  ?---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}* R. \+ z. v; o2 O) \5 k6 B/ R

Python基础知识汇总

主题推荐