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、写代码
6 [) R/ ^$ W" V  `7 |8 Ka.实现用户输入用户名和密码，当用户名为 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) :
8 P/ a# F6 Z& c! e& [ name = input('name:').strip()/ G4 }# a6 f( n1 Y7 w( ~& t
pwd = input('pwd：').strip()" O, r3 n- f: ^' F: c
' L) I% {! |* k- j
if name=='seven' and pwd=='123' :
1 F( ~+ q4 M$ ^       print('ok')
4 J# L; ?( i' o1 v# d' o else:; I! V2 Q& t% c9 A& g5 A
      print('error'). H' m1 f, c. i8 x
      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)  :7 M2 k- ]  j# d" @8 W2 N/ s
name = input('name: ')0 y5 b9 f! T; x4 H# D
pwd = input('pwd: ')
3 G) j$ K6 S# a# ^ if name == 'seven' and pwd == '123'  or name == 'alex' and pwd == '123':
1 B+ P6 s' G. Y; Z7 F       print('ok')! D+ b/ f( i7 d# ^
else :
6 j2 W5 Q2 y4 b- A       print('error')$ n6 G  E" H4 i6 f1 `
      count+=111、写代码
$ h+ E$ W0 X6 C, S  _/ w/ ~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) :
+ Q9 w* V  I; |4 a" \0 o0 f' a if i %2 != 0 :: ^% z1 p3 {: O2 A$ h/ z7 C4 i
      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% ~! r: ?2 D# ?4 J
if i %2 == 0:6 F" q- L* _) P: ]+ A! C8 u& F
      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"
' G3 ?8 i+ P& ^! h) f1 v1 k: E( Q2 ?5 va. 移除 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)
* p/ Q* U& t) M) F* y8 Q% y. C' Ifor i in name:
1 v) ~) I( H# ~# Z3 J1 @& x print(i)22、请用代码实现:利用下划线将列表的每一个元素拼接成字符串，li = ['alex', 'eric', 'rain']print('_'.join(['alex', 'eric', 'rain'])) alex_eric_rain" \0 t$ w7 c$ Z9 D7 X
22、写代码，有如下列表，按照要求实现每一个功能 li = ['alex', 'eric', 'rain']li = ['alex', 'eric', 'rain']
5 ^, g+ m7 k9 J- N- ?: ~print(len(li))b. 列表中追加元素 “seven”，并输出添加后的列表li.append('seven')
4 j2 A$ f/ q) z: m1 h  Iprint(li)
2 a* h9 x5 Y/ o2 J" y! }# @) b ['alex', 'eric', 'rain', 'seven']
( g6 @2 E: R  k$ f, }5 Y! h8 @c. 请在列表的第 1 个位置插入元素 “Tony”，并输出添加后的列表li.insert(0,'TONY')# |1 m5 S- R) Y. @/ T" g
print(li)d. 请修改列表第 2 个位置的元素为 “Kelly”，并输出修改后的列表li[1]=('killy')
- f) d  v4 w6 Y) ^, ^5 |print(li)
* R/ M7 f: K; r( M' f% Se. 请删除列表中的元素 “eric”，并输出修改后的列表li = ['alex', 'eric', 'rain']
8 g( w& m! P) O9 A5 Uli.pop(1)
( w9 O3 b  C! kprint(li) ['alex', 'rain']) S  g+ G" l* ?7 p
指名道姓的删除li = ['alex', 'eric', 'rain']% B" ?9 b+ F* u* y2 ^+ y
li.remove('alex')& F: m) H4 o# @3 C& `
print(li)
$ F' N3 _  h! d! F% u5 ff. 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表li = ['alex', 'eric', 'rain'], s. K+ w9 l: j9 ?* [' A2 r+ S& j
print(li.pop(1))8 A5 X) ]2 ]$ |" X
print(li). Q: H; o% j3 u

