Comment joindre deux ensembles sur une ligne sans utiliser "|" ?

Question

Supposons que S y T sont des ensembles assignés. Sans utiliser l'opérateur de jointure | Comment puis-je trouver l'union de ces deux ensembles ? Ceci, par exemple, trouve l'intersection :

S = {1, 2, 3, 4}
T = {3, 4, 5, 6}
S_intersect_T = { i for i in S if i in T }

Alors comment puis-je trouver l'union de deux ensembles en une ligne sans utiliser | ?

Answer 1

Vous pouvez simplement décompresser les deux ensembles en un seul comme ceci :

>>> set_1 = {1, 2, 3, 4}
>>> set_2 = {3, 4, 5, 6}
>>> union = {*set_1, *set_2}
>>> union
{1, 2, 3, 4, 5, 6}

Le site * déballe l'ensemble. Le dépaquetage consiste à représenter un itérable (par exemple, un ensemble ou une liste) comme chaque élément qu'il produit. Cela signifie que l'exemple ci-dessus se simplifie en {1, 2, 3, 4, 3, 4, 5, 6} qui se simplifie alors en {1, 2, 3, 4, 5, 6} car l'ensemble ne peut contenir que des éléments uniques.

Answer 2

Supposons que vous ayez 2 listes

 A = [1,2,3,4]
 B = [3,4,5,6]

pour que vous puissiez trouver A Union B comme suit

 union = set(A).union(set(B))

également si vous voulez trouver l'intersection et la non-intersection vous le faites comme suit

 intersection = set(A).intersection(set(B))
 non_intersection = union - intersection

Answer 3

Vous pouvez faire union ou la compréhension d'une liste simple

[A.add(_) for _ in B]

A aurait tous les éléments de B

Answer 4

Si vous voulez rejoindre n les meilleures performances semblent provenir de set().union(*list_of_sets) qui renverra un nouvel ensemble.

Ainsi, l'usage pourrait être :

s1 = {1, 2, 3}
s2 = {2, 3, 4}
s3 = {4, 5, 6}

s1.union(s2, s3) # returns a new set
# Out: {1, 2, 3, 4, 5, 6}
s1.update(s2, s3) # updates inplace

Ajouter à Alexander Klimenko Après avoir pris connaissance de la réponse de l'auteur ci-dessus, j'ai effectué quelques tests simples, comme indiqué ci-dessous. Je crois que la principale conclusion est qu'il semble que l'option plus de hasard les ensembles sont, les plus grande est la différence sur les performances.

from random import randint

n = 100

generate_equal = lambda: set(range(10_000))
generate_random = lambda: {randint(0, 100_000) for _ in range(10_000)}

for l in [
    [generate_equal() for _ in range(n)],
    [generate_random() for _ in range(n)]
]:
    %timeit set().union(*l)
    %timeit reduce(or_, l)

Out:
  # equal sets: 69.5 / 23.6 =~ 3
  23.6 ms ± 658 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
  69.5 ms ± 2.57 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
  # random sets: 438 / 78.7 =~ 5.6
  78.7 ms ± 1.48 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
  438 ms ± 20.8 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

Par conséquent, si vous souhaitez effectuer une mise à jour sur place, les meilleures performances proviennent de set.update la méthode, comme, la performance, s1.update(s2, s3) = set().union(s2, s3) .