Python Day3

Posted 2020-09-09

一、上节内容补充  

集合

集合是一个无序的，不重复的数据组合，它的主要作用如下：

• 去重，把一个列表变成集合，就自动去重了
• 关系测试，测试两组数据之前的交集、差集、并集等关系

一些操作如下：

 1 #!/usr/bin/env python3
 2 # -*- coding: utf-8 -*-
 3 # Author:Breakering
 4 set_1 = set([1,3,5,7,9,2,1,3,5])
 5 set_2 = set([2,4,6,8,10,5,6,9])
 6 
 7 print(set_1)
 8 #{1, 2, 3, 5, 7, 9}
 9 print(set_2)
10 #{2, 4, 5, 6, 8, 9, 10}
11 
12 #交集
13 print(set_1.intersection(set_2))
14 print(set_1 & set_2)
15 #{9, 2, 5}
16 
17 #并集
18 print(set_1.union(set_2))
19 print(set_1 | set_2)
20 #{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
21 
22 #差集
23 print(set_1.difference(set_2))
24 print(set_1 - set_2)
25 #{1, 3, 7}
26 
27 #对称差集（项在set_1或set_2中，但不会同时出现在二者中）
28 print(set_1.symmetric_difference(set_2))
29 print(set_1 ^ set_2)
30 #{1, 3, 4, 6, 7, 8, 10}
31 
32 #基本操作
33 set_1.add(4)                                               #在set_1中添加一项
34 print(set_1)
35 #{1, 2, 3, 4, 5, 7, 9}
36 set_1.update([11,13,15,17,19])                             #在set_1中添加多项
37 print(set_1)
38 #{1, 2, 3, 4, 5, 7, 9, 11, 13, 15, 17, 19}
39 
40 #使用remove()可以删除一项,如果不存在会报错：
41 set_1.remove(2)
42 set_1.remove(4)
43 print(set_1)
44 #{1, 3, 4, 5, 7, 9, 11, 13, 15, 17, 19}
45 set_1.discard(100)                                         #在set_1中删除一项,如果不存在则什么事也不干
46 print(set_1)
47 #{1, 3, 5, 7, 9, 11, 13, 15, 17, 19}
48 #set_1.pop()                                               #任意删除一个成员
49 #print(set_1)
50 #{3, 5, 7, 9, 11, 13, 15, 17, 19}
51 
52 print(set_1.issubset({1, 3, 5, 7, 9, 11, 13, 15, 17, 19,21}))   #判断set_1是不是某个集合的子集
53 #True
54 
55 print({1, 3, 5, 7, 9, 11, 13, 15, 17, 19,21}.issuperset(set_1)) #判断某个集合是不是set_1的父集
56 #True
57 
58 print(len(set_1))                                          #查看set_1的长度
59 #10
60 print(1 in set_1)                                          #测试某个元素不是set_1的成员
61 #True
62 print(1 not in set_1)                                      #测试某个元素不是set_1的成员
63 #False
64 
65 print(set_1.isdisjoint(set_2))                             #两个集合没有集合返回True
66 #False
67 
68 new_set = set_1.copy()                                     #浅copy
69 print(new_set)
70 #{1, 3, 5, 7, 9, 11, 13, 15, 17, 19}
71 
72 set_1.clear()                                              #清空整个集合
73 print(set_1)
74 #set()

View Code

文件操作

对文件操作流程

1. 打开文件，得到文件句柄并赋值给一个变量
2. 通过句柄对文件进行操作
3. 关闭文件

基本操作

 1 #!/usr/bin/env python3
 2 # -*- coding: utf-8 -*-
 3 # Author:Breakering
 4 f = open("test.txt",‘w+‘,encoding="utf-8")
 5 f.write("Hello!")
 6 f.flush()                   #将内容刷进文件
 7 f.seek(0)                   #将光标位置移动至某处
 8 print(f.readline())
 9 print(f.tell())             #打印光标位置
