python 集合划分分水岭

转载

mob64ca14068b0b 2024-10-11 21:13:50

文章标签 python 集合划分分水岭 python 开发语言初始化元组 文章分类 Python 后端开发

python 集合划分分水岭_开发语言

概述

Python 中的集合模块具有各种类型的容器，可以通过将它们导入到您的程序中来轻松使用。

容器是一种对象，可用于保存多个项，同时提供访问和循环访问它们的方法，例如元组或列表。

模块简介

Python中的模块只是包含Python代码的“.py”或python文件，这些代码可以包含特定内置函数的代码，并且可以导入到其他Python程序中，以便更轻松地使用内置函数。

模块可以看作是一个代码库或一个文件，其中包含要包含在 python 程序中的一组方法和函数。我们可以使用模块将相关函数、类或代码块组合在一起。因此，将大型 Python 代码块拆分为包含代码的模块被认为是构建大型 Python 代码的最佳实践。

收集模块

Python 中的集合模块具有各种类型的容器，通过使用集合模块将它们导入到您的程序中，可以轻松使用这些容器。

容器是一种对象，可用于保存多个项，同时提供访问和循环访问它们的方法，例如元组或列表。

集合模块下有不同的容器：

namedtuple（）
OrderedDict（）
defaultdict（）
Counter（）
deque（）
Chainmap

现在让我们详细讨论所有这些容器。

namedtuple（）

collections 模块的 namedtuple（）函数用于返回一个元组，其中包含每个元组位置的名称。元组的每个值都可以使用其相应的名称进行调用。常规元组很难记住元组对象的每个字段的索引。命名元组就是为了解决这个问题而创建的，它解决了常规元组对象的索引问题。

为了导入和使用 NamedTuple（），我们使用以下语法：

语法：

from collections import namedtuple


name = namedtuple('name', 'x, y')

导入后，您只需初始化对象即可，并可以根据代码使用它。

namedTuple 函数将对象名称作为其第一个参数，后跟名称作为其位置。首先使用 namedtuple（）函数定义 namedtuple（）对象的结构，并将 names 作为其位置，并通过将值传递给初始化的对象来初始化元组对象。

让我们看一些与 namedtuple（）函数相关的示例。

示例 1：

首先，我们将使用 namedtuple（）函数定义 namedtuple（）对象的结构，并以 names 作为其位置。

我们将通过将值传递给初始化的对象来初始化元组对象。

现在，您可以使用初始化的对象，通过使用名称作为元组的位置来获取值。

# Importing the namedtuple
from collections import namedtuple

# Defining the name of the object and positions for the object
nameTup = namedtuple('nameTup', 'value1, value2, value3')  
myTuple = nameTup('Scaler', 'Topics', 'Python')  

# Printing the values
print(myTuple.value1)
print(myTuple.value2)
print(myTuple.value3)

输出： w 该程序将使用名称作为其位置来打印元组对象中的值

Scaler
Topics
Python

示例 2：

在此示例中，我们将使用列表来创建元组，并将使用索引和名称来访问值。

# Importing the namedtuple
from collections import namedtuple

# Defining the positions for the object
tuple1 = namedtuple('tuple1', ['name', 'address', 'profession'])  
myTuple = tuple1('ABC', 'Street No.1 ABC complex', 'Teacher')  


# Printing the values using index of the list
print('Using the indexes to get the values')

print('\nName is :', myTuple[0])
print('Address is :', myTuple[1])
print('Profession is :', myTuple[2])

# Printing the values using names as positions 
print('\nUsing the names to get the values')

print('\nName is :', myTuple.name)
print('Address is :', myTuple.address)
print('Profession is :', myTuple.profession)

print('\nSimply printing the tuple')

print('\n',myTuple)

使用列表创建元组有助于我们通过使用索引和名称来访问元组的值。

输出：

该程序将使用传递的列表的索引以及名称作为其位置来打印元组对象中的值。

使用索引获取值
名称为：ABC
地址为：ABC综合大楼
1号街职业为：教师

使用名称获取值
Name is： ABC 地址是： Street No.1 ABC
complex
职业是： 教师

只需打印元组
tuple1（name='ABC'， address='Street No.1 ABC complex'， profession='Teacher'）

