相关疑难解决方法(0)

我首先看一下Python wikibook中的python语言.

对于集合,提到以下内容 - We can also have a loop move over each of the items in a set. However, since sets are unordered, it is undefined which order the iteration will follow.

并给出了代码示例

s = set("blerg")

for letter in s:
     print letter

输出:

 r b e l g

当我运行程序时,无论我运行多少次,我都会以相同的顺序得到结果.如果集合是无序的并且迭代顺序未定义,为什么它以相同的顺序返回集合？订单的基础是什么？

[ PS:对不起,如果我误解了一些非常基本的东西.我是一个蟒蛇新手]

我出于好奇而问这个问题(具体来说,深入了解python是如何工作的).

我完全知道python dict对象是无序的 - 你可以放入一堆项目,并打印出一些表示dict,并且表示中项目的顺序将与输入项目的顺序无关.

然而,令我好奇的是,为什么顺序从一次执行代码变为另一次？

我有一个非常简单的python脚本,正在打印dict到控制台.字典看起来像这样(内容非常相关):

{
    'hello': 'hi',
    'goodbye': 'bye',
    'hahaha': 'lol',
}

将其打印到控制台会导致项目不仅以随机顺序打印,而且每次运行程序时都以不同的顺序打印.这是我的问题:为什么会这样？

注意:python代码在django项目中(但在这种情况下我没有使用任何django功能 - 只是提到它以防它以某种方式相关).

假设我有两个选项来生成网络的邻接矩阵:nx.adjacency_matrix()以及我自己的代码.我想测试我的代码的正确性,并提出了一些奇怪的不等式.

示例:3x3网格网络.

import networkx as nx
N=3
G=nx.grid_2d_graph(N,N)
pos = dict( (n, n) for n in G.nodes() )
labels = dict( ((i,j), i + (N-1-j) * N ) for i, j in G.nodes() )
nx.relabel_nodes(G,labels,False)
inds=labels.keys()
vals=labels.values()
inds.sort()
vals.sort()
pos2=dict(zip(vals,inds))
plt.figure()
nx.draw_networkx(G, pos=pos2, with_labels=True, node_size = 200)

这是可视化:

邻接矩阵nx.adjacency_matrix():

B=nx.adjacency_matrix(G)
B1=B.todense()