10 f.seek(0)
11 f.write("n")                #此时修改会覆盖
12 f.close()
13 
14 
15 
16 with open("test.txt",‘r‘,encoding="utf-8") as f:
17     print(f.encoding)       #打印文件编码
18     print(f.fileno())       #返回文件句柄编号
19     print(f.name)           #打印文件名字
20     print(f.isatty())       #是不是终端设备
21     print(f.seekable())     #
22     print(f.readable())     #是否可读
23     print(f.writable())     #是否可写
24     print(f.closed)         #文件是否关闭
25 
26 with open("test1.txt",‘a‘,encoding="utf-8") as f:
27     f.truncate(10)          #截断，从头开始截断，不管指针在哪
28 
29 
30 f = open("song.txt",‘r+‘,encoding="utf-8")    #读写
31 print(f.readline())
32 print(f.readline())
33 print(f.readline())
34 print(f.tell())
35 f.write("=================")    #只会在文件末尾追加
36 f.close()
37 
38 f = open("test.txt",‘w+‘,encoding="utf-8")    #写读
39 f.write("===============\\n")
40 f.write("===============\\n")
41 f.write("===============\\n")
42 f.write("===============\\n")
43 print(f.tell())
44 f.seek(0)
45 print(f.readline())
46 f.write("*****************\\n")    #只会在文件末尾追加
47 f.close()
48 
49 #f = open("test.txt",‘a+‘,encoding="utf-8")     #追加读写
50 
51 
52 #网络传输，二进制文件就用二进制打开
53 f = open("test.txt",‘rb‘)      #读取二进制文件
54 print(f.readline())
55 f.close()
56 
57 f = open("test.txt",‘wb‘)      #写二进制文件
58 f.write("wwwwww".encode("utf-8"))
59 f.close()
60 
61 
62 f = open("test.txt",‘ab‘)      #追加二进制文件
63 f.write("xxxxxxx".encode("utf-8"))
64 f.close()

打开文件的模式有：

• r，只读模式（默认）。
• w，只写模式。【不可读；不存在则创建；存在则删除内容；】
• a，追加模式。【不可读； 不存在则创建；存在则只追加内容；】

"+" 表示可以同时读写某个文件

• r+，可读写文件。【可读；可写；可追加】
• w+，写读
• a+，同a

"U"表示在读取时，可以将 \\r \\n \\r\\n自动转换成 \\n （与 r 或 r+ 模式同使用）

• rU
• r+U

"b"表示处理二进制文件（如：FTP发送上传ISO镜像文件，linux可忽略，windows处理二进制文件时需标注）

• rb
• wb
• ab

文件修改

 1 #!/usr/bin/env python3
 2 # -*- coding: utf-8 -*-
 3 # Author:Breakering
 4 import sys
 5 wt_change = sys.argv[1]
 6 change = sys.argv[2]
 7 
 8 with open("song.txt","r",encoding="utf-8") as f1, 9      open("new_song.txt","w",encoding="utf-8") as f2:
10     for line in f1:
11         if wt_change in line:
12             line = line.replace(wt_change,change)
13         f2.write(line)

小知识点：进度条

1 #!/usr/bin/env python3
2 # -*- coding: utf-8 -*-
3 # Author:Breakering
4 import sys,time
5 
6 for i in range(50):
7     sys.stdout.write("=")
8     sys.stdout.flush()
9     time.sleep(0.1)

字符编码与转码

详细文章:

http://www.cnblogs.com/yuanchenqi/articles/5956943.html

http://www.diveintopython3.net/strings.html

需知:

1.在python2默认编码是ASCII, python3里默认是unicode

2.unicode 分为 utf-32(占4个字节),utf-16(占两个字节)，utf-8(占1-4个字节)， so utf-16就是现在最常用的unicode版本， 不过在文件里存的还是utf-8，因为utf8省空间

3.在py3中encode,在转码的同时还会把string 变成bytes类型，decode在解码的同时还会把bytes变回string

 1 #-*-coding:gb2312 -*-   #这个也可以去掉
 2 # Author:Breakering
 3 
 4 import sys
 5 print(sys.getdefaultencoding())
 6 
 7 
 8 msg = "我是最棒的"
 9 #msg_gb2312 = msg.decode("utf-8").encode("gb2312")
10 msg_gb2312 = msg.encode("gb2312") #默认就是unicode,不用再decode,喜大普奔
11 gb2312_to_unicode = msg_gb2312.decode("gb2312")
12 gb2312_to_utf8 = msg_gb2312.decode("gb2312").encode("utf-8")
13 
14 print(msg)
15 print(msg_gb2312)
16 print(gb2312_to_unicode)
17 print(gb2312_to_utf8)

 二、本节内容    

函数

函数是什么?

函数一词来源于数学，但编程中的「函数」概念，与数学中的函数是有很大不同的，具体区别，我们后面会讲，编程中的函数在英文中也有很多不同的叫法。在BASIC中叫做subroutine(子过程或子程序)，在Pascal中叫做procedure(过程)和function，在C中只有function，在Java里面叫做method。

