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、写代码
/ \+ _, t+ J4 W' [* ja.实现用户输入用户名和密码，当用户名为 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) :( c) i, s4 t7 D6 g6 }+ }" v
name = input('name:').strip()
1 \6 ^2 r6 b; J# k' [3 @. E; y4 p; z pwd = input('pwd：').strip()) r: z9 c" U9 k- z

, V, R/ Q9 p4 w- A( |! g if name=='seven' and pwd=='123' :
/ g$ s: a% {9 X5 v       print('ok')
/ F: r3 m0 g3 Q else:
4 h  g) F+ P& z. G       print('error')
8 r1 @3 N& \; m/ a& K7 E7 ]       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)  :
- K* Z0 {! r# H& u, r. ^ name = input('name: ')6 n  }: F. X) q& U7 T0 F1 A
pwd = input('pwd: ')
4 v* d$ i9 n$ e( [- K. l if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':# s8 p8 @( Y7 M) t
      print('ok')$ q7 q* j8 m7 b* v0 s
else :  m# C. V! O5 T
      print('error')
/ N2 d  S5 X) F) L1 R* Z* V' J5 z% F       count+=111、写代码
) J4 O9 R& \+ ~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) :
* p% O% Q) ~- K) k" o if i %2 != 0 :1 ?8 p' @, t; ^# H! F5 n2 @. K. X
      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 m+ m9 }& t1 F5 ]2 l: Q4 |% ]
