Python zorientowany obiektowo - struktury danych
Struktury danych w Pythonie są bardzo intuicyjne z punktu widzenia składni i oferują duży wybór operacji. Musisz wybrać strukturę danych Pythona w zależności od tego, czego dotyczą dane, czy wymagają modyfikacji, czy są to dane stałe i wymagany typ dostępu, np. Na początku / końcu / losowy itp.
Listy
Lista reprezentuje najbardziej wszechstronny typ struktury danych w Pythonie. Lista jest kontenerem zawierającym wartości oddzielone przecinkami (elementy lub elementy) między nawiasami kwadratowymi. Listy są pomocne, gdy chcemy pracować z wieloma powiązanymi wartościami. Ponieważ listy przechowują dane razem, możemy wykonywać te same metody i operacje na wielu wartościach jednocześnie. Indeksy list zaczynają się od zera iw przeciwieństwie do łańcuchów, listy są zmienne.
Struktura danych - lista
>>>
>>> # 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']Dostęp do elementów na liście Pythona
Każda pozycja listy ma przypisany numer - czyli indeks lub pozycję tego numeru. Indeksowanie zawsze zaczyna się od zera, drugi indeks to jedynka i tak dalej. Aby uzyskać dostęp do elementów listy, możemy użyć tych numerów indeksu w nawiasach kwadratowych. Obserwuj następujący kod, na przykład -
>>> 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'Puste obiekty
Puste obiekty to najprostsze i najbardziej podstawowe typy wbudowane w Pythonie. Używaliśmy ich wielokrotnie, nie zauważając, i rozszerzyliśmy je na każdą utworzoną przez nas klasę. Głównym celem napisania pustej klasy jest zablokowanie czegoś na jakiś czas, a następnie rozszerzenie i dodanie do tego zachowania.
Dodanie zachowania do klasy oznacza zastąpienie struktury danych obiektem i zmianę wszystkich odniesień do niego. Dlatego ważne jest, aby sprawdzić dane, czy są to zamaskowany obiekt, zanim cokolwiek stworzysz. Obserwuj następujący kod, aby lepiej zrozumieć:
>>> #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'Więc z góry widzimy, że nie można ustawić żadnych atrybutów na obiekcie, który został utworzony bezpośrednio. Gdy Python pozwala obiektowi na posiadanie dowolnych atrybutów, potrzeba pewnej ilości pamięci systemowej, aby śledzić, jakie atrybuty ma każdy obiekt, do przechowywania zarówno nazwy atrybutu, jak i jego wartości. Nawet jeśli nie są przechowywane żadne atrybuty, pewna ilość pamięci jest przydzielana na potencjalne nowe atrybuty.
Dlatego Python domyślnie wyłącza dowolne właściwości obiektu i kilka innych funkcji wbudowanych.
>>> # Empty Objects
>>>
>>> class EmpObject:
pass
>>> obj = EmpObject()
>>> obj.x = 'Hello, World!'
>>> obj.x
'Hello, World!'Dlatego, jeśli chcemy zgrupować właściwości razem, moglibyśmy przechowywać je w pustym obiekcie, jak pokazano w powyższym kodzie. Jednak ta metoda nie zawsze jest sugerowana. Pamiętaj, że klas i obiektów należy używać tylko wtedy, gdy chcesz określić zarówno dane, jak i zachowania.
Krotki
Krotki są podobne do list i mogą przechowywać elementy. Są jednak niezmienne, więc nie możemy dodawać, usuwać ani zastępować obiektów. Podstawowe korzyści, jakie krotka zapewnia ze względu na swoją niezmienność, to fakt, że możemy ich używać jako kluczy w słownikach lub w innych miejscach, w których obiekt wymaga wartości skrótu.
Krotki służą do przechowywania danych, a nie zachowania. Jeśli potrzebujesz zachowania do manipulowania krotką, musisz przekazać krotkę do funkcji (lub metody na innym obiekcie), która wykonuje akcję.
Ponieważ krotka może działać jako klucz słownikowy, przechowywane wartości różnią się od siebie. Możemy utworzyć krotkę, oddzielając wartości przecinkami. Krotki są umieszczone w nawiasach, ale nie są obowiązkowe. Poniższy kod przedstawia dwa identyczne przypisania.
>>> 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
>>>Definiowanie krotki
Krotki są bardzo podobne do list, z tym wyjątkiem, że cały zestaw elementów jest ujęty w nawiasy zamiast w kwadratowe.
Tak jak w przypadku wycinania listy, otrzymujesz nową listę, a gdy dzielisz krotkę, otrzymujesz nową krotkę.
>>> tupl = ('Tuple','is', 'an','IMMUTABLE', 'list')
>>> tupl
('Tuple', 'is', 'an', 'IMMUTABLE', 'list')
>>> tupl[0]
'Tuple'
>>> tupl[-1]
'list'
>>> tupl[1:3]
('is', 'an')Metody krotki w Pythonie
Poniższy kod przedstawia metody w krotkach Pythona -
>>> 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')
1Z powyższego kodu możemy zrozumieć, że krotki są niezmienne, a zatem -
ty cannot dodać elementy do krotki.
ty cannot dołączyć lub rozszerzyć metodę.
ty cannot usunąć elementy z krotki.
Krotki mają no usuń lub wyskocz metodę.
Count i index to metody dostępne w krotce.
Słownik
Słownik jest jednym z wbudowanych typów danych Pythona i definiuje relacje jeden do jednego między kluczami a wartościami.
Definiowanie słowników
Obserwuj poniższy kod, aby zrozumieć, jak definiować słownik -
>>> # 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'
>>>Z powyższego kodu możemy zauważyć, że:
Najpierw tworzymy słownik z dwoma elementami i przypisujemy go do zmiennej my_dict. Każdy element jest parą klucz-wartość, a cały zestaw elementów jest ujęty w nawiasy klamrowe.
Numer 1 jest kluczem i msftjest jego wartością. Podobnie,2 jest kluczem i IT jest jego wartością.
Możesz uzyskać wartości według klucza, ale nie odwrotnie. Tak więc, kiedy próbujemymy_dict[‘IT’] , zgłasza wyjątek, ponieważ IT nie jest kluczem.
Modyfikowanie słowników
Obserwuj poniższy kod, aby zrozumieć, jak modyfikować słownik -
>>> # 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'}Z powyższego kodu możemy zauważyć, że -
Nie możesz mieć zduplikowanych kluczy w słowniku. Zmiana wartości istniejącego klucza spowoduje usunięcie starej wartości.
W dowolnym momencie możesz dodać nowe pary klucz-wartość.
Słowniki nie mają koncepcji porządku między elementami. Są to proste kolekcje nieuporządkowane.
Mieszanie typów danych w słowniku
Obserwuj poniższy kod, aby zrozumieć, jak mieszać typy danych w słowniku -
>>> # 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'}Z powyższego kodu możemy zauważyć, że -
Nie tylko łańcuchy, ale wartość słownika może mieć dowolny typ danych, w tym łańcuchy, liczby całkowite, w tym sam słownik.
W przeciwieństwie do wartości słownikowych, klucze słownika są bardziej ograniczone, ale mogą być dowolnego typu, na przykład łańcuchami, liczbami całkowitymi lub innymi.
Usuwanie elementów ze słowników
Obserwuj poniższy kod, aby dowiedzieć się, jak usuwać elementy ze słownika -
>>> # 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
{}Z powyższego kodu możemy zauważyć, że -
del - umożliwia usuwanie pojedynczych pozycji ze słownika za pomocą klawisza.
clear - usuwa wszystkie pozycje ze słownika.
Zestawy
Set () to nieuporządkowana kolekcja bez zduplikowanych elementów. Chociaż poszczególne elementy są niezmienne, sam zestaw jest zmienny, czyli możemy dodawać lub usuwać elementy / przedmioty z zestawu. Możemy wykonywać operacje matematyczne, takie jak suma, przecięcie itp. Ze zbiorem.
Chociaż ogólnie zestawy można zaimplementować za pomocą drzew, ustawione w Pythonie można zaimplementować za pomocą tabeli skrótów. Pozwala to na wysoce zoptymalizowaną metodę sprawdzania, czy określony element znajduje się w zestawie
Tworzenie zestawu
Zestaw tworzy się poprzez umieszczenie wszystkich elementów (elementów) w nawiasach klamrowych {}, oddzielone przecinkiem lub za pomocą funkcji wbudowanej set(). Obserwuj następujące wiersze kodu -
>>> #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!'}
>>>Metody dla zestawów
Obserwuj poniższy kod, aby zrozumieć metody dla zestawów -
>>> >>> #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()
>>>Operatory zbiorów
Obserwuj poniższy kod, aby zrozumieć operatory dla zestawów -
>>> # 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()