Wyszukiwanie w witrynie

Naucz się struktury danych list w języku Python — część 1

Struktura danych to zbiór typów danych, relacji między nimi oraz funkcji i operacji, które można zastosować na danych. Typ danych może to ciąg, liczba całkowita, wartość zmiennoprzecinkowa i tak dalej.

Jaka jest różnica między obiektem zmiennym/niezmiennym?
Zmienne obiekty
  1. Obiekty, których stan można zmienić po utworzeniu, np. dodając, aktualizując lub usuwając elementy.
  2. Listy, słownik, zestaw, bytearray to zmienne typy obiektów w Pythonie.
Niezmienne obiekty
  1. Nie można modyfikować stanu obiektu. Po utworzeniu obiektu nie możemy dodawać, usuwać ani aktualizować elementów.
  2. String, Integer, Tuples, Frozenset to tylko niektóre z niezmiennych typów obiektów w Pythonie.
Jaka jest różnica między jednorodną/heterogeniczną strukturą danych?
  1. Jednorodna struktura danych – elementy danych będą tego samego typu danych (np. Array).
  2. Heterogeniczna struktura danych – elementy danych nie mogą należeć do tego samego typu danych (np. lista, krotki, zestawy itp.).
Jakie są typy danych prymitywne i nieprymitywne?

Zanim zrozumiemy funkcjonalność wbudowanej struktury danych, przyjrzyjmy się kilku wbudowanym funkcjom, które będą używane z obiektami struktury danych.

  • dir(obj) – wbudowana funkcja, która zwróci atrybut i metody.
  • len(obj) – Zwraca długość (liczbę elementów) obiektu. Argumentem może być sekwencja (taka jak ciąg znaków, bajty, krotka, lista lub zakres) lub kolekcja (taka jak słownik, zestaw lub zestaw zamrożony).
  • del – to wbudowane słowo kluczowe służy do usuwania obiektu z przestrzeni nazw lub usuwania elementów z obiektu, takiego jak lista, słownik itp.
  • type(obj) – funkcja type() albo zwraca typ obiektu, albo zwraca obiekt nowego typu na podstawie przekazanych argumentów.
  • id() – ta funkcja zwraca „tożsamość” obiektu. Jest to liczba całkowita, która gwarantuje, że będzie unikalna i stała dla tego obiektu przez cały okres jego istnienia.

Teraz, gdy poznałeś już kilka ważnych szczegółów, przejdźmy do struktur danych Pythona.

Python ma wbudowane struktury danych, a użytkownicy mogą definiować własne struktury danych. Wbudowana struktura danych obejmuje LIST, DICTIONARY, TUPLE i SET. Niektóre przykłady struktur danych zdefiniowanych przez użytkownika to STACK, QUEUES, TREE, HASHMAP itp.

Osoby znające inne języki programowania będą bardzo dobrze zaznajomione z typem tablicy. Ale w Pythonie nie są one tak powszechne.

Tutaj lista jest podobna do tablicy, ale pozwala nam przechowywać wartości dowolnego typu danych (heterogeniczne), podczas gdy tablica będzie przechowywać tylko dane określonego typu (int, float itp.). Aby użyć tablicy, musisz jawnie zaimportować tablicę z modułu „array”.

W tej serii artykułów na temat Pythona przyjrzymy się, czym jest struktura danych i wbudowana struktura danych w Pythonie.

LISTA

Lista to struktura danych będąca zbiorem różnych typów danych. Co oznacza „gromadzenie różnych typów danych”? Lista może przechowywać ciągi znaków, liczby całkowite, wartości zmiennoprzecinkowe, listę zagnieżdżoną i tak dalej.

Obiekty Listy są „Modyfikowalne”, co oznacza, że do elementów utworzonych na liście można uzyskać dostęp, modyfikować je lub usuwać. Indeksowanie obsługi list. Każda pozycja na listach jest przypisana do adresu, którego można użyć do uzyskania dostępu do określonej wartości pozycji lub jej modyfikacji.

  • Stwórz listę
  • Wstaw/Uzyskaj dostęp/Modyfikuj listę
  • Usuń listę

SPORZĄDZAĆ LISTĘ

Listę można utworzyć za pomocą nawiasów kwadratowych.

>>> name_empty = []			# Empty list
>>> name = ['Karthi', 'Leo', 'Matt', 'Kane', 'Scott', 'Petter', 'Will']	# list with string data type
>>> name_int = [1,2,3]			# list with Integer data type
>>> name_mixed = [name_int,name,1,2,3.14]	# list with nested list items.
>>> name_mixed
[[1, 2, 3], ['Karthi', 'Leo', 'Matt', 'Kane', 'Scott', 'Petter', 'Will'], 1, 2, 3.14]
>>> name_int
[1, 2, 3]

