Day03的课程要点记录
详细教程地址：金角大王 - Day3 Python基础3 | 金角大王 - Day2 Python基础2 | 银角大王 - Python基础（二）
一、集合的使用
集合是一个无序的，不重复的数据组合，它的主要作用如下：
- 去重，把一个列表变成集合，自动去重
- 关系测试，测试两组数据之前的交集、差集、并集等关系
1.1 常用操作
a = {11, 22, 33, 44}
s = set([3, 5, 9, 10]) #创建一个数值集合
t = set('Hello') #创建一个唯一字符的集合
a = t | s # t 和 s 的并集
b = t & s # t 和 s 的交集
c = t - s # 求差集（项在t中，但不在s中）
d = t ^ s # 对称差集（项在t或s中，但不会同时出现在二者中）
1.2 基本操作
-
s.intersection(t)，s & t，交集，返回一个新的 set 包含 s 和 t 中的公共元素
>>> s.intersection(t)
set()
-
s.union(t)，s | t，并集，放回一个新的 set 包含 s 和 t 中的每一个元素
>>> s.union(t)
{'e', 3, 'l', 5, 'H', 9, 10, 'o'}
-
s.difference(t)，s - t，差集，返回一个新的 set 包含 s 中有但是 t 中没有的元素
>>> s.difference(t)
{9, 10, 3, 5}
-
s.issubset(t)，s <= t，子集，测试 s 中的每一个元素是否都在 t 中
>>> s.issubset(t)
False
-
s.issuperset(t)，s >= t，父集，测试 t 中的每一个元素是否都在 s 中
>>> s.issuperset(t)
False
-
s.symmetric_difference()，s ^ t，对称差集，返回一个新的 set 包含 s 和 t 中不重复的元素
>>> s.symmetric_difference(t)
{'e', 'l', 'H', 3, 5, 9, 10, 'o'}
s.copy()，返回 set “s”的一个浅复制s.isdisjoint(t)，零交叉测试，如果两个集合中零交叉，则返回True
>>> s.isdisjoint(t)
True
1.3 增删改查
1.3.1 增加元素
-
t.add('a')向集合内添加一项元素
>>> t.add('a')
>>> t
{'o', 'e', 'l', 'H', 'a'}
-
s.update([111, 222, 333])向集合内添加多项元素
>>> s.update([111, 222, 333])
>>> s
{3, 5, 9, 10, 333, 111, 222}
1.3.2 删除元素
-
s.pop()随机删除 s 中的一个元素，并返回
>>> s.pop()
3
-
t.remove('a')删除 t 中的元素 a
>>> t.remove('a')
>>> t
{'o', 'e', 'l', 'H'}
-
s.discard()删除 s 中的一个指定元素，如果没有此元素，不报错
>>> s.discard(333)
>>> s
{5, 9, 10, 111, 222}
>>> s.discard(999)
>>> s
{5, 9, 10, 111, 222}
1.3.4 其他
len(s)set 的长度x in s 测试 x 是否是 s 的成员
x not in s 测试 x 是否不是 s 的成员
set集合练习题
old_dict = {
'#1': 8,
'#2': 4,
'#4': 2
}
new_dict ={
'#1': 4,
'#2': 4,
'#3': 2
}
需求
- 应该删除哪几个槽位？
- 应该更新哪几个槽位？
- 应该增加哪几个槽位？
实现代码：
old_set = set(old_dict.keys())
new_set = set(new_dict.keys())
del_set = old_set.difference(new_set) # 应该删除old中有new中无的差集
update_set = old_set.intersection(new_set) # 应该更新old和new的交集
add_set = new_set.difference(old_set) # 应该增加new中有old中无的差集
print(del_set)
print(update_set)
print(add_set)
二、文件操作
对文件操作流程：
- 打开文件，得到文件句柄并赋值给一个变量
- 通过句柄对文件进行操作
- 关闭文件
2.1 基本操作 - 读、写、追加
f = open('lyrics') # 打开文件
first_line = f.readline()
print('first line:',first_line) # 读一行
print('我是分隔线'.center(50,'-'))
data = f.read() # 读取剩下的所有内容,文件大时不要用
print(data) # 打印文件
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
2.2 循环读取文件内容
- 差方法
# 读取到第9行时，打印分割线
for index,line in enumerate(f.readlines())
if index == 9:
print("我是分隔线".center(20, '-'))
continue
print(line.strip())
- 好方法
count = 0
for line in f:
if count == 9:
print("我是分隔线".center(20, '-'))
count += 1
continue
print(line.strip())
count += 1
2.3 其他方法
f.tell()获取当前光标位置，以及f.seek()移动光标位置
print(f.tell()) # 获取当前光标位置。 （0）
print(f.readline()) # 打印第一行
print(f.readline()) # 打印第二行
print(f.tell()) # 获取当前光标位置。 （140）
print(f.seek(0)) # 光标移回至起始处
print(f.readline()) # 打印第一行
f.enconding() 当前文件的编码
f.fileno() 返回文件在内存中的编号
f.name() 当前文件的名字
f.seekable() 判断文件光标是否可移
f.readable() 判断文件是否可读
f.writable() 判断文件是否可写
f.truncate() 从文件起始截断到指定数（不填则清空）
f. flush() 将内存中暂存的内容刷新写入硬盘
命令行进度条实现方式
import sys, time
for i in range(100):
sys.stdout.write('#')
sys.stdout.flush()
time.sleep(0.1) # 每打印一个sleep0.1秒
2.4 文件的修改
将文件中某一行内的文字进行部分替换
# 将文本中全部的"我"替换为"你"
f = open('Yesterday2', 'r', encoding='utf-8')
f_new = open('Yesterday2.bak', 'w', encoding='utf-8')
for line in f:
if '我' in line:
line = line.replace('我', '你')
f_new.write(line)
f.close()
f_new.close()
2.5 with语句
为了避免打开文件后忘记关闭，可以通过管理上下文，即：
with open('log','r') as f:
...
如此方式，当with代码块执行完毕时，内部会自动关闭并释放文件资源。
在Python 2.7 后，with又支持同时对多个文件的上下文进行管理，即：
with open('log1') as obj1, open('log2') as obj2:
pass
课堂练习
程序1：实现简单的shell sed替换功能
import sys
find_str = sys.argv[1]
replace_str = sys.argv[1]
with open('Yesterday2', 'r', encoding='utf-8')as f,\
open('Yesterday3', 'w', encoding='utf-8') as f_new:
for line in f:
if find_str in line:
line = line.replace(find_str, replace_str)
f_new.write(line)
三、字符转编码操作
详细文章：py编码终极版 | Strings - Dive into Python3
Ascii码：每个字符存1个字节
Unicode：每个字符存2个字节
utf-8：英文用1个，其他用3个字节
所有转换动作都需要先decode为Unicode，再encode为相应编码
在字符串之前加u，默认为其是Unicode，可直接encode
练习：将字符按顺序转换编码，gb2312 -> utf-8 -> gbk。
Python2
import sys
print(sys.getdefaultencoding()) # 获取默认编码格式
s = '学习学习再学习'
s_gb = s.decode('uft-8').encode('gb2312') # utf-8 -> gb2312
s_gb_utf8 = s_gb.decode('gb2312').encode('utf-8') # gb2312 -> utf-8
s_gb_utf8_gbk = s_gb_utf8.decode('utf-8').encode(gbk) # utf-8 -> gbk
print(s_gb.decode('gb2312'))
print(s_gb_utf8.decode('utf-8'))
print(s_gb_utf8_gbk.decode('gbk'))
Python3： 3中encode同时会转换为bytes，显示字符串需要decode为unicode
import sys
print(sys.getdefaultencoding()) # 获取默认编码格式
s = '学习学习再学习' # py3_default = unicode
s_gb = s.encode('gb2312') # unicode -> gb2312
s_gb_utf8 = s_gb.decode('gb2312').encode('utf-8') # gb2312 -> utf-8
s_gb_utf8_gbk = s_gb_utf8.decode('utf-8').encode('gbk') # utf-8 -> gbk
print(s_gb.decode('gb2312'))
print(s_gb_utf8.decode('utf-8'))
print(s_gb_utf8_gbk.decode('gbk'))
四、函数
4.1 函数是什么？
函数是指将一组语句的集合通过一个名字(函数名)封装起来，要想执行这个函数，只需调用其函数名。
4.2 基本语法及特性
4.2.1 语法定义
def sayhi(): #函数名
print("Hello, I'm nobody!")
sayhi() #调用函数
带参数
# 下面这段代码
a,b = 5,8
c = a**b
print(c)
# 改成用函数写
def calc(x,y):
res = x**y
return res # 返回函数执行结果
c = calc(a,b) # 结果赋值给c变量
print(c)
4.2.2 特性：
- 减少重复代码
- 使程序变得可扩展
- 使程序变得易维护
4.3 返回值
用return语句返回函数的执行结果。
注意：
- 函数在执行过程中只要遇到
return语句，就会停止执行并返回结果。所以可以理解为return语句代表着函数的结束。 - 如果未在函数中指定
return，那这个函数的返回值为None。
4.4 函数参数
4.4.1 形参与实参
形参：变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量
实参：可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。因此应预先用赋值，输入等办法使参数获得确定值
# 改成用函数写
def calc(x,y):
res = x**y
return res
c = calc(a,b)
print(c)
4.4.2 位置参数
按顺序给函数传参数
def test(x,y,z):
print(x)
print(y)
print(z)
test(1, 2, 3)
4.4.3 关键参数
正常情况下，给函数传参数要按顺序，不想按顺序就可以用关键参数，只需指定参数名即可。但记住一个要求就是，关键参数必须放在位置参数之后。
def test(x,y,z):
print(x)
print(y)
print(z)
test(3, z=6, y=9)
4.4.4 默认参数
在写形参时直接给形参定义的一个值。
特点：调用函数的时候，默认函数非必须传递。
用途：
- 默认安装值
- 默认端口号
def test(x,y=2):
print(x)
print(y)
test(1)
test(1,10)
4.4.5 非固定参数
*args - 把多传入的位置参数变成一个元组形式。
def stu_register(name,age,*args): # *args 会把多传入的参数变成一个元组形式
print(name,age,args)
stu_register("Alex",22)
#输出
#Alex 22 () # 后面这个()就是args,只是因为没传值,所以为空
stu_register("Jack",32,"CN","Python")
#输出
# Jack 32 ('CN', 'Python') # 多传入的参数为元组形式
**kwargs - 将多个关键字参数写为字典
def stu_register(name,age,*args,**kwargs): # *kwargs 会把多传入的参数变成一个dict形式
print(name,age,args,kwargs)
stu_register("Alex",22)
#输出
#Alex 22 () {}#后面这个{}就是kwargs,只是因为没传值,所以为空
stu_register("Jack",32,"CN","Python",sex="Male",province="ShanDong")
#输出
# Jack 32 ('CN', 'Python') {'province': 'ShanDong', 'sex': 'Male'}
4.5 全局变量与局部变量
在子程序中定义的变量称为局部变量，在程序的一开始定义的变量称为全局变量。
全局变量作用域是整个程序，局部变量作用域是定义该变量的子程序。
当全局变量与局部变量同名时：
在定义局部变量的子程序内，局部变量起作用；在其它地方全局变量起作用。
name = 'Will'
def change_name(name):
print("before change:", name)
name = 'William'
print('after name', name)
change_name(name)
print(name)
想在函数内改变全局变量要先声明（可实现，但尽量不要用，出错后调试难度几何级提升）
name = 'Will'
school = 'Hometown'
def change_name(name):
global school
print("before change:", name)
name = 'William'
school = 'University'
print('after name', name)
change_name(name)
print(name,school)
五、递归
在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。
递归的特性：
- 递归必须有一个明确的结束条件
- 每次进入更深一层递归时，问题规模相比上次递归都应有所减少
- 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）
def calc(n):
print(n)
if int(n) > 0:
return calc(int(n/2))
calc(10)
六、函数式编程介绍
函数是Python内建支持的一种封装，我们通过把大段代码拆成函数，通过一层一层的函数调用，就可以把复杂任务分解成简单的任务，这种分解可以称之为面向过程的程序设计。函数就是面向过程的程序设计的基本单元。
函数式编程中的函数这个术语不是指计算机中的函数（实际上是Subroutine），而是指数学中的函数，即自变量的映射。也就是说一个函数的值仅决定于函数参数的值，不依赖其他状态。比如sqrt(x)函数计算x的平方根，只要x不变，不论什么时候调用，调用几次，值都是不变的。
Python对函数式编程提供部分支持。由于Python允许使用变量，因此，Python不是纯函数式编程语言。
6.1 定义
简单说，"函数式编程"是一种"编程范式"（programming paradigm），也就是如何编写程序的方法论。主要思想是把运算过程尽量写成一系列嵌套的函数调用。
一个数学表达式：(1 + 2) * 3 - 4
传统的过程式编程
var a = 1 + 2;
var b = a * 3;
var c = b - 4;
函数式编程要求使用函数，可以把运算过程定义为不同的函数，写成下面这样：
var result = subtract(multiply(add(1, 2), 3), 4);
再演进一下，可以变成这样
add(1,2).multiply(3).subtract(4)
这基本就是自然语言的表达了。再看下面的代码，应该一眼就能明白它的意思：
merge([1,2],[3,4]).sort().search("2")
因此，函数式编程的代码更容易理解。
但要想学好函数式编程，不要用Python，用Erlang,Haskell。
七、高阶函数
变量可以指向函数，函数的参数能接收变量。
而一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。
def add(a, b, f):
return f(a)+f(b)
res = add(3, 6, abs)
print(res)
八、作业
将输入的字符串转为字典的方法：b = eval(b) | json
第3周作业：day3 作业详细
HAproxy配置文件操作（配置文件参考）：
- 根据用户输入输出对应的backend下的server信息
- 可添加backend 和sever信息
- 可修改backend 和sever信息
- 可删除backend 和sever信息
- 操作配置文件前进行备份
- 添加server信息时，如果ip已经存在则修改;如果backend不存在则创建；若信息与已有信息重复则不操作
