44444444444.

EUGENIA BAHIT

DATA SCIENCE
CU PYTHON

MATERIAL DE STUDIU

Rapoarte și înregistrare:
Curs: http://escuela.eugeniabahit.com | Certificari: http://python.laeci.org
 Introducere în Data Science cu Python - Şcoala de Informatică Eugenia Bahit

REZUMAT
METODE DE MANIPULARE VARIABILE..........................................................................................................5
MANIPULAREA ȘIRURILOR DE TEXT..............................................................................................................5
METODE DE FORMAT......................................................................................................................................5
Prima literă cu majuscule...................................................................................................................................5
CONVERȚI UN ȘIR ÎN MINUSCULE............................................................................................................5
CONVERTĂ UN ȘIR ÎN MAJUSCULE..........................................................................................................6
CONVERSAȚI MAJUSCULE ÎN MINUSCULE ȘI VICE-VERSA...............................................................6
CONVERTĂ UN ȘIR ÎN FORMATUL DE TITL...........................................................................................6
CENTRAȚI UN TEXT......................................................................................................................................6
ALINIAȚI TEXTUL LA STÂNGA..................................................................................................................6
Aliniați textul la dreapta....................................................................................................................................7
COMPLETAREA UNUI TEXT PREVĂTÂND ZEROURI............................................................................7
METODE DE CĂUTARE....................................................................................................................................7
NUMĂRĂ NUMĂR DE APARIȚII ALE UNUI SUBȘIR...............................................................................7
CĂUTAȚI UN SUBȘIR ÎNTR-UN ȘIR...........................................................................................................7
METODE DE VALIDARE...................................................................................................................................8
ȘTIȚI DACĂ UN ȘIR ÎNCEPE CU UN ANUMIT ȘIR...................................................................................8
ȘTIȚI DACĂ UN ȘIR SE Termină CU UN ANUMIT ȘIR..............................................................................8
ȘTIȚI DACĂ UN ȘIR ESTE ALFANUMERIC...............................................................................................8
ȘTIȚI DACĂ UN ȘIR ESTE ALFABETIC......................................................................................................8
ȘTIȚI DACĂ UN ȘIR ESTE NUMERICAL....................................................................................................9
ȘTIȚI DACĂ UN ȘIR CONTINE DOAR MINUSCULE................................................................................9
ȘTIȚI DACĂ UN ȘIR CONTINE DOAR MAJUSCULE................................................................................9
ȘTIȚI DACĂ UN ȘIR CONTINE NUMAI SPAȚII ALTE............................................................................10
ȘTIȚI DACĂ UN ȘIR ARE FORMAT DE TITL...........................................................................................10
METODE DE SUBSTITUȚIE............................................................................................................................10
FORMATATE UN ȘIR, ÎNLOCUIȚI DINAMIC TEXTUL..........................................................................10
ÎNLOCUIȚI TEXTUL ÎNTR-UN ȘIR............................................................................................................11
ELIMINAȚI PERSONAJELE DIN STÂNGA ȘI DREPTEA UNUI ȘIR......................................................11
ȘTERGEȚI CARACTERELE DIN STÂNGA UNUI ȘIR.............................................................................11
ELIMINAȚI PERSONAJELE DIN DREAPTA UNUI ȘIR...........................................................................11
METODE DE UNIRE ȘI DIVIZARE................................................................................................................11
ÎNSCRIEȚI-VĂ ITERATIV LA UN SIR.......................................................................................................11

-2-

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire

4.0
 Introducere în Data Science cu Python - Şcoala de Informatică Eugenia Bahit

RUPE UN LANT IN TREI PARTE, FOLOSIND UN SEPARATOR...........................................................12

RUPEREA UNUI LANȚ ÎN MAI MULTE PĂRȚI, FOLOSIND UN SEPARATOR..................................12
DESPARTAREA UNUI LANȚ ÎN LINII.......................................................................................................12
MANIPULARE LISTĂ ȘI TUPLU........................................................................................................................14
METODE AGREGATE......................................................................................................................................14
ADĂUGAȚI UN ARTICOL LA sfârșitul listei..............................................................................................14
Adăugați mai multe articole la sfârșitul listei..................................................................................................14
ADĂUGAȚI UN ELEMENT ÎNTR-O POZIȚIE DETERMINATĂ.............................................................14
METODE DE ELIMINAREA............................................................................................................................14
ȘTERGEȚI ULTIMUL ARTICOL DIN LISTĂ.............................................................................................14
ȘTERGEȚI UN ELEMENT DUPĂ INDEXUL SĂU....................................................................................15
ȘTERGEȚI UN ELEMENT DUPĂ VALOAREA SA...................................................................................15
METODE DE COMANDA................................................................................................................................15
SORTEAȚI O LISTĂ ÎN INVERS (ORDINE INVERSĂ)............................................................................15
SORTAZĂ O LISTĂ ÎN FORMA ASCENDĂTORĂ....................................................................................15
SORTEAȚI O LISTĂ ÎN FORMA DESCENDĂTORĂ................................................................................15
METODE DE CĂUTARE..................................................................................................................................15
NUMĂRĂ NUMĂRUL DE APARIȚII..........................................................................................................15
OBȚINEȚI NUMĂRUL DE INDEX..............................................................................................................16
ANEXĂ DESPRE LISTE ȘI TUPLE.................................................................................................................16
CONVERSIE DE TIP......................................................................................................................................16
CONCATENAREA COLECȚILOR...............................................................................................................17
VALOARE MAXIMA SI MINIMA...............................................................................................................20
NUMĂRĂ ELEMENTE..................................................................................................................................20
MANIPULAREA DICTIONARULUI...................................................................................................................22
METODE DE ELIMINAREA............................................................................................................................22
GOLȚI UN DICȚIONAR................................................................................................................................22
METODE DE ADUGARE SI CREARE............................................................................................................22
COPIEAZĂ UN DICȚIONAR........................................................................................................................22
CREAȚI UN NOU DICȚIONAR DIN CHEILE LUI A.................................................................................23
SECVENŢĂ.....................................................................................................................................................23
DICTIONARE CONCATENATE..................................................................................................................23
SETĂ O CHEIE ȘI O VALOARE IMPLICITE.............................................................................................23
METODE DE RETURNARE.............................................................................................................................24
OBȚINE VALOAREA CHEIEI......................................................................................................................24
ȘTIȚI DACĂ EXISTA O CHEIE ÎN DICȚIONAR.......................................................................................24
OBȚINEREA CHEILOR ȘI VALORILOR UNUI DICȚIONAR..................................................................24

-3-

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire

 Introducere în Data Science cu Python - Şcoala de Informatică Eugenia Bahit

OBȚINEȚI CHEILE UNUI DICȚIONAR......................................................................................................24

OBȚINE VALORILE UNUI DICȚIONAR....................................................................................................25
OBȚINEȚI NUMĂRUL DE ARTICOLE ÎNTR-UN DICȚIONAR..............................................................25
MANIPULAREA SI MANIPULAREA DOSARELOR........................................................................................27
CĂI DE DESCHIDERE A UNUI DOSAR.........................................................................................................27
UNELE METODE ALE OBIECTULUI DOSAR..............................................................................................29
MANIPULAREA FIȘIERELOR CSV...................................................................................................................30
CATEVA EXEMPLE DE FISIERE CSV...........................................................................................................30
LUCRU CU FIȘIERE CSV DIN PYTHON.......................................................................................................32
CITIREA FIȘIERELOR CSV.........................................................................................................................32
SCRIEREA FIȘIERELOR CSV......................................................................................................................37
PROBABILITATE SI STATISTICA CU PYTHON.............................................................................................40
PROBABILITATEA EVENIMENTELOR SIMPLE ȘI COMPUSE MUTUAL EXCLUSIVE ÎN PYTHON.40
SPAȚIU EȘANȚĂ...........................................................................................................................................40
EVENIMENTE SIMPLE SI COMPUSE........................................................................................................40
ATRIBUIREA COTELOR..............................................................................................................................41
EVENIMENTE SIMPLE SE EXCLUSIVE MUTU...................................................................................41
EVENIMENTE COMPUSE DIN EVENIMENTE SIMPLE MUTUAL EXCLUSIVE.............................42
FUNCȚII..........................................................................................................................................................43
PROBABILITATE CONDIȚIONATĂ ÎN PYTHON........................................................................................43
FUNCȚII..........................................................................................................................................................44
EVENIMENTE DEPENDENTE.....................................................................................................................44
TEORIA MULTILOR ÎN PYTHON...........................................................................................................46
EVENIMENTE INDEPENDENTE................................................................................................................46
TEOREMA LUI BAYES ÎN PYTHON..............................................................................................................47
TEOREMA LUI BAYES SI PROBABILITATEA CAUZELOR..................................................................47
DATE: STUDIU DE CAZ...........................................................................................................................47
ANALIZĂ....................................................................................................................................................48
PROCEDURĂ..............................................................................................................................................49
FUNCȚII..........................................................................................................................................................54
LITTURĂ A MULTE......................................................................................................................................54
ANEXA I: CALCULE COMPLEXE.....................................................................................................................60
POPULAȚIE ȘI EȘANȚĂ DE STATISTICĂ: CALCULUL DE......................................................................60
VARIANȚA ȘI DEVIAȚIA STANDARD.........................................................................................................60
PRODUS DIN DOI VECTORI...........................................................................................................................61
CALCULURI DE FRECVENȚĂ RELATIVE, ABSOLUTE ȘI ACUMULATE.............................................61
ANEXA II: CREAREA UNUI MENIU DE OPȚIUNI..........................................................................................63

-4-

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire

 Introducere în Data Science cu Python - Şcoala de Informatică Eugenia Bahit

METODE DE MANIPULARE VARIABILE

În Python, fiecare variabilă este considerată un obiect . Pe fiecare obiect pot fi efectuate diferite tipuri de acțiuni

numite metode . Metodele sunt funcții, dar sunt derivate dintr-o variabilă. Prin urmare, aceste funcții sunt

accesate folosind sintaxa:

variabilă.funcție()

În unele cazuri, aceste metode (funcțiile unui obiect) vor accepta parametrii ca orice altă funcție.

variabilă.funcție(parametru)

MANIPULAREA ȘIRURILOR DE TEXT

În continuare, vom vedea principalele metode care pot fi aplicate unui șir de text, organizate pe categorii.

METODE DE FORMAT

Prima literă cu majuscule

Metoda: capitalize()
Returnează: o copie a șirului cu prima literă scrisă cu majuscule
> >> șir = „Bine ați venit la aplicația mea”
> >> rezultat = string.capitalize()
> >> rezultat
bun venit la aplicația mea

CONVERȚI UN ȘIR ÎN MINUSCULE

Metoda: mai jos()
Returnează: o copie a șirului cu minuscule
> >> șir = „Bună lume”
> >> șir. inferior()

-5-

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire

 Introducere în Data Science cu Python - Şcoala de Informatică Eugenia Bahit

Salut Lume

CONVERTĂ UN ȘIR ÎN MAJUSCULE

Metoda: top()
Returnează: o copie a șirului în majuscule
> >> șir = „Bună lume”
> >> șir. top()
SALUT LUME

CONVERSAȚI MAJUSCULE ÎN MINUSCULE ȘI VICE-VERSA

Metodă: swapcase()
Returnează: o copie a șirului convertită din majuscule în minuscule și invers
> >> șir = „Bună lume”
> >> șir. schimb de caz ()
Salut Lume