Do sprawdzenia typu obiektu możemy wykorzystać wbudowaną funkcję type().

>>> type(name)

Dostęp do metod i atrybutów instancji list możemy uzyskać za pomocą funkcji dir().

>>> dir(name)
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

Całkowitą liczbę pozycji na liście możemy sprawdzić metodą len().

>>> len(name)

Nową listę możemy utworzyć na podstawie już istniejącej, korzystając z metody list.copy().

>>> name_new = name.copy()
>>> name_new
['Karthi', 'Leo', 'Matt', 'Kane', 'Scott', 'Petter', 'Will']

WSTAWIANIE/DOSTĘP/MODYFIKACJA LISTY

Pozycję na listę możemy wstawić w dowolnej pozycji za pomocą metody list.insert(i, x).

>>> name = ['Leo','Matt','Kane','Scott','Petter','Will']
>>> name
['Leo', 'Matt', 'Kane', 'Scott', 'Petter', 'Will']
>>> name.insert(0,'Tom')	# Insert method takes 2 arguments (Index position, Item)
>>> name
['Tom', 'Leo', 'Matt', 'Kane', 'Scott', 'Petter', 'Will']	# Tom is inserted at the 0th position.

Możemy użyć metody list.append(x), aby dodać pojedynczy element do listy. Spowoduje to wstawienie elementu na koniec listy.

>>> name = []
>>> len(name)
0
>>> name.append('Leo')
>>> name.append('Matt')
>>> name.append('Kane')
>>> print(name)
['Leo', 'Matt', 'Kane']

Możemy użyć metody list.extend(), aby dodać wiele pozycji do listy.

>>> new_name = ['Gowtham','Martin','Luis']
>>> name.extend(new_name)
>>> name
['Will', 'Petter', 'Scott', 'Kane', 'Matt', 'Leo', 'Karthi', 'Will', 'Gowtham', 'Martin', 'Luis']

Możemy także użyć operatora '+', aby połączyć dwie listy. Obie listy mogą mieć różne typy danych.

>>> a = [1,2,3]
>>> b = [2,3,3]
>>> c = a + b
>>> c
[1, 2, 3, 2, 3, 3]
>>> d = ['karthi','kenny']
>>> e = a + d
>>> e
[1, 2, 3, 'karthi', 'kenny']

Jak już wspomniano, obiekty list są modyfikowalne. Element listy można modyfikować, odwołując się do pozycji indeksu i przypisując jej wartość.

>>> name									# Before modified
['Tom', 'Leo', 'Matt', 'Kane', 'Scott', 'Petter', 'Will']
>>> name[0] = 'Karthi'
>>> name									# After Modified
['Karthi', 'Leo', 'Matt', 'Kane', 'Scott', 'Petter', 'Will']

Lista obsługuje indeksowanie zarówno pozytywne, jak i negatywne.

Indeksowanie rozpoczyna się od 0, a indeksowanie ujemne zaczyna się od -1.

Dostęp do elementu listy możemy uzyskać, korzystając z jego pozycji w indeksie.

>>> name[0]			# Accessing the List item at index 0
'Leo'
>>> name[1]
'Matt'
>>> name[4]
'Petter'
>>> name[5]
'Will'
>>> name[-1]			# Accessing the list item with negative indexing
'Will'
>>> name[-6]
'Leo'

Możemy również użyć krojenia, aby uzyskać dostęp do elementów na liście. Krojenie pozwala nam uzyskać dostęp do szeregu elementów poprzez zdefiniowanie parametrów początkowych, końcowych i kroków.

SYNTAX: list[starting position, ending position, Step]

>>> name[0:3]
['Tom', 'Leo', 'Matt']
>>> name[:]
['Tom', 'Leo', 'Matt', 'Kane', 'Scott', 'Petter', 'Will']
>>> name[:4]
['Tom', 'Leo', 'Matt', 'Kane']
>>> name[:-2]
['Tom', 'Leo', 'Matt', 'Kane', 'Scott']
>>> name[:-1]
['Tom', 'Leo', 'Matt', 'Kane', 'Scott', 'Petter']
>>> name[:-1:2]
['Tom', 'Matt', 'Scott']

Liczbę wystąpień danej wartości możemy znaleźć za pomocą metody list.count(x).

>>> name_int = [1,1,2,3,1]
>>> name_int.count(1)
3

Pozycję Index danego elementu możemy znaleźć za pomocą metody list.index(x[, start[, end]]).