OrderedDict（）命令字典

OrderedDict 是一个字典，其中的键始终以相同的顺序插入。如果按特定顺序插入字典中键的顺序，则会保留这些键的顺序。即使以后更改了密钥的值，位置也不会改变。

因此，如果我们遍历字典，它将始终按照插入的顺序打印出值。

为了导入 OrderedDict（），我们使用以下语法：

语法：

from collections import OrderedDict

myDict = OrderedDict()

导入后，您只需初始化对象即可，并可以根据代码使用它。

首先使用 OrderedDict（）函数定义结构，并通过根据键传递值来初始化字典对象。

此外，您可以使用字典的内置函数，例如：

d.clear（）
d.get（[， ]）
d.items（）
d.keys（）
d.values（）
d.pop（[， ]）
d.popitem（）
d.update（)

让我们看一些与 OrderedDict（）函数相关的示例。

示例 1：

首先，我们将使用 OrderedDict（）函数定义结构，我们将通过根据键传递值来初始化字典对象。

现在，您可以使用字典来获取键值对。

# Importing the dictionary
from collections import OrderedDict  

# Initializing the dictionary
myDict = OrderedDict()  

# Adding the values
myDict['key1'] = 'value1'  
myDict['key2'] = 'value2'  
myDict['key3'] = 'value3'  
myDict['key4'] = 'value4'  

# Printing the dictionary
print(myDict)

我们只是在有序字典中启动了 4 个键和值。

输出：

您可以看到，当我们打印字典时，顺序被保留。

OrderedDict（[（'key1'， 'value1'），（'key2'， 'value2'），（'key3'， 'value3'），（'key4'， 'value4'）]）

示例 2：

在此示例中，我们将创建一个 OrderedDict，然后我们将更改键值，但将保持原始顺序。

# Importing the dictionary
from collections import OrderedDict  

# Initializing the dictionary
myDict = OrderedDict()  

# Adding the values
myDict['A'] = '1'  
myDict['B'] = '2'  
myDict['C'] = '3'  
myDict['D'] = '4'  

# Changing the values
myDict['A'] = '5'

# Ordering will be same
print(myDict)

将键“A”的值从 1 更改为 5 不会影响字典中键的顺序。

输出：

您可以看到，即使在更改字典的键值后，顺序也会保留。
OrderedDict（[（'A'， '5'），（'B'， '2'），（'C'， '3'），（'D'， '4'）]）

默认dict（）

在 Python 中，字典是数据值的无序集合，可用于以与地图相同的方式存储数据值。字典有一个键值对，键必须是唯一且不可变的，当我们尝试访问不存在的键时，它会抛出错误。defaultdict（）和简单 Dictionary 之间的唯一区别是，当您尝试访问 defaultdict（）中不存在的键时，它不会抛出异常或键错误。

为了导入 defaultdict（），我们使用以下语法：

语法：

from collections import defaultdict
    
mydict = defaultdict()

导入后，您只需初始化对象即可，并可以根据代码使用它。

首先使用 defaultdict（）函数定义结构，并通过根据键传递值来初始化字典对象。

此外，您可以使用字典的内置函数，例如：

d.clear()
d.get([, ])
d.items()
d.keys()
d.values()
d.pop([, ])
d.popitem()
d.update()

让我们看一些与 defaultdict（）函数相关的示例。

示例 1：

首先，我们将使用 defaultdict（）函数定义结构，我们将通过根据键传递值来初始化字典对象。

现在，您可以使用字典来获取键值对。

# Importing the dictionary
from collections import defaultdict  

# Initializing the dictionary
defDict = defaultdict()  

# Adding the values
defDict['k1'] = 'v1'  
defDict['k2'] = 'v2'  
defDict['k3'] = 'v3'  
defDict['k4'] = 'v4'  

# Printing the dictionary
print(defDict)

我们只是在有序字典中启动了 4 个键和值。

输出：

本示例仅打印字典值。

defaultdict（None， {'k1'： 'v1'， 'k2'： 'v2'， 'k3'： 'v3'， 'k4'： 'v4'}）

示例 2：

在此示例中，我们将尝试访问字典中不存在的键，但 defaultdict 不会给出任何键错误。

