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、写代码
) V) W. @% k/ e! O$ R4 e0 Va.实现用户输入用户名和密码，当用户名为 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) :* M/ U4 G6 u/ p
name = input('name:').strip()' L' Y2 p% d/ F# U$ F# x3 |) y
pwd = input('pwd：').strip()1 v" p2 Y% M6 G. I0 l8 r
6 S: [! v! W+ T% |
if name=='seven' and pwd=='123' :
$ j5 z" E& ~9 S$ M5 P$ T       print('ok')- d# X+ a- u# T0 G0 Z; `
else:
. l3 K' D4 @. p. r       print('error')
% |& J3 [+ n) R+ m5 |; `0 i       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)  :2 b' P" a+ g& A" W9 i( v6 t
name = input('name: ')0 f2 W3 x6 r5 Y! H, T3 U
pwd = input('pwd: ')
) _# W% c' i+ ]) ?1 S if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
& ~" {, ?7 r: `( J! ^2 u5 v       print('ok')7 ?. P# b, p, T
else :' X6 ^, y1 @0 a$ U" c
      print('error')9 R; h0 m+ I/ X7 ?4 Y+ O: @1 r$ g1 |
      count+=111、写代码6 p1 A/ z2 q' e( w% P) ?
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) :
' q2 \& b7 U, `0 a if i %2 != 0 :
! B' t1 O6 V. e       print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
+ R, D7 K1 Q+ W( ^ if i %2 == 0:" l3 }: B1 I9 K4 f- z0 i  F7 O* l
      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"
2 v; X' W1 ~/ e3 d! M+ Ua. 移除 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)
6 G# L/ b* y2 ~) B' dfor i in name:
) t  q) Y, {, w. \6 N4 k7 }: m print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain4 t) i. C" [' F7 O+ H9 p
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
- L; |8 [$ L' N( j# w' kprint(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
. l; q+ z8 L8 |4 k/ `. Lprint(li)
; @4 |4 D) [; O0 p9 S ['alex', 'eric', 'rain', 'seven']3 s  g6 j2 S; A2 y
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')1 |1 f0 M- o) j4 S! z
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
" V# M/ a( {7 Z; zprint(li)) P& K! {, T$ R/ |% ^2 `0 ^" U
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']" p$ M" g& k" Q& L; w* j
li.pop(1)
7 S& A- z: l; t; z% Cprint(li) ['alex', 'rain']
* o* W4 l1 Q% ]指名道姓的删除li = ['alex', 'eric', 'rain']5 w) D0 O1 m$ ]& A9 v6 n8 R
li.remove('alex')8 c& o2 A, q/ h9 P2 U: Q& |8 H
print(li)
/ C7 t8 ~( [7 D/ Z/ r! d0 J9 Wf. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']. ~: Y8 S% [4 M* E. ~
print(li.pop(1))0 L+ l5 x/ e1 }* h  ~$ A3 F/ t
print(li)$ a+ o3 K9 H6 s4 s( K/ e! p) z) }$ j4 f
1 E+ J& G& q) e- I$ w5 b: U
eric
" ~! `8 b2 o$ u. Z['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']. \# _9 D' @6 M: }" B
del li[1:]0 y1 e! W2 G7 R' J# |3 h& {' S$ R
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)2 r% S9 K5 u( t7 j) F4 y
li = ['alex', 'eric', 'rain']
' k6 w! T, x# J, f; u6 Nfor k,v in enumerate(li,1):! }& k7 x  n1 q8 H4 a- j
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
  x$ o: f, b' l. M, Ta. 请输出 “Kelly”: }+ G& b5 D; ^! h$ m" S# ?5 }
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]' B. v( \1 ~: `' C7 b, o
print(li[2][1][1])& a1 u/ G3 h* s6 c& J
b. 请使用索引找到 'all' 元素并将其修改为 “ALL”
8 h6 T% v% h& P* A# x  l" uli[2][2]='ALL'
5 c5 y9 X$ r6 xprint(li)7 ]0 D3 l7 k6 T3 F; i8 I" _% J7 ?2 }- H4 I
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')( |8 [5 p  v$ P% u" o7 h, [2 a9 R
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')/ T, D' c3 |! N6 Q
print(len(tu)), z3 N' h  N! V4 V; d, ?5 [9 N
b. 获取元组的第 2 个元素，并输出# V: q7 q( \, o& k7 W, l
print(tu[1])1 c9 v$ N/ E/ p- W
e. 请使用 for、len、range 输出元组的索引
( @- ]" n( {: Z% Efor i in range(len(tu)) :! L: P/ f7 F" S) j1 c+ k
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)# n1 A7 \+ G' M  e0 k9 g
for k,v in enumerate(tu,10) :6 L& H9 _) Q& j- W; t. C
print(k,v)
; l* c- C9 c$ z" i0 l10 alex# v$ `3 u' I. ^# A- {+ s4 W4 [
11 eric
" w, Y+ H! O1 {% r1 o' b0 T/ x12 rain
+ I" [; f* Y1 }: e8 M! V. O9 k# r9 i+ ~4 K0 p) C7 e2 w
for k in enumerate(tu,10) :% F6 G* g. N. W" d/ x% Z
print(k)- i5 z; ?" j% u8 Q4 ^3 c2 v
(10, 'alex')
3 G. _& S# P4 e4 O% ](11, 'eric')' N% K( m  ]( S- z8 t, }3 S2 f0 @
(12, 'rain')3 D% m' e: I/ {1 q
1 H% G: @/ y8 Y, z

