Vendosni operacione (p.sh., përcaktimi i grupeve të bashkimit, grupeve të produkteve dhe nënbashkësive) me llojin e grupit të Python

biznes

Python ofron një lloj të integruar të të dhënave, grup, i cili trajton grupet.

Kompleti i tipit është një koleksion elementesh jo dublikatë (elemente që nuk janë të njëjtën vlerë, elemente unike) dhe mund të kryejë operacione të grupeve si grup bashkimi, grup produkti dhe grup diferencash.

Në këtë seksion, operacionet bazë në operacionet e grupit të tipit shpjegohen me kodin e mostrës.

  • Krijimi i objekteve të vendosura:{},set()
  • vendos shënimin e përfshirjes
  • Numri i elementeve në grup:len()
  • Shtimi i një elementi në një grup:add()
  • Hiqni një element nga një grup:discard(),remove(),pop(),clear()
  • Wasset (bashkim, bashkim):|operator,union()
  • Kompletet e produkteve (pjesë të përbashkëta, kryqëzime, kryqëzime):& operatori,intersection()
  • plotësues relativ:-operator,difference()
  • grup diferencash simetrie:^ operator,symmetric_difference()
  • nëngrup ose jo:<= operator,issubset()
  • Kompleti i sipërm apo jo:>= operator,issuperset()
  • Përcaktimi nëse ato janë reciproke apo jo:isdisjoint()

Lloji i grupit është një lloj i ndryshueshëm që mund të shtojë dhe fshijë elementë, dhe ka gjithashtu një lloj grupi të ngrirë që ka të njëjtin funksion grupi dhe metoda të tjera si lloji i grupit, por është i pandryshueshëm (nuk mund të modifikohet duke shtuar, fshirë ose modifikuar ndryshe elementë ).

Krijimi i objektit të vendosur::{},set()

Gjeneruar nga kllapat e valës {}

Objektet e grupit të tipit mund të krijohen duke mbyllur elementët në kllapa {}.

Nëse ka vlera të dyfishta, ato injorohen dhe vetëm vlerat unike mbeten si elemente.

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

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

Mund të ketë si elementë lloje të ndryshme. Megjithatë, objektet e përditësueshme të tilla si llojet e listave nuk mund të regjistrohen. Tufat janë të lejuara.

Gjithashtu, duke qenë se llojet e grupeve janë të pa renditura, radha në të cilën ato gjenerohen nuk ruhet.

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

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

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

Lloje të ndryshme, si int dhe float, konsiderohen dublikatë nëse vlerat e tyre janë ekuivalente.

s = {100, 100.0}

print(s)
# {100}

Meqenëse një kllapa bosh {} konsiderohet një lloj fjalori, një objekt i tipit të grupit bosh (bashkësi bosh) mund të krijohet duke përdorur konstruktorin e përshkruar më poshtë.

s = {}

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

Gjeneruar nga grupi i konstruktorit ()

Objektet e tipit set mund të krijohen edhe me konstruktorin set().

Specifikimi i një objekti të përsëritur si një listë ose tuple si një argument gjeneron një objekt grupi, elementët e të cilit janë vetëm vlera unike, me elementë dublikatë të përjashtuar.

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'>

Llojet e grupeve të ngrira të pandryshueshme krijohen me konstruktorin frozenset().

fs_l = frozenset(l)

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

Nëse argumenti hiqet, krijohet një objekt bosh i tipit grup (bashkësi bosh).

s = set()

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

Elementet dublikatë mund të hiqen nga një listë ose tuple duke përdorur set(), por rendi i listës origjinale nuk ruhet.

Për të kthyer një lloj grupi në një listë ose tuple, përdorni list(),tuple().

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

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

Shih artikullin vijues për informacion mbi heqjen e elementeve dublikatë duke ruajtur rendin, nxjerrjen vetëm të elementeve dublikatë dhe përpunimin e elementeve dublikatë në një grup dydimensional (lista e listave).

vendos shënimin e përfshirjes

Si dhe kuptimet e listave, ka edhe kuptime të caktuara. Thjesht zëvendësoni kllapat katrore [] me kllapat {} në kuptimin e listës.

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

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

