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值都发了变化。
