Instalowanie Pythona
Podstawowym sposobem zainstalowania Pythona na komputerze jest odwiedzenie oficjalnej
strony Python www.python.org i pobieranie odpowiedniej wersji. Instalacja może być sprawdzona
w wierszu poleceń w Windows, wpisujemy: python - -version.
Napiszmy pierwszy kod Python za pomocą wiersza poleceń
W konsoli wpisujemy python, aby wystartować z możliwością pisania kodu i wpisujemy
następujący kod:
Print ('Hello World')
i naciśnij enter.
Właśnie napisaliśmy nasz pierwszy program w języku Python, wyświetlając komunikat za pomocą
Funkcji drukowania w języku Python.
Oczywiście do pisania większych programów użyjemy środowiska IDE. Preferowanym
rozszerzeniem plików Python jest „.py”, np. Hello_world.py i można go uruchomić z konsoli,
wpisując pełną ścieżkę do pliku w oknie poleceń.
Na przykład, jeśli zapisaliśmy nasz program Hello_world na pulpicie. Ścieżka do pliku może być:
C: \ Users \ nazwa_komputera \ Desktop \ Hello_World.py. Aby uruchomić nasz program:
Po prostu otwórz okno poleceń i wpisz „ścieżkę do pliku”.
Można pisać skrypty Pythona za pomocą notatnika: utwórz plik tekstowy notatnika >> Po otwarciu
wpisz swój kod Python w pliku >> Zapisz jako >> wybierz lokalizację zapisu swojego kodu >> W
„Nazwa pliku”, nazwij plik z rozszerzeniem „.py”, np. program.py i Zapisz.
Możesz także przeciągać i upuszczać ten plik do okna poleceń i uruchomiać go, naciskając enter.
Ćwiczenie: spróbuj napisać programy do wyświetlania tekstu przy użyciu funkcji
drukowania opisane w powyższym przykładzie.
Anaconda Navigator
Jest to graficzny interfejs użytkownika do uruchamiania Pythona i jest on specjalnie
zoptymalizowany do data science za pomocą Pythona. Ułatwia on zarządzanie pakietami i
bibliotekami Python dla data science. Jest to część dystrybucji Anaconda, która jest dostarczana
z wersją Pythona (najnowsza Anaconda - Python 3.7, maj 2019), tj. Jeśli nie masz
zainstalowanego Pythona, Anaconda zainstaluje wersję Pythona na komputerze.
Najważniejszą zaletą korzystania z anakondy są funkcje „kliknij, aby uruchomić” oferuje ona
uruchomienie dowolnego pakietu zainstalowanego na jej ścieżce dostępu. Łatwe jest również
tworzenie wirtualnych środowisk do instalowania i uruchamiania różnych wersji Python i innych
programów do analizy danych, takich jak „R”. Środowiska wirtualne to ścieżki (lub foldery)
specyficzne dla niektórych aplikacji lub pakietów w systemie operacyjnym.
Anaconda jest również wyposażona w interaktywne IDE (zintegrowane środowisko
programowania) do uruchamiania kodu w języku Python. Spyder IDE, wykorzystuje interfejs
konsoli i skryptu; notatnik Jupyter, który uruchamia interaktywną konsolę Python i graficzny
interfejs użytkownika w przeglądarce; Jupyter Lab itp. Będziemy używać notatnika Jupyter do
programowania w języku Python.
Aby zainstalować anaconda navigator, przejdź do strony www.anaconda.com/downloads i
pobierz najnowszą wersję dystrybucji anakondy.
Otwórz notatnik Jupyter, klikając przycisk Uruchom-Launch za pomocą nawigatora anakonda,
lub otwórz konsolę anakondy i wpisz: Jupyter notebook. Po otwarciu Jupytera kliknij New >>, a
następnie, kliknij python 3 / python [default].
Otworzy się edytor Python, w którym możemy pisać i wykonywać kod w czasie rzeczywistym.
Pliki Jupyter notebook są zapisywane jako „. ipynb ” i można uzyskać do nich dostęp / otworzyć przeglądając
lokalizację plików za pomocą strony eksploratora Jupyter Notebook. Jupyter obsługuje także Markdown i
inne funkcje kodowania na żywo, które to umożliwiają łatwe adnotowanie kod.
Instrukcje, polecenia i wyrażenia
Języki programowania wysokiego poziomu nie różnią się tak bardzo od języka ludzkiego. Kierują
się określonym wzorem i zasadą. Gdy ta reguła zostanie pominięta, daje błąd. W języku nazywa
się to błędem gramatycznym; w programowaniu nazywa się to błędem składni.
Znakiem # oznaczamy komentarz – ta linia jest pomijana. Komentarze mają ilustrować kod i
poprawiać jego czytelność. Korzystanie z Jupyter oferuje również więcej opcji ulepszania
czytelności kodu. Ponieważ korzysta on z frameworka internetowego, obsługuje „markdown”
(który jest sposobem formatowania tekstów na stronach internetowych).
Typy danych Python
Typy danych determinują atrybuty elementów wyrażenia zadeklarowane przez programistę.
Python, podobnie jak każdy inny język programowania, posiada szczególne typy danych:
Liczby (tj. int, float, zespolone itp.)
String
Listy
Krotki-Tuples
Słowniki
Booleany
Formatowanie print
Liczby
Liczby są reprezentowane w Pythonie jako liczby całkowite, zmiennoprzecinkowe lub liczby
zespolone.
Liczby całkowite
- int ()
Możemy wykonywać operacje arytmetyczne na liczbach całkowitych bezpośrednio z ścieżki (lub w
notatniku Jupyter).
Operacje arytmetyczne z Pythonem:
Wejście: ​5 + 10
Wyjście: ​15
Wejście: ​ 20–12
Wyjście: ​ 8
Wejście: ​ 3 * 5
Wyjście: ​ 15
Wejście: ​ 20/5
Wyjście: ​ 4.0
Dodawanie, odejmowanie i mnożenie liczb całkowitych z inną liczbą całkowitą daje liczbę całkowitą.
Wynikiem dzielenia jest liczba zmiennoprzecinkowa. Kolejność działań jest następująca: wyrażenia w nawiasie, potęgowanie, dzielenie, mnożenie, dodawanie, odejmowanie. Istnieją też
inne operacje arytmetyczne na liczbach całkowitych.
Ilustruje to poniższy kod:
Wejście: # Ten kod próbuje określić operacje porządkowe za pomocą liczb całkowitych
(7-2 * 2) ** 3 / (12-3 ** 2)
Wyjście: 9.0
** jest znakiem potęgowania w Pythonie (niektóre inne języki pozwalają na użycie „^”).
Ćwiczenie: Wypróbuj kilka innych operacji arytmetycznych na liczbach całkowitych. Pamiętaj, aby
przestrzegać kolejności operacji arytmetycznych, aby uniknąć błędów.
Początkowo istniało ograniczenie liczby znaków dopuszczalnych dla typu int (), ale zostało
zniesione w nowych wersjach Pythona. Teraz możemy zadeklarować typ całkowity z dowolną liczbą
znaków numerycznych (oczywiście mamy limit pamięci komputera!). Python konwertuje liczby
całkowite na dziesiętne, a następnie wykonuje operację arytmetyczną.
Zakładając, że musimy pomnożyć 52 przez 158. 5 w podstawie 2 to „101”, a 15 w podstawie 8 to
„17”
Wejście: # Ten kod mnoży liczby całkowite w różnych podstawach i wyświetla ekwiwalent dziesiętny
# aby podać 101 w podstawie 2, używamy 0b101
# aby określić 17 w podstawie 8, używamy 0o17
0b101 * 0o17
Wyjście: 75
Float
Liczby zmiennoprzecinkowe - liczby rzeczywiste zdefiniowane w matematyce. Wszystkie operacje
numeryczne, które są możliwe przy użyciu liczb całkowitych, mogą być również używane z liczbami
zmiennoprzecinkowymi.
Python 3 obsługuje operacje zmiennoprzecinkowe w prosty sposób. W Python 2 podczas dzielenia
przynajmniej jedna z liczb (zwykle dzielnik) zawsze musi być reprezentowany jako liczba
zmiennoprzecinkowa, aby uniknąć błędu obcięcia w wyniku.
Liczby całkowite mają nieograniczoną reprezentację w Pythonie, natomiast już nie. Maksymalna
wartość, jaką może przyjąć liczba zmiennoprzecinkowa, jest mniejsza niż 1,8e308 (czyli uważana
za nieskończoność w Pythonie).
Wejście: 1,8e308
Wejście inf
Na drugim końcu są liczby zmiennoprzecinkowe - mają minimalną wartość 1e-325 która jest
uważana za zero.
Wejście: 1e-325
Wejście 0,0
Liczby zespolone
Liczby zespolone w Pythonie są reprezentowane przez ich rzeczywiste i urojone części, i
wszystkie reguły operacji matematycznych, które mają zastosowanie do liczb całkowitych i liczb
zmiennoprzecinkowych.W Pythonie liczby zespolone są reprezentowane jako
{real} + {imaginary} j.
Przykład: napisz program do obliczania iloczynu 5 + 3i i 2 + 4i (5 + 3j i 2 + 4j lub 5 + j3 i 2 + j4)
We: # Ten program oblicza iloczyn liczb zespolonych
(5 + 3j) * (2 + 4j)
Wy: (-2 + 26j)
String
Jest to przedstawienie znaków tekstowych w języku programowania. W Python, ciągi znaków są
podawane między znakami cudzysłowu, pojedynczymi, podwójnymi lub potrójnymi. Przykład:
Spróbujmy utworzyć ciągi znaków z pojedynczym, podwójnym i trzema cudzysłowami. Możesz
zauważyć, że Python wyświetla te same wyniki.
We: 'Michael Foster'
Wy: 'Michael Foster'
We: ”David Beckham”
Wy: 'David Beckham'
We: ”””Guillermo Giovani”””
Wy: 'Guillermo Giovani'
Dlaczego nie trzymać się jednej konwencji? Odpowiedź jest oczywista - sposób pisania w języku
angielskim.
Łączenie ciągów tekstowych
Chociaż nie jest możliwe wykonywanie operacji arytmetycznych na ciągach (ciągi są
interpretowane jako tekst), ciągi znaków można łączyć ze sobą lub replikować.
Przykład: Załóżmy, że chcemy napisać imię przypadkowej osoby. Mamy imię i nazwisko.
We: 'Fire' + 'cracker!'
Wy: 'Fire cracker'
W tym przykładzie wprowadzamy spację przed słowem „cracker”. Aby nie otrzymać „Firecracker”.
Przykład: Spróbujmy teraz zreplikować ciąg. Wyobraźmy sobie, że musimywpisać to samo zdanie
100 razy. W tym przykładzie powtórzymy stwierdzenie „Kocham programowanie w języku Python
super ”trzy razy.
We: print(”Uwielbiam programowanie w języku Python, jest niesamowity\n” * 3)
Wy: Uwielbiam programowanie w języku Python, jest niesamowite
Uwielbiam programowanie w języku Python, jest niesamowite
Uwielbiam programowanie w języku Python, jest niesamowite
Funkcja drukowania umożliwia korzystanie z opcji formatowania, takich jak nowy znak wiersza \n
w powyższym kodzie.
Zmienne
Zmienną to miejsce w pamięci do przechowywania danych, dopóki nie będą potrzebne. Aby
zadeklarować zmienną, nazywamy ją np. „x”, i przypisujemy wartość określonego typu danych.
Następnie przypisana mu wartość staje się wartością zmiennej. Przykłady w Pythonie:
We: x = 5
y = 10
x+y
Wy: 15
Obie zmienne będą miały ten sam typ danych int () jak przypisane im dane.
Ćwiczenie: spróbuj sprawdzić typ drugiej zmiennej y. Zmień wartości x oraz y i wykonaj z nimi
dodatkowe operacje. Pamiętaj, że zmienne mogą pomieścić łańcuchy, pamiętaj tylko, aby wstawić
cudzysłowy.
Istnieje kilka zasad deklarowania zmiennych Python: Po pierwsze, Python zmienne mogą
zaczynać się tylko znakiem podkreślenia (_) lub literą alfabetu. Nie można użyć cyfry lub znaków
specjalnych tj. @, $,% itd. Ponadto Python ma pewne zastrzeżone nazwy funkcji, np. print, if, else
itp. Tych nazw nie można używać do deklarowania zmiennych aby uniknąć sprzecznych operacji
Pythona. Ponadto w deklaracji zmiennej zaleca się stosowanie konwencji nazewniczych. Jeśli
mamy zmienną z wieloma słowami, oddzielamy je znakiem podkreślenia: nazwa_zmiennej,
matric_Number, total_Number_Of_Cars itp.
Przykład: zbudujmy bardziej skomplikowany program do zilustrowania łańcucha.
We: # Ten program łączy imię i nazwisko oraz wyświetla pełne imię i nazwisko.
First_name = 'James'
Last_name = 'Potter'
Fullname = First_name + ' ' + Last_name
print (Fullname)
Wy: James Potter
Sprawdźmy atrybut zmiennej „Fullname”.
We: type(Fullname)
Wy: str
Ponownie zbudujmy bardziej skomplikowaną wersję programu, który akceptuje dane wejściowe
użytkownika dla imienia, nazwiska i wieku, a następnie wyświetla informacje. W tym przykładzie
użyto funkcji input (), a jej składnią może być wydedukowana z kodu.
We: # Ten program wyświetla nazwy
First_name = input ('Jak masz na imię? \t')
Last_name = input ('Podaj nazwisko? \t')
Age = str (input („Wiek? \t'))
Fullname = First_name + ' ' + Last_name
print ('Witaj' + Fullname + '\ n\n')
Print ('Musi być miło mieć' + Age + '; Jestem komputerem, nie mam wieku!')
Może być również łatwo zaobserwować konwersję typu danych zmiennej wiekowej na a string za
pomocą funkcji str (). Jest to również możliwe do konwersji na inne dane typy tj. int () do konwersji
na liczby całkowite, float () do konwersji do liczb zmiennoprzecinkowych i liczb zespolonych () do
zamiany na liczby zespolone.
Ćwiczenia
1. Utwórz prosty program, który przyjmie imię trzech przyjaciół i wita ich w restauracji np.
McDonalds.
2. Napisz program, który przyjmuje wartość całkowitą i wyświetla ją jako liczbę
zmiennoprzecinkową.
3. Napisz prosty program, który akceptuje wartość temperatury w stopniach Celsjusza, i
wyświetla ekwiwalent Fahrenheitach.
Podpowiedź:
Listy
Listy w języku Python nie różnią się tak bardzo od ogólnej idei list w zwykłym języku. Jest to tylko
zbiór wartości w sekwencji oddzielonej przecinkami. Listy mogą przechowywać wartości z
różnymi typami danych, tj. listę Pythona można łączyć z sekwencją liczb całkowitych, liczb
zmiennoprzecinkowych, łańcuchów itp. Listy można przypisywać do zmiennych na ich podstawie
deklaracji i kilka operacji na liście jest zilustrowane w następujących przykładach:
# Przykład
[1,2,3,4,6] # Lista liczb całkowitych
[12.1,13.42,15.6,18.93,20.0] # Lista float
['New', 'Takeen', 'Extra'] # Lista ciągów znaków
['True', 'False'] # Lista wyrażeń boolowskich
['Derek', 25, 125.50, True,] # Lista różnych typów danych
Aby zadeklarować listę w języku Python, używane są nawiasy kwadratowe [], a wartości są
oddzielone przecinkami. Wszystkie zadeklarowane powyżej listy pokazują, w jaki sposób listy
Python są elastyczne do przechowywania danych dowolnego rodzaju. Listy te zostały jednak
zadeklarowane do jednorazowej oceny. Lepszą praktyką jest przypisywanie list do zmiennych w
celu ponownego wykorzystania.
Aby uruchomić powyższy przykład, skopiuj i uruchom każdą listę osobno, jeśli kopiujesz
wszystkie powyższe listy, Python zwróci tylko wynik ostatnio zadeklarowanej listy.
Indeksowanie list
Po zadeklarowaniu listy, do każdej wartości na liście można uzyskać dostęp za pomocą metody
zwanej indeksowaniem. Chodzi o to, że każdy element na określonej liście ma identyfikator
umożliwiający dostęp do niego, a indeksowanie list to proces pobierania elementów listy za
pomocą ich identyfikatorów.
Aby skorzystać z indeksowania listy, należy najpierw przypisać listę do zmiennej. Warto też
zauważyć, że indeksowanie list w języku Python jest zależne od kierunku. Indeksowanie zaczyna
się od lewej do prawej, Python rozpoczyna indeksowanie od „0”, podczas gdy
indeksowanie od prawej do lewej rozpoczyna się od -1.
Przykład: Weźmy trzeci element z listy.
W []: Random_List = [1,2,3,4, 'jedzenie']
Random_List [2]
Wy []: 3
Alternatywnie, moglibyśmy pobrać wartość 3 z Random_List za pomocą polecenia Random_List [-3];
nie jest to jednak powszechna konwencja. Istnieją również inne wersje list - zagnieżdżone listy.
Przykład: To jest zagnieżdżona lista
Random_List2 = [[1,2,3,4, 'integers'], 'food', [12.3,5.2,10.0, 'floats']]
Aby zrozumieć listy zagnieżdżone, wyobraź sobie rosyjskie 'matrioszki' ;-) Ta analogia
przedstawia, to samo podejście do indeksowania dla list, które są zagnieżdżone w innych listach.
Przykład: Weźmy wartość 10.0 z Random_List2.
W []: Random_List2 = [[1,2,3,4, 'liczby całkowite'], 'food', [12.3,5.2,10.0, 'floats']]
Random_List2 [2] [2]
Wy []: 10,0
Korzystając z pierwszego polecenia, Random_List2 [2], udało się pobrać zagnieżdżoną listę
zawierającą pożądaną wartość 10,0. Jeśli policzymy, ta lista jest trzecim elementem w
Random_List2. Teraz, po użyciu pierwszego indeksu, pobieramy listę, możemy teraz również
indeksować tę nową listę. W ramach tego lista „Random_List2 [2]” ma wartość 10.0, która jest
trzecim elementem pod indeksem 2 (indeksy Pythona zaczynają się od zera, możemy również wybrać go
za pomocą „-2”), więc aby go pobrać, po prostu indeksujemy tę listę pod numerem 2: „Random_List2
Przykład: Stwórzmy program, który akceptuje informacje o użytkowniku i wyświetla niektóre wyniki.
W []: # Program, który akceptuje dane użytkownika
user_Data = eval (input ('''Podaj swoje dane w następującej
kolejności:
['Nazwisko', wiek, wzrost (w cm), żonaty (wpisz True/False)]
'''))
Podaj swoje dane w następującej kolejności:
['Nazwisko', wiek, wzrost (w cm), żonaty (wpisz True/False)]
['James Franco', 41, 180, False]
Wynik:
Metoda „eval” w powyższym kodzie służy do oceny wszelkich danych wejściowych sugerowanych przez
użytkownika. To pozwala Pythonowi zaakceptować dane wejściowe w postaci literału i interpretować go jako
kod Pythona. W tym przypadku Python rozpoznaje dane wejściowe jako listę
z uwagi na użycie []. Przypisuje również odpowiedni typ danych do każdego elementu jak określono na liście.
Po przygotowaniu listy user_Data możemy przypisać każdy element na liście do odpowiadających
im zmiennych i wydrukować pożądany wynik:
W []: Nazwisko = user_Data[0]
Wiek = user_Data[1]
Wzrost = user_Data[2]
M_Status = user_Data[3]
print (('''Oto twoje dane
Nazwisko: {}
Wiek: {}
Wzrost: {} m
Żonaty: {} ''').format (Nazwisko,Wiek,Wzrost,M_Status))
Wy:
Oto twoje dane
Nazwisko: James Franco
Wiek: 41 lat
Wzrost: 188 cm
Żonaty: Fałsz
Nowa metoda wprowadzona tutaj to '. format'. Oto jak działa: Z listy user_Data, którą
zadeklarowaliśmy w pierwszej komórce, bierzemy każdy element i przypisujemy je do zmiennych
„Nazwisko, Wiek, Wzrost i M_Status”.
Aby wyświetlić wszystkie te elementy bez konieczności łączenia łańcuchów (string) lub zmieniany
typu danych, do drukowania na ekranie możemy użyć funkcji drukowania z potrójnymi
cudzysłowami z użyciem wiele linii. Alternatywnie moglibyśmy zastosować pojedyncze lub
podwójne cudzysłowy wraz z opcjami zmiany linii/tabulacji, tj. \ n lub \ t.
Metoda '. format' to sposób kontrolowania drukowania. Musimy tylko wstawić { } w miejsca, w
które pójdą wartości, a następnie określić kolejność. Zakładając, że chcemy wydrukować coś w
stylu np.: Mam 5 lat i mam 20 PLN.
W []: print (('Mam {} lat i mam {}.').format (5, '20 PLN'))
Wy
Mam 5 lat i mam 20 PLN.
W powyższym kodzie 20 PLN musiało zostać określone jako ciąg-string. Lepsze podejście
polegałoby na zastosowaniu przypisania zmiennej, tj. przypisaniu 5 i 20 PLN do zmiennej i
przekazania ich do metody „.format”.
Ćwiczenie: Napisz program, który wyświetla historię konta bankowego klienta.
Indeksowanie zakresu (podział na listy)
Zakładając, że musimy pobrać zakres elementów z listy, powiedzmy pierwsze trzy elementów,
możemy to osiągnąć poprzez indeksowanie zakresu lub tzw. slicing. Operator zasięgu jest
dwukropkiem ':', a technika ma następującą składnię: Nazwa listy [zakres dla startu : koniec
zakresu +1].
Przykład: Pobierz nazwy zwierząt z poniższej listy [„Cat”, „Dog”, „Goat”, „Jaguar”, „Lion”] i
przypisz je do zmiennej domestic_animals.
W []: Animals = ['Cat', 'Dog', 'Goat', 'Jaguar', 'Lion']
domestic_Animals = Animals [0:3]
print (domestic_Animals)
Wy:
['Cat', 'Dog', 'Goat']
Alternatywnie, jeśli nasze pożądane dane zaczynają się od pierwszego elementu, nie ma takiej
potrzeby aby określić indeks „0” (lub indeks „-1” w indeksie od prawej do lewej), możemy pobrać
dane również za pomocą 'domestic_Animals = Animals [: 3]'. Możemy zauważyć, że element
„Goat” ma indeks „2”, jednak zakres składnia wymaga podania argumentu „koniec zakresu” jako
„koniec zakresu +1” czyli 3 w tym przypadku.
To samo podejście stosuje się w przypadku bardziej skomplikowanego przechwytywania
danych, jak na przykładzie:
Napisz program, który wybierze trzy różne smakołyki z listy jedzenie i wydrukuje wiadomość.
W []: food_list = ['ryż', 'sałatka', ['ciasto', 'lody', 'ciastka', 'pączki'],'fasola']
treats = food_list [2] [1:4]
Print ('Uwielbiam {}, {} i {}.'.format(treats[0], treats[1], treats[2]))
Wy:
Uwielbiam lody, ciastka i pączki.
Indeksowanie ciągów
Ciągi-string to tylko kilka „połączonych” znaków. Stąd wszystkie operacje indeksowania list mają
również zastosowanie do łańcuchów.
Przykład: Weź słowo „except” z ciągu.
W []: # Ten program ilustruje indeksowanie ciągów
String = „Exceptional”
# index -slice
new_string = String [:6]
# Drukowanie wyniku
print (new_string)
Wy:
Except
Przykład: Zbieranie słów z dowolnego elementu na liście.
W []: # pobieranie słowa „medical” z listy
word_list = ['nautical',['medieval', 'extravaganza'],'extra']
word = word_list[1][0][:4] + word_list [0][5:8]
print(word)
Wy:
Medical
Przećwicz warianty indeksowania list i ciągów, będą one bardzo przydatne na kolejnych
zajęciach.
Przypiszemy nowe elementy do listy. Pierwszy przypadek to ponowne przypisanie elementu. Listy
są zmienne, co oznacza, że mogą one pozwolić na zmianę początkowej deklaracji. Możemy
ponownie przypisać elementy listy za pomocą indeksowania, a także możemy dodawać lub
usuwać elementy z listy przy użyciu metod .append, .insert, .extend, .remove.
Przykład: Oto lista owoców, którymi chcemy manipulować ['Apple', 'Orange', 'Banana', 'Cashew',
'Almond'].
W []: # Deklaracja listy owoców
fruits = ['Apple', 'Orange', 'Banana', 'Cashew', 'Almond']
fruits
Wy []: [„Apple”, „Orange”, „Banana”, „Cashew”, „Almond”]
Teraz ponownie przypiszmy drugi element na liście, tj. „Orange” i zmień go na „Guawa”
W []: fruits [1] = 'Guawa'
fruits
Wy []: ['Apple', 'Guava', 'Banana', 'Cashew', 'Almond']
Zauważ, że guawa została zaindeksowana jako drugi element na liście. Jednak, pomarańcza
została usunięta / wymieniona.
W tej metodzie wykorzystano ideę zmiennego przypisania. Element „Orange” jest zmienną na
liście owoców, a jej nazwa oparta jest na indeksie, tj. fruits [1], podobnie jak nazwa zmiennej
„banana” to owoce [2]. Więc to jest po prostu kwestia ponownego przypisania wartości zmiennej.
Tej samej metody można użyć do ponownego przypisania dowolnych elementów na tej
liście.
Przykład: Ponowne przypisanie dla listy zagnieżdżonej. Najpierw bieżemy zagnieżdżony
element do ponownego przypisania, a następnie przypisujemy mu nową wartość.
W []: # Ponowne przypisanie zagnieżdżonego elementu.
New_list = ['Apple', ['Orange','Guava'], 'Banana', 'Cashew', 'Almond']
New_list
Wy []: ['Apple', ['Orange','Guava'], 'Banana', 'Cashew', 'Almond']
W []: New_list [1] [0] = 'Mango'
New_list
Wy []: ['Apple', ['Orange','Guava'], 'Banana', 'Cashew', 'Almond']
Ćwiczenie: teraz spróbuj zmienić element „target” na „targeting” na tej liście:
nest = [1,2,3, [4,5, [„target”]]]
Korzystając z naszej początkowej listy owoców, użyjmy metody .append. Ta metoda używa
przekazanej do niej wartość i dodaje ją na końcu listy. Można dodać tylko jeden element do listy
na raz. Jeśli więcej niż jeden element zostanie przekazany do metody, to dodaje go jako listę
podrzędną do listy zamierzonej.
Przykład: Dodaj owoc Pawpaw do listy owoców i ustaw jako ostatni element.
W []: # Deklaracja listy owoców
fruits = ['Apple', 'Orange', 'Banana', 'Cashew', 'Almond']
fruits.append ('Pawpaw')
fruits
Wy []:
['Apple', 'Orange', 'Banana', 'Cashew', 'Almond', 'Pawpaw']
Aby dodać listę podrzędną, użyj metody .append (‘[sub-list elements]’)
Przykład: Dodajmy podlistę węglowodanów do listy żywności
W []: # Deklarowanie listy potraw
foods = ['Beans','plantain','fish']
foods.append(['Rice', 'Wheat'])
foods
Wy []:
['Beans', 'plantain', 'fish',['Rice',
'Wheat']]
Teraz zastosujmy inną metodę „.extend”. Ta metoda dodaje również dane wejściowe wartości na
końcu listy. Jednak w przeciwieństwie do metody .append, w przypadku wielu wartości
wejściowych, metoda .extend dodaje każdy element do listy, tym samym rozszerza indeks listy.
Przykład: Użyj metody .extend, aby dodać dwa elementy na końcu listy.
W []: # Deklaracja listy potraw
foods=['Beans','plantain','fish']
foods.extend(['Rice','Wheat'])
foods
Wy []: ['Beans','plantain', 'fish','Rice',
'Wheat']
Obie metody .append i .extend akceptują tylko jeden argument wejściowy. Jeśli jest więcej niż
jeden, zamakamy wejścia w nawias kwadratowy.
Wyobraźmy sobie przypadek, w którym chcemy dodać element do dowolnej części listy bez
zastępowania elementu w tym indeksie. Metoda .insert jest odpowiednia do tego celu.
Akceptuje również jeden argument i wstawia wartość o podanym indeksie.
Metoda .insert ma następującą składnię: ListName.insert (pożądany indeks, Nowa wartość)
ListName to nazwa listy, którą mamy manipulować. Pożądanym indeksem jest oczekiwana
pozycja tego elementu, a Nowa wartość to element, który ma być wstawiony pod określonym
indeksem.
Przykład: Zastanów się nad poniższą listą liczb całkowitych i dodaj odpowiednią wartość, aby
uzyskać poprawną sekwencję. Count_to_ten = [1,2,4,5,6,7,8,10].
W []: # Ten program ilustruje metodę .insert.
Count_to_ten = [1,2,4,5,6,7,8,10]
Count_to_ten.insert (2,3)
Count_to_ten.insert (8,9)
Count_to_ten
Wy []: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Teraz lista „Count_to_ten” ma zwiększony rozmiar i indeksowanie o wartość 1, tj. Count_to_ten
= [1,2,3,4,5,6,7,8,10]. Teraz możemy dodać wartość 9 do właściwego indeksu 8 jak w czwartym
wierszu kodu.
Pamiętaj o rozszerzeniu indeksu przed przypisaniem elementów. Następnie następujący kod
osiągnąłby ten sam wynik:
W []: Count_to_ten = [1,2,4,5,6,7,8,10]
Count_to_ten.insert (7,9)
Count_to_ten.insert (2,3)
Count_to_ten
Wy: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Jest tak, ponieważ wstawienie wartości na liście przesuwa elementy listy o indeks wstawienia po
prawej stronie. Każdy z przesuniętych elementów ma teraz indeks zwiększany o liczbę
wstawionych elementów, tj. jeśli element miał indeks z 3 na liście, a do jego indeksu lub przed
indeksem wstawiono dwie pozycje - ten element ma teraz indeks 5. Ostatnią metodą, którą
rozważalibyśmy przy operacjach list, jest metoda .remove.
Służy do usuwania elementu z listy. Ma również podobną składnię z metoda .insert i
korzysta z indeksowania list.
Przykład: Dodajmy wartość 11 do listy Count_to_ten, a następnie wyczyśćmy ją przy użyciu
metody .remove.
W []: # Korzystanie z listy wyników z ostatniego przykładu
Count_to_ten.append (11)
Count_to_ten
Wy []: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10,11]
W []: # Resetowanie z powrotem do 10
Count_to_ten.remove (11)
Wy []: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Metoda .remove nie wymaga specyfikacji indeksu niechcianego elementu. Tylko nazwę lub
wartość potrzebną jest element do usunięcia.
Ćwiczenie: utwórz listę samochodów i ćwicz na niej różne manipulacje. Ćwiczyć dodawanie do
listy, usuwanie elementów itp.
Można też wykonać dodawanie i mnożenie listy (powtarzanie), tak jak w przypadku łańcuchów.
Przykład:
W []: # Dodawanie i mnożenie list
List1 =['A','B','C','D']
List2 =[1,2,3,4]
CombinedList = List1 + List2
CombinedList
Out []: [„A”, „B”, „C”, „D”, 1, 2, 3, 4]
W []: # Mnożenie list
List2 * 2
Out []: [1, 2, 3, 4, 1, 2, 3, 4]