Shihni artikullin vijues për më shumë informacion mbi shënimin e kuptimit të listës.

Numri i elementeve në grup:len()

Numri i elementeve në një grup mund të merret me funksionin e integruar len().

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

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

Nëse dëshironi të numëroni numrin e elementeve në secilën listë që ka elementë me vlera të dyfishta, etj., shihni artikullin vijues.

Shtimi i një elementi në një grup:add()

Për të shtuar një element në një grup, përdorni metodën add().

s = {0, 1, 2}

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

Hiqni një element nga një grup:discard(),remove(),pop(),clear()

Për të hequr një element nga një grup, përdorni metodat discard(), remove(), pop() dhe clear().

Metoda discard() fshin elementin e specifikuar në argument. Nëse specifikohet një vlerë që nuk ekziston në grup, asgjë nuk bëhet.

s = {0, 1, 2}

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

s = {0, 1, 2}

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

Metoda remove() gjithashtu heq elementin e specifikuar në argument, por një gabim KeyError kthehet nëse specifikohet një vlerë që nuk ekziston në grup.

s = {0, 1, 2}

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

# s = {0, 1, 2}

# s.remove(10)
# KeyError: 10

Metoda pop() heq elementet nga një grup dhe kthen vlerat e tyre. Nuk është e mundur të zgjedhësh cilat vlera të hiqen. Një grup bosh do të rezultojë në një gabim 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'

Metoda clear() heq të gjithë elementët dhe e bën grupin bosh.

s = {0, 1, 2}

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

Wasset (bashkim, bashkim):|operator,union()

Bashkësia e bashkimit (bashkimi, bashkimi) mund të merret me | operatori ose metoda 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}

Argumente të shumta mund të specifikohen për një metodë. Përveç llojit të grupit, listat dhe tuplet që mund të konvertohen në llojin e grupit sipas set() mund të specifikohen gjithashtu si argumente. E njëjta gjë vlen edhe për operatorët dhe metodat e mëvonshme.

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}

Kompletet e produkteve (pjesë të përbashkëta, kryqëzime, kryqëzime):& operatori,intersection()

Kompleti i produkteve (pjesa e përbashkët, kryqëzimi dhe kryqëzimi) mund të merret me & operatori ose metoda 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}

plotësues relativ:-operator,difference()

Seti i diferencës mund të merret me operatorin – ose metodën diferencë().

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}

grup diferencash simetrie:^ operator,symmetric_difference()

Bashkësia e diferencës simetrike (bashkësia e elementeve që përmbahet vetëm në njërin nga të dy) mund të merret me operatorin ^ ose simetrik_difference().

Ekuivalente me ndarjen ekskluzive (XOR) në operacionet logjike.

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

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

nëngrup ose jo:<= operator,issubset()

Për të përcaktuar nëse një grup është një nëngrup i një grupi tjetër, përdorni operatorin <= ose metodën issubset().

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

print(s1 <= s2)
# True

print(s1.issubset(s2))
# True

Si operatori <= ashtu edhe metoda issubset() kthehen true për grupe ekuivalente.

Për të përcaktuar nëse është një nëngrup i vërtetë, përdorni operatorin <=, i cili kthen false për grupe ekuivalente.

print(s1 <= s1)
# True

print(s1.issubset(s1))
# True

print(s1 < s1)
# False

Kompleti i sipërm apo jo:>= operator,issuperset()

Për të përcaktuar nëse një grup është një superbashkësi e një tjetri, përdorni operatorin >= ose issuperset().

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

print(s2 >= s1)
# True

print(s2.issuperset(s1))
# True

Si operatori >= ashtu edhe metoda issuperset() kthehen true për grupe ekuivalente.

Për të përcaktuar nëse është një superbashkësi e vërtetë, përdorni operatorin >=, i cili kthen false për grupe ekuivalente.

print(s1 >= s1)
# True

print(s1.issuperset(s1))
# True

print(s1 > s1)
# False

Përcaktimi nëse ato janë reciproke apo jo:isdisjoint()

Për të përcaktuar nëse dy grupe janë të thjeshtë me njëra-tjetrën, përdorni metodën isdisjoint().

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

print(s1.isdisjoint(s2))
# False

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