Hvordan finder man middelværdi, median og tilstand i Python?

Gennemsnit, median og tilstand er grundlæggende emner i statistik. Du kan nemt beregne dem i Python, med og uden brug af eksterne biblioteker.

Disse tre er de vigtigste mål for central tendens. Den centrale tendens lader os kende de “normale” eller “gennemsnitlige” værdier af et datasæt. Hvis du lige er begyndt med datavidenskab, er dette den rigtige tutorial for dig.

Ved slutningen af ​​denne øvelse vil du:

• Forstå begrebet middelværdi, median og tilstand
• Være i stand til at oprette dine egne middelværdi-, median- og tilstandsfunktioner i Python
• Gør brug af Pythons statistikmodul til at komme hurtigt i gang med brugen af ​​disse målinger

Hvis du ønsker en download-version af følgende øvelser, er du velkommen til at tjekke GitHub-depot.

Lad os komme ind på de forskellige måder at beregne middelværdi, median og tilstand på.

Beregning af middelværdien i Python

Det betyde eller aritmetisk gennemsnit er det mest anvendte mål for central tendens.

Husk, at den centrale tendens er en typisk værdi af et datasæt.

Et datasæt er en samling af data, derfor kan et datasæt i Python være en af ​​følgende indbyggede datastrukturer:

• Lister, tupler og sæt: en samling af objekter
• Strings: en samling af karakterer
• Ordbog: en samling af nøgleværdi-par

Bemærk: Selvom der er andre datastrukturer i Python som køer eller stakke, vil vi kun bruge de indbyggede.

Vi kan beregne middelværdien ved at tilføje alle værdierne af et datasæt og dividere resultatet med antallet af værdier. For eksempel, hvis vi har følgende liste over tal:

[1, 2, 3, 4, 5, 6]

Middelværdien eller gennemsnittet ville være 3,5, fordi summen af ​​listen er 21 og dens længde er 6. Enogtyve divideret med seks er 3,5. Du kan udføre denne beregning med nedenstående beregning:

(1 + 2 + 3 + 4 + 5 + 6) / 6 = 21

I denne vejledning vil vi bruge spillerne fra et basketballhold som vores eksempeldata.

Oprettelse af en brugerdefineret middelfunktion

Lad os starte med at beregne den gennemsnitlige (gennemsnitlige) alder for spillerne på et basketballhold. Holdets navn vil være “Pythonic Machines”.

pythonic_machine_ages = [19, 22, 34, 26, 32, 30, 24, 24]

def mean(dataset):
    return sum(dataset) / len(dataset)

print(mean(pythonic_machine_ages))

Nedbrydning af denne kode:

• “pythonic_machine_ages” er en liste med basketballspillernes aldre
• Vi definerer en mean() funktion, som returnerer summen af ​​det givne datasæt divideret med dets længde
  • Sum()-funktionen returnerer den samlede sum (ironisk nok) af værdierne af en iterabel, i dette tilfælde en liste. Prøv at sende datasættet som et argument, det returnerer 211
  • Funktionen len() returnerer længden af ​​en iterabel, hvis du sender datasættet til den, får du 8
• Vi overfører basketballholdets alder til funktionen mean() og udskriver resultatet.

Hvis du tjekker outputtet, får du:

26.375
# Because 211 / 8 = 26.375

Dette output repræsenterer gennemsnitsalderen for basketballholdspillerne. Bemærk, hvordan nummeret ikke vises i datasættet, men præcist beskriver alderen på de fleste spillere.

Brug mean() fra Python Statistic Module

Beregning af mål for central tendens er en almindelig operation for de fleste udviklere. Det er fordi Pythons statistik modul giver forskellige funktioner til at beregne dem sammen med andre grundlæggende statistik-emner.

Da det er en del af Python standard bibliotek du behøver ikke installere nogen ekstern pakke med PIP.

Sådan bruger du dette modul:

from statistics import mean

pythonic_machine_ages = [19, 22, 34, 26, 32, 30, 24, 24]

print(mean(pythonic_machine_ages))

I ovenstående kode skal du blot importere funktionen mean() fra statistikmodulet og sende datasættet til det som et argument. Dette vil returnere det samme resultat som den brugerdefinerede funktion, vi definerede i forrige afsnit:

26.375

Nu har du krystalklart begrebet gennemsnit, lad os fortsætte med medianmålingen.

Find medianen i Python

Det median er den midterste værdi af et sorteret datasæt. Det bruges – igen – til at give en “typisk” værdi af en bestemt befolkning.

I programmering kan vi definere medianen som den værdi, der adskiller en sekvens i to dele — Den nederste halvdel og den højere halvdel —.

