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、写代码
. ~  j$ ?/ O# J7 c8 ya.实现用户输入用户名和密码，当用户名为 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) :
1 j6 a, b7 I5 u4 P name = input('name:').strip()/ {( W8 V$ x8 b; x4 o
pwd = input('pwd：').strip()" y$ e7 Z$ K" x( _$ `
, V3 I. \2 f+ I% v- T
if name=='seven' and pwd=='123' :8 k9 C. N7 L) c) |
      print('ok')  L1 `5 Y+ A6 I9 @+ W2 V: y
else:
2 C- W7 B+ X% F' _5 O! d" T       print('error')6 F& i4 J! M* I! f/ k8 ], \+ z0 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)  :
5 D5 Y# o( u* k# v name = input('name: ')% o- L  M$ n) P7 n# p0 g+ q
pwd = input('pwd: ')$ `& [% L) j! A$ \! M* ?' ]
if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':) q& `) b; [' z& x. M5 \
      print('ok')
4 V6 i1 Z+ R7 Z- B; E else :5 g8 ^  V2 k4 k' N) X0 Q
      print('error')
! `. l: P- R& U6 r; G# ^0 G" @" h       count+=111、写代码* K- H) l$ z. [4 l1 f- c
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) :
' k; _! \) F7 `. k, O' g if i %2 != 0 :
' m' }0 t  h7 K7 y( e# p; D' l       print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
1 J0 r% F& a; d6 I+ n) I8 o" i' O if i %2 == 0:
/ ~4 C$ {% o  [& l7 I4 b$ B8 }6 _       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"
. t4 W! m" k$ y, X' ya. 移除 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)0 V' n+ p/ F9 U% Z$ H% u: I
for i in name:9 {6 L! _( W# ]* n
print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain9 |, N; ^, M9 ^  L5 K1 O4 v
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
* k( F' h2 L# M, w6 [print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
# A' u% v; f2 }/ Uprint(li)$ M4 ^/ j# q. b' P1 Y0 ^2 ]
['alex', 'eric', 'rain', 'seven']
- G+ \/ g) h0 O% f. i( I$ P1 u  gc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')5 T8 {1 }; p9 q' V2 e
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')' k+ f0 ?0 E+ M
print(li)
9 r% f1 N" V; m- U+ o+ J; }e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
9 }4 o0 u' G) w, Fli.pop(1)2 H) p; v. L+ W! ~# {
print(li) ['alex', 'rain']; v7 C% }' T0 |2 p% ]! h/ `# S9 d; H
指名道姓的删除li = ['alex', 'eric', 'rain']$ C7 ~  o7 c- b$ G% @* y- `& W
li.remove('alex')5 t/ H2 L8 n0 f0 _4 F
print(li)! s/ h" G+ H: @5 E
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
7 A& t9 D9 K, y( Pprint(li.pop(1))
! r8 O8 h; X6 M# Z' E& vprint(li)4 h2 j$ Y7 _. C6 U. c

  E! g3 b: Q4 C" n; A/ seric
4 N  E$ U: u% s& h6 a' A['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']& X" k/ z+ T0 b. n6 T
del li[1:]- I6 N) B; M( r$ z. n5 E; C- W8 r
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
1 ^5 Z" B) E# }" rli = ['alex', 'eric', 'rain']
- _: Y- G2 z; g$ e% i4 Sfor k,v in enumerate(li,1):
) L; q. N7 x  P% s# O1 [. l print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
2 Z6 P4 z# I+ q' ~/ N5 G3 e% |a. 请输出 “Kelly”3 |1 T/ s8 ], G8 [8 f* a5 u- F
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]5 Z+ d& l: Z( p) b. D+ v
print(li[2][1][1])
0 c# `8 E+ e3 [' q  M& q2 @b. 请使用索引找到 'all' 元素并将其修改为 “ALL”6 P7 s/ b+ y* ^+ u
li[2][2]='ALL'  f, X1 d. K; {9 N4 |& h3 y6 W
print(li)
% `+ o2 _$ X2 V$ r+ ]24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
! k2 T  `, p8 W7 W0 m) N% za. 计算元组长度并输出tu = ('alex', 'eric', 'rain'), Y6 A4 x+ g8 V& i0 z  B
print(len(tu))
: q' y0 |. Z$ Y# ub. 获取元组的第 2 个元素，并输出
- i2 j. C+ K; f; ?9 \print(tu[1])
7 L/ l( M: ?; `( ]e. 请使用 for、len、range 输出元组的索引
+ c6 H5 w- V7 U2 n6 ~for i in range(len(tu)) :$ g8 a$ W$ H4 G& e* V$ `% v- E
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)8 I! N( m4 `; N8 q
for k,v in enumerate(tu,10) :2 g% K3 M* X. a# O5 X  _. O# E; N
print(k,v)1 m- v  ~# h# w6 u% K9 Z, j; Z6 i& P0 B
10 alex' e0 \! k5 B7 ?. E6 @' D- H
11 eric. G, f5 r% c2 I$ }4 X
12 rain
/ r: K$ s8 O* s6 L6 `0 F) V2 l4 t3 z0 g: `% z3 V6 U# V
for k in enumerate(tu,10) :
+ U5 W% k, [$ X3 s, S print(k)  x( R6 v4 |7 K# `0 v' ~
(10, 'alex')) s6 I% v6 z+ v& p6 s& u% X
(11, 'eric')& V8 q% C+ j' {+ L) B
(12, 'rain')
) V2 X8 m4 I6 n9 o! _  s" o4 g3 T5 j$ `+ k0 J1 _
5 r3 e3 V$ _" H2 X
25、有如下变量，请实现要求的功能& c0 C* _6 B8 P0 c
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
+ a. v' B) @2 a3 p  s+ |% x# e
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以0 l# Q) _4 a4 ]
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
5 S2 r" P- M6 o+ ?, A* i( ^res=tu[1][2]['k2'].append('seven')# ?0 \" X; U, |. S/ j( \6 D

6 o! X/ ~; K5 N6 o" L" a8 n2 S" ~print(tu)
4 Z4 A& o1 g* l" k26、字典5 T$ T. i: _; ~* h0 A
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
# @9 @- W9 {- X# @ print(i)b. 请循环输出所有的 value
' p9 u; R0 Y* S+ k6 N+ G9 Bfor i in dic:; N/ x9 `: j; E( E9 H
print(dic)2 h. O3 G$ b% x
c. 请循环输出所有的 key 和 valuefor i in dic:, ?; N7 ~5 Y" {1 m6 L
print(i,dic)/ t3 j8 }* l: S' E$ Y
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典/ w) }. D2 G1 N& |& b! V" U
dic['k4']='v4'
. z! S0 m* A6 q0 g) Pprint(dic)2 ^5 s6 b0 f- r0 O: P; Q' V3 T- @! K
e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
4 M9 ?; {( G+ ]# ^dic['k1']='alex'
4 p" l& y- M% x8 H# Sprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
+ E4 @5 L1 S  o. o; H/ Jdic['k3'].append(44)+ Y, x( Q2 p$ ]9 `
print(dic)
1 F7 E; p0 z% e6 u9 F' |5 A& z( M: M5 Z3 ]5 y3 M
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典, }. _0 c6 f6 f' l
dic['k3'].insert(0,44)/ x, G# l( w, H$ j
print(dic)
! @0 N6 t! _0 ?( h  r3 f5 U27、转换0 K& P3 n  [6 \( h5 ]) Y, W' G2 g
a. 将字符串 s = "alex" 转换成列表  s = "alex"
$ S8 {: H; d3 W, g( L) p! I3 F; X0 h" Z. |" ^! t$ W8 h2 {) A
print(list(s))b. 将字符串 s = "alex" 转换成元祖
, U: [3 I! T/ }' L8 Ts = "alex"  C% G2 P8 b/ m8 o2 \# d
print(tuple(s))4 p' z! o) ]% x3 O4 u
% v6 F8 {+ }5 V
b. 将列表 li = ["alex", "seven"] 转换成元组7 J9 |: M, S% y
li = ["alex", "seven"]
  x1 d1 |% d+ z  ^; I9 Sprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
& r6 p6 j  Y# D% ?3 n* f4 x; ]tu = ('Alex', "seven")2 T' p' |; ~' O
li=list(tu)) D2 C" E! h& S# d7 m) H$ U$ y
print(li)
4 m% P' k) g2 I$ e" Y$ Y
3 M9 ]' K3 Z$ i8 v* ~: e4 P, C5 ?& T1 K2 _; e
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增; k: u0 u; T( ?1 m  o* H
$ w: l4 F$ ~4 ?+ B+ u
dic={}3 Y' F. u% f- [4 K, `
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面4 Z3 t  P7 N( y) c9 R$ Y4 C
dic[k]=v
2 M* E- D. K0 [3 e print(dic)27、转码n = "老男孩"% p" Q* V+ J* I3 G! I
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
3 w& X8 p# O- P3 M# F( ?; J1 e" Fa=n.encode('utf-8')
, f7 A! H  A2 d$ W3 [6 T+ Dprint(a)
# i9 _. \5 @* r! W% ub=a.decode('utf-8')- S* O  `) H4 D$ V" _
print(b)8 [6 ~, _3 p; O& V
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')  T& \0 _3 @' G
print(a): C7 `. R1 {) H; R
b=a.decode('gbk')* Y: r" F+ Y# d+ W
print(b)28、求 1-100 内的所有数的和- c. u4 O  p4 I0 v, N3 @: E, c
count=1
/ t) L; t9 n1 Q  i7 \# Usum=0- U% s6 [. s! D$ h* T$ H) C! z
for i in range(100) :
1 R# y; t; B2 B' T( T/ p2 O sum=sum+count! ]0 x2 R) ]# r4 Y7 R
count+=11 ]9 h8 `  B2 z8 [
print(sum)4 `* t* t7 \. ]1 `4 @' \
( a# @7 A9 ?1 a4 U  K
count=16 P' D( m% L/ t. p7 O) @' K
sum=0/ r% b1 e4 H5 d4 J, N
while count<=100 :
0 j+ e+ L# S0 e- h1 [3 d4 t& B7 N sum+=count
; r1 h) {6 P! @; ~7 m$ K4 g1 P count+=1+ @& }- ?" K2 W
print(sum)29、元素分类
! X- ~% m  r- y" d" v  ^2 S/ N& x有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
* v/ g4 ?$ J  m将小于 66 的值保存至第二个 key 的值中。) u, Q/ ?  G' ]9 s) b
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}* ]% t, N4 Q( l* U3 B% `6 Z
li=[11,22,33,44,55,66,77,88,99,90]$ u7 b9 c( e0 o; Z
dic1={. |+ e& v; J+ }# `
'max':[],
' |1 |3 ^# J1 M+ F 'min':[], `5 V: [1 Y* J
}3 U# z4 L- C( n5 J9 U6 i
for i in li :* [4 Y! m" M) E$ N- C1 ?( S* ]: Q7 r
if i <66 :9 r( p7 y9 [( O
      dic1['min'].append(i)" L0 Q+ l2 h% ]( e
else:
* o! t5 I: [. H7 t( B; @       dic1['max'].append(i)" r" Z7 |- Y7 l3 _1 `4 z9 i. v
print(dic1)
2 E3 B* y8 K7 I& E( N* T' G+ o9 J. }8 Q4 J1 j2 s
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
! A1 N6 o4 `5 B* W  F% K% r

Python基础知识汇总

主题推荐