# [7 `, v! ]# ?: D$ k, {7 deric1 W5 k0 j7 s+ D1 A
['alex', 'rain']h. 请删除列表中的第 2 至 4 个元素，并输出删除元素后的列表li = ['alex', 'eric', 'rain']
$ T5 \9 n" q9 T/ y& ~6 Gdel li[1:]
7 B! H" f3 T; A. u. t. h. Nprint(li) k. 请使用 enumrate 输出列表元素和序号(序号从 100 开始): }. i. _- J$ ~7 Z
li = ['alex', 'eric', 'rain']
% T7 M# x8 D  S) a. tfor k,v in enumerate(li,1):* p1 p" y" r  m, c
print(k,v)23、写代码，有如下列表，请按照功能要求实现每一个功能 li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
8 g& |$ x' \- V5 F* Ka. 请输出 “Kelly”! t5 p4 L5 [1 i( {
li = ["hello", 'seven', ["mon", ["h", "kelly"], 'all'], 123, 446]
print(li[2][1][1])
0 F* E, K% w0 h$ Ob. 请使用索引找到 'all' 元素并将其修改为 “ALL”; W4 R% C5 T9 N3 c
li[2][2]='ALL'
, e2 N2 t/ c! f8 D* Jprint(li)
5 ?. y( ^/ ~$ w* H3 z( Y24、写代码，有如下元组，按照要求实现每一个功能 tu = ('alex', 'eric', 'rain')1 D5 o$ m% r. a  L; I+ n5 a' [
a. 计算元组长度并输出tu = ('alex', 'eric', 'rain'). ]/ k% T9 j* M( v8 `( ~1 O
print(len(tu)), Q* U9 r1 X5 r( Y& D
b. 获取元组的第 2 个元素，并输出
9 i* C7 \& {& W# x3 B- dprint(tu[1])
0 A2 {5 x$ ~8 d% L" w& S1 t' Q4 ue. 请使用 for、len、range 输出元组的索引# M# _' y/ b* `6 `+ T3 Y
for i in range(len(tu)) :' Z, X* c. ~' k
print(tu.index(tu))f. 请使用 enumrate 输出元祖元素和序号(序号从 10 开始)
; c7 _! d, N3 e" e7 H9 A! Y; mfor k,v in enumerate(tu,10) :0 s  P. U- H  ~( j) \$ N2 L1 H
print(k,v)% |$ s$ P0 `" A: x
10 alex
# z$ p9 o) P' ~$ |8 q11 eric
1 V9 }" H# d( B. v) [12 rain
) D) @. Y) J( r# b' N) H: m6 [  A; h& V
for k in enumerate(tu,10) :' x7 I! o1 J# n# {! u
print(k)
$ w# t8 I9 a8 H1 S  y1 g0 E1 ?( t(10, 'alex')# L. C+ B3 P7 o: n, i9 W
(11, 'eric')
, b8 {  y) u8 n(12, 'rain')9 y: ?' ?; n5 ?3 z2 S! ^: R

2 ^' v# Z/ P, _+ M2 P2 L( N) X$ M8 s' \+ [* a1 ]+ s  R
25、有如下变量，请实现要求的功能
, k! y) c  [; |tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])c. 请问 tu 变量中的"k2"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”
元组，不可以
+ G* D8 @% b* H/ m, v
d. 请问 tu 变量中的"k3"对应的值是什么类型?是否可以被修改?如果可以，请在其中添加一个元素 “Seven”列表，可以+ t, F* k' R, K  K1 D/ S
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])& l% {1 M# J# B+ ?$ q
res=tu[1][2]['k2'].append('seven')% F+ M9 y- [9 |& s) v8 l1 C
  H# T5 T, o" h! G# h& ]! |0 m
print(tu)
2 V0 ^3 l- G6 k. }. n26、字典
9 C& O5 ~$ y9 d% rdic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}for i in dic:5 g1 ]7 t' r" G+ Z1 V
print(i)b. 请循环输出所有的 value" R: e6 h) j, K7 ]9 f+ U
for i in dic:- i% Q9 c: N+ L( {, t
print(dic)! R) u) O9 I& g/ E+ z7 M
c. 请循环输出所有的 key 和 valuefor i in dic:
* F+ Y% |7 K7 ?* B  Dprint(i,dic)
( x6 ]" `9 w7 h; ~d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典4 Z# m7 W; S& c  |" }
dic['k4']='v4'5 n! c/ k! I) q/ p2 d
print(dic)
# R; z: g* M2 h1 B. n" l1 ge. 请在修改字典中 “k1” 对应的值为 “alex”，输出修改后的字典( t4 V) r* D/ }9 b. z
dic['k1']='alex'# O) O1 o. y5 u4 W) s
print(dic)f. 请在 k3 对应的值中追加一个元素 44，输出修改后的字典% u: g3 Y" P5 O1 k# V
dic['k3'].append(44)
+ ?( h- {8 @; j: ]print(dic)/ Q3 q1 K- }8 ~