[[0 0 0 0 0 1 0 0 1]
 [0 0 0 1 0 1 0 0 0]
 [0 0 0 …

我知道Python dicts是无序的,但如果你调用iteritems(),它会返回一个有序的列表.如何确定该列表的顺序？

请参阅下面的连接方法代码片段(使用Python 2.7.2):

iDict={'1_key':'abcd','2_key':'ABCD','3_key':'bcde','4_key':'BCDE'}
'--'.join(iDict)

结果显示为

'2_key--1_key--4_key--3_key'

请评论为什么只有密钥加入？序列也不按顺序排列.

注意 - 以下是各个方法.

• '--'.join(iDict.values())==> 'ABCD--abcd--BCDE--bcde' ==>序列不按顺序排列
• '--'.join(iDict.keys()) ==> '2_key--1_key--4_key--3_key'==>序列不在orde中

我想编写一个可以用作可散列集合中的键的类(例如,在a中dict).我知道用户类默认id(self)是可以使用的,但在这里使用是错误的.

我的类拥有一个tupleas成员变量.派生tuple似乎不是一个选项,因为在我的构造函数中,我没有得到与构造函数相同的参数tuple.但也许这不是限制？

我需要的基本上是tuple一个真正的元组给它的方式的哈希.

hash(self.member_tuple) 做到了那一点.

这里的想法是两个元组可以相等而不id相等.

如果我__cmp__()按如下方式执行:

def __cmp__(self, other):
    return cmp(self, other)

这会自动求助于hash(self)比较吗？......或者我应该按如下方式实施:

def __cmp__(self, other):
    return cmp(self.member_tuple, other)

我的__hash__()函数被实现为返回被保持的哈希值tuple,即:

def __hash__(self):
    return hash(self.member_tuple)

基本上,如何做__cmp__()和__hash__()互动？我不知道是否__cmp__()该other将已经是一个哈希与否,我是否应该比较对"我"的哈希(这将是的举行的一个tuple),或反对self.

那么哪一个是正确的呢？

任何人都可以对此有所了解并可能指出我的文档吗？

我想只检索词典"e"中的第四项(下面).

我尝试使用OrderedDict()方法,但它没有用.这是我的结果:

from collections import OrderedDict

e = OrderedDict()
e = {'a': 'A',
     'b': 'B',
     'c': 'C',
     'd': 'D',
     'e': 'E'
    }

for k, v in e.items():
    print k, v

print e.items()[3]

最后一行返回:('e','E')

所以我将键和值转换为列表,但是这些列表在我打印时是如何出现的:

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


['A', 'C', 'B', 'E', 'D']

对我来说,这解释了它为什么会发生,但不是如何发生的.

所以,接下来我整理了它们.这给了我正在寻找的结果 - 但它似乎不必要地复杂化:

e = {'a': 'A',
     'b': 'B',
     'c': 'C',
     'd': 'D',
     'e': 'E'
}
k, v = sorted(e.keys()), sorted(e.values())
print "{}: {}".format(k[3], v[3])

结果:d:D

OrderedDict()不是必需的.

有更简单的方法吗？有人可以解释为什么字典中的元素是这样排序的:

keys: 'a', 'c', 'b', 'e', 'd'


values: …

我已经看到了建议的解决方案和解决方法，但是找不到关于不允许在迭代过程中更改集的选择的解释。你能帮我理解为什么可以吗

In [1]: l = [1]

In [2]: for i in l:
            l.append(2*i)
            if len(l)>10:
                    break

In [3]: l
Out[3]: [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]

虽然这不行

In [4]: l = {1}

In [5]: for i in l:
            l.add(2*i)
            if len(l)>10:
                    break
---------------------------------------------------------------------------
RuntimeError                              Traceback (most recent call last)
<ipython-input-5-b5bdff4a382b> in <module>()
----> 1 for i in l:
      2         l.add(2*i)
      3         if len(l)>10:
      4                 break
      5

RuntimeError: Set changed size during iteration

在迭代时更改集合有什么不好？

我知道集合中的顺序未定义，因此next …

我正在使用Hackerrank进行Python 3学习.

在最常见的任务中,您将获得一个仅包含小写英文字符的字符串,您需要在该字符串中找到前三个最常见的字符.

我遇到了一些问题.

我对此问题的解决方案如下:

#!/bin/python3
import sys

if __name__ == "__main__":
  s = input().strip()
  ch_dict = {}
  for ch in s:
      if ch in ch_dict : ch_dict[ch] +=1
      else: ch_dict[ch] = 1

  result = sorted(ch_dict.items(),key=lambda d:d[1],reverse=True)
  for i in result:
      if i[1] != 1:
          print(" ".join(map(str,i)))

当我在本地环境中测试此代码时,它可以工作!

但在线测试中,它可能会失败!

对于此输入:

aabbbccde

我提交了很多次,有时得到这样的正确答案:

b 3
a 2
c 2

并且还可以得到这个:

b 3
c 2
a 2

看起来好像不稳定？或者我的代码有什么关系？或者在Hackerrank环境中出了什么问题？

我怎样才能保证输出？

从 PyScripter (3.6.4.0) REPL 控制台：

*** Python 3.7.7 (tags/v3.7.7:d7c567b08f, Mar 10 2020, 10:41:24) [MSC v.1900 64 bit (AMD64)] on win32. ***
*** Remote Python engine is active ***
>>> d = {}
>>> d['B'] = 12
>>> d['A'] = 10
>>> d['C'] = 34
>>> d
{'A': 10, 'B': 12, 'C': 34}

这个结果让我们相信 Python 对键进行排序并且不保留插入顺序，而从 3.6 版本开始就可以保证。

现在让我们在 PyScripter 之外的控制台中运行完全相同版本的 Python：

Python 3.7.7 (tags/v3.7.7:d7c567b08f, Mar 10 2020, 10:41:24) [MSC v.1900 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or …