For at beregne medianen skal vi først sortere datasættet. Vi kunne gøre dette med sorteringsalgoritmer eller bruge den indbyggede funktion sorted(). Det andet trin er at bestemme, om datasættets længde er ulige eller lige. Afhængigt af dette er nogle af følgende processer:

• Ulige: Medianen er den midterste værdi af datasættet
• Lige: Medianen er summen af ​​de to midterste værdier divideret med to

Lad os fortsætte med vores basketballholdsdatasæt, og lad os beregne spillernes medianhøjde i centimeter:

[181, 187, 196, 196, 198,  203, 207, 211, 215]
# Since the dataset is odd, we select the middle value
median = 198

Som du kan se, da datasættets længde er ulige, så kan vi tage den midterste værdi som medianen. Men hvad ville der ske, hvis en spiller lige blev pensioneret?

Vi bliver nødt til at beregne medianen ved at tage de to midterste værdier af datasættet

[181, 187, 196, 198, 203, 207, 211, 215] 
# We select the two middle values, and divide them by 2
median = (198 + 203) / 2
median = 200.5

Oprettelse af en brugerdefineret medianfunktion

Lad os implementere ovenstående koncept i en Python-funktion.

Husk de tre trin, vi skal følge for at få medianen af ​​et datasæt:

• Sorter datasættet: Vi kan gøre dette med sorted()-funktionen
• Bestem, om det er ulige eller lige: Vi kan gøre dette ved at hente længden af ​​datasættet og bruge modulo-operatoren (%)
• Returner medianen baseret på hvert tilfælde:
  • Ulige: Returner den midterste værdi
  • Lige: Returner gennemsnittet af de to midterste værdier

Det ville resultere i følgende funktion:

pythonic_machines_heights = [181, 187, 196, 196, 198, 203, 207, 211, 215]
after_retirement = [181, 187, 196, 198, 203, 207, 211, 215]

def median(dataset):
    data = sorted(dataset)
    index = len(data) // 2
    
    # If the dataset is odd  
    if len(dataset) % 2 != 0:
        return data[index]
    
    # If the dataset is even
    return (data[index - 1] + data[index]) / 2

Udskrivning af resultatet af vores datasæt:

print(median(pythonic_machines_heights))
print(median(after_retirement))

Produktion:

198
200.5

Bemærk, hvordan vi opretter en datavariabel, der peger på den sorterede database i starten af ​​funktionen. Selvom listerne ovenfor er sorteret, ønsker vi at oprette en genanvendelig funktion, og derfor sorterer datasættet hver gang funktionen aktiveres.

Indekset gemmer den midterste værdi – eller den øvre midterste værdi – af datasættet ved at bruge heltalsdelingsoperatoren. For eksempel, hvis vi passerede listen “pythonic_machine_heights” ville den have værdien 4.

Husk, at i Python-sekvensen starter indekser ved nul, det er fordi vi er i stand til at returnere det midterste indeks på en liste med en heltalsdivision.

Derefter kontrollerer vi, om længden af ​​datasættet er ulige ved at sammenligne resultatet af modulo-operationen med en værdi, der ikke er nul. Hvis betingelsen er sand, returnerer vi det midterste element, for eksempel med listen “pythonic_machine_heights”:

>>> pythonic_machine_heights[4]
# 198

På den anden side, hvis datasættet er lige, returnerer vi summen af ​​de midterste værdier divideret med to. Bemærk at data[index -1] giver os det nederste midtpunkt af datasættet, mens data[index] forsyner os med det øvre midtpunkt.

Brug af median() fra Python Statistic Module

Denne måde er meget enklere, fordi vi bruger en allerede eksisterende funktion fra statistikmodulet.

Personligt, hvis der allerede er defineret noget for mig, ville jeg bruge det på grund af DRY —Gentag ikke dig selv — princippet (i dette tilfælde, gentag ikke andres kode).

Du kan beregne medianen af ​​de tidligere datasæt med følgende kode:

from statistics import median

pythonic_machines_heights = [181, 187, 196, 196, 198, 203, 207, 211, 215]
after_retirement = [181, 187, 196, 198, 203, 207, 211, 215]

print(median(pythonic_machines_heights))
print(median(after_retirement))

Produktion:

198
200.5

Beregning af tilstanden i Python

Det mode er den hyppigste værdi i datasættet. Vi kan tænke på det som den “populære” gruppe af en skole, der kan repræsentere en standard for alle elever.

Et eksempel på tilstand kunne være det daglige salg af en teknologibutik. Datasættets tilstand ville være det mest solgte produkt på en bestemt dag.

['laptop', 'desktop', 'smartphone', 'laptop', 'laptop', 'headphones']

