Python orientato agli oggetti - Strutture dati
Le strutture dati Python sono molto intuitive dal punto di vista della sintassi e offrono un'ampia scelta di operazioni. È necessario scegliere la struttura dei dati Python a seconda di cosa comportano i dati, se devono essere modificati o se si tratta di un dato fisso e quale tipo di accesso è richiesto, come all'inizio / fine / casuale ecc.
Liste
Una lista rappresenta il tipo più versatile di struttura dati in Python. Un elenco è un contenitore che contiene valori separati da virgole (elementi o elementi) tra parentesi quadre. Gli elenchi sono utili quando vogliamo lavorare con più valori correlati. Poiché gli elenchi tengono insieme i dati, possiamo eseguire gli stessi metodi e operazioni su più valori contemporaneamente. Gli indici delle liste iniziano da zero e, a differenza delle stringhe, le liste sono modificabili.
Struttura dei dati - Elenco
>>>
>>> # Any Empty List
>>> empty_list = []
>>>
>>> # A list of String
>>> str_list = ['Life', 'Is', 'Beautiful']
>>> # A list of Integers
>>> int_list = [1, 4, 5, 9, 18]
>>>
>>> #Mixed items list
>>> mixed_list = ['This', 9, 'is', 18, 45.9, 'a', 54, 'mixed', 99, 'list']
>>> # To print the list
>>>
>>> print(empty_list)
[]
>>> print(str_list)
['Life', 'Is', 'Beautiful']
>>> print(type(str_list))
<class 'list'>
>>> print(int_list)
[1, 4, 5, 9, 18]
>>> print(mixed_list)
['This', 9, 'is', 18, 45.9, 'a', 54, 'mixed', 99, 'list']Accesso agli elementi nell'elenco Python
Ad ogni elemento di una lista viene assegnato un numero, che è l'indice o la posizione di quel numero. L'indice inizia sempre da zero, il secondo indice è uno e così via. Per accedere agli elementi in un elenco, possiamo utilizzare questi numeri di indice all'interno di una parentesi quadra. Ad esempio, osservare il codice seguente:
>>> mixed_list = ['This', 9, 'is', 18, 45.9, 'a', 54, 'mixed', 99, 'list']
>>>
>>> # To access the First Item of the list
>>> mixed_list[0]
'This'
>>> # To access the 4th item
>>> mixed_list[3]
18
>>> # To access the last item of the list
>>> mixed_list[-1]
'list'Oggetti vuoti
Gli oggetti vuoti sono i tipi integrati di Python più semplici e basilari. Li abbiamo usati più volte senza accorgercene e li abbiamo estesi a tutte le classi che abbiamo creato. Lo scopo principale di scrivere una classe vuota è bloccare qualcosa per il momento e successivamente estenderlo e aggiungervi un comportamento.
Aggiungere un comportamento a una classe significa sostituire una struttura dati con un oggetto e modificare tutti i riferimenti ad esso. Quindi è importante controllare i dati, se si tratta di un oggetto sotto mentite spoglie, prima di creare qualsiasi cosa. Osservare il codice seguente per una migliore comprensione:
>>> #Empty objects
>>>
>>> obj = object()
>>> obj.x = 9
Traceback (most recent call last):
File "<pyshell#3>", line 1, in <module>
obj.x = 9
AttributeError: 'object' object has no attribute 'x'Quindi dall'alto, possiamo vedere che non è possibile impostare alcun attributo su un oggetto che è stato istanziato direttamente. Quando Python consente a un oggetto di avere attributi arbitrari, ci vuole una certa quantità di memoria di sistema per tenere traccia di quali attributi ha ogni oggetto, per memorizzare sia il nome dell'attributo che il suo valore. Anche se non vengono memorizzati attributi, una certa quantità di memoria viene allocata per potenziali nuovi attributi.
Quindi Python disabilita le proprietà arbitrarie sull'oggetto e molti altri integrati, per impostazione predefinita.
>>> # Empty Objects
>>>
>>> class EmpObject:
pass
>>> obj = EmpObject()
>>> obj.x = 'Hello, World!'
>>> obj.x
'Hello, World!'Quindi, se vogliamo raggruppare le proprietà insieme, potremmo memorizzarle in un oggetto vuoto come mostrato nel codice sopra. Tuttavia, questo metodo non è sempre suggerito. Ricorda che le classi e gli oggetti dovrebbero essere usati solo quando vuoi specificare sia dati che comportamenti.
Tuple
Le tuple sono simili agli elenchi e possono memorizzare elementi. Tuttavia, sono immutabili, quindi non possiamo aggiungere, rimuovere o sostituire oggetti. I vantaggi principali che la tupla fornisce a causa della sua immutabilità è che possiamo usarli come chiavi nei dizionari o in altre posizioni in cui un oggetto richiede un valore hash.
Le tuple vengono utilizzate per memorizzare i dati e non il comportamento. Nel caso in cui sia necessario un comportamento per manipolare una tupla, è necessario passare la tupla a una funzione (o metodo su un altro oggetto) che esegue l'azione.
Poiché la tupla può agire come una chiave del dizionario, i valori memorizzati sono diversi l'uno dall'altro. Possiamo creare una tupla separando i valori con una virgola. Le tuple sono racchiuse tra parentesi ma non obbligatorie. Il codice seguente mostra due assegnazioni identiche.
>>> stock1 = 'MSFT', 95.00, 97.45, 92.45
>>> stock2 = ('MSFT', 95.00, 97.45, 92.45)
>>> type (stock1)
<class 'tuple'>
>>> type(stock2)
<class 'tuple'>
>>> stock1 == stock2
True
>>>Definizione di una tupla
Le tuple sono molto simili a list tranne per il fatto che l'intero insieme di elementi è racchiuso tra parentesi invece che tra parentesi quadre.
Proprio come quando si divide una lista, si ottiene una nuova lista e quando si divide una tupla, si ottiene una nuova tupla.
>>> tupl = ('Tuple','is', 'an','IMMUTABLE', 'list')
>>> tupl
('Tuple', 'is', 'an', 'IMMUTABLE', 'list')
>>> tupl[0]
'Tuple'
>>> tupl[-1]
'list'
>>> tupl[1:3]
('is', 'an')Metodi di tupla Python
Il codice seguente mostra i metodi nelle tuple Python:
>>> tupl
('Tuple', 'is', 'an', 'IMMUTABLE', 'list')
>>> tupl.append('new')
Traceback (most recent call last):
File "<pyshell#148>", line 1, in <module>
tupl.append('new')
AttributeError: 'tuple' object has no attribute 'append'
>>> tupl.remove('is')
Traceback (most recent call last):
File "<pyshell#149>", line 1, in <module>
tupl.remove('is')
AttributeError: 'tuple' object has no attribute 'remove'
>>> tupl.index('list')
4
>>> tupl.index('new')
Traceback (most recent call last):
File "<pyshell#151>", line 1, in <module>
tupl.index('new')
ValueError: tuple.index(x): x not in tuple
>>> "is" in tupl
True
>>> tupl.count('is')
1Dal codice mostrato sopra, possiamo capire che le tuple sono immutabili e quindi -
tu cannot aggiungere elementi a una tupla.
tu cannot aggiungere o estendere un metodo.
tu cannot rimuove gli elementi da una tupla.
Le tuple hanno no metodo di rimozione o pop.
Count e index sono i metodi disponibili in una tupla.
Dizionario
Il dizionario è uno dei tipi di dati incorporati in Python e definisce le relazioni uno a uno tra chiavi e valori.
Definizione di dizionari
Osservare il codice seguente per comprendere come definire un dizionario:
>>> # empty dictionary
>>> my_dict = {}
>>>
>>> # dictionary with integer keys
>>> my_dict = { 1:'msft', 2: 'IT'}
>>>
>>> # dictionary with mixed keys
>>> my_dict = {'name': 'Aarav', 1: [ 2, 4, 10]}
>>>
>>> # using built-in function dict()
>>> my_dict = dict({1:'msft', 2:'IT'})
>>>
>>> # From sequence having each item as a pair
>>> my_dict = dict([(1,'msft'), (2,'IT')])
>>>
>>> # Accessing elements of a dictionary
>>> my_dict[1]
'msft'
>>> my_dict[2]
'IT'
>>> my_dict['IT']
Traceback (most recent call last):
File "<pyshell#177>", line 1, in <module>
my_dict['IT']
KeyError: 'IT'
>>>Dal codice sopra possiamo osservare che:
Per prima cosa creiamo un dizionario con due elementi e lo assegniamo alla variabile my_dict. Ogni elemento è una coppia chiave-valore e l'intero set di elementi è racchiuso tra parentesi graffe.
Il numero 1 è la chiave e msftè il suo valore. Allo stesso modo,2 è la chiave e IT è il suo valore.
Puoi ottenere valori per chiave, ma non viceversa. Così quando ci proviamomy_dict[‘IT’] , solleva un'eccezione, perché IT non è una chiave.
Modifica dei dizionari
Osservare il codice seguente per comprendere come modificare un dizionario:
>>> # Modifying a Dictionary
>>>
>>> my_dict
{1: 'msft', 2: 'IT'}
>>> my_dict[2] = 'Software'
>>> my_dict
{1: 'msft', 2: 'Software'}
>>>
>>> my_dict[3] = 'Microsoft Technologies'
>>> my_dict
{1: 'msft', 2: 'Software', 3: 'Microsoft Technologies'}Dal codice sopra possiamo osservare che -
Non puoi avere chiavi duplicate in un dizionario. La modifica del valore di una chiave esistente eliminerà il vecchio valore.
Puoi aggiungere nuove coppie chiave-valore in qualsiasi momento.
I dizionari non hanno il concetto di ordine tra gli elementi. Sono semplici raccolte non ordinate.
Combinazione di tipi di dati in un dizionario
Osservare il codice seguente per comprendere come combinare i tipi di dati in un dizionario:
>>> # Mixing Data Types in a Dictionary
>>>
>>> my_dict
{1: 'msft', 2: 'Software', 3: 'Microsoft Technologies'}
>>> my_dict[4] = 'Operating System'
>>> my_dict
{1: 'msft', 2: 'Software', 3: 'Microsoft Technologies', 4: 'Operating System'}
>>> my_dict['Bill Gates'] = 'Owner'
>>> my_dict
{1: 'msft', 2: 'Software', 3: 'Microsoft Technologies', 4: 'Operating System',
'Bill Gates': 'Owner'}Dal codice sopra possiamo osservare che -
Non solo stringhe, ma il valore del dizionario può essere di qualsiasi tipo di dati, comprese stringhe, numeri interi, incluso il dizionario stesso.
A differenza dei valori del dizionario, le chiavi del dizionario sono più limitate, ma possono essere di qualsiasi tipo come stringhe, numeri interi o qualsiasi altro.
Eliminazione di elementi dai dizionari
Per informazioni sull'eliminazione di elementi da un dizionario, osservare il codice seguente:
>>> # Deleting Items from a Dictionary
>>>
>>> my_dict
{1: 'msft', 2: 'Software', 3: 'Microsoft Technologies', 4: 'Operating System',
'Bill Gates': 'Owner'}
>>>
>>> del my_dict['Bill Gates']
>>> my_dict
{1: 'msft', 2: 'Software', 3: 'Microsoft Technologies', 4: 'Operating System'}
>>>
>>> my_dict.clear()
>>> my_dict
{}Dal codice sopra possiamo osservare che -
del - consente di eliminare singoli elementi da un dizionario tramite chiave.
clear - elimina tutti gli elementi da un dizionario.
Imposta
Set () è una raccolta non ordinata senza elementi duplicati. Sebbene i singoli elementi siano immutabili, il set stesso è mutabile, ovvero possiamo aggiungere o rimuovere elementi / elementi dal set. Possiamo eseguire operazioni matematiche come unione, intersezione ecc. Con set.
Sebbene i set in generale possano essere implementati usando gli alberi, i set in Python possono essere implementati usando una tabella hash. Ciò consente un metodo altamente ottimizzato per verificare se un elemento specifico è contenuto nel set
Creare un set
Un set viene creato inserendo tutti gli elementi (elementi) all'interno di parentesi graffe {}, separati da virgola o utilizzando la funzione incorporata set(). Rispettare le seguenti righe di codice:
>>> #set of integers
>>> my_set = {1,2,4,8}
>>> print(my_set)
{8, 1, 2, 4}
>>>
>>> #set of mixed datatypes
>>> my_set = {1.0, "Hello World!", (2, 4, 6)}
>>> print(my_set)
{1.0, (2, 4, 6), 'Hello World!'}
>>>Metodi per insiemi
Osservare il codice seguente per comprendere i metodi per gli insiemi:
>>> >>> #METHODS FOR SETS
>>>
>>> #add(x) Method
>>> topics = {'Python', 'Java', 'C#'}
>>> topics.add('C++')
>>> topics
{'C#', 'C++', 'Java', 'Python'}
>>>
>>> #union(s) Method, returns a union of two set.
>>> topics
{'C#', 'C++', 'Java', 'Python'}
>>> team = {'Developer', 'Content Writer', 'Editor','Tester'}
>>> group = topics.union(team)
>>> group
{'Tester', 'C#', 'Python', 'Editor', 'Developer', 'C++', 'Java', 'Content
Writer'}
>>> # intersets(s) method, returns an intersection of two sets
>>> inters = topics.intersection(team)
>>> inters
set()
>>>
>>> # difference(s) Method, returns a set containing all the elements of
invoking set but not of the second set.
>>>
>>> safe = topics.difference(team)
>>> safe
{'Python', 'C++', 'Java', 'C#'}
>>>
>>> diff = topics.difference(group)
>>> diff
set()
>>> #clear() Method, Empties the whole set.
>>> group.clear()
>>> group
set()
>>>Operatori per insiemi
Osservare il codice seguente per comprendere gli operatori per gli insiemi:
>>> # PYTHON SET OPERATIONS
>>>
>>> #Creating two sets
>>> set1 = set()
>>> set2 = set()
>>>
>>> # Adding elements to set
>>> for i in range(1,5):
set1.add(i)
>>> for j in range(4,9):
set2.add(j)
>>> set1
{1, 2, 3, 4}
>>> set2
{4, 5, 6, 7, 8}
>>>
>>> #Union of set1 and set2
>>> set3 = set1 | set2 # same as set1.union(set2)
>>> print('Union of set1 & set2: set3 = ', set3)
Union of set1 & set2: set3 = {1, 2, 3, 4, 5, 6, 7, 8}
>>>
>>> #Intersection of set1 & set2
>>> set4 = set1 & set2 # same as set1.intersection(set2)
>>> print('Intersection of set1 and set2: set4 = ', set4)
Intersection of set1 and set2: set4 = {4}
>>>
>>> # Checking relation between set3 and set4
>>> if set3 > set4: # set3.issuperset(set4)
print('Set3 is superset of set4')
elif set3 < set4: #set3.issubset(set4)
print('Set3 is subset of set4')
else: #set3 == set4
print('Set 3 is same as set4')
Set3 is superset of set4
>>>
>>> # Difference between set3 and set4
>>> set5 = set3 - set4
>>> print('Elements in set3 and not in set4: set5 = ', set5)
Elements in set3 and not in set4: set5 = {1, 2, 3, 5, 6, 7, 8}
>>>
>>> # Check if set4 and set5 are disjoint sets
>>> if set4.isdisjoint(set5):
print('Set4 and set5 have nothing in common\n')
Set4 and set5 have nothing in common
>>> # Removing all the values of set5
>>> set5.clear()
>>> set5 set()