if i %2 == 0:6 s0 \; x& Y# m# ]
      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". k( I& [( Y# o/ Q$ E2 W
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)  f" c5 E. j0 L8 g
for i in name:
9 s  @0 i9 \+ M print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain+ H2 t7 O! [# r: r; B, L. \
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']1 x* T6 ?6 z$ p. I
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')    7 p# I: {" G- a9 @
print(li)
% u- b$ o) Q3 _ ['alex', 'eric', 'rain', 'seven']
7 K* W! m! }, D, Lc. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')
. f; |9 C0 x' U6 k" g' u8 s  ?print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
0 _: m% L2 W1 }) C0 a( t7 G  U* n# Uprint(li)4 K5 F" d+ m' z
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']! G' O) U% _. p  K/ B3 a9 C1 S% v: }
li.pop(1)
( `9 ^+ m, j& h' u3 F. lprint(li) ['alex', 'rain']
# M% }( p- P3 m" ^% ?- O. N' Q指名道姓的删除li = ['alex', 'eric', 'rain']  Z3 ?6 g  c: @/ ?7 t/ Z$ ^- y* h
li.remove('alex')" Z# O* n1 ]2 j
print(li)( d  S$ l6 ~) `
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']8 ~* t8 P$ X- g
print(li.pop(1))
& \, O6 z: O6 mprint(li)7 D( r& _* X% t
  ?# r% q) E( k; O& K/ I
eric( x/ X  v( I1 k! X$ k& z, C
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
1 u& f  ?. z; X. p2 w9 U! b/ f' I9 Udel li[1:]
6 u/ N7 r& q3 {# j' C. |print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
9 z+ t% i0 E, [+ hli = ['alex', 'eric', 'rain']  ]+ J* s$ F% m
for k,v in enumerate(li,1):4 F. U3 T1 M) ?% M0 \4 O
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]* h  d; t, u1 b* T, D& X
a. 请输出 “Kelly”
" X0 |, x7 l, E! h0 Xli = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
+ U3 W6 t; F" T6 e/ r5 D! Vprint(li[2][1][1])
- E: w; }( b+ W- g, p0 Wb. 请使用索引找到 'all' 元素并将其修改为 “ALL”
, v% o" {8 w9 q+ T/ w) C, ali[2][2]='ALL'
7 F; D+ @0 d" f/ Dprint(li)$ N, |* T3 @/ u' P8 q, \" B7 l* @
24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')
& D% s' O- n0 i2 Y5 R9 Ca. 计算元组长度并输出tu = ('alex', 'eric', 'rain')
& i. _3 G  g* \- _' hprint(len(tu))! B6 o4 g( A  E6 Q: ~6 s: G' s
b. 获取元组的第 2 个元素，并输出
4 F: N8 m, M2 X( U' K; ^print(tu[1]), Q  }6 Z* E) {* B$ ~- e
e. 请使用 for、len、range 输出元组的索引
8 M( M" {  }. h# C* Vfor i in range(len(tu)) :
- n# t  f5 t, ~9 o print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)# E- F/ f7 a( D4 `3 |+ f2 V; F
for k,v in enumerate(tu,10) :
/ }1 i" O( m; b: g) F print(k,v)8 k. o% S# x" W1 ]* J% O
10 alex& t+ D" B1 F4 |
11 eric; d6 c! ]) T$ ~% g9 D
12 rain
$ G5 X3 M# P: E' Q% K. o& e# ~% T+ |
for k in enumerate(tu,10) :
, _' O+ f' q2 h print(k)
% u# P4 Y+ j( j# U3 ?1 B7 m& N: L(10, 'alex')7 z; S4 E' v" O0 B% ^
(11, 'eric')
- P& g. G7 B- d  C(12, 'rain')! y& a! j9 k4 \5 q1 ]& v( S
0 z+ l5 W* k; t

! L: f: k6 C/ v) {5 ~' W+ w1 ~25、有如下变量，请实现要求的功能
4 N: j- S- F5 J. v4 M0 ytu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
* S% K8 }' W3 s# d0 R
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以' T7 i( }$ u& U9 p: K( Z$ b
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])& T% C$ E( V: @9 r; Y# K
res=tu[1][2]['k2'].append('seven')
  ^+ y# i" {) c' n2 b6 a! e  O7 e6 Z" K% U% T
print(tu)
4 R4 o: E. f, l2 t7 u' D2 E/ [26、字典2 e6 X# L$ I* D& l: Z% v
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:& Q5 D- H! j5 {( }( i' D
print(i)b. 请循环输出所有的 value5 N( q; t( ?; c3 g9 X6 u
for i in dic:
* b; Q$ R& ]# Y5 t% x print(dic)
# T2 l; `: \! g" K" ic. 请循环输出所有的 key 和 valuefor i in dic:' ?& V( b  w% L
print(i,dic)! T! Q% x9 u5 l4 L8 j' u
d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典6 t. [# p0 Z6 k- d
dic['k4']='v4'0 M9 D: M* a* P( v, Y
print(dic)
/ z$ H# u: M8 j* ]e. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典& }9 ?) i. h5 i+ e( {
dic['k1']='alex'
7 f- I/ b  h, A! |+ mprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典2 D$ [& c0 R* Y, \% L
dic['k3'].append(44)
' A, M# z+ U+ v0 }- Hprint(dic)5 {, P, Q. h, @6 n/ f, `
: @; k1 c9 W. a& A$ a/ R
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典
0 I) f; u) K- [& A# {: xdic['k3'].insert(0,44). C& }% @! l6 Q
print(dic)( {5 [* u0 B( v
27、转换9 K) h7 M  X9 h7 N# o% a. \! s
a. 将字符串 s = "alex" 转换成列表  s = "alex"- {' n$ d/ e5 s2 J4 ?
5 X8 R1 B+ F% [
print(list(s))b. 将字符串 s = "alex" 转换成元祖9 R0 [. i" N% Q; q
s = "alex"
  J4 Z0 d8 n% kprint(tuple(s))
2 f; D) ?) j% B( [! b: J. `7 N
0 u' L  ]& R3 `5 s1 N1 k$ ]$ L7 cb. 将列表 li = ["alex", "seven"] 转换成元组$ I  ?: M1 D' t+ q" z
li = ["alex", "seven"]; J: }2 X; ?! Z- _" X  b9 ?
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
: l8 E, Z+ |. [4 V+ d9 Ntu = ('Alex', "seven")
: i1 R: G+ y% T$ ]7 mli=list(tu)2 w7 f: v" `1 K) G: T: l
print(li)/ L! u) f# S: H$ d4 e* O
7 L, `$ G) _+ G5 g; I; X" }: N

! f* a3 z7 N+ x7 {1 Qd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
6 B) C/ f' s) l& ^  E5 m& ?. o4 U8 v4 j# p' `0 N6 t! k/ r) x/ n
dic={}
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面% t) I  s  r* |! U( ]
dic[k]=v4 @7 v) z6 F5 |+ C  V
print(dic)27、转码n = "老男孩"
, w) B* p. L& Y6 v& [a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
, N# ]# Q) d5 Q9 ia=n.encode('utf-8')
4 f& t2 I- U7 m$ X  S2 u  pprint(a)
* O9 g7 s) g  {* U7 A' g+ l- nb=a.decode('utf-8')
" H3 }/ k6 A3 K$ T  Y9 q6 @print(b), U  @: e) ]" Q" _5 w
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')1 z- D, g( t; r0 p! j
print(a)
/ {6 V3 s& p' I! m: f7 N/ r1 D9 mb=a.decode('gbk')
1 U8 N, o- y! Y9 ^+ ^! R  h8 X0 Dprint(b)28、求 1-100 内的所有数的和
. l2 T0 s& L) Z+ Gcount=1
; l1 T( h/ w2 ~, z1 Xsum=0. u2 r% i/ N4 c. F1 U
for i in range(100) :) T+ v# w: A; E" l
sum=sum+count
, b$ A$ D2 l0 M) P9 Q4 B* z count+=1' q; K+ a: H, `$ |5 b! H
print(sum)
0 ^2 s: Y% k# y- d) _
6 h2 G! b6 p1 o8 W- H; |count=1  [* o6 {! ^* w1 k
sum=0
$ b4 k8 O5 C4 y0 \while count<=100 :
* X' h* q% s7 {" B sum+=count
0 I; G( z" k* E6 k) |) U; U3 b count+=1, p* ^& p3 t2 I+ ]- L- L1 u' L
print(sum)29、元素分类
4 T" j! C- _# a6 ~7 P7 G有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，
% Y. ]& r( g4 s) m将小于 66 的值保存至第二个 key 的值中。  i- G! x( _! w" Q2 T
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}$ l- L( s- @- P- O
li=[11,22,33,44,55,66,77,88,99,90]
- M  s& {8 c2 G( g; s( ^8 }" @dic1={/ ?; c: }- D5 P; J* j
'max':[],
* H, r  @: ~/ u; O6 V) p 'min':[]
! `: H8 r% V, o  [, J& Y1 B}
( p* d6 ~5 j1 P" Y( i. efor i in li :
) {9 u! P$ D  }, J if i <66 :
. O) t& l- d" g2 ~+ q% }/ }) \       dic1['min'].append(i)
7 `# A8 S1 C" m$ a# N" T+ h; B else:+ R$ d, {! v! a% X# q; }
      dic1['max'].append(i)
" A5 v! {% h7 l- i; o/ j0 Z2 }print(dic1)
" g3 m5 W* U0 G- P6 F+ ^1 A) V0 q( t3 d
---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}2 j7 z# S! w4 l" S# d- b6 c+ b% V, V! ?

Python基础知识汇总

主题推荐