blocks|key|1815818|text|random.seed(datetime.datetime.now())+

from+random+import+randint
#+ot+generate+100+tuples+with+randints+in+range+0-99
li+=+[(randint(0,99),randint(0,99))+for+i+in+range(100)]
print(li)

[(80,+55),+(3,+10),+(66,+65),+(26,+23),+(8,+72),+(83,+25),+(24,+99),+(72,+9),+(52,+76),+(72,+68),+(67,+25),+(72,+18),+(94,+62),+(7,+62),+(49,+94),+(29,+89),+(11,+38),+(52,+51),+(19,+32),+(20,+85),+(56,+61),+(4,+40),+(97,+58),+(82,+2),+(50,+82),+(77,+5),+(2,+9),+(2,+46),+(39,+4),+(74,+40),+(69,+15),+(1,+77),+(45,+58),+(80,+59),+(85,+80),+(27,+80),+(81,+4),+(22,+33),+(77,+60),+(75,+87),+(43,+36),+(60,+34),+(90,+54),+(75,+3),+(89,+84),+(51,+93),+(62,+64),+(81,+50),+(15,+60),+(33,+97),+(42,+62),+(83,+26),+(13,+33),+(41,+87),+(29,+63),+(4,+32),+(6,+14),+(79,+73),+(95,+4),+(41,+16),+(96,+64),+(15,+28),+(35,+13),+(35,+82),+(77,+16),+(63,+27),+(75,+37),+(11,+52),+(21,+35),+(37,+96),+(9,+86),+(83,+11),+(5,+42),+(34,+32),+(17,+8),+(65,+55),+(58,+19),+(90,+40),+(18,+75),+(29,+14),+(0,+11),+(25,+68),+(34,+52),+(22,+8),+(12,+53),+(16,+49),+(73,+54),+(78,+80),+(74,+60),+(40,+68),+(69,+20),+(37,+38),+(74,+60),+(53,+90),+(25,+48),+(44,+52),+(49,+27),+(28,+35),+(29,+94),+(35,+60)]|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1815819|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>random.seed(datetime.datetime.now()) 

from random import randint
# ot generate 100 tuples with randints in range 0-99
li = [(randint(0,99),randint(0,99)) for i in range(100)]
print(li)

[(80, 55), (3, 10), (66, 65), (26, 23), (8, 72), (83, 25), (24, 99), (72, 9), (52, 76), (72, 68), (67, 25), (72, 18), (94, 62), (7, 62), (49, 94), (29, 89), (11, 38), (52, 51), (19, 32), (20, 85), (56, 61), (4, 40), (97, 58), (82, 2), (50, 82), (77, 5), (2, 9), (2, 46), (39, 4), (74, 40), (69, 15), (1, 77), (45, 58), (80, 59), (85, 80), (27, 80), (81, 4), (22, 33), (77, 60), (75, 87), (43, 36), (60, 34), (90, 54), (75, 3), (89, 84), (51, 93), (62, 64), (81, 50), (15, 60), (33, 97), (42, 62), (83, 26), (13, 33), (41, 87), (29, 63), (4, 32), (6, 14), (79, 73), (95, 4), (41, 16), (96, 64), (15, 28), (35, 13), (35, 82), (77, 16), (63, 27), (75, 37), (11, 52), (21, 35), (37, 96), (9, 86), (83, 11), (5, 42), (34, 32), (17, 8), (65, 55), (58, 19), (90, 40), (18, 75), (29, 14), (0, 11), (25, 68), (34, 52), (22, 8), (12, 53), (16, 49), (73, 54), (78, 80), (74, 60), (40, 68), (69, 20), (37, 38), (74, 60), (53, 90), (25, 48), (44, 52), (49, 27), (28, 35), (29, 94), (35, 60)]
</code></pre>

