ప్రధాన కంటెంట్‌కు వెళ్లండి
మాడ్యూల్ 8 · 4లో పాఠం 3కోర్సులో 31/36~12 min
మాడ్యూల్ పాఠాలు (3/4)

సేకరణలు: కౌంటర్ మరియు డిఫాల్ట్‌డిక్ట్

collections మాడ్యూల్ విస్తరించే ప్రత్యేక డేటా రకాలను జోడిస్తుంది అంతర్నిర్మిత సేకరణలు. ఎక్కువగా ఉపయోగించే మూడు: Counter, defaultdict, namedtuple.

Counter: ఫ్రీక్వెన్సీ లెక్కింపు

Python
from collections import Counter

parole = ["mela", "pera", "mela", "kiwi", "mela", "pera"]
c = Counter(parole)
# Counter({'mela': 3, 'pera': 2, 'kiwi': 1})

c["mela"]            # 3
c["banana"]          # 0   (default for missing keys, NO KeyError)
c.most_common(2)     # [('mela', 3), ('pera', 2)]

ఇది స్ట్రింగ్స్‌పై కూడా పని చేస్తుంది (అక్షరాల గణనలు):

Python
Counter("ciao mondo")
# Counter({'o': 2, 'c': 1, 'i': 1, 'a': 1, ' ': 1, 'm': 1, 'n': 1, 'd': 1})

ఇది గణనల (+, -, &, |)పై సెట్-వంటి కార్యకలాపాలకు మద్దతు ఇస్తుంది - చాలా సులభ వివిధ మూలాల నుండి గణనలను సమగ్రపరచడం కోసం.

defaultdict: ఆటోమేటిక్ డిఫాల్ట్‌తో డిక్ట్

మీరు తప్పిపోయిన కీని యాక్సెస్ చేసినప్పుడు, ఒక కాల్ చేయడం ద్వారా దాన్ని ** సృష్టిస్తుంది** అని ఆదేశం కర్మాగారం.

Python
from collections import defaultdict

gruppi = defaultdict(list)        # factory = list (empty list)
for nome in ["Ada", "Linus", "Ada", "Grace"]:
    gruppi[nome].append(1)
# defaultdict(list, {'Ada': [1, 1], 'Linus': [1], 'Grace': [1]})

defaultdict లేకుండా, మీరు వ్రాయవలసి ఉంటుంది:

Python
gruppi = {}
for nome in [...]:
    if nome not in gruppi:
        gruppi[nome] = []
    gruppi[nome].append(1)

సాధారణ కర్మాగారాలు: list, int (డిఫాల్ట్ 0), set, dict.

namedtuple: ఫీల్డ్ పేర్లతో టుపుల్స్

మార్పులేని రికార్డ్-క్లాస్‌లను సృష్టించడానికి తేలికైన మార్గం. ఇది ఒక టుపుల్, కానీ పేరుతో ఫీల్డ్ యాక్సెస్‌తో.

Python
from collections import namedtuple

Punto = namedtuple("Punto", ["x", "y"])
p = Punto(3, 4)
p.x          # 3 (access by name)
p[0]         # 3 (access by index, still a tuple)
p.x + p.y    # 7

# typical use: return multiple values from a function
def divisione(a, b):
    Risultato = namedtuple("Risultato", ["quoziente", "resto"])
    return Risultato(a // b, a % b)

r = divisione(17, 5)
r.quoziente   # 3
r.resto       # 2

(మరింత అధునాతన కేసుల కోసం 3.7 నుండి dataclasses కూడా ఉంది — M9 చూడండి.)

nametuple: తేలికైన మార్పులేని రికార్డులు

collections మాడ్యూల్ namedtupleని కూడా ఎగుమతి చేస్తుంది, ఇది కన్స్ట్రక్టర్‌లు లేదా బాయిలర్‌ప్లేట్ పద్ధతులను వ్రాయకుండా నిర్మాణాత్మక డేటాను నిల్వ చేయడానికి తేలికైన తరగతి-వంటి వస్తువులను త్వరగా రూపొందించడానికి మిమ్మల్ని అనుమతిస్తుంది:

Python
from collections import namedtuple
Point = namedtuple('Point', ['x', 'y'])
p = Point(10, 20)
print(p.x, p.y)

దీనిని ప్రయత్నించండి

వ్యాయామం#python.m8.l3.e1
ప్రయత్నాలు: 0లోడ్ అవుతోంది...

`పదాలు = ['మేళా', 'పేరా', 'మేళా', 'కివి', 'మేళా', 'పేరా']` జాబితాను అందించి, `టాప్`లో అత్యంత తరచుగా వచ్చే పదాన్ని స్ట్రింగ్‌గా గణించండి. `టాప్`ని మూల్యాంకనం చేయండి.

ఎడిటర్ లోడ్ అవుతోంది…
సూచనను చూపించు

కౌంటర్(...).most_common(1) రిటర్న్స్ [(పదం, కౌంట్)].

3 ప్రయత్నాల తర్వాత పరిష్కారం లభిస్తుంది

వ్యాయామం సమీక్షించండి

వ్యాయామం#python.m8.l3.e2
ప్రయత్నాలు: 0లోడ్ అవుతోంది...

విద్యార్థులకు `ఎన్రోల్‌మెంట్‌లు = [('అడా', 'మేట్'), ('లినస్', 'ఫిసికా'), ('అడా', 'స్టోరియా'), ('గ్రేస్', 'మేట్')]` అందించబడి, `కోర్సుల_ప్రతి_విద్యార్థి`ని డిఫాల్ట్ (జాబితా)గా రూపొందించండి. `డిక్ట్(కోర్సులు_ప్రతి_విద్యార్థి)`ని మూల్యాంకనం చేయండి.

ఎడిటర్ లోడ్ అవుతోంది…
సూచనను చూపించు

డిఫాల్ట్‌డిక్ట్(జాబితా) ఆపై నమోదులలో s, c.

3 ప్రయత్నాల తర్వాత పరిష్కారం లభిస్తుంది

అదనపు సవాలు

వ్యాయామం#python.m8.l3.e3
ప్రయత్నాలు: 0లోడ్ అవుతోంది...

\`కలెక్షన్స్\` నుండి \`కౌంటర్\`ని దిగుమతి చేయండి. \`text = "abracadabra"\` స్ట్రింగ్‌లోని అక్షరాల ఫ్రీక్వెన్సీని లెక్కించండి. కౌంటర్‌ని \`char_counter\`లో నిల్వ చేసి, దానిని మూల్యాంకనం చేయండి.

ఎడిటర్ లోడ్ అవుతోంది…
సూచనను చూపించు

కౌంటర్ స్ట్రింగ్‌ను పారామీటర్‌గా తీసుకుంటుంది మరియు ప్రతి అక్షరం యొక్క సంఘటనలను గణిస్తుంది.

3 ప్రయత్నాల తర్వాత పరిష్కారం లభిస్తుంది