. I# Q- k/ ]9 M8 bg. 请在 k3 对应的值的第 1 个位置插入个元素 18，输出修改后的字典& j. F1 u! C/ V- I. `- m( w+ U
dic['k3'].insert(0,44)
& z2 Z3 j. \4 q! P1 i5 qprint(dic)* W/ `1 x. u* n5 P, c/ D9 ]
27、转换1 z4 u9 e! f7 i1 q
a. 将字符串 s = "alex" 转换成列表  s = "alex"2 N) ]& \) I' ?, s3 }9 |
. e4 H5 Q. m* O# ?0 @# g; v+ P
print(list(s))b. 将字符串 s = "alex" 转换成元祖
: g; m6 Q# h  \* R. \s = "alex"
  r" H8 [8 a6 B  l, p4 G1 K9 ?print(tuple(s))
5 [# _' \3 L- O; |% w/ E
+ x( w. S9 h5 i3 o4 }1 {b. 将列表 li = ["alex", "seven"] 转换成元组
9 L) \! M$ m# L1 T+ n( ili = ["alex", "seven"]7 o1 V7 s. D4 h: [/ l8 `4 c, g! X, z! A
print(tuple(li))c. 将元祖 tu = ('Alex', "seven") 转换成列表' k% V! Q7 V/ g/ f2 ^
tu = ('Alex', "seven")
5 R! E& `! [  G/ h: |. |0 k* Tli=list(tu)
* w8 e; s/ l7 c6 g" qprint(li)
/ v8 R8 s- r1 a% H0 n0 Z+ }& z$ c9 r/ c6 [

; M' O1 L: r0 i# ~1 O9 O; xd. 将列表 li = ["alex", "seven"] 转换成字典且字典的 key 按照 10 开始向后递增
) s: n8 \0 n; l9 t7 u" s6 H% D* c5 b1 _3 f" j! D* F
dic={}- d7 J$ a8 X% o0 c3 [
for k,v in enumerate(li,10) :----li要放在前面，序号放在后面* ^  Q- p5 T5 A8 P
dic[k]=v
: d: j' U. E; }8 W$ @! k1 p  P8 ]1 V print(dic)27、转码n = "老男孩": D$ z1 M1 O# e2 h! R3 Y
a. 将字符串转换成 utf-8 编码的字节，并输出，然后将该字节再转换成 utf-8 编码字符串，再输出n = "老男孩"2 w6 k! \% m* @- }
a=n.encode('utf-8')
6 r2 W3 E" y) N& e; z# Q6 ~print(a)3 Z& r2 S: W, S9 n% z0 ~
b=a.decode('utf-8')
; ^% Y0 I# w/ g: G0 ?1 y# Uprint(b)( Q$ c; D- E2 h( g% w# s8 q
b. 将字符串转换成 gbk 编码的字节，并输出，然后将该字节再转换成 gbk 编码字符串，再输出a=n.encode('gbk')1 W' @$ d4 X" ]& p7 U5 L7 Y
print(a)! _2 I. e' Z* R
b=a.decode('gbk')
, I4 k  a3 A4 t  ?( D5 `print(b)28、求 1-100 内的所有数的和
# w) n9 a4 n5 `$ k- ^: Acount=1
9 L, J. N2 z  W' S( z" X* [! D: O0 Qsum=0
" u5 K0 A+ C& Z; Cfor i in range(100) :
* h8 X& ]- J: Q2 A- I sum=sum+count
1 o8 W& }0 }+ L: ^! Q count+=1# m2 l" J: @" `7 v
print(sum)8 n5 i0 {, d+ y8 m
2 {0 t! x+ X0 _+ ?" T$ u
count=15 e$ y1 P2 ?9 l7 L2 q  h
sum=0
, s' |  D7 ]% V; M  H( f. Twhile count<=100 :, X0 l6 M/ k: s+ m( L
sum+=count3 e- v4 M1 e: o% P- j& K! J
count+=10 G, K3 C0 i' b# ~$ m  n
print(sum)29、元素分类5 u+ o: n2 d7 C
有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个 key 中，: c* v: O# z( w% q0 t8 h
将小于 66 的值保存至第二个 key 的值中。
9 S( j$ D" t" u3 e5 t即: {'k1': 大于 66 的所有值, 'k2': 小于 66 的所有值}. H" k+ v! ]5 [2 I
li=[11,22,33,44,55,66,77,88,99,90]' h/ r# M; t% A8 u
dic1={2 l# ]4 H' u( j/ ]  a" ^
'max':[],
( t% `7 @; O, H% r8 E 'min':[]
6 W: |, B6 R. g4 j' c}  \9 s( ]9 i  J% _! T( }6 `! c
for i in li :8 \3 X& Y% H. }: I; N: S  l" F
if i <66 :
- J" O, C$ O4 Y8 r1 l  b3 Y       dic1['min'].append(i)
/ X8 F- u# g" D: R else:8 ?9 q) @7 B& I  P/ ]" @
      dic1['max'].append(i)
4 ~  X" ~; E) K4 J* v8 c, Rprint(dic1)4 V/ D7 [' s9 C% W

: H3 }9 b7 U) ~9 s---{'max': [66, 77, 88, 99, 90], 'min': [11, 22, 33, 44, 55]}
- n& n# n. \( a; ?2 {6 q" S

Python基础知识汇总

主题推荐