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

一、set集合:

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

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

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也是去除重复元素并赋给一个新的列表。
集合(set)

练习:寻找差异

# 数据库中原有:
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)
dome

二、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函数可以做以下操作:

 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})
计数器(Counter)

2、有序字典(orderedDict):

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

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]})
defaultdict字典解决方法

三、深浅拷贝:

拷贝模块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值确没有变化。
浅拷贝(copy)

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值都发了变化。
深拷贝(deepcopy)

 

 

你可能感兴趣的:(Python学习之路——字符处理(二))