Python 用字典为循环嵌套。如何从第一个使用的值开始检查第二个

因此，我有一个字典，其中标签是患者代码或姓名（字符串），关联的数字是咨询时间（int）。例如，我有：

{'0001'：15，'Charles'：20}

人'0001'进行咨询需要15分钟，人'Charles'需要20分钟

我事先不知道哪里有一个名字或一个数字来识别一个人（但它们都是字符串），也就是说，我不知道查尔斯在字典里的位置，甚至不知道它是否存在

我想运行这个字典来检查有相同咨询时间的患者，如果他们有，我想运行一个不相关的函数。现在我有这个：

for pat_i in self.MD_dict:
    for pat_j in self.MD_dict:
        if(self.MD_dict[pat_i]==self.MD_dict[pat_j]):
           aux=aux+1
           funtion(pat_i, pat_j);

但是我希望j从I+1开始。我该怎么做

我试过使用range功能：

for pat_i in range(len(self.MD_dict)):
    for pat_j in range(i+1,len(self.MD_dict)):
        if(self.MD_dict[pat_i]==self.MD_dict[pat_j]):
           aux=aux+1
           funtion(pat_i, pat_j);

---

但因为pat_，我可能是一根绳子，这行不通。例如，对于pat_i=1和pat_j=2，if工作所需的代码为“0001”和Charles。但是自从pat_i0001'和pat_j！='Charles’这不起作用

在原始词典中，患者姓名/id是关键，时间是价值。在新字典中，时间是键，paitent name/id列表是值

sorted_items = sorted(self.MD_dict.items(), key=lambda x: x[1])
for i, (pat_i, pat_i_val) in enumerate(sorted_items):
    for (pat_j, pat_j_val) in sorted_items[i+1:]
        if pat_i_val == pat_j_val:
           aux=aux+1
           funtion(pat_i, pat_j)

这就是制作反向查找词典的想法，然后将患者姓名/id与同一时间合并到一个列表中

def make_inverse_dict（x）：
#时间是关键。病人名单是有价值的
时间_dict={}
对于名称，时间单位为x.items（）：
如果按时间规定：
时间\记录[时间].追加（名称）
其他：
时间记录[时间]=[姓名]
返回时间
def f（p1，p2）：
打印（f“{p1}，{p2}”）
def生成患者对（患者列表）：
#三角环使患者成对
#不重复
n_患者=len（患者列表）
out=[]
对于范围内的i（n_患者）：
对于范围（i）中的j：
配对=（患者名单[i]，患者名单[j]）
out.append（对）
返回
def main（）：
病人姓名={'0001'：15，
'0002': 10,
查尔斯：20岁，
安：20岁，
'0003': 15}
时间记录=反向记录（患者记录）
对于时间，患者列表在时间目录项（）中：
n_患者=len（患者列表）
打印（“时间：”，时间）
如果n_患者>1：
对于组合患者对（患者列表）中的p1、p2：
f（p1，p2）
main（）

结果:

time:  15
    0003, 0001
time:  10
time:  20
    Ann, Charles

---

您的代码的问题是，您对它进行了多次迭代。在第二次迭代中，检查

MD_dict[pat_i]

是否等于

MD_dict[pat_j]

。这意味着您将获得双倍的数据量，因为在一个点上，第二个循环将达到与第一个循环相同的点。例如，当第一个循环到达一个值时，比如说“Charles”，第二个循环将首先从开始处开始，然后最终到达“Charles”。显然，“Charles”的值不会在第一个循环和第二个循环之间改变-这将导致一个实例，在该实例中，您将传递“Charles”和“Charles”进入你的功能，这不是你想要的

假设

MD\u dict

是：

MD_dict = {'0001': 15, 'Charles': 20, '0002':15, 'Alex': 20, 'Jack':15}

我们所能做的是使用

枚举
来确保不会发生这些重复：

pats=list（MD_dict.keys（））
枚举=列表（枚举（pats））

上面，
enum
将患者姓名与他们出现的索引配对：

[(0, '0001'), (1, 'Charles'), (2, '0002'), (3, 'Alex'), (4, 'Jack')]

然后，我们可以迭代
enum
两次：

对于枚举中的x，pat_i:
对于枚举中的y，pat_j：
如果x！=y和MD_dict[pat_i]==MD_dict[pat_j]：
函数（pat_i，pat_j）#在此处应用函数

注意
x！=y
出现在条件语句中。这是为了避免将同一个人与自己配对。这确保了第二个循环不会考虑第一个循环的人。结果是：

function(0001, 0002)       # consult times == 15
function(0001, Jack)       # consult times == 15
function(Charles, Alex)    # consult times == 20
function(0002, 0001)       # consult times == 15
function(0002, Jack)       # consult times == 15
function(Alex, Charles)    # consult times == 20
function(Jack, 0001)       # consult times == 15
function(Jack, 0002)       # consult times == 15

然而，上面的函数有一个问题，我不完全清楚你在这个问题中要求什么。这个问题是该函数稍后将应用于“Charles”和“Alex”，然后应用于“Alex”和“Charles”。这是因为我们在字典中运行了两次，所以当第一个循环命中“Charles”时，它将拾取“Alex”作为匹配项，当第一个循环命中“Alex”时，它将拾取“Charles”作为匹配项。如果这不是您想要的，我们可以在第二个循环上切片
enum
：

pats = list(MD_dict.keys())
enum = list(enumerate(pats))
for x, pat_i in enum:
    for y,pat_j in enum[x+1:]:
        if MD_dict[pat_i] == MD_dict[pat_j]:
            function(pat_i, pat_j) # apply function here

以上， y，PATJJ在EnUM中[X+1：] /代码>只考虑跟随第一个循环的人。然后，我们不必检查
x！=y
。结果如下：

function(0001, 0002)      # consult times == 15
function(0001, Jack)      # consult times == 15
function(Charles, Alex)   # consult times == 20
function(0002, Jack)      # consult times == 15

您需要使用多少对
（患者姓名、时间）
？计算机需要多少时间才能完成这项工作？我不知道确切的数字，只是总少于20对。没有时间限制什么是“命令”
？这是个错误！应该是MD_列表。我将纠正它意味着没有解释张贴代码通常是不鼓励的。仅仅给出解决方案并不能帮助OP或未来的观众理解这里到底发生了什么，以及为什么他们的实现是错误的。对不起，这不是我想要的。我不想明确地知道哪些患者有相同的时间。我想检查这些病人是否有相同的时间，然后如果他们有，我想对这两个病人做某种功能。函数的内容实际上并不相关