* O8 D$ |) j0 Y) n) T6 s! z25、有如下变量，请实现要求的功能
6 E, f0 w, B& [; k& `+ R# b5 Qtu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
2 {  r3 s; H8 C4 M, l7 o
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
4 K9 I8 Y  z( w$ Otu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
7 W2 g5 w+ d) J* K$ y5 w* Z4 eres=tu[1][2]['k2'].append('seven')7 Z* E& D. r$ Q' a# f6 ?7 v7 W  H
3 r: f) V3 p4 H  a, z
print(tu)
9 x# a, s) `3 P( b$ ~$ z0 ^! W26、字典
$ E9 w4 W& d* Kdic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:
' g! e2 y  e+ A+ W& i print(i)b. 请循环输出所有的 value& g7 M: l3 Z* L2 n/ u( s0 L- G
for i in dic:4 r" S7 j7 O1 Q+ {; n1 }9 e, `- c
print(dic)) H" L) C7 {6 v
c. 请循环输出所有的 key 和 valuefor i in dic:0 g9 ]: @& k$ l
print(i,dic)
2 s. G: \( L- x: Xd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
+ k& H' ~3 n8 p) F! ]dic['k4']='v4'
4 m# A( q+ U+ I5 H% j* A2 Sprint(dic)
; a2 G, G% ^0 |e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典
" _- ?$ F  S: t% w2 A" ?$ b# Ydic['k1']='alex'
* N4 o/ |5 ~3 h1 [& c( C& Bprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
. F) r* h' q) k- ?, Pdic['k3'].append(44)7 s, O7 |" }+ q) a& N& H6 {
print(dic)
& U6 j! W0 W, n& g6 v& H( E+ m2 W
6 O% t& r$ d8 ?8 G# t! g" ug. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典  @) f7 E" Y- \; r2 W* T, t
dic['k3'].insert(0,44)& V0 s# e& c& B! z! S1 Y6 D- S
print(dic)2 Y7 M+ p6 `* C! ]' Z  E) ^3 \
27、转换
8 w0 y+ }6 e  L  G/ v% Ta. 将字符串 s = "alex" 转换成列表  s = "alex"+ K, ~% z6 a4 f$ R+ v

) v0 B) z6 A! l' Nprint(list(s))b. 将字符串 s = "alex" 转换成元祖
0 k1 D9 Z9 A& J4 O9 ^5 m- F( _9 P5 js = "alex". G7 R  w, R7 p/ L
print(tuple(s))
$ {, @9 K# n7 a- x7 X7 ^  [
8 w' o6 K' E. db. 将列表 li = ["alex", "seven"] 转换成元组
0 P9 K" ^( |3 |3 K! e' ?li = ["alex", "seven"]
  E* |$ _) u# F6 L. z( M4 dprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
- Y! ?& u: s- ^tu = ('Alex', "seven"), D; ^0 N/ j3 G9 {- b
li=list(tu)+ W, B$ d( q/ E8 _
print(li)4 F4 m  A1 N5 B6 C
" i. e- P. K8 e/ B
! t8 o6 I0 \1 _, v" X" J3 m# b; \
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增' I+ I2 F6 t+ B/ i& R/ Z! P9 |( B

. K7 E5 o1 _5 F- X" f1 |* Wdic={}
% c: w- n) b3 T  ~2 S$ ?3 |for k,v in enumerate(li,10) :----li要放在前面，序号放在后面
/ g" _8 k8 ]1 }4 l( _ dic[k]=v! t# {/ f% t1 G  @/ u
print(dic)27、转码n = "老男孩"% O# @+ P- H& N
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
' x, j  O& Y  W7 J+ Va=n.encode('utf-8')
; w% }( M5 _" C% {( G3 G2 mprint(a)
. E- J5 R$ c" E$ k, Mb=a.decode('utf-8')
8 ]6 R: I6 y! ~  G+ v- Dprint(b)
) t5 m! C7 v8 ]7 R7 ob. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')/ p2 Y' t3 N" w' J" ?) \
print(a)
1 c; }* _" A/ E! Jb=a.decode('gbk'). S1 A! |. Y" P6 J2 p
print(b)28、求 1-100 内的所有数的和
! h2 y" s6 s5 u1 r8 dcount=1
4 q* U# x" F  b% g9 N1 A+ rsum=0
7 N2 U# r/ N( jfor i in range(100) :
! ^( O$ ?+ E: u' Q; s; G sum=sum+count
2 u  d5 I* ?" Q1 r  I count+=1
2 e8 l6 a$ a# Q6 u1 C3 x9 lprint(sum)
1 V8 I: W& @1 y7 d* W# @# H; k3 Z  \7 O+ b  k4 B' ~. c, `8 G+ M: J
count=17 Q3 P& C, W  L( j+ F& ]
sum=0! i# d( U9 N( o
while count<=100 :; ?; z. t! k' v9 A2 V+ x: C/ v, @
sum+=count
: _' L( d( ]2 {$ y2 T: }9 J2 D count+=1
( K* G# v6 {  W0 N# p" E- Xprint(sum)29、元素分类0 |7 W; h6 Y  J5 N( ]* X# c* [
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
2 y2 y% o9 N; j. d+ C. f将小于 66 的值保存至第二个 key 的值中。
* U( @4 |1 X' x2 [0 I即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}) p" i( Q" I7 L: J+ |7 r
li=[11,22,33,44,55,66,77,88,99,90]
3 V7 o4 r" g' V% }' ldic1={( Q& N6 q( u* n2 y2 r" |- B
'max':[],! p+ t+ Z, r7 W/ C! P6 `
'min':[]2 s# j- r) j3 k1 P" Q* ]% J0 O
}
/ A0 P& r$ C5 x: V4 m6 mfor i in li :6 i! u6 a5 P0 ~! @: W7 E" \
if i <66 :
/ m( z, x6 _6 b- ~9 u       dic1['min'].append(i)
8 ^/ F1 n, k: q& v/ Q* Z else:' m  C$ T8 I* N9 b
      dic1['max'].append(i)9 M8 \  F* O" @7 a+ `
print(dic1)# h. t0 s* r( I4 d2 l8 J) e* d# e
- ]4 E4 {/ l9 n- B/ Y! E, J
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}& `+ L$ H! X. v/ E* w* M

Python基础知识汇总

主题推荐