Python学习之路——字符处理(二)

一、set集合:

set是一个无序且不重复的元素集合

建立一个集合：
x = set([1, 'tom', 2, 3, 4])
print(type(x))
print(x)
以上实例运行后反回结果结果为：
<class 'set'>
{'tom', 1, 2, 3, 4}

set集合整数可以做以下操作：

add函数：把要传入的元素做为一个整体添加到集合中
x = set([1, 'tom', 2, 3, 4])
y = ('address',)
x.add(y)
x.add('number')
print(x)
以上实例运行后反回结果结果为：
{1, 2, 3, 4, 'tom', 'number', ('address',)}

clear()函数：清除集合元素：
x = set([1, 'tom', 2, 3, 4])
x.clear()
print(x)
以上实例运行后反回结果结果为：
set()

copy()函数：拷贝一个对象
x = set([1, 'tom', 2, 3, 4])
y = x.copy()
print(y)
以上实例运行后反回结果结果为：
{'tom', 1, 2, 3, 4}
注：copy函数会在下面做详细讲解。

difference()函数：对比两个列表的差集：
x = set([1, 2, 3, 4, 'tom',])
y = set(['tom', 3, 4, 5, 6,])
z = x.difference(y)
print(z)
以上实例运行后反回结果结果为：
{1, 2}

symmetric_difference()函数：对比两个列表对称差集：
x = set([1, 2, 3, 4, 'tom',])
y = set(['tom', 3, 4, 5, 6,])
z = x.symmetric_difference(y)
print(z)
以上实例运行后反回结果结果为：
{1, 2, 5, 6}
注：difference()与symmetric_difference()都是做差集，当x与y做比较时如果用difference函数只会取出x有而y没有的元素。而sysmmetric difference 函数是对称差集，会取出互相都没有的元素。

difference_update()函数：对比两个列表的差集
x = set([1, 2, 3, 4, 'tom',])
y = set(['tom', 3, 4, 5, 6,])
x.difference_update(y)
print(x)
以上实例运行后反回结果结果为：
{1, 2}
注：difference_update函数是将返回值放到原变量内，而difference是需要赋给一个新的列表。

symmetric_difference_update()函数：对比两个列表的对称差集：
x = set([1, 2, 3, 4, 'tom',])
y = set(['tom', 3, 4, 5, 6,])
x.symmetric_difference_update(y)
print(x)
以上实例运行后反回结果结果为：
{1, 2, 5, 6}
注：symmetric_difference_update函数是将返回值放到原列表内，而symmetric_difference是需要赋给一个新的列表。

discard()函数：删除元素：
x = set([1, 2, 3, 4, 'tom',])
x.discard('tom')
print(x)
以上实例运行后反回结果结果为：
{1, 2, 3, 4}

intersection()函数：获取两个列表交集：
x = set([1, 2, 3, 4, 'tom',])
y = set(['tom', 3, 4, 5, 6,])
z = x.intersection(y)
print(z)
以上实例运行后反回结果结果为：
{3, 4, 'tom'}

intersection_update()函数：获取两个列表交集：
x = set([1, 2, 3, 4, 'tom',])
y = set(['tom', 3, 4, 5, 6,])
x.intersection_update(y)
print(x)
以上实例运行后反回结果结果为：
{'tom', 3, 4}
注：intersection_update函数是将返回值放到原列表内，而intersection_是需要赋给一个新的列表。

isdisjoint()函数：如果两个列表有交集反回False,如果有交集反回True：
x = set([1, 2, 3, 4, 'tom',])
y = set(['tom', 3, 4, 5, 6,])
z = set([7, 8])
s1 = x.isdisjoint(y)
s2 = x.isdisjoint(z)
print('有交集:',s1)
print('无交集:',s2)
以上实例运行后反回结果结果为：
有交集: False
无交集: True

issubset()函数：判断是不是子集：
x = set([1, 2, 3,])
y = set(['tom', 3, 4, 5, 6,])
z = set([1, 2, 3, 4, 'tom',])
s1 = x.issubset(y)
s2 = x.issubset(z)
print('不是子集:',s1)
print('是子集:',s2)
注：如果x列表的元素全部包含在z列表中说明是子集返回True，反之则返回False
以上实例运行后反回结果结果为：
不是子集: False
是子集: True

