一、面向对象（初识）
由类和方法组成，类里面封装了很多功能，根据这个类，可以创建一个这个类的对象，即对象是根据这个类创建的，以后这个对象要使用某个功能的时候就从这个类里面的找。
例：
str
-功能一
-功能二
-功能三
-。。。s1 = 'alex'
str即是类，s1即是根据这个类创建的一个对象。二、set集合
set是一个无序、不重复、可嵌套的集合。1、语法：se = {}或se = set()或se = set((11,22,33,33)),set()时其实是调用这个类里面的__init__方法
写法和字典相似，但字典是由key和值代表一个元素，而set中一个内容就代表一个元素。
例1
se = {'123','345'}2、添加元素
例
s = set()
s.add(123)
print(s)
重复添加同一个元素，只打印一个3、清除集合中的元素
例
s.clear()
print(s)4、复制
例
s1 = s1.copy(s)
copy属于浅拷贝，deepcopy属于深拷贝5、差值
例
s1 = {11,22,33}
s2 = {22,33,44}
s3 = s1.difference(s2)
print(s3)
将S1中存在，但在s2中不存在的元素放入s36、对称差值
例
s1 = {11,22,33}
s2 = {22,33,44}
s3 = s1.symmetric_difference(s2)
print(s3)
将s1中存在的，但在s2中不存在的元素放入s3，并且将s2中存在，但在s1中不存在的元素放入s37、差值更新
例
s1 = {11,22,33}
s2 = {22,33,44}
s1.difference_update(s2)
将S1中存在，但在s2中不存在的元素跟更新s18、对称差值更新
例
s1 = {11,22,33}
s2 = {22,33,44}
s1.symmetric_difference_update(s2)
print(s3)
将s1中存在的，但在s2中不存在的元素更新进s1，并且将s2中存在，但在s1中不存在的元素更新进s19、移除指定元素（元素不存在，不报错）
例
s1 = {11,22,33}
s1.discard(11)
print(s1)
如果移除的元素不存在，不会报错10、移除指定元素（元素不存在，则报错）
例
s1 = {11,22,33}
s1.remove(11)
print(s1)11、移除元素（随机移除一个元素，并返回被移除的元素）
例
s1 = {11,22,33}
ret = s1.pop()
print(s1)
print（ret）12、取交集
例
s1 = {11,22,33}
s2 = {22,33,44}
s3 = s1.intersection(s2)
print(s3)
将s1和s2都有的元素，赋值到s313、取交集更新
例
s1 = {11,22,33}
s2 = {22,33,44}
s1.intersection_update(s2)
print(s1)
将s1和s2都有的元素，更新到s114、判断是否有交集
例
s1 = {11,22,33}
s2 = {22,33,44}
p = s1.isdisjoint(s2)
判断两个集合是否有交集，有则返回true，没有则返回false15、并集
例
s1 = {11,22,33}
s2 = {22,33,44}
s3 = s1.union(s2)
print(s3)
将s1和s2的元素合并后复制到s316、更新
例
s1 = {11,22,33}
li = [1,2,3,4]
s1.update(li)
批量添加多个元素进s1，update可以接受可被for循环的数据
注，字符串也是一个可循环的数据练习：
old_dict = {
"#1":8,
"#2":4,
"#4":2
}new_dict = {
"#1":4,
"#2":4,
"#3":2
}现有上述两个字典，实现以下需求：
1、应该删除哪几个槽位
2、应该增加那几个槽位
3、应该更新那几个槽位三、函数初识
面向过程编程：从上到下一点一点的写，遇到重复的操作，一般复制之前的操作进行粘贴，造成代码可读性差、代码重用性差、代码量增加。
函数式编程：将会重复使用到的功能，定义成一个函数，在使用的时候调用函数即可
语法：
def f1(): #使用def关键字创建一个函数，函数名字是f1，解释器在创建函数时在内存中为这个函数开辟一个空间，将函数体添加进内存，并为函数创建一个名字，但不直行函数体，函数体在调用的时候才被直行。
pass #函数中所进行的操作
注，函数中还需定义返回值，来告诉函数调用者函数是否直行成功。
f1() #调用函数例1：发邮件的函数
def send_mail():
try:
import smtplib
from email.mime.text import MIMEText
from email.utils import formataddr msg = MIMEText('邮件内容', 'plain', 'utf-8')
msg['From'] = formataddr(["瞿姜",'18963603513@189.cn'])
msg['To'] = formataddr(["瞿姜",'18963603513@189.cn'])
msg['Subject'] = "主题" server = smtplib.SMTP("smtp.189.cn", 25)
server.login("18963603513@189.cn", "198787")
server.sendmail('18963603513@189.cn', ['18963603513@189.cn',], msg.as_string())
server.quit()
except:
#发送失败执行
return False
else:
#发送成功执行
return True ret = send_mail() #ret用来接受函数的返回值
if ret:
print('发送成功')
else：
print('发送失败')
注：try、except、else用来接收异常，并执行相关语句，上文中try尝试运行函数体，如发生异常则运行except下的代码，否则运行else下的代码。例2
def f1():
print('123')
return '111'
print('456')
f1()
注，在函数中，执行了return语句之后，立即停止执行函数，也就是说return后面的语句永远不会被执行。例3
def f1():
print('123')
f1()
注：如果函数中没有定义返回值，则默认返回None1、函数参数
def send_mail(xxoo):
try:
import smtplib
from email.mime.text import MIMEText
from email.utils import formataddr msg = MIMEText('邮件内容', 'plain', 'utf-8')
msg['From'] = formataddr(["瞿姜",'18963603513@189.cn'])
msg['To'] = formataddr(["瞿姜",'18963603513@189.cn'])
msg['Subject'] = "主题" server = smtplib.SMTP("smtp.189.cn", 25)
server.login("18963603513@189.cn", "198787")
server.sendmail('18963603513@189.cn', [xxoo,], msg.as_string())
server.quit()
except:
#发送失败执行
return False
else:
#发送成功执行
return True ret = send_mail() #ret用来接受函数的返回值
if ret:
print('发送成功')
else：
print('发送失败')ret = sendmail('18963603513@189.cn')
注：xxoo是形式参数，在调用函数时，括号内传入实际参数，在函数体中相当于将xxoo作为一个变量，将实际参数赋值给xxoo，从而由函数体中使用。例1
while True:
em = input('请输入邮箱地址：')
result = send_mail(em)
if result == True:
print ('发送成功')
else：
print ('发送失败')例2
def send_mail(xxoo,content)：
print('发送成功：'，xxoo，content)
send_mail('18963603513@189.cn','SB')
注:形式参数可以有多个，在传入参数的时候也需要传入相应数量的实际参数。2、默认参数
例1
def send_mail(xxoo,content,xx='ok')：
print('发送成功：'，xxoo，content,xx)
send_mail('18963603513@189.cn','SB')
注：如果形式参数xx设置了默认值，那么在传入参数时，如果没有传入与xx位置对应的实际参数，xx就使用ok作为实际参数，如果为xx传入了实际参数，则使用传入的值作为xx的值。python中规定，如果为某个形式参数指定了默认参数时，这个形式参数必须放到所有形式参数的末尾。3、指定参数
例1
def send_mail(xxoo,content)：
print('发送成功：'，xxoo，content)
send_mail(content='18963603513@189.cn',xxoo='SB')
注：可在调用的时候指定实际参数所对应的形式参数，这种情况下，传入的实际参数不需要与形式参数的位置一一对应。4、动态参数
例1
def f1(*args)：
print(args)
f1(11,22,'alex','hhhh')
注：可以使用*代表若干个参数，从而使一个形式参数可以接受多个实际参数，在函数体中，这个传入的若干个实际参数将会形成一个元组赋值给这个形式参数。例2
def f1(*args)：
print(args)
li = [11,22,33,44]
f1(li)
注：如果传入的实际参数是一个列表，那么在函数体内部，只会将这个列表作为元组中的一个元素赋值给形式参数。例3
def f1(*args)：
print(args)
li = [11,22,33,44]
f1(*li)
注：如果传入的实际参数也有*号，则表示将列表中的每个元素都转化成元组的每一个元素，字符串同理例4
def f1(**args)：
print(args)
f1(n1='li')
注：当形式参数有两个*时，表示传入的实际参数将成为字典中的元素，根据字典的特性，需要有key和value，因此在传实际参数时需要传入指定参数例5
def f1(**args)：
print(args)
dic = {'k1':'v1','k2':'v2'}
f1(**dic)
注：如果传入实际参数时也使用两个*，那么代表将参数单独形成一个字典，而不作为字典中的元素。例6：万能参数
def f1(*args，**kwargs)：
print(args，kwargs)
f1(11，22，33，44，k1='v1',k2='v2')
注：在形式参数既有*又有**的情况下，如过传入的实际参数既有列表又有指定参数，则会自动将列表放入*的列表中，将指定参数放入**的字典中。*的形式参数必须在**的形式参数前面，顺序不能够改变。5、format（）
format（）函数是用于格式化输出的。
例1
s = 'i am {0},age {1}'.format('alex',18)例2
s = 'i am {0},age {1}'.format(*['alex',18])例3
s = 'i am {name},age {age}'.format(name='alex',age=18)例4
s = 'i am {name},age {age}'.format(**｛name：'alex',age：18｝)6、补充知识
例1
def f1(a1,a2):
return a1 + a2def f1(a1,a2):
return a1 * a2ret = f1(8,8)
print(ret)
注：上述例子中，由于python的执行方式是从上到下的方式，当出现两个f1函数时，最后一次定义的函数生效，而第一次定义的函数所开辟的内存会被垃圾回收机制定期清除掉。例2
def f1(a1):
a1.append(999)li = [11,22,33,44]
f1(li)
print(li)
注：python在传参数的时候，传递的是对内存的引用，因此上述结果，li的结果是[11,22,33,44,999]例3，局部变量
def f1():
name = 'alex'
print(name)
def f2():
print(name)
注：在函数中被定义的变量，只能在本函数体中使用，其作用域就是这个函数体。例4，全局变量
name = 'alex'
def f1():
age = 18
print(age,name)
def f2():
age = 19
print(age,name)
注：由于变量name在文件中被定义，它的作用域是整个py文件，所有的作用域都可读。
注：定义全局变量时，变量名大写，这是一个潜规则，便于代码阅读。例5
name = 'alex'
def f1():
age = 18
name = '123'
print(age,name)
注：如果在函数体中出现了一个与全局变量同名的局部变量，当函数在执行的时候会优先执行局部变量。即局部变量优先与全局变量使用。例6
name = 'alex'
def f1():
age = 18
global name
name = '123'
print(age,name)
注：如果需要在函数体中修改一个全局变量，则需要在修改之前使用global变量名，声明一下这个变量是全局变量方可修改。例7
name = [11,22,33]
def f1():
age = 18
name.append('44')
print(age,name)
注：如果全局变量是一个列表、字典、元组内的列表元素、集合，那么在函数体中可以直接修改，但不能重新赋值。7、函数的写法潜规则
需要添加备注说明其作用
函数与函数之间需要空两行四、三元运算（三目运算）
语法：name = 'alex' if 1 == 1 else 'SB'
等同于
if 1 == 1:
name = 'alex'
else:
name = 'SB'
注：三元运算其实就是对简单的if else语句的简写。五、lambda表达式
语法：f2 = lambda a1: a1 + 100
等同于
def f2(a1):
return a1 + 100
注：可以是用lambda表达式来实现一些简单的函数。六、内置函数
1、abs()
取绝对值的函数
例
n = abs(-1)2、all()
接收一个可以被迭代的对象，如列表等，如果这个对象中的元素全都为真的时候返回真，有一个元素是假的则返回假
代表False：0,None,"",[],()3、any()
接收一个可以被迭代的对象，如列表等，如果这个对象中的元素有一个是真的时候返回真，所有元素都是假的时候则返回假4、ascii()
自动执行对象的__repr__方法
例
class Foo:
def __repr__(self):
return "333"n = ascii(Foo())
print(n)5、bin()
接受一个十进制，并把这个十进制转换为二进制返回，返回值格式为0b+二进制值6、oct()
接受一个十进制，并把这个十进制转换为八进制返回，返回值格式为0o+八进制值7、hex()
接受一个十进制，并把这个十进制转换为十六进制返回，返回值格式为0x+十六进制值8、bool()
接受一个值，并返回这个值代表的布尔值，即True或False
代表False：0,None,"",[],()
代表Ture：1，-1，" ",[ ],( )9、重要：bytes()
一个字节是8位
一个UTF-8编码的汉字占3个字节
一个GBK编码的汉字占2个字节
bytes()的作用是将一个汉字转换成字节，返回的是以16进制形式表示的字节。
例1
s = "李杰"
n = bytes(s,encoding="utf-8")
print(n)例2
s = "李杰"
n = bytes(s,encoding="gbk")
print(n)10、bytearray()
原理同bytes(),但bytes()返回的是多个字节组成的字符串，而此函数返回的是将每个字节作为元素的列表。11、str()
此函数可将已转换成字节的汉字转换成字符串,注意需要提供编码参数
例
s = "李杰"
n = bytes(s,encoding="utf-8")
a = str(n,encoding="utf-8")
print(a)七、文件操作，open()函数
1、打开文件之打开方式
例1
f = open("db","r")
已只读方式打开文件例2
f = open("db","w")
已只写文件方式打开文件，注：打开时会清空文件里面所有内容例3
f = open("db","x")
如果当db文件存在的时候就报错，如果不存在就创建文件并以w方式打开文件，这是python3.X新增的。例4
f = open("db","a")
f.write("李杰")
f.close
已追加方式发开文件，可在文件原有内容后追加内容。注：需要根据文件的保存方式设置encoding，一般情况下以utf-8保存。读出来的是字符串，因此在写的时候也需要是字符串例5
f = open("db","ab")
f.write(btyes("李杰",encoding="utf-8"))
f.close
注：在打开方式中加上b，表示直接读出来字节类型，因此写的时候也需要是字节类型，即二进制。例6
f = open("db","r+",encoding="utf-8")
data = f.read()
f.seek(1)
f.write("777")
f.close
注：使用r+以可读、可写的方式打开文件（用的比较多），在python中，只要有了读的操作，指针就会放到最后，当添加内容时默认添加到最后，如果需要修改指针位置，可使用seek方法调整，但添加的内容会覆盖指针位置后面的字符，但seek永远是按照字节的位置定位，因此有可能会破坏汉字，因为一个汉字是3个或者2个字节例7
f = open("db","r+",encoding="utf-8")
data = f.read(1)
print(f.tell())
f.write("777")
f.close
注：f.tell()显示读过以后指针所在的位置（永远以字节为单位）。例8
f = open("db","w+",encoding="utf-8")
注：使用w+方式打开文件时，会先清除文件内的所有内容，之后进行写的内容才可以读。例9
f = open("db","a+",encoding="utf-8")
注：使用a+方式打开文件时，所添加的字符永远在最后添加。2、操作文件
例1
f = open("db","r+",encoding="utf-8")
f.read()
注：如果无参数则读取所有内容，如果打开时有b，则按字节读取，否则按字符读取例2
f.tell()
注：获取当前指针位置例3
f.seek()
注：指定指针位置，永远按照字节操作例4
f.write()
注：写数据，如果有b则写入字节，否则写入字符例5
f.close()
注：关闭文件例6
f.fileno()
注：返回一个文件描述符例7
f.flush()
注：将写入的内容强制刷入硬盘例8
f.readable()
注：检测文件是否可读例9
f.seekable()
注：检测指针是否可操作例10
f.readline()
注：仅读取一行，读取过后指针在本行末尾，如果再次读取则会读取到后面一行例11
f.write()
注：检测文件是否可写例12
f.truncate()
注：清空指针所在位置以后的内容例13（常用）
f = open("db","r+",encoding="utf-8")
for line in f:
print(line)
注：使用for循环，循环文件内容每一行并进行输出例14
f.readlines()
注：将文件所有行读取，形成列表，并且每一行数据为列表中的一个元素3、关闭文件
例1
f.close()
注：关闭文件例2
with open("db") as f:
pass
注：使用with打开一个文件，在内部的代码块执行完毕后，自动关闭文件。例3
with open("db1","r",encoding="utf-8") as f1,open("db2","w",encoding="utf-8") as f2:
times=0
for line in f1:
time += 1
if times <=10:
f2.write(line)
else:
break
注：使用with同时打开多个文件，执行操作后，同时关闭。使用场景：将db1某些内容写到db2中。例4
with open("db1","r",encoding="utf-8") as f1,open("db2","w",encoding="utf-8") as f2:
for line in f1:
new_str = line.replace("alex","st")
f2.write(new_str)
注：将f1中每一行读取，然后替换“alex”再写入f2.作业：
详细见：http://www.cnblogs.com/wupeiqi/articles/4950799.html
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#Author:Victor Qu
'''
老板现在给你任务，公司有haproxy配置文件，希望通过python程序可以对ha配置文件进行增删改，不再是以往的打开文件进行直接操作了。
'''
import os def show(backend):
result = []
with open("haproxy","r",encoding="utf-8") as f:
flag = False
for line in f:
if line.strip("\n") == "backend {0}".format(backend):
flag = True
continue
if flag and line.strip().startswith("backend"):
flag = False
break
if flag and line.strip():
result.append(line.strip())
return result def add(**view):
ret = show(view["backend"])
view_of_add = " server {_IP} {_IP} weight {_weight} maxconn {_maxconn}\n".format(
_IP=view["record"]["ip"], _weight=view["record"]["weight"], _maxconn=view["record"]["maxconn"])
for line in ret:
if line.strip() == view_of_add.strip():
return False
with open("haproxy","r",encoding="utf-8") as f,open("~haproxy","w",encoding="utf-8") as w:
flag = False
for line in f:
w.write(line)
if line.strip() == "backend {0}".format(view["backend"]):
w.write(view_of_add)
flag = True
if flag == False:
w.write("\nbackend {0}".format(view["backend"]))
w.write("\n{0}".format(view_of_add))
os.remove("haproxy")
os.rename("~haproxy","haproxy")
ret = show(view["backend"])
return ret def delete(**view):
ret = show(view["backend"])
view_of_del = "server {_IP} {_IP} weight {_weight} maxconn {_maxconn}".format(
_IP=view["record"]["ip"], _weight=view["record"]["weight"], _maxconn=view["record"]["maxconn"])
for line in ret:
if line.strip() == view_of_del:
with open("haproxy", "r", encoding="utf-8") as f, open("~haproxy", "w", encoding="utf-8") as w:
flag = False
for line in f:
if line.strip() == "backend {0}".format(view["backend"]):
flag = True
w.write(line)
continue
if flag and line.strip().startswith("backend"):
flag = False
if flag and line.strip() == view_of_del:
continue
w.write(line)
os.remove("haproxy")
os.rename("~haproxy", "haproxy")
ret = show(view["backend"])
return ret
else:
return False def main():
while True:
titel_list = ("1、查询节点数据","2、增加节点数据","3、删除节点数据")
for line in titel_list:
print(line)
chice = input("请输入选择：")
if chice == "":
point = input("请输入节点名称：")
ret = show(point)
if ret:
for line in ret:
print(line)
else:
print("输入的节点名称不存在。")
continue
elif chice == "":
dict_of_point = {"backend":"","record":{"ip":"","weight":"","maxconn":""}}
point = input("请输入节点名称：")
ip = input("请输入IP地址：")
weight = input("请输入权重：")
maxconn = input("请输入Maxconn：")
dict_of_point["backend"] = point
dict_of_point["record"]["ip"] = ip
dict_of_point["record"]["weight"] = weight
dict_of_point["record"]["maxconn"] = maxconn
ret = add(**dict_of_point)
if ret:
for line in ret:
print(line)
else:
print("输入的数据已存在：")
continue
elif chice == "":
dict_of_point = {"backend": "", "record": {"ip": "", "weight": "", "maxconn": ""}}
point = input("请输入节点名称：")
ip = input("请输入IP地址：")
weight = input("请输入权重：")
maxconn = input("请输入Maxconn：")
dict_of_point["backend"] = point
dict_of_point["record"]["ip"] = ip
dict_of_point["record"]["weight"] = weight
dict_of_point["record"]["maxconn"] = maxconn
ret = delete(**dict_of_point)
if ret:
for line in ret:
print(line)
else:
print("输入的数据不存在：")
continue
else:
print("您的输入有误") main()
