Python 函数基础、有序集合、文件操作(三)

一、set

特点：

　　 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'}

二、collection系列

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循环，需要相当长的代码来实现。并且在开发过程中会出现许多重复的代码，引入函数后就可以避免这一乱象。

1、自定义函数

　　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