# Importing the dictionary
from collections import defaultdict  

# Initializing the dictionary
dic = defaultdict(int)  

# Adding the values
dic[1] = 'a'  
dic[2] = 'b'  
dic[3] = 'c'  

# Printing the dictionary
print(dic[4])

defaultdict 在访问不存在的密钥的情况下是有利的，因为在这些情况下不会发生错误。

输出：

在初始化 defaultdict 时，如果我们不传递对象引用（如 int、bool），则会导致键错误，并且在这种情况下无法推断回退默认值。

在这种情况下，我们将默认值设置为 int，因此如果缺少键，它将返回 0。

您可以看到，当我们尝试访问字典中的值 4 时，它只是返回 0 而不是返回 KeyError。

计数器（）

计数器是一种内置数据结构，用于计算数组或列表中每个值出现的次数。

使用 Counter 子类对可散列对象进行计数。counter（）对象在调用时构造一个可迭代的哈希表。

为了导入 Counter（），我们使用以下语法： 语法：

from collections import Counter

导入后，只需初始化 Counter 对象即可，并可以根据代码使用它。让我们看一些与 Counter（）函数相关的示例。

示例 1：

首先，我们将使用 Counter（）函数初始化结构，我们将在计数器对象中传递列表，并创建一个可哈希对象

现在，您可以获取哈希的键值。

# Importing the Counter
from collections import Counter  

# Making a list
l = [1,1,1,1,1,2,2,3,3,4]  

# Making the counter Object
c = Counter(l)  
print(c)

Counter 对象创建所有不同键及其计数器值的字典。

输出：

本示例仅打印创建的计数器对象。计数器（{1： 5， 2： 2， 3： 2， 4： 1}）

示例 2：

我们将传递包含字符串值的列表，因此将创建字符串字典作为键。

现在，您可以获取哈希的键值。

# Importing the Counter
from collections import Counter  

# Making a list
stringList = ['a', 'b', 'c', 'c', 'c', 'b', 'b', 'b', 'a', 'a', 'a', 'a']  

# Making the counter Object
c = Counter(stringList)  
print(c)

输出：

本示例仅打印创建的计数器对象。计数器（{'a'： 5， 'b'： 4， 'c'： 3}）

deque（）

Deque 是列表的更有效变体，用于轻松添加和删除项目。它可以在列表的开头或结尾添加或删除项目。

它是一个双端队列，在两端都有可用的插入和删除操作。

为了导入 deque（），我们使用以下语法：

语法：

from collections import deque
    
deq = deque()

导入后，只需初始化 deque（）对象即可，并根据代码使用它。

导入后，只需初始化对象并在 deque 对象中传递列表即可。

此外，您可以使用内置函数进行设计，例如：

append（）：附加到 deque（）的右侧
appendleft（）：追加到 deque（）的左侧
pop（）：从 deque（）的右侧弹出一个元素
popleft（）：弹出 deque（）的左侧
index（ele， beg， end）：从 deque（）中获取元素的索引
insert（i， a）：插入 deque（）的特定索引处
remove（）：从 deque 中删除元素
count（）：计算 deque（）中元素的出现次数
reverse（）：反转 deque（）
rotate（）：将 deque（）旋转指定的数字。让我们看一些与 deque（）相关的示例。

例：

首先，我们将初始化 deque 对象，并将列表传递到 deque 对象中。

现在，我们将在deque的两端应用移除和插入。

我们使用 append（）和 appendleft（）函数在两端添加项目，然后打印出来。

现在，我们终于使用 pop（）和 popleft（）函数从两端删除了项目。

# Importing the deque
from collections import deque  

# Initialization
l = ['Hi', 'This', 'is', 'Scaler']  
myDeq = deque(l)  

# Printing the deque
print("Original Deque is :", myDeq)  

# Inserting at both the ends
myDeq.append("!!")  
myDeq.appendleft("!!")

# Printing the updated deque
print("Deque after adding to both the ends is :",myDeq)

# Removing from both the ends
myDeq.pop()  
print("Deque after removal from start is :",myDeq)

myDeq.popleft()  
print("Deque after removal from beginning is :",myDeq)

myDeq.insert(1, "New")
print("Deque after insertion is :",myDeq)