pop()函数：随即删除列表内的一个元素：
x = set([1, 2, 3, 4, 'tom',])
x.pop()
print(x)
以上实例运行后反回结果结果为：
{2, 3, 4, 'tom'}

remove()函数：删除指定元素：
print('以上实例运行后反回结果结果为：')
x = set([1, 2, 3, 4, 'tom', 'earl'])
x.remove('tom')
print(x)
以上实例运行后反回结果结果为：
{1, 2, 3, 4, 'earl'}

union()函数：取两个列表并集：
x = set([1, 2, 3, 4, 'tom',])
y = set(['tom', 3, 4, 5, 6,])
s1 = x.union(y)
print('并集:',s1)
以上实例运行后反回结果结果为：
并集: {1, 2, 3, 4, 5, 6, 'tom'}
注：union函数是将两个列表合并，排除重复元素。

update()函数：将一个列表更新到另一个列表中：
x = set([1, 2, 3, 4, 'tom',])
y = set(['tom', 3, 4, 5, 6,])
x.update(y)
print(x)
注：update函数是将返回值放到原列表内去除重复元素，而union也是去除重复元素并赋给一个新的列表。

练习：寻找差异

# 数据库中原有：
old_dict = {
    "#1":{ 'hostname': 'c1', 'cpu_count': 2, 'mem_capicity': 80 },
    "#2":{ 'hostname': 'c1', 'cpu_count': 2, 'mem_capicity': 80 },
    "#3":{ 'hostname': 'c1', 'cpu_count': 2, 'mem_capicity': 80 },
}

# cmdb 新汇报的数据：
new_dict = {
    "#1":{ 'hostname': 'c1', 'cpu_count': 2, 'mem_capicity': 800 },
    "#3":{ 'hostname': 'c1', 'cpu_count': 2, 'mem_capicity': 80 },
    "#4":{ 'hostname': 'c2', 'cpu_count': 2, 'mem_capicity': 80 }
}

需要删除：new_dict没有old_dict都存在的Key。

需要添加：new_dict有old_dict没有的Key。

需要更新：new_dict有old_dict也有的Key。

old_set = set(old_dict.keys())
update_list = list(old_set.intersection(new_dict.keys()))

new_list = []
del_list = []

for i in new_dict.keys():
    if i not in update_list:
        new_list.append(i)

for i in old_dict.keys():
    if i not in update_list:
        del_list.append(i)

print(update_list, new_list, del_list)

二、collections模块:

1、计数器（counter）

Counter是对字典类型的补充，用于追踪值的出现次数。

注：Counter具备字典的所有功能 + 自己的功能

Counter实例：

import collections
c = collections.Counter('slfjslfjsljfsfowjfwjflsjflsjflsjf')
print(c)

或

from collections import Counter
c = Counter('slfjslfjsljfsfowjfwjflsjflsjflsjf')
print(c)
以上两个实例运行后反回结果结果为：
Counter({'f': 9, 'j': 8, 's': 7, 'l': 6, 'w': 2, 'o': 1})

Counter函数可以做以下操作：

 Counter()函数：返回一个迭代器。元素被重复了多少次，在该迭代器中就包含多少个该元素
from collections import Counter
x = Counter('1212abacdc')
y = list(x.elements())
print(y)
以上实例运行后反回结果结果为：
['2', '2', 'c', 'c', 'a', 'a', '1', '1', 'd', 'b']

update()函数：相加，原来存在的增加一个，没有的添加新的。
from collections import Counter
x = Counter('1212abcdc')
print(x)
x.update('agt')
print(x)
以上实例运行后反回结果结果为：
Counter({'2': 2, 'c': 2, '1': 2, 'd': 1, 'b': 1, 'a': 1})
Counter({'2': 2, 'c': 2, 'a': 2, '1': 2, 'g': 1, 't': 1, 'd': 1, 'b': 1})

subtract()函数：相减，原来存在的减一个，没有的则为负数。
from collections import Counter
x = Counter('1212abcdc')
print(x)
x.subtract('12agt')
print(x)
以上实例运行后反回结果结果为：
Counter({'c': 2, '2': 2, '1': 2, 'a': 1, 'b': 1, 'd': 1})
Counter({'c': 2, 'b': 1, '2': 1, '1': 1, 'd': 1, 'a': 0, 't': -1, 'g': -1})