CONVERTĂ UN ȘIR ÎN FORMATUL DE TITL

Metoda: title()
Returnează: o copie a șirului convertit
> >> șir = „bună lume”
> >> șir. titlu()
Salut Lume

CENTRAȚI UN TEXT
Metodă: centru (lungime[, „caracter de umplutură”)
Returnează: o copie a șirului centrat
> >> șir = „Bine ați venit în aplicația mea”. Capitalize()
> >> șir. centru(50, "=")
===========Bine ați venit la aplicația mea=============

> >> șir. centru(50, " ")

bun venit la aplicația mea

ALINIAȚI TEXTUL LA STÂNGA

Metodă: ljust(lungime[, „caracter de umplutură”])
Returnează: o copie aliniată la stânga a șirului
> >> șir = „Bine ați venit în aplicația mea”. Capitalize()
>>> șir. ljust(50, "=")
Bun venit la aplicația mea==========================

-6-

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire

4.0
 Introducere în Data Science cu Python - Şcoala de Informatică Eugenia Bahit

Aliniați textul la dreapta

Metodă: rjust(lungime[, „caracter de umplutură”])
Returnează: o copie aliniată la dreapta a șirului
>>> șir = „Bine ați venit în aplicația mea”. Capitalize()
>>> șir. rjust(50, "=")
======================= Bun venit în aplicația mea

>>> șir. rjust(50, " ")

bun venit la aplicația mea

COMPLETAREA UNUI TEXT PREVĂTÂND ZEROURI

Metodă: zfill(lungime)
Returnează: o copie a șirului căptușită cu zerouri la stânga până când atinge lungimea finală indicată
>>> număr_factură = 1575
>>> str(numar_factura). zfill(12)
000000001575

METODE DE CĂUTARE

NUMĂRĂ NUMĂR DE APARIȚII ALE UNUI SUBȘIR

Metodă: count(„subșir”[, start_position, end_position])
Returnează: un număr întreg care reprezintă numărul de apariții ale subșirului în șir
>>> șir = „Bine ați venit în aplicația mea”. Capitalize()
>>> șir. count("a")
3

CĂUTAȚI UN SUBȘIR ÎNTR-UN ȘIR

Metodă: find(„subșir”[, start_position, end_position])
Returnează: un număr întreg care reprezintă poziția de pornire a subșirului din interior
lanţ. Dacă nu îl găsește, returnează -1
>>> șir = „Bine ați venit în aplicația mea”. Capitalize()
>>> șir. gaseste ("al meu")
13
>>> șir. găsiți ("meu", 0, 10)
-1

-7-

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire

4.0
 Introducere în Data Science cu Python - Şcoala de Informatică Eugenia Bahit

METODE DE VALIDARE

ȘTIȚI DACĂ UN ȘIR ÎNCEPE CU UN ANUMIT ȘIR

Metodă: startswith(„subșir”[, start_position, end_position])
Returnează: adevărat sau fals
> >> șir = „Bine ați venit în aplicația mea”. Capitalize()
> >> șir. începe cu ("Bun venit")
Adevărat
> >> șir. începe cu ("aplicație")
fals
> >> șir. începe cu ("aplicație", 16)
Adevărat

ȘTIȚI DACĂ UN ȘIR SE Termină CU UN ANUMIT ȘIR

Metodă: endswith(„subșir”[, start_position, end_position])
Returnează: adevărat sau fals
> >> șir = „Bine ați venit în aplicația mea”. Capitalize()
> >> șir. se termina cu ("aplicare")
Adevărat
> >> șir. endswith("Bine ai venit")
fals
> >> șir. endswith("Bun venit", 0, 10)
Adevărat

ȘTIȚI DACĂ UN ȘIR ESTE ALFANUMERIC

Metoda: isalnum()
Returnează: adevărat sau fals
> >> șir = "pepegrillo 75"
> >> șir. isalnum()
fals
> >> șir = „pepegrillo”
> >> șir. isalnum()
Adevărat
> >> șir = „pepegrillo75”
> >> șir. isalnum()
Adevărat

ȘTIȚI DACĂ UN ȘIR ESTE ALFABETIC

Metoda: isalpha()
Returnează: adevărat sau fals
> >> șir = "pepegrillo 75"
> >> șir. isalpha()
fals

-8-

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire

4.0
 Introducere în Data Science cu Python - Şcoala de Informatică Eugenia Bahit

> >> șir = „pepegrillo”

> >> șir. isalpha()
Adevărat
> >> șir = „pepegrillo75”
> >> șir. isalpha()
fals

ȘTIȚI DACĂ UN ȘIR ESTE NUMERICAL

Metoda: isdigit()
Returnează: adevărat sau fals
> >> șir = "pepegrillo 75"
> >> șir. isdigit()
fals
> >> șir = „7584”
> >> șir. isdigit()
Adevărat
> >> șir = „75 84”
> >> șir. isdigit()
fals
> >> șir = "75.84"
> >> șir. isdigit()
fals

ȘTIȚI DACĂ UN ȘIR CONTINE DOAR MINUSCULE

Metoda: islower()
Returnează: adevărat sau fals
> >> șir = „jimmy cricket”
> >> șir. este mai jos()
Adevărat
> >> șir = „Jiminy Cricket”
> >> șir. este mai jos()
fals
> >> șir = „Pepegrickillo”
> >> șir. este mai jos()
fals
> >> șir = „pepegrillo75”
> >> șir. este mai jos()
Adevărat

ȘTIȚI DACĂ UN ȘIR CONTINE DOAR MAJUSCULE

Metoda: isupper()
Returnează: adevărat sau fals
> >> șir = „JIMNY CRICKET”
> >> șir. isupper()
Adevărat
> >> șir = „Jiminy Cricket”
> >> șir. isupper()
fals

-9-

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire

4.0
 Introducere în Data Science cu Python - Şcoala de Informatică Eugenia Bahit

> >> șir = „Pepegrickillo”

> >> șir. isupper()
fals
> >> șir = „PEPEGRILLO”
> >> șir. isupper()
Adevărat

ȘTIȚI DACĂ UN ȘIR CONTINE NUMAI SPAȚII ALTE

Metoda: isspace()
Returnează: adevărat sau fals
> >> șir = „jimmy cricket”
> >> șir. isspace()
fals
> >> șir = " "
> >> șir. isspace()
Adevărat

ȘTIȚI DACĂ UN ȘIR ARE FORMAT DE TITL

Metoda: istitle()
Returnează: adevărat sau fals
> >> șir = „Jiminy Cricket”
> >> șir. istitle()
Adevărat
> >> șir = „Jimmy Cricket”
> >> șir. istitle()
fals

METODE DE SUBSTITUȚIE

FORMATATE UN ȘIR, ÎNLOCUIȚI DINAMIC TEXTUL

Metodă: format(*args, **kwargs)
Returnează: șirul formatat
> >> șir = „Bine ați venit la aplicația mea {0}”
> >> șir. format ("în Python")
bun venit la aplicația mea python

> >> șir = „Suma brută: ${0} + TVA: ${1} = Sumă netă: {2}”
> >> șir. format (100, 21, 121)
Sumă brută: 100 USD + TVA: 21 USD = Sumă netă: 121

> >> string = "Suma brută: ${brut} + TVA: ${iva} = Sumă netă: {net}"
> >> șir. format(brut=100, tva=21, net=121)
Sumă brută: 100 USD + TVA: 21 USD = Sumă netă: 121

> >> șir. format(brut=100, tva=100 * 21 / 100, net=100 * 21 / 100 + 100)

Sumă brută: 100 USD + TVA: 21 USD = Sumă netă: 121

- 10 -

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire

4.0
 Introducere în Data Science cu Python - Şcoala de Informatică Eugenia Bahit

ÎNLOCUIȚI TEXTUL ÎNTR-UN ȘIR

Metodă: înlocuiți ("subșir de căutat", "subșir de înlocuit cu")
Returnează: șirul înlocuit
> >> cautare = "prenume prenume"
> >> replace_by = "Juan Pérez"
> >> „Stimate domnule prenume prenume:”. înlocuiți(căutați, înlocuiți_prin) Stimate domnule Juan Pérez:

ELIMINAȚI PERSONAJELE DIN STÂNGA ȘI DREPTEA UNUI ȘIR

Metoda: strip(["caracter"])
Returnează: șirul înlocuit
> >> șir = " www.eugeniabahit.com "
> >> șir. bandă()
www.eugeniabahit.com
> >> șir. bandă(' ')
www.eugeniabahit.com

ȘTERGEȚI CARACTERELE DIN STÂNGA UNUI ȘIR

Metodă: lstrip([„caracter”])
Returnează: șirul înlocuit
> >> șir = " www.eugeniabahit.com "
> >> șir. lstrip("w." )
eugeniabahit.com

> >> șir = " www.eugeniabahit.com "

> >> șir. lstrip()
www.eugeniabahit.com

ELIMINAȚI PERSONAJELE DIN DREAPTA UNUI ȘIR

Metodă: rstrip([„caracter”])
Returnează: șirul înlocuit
> >> șir = " www.eugeniabahit.com "
> >> șir. rstrip( )
www.eugeniabahit.com

METODE DE UNIRE ȘI DIVIZARE

ÎNSCRIEȚI-VĂ ITERATIV LA UN SIR

Metodă: alăturați (iterabil)
Returnează: șirul îmbinat cu iterabilul (șirul este separat de fiecare dintre elementele iterabilului)
>>> invoice_number_format = ("Nr 0000-0", "-0000 (ID: ", ")")

- 11 -

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire

4.0
 Introducere în Data Science cu Python - Şcoala de Informatică Eugenia Bahit

>>> număr = "275"

> >> invoice_number = număr. join(invoice_number_format)
> >> număr_factură
Nr. 0000-0275-0000 (ID: 275)

RUPE UN LANT IN TREI PARTE, FOLOSIND UN SEPARATOR

Metodă: partiție ("separator")
Returnează: un tuplu de trei elemente în care primul este conținutul șirului înainte de separator, al doilea este
separatorul în sine, iar al treilea este conținutul șirului după separator
> >> tuplu = „http://www.eugeniabahit.com”. partiție ("www.")
> >> tuplu
(„http://”, „www.”, „eugeniabahit.com”)

> >> protocol, separator, domeniu = tuplu

>>>> „Protocol: {0}\nDomeniu: {1}”.format(protocol, domeniu) Protocol: http://
Domeniu: eugeniabahit.com

RUPEREA UNUI LANȚ ÎN MAI MULTE PĂRȚI, FOLOSIND UN SEPARATOR

Metoda: split ("separator")
Returnează: o listă cu toate elementele găsite prin împărțirea șirului cu un separator
>>> cuvinte cheie = „python, ghid, curs, tutorial”. Despică(", ")
> >> cuvinte cheie
['python', 'ghid', 'curs', 'tutorial']

DESPARTAREA UNUI LANȚ ÎN LINII

Metodă: splitlines()
Returnează: o listă în care fiecare element este o fracțiune din șirul împărțit în linii
>>> text = """Rândul 1
randul 2
linia 3
Linia 4 """
> >> text. linii de scindare()
[„Linia 1”, „Linia 2”, „Linia 3”, „Linia 4”]

> >> text = "Rând 1\nLinie 2\nLinie 3"

> >> text. linii de scindare()
[„Linia 1”, „Linia 2”, „Linia 3”]

- 12 -

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire

4.0
(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire 4.0
MANIPULARE LISTĂ ȘI TUPLU
În acest capitol, vom vedea metodele pe care le posedă obiectul listă . Unele dintre ele sunt
disponibile și pentru tuplu .

METODE AGREGATE

ADĂUGAȚI UN ARTICOL LA sfârșitul listei

Metoda: append(„articol nou”)
> >> nume_masculi = ["Alvaro", "Jacinto", "Miguel", "Edgardo", "David"]
> >> nume_de_masculi. append(„Iosif”)
> >> nume_de_masculi
[„Alvaro”, „David”, „Edgardo”, „Jacinto”, „Jose”, „Ricky”, „Jose”]

Adăugați mai multe articole la sfârșitul listei

Metodă: extinde(other_list)
> >> nume_de_masculi. extinde(["Iosif", "Gerardo"])
> >> nume_de_masculi
[„Alvaro”, „David”, „Edgardo”, „Jacinto”, „Jose”, „Ricky”, „Jose”, „Jose”, „Gerardo”]

ADĂUGAȚI UN ELEMENT ÎNTR-O POZIȚIE DETERMINATĂ

Metodă: insert (poziție, „element nou”)
> >> nume_de_masculi. insert(0, "Ricky")
> >> nume_de_masculi
[„Ricky”, „Alvaro”, „David”, „Edgardo”, „Jacinto”, „Jose”, „Ricky”, „Jose”, „Jose”, „Gerardo”]

METODE DE ELIMINAREA

ȘTERGEȚI ULTIMUL ARTICOL DIN LISTĂ

Metoda: pop()
Returnează: elementul eliminat
> >> nume_de_masculi. pop()
"Gerardo"
> >> nume_de_masculi
[„Ricky”, „Alvaro”, „David”, „Edgardo”, „Jacinto”, „Jose”, „Ricky”, „Jose”, „Jose”]

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire

4.0
 Introducere în Data Science cu Python - Şcoala de Informatică Eugenia Bahit

ȘTERGEȚI UN ELEMENT DUPĂ INDEXUL SĂU

Metoda: pop(index)
Returnează: elementul eliminat
>>> nume_de_masculi. pop (3)
„Edgardo”

>>> nume_de_masculi
[„Ricky”, „Alvaro”, „David”, „Jacinto”, „Jose”, „Ricky”, „Jose”, „Jose”]

ȘTERGEȚI UN ELEMENT DUPĂ VALOAREA SA

Metoda: elimina ("valoare")
>>> nume_de_masculi. elimina ("Jose")
>>> nume_de_masculi
[„Ricky”, „Alvaro”, „David”, „Jacinto”, „Ricky”, „Jose”, „Jose”]

METODE DE COMANDA

SORTEAȚI O LISTĂ ÎN INVERS (ORDINE INVERSĂ)

Metoda: invers ()
>>> nume_de_masculi. verso()
>>> nume_de_masculi
[„Jose”, „Jose”, „Ricky”, „Jacinto”, „David”, „Alvaro”, „Ricky”]

SORTAZĂ O LISTĂ ÎN FORMA ASCENDĂTORĂ

Metoda: sortare()
>>> nume_de_masculi. fel()
>>> nume_de_masculi
[„Alvaro”, „David”, „Jacinto”, „Jose”, „Jose”, „Ricky”, „Ricky”]

SORTEAȚI O LISTĂ ÎN FORMA DESCENDĂTORĂ

Metodă: sortare(invers=adevărat)
>>> nume_de_masculi. sortare(invers=Adevărat)
>>> nume_de_masculi
[„Ricky”, „Ricky”, „Jose”, „Jose”, „Jacinto”, „David”, „Alvaro”]

METODE DE CĂUTARE

NUMĂRĂ NUMĂRUL DE APARIȚII

Metodă: numărare (element)
>>> nume_masculi = ["Alvaro", "Miguel", "Edgardo", "David", "Miguel"]

- 15 -

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire

 Introducere în Data Science cu Python - Şcoala de Informatică Eugenia Bahit

>>> nume_de_masculi. count("Miguel") 2 >>> male_names = ("Alvaro", "Miguel", "Edgardo", "David", "Miguel")
>>> nume_de_masculi. conte ("Michael")
2

OBȚINEȚI NUMĂRUL DE INDEX

Metodă: index(element[, start_index, end_index])
>>> nume_de_masculi. index ("Michael") 1

>>> nume_de_masculi. index(„Michael”, 2, 5) 4

ANEXĂ DESPRE LISTE ȘI TUPLE

CONVERSIE DE TIP
În setul de funcții încorporate în Python, este posibil să găsiți două funcții care vă permit să convertiți liste în

tupluri și invers. Aceste funcții sunt list și tuple , pentru a converti tupluri în liste și, respectiv, liste în tuplu.

Una dintre cele mai frecvente utilizări este convertirea tuplurilor în liste, care trebuie modificate. Acest lucru se

întâmplă adesea cu rezultatele obținute dintr-o interogare de bază de date.

>>> tuplu = (1, 2, 3, 4)

>>> tuplu (1, 2, 3, 4)

>>> lista(tuplu)
[1, 2, 3, 4]

>>> lista = [1, 2, 3, 4]

>>> lista [1, 2, 3, 4]

>>> tuplu(lista)
(1, 2, 3, 4)

- 16 -

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire

4.0
 Introducere în Data Science cu Python - Şcoala de Informatică Eugenia Bahit

CONCATENAREA COLECȚILOR
Puteți concatena (sau alătura) două sau mai multe liste sau două sau mai multe tupluri, folosind semnul plus +.

Nu puteți alătura o listă la un tuplu. Colecțiile de alăturat trebuie să fie de același tip.

>>> list1 = [1, 2, 3, 4]

> >> list2 = [3, 4, 5, 6, 7, 8]
> >> lista3 = lista1 + lista2
> >> lista3
[1, 2, 3, 4, 3, 4, 5, 6, 7, 8]

METODE DE MANIPULARE VARIABILE 5

MANIPULAREA ȘIRURILOR DE TEXT 5
METODE DE FORMAT 5
Prima literă cu majuscule 5
CONVERȚI UN ȘIR ÎN MINUSCULE 5
CONVERTĂ UN ȘIR ÎN MAJUSCULE 6
CONVERSAȚI MAJUSCULE ÎN MINUSCULE ȘI VICE-VERSA 6
CONVERTĂ UN ȘIR ÎN FORMATUL DE TITL 6
CENTRAȚI UN TEXT 6
ALINIAȚI TEXTUL LA STÂNGA 6
Aliniați textul la dreapta 7
COMPLETAREA UNUI TEXT PREVĂTÂND ZEROURI 7
METODE DE CĂUTARE 7
NUMĂRĂ NUMĂR DE APARIȚII ALE UNUI SUBȘIR 7
CĂUTAȚI UN SUBȘIR ÎNTR-UN ȘIR 7
METODE DE VALIDARE 8
ȘTIȚI DACĂ UN ȘIR ÎNCEPE CU UN ANUMIT ȘIR 8
ȘTIȚI DACĂ UN ȘIR SE Termină CU UN ANUMIT ȘIR 8
ȘTIȚI DACĂ UN ȘIR ESTE ALFANUMERIC 8
ȘTIȚI DACĂ UN ȘIR ESTE ALFABETIC 8
ȘTIȚI DACĂ UN ȘIR ESTE NUMERICAL 9
ȘTIȚI DACĂ UN ȘIR CONTINE DOAR MINUSCULE 9
ȘTIȚI DACĂ UN ȘIR CONTINE DOAR MAJUSCULE 9
ȘTIȚI DACĂ UN ȘIR CONTINE NUMAI SPAȚII ALTE 10
ȘTIȚI DACĂ UN ȘIR ARE FORMAT DE TITL 10
METODE DE SUBSTITUȚIE 10
FORMATATE UN ȘIR, ÎNLOCUIȚI DINAMIC TEXTUL 10
ÎNLOCUIȚI TEXTUL ÎNTR-UN ȘIR 11
ELIMINAȚI PERSONAJELE DIN STÂNGA ȘI DREPTEA UNUI ȘIR 11

- 17 -

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire

 Introducere în Data Science cu Python - Şcoala de Informatică Eugenia Bahit

ȘTERGEȚI CARACTERELE DIN STÂNGA UNUI ȘIR 11

ELIMINAȚI PERSONAJELE DIN DREAPTA UNUI ȘIR 11
METODE DE UNIRE ȘI DIVIZARE 11
ÎNSCRIEȚI-VĂ ITERATIV LA UN SIR 11
RUPE UN LANT IN TREI PARTE, FOLOSIND UN SEPARATOR 12
RUPEREA UNUI LANȚ ÎN MAI MULTE PĂRȚI, FOLOSIND UN SEPARATOR 12
DESPARTAREA UNUI LANȚ ÎN LINII 12
MANIPULARE LISTĂ ȘI TUPLU 14
METODE AGREGATE 14
ADĂUGAȚI UN ARTICOL LA sfârșitul listei 14
Adăugați mai multe articole la sfârșitul listei 14
ADĂUGAȚI UN ELEMENT ÎNTR-O POZIȚIE DETERMINATĂ 14
METODE DE ELIMINAREA 14
ȘTERGEȚI ULTIMUL ARTICOL DIN LISTĂ 14
ȘTERGEȚI UN ELEMENT DUPĂ INDEXUL SĂU 15
ȘTERGEȚI UN ELEMENT DUPĂ VALOAREA SA 15
METODE DE COMANDA 15
SORTEAȚI O LISTĂ ÎN INVERS (ORDINE INVERSĂ) 15
SORTAZĂ O LISTĂ ÎN FORMA ASCENDĂTORĂ 15
SORTEAȚI O LISTĂ ÎN FORMA DESCENDĂTORĂ 15
METODE DE CĂUTARE 15
NUMĂRĂ NUMĂRUL DE APARIȚII 15
OBȚINEȚI NUMĂRUL DE INDEX 16
ANEXĂ DESPRE LISTE ȘI TUPLE 16
CONVERSIE DE TIP 16
CONCATENAREA COLECȚILOR 17
VALOARE MAXIMA SI MINIMA 20
NUMĂRĂ ELEMENTE 20
MANIPULAREA DICTIONARULUI 22
METODE DE ELIMINAREA 22
GOLȚI UN DICȚIONAR 22
METODE DE ADUGARE SI CREARE 22
COPIEAZĂ UN DICȚIONAR 22
CREAȚI UN NOU DICȚIONAR DIN CHEILE LUI A 23
SECVENŢĂ 23
DICTIONARE CONCATENATE 23
SETĂ O CHEIE ȘI O VALOARE IMPLICITE 23

- 18 -

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire

4.0
 Introducere în Data Science cu Python - Şcoala de Informatică Eugenia Bahit

METODE DE RETURNARE 24
OBȚINE VALOAREA CHEIEI 24
ȘTIȚI DACĂ EXISTA O CHEIE ÎN DICȚIONAR 24
OBȚINEREA CHEILOR ȘI VALORILOR UNUI DICȚIONAR 24
OBȚINEȚI CHEILE UNUI DICȚIONAR 24
OBȚINE VALORILE UNUI DICȚIONAR 25
OBȚINEȚI NUMĂRUL DE ARTICOLE ÎNTR-UN DICȚIONAR 25
MANIPULAREA SI MANIPULAREA DOSARELOR 27
CĂI DE DESCHIDERE A UNUI DOSAR 27
UNELE METODE ALE OBIECTULUI DOSAR 29
MANIPULAREA FIȘIERELOR CSV 30
CATEVA EXEMPLE DE FISIERE CSV 30
LUCRU CU FIȘIERE CSV DIN PYTHON 32
CITIREA FIȘIERELOR CSV 32
SCRIEREA FIȘIERELOR CSV 37
PROBABILITATE SI STATISTICA CU PYTHON 40
PROBABILITATEA EVENIMENTELOR SIMPLE ȘI COMPUSE MUTUAL EXCLUSIVE ÎN PYTHON 40
SPAȚIU EȘANȚĂ 40
EVENIMENTE SIMPLE SI COMPUSE 40
ATRIBUIREA COTELOR 41
EVENIMENTE SIMPLE SE EXCLUSIVE MUTU 41
EVENIMENTE COMPUSE DIN EVENIMENTE SIMPLE MUTUAL EXCLUSIVE 42
FUNCȚII 43
PROBABILITATE CONDIȚIONATĂ ÎN PYTHON 43
FUNCȚII 44
EVENIMENTE DEPENDENTE 44
TEORIA MULTILOR ÎN PYTHON 46
EVENIMENTE INDEPENDENTE 46
TEOREMA LUI BAYES ÎN PYTHON 47
TEOREMA LUI BAYES SI PROBABILITATEA CAUZELOR 47
DATE: STUDIU DE CAZ 47
ANALIZĂ 48
PROCEDURĂ 49
FUNCȚII 54
LITTURĂ A MULTE 54
ANEXA I: CALCULE COMPLEXE 60
POPULAȚIE ȘI EȘANȚĂ DE STATISTICĂ: CALCULUL DE 60

- 19 -

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire

 Introducere în Data Science cu Python - Şcoala de Informatică Eugenia Bahit

VARIANȚA ȘI DEVIAȚIA STANDARD 60

PRODUS DIN DOI VECTORI 61
CALCULURI DE FRECVENȚĂ RELATIVE, ABSOLUTE ȘI ACUMULATE 61
ANEXA II: CREAREA UNUI MENIU DE OPȚIUNI 63
>
> >> tuplu4 = tuplu1 + tuplu2 + tuplu3
> >> tuplu4
(1, 2, 3, 4, 5, 4, 6, 8, 10, 3, 5, 7, 9)

VALOARE MAXIMA SI MINIMA

Puteți obține valoarea maximă și minimă atât a listelor, cât și a tuplurilor:

> >> max(tuplu4)

10
> >> max(tuplu1)
5
> >> min(tuplu1)
1
> >> max(lista3)
8
> >> min(lista1)
1

NUMĂRĂ ELEMENTE
Funcția len() este utilizată pentru a număra elementele unei liste sau tuplu, precum și caracterele unui șir de text:

> >> len(lista3)

10
> >> len(lista1)
4

- 20 -

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire

4.0
(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire 4.0
MANIPULAREA DICTIONARULUI
METODE DE ELIMINAREA

GOLȚI UN DICȚIONAR
Metoda: clear()
>>> dicționar = {"culoare": "violet", "dimensiune": "XS", "preț": 174,25}
> >> dictionar
{„culoare”: „violet”, „preț”: 174,25, „dimensiune”: „XS”}

> >> dicționar .clear()

> >> dictionar
{}

METODE DE ADUGARE SI CREARE

COPIEAZĂ UN DICȚIONAR
Metoda: copy()
> >> dicționar = {"culoare": "violet",
> >> cămașă = dicționar .copy()
> >> dictionar
{„culoare”: „violet”, „preț”: 174,25,

> >> cămașă {'culoare': 'violet', 'preț':

> >> Dictionary.clear()

„dimensiune”: „XS”, „preț”: 174,25}
> >> dicționar {}

> >> cămașă

„dimensiune”: „XS”}
{„culoare”: „violet”, „preț”:

> >> muscular = camasa

> >> cămașă 174.25, „dimensiune”: „XS”}
{„culoare”: „violet”, „preț”:

> >> muscular {'culoare': 'violet', 'preţ':

>>> shirt.clear()
>>> tricou {} >>> maiou {}
174.25, „dimensiune”: „XS”}

174.25, „dimensiune”: „XS”}

174.25, „dimensiune”: „XS”}

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire

4.0
 Introducere în Data Science cu Python - Şcoala de Informatică Eugenia Bahit

CREAȚI UN NOU DICȚIONAR DIN CHEILE LUI A

SECVENŢĂ
Metodă: dict.fromkeys(secvență[, valoare implicită])
>>> secvență = ["culoare", "dimensiune", "brand"]
>>> dicționar1 = dict.fromkeys(secvență)
>>> dictionar1
{'culoare': Niciuna, 'brand': Niciuna, 'dimensiune': Niciuna}

>>> dictionary2 = dict.fromkeys(secvență, „valoare x implicită”)

>>> dictionar2
{'culoare': 'valoare implicită', 'brand': 'valoare implicită', 'mărime': 'valoare implicită'}

DICTIONARE CONCATENATE
Metodă: actualizare (dicționar)
>>> dicționar1 = {"culoare": "verde", "preț": 45}
>>> dicționar2 = {"dimensiune": "M", "brand": "Lacoste"}
>>> dicționar1 .actualizare (dicționar2)
>>> dictionar1
{„culoare”: „verde”, „preț”: 45, „brand”: „Lacoste”, „mărime”: „M”}

SETĂ O CHEIE ȘI O VALOARE IMPLICITE

Metodă: setdefault(„cheie”[, Niciuna|default_value])

Dacă cheia nu există, o creează cu valoarea implicită. Returnează întotdeauna valoarea pentru cheia
transmisă ca parametru.

>>> cămașă = {"culoare": "roz", "brand": "Zara"}

>>> cheie = cămaşă. setdefault("dimensiune", "U")
> >> cheie
'SAU'

> >> cămașă

{„culoare”: „roz”, „brand”: „Zara”, „dimensiune”: „U”}

> >> shirt2 = shirt.copy()

> >> cămașă2
{„culoare”: „roz”, „brand”: „Zara”, „dimensiune”: „U”}

> >> cheie = cămașă2. setdefault(„ștampilat”)

> >> cheie
> >> cămașă2
{„culoare”: „roz”, „model”: niciunul, „brand”: „Zara”, „dimensiune”: „U”}

> >> cheie = cămașă2. setdefault("brand", "Lacoste")

> >> cheie
"Zara"

- 23 -

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire

4.0
 Introducere în Data Science cu Python - Şcoala de Informatică Eugenia Bahit

>>> cămașă2
{„culoare”: „roz”, „model”: niciunul, „brand”: „Zara”, „dimensiune”: „U”}

METODE DE RETURNARE

OBȚINE VALOAREA CHEIEI

Metodă: get(cheie[, „valoare x implicită dacă cheia nu există”])
>>> cămașă. obține(„culoare”)
'roz'

>>> cămașă. obține(„stoc”)

>>> cămașă. get("stoc", "stoc epuizat")
'epuizat'

ȘTIȚI DACĂ EXISTA O CHEIE ÎN DICȚIONAR

Metodă: „cheie” în dicționar
> >> există = „preț” în cămașă
> >> exista
fals

> >> există = „culoare” în cămașă

> >> exista
Adevărat

OBȚINEREA CHEILOR ȘI VALORILOR UNUI DICȚIONAR

Metodă: articole()
dicționar = {'culoare': 'roz', 'brand': 'Zara', 'mărime': 'U'}

pentru cheie, valoare în dictionary.items() :

valoare cheie
Ieșire:
('culoarea roz')
(„brand”, „Zara”)
(„mărime”, „U”)

OBȚINEȚI CHEILE UNUI DICȚIONAR

Metoda: chei()
dicționar = {'culoare': 'roz', 'brand': 'Zara', 'dimensiune': 'U'} pentru cheie în dicționar.keys():
cheie
'marca'
'talie'
'culoare'

Obțineți cheile într-o listă

- 24 -

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire

4.0
 Introducere în Data Science cu Python - Şcoala de Informatică Eugenia Bahit

> >> dicționar = {'culoare': 'roz', 'brand': 'Zara', 'mărime': 'U'}

> >> chei = list(dictionary.keys())
> >> chei
[„culoare”, „brand”, „dimensiune”]

OBȚINE VALORILE UNUI DICȚIONAR

Metoda: valoare()
dicționar = {'culoare': 'roz', 'brand': 'Zara', 'mărime': 'U'}
pentru cheie în dicționar.valori():
cheie
'roz'
"Zara"
'SAU'

Obțineți valori într-o listă

> >> dicționar = {'culoare': 'roz', 'brand': 'Zara', 'mărime': 'U'}
> >> chei = list(dictionary.values())

OBȚINEȚI NUMĂRUL DE ARTICOLE ÎNTR-UN DICȚIONAR

Pentru a număra elementele unui dicționar, ca și în cazul listelor și tuplurilor, este utilizată funcția încorporată
len().
> >> dicționar = {'culoare': 'roz', 'brand': 'Zara', 'mărime': 'U'}
> >> len(dictionar)
3

- 25 -

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire

4.0
(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire 4.0
MANIPULAREA SI MANIPULAREA DOSARELOR
Python vă permite să lucrați la două niveluri diferite în ceea ce privește sistemul de fișiere și

directoare.

Unul dintre ele este prin modulul os , care facilitează lucrul cu întregul sistem de fișiere și

directoare, la nivelul sistemului de operare însuși.

Al doilea nivel este cel care permite lucrul cu fișiere manipulând citirea și scrierea acestora din aplicația sau

scriptul în sine, tratând fiecare fișier ca pe un obiect.

CĂI DE DESCHIDERE A UNUI DOSAR

Modul în care este deschis un fișier este legat de obiectivul final care răspunde la întrebarea „ Pentru ce este

deschis acest fișier?” . Răspunsurile pot fi mai multe: a citi, a scrie sau a citi și a scrie.

De fiecare dată când un fișier este „deschis”, un pointer este creat în memorie .

Acest pointer va poziționa un cursor (sau un punct de acces ) într-o anumită locație din memorie (spus mai

simplu, va poziționa cursorul la un anumit octet al conținutului fișierului).

Acest cursor se va muta în interiorul fișierului pe măsură ce fișierul este citit sau în care este scris.

Când un fișier este deschis în modul de citire, cursorul este poziționat la octetul 0 al fișierului (adică, la începutul

fișierului). După ce fișierul este citit, cursorul se deplasează la octetul final al fișierului (echivalent cu numărul

total de octeți din fișier). Același lucru se întâmplă și când este deschis în modul de scriere. Cursorul se va mișca

pe măsură ce tastați.

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire

4.0
 Introducere în Data Science cu Python - Şcoala de Informatică Eugenia Bahit

Când doriți să scrieți la sfârșitul unui fișier non-null, este utilizat modul de adăugare . Aceasta deschide fișierul
cu cursorul la sfârșitul fișierului.
Simbolul + ca sufix al unui mod adaugă modul opus modului de deschidere odată ce acțiunea de deschidere este

executată. De exemplu, modul r (citire) cu sufixul + (r+), deschide fișierul pentru citire și, după citire, readuce

cursorul la octetul 0.

Următorul tabel arată diferitele moduri de a deschide un fișier:

Indicator modul de deschidere locația indicatorului
r Numai citire la începutul dosarului
rb Citește numai în modul binar la începutul dosarului

r+ Citire si scriere la începutul dosarului

rb+ Citirea și scrierea în mod binar la începutul dosarului
Scrie doar.
Suprascrie fișierul dacă există.
w la începutul dosarului
Creați fișierul dacă nu există.

Scrieți numai în modul binar. Suprascrie

wb fișierul dacă există. Creați fișierul dacă nu la începutul dosarului
există.

Scrierea și lectura.
w+ Suprascrie fișierul dacă există. la începutul dosarului
Creați fișierul dacă nu există.
Scrierea și citirea în modul binar. Suprascrie
wb+ fișierul dacă există. Creați fișierul dacă nu la începutul dosarului
există.
Dacă fișierul există, la sfârșitul
Adăugat (adăugați conținut). acestuia.
la Creați fișierul dacă nu există. Dacă fișierul nu există, la
început.
Dacă fișierul există, la sfârșitul
Adăugat în modul binar (adăugați conținut). acestuia.
ab Creați fișierul dacă nu există. Dacă fișierul nu există, la
început.

a+ Adăugat (adăugați conținut) și citit. Dacă fișierul există, la sfârșitul

- 28 -

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire

4.0
 Introducere în Data Science cu Python - Şcoala de Informatică Eugenia Bahit

acest.
Creați fișierul dacă nu există. Dacă fișierul nu există, la
început.
Dacă fișierul există, la sfârșitul
Adăugat (adăugați conținut) și citit în modul acestuia.
ab+ binar. Dacă fișierul nu există, la
Creați fișierul dacă nu există. început.

UNELE METODE ALE OBIECTULUI DOSAR

Obiectul fișier, printre metodele sale, are următoarele:

Metodă Descriere
Citiți întregul conținut al unui fișier.
citit([octeți]) Dacă i se trece lungimea în octeți, va citi numai conținutul
până la lungimea dată.
readlines() Citiți toate rândurile unui fișier

scrie (șir) Scrieți șirul în fișier

Secvența va fi orice iterabil ale cărui elemente vor fi scrise
linii de scriere (secvență)
câte una pe linie

ACCESAREA FIȘIERELOR PRIN STRUCTURA WITH Cu structura with și funcția open(), puteți
deschide un fișier în orice mod și puteți lucra cu el, fără a fi nevoie să-l închideți sau să distrugeți pointerul,
deoarece acest lucru este realizat de către structura with.

Citiți un fișier:

cu open("fișier.txt", "r" ) ca fișier: conținut = fișier.read()

Scrieți într-un fișier:

continut = """
Acesta va fi conținutul noului fișier.
Fișierul va avea mai multe rânduri.

- 29 -

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire

4.0
 Introducere în Data Science cu Python - Şcoala de Informatică Eugenia Bahit

"""

cu open("fișier.txt", "r" ) ca fișier: fișier.scrie(conținut)

MANIPULAREA FIȘIERELOR CSV

Formatul CSV își derivă numele din engleza „valori separate prin virgulă” (valori separate prin virgulă),

definite în RFC 4180 . Acestea sunt fișiere text simplu, destinate stocării în masă a datelor. Este unul dintre cele

mai simple formate pentru efectuarea analizei datelor. De fapt, multe formate de fișiere care nu sunt libere (sau

gratuite, dar mai complexe) sunt adesea convertite în CSV pentru a aplica știința datelor complexe în diferite

limbi.

Un fișier CSV este format dintr-un antet care definește numele coloanelor, iar rândurile următoare au datele

corespunzătoare fiecărei coloane, separate prin virgulă. Cu toate acestea, multe alte simboluri pot fi folosite ca

separatori de celule. Printre acestea, tabulatorul și punctul și virgulă sunt la fel de frecvente ca și virgula.

CATEVA EXEMPLE DE FISIERE CSV

Date meteorologice (separate prin ;)

ID;DATE;VV;DV;T;HR;PPT;RS;P
0;2016-03-01 00:00:00;;;9.9;73;;;
1;2016-03-01 00:30:00;;;9.0;67;;;
2;2016-03-01 01:00:00;;;8.3;64;;;
3;2016-03-01 01:30:00;;;8.0;61;;;
4;2016-03-01 02:00:00;;;7.4;62;;;
5;2016-03-01 02:30:00;;;8.3;47;;;
6;2016-03-01 03:00:00;;;7.7;50;;;
7;2016-03-01 03:30:00;;;9.0;39;;;

Scoruri obținute de jucători într-un turneu (separate prin ,) nume, cantitate, an

- 30 -

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire

4.0
 Introducere în Data Science cu Python - Şcoala de Informatică Eugenia Bahit

Mary,858,1930
Jose,665,1930
roz,591,1930
Juan Carlos, 522,1930
Antonio,509,1930
Maria Esther,495,1930
Maria Luisa,470,1930
Joanna,453,1930
Ioan,436,1930

Companii înregistrate la Inspectoratul General de Justiție din Argentina (separate prin , și datele între

ghilimele)

"număr_corelativ","tip_corporat","descriere_tip_corporat","motiv_companie","abonament_renunțat","cod_de_de
înregistrare","detaliu_deregistrare"
"10","10","SOCIEDAD COLECTIVE","AA VALLE Y COMPA¥IA","S","42014","APARTINE REGISTRULUI ENTITATILOR
INACTIVE"
"11","10","SOCIEDAD COLECTIVE","A LUCERO YH CARATOLI","S","42014","APARTINE
ÎNREGISTRAREA ENTITĂȚILOR INACTIVE”
"12","10","SOCIEDAD COLLECTIVE","A PUIG E HIJOS","S","42014","APARTINE
ÎNREGISTRAREA ENTITĂȚILOR INACTIVE”
"13","10","SOCIEDAD COLLECTIVE","ACIC A","S","42014","APARTINE ÎNREGISTRULUI
ENTITATI INACTIVE"
"14","10","SOCIEDAD COLLECTIVE","A¥ON BEATRIZ SY CIA","S","42014","APARTINE
ÎNREGISTRAREA ENTITĂȚILOR INACTIVE”
"15","10","SOCIEDAD COLLECTIVE","ABA DIESEL","S","42014","APARTINE ÎNREGISTRULUI
ENTITATI INACTIVE"
„16","10","PARTENERIAT COLECTIV","ABADA L JOSE ȘI JORGE JOSE
ABADAL","S","42014","APARTINE REGISTRULUI ENTITATILOR INACTIVE"
"17","10","SOCIEDAD COLECTIVE","ABADAL JOSE E HIJO","S","42014","APARTINE REGISTRULUI ENTITATILOR
INACTIVE"
"18","10","SOCIEDAD COLLECTIVE","ABATE Y MACIAS","S","42014","APARTINE LA
ÎNREGISTRAREA ENTITĂȚILOR INACTIVE”

De asemenea, este posibil să găsiți date stocate în fișiere text (TXT) cu formate foarte asemănătoare cu ceea ce

se așteaptă să fie găsit într-un CSV. Uneori este posibil să dezvoltați un script de format pentru a corecta aceste

fișiere, astfel încât să puteți lucra cu un CSV.

Observații meteo în TXT

DATA TMAX TMIN NUME

--------------------------------------------------------------------
07122017 28.0 19.0 AEROPARQUE AERO
07122017 26,8 12,4 ALBASTRU AERO

- 31 -

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire

4.0
 Introducere în Data Science cu Python - Şcoala de Informatică Eugenia Bahit

07122017 29.6 7.8 WHITE BAY AERO

07122017 22.7 6.7 BARILOCHE AERO
07122017 3.0 -8,5 BAZĂ BELGRANO II
07122017 2.4 -0.2 BASE CARLINI (EX JUBANY)
07122017 3.9 -0,6 BAZĂ DE SPERĂ
07122017 0.7 -3,6 BAZĂ MARAMBIO

LUCRU CU FIȘIERE CSV DIN PYTHON

Python oferă propriul modul numit csv, care facilitează analizarea datelor din fișierele CSV, atât pentru citire, cât

și pentru scriere.

Acest modul este utilizat în combinație cu structura cu și funcția open pentru a citi sau genera fișierul și modulul

CSV pentru analiza .

CITIREA FIȘIERELOR CSV

Fișier content.csv

0;2016-03-01 00:00:00;;;9.9;73;;;
1;2016-03-01 00:30:00;;;9.0;67;;;
2;2016-03-01 01:00:00;;;8.3;64;;;
3;2016-03-01 01:30:00;;;8.0;61;;;
4;2016-03-01 02:00:00;;;7.4;62;;;
5;2016-03-01 02:30:00;;;8.3;47;;;
6;2016-03-01 03:00:00;;;7.7;50;;;
7;2016-03-01 03:30:00;;;9.0;39;;;
8;2016-03-01 04:00:00;;;8.7;39;;;

din cititorul de import csv

cu open("fișier.csv", "r") ca fișier: document = reader(fișier, delimitator=';', pentru rândul din document:
' '.join(rând) quotechar='"')

Ieșire:

'0 2016-03-01 00:00:00 9.9 73

'1 2016-03-01 00:30:00 9.0 67
'2 2016-03-01 01:00:00 8.3 64
'3 2016-03-01 01:30:00 8.0 61
'4 2016-03-01 02:00:00 7.4 62
'5 2016-03-01 02:30:00 8.3 47
'6 2016-03-01 03:00:00 7.7 50
'7 2016-03-01 03:30:00 9.0 39
'8 2016-03-01 04:00:00 8.7 39

- 32 -

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire

4.0
 Introducere în Data Science cu Python - Şcoala de Informatică Eugenia Bahit

Când fișierul CSV are un antet, este necesar să săriți peste antet:

Fișier content.csv

ID;DATE;VV;DV;T;HR;PPT;RS;P
0;2016-03-01 00:00:00;;;9.9;73;;;
1;2016-03-01 00:30:00;;;9.0;67;;;
2;2016-03-01 01:00:00;;;8.3;64;;;
3;2016-03-01 01:30:00;;;8.0;61;;;
4;2016-03-01 02:00:00;;;7.4;62;;;
5;2016-03-01 02:30:00;;;8.3;47;;;
6;2016-03-01 03:00:00;;;7.7;50;;;
7;2016-03-01 03:30:00;;;9.0;39;;;
8;2016-03-01 04:00:00;;;8.7;39;;;

din cititorul de import csv

cu open("fișier.csv", "r") ca fișier: document = reader(fișier, delimitator=';', anteturi = următorul(document)

pentru rândul din document: quotechar='"')
' '.join(rând)

Ieșire:

METODE DE MANIPULARE VARIABILE 5

MANIPULAREA ȘIRURILOR DE TEXT 5
METODE DE FORMAT 5
Prima literă cu majuscule 5
CONVERȚI UN ȘIR ÎN MINUSCULE 5
CONVERTĂ UN ȘIR ÎN MAJUSCULE 6
CONVERSAȚI MAJUSCULE ÎN MINUSCULE ȘI VICE-VERSA 6
CONVERTĂ UN ȘIR ÎN FORMATUL DE TITL 6
CENTRAȚI UN TEXT 6
ALINIAȚI TEXTUL LA STÂNGA 6
Aliniați textul la dreapta 7
COMPLETAREA UNUI TEXT PREVĂTÂND ZEROURI 7
METODE DE CĂUTARE 7
NUMĂRĂ NUMĂR DE APARIȚII ALE UNUI SUBȘIR 7
CĂUTAȚI UN SUBȘIR ÎNTR-UN ȘIR 7
METODE DE VALIDARE 8
ȘTIȚI DACĂ UN ȘIR ÎNCEPE CU UN ANUMIT ȘIR 8
ȘTIȚI DACĂ UN ȘIR SE Termină CU UN ANUMIT ȘIR 8

- 33 -

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire

4.0
 Introducere în Data Science cu Python - Şcoala de Informatică Eugenia Bahit

ȘTIȚI DACĂ UN ȘIR ESTE ALFANUMERIC 8

ȘTIȚI DACĂ UN ȘIR ESTE ALFABETIC 8
ȘTIȚI DACĂ UN ȘIR ESTE NUMERICAL 9
ȘTIȚI DACĂ UN ȘIR CONTINE DOAR MINUSCULE 9
ȘTIȚI DACĂ UN ȘIR CONTINE DOAR MAJUSCULE 9
ȘTIȚI DACĂ UN ȘIR CONTINE NUMAI SPAȚII ALTE 10
ȘTIȚI DACĂ UN ȘIR ARE FORMAT DE TITL 10
METODE DE SUBSTITUȚIE 10
FORMATATE UN ȘIR, ÎNLOCUIȚI DINAMIC TEXTUL 10
ÎNLOCUIȚI TEXTUL ÎNTR-UN ȘIR 11
ELIMINAȚI PERSONAJELE DIN STÂNGA ȘI DREPTEA UNUI ȘIR 11
ȘTERGEȚI CARACTERELE DIN STÂNGA UNUI ȘIR 11
ELIMINAȚI PERSONAJELE DIN DREAPTA UNUI ȘIR 11
METODE DE UNIRE ȘI DIVIZARE 11
ÎNSCRIEȚI-VĂ ITERATIV LA UN SIR 11
RUPE UN LANT IN TREI PARTE, FOLOSIND UN SEPARATOR 12
RUPEREA UNUI LANȚ ÎN MAI MULTE PĂRȚI, FOLOSIND UN SEPARATOR 12
DESPARTAREA UNUI LANȚ ÎN LINII 12
MANIPULARE LISTĂ ȘI TUPLU 14
METODE AGREGATE 14
ADĂUGAȚI UN ARTICOL LA sfârșitul listei 14
Adăugați mai multe articole la sfârșitul listei 14
ADĂUGAȚI UN ELEMENT ÎNTR-O POZIȚIE DETERMINATĂ 14
METODE DE ELIMINAREA 14
ȘTERGEȚI ULTIMUL ARTICOL DIN LISTĂ 14
ȘTERGEȚI UN ELEMENT DUPĂ INDEXUL SĂU 15
ȘTERGEȚI UN ELEMENT DUPĂ VALOAREA SA 15
METODE DE COMANDA 15
SORTEAȚI O LISTĂ ÎN INVERS (ORDINE INVERSĂ) 15
SORTAZĂ O LISTĂ ÎN FORMA ASCENDĂTORĂ 15
SORTEAȚI O LISTĂ ÎN FORMA DESCENDĂTORĂ 15
METODE DE CĂUTARE 15
NUMĂRĂ NUMĂRUL DE APARIȚII 15
OBȚINEȚI NUMĂRUL DE INDEX 16
ANEXĂ DESPRE LISTE ȘI TUPLE 16

- 34 -

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire

4.0
 Introducere în Data Science cu Python - Şcoala de Informatică Eugenia Bahit

CONVERSIE DE TIP 16
CONCATENAREA COLECȚILOR 17
VALOARE MAXIMA SI MINIMA 20
NUMĂRĂ ELEMENTE 20
MANIPULAREA DICTIONARULUI 22
METODE DE ELIMINAREA 22
GOLȚI UN DICȚIONAR 22
METODE DE ADUGARE SI CREARE 22
COPIEAZĂ UN DICȚIONAR 22
CREAȚI UN NOU DICȚIONAR DIN CHEILE LUI A 23
SECVENŢĂ 23
DICTIONARE CONCATENATE 23
SETĂ O CHEIE ȘI O VALOARE IMPLICITE 23
METODE DE RETURNARE 24
OBȚINE VALOAREA CHEIEI 24
ȘTIȚI DACĂ EXISTA O CHEIE ÎN DICȚIONAR 24
OBȚINEREA CHEILOR ȘI VALORILOR UNUI DICȚIONAR 24
OBȚINEȚI CHEILE UNUI DICȚIONAR 24
OBȚINE VALORILE UNUI DICȚIONAR 25
OBȚINEȚI NUMĂRUL DE ARTICOLE ÎNTR-UN DICȚIONAR 25
MANIPULAREA SI MANIPULAREA DOSARELOR 27
CĂI DE DESCHIDERE A UNUI DOSAR 27
UNELE METODE ALE OBIECTULUI DOSAR 29
MANIPULAREA FIȘIERELOR CSV 30
CATEVA EXEMPLE DE FISIERE CSV 30
LUCRU CU FIȘIERE CSV DIN PYTHON 32
CITIREA FIȘIERELOR CSV 32
SCRIEREA FIȘIERELOR CSV 37
PROBABILITATE SI STATISTICA CU PYTHON 40
PROBABILITATEA EVENIMENTELOR SIMPLE ȘI COMPUSE MUTUAL EXCLUSIVE ÎN
PYTHON 40
SPAȚIU EȘANȚĂ 40
EVENIMENTE SIMPLE SI COMPUSE 40
ATRIBUIREA COTELOR 41
EVENIMENTE SIMPLE SE EXCLUSIVE MUTU 41

- 35 -

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire

4.0
 Introducere în Data Science cu Python - Şcoala de Informatică Eugenia Bahit

EVENIMENTE COMPUSE DIN EVENIMENTE SIMPLE MUTUAL EXCLUSIVE 42

FUNCȚII 43
PROBABILITATE CONDIȚIONATĂ ÎN PYTHON 43
FUNCȚII 44
EVENIMENTE DEPENDENTE 44
TEORIA MULTILOR ÎN PYTHON 46
EVENIMENTE INDEPENDENTE 46
TEOREMA LUI BAYES ÎN PYTHON 47
TEOREMA LUI BAYES SI PROBABILITATEA CAUZELOR 47
DATE: STUDIU DE CAZ 47
ANALIZĂ 48
PROCEDURĂ 49
FUNCȚII 54
LITTURĂ A MULTE 54
ANEXA I: CALCULE COMPLEXE 60
POPULAȚIE ȘI EȘANȚĂ DE STATISTICĂ: CALCULUL DE 60
VARIANȚA ȘI DEVIAȚIA STANDARD 60
PRODUS DIN DOI VECTORI 61
CALCULURI DE FRECVENȚĂ RELATIVE, ABSOLUTE ȘI ACUMULATE 61
ANEXA II: CREAREA UNUI MENIU DE OPȚIUNI 63

O altă modalitate de a citi fișierele CSV cu antete este să utilizați obiectul DictReader în loc de

reader și să accesați astfel doar valoarea coloanelor dorite, după nume:

din csv import DictReader

cu open("fișier.csv", "r") ca fișier: document = DictReader (fișier, delimitator=';', pentru rândul din document:
rând['DATE'] quotechar='"')

- 36 -

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire

4.0
 Introducere în Data Science cu Python - Şcoala de Informatică Eugenia Bahit

Ieșire:

'2016-03-01 00:00:00'
'2016-03-01 00:30:00'
'2016-03-01 01:00:00'
'2016-03-01 01:30:00'
'2016-03-01 02:00:00'
'2016-03-01 02:30:00'
'2016-03-01 03:00:00'
'2016-03-01 03:30:00'
'2016-03-01 04:00:00'

SCRIEREA FIȘIERELOR CSV

Scrierea unui CSV fără antet:

din writer de import csv cu open("data.csv", "w") ca fișier:

document = writer(fișier, delimitator=';', quotechar='"') document.writerows(array)

În exemplul de mai sus, o matrice ar putea fi o listă de liste cu același număr de elemente. De

exemplu: matrice = [

[„John”, 373, 1970],

[„Anna”, 124, 1983],
[„Petru”, 901, 1650],
[„Trandafir”, 300, 2000],
[„Joan”, 75, 1975],
]

Cele de mai sus ar genera un fișier numit data.csv cu următorul conținut:

eugenia@bella:~$ cat data.csv

Ioan;373;1970
Anne;124;1983
Petru;901;1650
Roz;300;2000
Joanna;75;1975

- 37 -

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire

4.0
 Introducere în Data Science cu Python - Şcoala de Informatică Eugenia Bahit

Scrierea unui CSV cu antet:

În acest caz, matricea de scris va trebui să fie o listă de dicționare ale căror chei se potrivesc cu

anteturile indicate.

matrice = [
dict(player='John', points=373, year=1970), dict(player='Anna', points=124, year=1983),
dict(player='Peter', points=901, year=1650) , dict(player='Rosa', points=300, year=2000), dict(player='Joan',
points=75, year=1975), ] din csv import DictWriter

anteturi = ['player', 'points', 'year'] cu open("data.csv", "w") ca fișier:

document = DictWriter(fișier, delimitator=';', nume quotechar='"',
câmpuri=anteturi)
document.writeheader()
document.writerrows(matrice)

Funcții statistice simple

Pe listele și tuplurile obținute sau nu dintr-un CSV, pot fi efectuate funcții statistice simple precum

următoarele:

număra articolele len (colecție) sumă

adauga elemente (colecție) max
obține un număr mai mare (colecție) min
obține un număr mai mic (colecție)

- 38 -

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire

4.0
(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire 4.0
PROBABILITATE SI STATISTICA CU PYTHON
PROBABILITATEA EVENIMENTELOR SIMPLE ȘI COMPUSE MUTUAL
EXCLUSIVE ÎN PYTHON
SPAȚIU EȘANȚĂ
Un spațiu eșantion este un set de evenimente posibile, cum ar fi cele care ar putea rezulta din

aruncarea unui zar:

E=(1,2,3,4,5,6)
spațiu_eșantion = [1, 2, 3, 4, 5, 6]

Fiecare element dintr-un spațiu de probă este denumit punct de probă . Numărul de puncte de

eșantionare este notat cu n astfel încât pentru spațiul de eșantion E=11,2,3,4,5,6/

, n=6 .

n = len(sample_space)

EVENIMENTE SIMPLE SI COMPUSE

Un eveniment este un set de rezultate într-un spațiu eșantion. De exemplu:

• aruncarea unui zar este un eveniment

• Probabilitatea ca numărul 5 să apară în respectiva aruncare este un eveniment simplu A =

{5} și este exclusivă : dacă apare 5, niciun alt număr nu poate apărea simultan.

• probabilitatea ca la tragere la sorti să apară un număr impar este evenimentul compus

B=11,3,5}
care la rândul lor va depinde de evenimente
exclusive simple ^ = {1} , B2 = {2} și B3 = {3}

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire

4.0
 Introducere în Data Science cu Python - Şcoala de Informatică Eugenia Bahit

ATRIBUIREA COTELOR
Atribuirea probabilității este una care oferă modele matematice pentru a calcula șansele ca anumite

evenimente să apară sau nu.

Probabilitatea unui eveniment se notează cu P( eveniment)

.

Evenimentele pot fi:

• simplu sau compus

• reciproc exclusiv sau independent

EVENIMENTE SIMPLE SE EXCLUSIVE MUTU

Dacă luăm în considerare un spațiu eșantion A , fiecare dintre punctele eșantionului k , va fi notat cu

Ak și probabilitatea lor, desemnată ca P(Ak) , va fi determinată de:

P(A,) = -
Nu

probabilitate = 1,0 / n

În Python , cel puțin un element al ecuației trebuie să fie un număr real dacă ceea ce este
necesar ca rezultat este un număr real.

Probabilitatea fiecărui punct eșantion, ca evenimente care se exclud reciproc, este aceeași pentru

fiecare eveniment.

P^) = P(5) = P(4) = P(3) = P(2) = P(1)

- 41 -

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire

4.0
 Introducere în Data Science cu Python - Şcoala de Informatică Eugenia Bahit

EVENIMENTE COMPUSE DIN EVENIMENTE SIMPLE MUTUAL

EXCLUSIVE
Când evenimentele simple care alcătuiesc evenimentul compus A se exclud reciproc, probabilitatea

evenimentului compus va fi dată de suma probabilităților fiecărui eveniment simplu P(Ak) , astfel

încât:

P(A) = P(A1)—P(A2)——P(Ak)
De exemplu, pentru a estima probabilitatea ca un număr par să apară la o singură aruncare a zarului,

obțineți evenimentul .4 = {2. 4,. 6}

, dat de suma

probabilităților fiecăruia dintre evenimentele simple P(2)—P(3)—P(4, ale spațiului eșantion

E=11,2,3,4,5,6}
astfel încât:

P(A) = P(2) - P(4) +P(6)

P(A) =1+1+1=8
P(A) - |

3
În primul rezultat 6 (în a doua etapă, înainte de a găsi cel mai mare comun

1
divizor [GCD] și reduceți fracția la 2 ), numitorul este echivalent cu numărul de evenimente simple

din cadrul evenimentului compus «numere pare» și se notează cu h . Numitorul, 6 , este n , totalul

tuturor evenimentelor din spațiul eșantion. În acest fel, probabilitatea unui eveniment compus A din

evenimente care se exclud reciproc este dată de câtul lui h și n astfel încât:
p(a) = • n

numere_pare = [i pentru i în spațiul_eșantion dacă i % 2 este 0] h = len(numere_pare) probabilitate =

float(h) / n

- 42 -

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire

4.0
 Introducere în Data Science cu Python - Şcoala de Informatică Eugenia Bahit

Un eveniment compus poate fi notat prin unirea evenimentelor sale simple (simbolul u , citit ca

„o”), astfel încât:

P(A, u A u ...A,) = P(A, ) + P(A2) + ...A,

De exemplu, pentru cazul evenimentului „numere pare”, se obține că:

P(2U4U6 ) = P(2)+P(4)+P(6)
P(2U4U6) = 1++1+1 =8
P(2 U 4 U 6) = |

Astfel încât P(2U4U 6)

este un eveniment și P(2) , P( 4) și P(6) sunt probabilitățile de
cele trei evenimente care o compun. Într-un context nou, U 4 U 6)
ar putea fi
tratat ca un eveniment A.

FUNCȚII
# Probabilitatea unor evenimente simple care se exclud reciproc pssme = lambda e: 1.0 / len(e) #
Probabilitatea unor evenimente compuse care se exclud reciproc def pscme(e, sc):
n = len(e)
return len(sc) / float(n)

PROBABILITATE CONDIȚIONATĂ ÎN PYTHON

B= {2,4,6}
c. Probabilitatea lui B: P(B) =$=6=2

d. Probabilitatea de intersecție:

P(ARB) = P(A)P(B)
P(A n B) = 1 I
P(AnB) = I

e = eșantion_space = [1, 2, 3, 4, 5, 6] n = len(e) # total eșantion

# probabilitatea A
a = [i pentru i în e dacă i % 2 nu este 0] pa = len(a) / float(n)

- 43 -

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire

4.0
 Introducere în Data Science cu Python - Şcoala de Informatică Eugenia Bahit

# probabilitatea lui B
b = [i pentru i în e dacă i % 2 este 0]
bp = len(b) / float(n)

# probabilitatea de intersectare a evenimentelor pi = pa * pb

FUNCȚII
# Probabilitate condiționată: evenimente dependente def pscd(e, a, b):
i = listă(mulțimea(a).intersecția(b))
pi = pscme(e, i)
pa = pscme(e, a)
return pi/pa

# Probabilitate condiționată: evenimente independente def psci(e, a, b):

pa = pscme(e, a)
pb = pscme(e, b)
return pa * bp

EVENIMENTE DEPENDENTE
Se referă la probabilitatea ca două evenimente să apară simultan, deoarece al doilea eveniment

depinde de apariția primului.

Probabilitatea ca B să apară dacă apare A se notează cu P(BA) și se citește „probabilitatea ca B dat

A” , astfel încât:

P (B I^ _
1
■P(A)

Unde PA n B)
este probabilitatea intersectării evenimentelor lui A și B

— definită ca: P{A n B) = P(A)P(BA,

—, astfel încât intersecția este un eveniment

nou compus din evenimente simple. În exemplul de mai jos, ar fi egal cu 11,3} (deoarece 1 și 3 sunt

atât în A cât și în B ).

Exemplu : Care este probabilitatea ca la aruncarea unui zar să rezulte un număr impar mai mic de 4?

- 44 -

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire

4.0
 Introducere în Data Science cu Python - Şcoala de Informatică Eugenia Bahit

Aruncarea zarurilor este un eveniment în sine. Vrem să aflăm probabilitatea lui B = {1.2.3} (număr
mai mic decât 4) având în vedere că A=(1,3,5 (număr impar) a apărut în spațiul eșantionar E = {1.2.
3. 4,5,6} .

spațiu_eșantion = [1, 2, 3, 4, 5, 6]
a = [i pentru i în spațiul_eșantion dacă i % 2 nu este 0]
b = [i pentru i în spațiul_eșantion dacă i < 4]

Pentru a calcula probabilitatea unei intersecții, mai întâi găsiți intersecția:

An ={1,3}

intersect = [i pentru i în a dacă i în b]

Și apoi, probabilitatea noului eveniment compus este calculată:

112 1
P(AnB)=P(1)+P(3)=+=é=, b0O3

sau, ce este la fel:

poand_1-2_1
#6 3

De asemenea, este necesar să se obțină probabilitatea lui A , ținând cont de faptul că

este, de asemenea, un eveniment compus:

p_I_2_1
In final, se obtine ca:

P(B|A) = P427
P(B|.A) = 1/2
P(BA) =5=0,6

e = spațiu_probă = [1, 2, 3, 4, 5, 6]

a = [i pentru i în e dacă i % 2 nu este 0] # numere impare

b = [i pentru i în și dacă i < 4] # numere mai mici de 4

- 45 -

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire

4.0
 Introducere în Data Science cu Python - Şcoala de Informatică Eugenia Bahit

intersect = [i pentru i în a dacă i în b] # intersecția lui A și B

n = len(e) # eșantion total

ha = len(a) # numărul total de evenimente simple din A
hintersec = len(intersec) # numărul total de evenimente simple la intersecție

# probabilitatea de intersectie
probabilitate_intersec = float(hintersec) / n

# probabilitatea de „a”
probabilitate_a = float(ha) / n

# probabilitate condițională
probabilitate_b_dată_a = probabilitate_interceptare / probabilitate_a

TEORIA MULTILOR ÎN PYTHON

Când obținem intersecția a două evenimente compuse, am folosit o metodă manuală spunând:

returnează „i” pentru fiecare „i” din lista „a” dacă este în lista „b”.

Cu toate acestea, deoarece fiecare eveniment compus este o mulțime și Python oferă un tip de date

numit set, este posibil să obțineți intersecția prin manipularea evenimentelor compuse ca seturi

Python. Cu set puteți converti orice iterabil într-un set și puteți efectua operațiuni de set, cum ar fi

unirea și intersecția, atunci când este necesar. intersecție = listă(set(a).intersection(b))

Aici setul obținut este convertit într-o listă pentru a se termina pentru a fi în concordanță cu restul

codului și pentru ca elementul rezultat să suporte operațiunile obișnuite și tratamentul unei liste.

Când aveți îndoieli cu privire la utilizarea listelor sau seturilor, trebuie aplicat principiul simplității

și implementată cea mai simplă soluție.

EVENIMENTE INDEPENDENTE

Spre deosebire de cazul precedent, aici probabilitatea ca B să apară nu este afectată de apariția lui

A . De exemplu, probabilitatea de a arunca un zar

- 46 -

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire

4.0
 Introducere în Data Science cu Python - Şcoala de Informatică Eugenia Bahit

iar obținerea unui număr par (evenimentul B) nu este afectată de faptul că un număr impar
(evenimentul A) a fost aruncat la o aruncare anterioară. Probabilitatea lui B este independentă de A
și este dată de produsul probabilității ambelor evenimente:
P(AnB) = P(A)P(B)

Aici intersecția este probabilitatea ca ambele evenimente să convergă.

Calculată probabilitatea ambelor evenimente independente, acestea se înmulțesc obținând:

a. Spațiu de probă (pentru ambele evenimente):

E = {1,2,3,4,5,0}

b. Probabilitatea A:

.4= {1,3,5}
P(A) = h = 2 = 1

TEOREMA LUI BAYES ÎN PYTHON

TEOREMA LUI BAYES SI PROBABILITATEA CAUZELOR

Având în vedere o serie de evenimente Ak a căror sumă totală este un spațiu eșantion E și orice

eveniment B , Teorema lui Bayes ne permite să cunoaștem probabilitatea ca fiecare eveniment Ak al

lui E , să fie cauza lui B . Din acest motiv, este cunoscută și sub numele de probabilitatea

cauzelor .

DATE: STUDIU DE CAZ

Având în vedere un oraș de 50.000 de locuitori , cu următoarea distribuție:

- 47 -

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire

4.0
 Introducere în Data Science cu Python - Şcoala de Informatică Eugenia Bahit

fetelor Copii femei Bărbați

11000 9000 16000 14000

Și, un raport de 9.000 de cazuri de gripă , distribuite după cum urmează:

Fete Băieți Femei Bărbați

2000 1500 3000 2500

Se urmărește obținerea probabilității ca cauza contractării gripei să fie faptul că aparțineți unui

anumit sector demografic (de exemplu, sectorul demografic format din băieți sau fete).

ANALIZĂ
Din cele menționate mai sus se poate obține că:

• Orașul (total absolut de locuitori) este spațiul eșantion E .

• Numărul de fete, băieți, femei și bărbați este fiecare dintre evenimentele Ak din spațiul
eșantion E

• Ca valoare a lui n luăm suma spațiului eșantion 2 Aa , astfel încât

n = 50000

• Valoarea lui h pentru evenimentele Ak este fiecare dintre valorile date în tabelul de
distribuție a populației.

• A avea gripă este evenimentul B.

• Tabelul de distribuție a cazurilor de gripă corespunde intersecțiilor evenimentului B cu
fiecare eveniment Ak , adică fiecare Akn B

Conform calculului de probabilitate care se aplică, se va putea obține:

- 48 -

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire

4.0
 Introducere în Data Science cu Python - Şcoala de Informatică Eugenia Bahit

• Probabilitatea de a fi fată, băiat, femeie sau bărbat în oraș, prin P(Ak) . Este considerată o
probabilitate anterioară .

• Probabilitatea de a fi fată, băiat, femeie sau bărbat și de a avea gripă, obținută cu P(Ak B) și
considerată probabilitate condiționată .

• Probabilitatea ca orice locuitor, indiferent de sectorul căruia îi aparține, să aibă gripă, se

obține cu

Nu
P(B)=>P(A)P(BA,)
k=1 și este considerată o probabilitate totală.

• Probabilitatea ca cineva cu gripă să fie fată, băiat, femeie sau bărbat este găsită folosind
teorema lui Bayes . Această probabilitate este considerată probabilitate a posteriori ,

permițând răspunsuri la întrebări precum : care este probabilitatea ca un nou caz de gripă să

fie la un băiat sau o fată?

O modalitate eficientă și ordonată de a obține o probabilitate posterioară cu teorema lui Bayes este

să obțineți mai întâi cele trei probabilități anterioare: anterioară, condiționată și totală.

AVERTIZARE:
de acum înainte, map(float, <list>) va fi folosită în codul sursă pentru a converti elementele
unei liste în numere reale, atâta timp cât acest lucru nu supraîncărcă codul.

PROCEDURĂ
1. Calcul de probabilitate anterior

Randamente: probabilitatea ca un locuitor să aparțină unui anumit sector demografic.

- 49 -

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire

 Introducere în Data Science cu Python - Şcoala de Informatică Eugenia Bahit

Formulă:

Informatie necesara:

hk = date din tabelul de distribuție a populației

n = este întotdeauna numărul total al spațiului eșantion (50.000)

Rezultate:
m) = = 0.22
50000 probabilitate fifetiță

9000
P(A2) = 50000
= 0.18
probabilitate ficopil
16000
= 0.32
50000
probabilitate fifemei
14000 = 0.28
50000 probabilitate fiom

Cod Python:

locuitori = hartă(float, [11000, 9000, 16000, 14000])

n = suma(locuitori)
pa = [h / n pentru h în locuitori]

2. probabilitate condițională

Returnări: probabilitatea de a avea gripă aparținând unui sector demografic

specific.

Certitudine: Ak (sectorul demografic)

Obiectiv: B (probabilitatea de a avea gripă)

- 50 -

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire

4.0
 Introducere în Data Science cu Python - Şcoala de Informatică Eugenia Bahit

P(AknB)
P(BAk)= P(A,)
Formulă:
Informatie necesara:

h=B,
P(AknB) =
h = intersecții (date din tabelul de distribuție a cazurilor de gripă)

Rezultate:

. .....
P(BA1)= LANA 1
0 18 0.22 ' șansa de a face gripă în copilărie

IWO
P(BI A) = 50000 = 0.16
0.18
șansa de a face gripă în copilărie
3000
P(BI A3) = wooo __0 19
0.32 '
șansa de a face gripă ca femeie
2500
P(BI A) = LÂNĂ ___0 18
0.28 ' probabilitatea de a avea gripă ca bărbat

Cod Python:

afectat = hartă(float, [2000, 1500, 3000, 2500]) pi = [k / n pentru k în afectat]

pba = [pi[i] / pa[i] pentru i în interval(len(pi))]

3. probabilitate totală

Returnări: probabilitatea ca oricare dintre locuitori, indiferent de sectorul demografic căruia îi

aparțin, să aibă gripă.

- 51 -

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire

4.0
 Introducere în Data Science cu Python - Şcoala de Informatică Eugenia Bahit

Nu
P(B) = >P(A,) P(BA,)
Formulă: k=1

Informatie necesara:

probabilitate anterioară
probabilitate condițională

Rezultate:

P(B) = PA,) PBA)) PBA)) (])+() PB])