myDeq.remove("New")
print("Deque after removal of value New is :",myDeq)

print("count of Scaler in deque is : ", myDeq.count("Scaler"))

myDeq.reverse()
print("Deque after reversing is :",myDeq)

myDeq.rotate(1)
print("Deque after rotation by 1 element is :",myDeq)

我们已经在我们的 deque 上执行了上述所有功能。

输出：

首先，在 deque（）函数中传递一个列表，然后我们使用 append（）和 appendleft（）函数在两端添加项目，然后打印出来。

现在，我们终于使用 pop（）和 popleft（）函数从两端删除了项目。

原 Deque 是： deque（['Hi'， 'This'， 'is'， 'Scaler']）

两端相加后的 deque 是：deque（['！！'， 'Hi'， 'This'， 'is'， 'Scaler'， '！！']）

从头开始移除后的 Deque 是：** deque（['！！'， 'Hi'， 'This'， 'is'， 'Scaler']）**

从头开始删除后的 deque 是：deque（['Hi'， 'This'， 'is'， 'Scaler']）

插入后的 deque 是： deque（['Hi'， 'New'， 'This'， 'is'， 'Scaler']）

删除值后的 Deque New is： deque（['Hi'， 'This'， 'is'， 'Scaler']）

以 deque 为单位的 Scaler 计数为：1

反转后的 deque 是： deque（['Scaler'， 'is'， 'This'， 'Hi']）

旋转 1 个元素后的 Deque 为：deque（['Hi'， 'Scaler'， 'is'， 'This']）

链图

ChainMap 在将字典组合并链接在一起后返回字典列表。ChainMaps可以将多个字典封装到单个对象或单元中，并且对包含的字典数量没有限制。

为了导入 Chainmap（），我们使用以下语法：

语法：

from collections import Chainmap
    
cm = chainmap(dic1, dic2)

导入后，您只需通过传递要封装的字典来初始化 Chainmap（）对象即可。

此外，您还可以使用chainmap的内置函数，例如：

keys（）：用于获取 chainmap 的所有密钥
values（）：用于获取 Chainmap 的所有值
maps（）：它用于获取对象中的所有键及其特定值
newchild（）：在链图的开头添加一个新字典
reversed（）：用于反转 chainmap 对象。

让我们看一些与 Chainmap（）相关的例子。

例：

首先，我们将初始化 Chainmap 对象，并将所有我们想要封装在 chainmap 对象中的字典传递。

最后，我们将打印最终的 chainmap 对象。

# Importing the deque
from collections import ChainMap

# Dictionary 1
dict1 = { 'k1' : 1, 'k2' : 2, 'k3': 3 } 
# Dictionary 2
dict2 = { 'k4' : 4 }  

# Making the ChainMap
finalChainMap = ChainMap(dict1, dict2)  

# Printing the ChainMap
print(finalChainMap) 

print("All the keys of the chainmap is :", list(finalChainMap.keys()))

print("All the values the chainmap is :", list(finalChainMap.values()))

print("All the keys-value pairs of the chainmap is :", finalChainMap.maps)

print("All the keys of the chainmap is :", list(finalChainMap.keys()))

dict3 = { 'k5' : 5 }  

chain1 = finalChainMap.new_child(dict3)
print("chainmap after addition at beginning is :", chain1)

print("Reversed chainmap is :", list(reversed(chain1.maps)))

输出：

我们只是在将字典封装到 Object 后打印出 chainMap 对象。

链映射（{'k1'： 1， 'k2'： 2， 'k3'： 3}， {'k4'： 4}）

链图的所有键都是：['k2'， 'k3'， 'k1'， 'k4']

链图的所有值为：[2， 3， 1， 4]

链图的所有键值对都是： [{'k1'： 1， 'k2'： 2， 'k3'： 3}， {'k4'： 4}]

链图的所有键都是：['k2'， 'k3'， 'k1'， 'k4']

开头添加后的 chainmap 是： ChainMap（{'k5'： 5}， {'k1'： 1， 'k2'： 2， 'k3'： 3}， {'k4'： 4}）

反转的链映射为： [{'k4'： 4}， {'k1'： 1， 'k2'： 2， 'k3'： 3}， {'k5'： 5}]