blocks|key|654081|text|这里有一个解决方案，首先生成一个随机的节点填充(pop1)，然后对其进行洗牌(pop2)，并将它们合并成一个对列表。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|654082|注：这种方法只生成顶点，每个节点恰好只有一次start和准确的一次end，所以可能不是您想要的结果。另一种方法见下文|BOLD|654083|import+random,+copy

random.seed()+#+defaults+to+time.time()+...
#+extract+a+number+of+samples+-+the+number+of+nodes+you+want
pop1+=+random.sample(xrange(1000),+10)
pop2+=+copy.deepcopy(+pop1+)
random.shuffle(+pop2+)
#+generate+pairs+from+the+same+population+-+this+guarantees+your+constraint
pairs+=+zip(+pop1,+pop2+)

print+pairs|code-block|syntax|javascript|654084|输出：|654085|[(17,+347),+(812,+688),+(347,+266),+(731,+342),+(342,+49),+(904,+17),+(49,+731),+(50,+904),+(688,+50),+(266,+812)]|654086|这是另一种方法|654087|这允许重复出现节点。这样做的目的是从相同的种群中提取start和end节点：|654088|import+random
random.seed()
population+=+range(10)+#+any+population+would+do
#+choose+randomly+from+the+population+for+both+ends
#+so+you+can+have+duplicates
pairs+=+[(random.choice(population),+random.choice(population)+for+_+in+xrange(100)]
print+pairs[:10]|654089|654090|[(1,+9),+(7,+1),+(8,+6),+(4,+7),+(6,+2),+(7,+3),+(0,+2),+(1,+0),+(8,+3),+(8,+3)]|654091|entityMap^0|O|4|13|4|0|0|2|M|5|X|3|0|0|0|0|0|Q|5|W|3|0|0|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@$9|13|A|14|B|C]|$9|15|A|16|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|17|8|@$9|18|A|19|B|H]|$9|1A|A|1B|B|C]|$9|1C|A|1D|B|C]]|D|@]|E|$]]|$1|I|3|J|5|K|7|1E|8|@]|D|@]|E|$L|M]]|$1|N|3|O|5|6|7|1F|8|@]|D|@]|E|$]]|$1|P|3|Q|5|K|7|1G|8|@]|D|@]|E|$L|M]]|$1|R|3|S|5|6|7|1H|8|@]|D|@]|E|$]]|$1|T|3|U|5|6|7|1I|8|@$9|1J|A|1K|B|C]|$9|1L|A|1M|B|C]]|D|@]|E|$]]|$1|V|3|W|5|K|7|1N|8|@]|D|@]|E|$L|M]]|$1|X|3|O|5|6|7|1O|8|@]|D|@]|E|$]]|$1|Y|3|Z|5|K|7|1P|8|@]|D|@]|E|$L|M]]|$1|10|3|-4|5|6|7|1Q|8|@]|D|@]|E|$]]]|11|$]]

Here is a solution that first generates a random population of nodes (<code>pop1</code>), then shuffles it (<code>pop2</code>) and combines those into a list of pairs.

Note: this method only yields vertices where each node is exactly once <code>start</code> and exactly once <code>end</code>, so maybe not what you're after. See below for another method

<pre><code>import random, copy

random.seed() # defaults to time.time() ...
# extract a number of samples - the number of nodes you want
pop1 = random.sample(xrange(1000), 10)
pop2 = copy.deepcopy( pop1 )
random.shuffle( pop2 )
# generate pairs from the same population - this guarantees your constraint
pairs = zip( pop1, pop2 )

print pairs
</code></pre>

Output:

<pre><code>[(17, 347), (812, 688), (347, 266), (731, 342), (342, 49), (904, 17), (49, 731), (50, 904), (688, 50), (266, 812)]
</code></pre>

<h2>Here is another method</h2>

This allows for duplicate occurrences of the nodes.
The idea is to draw <code>start</code> and <code>end</code> nodes from the same population:

<pre><code>import random
random.seed()
population = range(10) # any population would do
# choose randomly from the population for both ends
# so you can have duplicates
pairs = [(random.choice(population), random.choice(population) for _ in xrange(100)]
print pairs[:10]
</code></pre>

Output:

<pre><code>[(1, 9), (7, 1), (8, 6), (4, 7), (6, 2), (7, 3), (0, 2), (1, 0), (8, 3), (8, 3)]
</code></pre>

blocks|key|654146|text|对于列表创建，您可以执行如下操作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|654147|import+random
max+=+999
min+=+0
original_values+=+range(min,+max)+#+could+be+arbitrary+list
n_edges+=+#+some+number..
my_edge_list+=+[(random.choice(original_values),+random.choice(original_values))+
++++++++++++++++++++++for+_+in+range(n_edges)]|code-block|syntax|javascript|654148|要断言其中包含所有的值，可以执行以下操作|654149|vals+=+set([v+for+tup+in+my_edge_list+for+v+in+tup])
assert+all([v+in+vals+for+v+in+original_values])|654150|断言将确保在边中有正确的表示形式。只要尽你最大的努力确保你没有击中断言，你就可以做几件事。|654151|示例，不需要从整数列表中替换，直到它们全部消失，创建一个“基本网络”，然后随机添加更多到您心中的愿望。|ordered-list-item|654152|使n_edges足够高，很可能您的条件将得到满足。如果不再试一次..。|654153|实际上取决于您将使用网络的用途以及您希望它具有什么样的结构。|654154|编辑:我已经更新了我的响应，使其对任意的值列表更加健壮，而不是需要一个顺序列表。|offset|length|style|BOLD|654155|entityMap^0|0|0|0|0|0|0|0|0|0|14|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|12|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|13|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|14|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|15|8|@]|9|@]|A|$]]|$1|M|3|N|5|O|7|16|8|@]|9|@]|A|$]]|$1|P|3|Q|5|O|7|17|8|@]|9|@]|A|$]]|$1|R|3|S|5|6|7|18|8|@]|9|@]|A|$]]|$1|T|3|U|5|6|7|19|8|@$V|1A|W|1B|X|Y]]|9|@]|A|$]]|$1|Z|3|-4|5|6|7|1C|8|@]|9|@]|A|$]]]|10|$]]

For the list creation you can do something like:

<pre><code>import random
max = 999
min = 0
original_values = range(min, max) # could be arbitrary list
n_edges = # some number..
my_edge_list = [(random.choice(original_values), random.choice(original_values)) 
 for _ in range(n_edges)]
</code></pre>

To assert you have all values in there you can do the following

<pre><code>vals = set([v for tup in my_edge_list for v in tup])
assert all([v in vals for v in original_values])
</code></pre>

The assert will make sure you have the proper representation in your edges. As far as doing your best to make sure you don't hit that assert you can do a couple of things.

<ol>
<li>Sample without replacement from your list of integers until they are all gone to create a "base network" and then randomly add on more to your hearts desire</li>
<li>Make n_edges sufficiently high that it's very likely your condition will be met. If it's not try again...</li>
</ol>

Really depends on what you're going to use the network for and what kind of structure you want it to have

EDIT: I have updated my response to be more robust to an arbitrary list of values rather than requiring a sequential list