Som du kan forstå, er tilstanden for ovenstående datasæt “bærbar”, fordi det var den hyppigste værdi på listen.

Det fede ved mode er, at datasættet ikke må være numerisk. For eksempel kan vi arbejde med strenge.

Lad os analysere salget af en anden dag:

['mouse', 'camera', 'headphones', 'usb', 'headphones', 'mouse']

Datasættet ovenfor har to tilstande: “mus” og “hovedtelefoner”, fordi begge har en frekvens på to. Det betyder, at det er en multimodal datasæt.

Hvad hvis vi ikke kan finde tilstanden i et datasæt, som det nedenfor?

['usb', 'camera', 'smartphone', 'laptop', 'TV']

Dette kaldes en ensartet fordelingdybest set betyder det, at der ikke er nogen tilstand i datasættet.

Nu har du et hurtigt greb om begrebet tilstand, lad os beregne det i Python.

Oprettelse af en brugerdefineret tilstandsfunktion

Vi kan tænke på frekvensen af ​​en værdi som et nøgle-værdi-par, med andre ord en Python-ordbog.

Idet vi rekapitulerer basketball-analogien, kan vi bruge to datasæt til at arbejde med: Pointene pr. spil og sneaker-sponsoratet af nogle spillere.

For at finde tilstanden skal vi først oprette en frekvensordbog med hver af værdierne i datasættet, derefter hente den maksimale frekvens og returnere alle elementerne med den frekvens.

Lad os oversætte dette til kode:

points_per_game = [3, 15, 23, 42, 30, 10, 10, 12]
sponsorship = ['nike', 'adidas', 'nike', 'jordan',
               'jordan', 'rebook', 'under-armour', 'adidas']

def mode(dataset):
    frequency = {}

    for value in dataset:
        frequency[value] = frequency.get(value, 0) + 1

    most_frequent = max(frequency.values())

    modes = [key for key, value in frequency.items()
                      if value == most_frequent]

    return modes

Kontrollerer resultatet ved at sende de to lister som argumenter:

print(mode(points_per_game))
print(mode(sponsorship))

Produktion:

[10]
['nike', 'adidas', 'jordan']

Som du kan se, gav den første udskriftserklæring os en enkelt tilstand, mens den anden returnerede flere tilstande.

Forklarer koden ovenfor dybere:

• Vi erklærer en frekvensordbog
• Vi itererer over datasættet for at skabe en histogram — den statistiske betegnelse for et sæt tællere (eller frekvenser) —
  • Hvis nøglen findes i ordbogen, tilføjer den én til værdien
  • Hvis det ikke findes, opretter vi et nøgle-værdi-par med værdien én
• Den mest_hyppige variabel gemmer – ironisk nok – den største værdi (ikke nøgle) i frekvensordbogen
• Vi returnerer tilstandsvariablen, som består af alle nøglerne i frekvensordbogen med den mest frekvens.

Bemærk, hvor vigtigt variabelnavngivning er for at skrive læsbar kode.

Brug af mode() og multimode() fra Python Statistic Module

Igen giver statistikmodulet os en hurtig måde at udføre grundlæggende statistikoperationer på.

Vi kan bruge to funktioner: mode() og multimode().

from statistics import mode, multimode

points_per_game = [3, 15, 23, 42, 30, 10, 10, 12]
sponsorship = ['nike', 'adidas', 'nike', 'jordan',
               'jordan', 'rebook', 'under-armour', 'adidas']

Ovenstående kode importerer begge funktioner og definerer de datasæt, vi har arbejdet med.

Her kommer den lille forskel: Funktionen mode() returnerer den første tilstand, den støder på, mens multimode() returnerer en liste med de hyppigste værdier i datasættet.

Derfor kan vi sige, at den brugerdefinerede funktion, vi definerede, faktisk er en multimode() funktion.

print(mode(points_per_game))
print(mode(sponsorship))

Produktion:

10
nike

Bemærk: I Python 3.8 eller nyere returnerer funktionen mode() den første tilstand, den fandt. Hvis du har en ældre version, får du en Statistikfejl.

Brug af multimode()-funktionen:

print(multimode(points_per_game))
print(multimode(sponsorship))

Produktion:

[10]
['nike', 'adidas', 'jordan']

For at opsummere

Tillykke! Hvis du fulgte så langt, lærte du at beregne middelværdien, medianen og tilstanden, de vigtigste centrale tendensmålinger.

Selvom du kan definere dine brugerdefinerede funktioner for at finde middelværdi, median og tilstand, anbefales det at bruge statistikmodulet, da det er en del af standardbiblioteket, og du skal ikke installere noget for at begynde at bruge det.

Læs derefter en venlig introduktion til dataanalyse i Python.