copy()函数：浅拷贝
from collections import Counter
x = Counter('1212abcdc')
y = x.copy()
print(x)
print(y)
以上实例运行后反回结果结果为：
Counter({'c': 2, '1': 2, '2': 2, 'd': 1, 'b': 1, 'a': 1})
Counter({'c': 2, '1': 2, '2': 2, 'd': 1, 'b': 1, 'a': 1})

2、有序字典（orderedDict）:

说明：OrderedDict是collections中的一个包，能够记录字典元素插入的顺序，常常和排序函数一起使用,来生成一个排序的字典。

from collections import OrderedDict
dic = OrderedDict({'k1':'v1'})
dic['k2'] = 'v2'
dic['k3'] = 'v3'
print('有序字典：')
for k,v in dic.items():
    print('%s:%s' %(k, v))

dic_new = {'k1':'v1'}
dic_new['k2'] = 'v2'
dic_new['k3'] = 'v3'
print('无序字典：')
for k,v in dic_new.items():
    print('%s:%s' %(k, v))
以上实例运行后反回结果结果为：
有序字典：
k1:v1
k2:v2
k3:v3
无序字典：
k3:v3
k1:v1
k2:v2

注：有序字典会根据key与valuse加入先后排序排序，如果是同时加入就需要指定排序值。

from collections import OrderedDict
dic = OrderedDict({'k1':'v1'})
dic['k3'] = 'v3'
dic['k2'] = 'v2'
print('有序字典：')
for k,v in dic.items():
    print('%s:%s' %(k, v))


dic_new = {'k1':'v1'}
dic_new['k2'] = 'v2'
dic_new['k3'] = 'v3'
print('无序字典：')
for k,v in dic_new.items():
    print('%s:%s' %(k, v))
以上实例运行后反回结果结果为：
有序字典：
k1:v1
k3:v3
k2:v2
无序字典：
k1:v1
k3:v3
k2:v2

 

3、默认字典(defaultdict)

defaultdict是对字典的类型的补充，他默认给字典的值设置了一个类型。

需求：

有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中。
即： {'k1': 大于66 , 'k2': 小于66}

values = [11, 22, 33,44,55,66,77,88,99,90]
my_dict = {}
for value in values:
    if value > 66:
        if 'k1' in my_dict.keys():
            my_dict['k1'].append(value)
        else:
            my_dict['k1'] = [value]
    else:
        if 'k2' in my_dict.keys():
            my_dict['k2'].append(value)
        else:
            my_dict['k2'] = [value]

print(my_dict)

以上实例运行后反回结果结果为：
{'k1': [77, 88, 99, 90], 'k2': [11, 22, 33, 44, 55, 66]}

from collections import defaultdict

values = [11, 22, 33,44,55,66,77,88,99,90]

my_dict = defaultdict(list)

for value in values:
    if value > 66:
        my_dict['k1'].append(value)
    else:
        my_dict['k2'].append(value)

print(my_dict)

以上实例运行后反回结果结果为：
defaultdict(<class 'list'>, {'k1': [77, 88, 99, 90], 'k2': [11, 22, 33, 44, 55, 66]})

三、深浅拷贝：

拷贝模块copy:

copy分为浅拷贝与深拷贝：

1、浅拷贝只拷贝一层:

例如：

import copy
x = ['a', 'b', [1, 2, 3,],]
y = copy.copy(x)
print(id(x))
print(id(y))
print(id(x[2]))
print(id(y[2]))
以上实例运行后反回结果结果为：
12559112
8548680
12561288
12561288
注：以上反回结果可以看出来，浅拷贝只有列表第一层在内的ID值发生了变化，而第二层的内存ID值确没有变化。

2、深拷贝是拷贝所有元素质:

import copy
x = ['a', 'b', [1, 2, 3,],]
y = copy.deepcopy(x)
print(id(x))
print(id(y))
print(id(x[2]))
print(id(y[2]))
以上实例运行后反回结果结果为：
17474312
17474824
17475720
17475784
注：深拷贝产生的列表所有元素在内存的ID值都发了变化。