blocks|key|654201|text|除了如何使用python的networkx模块从节点列表生成完全连接的子图上的一个完整图外，还有一个类似的答案。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|654202|在您的例子中，使用朱宾梅塔的回答|654203|导入networkx导入迭代工具def+complete_graph_from_list(L，create_using=None)：g=+networkx.empty_graph(len(L)，create_using)如果len(L)>1:如果G.is_directed()：create_using=+itertools.permutations(L,2)，否则:create_using=+itertools.combinations(L,2)+G.add_edges_from(边)返回G|blockquote|654204|您可以将图表构建为：|654205|S+=+complete_graph_from_list(map(lambda+x:+str(x),+range(0,1000)))
print+S.edges()|code-block|syntax|javascript|654206|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/10649673/how-to-generate-a-fully-connected-subgraph-from-node-list-using-pythons-network|1|https://stackoverflow.com/users/294714/zubinmehta|2|https://stackoverflow.com/a/10651524/510937^0|2|Z|0|0|9|4|1|E|2|2|0|0|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@$A|12|B|13|1|14]]|C|$]]|$1|D|3|E|5|6|7|15|8|@]|9|@$A|16|B|17|1|18]|$A|19|B|1A|1|1B]]|C|$]]|$1|F|3|G|5|H|7|1C|8|@]|9|@]|C|$]]|$1|I|3|J|5|6|7|1D|8|@]|9|@]|C|$]]|$1|K|3|L|5|M|7|1E|8|@]|9|@]|C|$N|O]]|$1|P|3|-4|5|6|7|1F|8|@]|9|@]|C|$]]]|Q|$R|$5|S|T|U|C|$V|W]]|X|$5|S|T|U|C|$V|Y]]|Z|$5|S|T|U|C|$V|10]]]]

There is a similar answer but for a complete graph on - <a href="https://stackoverflow.com/questions/10649673/how-to-generate-a-fully-connected-subgraph-from-node-list-using-pythons-network">How to generate a fully connected subgraph from node list using python&#39;s networkx module</a>

In your case, using <a href="https://stackoverflow.com/users/294714/zubinmehta">zubinmehta</a>'s <a href="https://stackoverflow.com/a/10651524/510937">answer</a>:

<blockquote>
<pre><code>import networkx
import itertools

def complete_graph_from_list(L, create_using=None):
 G = networkx.empty_graph(len(L),create_using)
 if len(L)&gt;1:
 if G.is_directed():
 edges = itertools.permutations(L,2)
 else:
 edges = itertools.combinations(L,2)
 G.add_edges_from(edges)
 return G
</code></pre>
</blockquote>

You could build the graph as:

<pre><code>S = complete_graph_from_list(map(lambda x: str(x), range(0,1000)))
print S.edges()
</code></pre>

blocks|key|1816007|text|Python内置了名为迭代工具的库。下面是您如何实现您提到的内容的示例：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1816008|import+itertools

list+=+[3,+4,+6,+7]
sublist_length+=+2
comb+=+itertools.combinations(list,+sublist_length)|code-block|syntax|javascript|1816009|这将返回梳状作为迭代器。|style|BOLD|1816010|您可以执行comb.next()来获取迭代器中的下一个元素，也可以按如下所示在for循环上进行迭代以获得所有结果。|CODE|1816011|for+item+in+comb:
++++print+item|1816012|哪一项应产出：|1816013|(3,+4),
(3,+6),
(3,+7),
(4,+6),
(4,+7),
(6,+7),|1816014|我希望这能解决你的问题。|1816015|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/2/library/itertools.html^0|B|4|0|0|0|4|2|0|5|B|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|15|8|@]|9|@$A|16|B|17|1|18]]|C|$]]|$1|D|3|E|5|F|7|19|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|1A|8|@$A|1B|B|1C|K|L]]|9|@]|C|$]]|$1|M|3|N|5|6|7|1D|8|@$A|1E|B|1F|K|O]]|9|@]|C|$]]|$1|P|3|Q|5|F|7|1G|8|@]|9|@]|C|$G|H]]|$1|R|3|S|5|6|7|1H|8|@]|9|@]|C|$]]|$1|T|3|U|5|F|7|1I|8|@]|9|@]|C|$G|H]]|$1|V|3|W|5|6|7|1J|8|@]|9|@]|C|$]]|$1|X|3|-4|5|6|7|1K|8|@]|9|@]|C|$]]]|Y|$Z|$5|10|11|12|C|$13|14]]]]

