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

时间：2021-10-11 04:06:16

一、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)

以上实例运行后反回结果结果为：

['', '', 'c', 'c', 'a', 'a', '', '', 'd', 'b']

update()函数：相加，原来存在的增加一个，没有的添加新的。

from collections import Counter

x = Counter('1212abcdc')

print(x)

x.update('agt')

print(x)

以上实例运行后反回结果结果为：

Counter({'': 2, 'c': 2, '': 2, 'd': 1, 'b': 1, 'a': 1})

Counter({'': 2, 'c': 2, 'a': 2, '': 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, 'a': 1, 'b': 1, 'd': 1})

Counter({'c': 2, 'b': 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, '': 2, '': 2, 'd': 1, 'b': 1, 'a': 1})

Counter({'c': 2, '': 2, '': 2, 'd': 1, 'b': 1, 'a': 1})

计数器(Counter)

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]})

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)

 

相关文章