标签：
set是一个无序且不重复的元素集合访问速度快；天生解决元素重复问题
初始化
>>> s1 = set()
>>> print(type(s1))
<class ‘set‘>
add() 增加元素
>>> s1.add(‘tom‘)
>>> print(s1)
{‘tom‘}
clear() 清空
>>> s1.clear()
>>> print(s1)
set()
循环老的序列，只要某一个元素在原序列，有就删除。对比自己没有的
difference() 对比，显示不同的部分
Return the difference of two or more sets as a new set.
返回不同的部分生成新的集合。
>>> s1
{1, 2, 3, 4, ‘haha‘}
>>> s2 = s1.difference([‘haha‘])
>>> s2
{1, 2, 3, 4}
difference_update() 对比，并将修改原集合，不生成新的集合
>>> s1
{1, 2, 3, 4, ‘haha‘}
>>> s3 = s1.difference_update([‘haha‘])
>>> s1
{1, 2, 3, 4}
>>> s3
>>>
difference和differentce_update的区别：
一个是生成新的set
删除当前set中包含在new set里的元素
dicard() 移除
>>> s1.discard(1)
>>> s1
{2, 3, 4}
intersection() 取交集,生成新set
>>> s1
{1, 2, 3, 4, ‘tom‘, ‘cow‘, ‘cat‘}
>>> s3 = s1.intersection([‘tom‘,‘cat‘])
>>> s3
{‘cat‘, ‘tom‘}
intersetion_update() 取交集，修改原来set
>>> s3 = s1.intersection_update([‘tom‘,‘cat‘])
>>> s3 #说明没有生成新的set
>>> s1
{‘cat‘, ‘tom‘} #修改原set
isdisjonint() 如果没有交集，返回True
>>> s1
{‘tom‘, 1, 2, 3, 4, ‘cat‘, ‘pig‘}
>>> s3
{‘haha‘}
>>> s1.isdisjoint(s3)
True
issubset() 是否是子集
>>> s1
{‘tom‘, 1, 2, 3, 4, ‘cat‘, ‘pig‘}
>>> s2
{‘tom‘, 3}
>>> s2.issubset(s1)
True
s1.issuperset(s2) 是否是父集；s2是否是s1的子集，如果是则返回True，否则返回False
>>> s1
{‘tom‘, 1, 2, 3, 4, ‘cat‘, ‘pig‘}
>>> s2
{‘tom‘, 3}
>>> s1.issuperset(s2)
True
pop() 移除；移除的同时并获取这个值
>>> s1
{2, 3, 4, ‘cat‘, ‘pig‘}
>>> ret = s1.pop()
>>> ret
2
{3, 4, ‘cat‘, ‘pig‘}
remove() 指定移除;没有返回值
>>> s1.remove(‘pig‘)
>>> s1
{3, 4, ‘cat‘}
循环两次，对比前后set的不同。
symmetric_difference() 差集，并获取新对象
>>> s1
{3, 4, ‘cat‘}
>>> s2
{‘tom‘, 3}
>>> s1.symmetric_difference(s2)
{‘tom‘, ‘cat‘, 4}
symmetric_difference_update() 差集，改变原来;对比两个集合，取不同部分返回给原来的集合
>>> s1 = set(‘abcd‘)
>>> s2 = set(‘bcdf‘)
>>> s1.symmetric_difference_update(s2)
>>> s1
{‘f‘, ‘a‘}
>>> s2
{‘b‘, ‘f‘, ‘c‘, ‘d‘}
union() 并集
>>> s2 = set(‘bcdf‘)
>>> s1 = set(‘abcd‘)
>>> s1.union(s2)
{‘b‘, ‘a‘, ‘d‘, ‘c‘, ‘f‘}
update() 更新
>>> s1.update([2])
>>> s1
{‘b‘, 2, ‘a‘, ‘h‘, ‘d‘, ‘c‘}
1、计数器
首先需要导入 collections模块
Counter() 统计
import collections
>>> st1 = collections.Counter(‘asdasdqwcadfqwqwfadf‘)
>>> st1
Counter({‘a‘: 4, ‘d‘: 4, ‘f‘: 3, ‘q‘: 3, ‘w‘: 3, ‘s‘: 2, ‘c‘: 1})
most_common() 取出出现前X个
>>> print(st1.most_common(4))
[(‘a‘, 4), (‘d‘, 4), (‘f‘, 3), (‘q‘, 3)]
>>> for k in st1.elements():
... print(k)
...
c
a
a
.......
>>> for k,v in st1.items():
... print(k,v)
...
c 1
a 4
f 3
q 3
w 3
s 2
d 4
elements，等于原生的值。传入的是什么就是什么；
st1，就是处理过封装过的数据。
update() 增加
>>> st1 = collections.Counter(‘asdasdasdasdsadasqweqw‘)
>>> st1
Counter({‘a‘: 6, ‘s‘: 6, ‘d‘: 5, ‘q‘: 2, ‘w‘: 2, ‘e‘: 1})
>>> st1.update([‘tom‘,‘a‘,‘asd‘])
>>> st1
Counter({‘a‘: 7, ‘s‘: 6, ‘d‘: 5, ‘q‘: 2, ‘w‘: 2, ‘tom‘: 1, ‘asd‘: 1, ‘e‘: 1})
subtract() 删除
如果存在就减1，不存在为-1
>>> st1 = collections.Counter(‘aabbccddeef‘)
>>> st1
Counter({‘b‘: 2, ‘e‘: 2, ‘c‘: 2, ‘a‘: 2, ‘d‘: 2, ‘f‘: 1})
>>> st1.subtract([‘a‘,‘dd‘])
>>> st1
Counter({‘b‘: 2, ‘e‘: 2, ‘c‘: 2, ‘d‘: 2, ‘f‘: 1, ‘a‘: 0, ‘dd‘: -1})
2、有序字典
>>> dic = collections.OrderedDict()
>>> dic = dict()
>>> dic[‘k1‘] = ‘aa‘
>>> dic[‘k2‘] = ‘bb‘
>>> dic[‘k3‘] = ‘cc‘
>>> dic
{‘k2‘: ‘bb‘, ‘k1‘: ‘aa‘, ‘k3‘: ‘cc‘}
move_to_end() 移动一个到最后面
>>> dic = collections.OrderedDict()
>>> dic[‘k1‘] = ‘aa‘
>>> dic[‘k2‘] = ‘bb‘
>>> dic[‘k3‘] = ‘cc‘
>>>dic.move_to_end(‘k1‘)
OrderedDict([(‘k2‘, ‘bb‘), (‘k3‘, ‘cc‘), (‘k1‘, ‘aa‘)])
pop() 删除
>>> dic.pop(‘k1‘)
‘aa‘
>>> dic
OrderedDict([(‘k2‘, ‘bb‘), (‘k3‘, ‘cc‘)])
update() 增加
>>> dic.update({‘k1‘:‘1111‘,‘k100‘:‘100‘})
>>> dic
OrderedDict([(‘k2‘, ‘bb‘), (‘k3‘, ‘cc‘), (‘k1‘, ‘1111‘), (‘k100‘, ‘100‘)])
3、默认字典
>>> dic = collections.defaultdict(list)
>>> dic[‘k1‘].append(‘tom‘)
>>> dic
defaultdict(<class ‘list‘>, {‘k1‘: [‘tom‘]})
from collections import defaultdicevalues = [11,22,33,44,55,66,77,88,99,]
my_dict = defaultdict(list)
my_dict = {}
for value in values:
if value > 66:
my_dict[‘k1‘].append(value)
else:
my_dict[‘‘k2].append(value)
4、可命名元组
>>> MytupleClass = collections.namedtuple(‘MytupleClass‘,[‘x‘,‘y‘,‘z‘])
>>> st1 = MytupleClass(11,22,33)
>>> print(st1.x)
11
>>> print(st1.y)
22
>>> print(st1.z)
33
5、队列
>>> d = collections.deque()
>>> d
deque([])
>>> d.append(‘1‘)
>>> d
deque([‘1‘])
>>> d.appendleft(‘11‘)
>>> d.appendleft(‘22‘)
>>> d
deque([‘22‘, ‘11‘, ‘1‘])
count() 统计
>>> d
deque([‘11‘, ‘22‘, ‘11‘, ‘1‘])
>>> d.count(‘11‘)
2
单向队列
先进先出
import queue
q = queue.Queue()
q.put(‘123‘)
q.put(‘678‘
print(q.qsize())
2
print(q.get())
>>> print(q.get())
123
>>> print(q.get())
678
>>> print(q.get())
6、深浅拷贝
copy.copy()
只拷贝一层
>>> s1 = ‘aa‘
>>> s2 = s1
>>> print(id(s1))
4558601776
>>> print(id(s2))
4558601776
>>> n1 = [1,2,‘aa‘,‘bb‘,{‘kk‘:‘vv‘}]
>>> n1
[1, 2, ‘aa‘, ‘bb‘, {‘kk‘: ‘vv‘}]
>>> n2 = n1
>>> print(id(n1))
4558122952
>>> print(id(n2))
4558122952
copy.deepcopy()
拷贝所有层
a
三、函数基础
学习函数之前，为了实现某个特定功能，需要根据业务逻辑从上到下实现功能，套用无数个if...else或者while循环，需要相当长的代码来实现。并且在开发过程中会出现许多重复的代码，引入函数后就可以避免这一乱象。
Python的函数是通过赋值传递的，参数通过赋值传递给函数。def语句将创建一个函数对象并将其赋值给一个变量名，def语句的一般格式如下：
def function_name(arg1,arg2[,...]):
statement
[return value]
def:表示函数的关键字
函数名：函数的名称，根据名称来调用函数
函数体：函数中进行一系列的逻辑计算，封装的一些功能
参数：为函数体提供数据
返回值：当函数执行完毕后，可以给调用者返回数据。但返回值不是必须的，如果没有return语句，则默认返回值为None。
示例：
#有返回值
def test(): st1 = ‘tom‘ st2 = ‘cat‘ return st1,st2 reg = test() print(reg) #输出结果 (‘tom‘, ‘cat‘)
#无返回值
def test(): st1 = ‘tom‘ st2 = ‘cat‘ reg = test() print(reg) #运行结果 None
参数：
普通参数
默认参数
动态参数
Python函数的两种类型参数，一种是函数定义里的形参，一种是调用函数时传入的实参。
在函数的内部，实参会被赋值给形参。
作为实参传入到函数的变量名称和函数定义里形参的名字没有关系。函数里面只关心形参的值，而不去关心它在调用前叫什么名字。
异常处理：
try/except 捕获异常并处理
try:
block
except [exception,[data…]]:
block
执行try下的语句，如果引发异常，则执行过程会跳到第一个except语句；
如果第一个except中定义的异常与引发的异常匹配，则执行该except中的语句；
如果不匹配则执行下一个except。
import smtplib from email.mime.text import MIMEText from email.utils import formataddr def mail(f_user,t_user): res = True try: msg = MIMEText(‘邮件内容‘,‘plain‘,‘utf-8‘) msg[‘From‘] = formataddr([‘wo‘,f_user]) msg[‘To‘] = formataddr([‘Test‘,t_user]) msg[‘Subject‘] = ‘主题‘ server = smtplib.SMTP(‘smtp.163.com‘,25) server.login(f_user,‘hahah@163.com‘) server.sendmail(f_user,[t_user,],msg.as_string()) server.quit() except Exception: res = False return ret res = mail(‘xxxxx@163.com‘,‘xxxxx@163.com‘) if res == True: print("Success!") else: print("Try again!")
代码执行解析：
1、传两个值给mail（）分别为发送者和接受者邮箱；
2、执行mail(),指定res为True，如果执行后面发送邮件功能正常运行，那么就不再执行except；
如果发送邮件失败，执行except，并将res = False;
3、如果res 返回值为True，打印“Success！”，否则打印“Try again！”
动态参数
当函数的参数不确定时，可以使用*args和**kwargs。*args没有key值，**kwargs有key值
示例：
def show(*args): print(args,type(args)) show(‘enenen‘) #运行结果 (‘enenen‘,) <class ‘tuple‘>
# *args可以当作可容纳多个变量组成的list或tuple
def show(**args): print(args,type(args)) show(k1 = 22) #运行结果 {‘k1‘: 22} <class ‘dict‘>
def show(*args,**kwargs): print(args,type(args)) print(kwargs,type(kwargs)) show(2,3,4,232,4343,n1=20,k1=‘tom‘) #运行结果 (2, 3, 4, 232, 4343) <class ‘tuple‘> {‘n1‘: 20, ‘k1‘: ‘tom‘} <class ‘dict‘>
写参数的时候，一个*放在前面，两个*放后面。
def show(*args,**kwargs): print(args,type(args)) print(kwargs,type(kwargs)) l = [1,2,3,3434,343,] d = {‘k1‘:100,‘k2‘:20} show(*l,**d) #运行结果 (1, 2, 3, 3434, 343) <class ‘tuple‘> {‘k2‘: 20, ‘k1‘: 100} <class ‘dict‘
动态参数格式化
s1 = ‘{0} is {1}‘ res = s1.format(‘tom‘,‘cat‘) print(res) #运行结果 tom is cat
s1 = ‘{0} is {1}‘ l = [‘tom‘,‘cat‘] res = s1.format(*l) print(res) #运行结果 tom is cat
s1 = ‘{name} is {age}‘ d1 = {‘name‘:‘tom‘,‘age‘:11} res = s1.format(**d1) print(res) #运行结果 tom is 11
详情见http://www.cnblogs.com/xiajie/p/5081122.html 补充部分：
read():读取指定数目个字节到字符串中，负数将读取至文件末尾，默认是-1
>>> file_obj = open(‘test.txt‘,‘r‘) >>> file_obj.read() ‘dfdff\n‘ >>> file_obj.seek(0) >>> file_obj.read(0) ‘‘ >>> file_obj.read(1) ‘d‘ >>> file_obj.read(2) ‘fd‘ >>> file_obj.read(-1) ‘ff\n‘
readline():读取文件的一行，包括行结束符，可以制定size参数的值，默认是-1
>>> file_obj = open(‘test.txt‘,‘r‘) >>> file_obj.readline() ‘xxx\n‘ >>> file_obj.readline(2) ‘ha‘ >>> file_obj.readline(-1) ‘enene\n‘
readlines():读取所有剩余的行，然后作为一个字符串列表返回
>>> file_obj.seek(0) >>> file_obj.readlines() [‘xxx\n‘, ‘haha\n‘, ‘enene\n‘]
文件的指针定位与查询
（1）文件指针：
文件被打开后，其对象保存在 f 中， 它会记住文件的当前位置,以便于执行读、写操作，这个位置称为文件的指针( 一个从文件头部开始计算的字节数 long 类型 )。
（2）文件打开时的位置:
以"r" "r+" "rb+" 读方式, "w" "w+" "wb+"写方式 打开的文件，
一开始，文件指针均指向文件的头部。
(3) 获取文件指针的值:
L = f.tell()
(4) 移动文件的指针
f.seek( 偏移量, 选项 )
选项 =0 时， 表示将文件指针指向从文件头部到 "偏移量"字节处。
选项 =1 时， 表示将文件指针指向从文件的当前位置，向后移动 "偏移量"字节。
选项 =2 时， 表示将文件指针指向从文件的尾部，，向前移动 "偏移量"字节。
>>> file_obj.seek(0) >>> file_obj.tell() 0 >>> file_obj.seek(5) >>> file_obj.tell() 5 >>> file_obj.seek(5,1) >>> file_obj.tell() 10 >>> file_obj.seek(5,2) >>> file_obj.tell() 57 >>> file_obj.seek(5,0) >>> file_obj.tell() 5
标签：
原文地址：http://www.cnblogs.com/xiajie/p/5137149.html
