Establir operacions (p. ex., determinar conjunts d’unió, conjunts de productes i subconjunts) amb el tipus de conjunt de Python

Negocis

Python proporciona un tipus de dades integrat, set, que gestiona conjunts.

El conjunt de tipus és una col·lecció d’elements no duplicats (elements que no tenen el mateix valor, elements únics) i pot realitzar operacions de conjunt com ara el conjunt d’unions, el conjunt de productes i el conjunt de diferències.

En aquesta secció, s’expliquen les operacions bàsiques de les operacions de conjunt de tipus conjunt amb codi d’exemple.

  • Creació d’objectes conjunts:{},set()
  • establir la notació d’inclusió
  • Nombre d’elements del conjunt:len()
  • Afegir un element a un conjunt:add()
  • Elimina un element d’un conjunt:discard(),remove(),pop(),clear()
  • Wasset (fusió, unió):|operador,union()
  • Conjunts de productes (parts comunes, interseccions, interseccions):& operador,intersection()
  • complement relatiu:-operador,difference()
  • conjunt de diferències de simetria:^ operador,symmetric_difference()
  • subconjunt o no:<= operador,issubset()
  • Conjunt superior o no:>= operador,issuperset()
  • Determinació de si són mútuament primers o no:isdisjoint()

El tipus de conjunt és un tipus mutable que pot afegir i suprimir elements, i també hi ha un tipus de conjunt congelat que té la mateixa operació de conjunt i altres mètodes que el tipus de conjunt, però és immutable (no es pot modificar afegint, suprimint o modificant elements d’una altra manera). ).

Creació de l’objecte conjunt::{},set()

Generat per parèntesis d’ona {}

Els objectes de tipus conjunt es poden crear tancant elements entre claus {}.

Si hi ha valors duplicats, s’ignoren i només romanen com a elements els valors únics.

s = {1, 2, 2, 3, 1, 4}

print(s)
print(type(s))
# {1, 2, 3, 4}
# <class 'set'>

És possible tenir diferents tipus com a elements. Tanmateix, no es poden registrar objectes actualitzables, com ara tipus de llista. Es permeten tuples.

A més, com que els tipus de conjunt no estan ordenats, l’ordre en què es generen no s’emmagatzema.

s = {1.23, 'abc', (0, 1, 2), 'abc'}

print(s)
# {(0, 1, 2), 1.23, 'abc'}

# s = {[0, 1, 2]}
# TypeError: unhashable type: 'list'

Els diferents tipus, com int i float, es consideren duplicats si els seus valors són equivalents.

s = {100, 100.0}

print(s)
# {100}

Com que una clau {} es considera un tipus de diccionari, es pot crear un objecte tipus conjunt buit (conjunt buit) utilitzant el constructor que es descriu a continuació.

s = {}

print(s)
print(type(s))
# {}
# <class 'dict'>

Generat pel constructor set()

Els objectes de tipus set també es poden crear amb el constructor set().

Especificar un objecte iterable com una llista o una tupla com a argument genera un objecte conjunt els elements del qual només són valors únics, amb els elements duplicats exclosos.

l = [1, 2, 2, 3, 1, 4]

print(l)
print(type(l))
# [1, 2, 2, 3, 1, 4]
# <class 'list'>

s_l = set(l)

print(s_l)
print(type(s_l))
# {1, 2, 3, 4}
# <class 'set'>

Els tipus frozenset immutables es creen amb el constructor frozenset().

fs_l = frozenset(l)

print(fs_l)
print(type(fs_l))
# frozenset({1, 2, 3, 4})
# <class 'frozenset'>

Si s’omet l’argument, es crea un objecte de tipus conjunt buit (conjunt buit).

s = set()

print(s)
print(type(s))
# set()
# <class 'set'>

Els elements duplicats es poden eliminar d’una llista o tupla mitjançant set(), però l’ordre de la llista original no es conserva.

Per convertir un tipus de conjunt en una llista o tupla, utilitzeu list(),tupla().

l = [2, 2, 3, 1, 3, 4]

l_unique = list(set(l))
print(l_unique)
# [1, 2, 3, 4]

Vegeu l’article següent per obtenir informació sobre com eliminar elements duplicats tot preservant l’ordre, extreure només elements duplicats i processar elements duplicats en una matriu bidimensional (llista de llistes).

establir la notació d’inclusió

A més de les comprensions de llista, hi ha comprensions establertes. Simplement substituïu els claudàtors [] per claus {} a la comprensió de la llista.

s = {i**2 for i in range(5)}

print(s)
# {0, 1, 4, 9, 16}

Consulteu l’article següent per obtenir més informació sobre la notació de comprensió de llistes.

Nombre d’elements del conjunt:len()

El nombre d’elements d’un conjunt es pot obtenir amb la funció integrada len().

s = {1, 2, 2, 3, 1, 4}

print(s)
print(len(s))
# {1, 2, 3, 4}
# 4

Si voleu comptar el nombre d’elements de cada llista que té elements amb valors duplicats, etc., consulteu l’article següent.

Afegir un element a un conjunt:add()

Per afegir un element a un conjunt, utilitzeu el mètode add().

s = {0, 1, 2}

s.add(3)
print(s)
# {0, 1, 2, 3}