P(B") = 0,22 ■ 0,18-0,18 ■ 0,16+0,32 ■ 0,19 — 0,28 ■ 0,18

PIB] = 0,04 - 0,03 - 0,06 - 0,05

P(B) = 0,18

Cod Python:

produse = [pa[i] * pba[i] pentru i în interval(len(pa))] pb = suma(produse)

Observatii :

(a) rețineți că în ieșirea anterioară va exista o diferență de .01 față de soluția manuală. Acest lucru

se datorează rotunjirii făcute în soluția manuală. Această diferență poate fi eradicată prin utilizarea a

3 zecimale în valorile probabilității condiționate (în loc de 2) în soluția manuală.

- 52 -

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire

4.0
 Introducere în Data Science cu Python - Şcoala de Informatică Eugenia Bahit

(b) probabilitatea de a NU avea gripă va fi dată de 1 - P(B'l astfel încât

1 -0,18 = 0,82 dar nu va fi necesar să îl utilizați pentru acest exemplu cu
teorema lui Bayes.

4. probabilitate posterioară

Randamente: probabilitatea de a aparține unui anumit sector demografic și de a avea gripă.

Certitudine: B (ai gripa)

Țintă: Ak (probabilitatea de a aparține unui anumit grup demografic)

_ . 2P(A,)P(BA+)
Formulă: k=1

Informatie necesara:

PAk) P(BAk,
= produsul obţinut în fiecare dintre termenii probabilităţii totale

Nu

2P(AL)P(B|A)
k=1 = probabilitatea globală

Rezultate:

= 0.22
probabilitatea de a fi o fată cu gripă

0.03
P(A2B)= 0.18
= 0.16
probabilitatea de a fi un copil cu gripă

- 53 -

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire

4.0
 Introducere în Data Science cu Python - Şcoala de Informatică Eugenia Bahit

0.06 —
P(A3B)= = 0.33
0,18 probabilitate de a fi o femeie cu gripă

0.05 -
P(A4B)= = 0.27
0,18 probabilitate de a fi bărbat să aibă gripă

Cod Python:

pab = [p / pb pentru p în produse]

FUNCȚII
# Teorema lui Bayes
def bayes(e, b):
n = float(suma(e))
pa = [h / n pentru h în e]
pi = [k/n pentru k în b]
pba = [pi[i] / pa[i] pentru i în interval(len(pi))]
prods = [pa[i] * pba[i] pentru i în interval(len(pa))]
bpt = suma(produse)
pab = [p / pb pentru p în produse]
retur pab

LITTURĂ A MULTE
[0] Probabilitate și statistică, Murray Spiegel. McGraw-Hill, Mexic 1988. ISBN: 968-451-102-7

- 54 -

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire

4.0
(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire 4.0
(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire 4.0
(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire 4.0
(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire 4.0
(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire 4.0
ANEXA I: CALCULE COMPLEXE
POPULAȚIE ȘI EȘANȚĂ DE STATISTICĂ: CALCULUL DE
VARIANȚA ȘI DEVIAȚIA STANDARD
din import matematică sqrt

mostre = [12, 23, 24, 22, 10, 17] # liste de exemple

n = len(eșantioane)
medie = suma(eșantioane) / float(n)

Jumătat
e

varianţa populaţiei
2 _ H(,2)2
" Nu

varianța eșantionului

abaterea standard a probei

abaterea standard a populației

diferențe = [xi - medie pentru xi în eșantioane]

puteri = [x ** 2 pentru x în diferențe]
suma = suma(puterile)

varianță_eșantion = sumă / (n - 1) varianță_populație = sumă / n

abatere_eșantion = sqrt(varianță_eșantion) abatere_populație = sqrt(varianță_populație)

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire

4.0
 Introducere în Data Science cu Python - Şcoala de Informatică Eugenia Bahit

PRODUS DIN DOI VECTORI

vector1 = [3, 0]
vvector2 = [4, 3]
pe = sumă([x * y pentru x, y în zip(vector1, vector2)])

CALCULURI DE FRECVENȚĂ RELATIVE, ABSOLUTE ȘI ACUMULATE

# FRECVENTA ABSOLUTA
# De câte ori apare o valoare într-o probă

mostre = [1, 2, 3, 4, 3, 2, 6, 7, 3, 3, 1, 8, 5, 9] absolut = []

frecvențe = []

pentru n în eșantioane:
dacă nu n în absolute:
absolute.apend(n)
fi = samples.count(n)
frecvențe.apend(fi)

N = suma(frecvențele) # == len(eșantioane)

# FRECVENTA RELATIVA
# Coeficient între frecvența absolută și N relativ = [float(fi) / N pentru fi în frecvențe] sumrelative =
rotund(sum(relativ)) # == 1

# FRECVENTA CUMULATIVA
# Suma tuturor frecvențelor mai mică sau egală cu frecvențele absolute.sort()
cumulativ = [sum(frecvențe[:i+1]) pentru i, fi în enumerate(frecvențe)]

# FRECVENTA RELATIVA CUMULATIVA

# Coeficient între frecvența cumulativă și cantitatea totală de date cumulate = [float(f) / N pentru f în
cumulat]

- 61 -

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire

4.0
(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire 4.0
ANEXA II: CREAREA UNUI MENIU DE OPȚIUNI
În scripting , poate fi util să oferiți utilizatorului un meniu de opțiuni și ca scriptul să acționeze

asupra opțiunii alese de utilizator. Iată un truc pentru a rezolva acest lucru într-un mod simplu și

inteligent.

1) În primul rând, întregul script trebuie organizat în funcții.

2) În al doilea rând, este necesar ca toate funcțiile să aibă documentația corespunzătoare, care să

definească exact ce face funcția:

def read_file():
"""Citiți fișierul CSV"""
returneaza "citeste"

def write_file():
"""Scrieți fișierul CSV"""
returneaza "scrie"

def _add_numbers(lista):
"""Suma numerele unei liste""" returnează "privat"

3) În continuare, se definește o listă cu numele tuturor funcțiilor care vor fi accesibile de către

utilizator, din meniu:

funcții = [ 'read_file' , 'write_file' ]

Trucul va fi să automatizezi atât generarea meniului, cât și apelul la funcție.

Pentru a automatiza generarea meniului , trucul este să folosiți:

▪ Lista de la pasul 3

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire

4.0
 Introducere în Data Science cu Python - Şcoala de Informatică Eugenia Bahit

▪ Funcția locals().

▪ Atributul doc

număr = 1 # va fi folosit ulterior pentru a accesa funcția

meniu = „Alegeți o opțiune:\n”

pentru funcții în funcții:

meniu += "\t{}. {}\n".format(număr, locals()[funcție].__doc__) număr = număr + 1 # număr de incremente
la fiecare iterație

ecou (meniu)
opțiune = int(get("Opțiunea ta: "))
# echo and get: hack-uri învățate în cursul introductiv

În final, pentru a accesa dinamic funcția aleasă de utilizator, trucul va fi să folosești opțiunea aleasă

de utilizator, ca index pentru a accesa numele funcției din listă, și să apelezi din nou localnicii pentru

a apela funcția:

function = functions[option – 1] locals() # obține numele funcției

[function]() # funcția este apelată prin locals()

- 64 -

(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire

4.0
(C) 2011 - 2018 Eugenia Bahit. Creative Commons Atribuire 4.0
 CERTIFICAT

Arată cât de mult ai învățat!

Dacă ați ajuns la finalul cursului puteți obține o triplă certificare:

- Certificat de participare (eliberat de școala Eugenia Bahit)

- Certificat de realizare (eliberat de CLA Linux)
- Aprobare de certificare (eliberată de LAECI)

Aflați de la profesorul dvs. sau vizitați site-ul web de certificare la http://python.eugeniabahit.org .

Dacă trebuie să vă pregătiți examenul, vă puteți înscrie la

Curs de știință a datelor cu Python la
Şcoala de Informatică Eugenia Bahit
www.eugeniabahit.com