>>> name			# Inserted ‘Will’ at the end of the list. Now we have 2 name ‘Will’.
['Will', 'Petter', 'Scott', 'Kane', 'Matt', 'Leo', 'Karthi', 'Will']
>>> name.index('Will)	# Returns the index position of first occurence of x.
0
>>> name.index('Will',2)	# Starting index positon’2’ is given.
7
>>> name.index('Will',2,4)	# Starting and Ending Index position is given. Since there is no 					occurence of ‘Will’ within the given search position it will throw 					Value Error.
Traceback (most recent call last):
File "<stdin>", line 1, in 
ValueError: 'Will' is not in list

Możemy użyć metody list.reverse(), aby odwrócić pozycje na liście.

>>> name
['Karthi', 'Leo', 'Matt', 'Kane', 'Scott', 'Petter', 'Will']
>>> name.reverse()
>>> name
['Will', 'Petter', 'Scott', 'Kane', 'Matt', 'Leo', 'Karthi']

USUŃ LISTĘ

Możemy użyć metody list.pop(x), aby usunąć element z listy na pozycji x. Funkcja ta usunie pozycję z listy i wyświetli usuniętą pozycję. Jeśli nie określono x, to metoda pop() zwróci ostatnią pozycję z listy.

>>> name
['Will', 'Petter', 'Scott', 'Kane', 'Matt', 'Leo', 'Karthi', 'Will', 'Gowtham', 'Martin', 'Luis']
>>> name.pop(0)
'Will'
>>> name
['Petter', 'Scott', 'Kane', 'Matt', 'Leo', 'Karthi', 'Will', 'Gowtham', 'Martin', 'Luis']
>>> name.pop()
'Luis'

Do usunięcia pozycji z listy możemy także użyć metody list.remove (x). Tutaj x pobiera wartość elementu i zgłasza ValueError, jeśli x nie znajduje się na liście.

>>> name = ['Leo','Matt','Kane','Scott','Petter','Will']
>>> name.remove('Leo')
>>> name
['Matt', 'Kane', 'Scott', 'Petter', 'Will']
>>> name.remove('Leo')
Traceback (most recent call last):
  File "", line 1, in 
ValueError: list.remove(x): x not in list

Możemy sprawić, że lista będzie pusta, przypisując jej nazwę w nawiasach kwadratowych lub używając metody list.clear().

>>> name1 = name.copy()
>>> name1
['Petter', 'Scott', 'Kane', 'Matt', 'Leo', 'Karthi', 'Will', 'Gowtham', 'Martin']
>>> name
['Petter', 'Scott', 'Kane', 'Matt', 'Leo', 'Karthi', 'Will', 'Gowtham', 'Martin']
>>> name = []			
>>> name
[]
>>> name1.clear()		
>>> name1
[]

Zamiast używać metod listowych do opróżnienia listy lub usunięcia elementu z listy, możemy użyć wbudowanego słowa kluczowego del, aby wykonać tę akcję. Słowo kluczowe „del” może usunąć obiekt listy z pamięci, usunąć element z listy lub usunąć element z wycinka.

>>> name = ['Leo','Matt','Kane','Scott','Petter','Will']
>>> del name[0]
>>> name
['Matt', 'Kane', 'Scott', 'Petter', 'Will']
>>> del name[-3:]
>>> name
['Matt', 'Kane']
>>> del name[:]
>>> name
[]

Wbudowana funkcja id() zwraca „tożsamość” obiektu. Jest to liczba całkowita, która gwarantuje, że będzie unikalna i stała dla tego obiektu przez cały okres jego istnienia.

>>> id(name)
139979929658824
>>> del name
>>> id(name)
Traceback (most recent call last):
  File "", line 1, in 
NameError: name 'name' is not defined

Uwaga: usunęliśmy zmienną listy z pamięci za pomocą funkcji del(), dlatego zgłasza ona błąd nazwy.

help() funtion:

Wbudowana pomoc function() jest bardzo przydatna do uzyskania szczegółowych informacji na temat konkretnego obiektu lub metod tego obiektu.

help(object)
help(object.method)
Streszczenie

Do tej pory w tym artykule widzieliśmy, jak możemy używać listowej struktury danych do przechowywania, uzyskiwania dostępu, modyfikowania i usuwania obiektów list za pomocą metod list. Widzieliśmy także kilka wbudowanych funkcji, takich jak id(), dir(), type(), help()<, które są bardzo efektywnymi funkcjami. Mamy również funkcję rozumienia list w Pythonie, która zapewnia bardziej zwięzły i czytelny sposób tworzenia listy.