set集合
s1=set()
集合特点：
- 访问速度快
- 没有重复项
collections系列（数据类型容器模块）
一、计数器(Counter)
Counter是对字典类型的补充，用于追踪值的出现次数。
import collections 导入模块
例：
import collections
obj=collections.Counter("aaafffefwifewfewf")
print(obj)
Counter({'f': 7, 'a': 3, 'w': 3, 'e': 3, 'i': 1})
二、有序字典(OrderedDict)
orderdDict是对字典类型的补充，他记住了字典元素添加的顺序
例：
import collections
dic=collections.OrderedDict()
dic['k1']='v1'
dic['k2']='v2'
dic['k3']='v3'
print(dic)
输出：OrderedDict([('k1', 'v1'), ('k2', 'v2'), ('k3', 'v3')])
三、默认字典（defaultdict）
defaultdict是对字典的类型的补充，它默认给字典的值设置了一个类型
四、可命名元组（namedtuple）
根据nametuple可以创建一个包含tuple所有功能以及其他功能的类型
例：
import collections
MytupleClass=collections.namedtuple('MytupleClass',['x','y','z'])
obj=MytupleClass(11,22,33)
print(obj.x)
print(obj.y)
print(obj.z)
输出：11
22
33
双向队列
一个线程安全的双向队列
例：
import collections
d=collections.deque()
d.append('1')
d.appendleft('0')
d.appendleft('1')
print(d)
r=d.count('1')
print(r)
输出：
deque(['1', '0', '1'])
2
深浅拷贝原理
对于字符串和数字而言，赋值、浅拷贝和深拷贝无意义，因为其永远指向同一个内存地址
深拷贝
在内存中将所有的数据重新创建一份（排除最后一层，即：python内部对字符串和数字的优化）
copy.copy()
浅拷贝
在内存中只额外创建第一层数据
copy.deepcopy()
函数
一、背景
函数式编程和面向过程编程的区别：
- 函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可
- 面向对象：对函数进行分类和封装，让开发“更快更好更强...”
函数式编程最重要的是增强代码的重用性和可读性
二、定义和使用
def 函数名(参数):
...
函数体
...
函数的定义主要有如下要点：
- def：表示函数的关键字
- 函数名：函数的名称，日后根据函数名调用函数
- 函数体：函数中进行一系列的逻辑计算，如：发送邮件、计算出 [11,22,38,888,2]中的最大数等...
- 参数：为函数体提供数据
- 返回值：当函数执行完毕后，可以给调用者返回数据。
以上要点中，比较重要有参数和返回值：
1、返回值
函数是一个功能块，该功能到底执行成功与否，需要通过返回值来告知调用者。
def 发送短信():
发送短信的代码...
if 发送成功:
return True
else:
return False
while True:
# 每次执行发送短信函数，都会将返回值自动赋值给result
# 之后，可以根据result来写日志，或重发等操作
result = 发送短信()
if result == False:
记录日志，短信发送失败...
2、参数
- 无参数
- 有参数
- 普通参数
- 默认参数
- 动态参数
普通参数举例：（argv为函数mail的形参，1和2为mail的）
def mail(argv):
n=123
n+=argv
print(n)
mail(1)
mail(2)
输出：124
125
默认参数举例：（注：默认参数需要放在参数列表最后）
def mail(argv1,argv2=10):
n=123
n+=argv1
n+=argv2
print(n)
mail(1,2)
mail(1)
输出：126
134
指定参数举例：（指定形参的值）
def show(a1,a2):
print(a1,a2)
show(a2=123,a1=999)
输出：999 123
动态参数举例1：（*args会把实参当做1个序列处理，**args会把实参当做1个字典处理）
def show(*args,**args2):
print(args,type(args))
print(args2,type(args2))
show(11,22,33,44,a1='aaa',b1='bbb')
输出：(11, 22, 33, 44) <class 'tuple'>
{'a1': 'aaa', 'b1': 'bbb'} <class 'dict'>
动态参数举例2：（如果让形参接收和实参一样的类型，需对应在实参前加*或**，否则会把实参当做1个元组处理）
def show(*args,**args2):
print(args,type(args))
print(args2,type(args2))
e=[11,22,33,44]
f={'a1':'aaa','b1':'bbb'}
show(e,f)
print("==================")
show(*e,**f)
输出：
([11, 22, 33, 44], {'a1': 'aaa', 'b1': 'bbb'}) <class 'tuple'>
{} <class 'dict'>
==================
(11, 22, 33, 44) <class 'tuple'>
{'a1': 'aaa', 'b1': 'bbb'} <class 'dict'>
lambda表达式
lambda存在意义就是对简单函数的简洁表示
例：
func=lambda a:a+1
ret=func(99)
print(ret)
输出：100
1、创建形式参数a
2、函数内容，a+1，并把结果return
内置函数
open函数
该函数用于文件处理
f=open('test.log','w',encoding='utf-8')
f.write('123456') #将123456写入文件test.log
f.close()
f=open('test.log','r',encoding='utf-8')
print("==========")
print(f.read()) #读取文件test.log
f.close()
f=open('test.log','r',encoding='utf-8')
f.seek(1) #指定当前指针位置
print("==========")
print(f.tell()) #查看当前指针位置
print(f.read(2)) #指定读取字符
print(f.tell()) #查看当前指针位置
f.close()
输出：==========
123456
==========
1
23
3