Python has inbuilt library called <a href="https://docs.python.org/2/library/itertools.html" rel="nofollow noreferrer">itertools</a>.
Sample as below as how you achieve what you mentioned:

<pre><code>import itertools

list = [3, 4, 6, 7]
sublist_length = 2
comb = itertools.combinations(list, sublist_length)
</code></pre>

This will return comb as an iterator.

You can do <code>comb.next()</code> to get next element in the iterator or iterate over a for loop to get all results as you wanted as below.

<pre><code>for item in comb:
 print item
</code></pre>

which should output:

<pre><code>(3, 4),
(3, 6),
(3, 7),
(4, 6),
(4, 7),
(6, 7),
</code></pre>

I hope this will solve your problem.

blocks|key|654225|text|下面是一个networkx命令，它将创建一个图，以便每个节点都有一个边缘：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|654226|import+networkx+as+nx
G+=+nx.configuration_model([1]*1000)|code-block|syntax|javascript|654227|如果你仔细观察它的核心，它会回答你的问题--每个节点都会出现在中，正好是的一个边缘。|offset|length|style|BOLD|654228|import+random
mylist+=+random.suffle(range(start,end))
edgelist+=+[]
while+mylist:
++++edgelist.append((mylist.pop(),mylist.pop()))|654229|在进行弹出之前，您应该保证mylist具有偶数长度。|CODE|654230|entityMap^0|0|0|V|5|0|0|D|6|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|U|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|V|8|@$I|W|J|X|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|Y|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|Z|8|@$I|10|J|11|K|Q]]|9|@]|A|$]]|$1|R|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|S|$]]

Here is a networkx command that will create a graph such that each node has exactly one edge:

<pre><code>import networkx as nx
G = nx.configuration_model([1]*1000)
</code></pre>

If you look into the guts of it, it does the following which answers your question - each node will appear in exactly one edge.

<pre><code>import random
mylist = random.suffle(range(start,end))
edgelist = []
while mylist:
 edgelist.append((mylist.pop(),mylist.pop()))
</code></pre>

You should guarantee that <code>mylist</code> has even length before going through the popping.

I am rather new to Python and NetworkX. I need to create a list similar to <code>Edgelist=[(0,1),(0,3),(1,0),(1,2),(1,4),(2,1),(2,5)]</code>, which elements represent the starting and ending node of an edge (link) that is in turn part of a network.

Rather than setting them manually, I want Python to create the couples you see in the list by randomly selecting the integer values of <code>(start,end)</code> from an assigned range of values (namely, <code>0, 999</code>), which represent the node IDs. Then, I want to make sure that every node ID is included at least once in the series of (start,end) values (this means that all my nodes will be connected to at least one other node).

I know I could use <code>random.randint(0, 999)</code> but I don't know how to "nest" it into the creation of a list (perhaps a for loop?). I wish I had some code to show you but this is my first attempt at working with NetworkX! 

EDIT

To give you a visual idea of what I mean, here are two images. The first is a regular network (aka lattice), and the second is a random one. The edge list of the first was created manually in order to reproduce a chess table, while the second displays an edge list which is a (manually) shuffled counterpart of the first one. As you see, the nodes are kept in exactly the same locations. Hope this helps a bit more. Thanks!
<a href="https://i.stack.imgur.com/JaoeZ.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/JaoeZ.png" alt="enter image description here"></a>
<a href="https://i.stack.imgur.com/0jwm3.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/0jwm3.png" alt="enter image description here"></a>

How to generate a list with couples of random integers?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我对Python和NetworkX相当陌生。我需要创建一个类似于Edgelist=[(0,1),(0,3),(1,0),(1,2),(1,4),(2,1),(2,5)]的列表，其中的元素表示边缘(链接)的开始和结束节点，而边缘(链接)又是网络的一部分。我不希望Python手动设置它们，而是通过从指定的值范围(即(sta...

问如何生成一对随机整数的列表？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何生成一对随机整数的列表？EN