Elimina un element d’un conjunt:discard(),remove(),pop(),clear()

Per eliminar un element d’un conjunt, utilitzeu els mètodes discard(), remove(), pop() i clear().

El mètode discard() elimina l’element especificat a l’argument. Si s’especifica un valor que no existeix al conjunt, no es fa res.

s = {0, 1, 2}

s.discard(1)
print(s)
# {0, 2}

s = {0, 1, 2}

s.discard(10)
print(s)
# {0, 1, 2}

El mètode remove() també elimina l’element especificat a l’argument, però es retorna un error KeyError si s’especifica un valor que no existeix al conjunt.

s = {0, 1, 2}

s.remove(1)
print(s)
# {0, 2}

# s = {0, 1, 2}

# s.remove(10)
# KeyError: 10

El mètode pop() elimina elements d’un conjunt i retorna els seus valors. No és possible seleccionar quins valors eliminar. Un conjunt buit donarà lloc a un error KeyError.

s = {2, 1, 0}

v = s.pop()

print(s)
print(v)
# {1, 2}
# 0

s = {2, 1, 0}

print(s.pop())
# 0

print(s.pop())
# 1

print(s.pop())
# 2

# print(s.pop())
# KeyError: 'pop from an empty set'

El mètode clear() elimina tots els elements i deixa el conjunt buit.

s = {0, 1, 2}

s.clear()
print(s)
# set()

Wasset (fusió, unió):|operador,union()

El conjunt d’unió (fusió, unió) es pot obtenir amb el | operador o el mètode union().

s1 = {0, 1, 2}
s2 = {1, 2, 3}
s3 = {2, 3, 4}

s_union = s1 | s2
print(s_union)
# {0, 1, 2, 3}

s_union = s1.union(s2)
print(s_union)
# {0, 1, 2, 3}

Es poden especificar diversos arguments per a un mètode. A més del tipus de conjunt, també es poden especificar com a arguments les llistes i tuples que es poden convertir al tipus de conjunt mitjançant set(). El mateix s’aplica als operadors i mètodes posteriors.

s_union = s1.union(s2, s3)
print(s_union)
# {0, 1, 2, 3, 4}

s_union = s1.union(s2, [5, 6, 5, 7, 5])
print(s_union)
# {0, 1, 2, 3, 5, 6, 7}

Conjunts de productes (parts comunes, interseccions, interseccions):& operador,intersection()

El conjunt de productes (part comuna, intersecció i intersecció) es pot obtenir amb el & operador o el mètode intersection().

s_intersection = s1 & s2
print(s_intersection)
# {1, 2}

s_intersection = s1.intersection(s2)
print(s_intersection)
# {1, 2}

s_intersection = s1.intersection(s2, s3)
print(s_intersection)
# {2}

complement relatiu:-operador,difference()

El conjunt de diferències es pot obtenir amb l’operador – o el mètode difference().

s_difference = s1 - s2
print(s_difference)
# {0}

s_difference = s1.difference(s2)
print(s_difference)
# {0}

s_difference = s1.difference(s2, s3)
print(s_difference)
# {0}

conjunt de diferències de simetria:^ operador,symmetric_difference()

El conjunt de diferències simètriques (el conjunt d’elements contingut només en un dels dos) es pot obtenir amb l’operador ^ o symmetric_difference().

Equivalent a la disjunció exclusiva (XOR) en operacions lògiques.

s_symmetric_difference = s1 ^ s2
print(s_symmetric_difference)
# {0, 3}

s_symmetric_difference = s1.symmetric_difference(s2)
print(s_symmetric_difference)
# {0, 3}

subconjunt o no:<= operador,issubset()

Per determinar si un conjunt és un subconjunt d’un altre conjunt, utilitzeu l’operador <= o el mètode issubset().

s1 = {0, 1}
s2 = {0, 1, 2, 3}

print(s1 <= s2)
# True

print(s1.issubset(s2))
# True

Tant l’operador <= com el mètode issubset() tornen cert per a conjunts equivalents.

Per determinar si és un subconjunt veritable, utilitzeu l’operador <=, que retorna fals per a conjunts equivalents.

print(s1 <= s1)
# True

print(s1.issubset(s1))
# True

print(s1 < s1)
# False

Conjunt superior o no:>= operador,issuperset()

Per determinar si un conjunt és un superconjunt d’un altre, utilitzeu l’operador >= o issuperset().

s1 = {0, 1}
s2 = {0, 1, 2, 3}

print(s2 >= s1)
# True

print(s2.issuperset(s1))
# True

Tant l’operador >= com el mètode issuperset() tornen cert per a conjunts equivalents.

Per determinar si és un superconjunt veritable, utilitzeu l’operador >=, que retorna fals per a conjunts equivalents.

print(s1 >= s1)
# True

print(s1.issuperset(s1))
# True

print(s1 > s1)
# False

Determinació de si són mútuament primers o no:isdisjoint()

Per determinar si dos conjunts són primers entre si, utilitzeu el mètode isdisjoint().

s1 = {0, 1}
s2 = {1, 2}
s3 = {2, 3}

print(s1.isdisjoint(s2))
# False

print(s1.isdisjoint(s3))
# True
Copied title and URL