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、写代码! e2 V) k, {* b, ?0 O
a.实现用户输入用户名和密码，当用户名为 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 Z7 x- ~4 a$ R3 d name = input('name:').strip(): B/ {' T, |: V2 A
pwd = input('pwd：').strip()* h( @4 Z' a3 m3 C4 o' R% a

8 K$ ~1 j, m9 J* z3 ~5 n7 P+ V, V& | if name=='seven' and pwd=='123' :
+ h" X, u7 d) b0 b6 ^7 d       print('ok')0 G8 P, Z( J6 m$ J( |# I
else:
" W- P4 J# f7 L' |& B       print('error')
/ Q# S0 b) J* m- I  \- @6 d       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)  :# R4 O+ u# {5 Q# |
name = input('name: ')
/ {" k; J( w- {% p# K9 v5 ]7 _ pwd = input('pwd: ')
& x- G; {3 \$ l- h if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
3 T. D) Q8 \$ \, j9 G       print('ok')
4 ~% Y& v' W3 b5 H' e: U5 x# i7 I else :
! {" A8 p4 E% u4 |! P& F* D6 k% N       print('error'). c2 @+ d$ B( N0 Q7 l7 `
      count+=111、写代码
, g9 L! B  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) :
" I  l0 ]2 ?/ b$ ?# c* L if i %2 != 0 :* C; D5 o: |& O/ C  K
      print(i)

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

e. 使用 while 循环实现输出 1-100 内的所有偶数
for i in range(100) :
$ Z: O; h/ b! K5 t* B! H if i %2 == 0:
! \) T) l  H2 P$ g) w       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"6 b9 |# `. Y7 Y# O8 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)" T# u' o9 l6 p' x# }) o8 s- a
for i in name:
. z" }6 l: \1 h% }) g4 J. P print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain1 b2 _. N7 y) t* _# G- ?* m
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']3 T, e8 _6 j; ?- w) z
print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
7 `  A6 J6 `: T' ]6 P/ B0 J5 dprint(li)4 A% A2 _4 V# {4 \! r8 }6 B" Y4 a
['alex', 'eric', 'rain', 'seven']; G: T: {  r( z; o
c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY'); k8 q, M" O  y" g% G- V( [% V+ R
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')0 Q- R. w4 Q- S. F, a$ V
print(li)3 {" D; r0 W/ N+ E* p9 r9 ], {
e. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
8 p5 r- v( N  F& hli.pop(1)
  ^9 a8 j) q$ H9 Dprint(li) ['alex', 'rain']
8 ^0 c5 Y# g4 O1 h. m4 ?& H  K& l* Q指名道姓的删除li = ['alex', 'eric', 'rain']
$ s4 |* P& I3 D; ]" Eli.remove('alex')& W( a) j0 y7 m) ^1 O, @5 @
print(li)( R7 L2 H/ z1 l: v. t4 J/ p( B2 u
f. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain']
! J4 _3 J* B7 l+ Y! }- Lprint(li.pop(1))& A' X, Y! _1 W: y, h, \, W% z
print(li)
0 x' `& `9 K7 J7 K
5 T) D6 h# g9 e1 \8 u4 X0 |; }eric
/ P" N; u/ ~8 L4 J4 w; C9 b['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']7 z/ [& ~6 L- E' ?5 {+ a
del li[1:]* U  o  e7 {$ `2 J: U
print(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始)
" `0 R9 j( y8 f& s+ [" b  [8 j0 Dli = ['alex', 'eric', 'rain']
6 X$ X% h$ e9 E  D4 @7 ]for k,v in enumerate(li,1):
; @3 p- ~+ D# U/ ^% e print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
! Q5 d  ^3 n9 p/ T; \, za. 请输出 “Kelly”  P/ g" x+ w% @7 V) `- ]  W
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]- }% N# G4 T. Z+ Z* K% p2 G* P1 B
print(li[2][1][1])
  f4 G" v3 |* M4 ^  R+ W5 qb. 请使用索引找到 'all' 元素并将其修改为 “ALL”9 _$ c8 `/ |  r0 E, s6 [5 n
li[2][2]='ALL'
# k, k$ H+ U4 \* P" _0 i* r! jprint(li)
" s) B+ v9 Q+ n' w$ v: E1 E24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')8 R% V. t# F8 M$ h" ]2 {* Z/ v
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain')0 v! m% H5 _1 b5 D; c8 a2 c/ o
print(len(tu))
, n5 p6 d1 E( W) Q7 H2 ^b. 获取元组的第 2 个元素，并输出+ T% s/ h, ^/ _7 H) h$ R* a
print(tu[1])
6 D, O! \8 S% o  I" [4 _e. 请使用 for、len、range 输出元组的索引
+ x; m, D- Z8 s5 X, z8 Nfor i in range(len(tu)) :; Q# h3 i7 \! s& D
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
7 x! M3 h: a" L: c6 ^! U9 `1 w0 mfor k,v in enumerate(tu,10) :
) M; s+ \9 `: X! P# m$ A print(k,v)' ], m4 R; H  |5 k; e) }
10 alex" u7 z+ }3 E+ x4 S& W: t7 \0 v
11 eric7 W: m) Q/ T' h! B& o1 b, V* k$ L
12 rain
+ H) F8 e# _8 R% C3 @3 C" Z* r0 f' \, B" J2 \# t
for k in enumerate(tu,10) :' w+ l% D) D' j8 c) L0 x7 ^7 _
print(k), s  w9 E' Y. A) y
(10, 'alex')
. \* x7 y  M/ f) D(11, 'eric')5 B  X: P1 H& ]5 z0 F# ~- E
(12, 'rain')( A. N# V; x* }) {2 D/ |4 t

! J' Q; Q4 w2 f- c" T+ \2 m
" u7 u6 b% q# ^! G25、有如下变量，请实现要求的功能
/ v- a4 a( E0 q( I" T, e2 ?3 Y, Ztu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以

# T$ v/ A1 r4 o+ a* Fd. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以
% x8 _+ y, e+ `tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44]); L. p4 h) u) c
res=tu[1][2]['k2'].append('seven')
* }! p( l: r6 I3 U" c9 ?6 c# j2 b% ~6 ?0 z. ~$ _  B! y. Y  B
print(tu)/ ^9 O7 c8 z+ h% i
26、字典
0 d. A/ F- S# x* z3 q' l4 Odic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:" L6 A' k& h7 T" d. p2 [
print(i)b. 请循环输出所有的 value1 m9 G* a! n. {$ }, j0 z" s
for i in dic:
7 Q( I, N9 \! Q* B7 ` print(dic). r( W( K1 X  B
c. 请循环输出所有的 key 和 valuefor i in dic:
! p1 ?3 j; |  |print(i,dic)
; _, L: l1 Q0 e: a3 g1 L% cd. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
" k: A4 L9 {5 p6 _dic['k4']='v4'
4 ~& [. n1 N# F# a: w: I) [: Uprint(dic)
# F* U3 C" U+ y# R2 Q+ m8 M& fe. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典+ T- q* g4 f$ c. w
dic['k1']='alex'
& P" _2 X+ g! Kprint(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典
; W/ e: ^- ?5 ^% t+ ^- a$ v0 ^dic['k3'].append(44)
8 S9 y6 C3 ]+ m. u$ wprint(dic)
+ g* O0 g1 B) n4 M8 A( B+ b* _, ]% j! D) @/ C5 B% O
g. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典) Y% J  Y/ `' d( ~
dic['k3'].insert(0,44)
% @: r. O0 l# D0 ^# hprint(dic)
5 T. x0 P6 I. Z& s, v7 L: M" @27、转换0 o6 A2 t& }( \: U5 v; {9 ]. y
a. 将字符串 s = "alex" 转换成列表  s = "alex"
$ I1 ^9 u# ?) E4 n
/ z$ B  ?  P% N% w; J! _, Iprint(list(s))b. 将字符串 s = "alex" 转换成元祖$ }5 |4 ~; D1 p+ Z
s = "alex"/ {: q: z& |7 E* V1 ]& v# ]
print(tuple(s))! O0 V3 U& J" w$ h; n. a

! g% |* F: ?3 ^  k. ab. 将列表 li = ["alex", "seven"] 转换成元组. L3 K; L4 W  Y7 v, [
li = ["alex", "seven"]
( U, Y' a9 S# ~4 c3 @( G$ z- f, n* u0 tprint(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表
5 Y7 {" V  K0 p5 k) Ktu = ('Alex', "seven")
  o' n: z$ Q% }li=list(tu)
* q! n6 h" C# u6 G) H# x8 a# D5 ?print(li)
( |, E% m% z4 S  W5 l. S
2 @( ~0 T7 R3 m7 R% H: s1 W- M+ f9 U# z9 k; w7 c% |) h
d. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增# `. z3 }0 H- D8 v- s
: _2 Y& O% X& o, {6 K
dic={}
5 J8 _7 p4 f- r3 cfor k,v in enumerate(li,10) :----li要放在前面，序号放在后面% G- b$ _+ y! h% n4 I
dic[k]=v
) [2 G5 t3 F' ~0 ~/ S0 J print(dic)27、转码n = "老男孩"
) Y0 B9 r0 H% M& l0 @a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"
6 w8 y/ a  Z& D: L4 x/ z  xa=n.encode('utf-8') # X. O5 z! X; ~# E% a+ H
print(a)  N) _' Z0 t( X! H. `2 M
b=a.decode('utf-8'). _, d- K7 |: R& A' P
print(b)
$ C1 |* u$ o9 u$ x7 Db. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')
$ n/ W  ~! q) m% B1 H0 c' pprint(a)
5 v4 ]6 b, Q/ P# f& a3 ^1 Q( ob=a.decode('gbk'), j5 \+ P( c/ h8 \1 Q0 d8 s& a
print(b)28、求 1-100 内的所有数的和, ~; P/ o& H6 \  h
count=1/ P* O4 q1 j5 S3 r( F  i7 j
sum=0
9 v3 b, Z2 C' ?3 s7 F& sfor i in range(100) :, |8 U1 C' U& v9 J: q
sum=sum+count
( V# j( m5 M* e5 v3 ^ count+=1/ c6 D2 P- j' |' j2 m( C) {
print(sum). W' X) P4 g- S) }

4 J# J* V' I8 Q& icount=1; y3 ]. x% g5 |8 l, D$ _+ `; b
sum=01 g- i  z( s2 d- g
while count<=100 :
4 W+ Y; @: Q& ?. T  N4 a  k. P sum+=count
& T7 Q  k1 k. ?3 K* y6 M9 [ count+=1
" A1 q$ \; s$ |! Q2 G/ z  Yprint(sum)29、元素分类% D6 v3 ~' W4 Y% u- O7 Q& t! P
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，1 h, u% S( |( h! t
将小于 66 的值保存至第二个 key 的值中。6 n3 E+ c; v0 k" Z5 D) S* w& w
即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}! ~9 Q, f/ Z! w
li=[11,22,33,44,55,66,77,88,99,90]
* N) ~* i: p9 ^( ], D# Fdic1={! z" j1 Y' C8 T: ~
'max':[],+ w2 P" z; {. N9 Y+ |7 y$ H
'min':[]4 w( u7 J" o% L: B7 z/ h) C; R
}4 _4 U* r+ b& r# R3 ^
for i in li :) C1 x- g. w3 A$ v, @  x$ j' g
if i <66 :
9 E$ q# f8 B: F+ A0 Z       dic1['min'].append(i)
2 `% h- v. }* e; O3 I% s: K: Q else:" S8 I, j' Y; o, |, A' m
      dic1['max'].append(i)
0 F1 [' w6 y$ M$ N6 i2 Dprint(dic1). ^' ?& Y+ k. @+ k8 t0 k

1 [+ x( F- Y, n: g& r3 l# o: X---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
: |% I, G( i& W  |5 K

Python基础知识汇总

主题推荐