定义: 函数是指将一组语句的集合通过一个名字(函数名)封装起来，要想执行这个函数，只需调用其函数名即可

特性:

1. 减少重复代码
2. 保持一致性
3. 代码可扩展

函数的参数：

• 形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量
• 实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。因此应预先用赋值，输入等办法使参数获得确定值

一些用法：

 1 #!/usr/bin/env python3
 2 # -*- coding: utf-8 -*-
 3 # Author:Breakering
 4 
 5 def f1():              
 6     pass
 7 
 8 def f2():              #定义一个函数
 9     pass
10     return
11 
12 def f3(a,b,c):         #位置参数
13     print(a)
14     print(b)
15     print(c)
16 
17 f3(1,2,3)
18 
19 def f4(a,b=2):          #b就是一个默认参数
20     print(a)
21     print(b)
22 
23 f4(1,b=3)
24 
25 #关键参数必须放在位置参数之后
26 def f5(a,b,c,d=2):
27     pass
28 
29 f5(1,b=2,c=3,d=3)
30 
31 
32 #参数组
33 #*args   接收位置参数，并将传入的参数变成一个元组的形式
34 def f6(a,*args):
35     print(a)
36     print(args)
37 
38 f6(1,"Breakering",23)
39 f6(1,*["Breakering",23])
40 
41 #*kwargs  接收关键字参数，并将传入的参数变成一个字典的形式
42 def f7(a,**kwargs):
43     print(a)
44     print(kwargs)
45 
46 f7(1,name="Breakering",age=23)
47 f7(1,**{"name":"Breakering","age":23})

PS：关键参数必须放在位置参数之后

局部变量

 1 #!/usr/bin/env python3
 2 # -*- coding: utf-8 -*-
 3 # Author:Breakering
 4 
 5 
 6 name = "Breakering"
 7 age = 25
 8 
 9 def change(name):
10     global age                #声明全局变量后就可以在函数内部修改全局变量
11     print("Brfore change:",name,age)
12     name = "Profhua"          #这个函数就是这个变量的作用域
13     age = 23
14     print("After change:",name,age)
15 
16 
17 change(name)
18 print(name)
19 print(age)
20 #结果
21 # Brfore change: Breakering 25
22 # After change: Profhua 23
23 # Breakering
24 # 23
25 
26 l = ["Breakering","Profhua","Wolf"]
27 
28 def change_test(l):
29     l[2] = "Dog"                 #列表、字典、集合以及类在函数内部是可以修改的
30     print("inside:",l)
31 
32 change_test(l)
33 print("outside:",l)
34 #结果
35 # inside: [‘Breakering‘, ‘Profhua‘, ‘Dog‘]
36 # outside: [‘Breakering‘, ‘Profhua‘, ‘Dog‘]

全局与局部变量

在子程序中定义的变量称为局部变量，在程序的一开始定义的变量称为全局变量。

全局变量作用域是整个程序，局部变量作用域是定义该变量的子程序。

当全局变量与局部变量同名时：

在定义局部变量的子程序内，局部变量起作用；在其它地方全局变量起作用。

返回值

要想获取函数的执行结果，就可以用return语句把结果返回

注意:

1. 函数在执行过程中只要遇到return语句，就会停止执行并返回结果，so 也可以理解为 return 语句代表着函数的结束
2. 如果未在函数中指定return,那这个函数的返回值为None

PS:函数为什么需要返回值，一个重要的作用就是，需要函数的执行结果

递归

在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。

 1 #!/usr/bin/env python3
 2 # -*- coding: utf-8 -*-
 3 # Author:Breakering
 4 
 5 def calc(n):
 6     print(n)
 7     if int(n/2) > 0:
 8         return calc(n/2)
 9     print("----->",n)
10 
11 calc(100)

递归特性:

1. 必须有一个明确的结束条件

2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少

3. 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）

高阶函数

将一个函数当作一个参数传给另一个函数，那么这另一个函数就是高阶函数

1 #!/usr/bin/env python3
2 # -*- coding: utf-8 -*-
3 # Author:Breakering
4 def add(a,b,f):           #将一个函数当作一个参数传给另一个函数，那么这另一个函数就是高阶函数
5     return f(a) + f(b)
6 
7 ret = add(4,-6,abs)
8 print(ret)
9 #10

函数式编程

参考大王博客：http://www.cnblogs.com/alex3714/articles/5740985.html

三、作业  

程序练习　　

程序1: 实现简单的shell sed替换功能

程序2:修改haproxy配置文件