Na początku warto powiedzieć wprost, że Python jest językiem programowania, którego nauka może pochłonąć dość dużo czasu, jeśli chcesz poznać wszystkie jego szczegóły. Natomiast dobra wiadomość jest taka, że na początku nie potrzebujesz tego, aby zacząć rozwiązywać pewne problemy. Wystarczy poznać tylko jakąś część tego języka i już można używać go skutecznie i wiele osiągać. Pewnie kojarzysz regułę 20% wysiłku i 80% wartości (na bazie zasady Pareto). Właśnie taki jest nasz cel - uczyć się i działać z Pythonem w taki sposób, aby w jak najkrótszym czasie i jak najniższym wysiłkiem poznać i wykorzystać to, co daje ogromną wartość.
Przed rozpoczęciem nauki warto sobie jeszcze raz uświadomić, dlaczego warto poznać Pythona. Popularność tego języka rośnie bardzo szybko od kilku lat. Głównie dlatego, że jest bardzo wygodny w użyciu jeśli chodzi o tematy związane z analizą danych, data science, uczeniem maszynowym.

Cały artykuł o popularności tego języka możesz тут. Można również zobaczyć trendy dotyczące zapytania na stack overflow.

No to zaczynajmy!

Krok po kroku
Jeśli jesteś osobą początkującą możesz skorzystać z nagrania poniżej. Omawiam tam krok po kroku tę lekcję. Możesz to pominąć i skupić się na samym tekście pisanym poniżej i kodzie, a możesz dodatkowo posłuchać i zobaczyć nagranie. Decyzja należy do Ciebie :)

✔️ Zmienna

Najpierw zobaczymy, jak się tworzy zmienne w Python.

Kod
my_var = 1
my_var to jest nazwa zmiennej.

Jeśli chodzi o nazewnictwo, to warto używać języka angielskiego.

Natomiast jeśli chodzi o styl, to warto sprawdzić standardy PEP8.
Warto również zaznaczyć, że jest kilka słów, których pod żadnych pozorem NIE powinniśmy używać jako nazw zmiennych. Do takich słów należą m.in. print, list, set, dict itd. To są nazwy, których Python używa do własnych, wbudowanych funkcji. Nie ma ich aż tak dużo, ale na szczęście nie musisz ich wszystkich zapamiętywać. Jeśli używamy funkcji, to jupyter automatycznie zmienia kolor takiego słowa na zielony, więc wystarczy tylko uważnie śledzić kolory ;).

W tym momencie przypisaliśmy do my_var wartość 1. Zwróć uwagę, że na końcu nie ma ";" (jak zwykle to bywa w C++ i podobnych językach). Średnik można dodać, ale jest to opcjonalne.

Wypiszmy teraz zawartość zmiennej. W tym celu posługujemy się funkcją print().

Коd
print(my_var)
Wynik: 1

Gratuluję! Jak widzisz, została wypisana zawartość zmiennej, w tym przypadku 1.

Zadanie 1.2.1
Proszę utwórz nową zmienną (nadaj inną nazwę) i wypisz jej zawartość.
Zamiast ## YOUR CODE HERE wpisz swój kod.

Zwróć uwagę, że jeśli wstawimy # (czyta się jako "hasz"), to wtedy możemy wpisywać komentarz. Komentarze są ignorowane w momencie uruchamiania kodu. Czyli jeśli mamy kilka linijek kodu i nie chcemy, aby któraś się wykonała, wystarczy dodać # na początku linijki. Warto podkreślić, że każda linijka kodu wymaga oddzielnego dodania znaku #. Dodatkowo nie ma znaczenia, ile znaków # użyjemy. Wystarczy jeden i wtedy wszystko za nim będzie ignorowane przy uruchamianiu kodu (czasami dodaje się ich więcej żeby np. zwiększyć czytelność komentarzy).

Typy zmiennych

Int
Już wiesz, jak utworzyć zmienną. Teraz czas przejść do omówienia, jakie są typy zmiennych. Najpierw jednak poznajmy funkcję type(), która umożliwia sprawdzenie, jakiego typu jest zmienna. Sprawdźmy to:

Код
type(my_var)
Wynik: int

Jak widzisz zmienna jest typu int, co jest skrótem od integer (po angielsku oznacza to po prostu liczba całkowita).

Float

Kolejna zmienna, którą warto poznać to float, czyli zmienna przecinkowa. Co to oznacza? To zmienna, której używamy wtedy, gdy chcemy używać liczb dziesiętnych, a więc np. jak chcemy zapisać temperaturę (36.6) lub średnią ocenę (4.9). Zwróć uwagę, że dodajemy kropkę (.), a nie przecinek (,). Ten standard pochodzi z USA.

Коd
my_temp = 36.6
type(my_temp)
Wynik: float


Boolean

Zmienna logiczna, która ma dwa stany True lub False.
Коd
is_good = True
print(is_good)
type(is_good)
Wynik: True, bool

Zwróć uwagę, że True lub False pisze się z dużej litery.

Lista

Dość często mamy potrzebę zapisania ciągu liczb (lub znaków) np. wypisując, jakie są oceny w grupie. Załóżmy, że grupa składa się z pięciu osób i mają następujące oceny: 4, 5, 5, 3, 4. Zmienna, która przechowuje ciąg znaków to lista, którą tworzymy używając nawiasów kwadratowych [].

Коd
group_scores = [4, 5, 5, 3, 4]

print(group_scores)
type(group_scores)
Wynik: [4, 5, 5, 3, 4], list

Jak widzisz do zmiennej group_scores przypisaliśmy listę z ocenami. W tej chwili ta lista składa się z pięciu elementów.

W jaki sposób można dostać się do poszczególnych wartości listy? Odpowiedź: używając indeksów. Każdy element w liście ma swój indeks, za pomocą którego możemy dostać się do danej wartości. Przy czym należy pamiętać, że indeksowanie zaczyna się od 0! Innnymi słowy, jeśli chcesz zobaczyć pierwszy element w liście, to należy to zrobić w ten sposób group_scores[0].

Sprawdźmy to.

Коd
group_scores[0]
Wynik: 4

Zadanie 1.2.2

Twoim zadaniem jest dostać się do czwartego elementu w liście (a więc wynikiem powinno być 3). Pamiętaj o przesunięciu o jeden w indeksie!

Zadanie 1.2.3*
Twoim zadaniem jest dostać się do ostatniego elementu listy (załóżmy, że nie wiesz, jak dużo elementów jest w liście).

Podpowiedź: za pomocą funkcji len() możesz zobaczyć ilość elementów w liście.

Indeksacja też może zawierać ujemne liczby np. -1, -2, -3 itd.. Wtedy liczymy od końca. Innymi słowy, -1 oznacza ostatni element, dzięki czemu jest łatwiej dostać się do ostatniego elementu.

Jest jeszcze możliwość wyciąć kawałek listy z listy. Składnia wygląda w taki sposób [start_index:stop_index]. Jest to przedział z lewej strony domknięty, a z prawej otwarty. Innymi słowy w wyniku będziemy mieli elementy o indeksach od start_index do stop_index-1.

Załóżmy, że chcemy z naszej listy wyciągnąć listę pomijając pierwszą wartość.

Коd
group_scores
Wynik: [4, 5, 5, 3, 4]

Коd
group_scores[1:5] # zaczynamy od drugiej wartości (czyli start_index=1), a kończymy na piątej (która ma indeks 4)
Wynik: [5, 5, 3, 4]

Код
group_scores[2:5] # zaczynamy od trzeciej wartości (czyli start_index=2), a kończymy na piątej (która ma indeks 4)
Wynik: [5, 3, 4]

Ciekawostka: jeśli pominiemy start_index, to wtedy interpretator podstawi tam 0. Jeśli natomiast pominiemy stop_index, to podstawi wynik użycia len().

Zobaczmy. Za pomocą == możemy sprawdzić, czy 2 zmienne mają takie same wartości. Dlaczego nie za pomocą =? Ponieważ = służy do przypisywania wartości do nazwy zmiennej.

Коd
group_scores[:3] == group_scores[0:3] # listy są identyczne
Wynik: True

Коd
group_scores[2:] == group_scores[2:len(group_scores)] # listy są identyczne
Wynik: True

Jak myślisz, co się stanie w przypadku, kiedy nie podamy jawnie start_index i stop_index? Mam teraz na myśli taką konstrukcję [:], czyli został pominięty start_index i stop_index.
Коd
group_scores[:]
Wynik: [4, 5, 5, 3, 4]

W ten sposób zwracamy całą listę. A dokładnie to jej fizyczną kopię. Zaraz Ci pokażę na przykładzie, o co mi chodzi. Najpierw jednak trzeba poznać kolejną funkcję - id(). Zwraca ona nam fizyczny identyfikator zmiennej (adres w pamięci RAM).

O pamięci RAM można pomyśleć w ten sposób. Jest sobie miasto (załóżmy, że to jest pojedyncza kostka RAM).

Fizycznie to wygląda tak jak na zdjęciu, natomiast logicznie możesz sobie wyobrazić, że w środku "tego miasta" jest wiele domków. Każdy domek ma adres (identyfikator). Każdy dom ma też swoją pojemność, ile ludzi (danych) może tam mieszkać.

Funkcja id() zwraca adres, gdzie mieszka ta czy inna zmienna. Dość często w celach optymalizacji różne zmienne fizycznie są przechowywane pod tym samym adresem (między innymi to dotyczy list).

Natomiast możemy skopiować zawartość fizyczną do innego domku. A więc mówiąc, że mamy fizyczną kopię oznacza to, że ta sama informacja jest w różnych "domkach".

Liczba domków w mieście jest ograniczona. W tym przypadku tę liczbę "domków" mierzy się w bajtach (teraz żyjemy w czasach, kiedy obok jest przystawka Giga lub nawet Tera Bajty).

Zobacz na przykładzie. Załóżmy, że najpierw tworzymy nową zmienną list_a do której przypisujemy listę [1, 2, 3]

W wyniku tego fizycznie ta lista jest przechowywana w domku nr. 3. Adres możemy zobaczyć przy pomocy funkcji id(). Następnie tworzymy nową zmienną list_b, ale ona wskazuje na ten sam adres co zmienna list_a. Innymi słowy, zmieniając zawartość domku nr. 3 wpłynie to jednocześnie na list_a oraz list_b. Możesz też myśleć o tym tak, że zmienna nie jest domkiem, ale prowadzi Cię do konkretnego domku. Zobacz na obrazku.
Natomiast możemy zrobić fizyczną kopię. Aby zrobić fizyczną kopię listy używamy tego operatora [:]. Załóżmy, że tworzymy fizyczna kopię list_a i przypisujemy ją do list_c. To wtedy faktycznie zawartość jednego domku (w tym przypadku nr. 3) zostanie przeniesiona do zawartości drugiego domku (w tym przypadku nr. 6). Zobacz na obrazku.
Teraz wróćmy do group_scores i zróbmy eksperyment na żywo.

Коd
copy_group_scores = group_scores

id(group_scores), id(copy_group_scores)
Wynik: (140570324603456, 140570324603456)

Jak widzisz, w tej chwili mamy dwie zmienne, ale fizycznie są one przypisane do tego samego obiektu (taka specyfika Pythona, że jeśli tworzymy nową listę na bazie innej zmiennej, to nie tworzy się nowy obiekt [używając analogii powyżej, nie zajmuje się nowego domku]).
Jeśli zmodyfikujesz cokolwiek w liście copy_group_scores, to również wpłynie to na listę group_scores.

Sprawdźmy to.

Коd
copy_group_scores[0] = 100
group_scores
Wynik: [100, 5, 5, 3, 4]

Zmieniliśmy pierwszy element w copy_group_scores i to również wpłynęło na pierwszy element w group_scores. Załóżmy, że jednak chcemy zrobić fizyczną kopię listy (stworzyć nowy obiekt, który ma takie same elementy). Wtedy używamy konstrukcji z [:].

Sprawdźmy to:

Коd
group_scores = [4, 5, 5, 3, 4]
clone_group_scores = group_scores[:]
clone_group_scores[0] = 100

print(group_scores)
id(group_scores), id(clone_group_scores)
Wynik:
[4, 5, 5, 3, 4]

(140570324576064, 140570324652800)

Jak widać group_scores oraz clone_group_scores to dwie różne listy fizyczne (mają różne ID). Dlatego po zmianie wartości w clone_group_scores nie zaszły żadne zmiany w group_scores (i na odwrót).

Co jeżeli chcemy dodać zupełnie nowy element, a nie zmienić istniejący?
Dodanie wartości do istniejącej listy odbywa sie przy pomocy funkcji .append. Nowy element pojawi się wtedy na końcu.

Коd
my_list = [1]
print(my_list)
my_list.append(2)
print(my_list)
Wynik:
[1]
[1, 2]
Możemy również wstawić element do listy pod konkretny indeks za pomocą .insert(index, wartość). Wtedy wszystkie elementy na prawo od tego miejsca przesuną się o jedno miejsce.

Коd
my_list = [1, 2, 4]
print(my_list)
my_list.insert(2, 3)
print(my_list)
Wynik:
[1, 8, 4]
[1, 8, 3, 4]

Jeśli masz dwie listy i chcesz je połączyć to można zrobić to w ten sposób:
Коd
list_a = [1, 2, 3]
list_b = [4, 5, 6]

list_c = list_a + list_b
list_c
Wynik:
[1, 2, 3, 4, 5, 6]
Wynik:
[1, 2]

Warto również wiedzieć, że zmienne w ramach listy nie muszą być tego samego typu.

Коd
my_list = [1, 0.1, 2]
print(my_list)
Wynik:
[1, 0.1, 2]
Set

Czyli po angielsku zbiór. Zbiór ma taką ciekawą właściwość, że zawiera tylko unikalne elementy. Często używamy go wtedy, jak chcemy osiągnąć co najmniej jedną z trzech rzeczy:
  1. Kiedy zależy nam na posiadaniu unikalnego zbioru elementów (w liście te same wartości mogą się powtarzać wiele razy).
  2. Szybko sprawdzić, czy dany element należy do zbioru.
  3. Operacje matematyczne na zbiorach (łączenie, sprawdzanie różnicy itd).
set można utworzyć z list.

Zobacz poniżej.

Коd
my_list = [1, 1, 1, 2]
my_set = set(my_list)

my_set
Wynik:
{1, 2}

Jak widać, set można odróżnić od list tym, że wartości są pomiędzy {}.
To co również jest ważne w set, to że jest on nieindeksowany. Oznacza to, że nie możemy wyciągnąć z niego dowolnego elementu albo przedziału, tak jak z listy. Jeżeli chcemy to zrobić, to musimy najpierw zamienić go na list.

Коd
my_list = list(my_set)
my_list[0]
Wynik:
1

Zbiory często mogą być przydatne w praktyce np. do znalezienia unikalnych ID. Załóżmy, że masz listę transakcji zakupów i chcesz na szybko sprawdzić, ile unikalnych produktów było zakupionych.
Załóżmy, że w zmiennej transactions mamy ID produktów, które były zakupione.

Коd
transactions = [1, 1, 2, 1, 2, 3, 5, 6, 7, 1, 8]
Jeśli chcemy znaleźć unikalną liczbę produktów, wystarczy zrobić zbiór z listy w ten sposób:

Коd
set_transactions = set(transactions)
set_transactions
Wynik:
{1, 2, 3, 5, 6, 7, 8}

Коd
len(set_transactions)
Wynik:
7

Jak widzimy mamy 7 unikalnych produktów.

Kolejna przydatna funkjonalność na zbiorach, to pewne operacje na zbiorach:
  • zbiór A i zbiór B
  • tylko zbiór A
  • wspólna część A i B
  • wszystko oprócz wspólnej części A i B


Коd
set_a = {1, 2, 3, 4, 5}
set_b = {4, 5, 6, 7}
A i B razem

set_a | set_b

Коd
set_a_or_b = set_a | set_b
set_a_or_b
Wynik:
{1, 2, 3, 4, 5, 6, 7}
Wspólna część A i B

set_a & set_b
Коd
set_a_intersect_b = set_a & set_b
set_a_intersect_b
Wynik:
{4, 5}

A za wyjątkiem wspólnej cześci z B

set_a - set_b
Коd
set_a_diff_b = set_a - set_b
set_a_diff_b
Wynik:
{1, 2, 3}

A i B za wyjątkiem wspólnej części

set_a ^ set_b

Коd
set_a_sym_b = set_a ^ set_b
set_a_sym_b
Wynik:
{1, 2, 3, 6, 7}


Tuple

Podobną konstrukcję do list ma tuple. W języku polskim czasem jest nazywana krotką.
Коd
my_tuple = (0, 7, 2)

print(my_tuple)
type(my_tuple)
Wynik:
(0, 7, 2)
tuple
tuple działa bardzo podobnie do list, ale ma szereg różnic. Zacznijmy jednak od podobieństw. Dostęp do danych jest podobny. Używając indeksu możemy dostać się do poszczególnych wartości. Na przykład, żeby dostać się do drugiego elementu używamy indeksu 1. Zobacz poniżej.

Коd
my_tuple[1]
Wynik:
7
Na czym polegają różnice?

Po pierwsze, list tworzy się w nawiasach kwadratowych [], a tuple w okrągłych (). Ewentualnie nawiasy można pominąć, ale wtedy muszą być co najmniej dwa elementy (przecinek musi się pojawić co najmniej raz). Zobaczmy.

Коd
my_tuple = 0, 1, 2 
print(my_tuple)
Wynik:
(0, 1, 2)
Po drugie, tuple to immutable type. W praktyce oznacza to, że jak raz je utworzysz, to nie możesz tego nadpisać. Zobacz, co się stanie.
Коd
my_tuple[1] = 1
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-40-6c299328a8a7> in <module>
----> 1 my_tuple[1] = 1

TypeError: 'tuple' object does not support item assignment

Pojawił się wyjątek, który mówi, że nie można nadpisać tuple. Fakt, że nie można nadpisywać danych jest bardzo piękną rzeczą, w szczególności jak działamy na wielowątkowym systemie.

String
Teraz poznajmy jeden z najbardziej popularnych typów zmiennych, który umożliwia przechowywanie tekstu. Mowa o string. Np. jeśli chcesz zapisać do zmiennej imię, to możesz to zrobić właśnie w taki sposób.

Коd
my_name = 'Jacek'
print(my_name)
type(my_name)
Wynik:
Jacek
str
string w pewnym sensie można traktować jak listę znaków (literek). Dlatego, podobnie jak w list, można odwołać się do tych elementów wykorzystując indeksy. Czyli, żeby dostać się do pierwszej litery używamy indeksu 0, a do ostatniej litery -1 itd.
Коd
my_name[0]
Wynik:
'J'

Коd
my_name[-1] # dostajesz ten sam wynik my_name[len(my_name) - 1]
Wynik:
'k'
Podobnie możesz też pobrać fragment string'u (czyli tzw. substring). To właśnie Twoje kolejne zadanie :)

Zadanie 1.2.4
my_name w tej chwili zawiera imię Jacek. Twoim zadaniem jest pobrać kawałek tekstu. Oczekiwana odpowiedź: ace.

Podpowiedź. Pamiętaj o konstrukcji [start_index:stop_index].

Zapamiętaj, że string też jest immutable (podobnie jak tuple), czyli nie możesz nadpisać danej literki. Zobacz.
Коd
my_name[0] = 'A'
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-50-2671cbeca83c> in <module>
----> 1 my_name[0] = 'A'

TypeError: 'str' object does not support item assignment


Dostaliśmy podobny wynik, który pojawił się przy nadpisywaniu wartości w tuple.

Zwróć również uwagę na cudzysłów otaczający słowo. Masz dwie opcje:
  • pojedynczy, czasem nazywany apostrofem np. 'jakiś tekst'
  • podwójny np. "jakiś tekst"
Której formy używać? To już zależy od Ciebie. Dla spójności warto jednak, aby w ramach danego kodu trzymać się jednej formy.

✔️ Wstrzyknięcie wartości
Załóżmy, że chcesz połączyć fragmenty informacji w jeden string. Można to zrobić na kilka sposobów. Zerknij na przykład poniżej.

Коd
"Total: " + str(100) + "zł (" + str(7) + " szt.)"
Wynik:
'Total: 100zł (7 szt.)'

Myślę, że zgodzisz się, że czytanie takiej linii jest dość trudne. Jest inny sposób, aby zrobić to łatwiej i ładniej.

Коd
"Total: {0}zł ({1} szt.)".format(100, 7)
Wynik:
'Total: 100zł (7 szt.)'
W nawiasach klamrowych podaje się indeks argumentu np. {0}, co oznacza zerowy indeks, czyli pierwszy element z .format(100, 7). W naszym przypadku będzie to 100. W nowszych wersjach Python są jeszcze inne sposoby, ale na to trzeba uważać, bo nie wszędzie jest najnowsza wersja Pythona. Oczywiście można zrobić wszystko (pokłócić się ze wszystkimi w Twojej firmie) po to, żeby była najnowsza wersja albo w tym samym czasie można skupić się na tym, żeby było "wystarczająco dobrze" i działało nawet na python 2. Proponuję jednak próbować łączyć pragmatyzm z entuzjazmem, ale wybór zostawiam po Twojej stronie :).

Dict

Mówiąc o grupie i ich ocenach, warto czasem też wiedzieć, kto ma jaką ocenę, niż tylko mieć anonimowy ciąg cyfr. Na pomoc nam przychodzi słownik (dict). To jest struktura, która składa się z pary: klucz i wartość. W tym przypadku kluczem może być imię, a wartością ocena. Zobacz, jak to wygląda w kodzie.

Коd
dict_scores = {
    'Jan': 4,
    'Adam': 5,
    'Ania': 5,
    'Adrian': 3,
    'Agnieszka': 4
}

print(dict_scores)
type(dict_scores)
Wynik:
{'Jan': 4, 'Adam': 5, 'Ania': 5, 'Adrian': 3, 'Agnieszka': 4}
dict
Żeby sprawdzić, jaką ocenę ma np. Ania, wystarczy odwołać się w taki sposób, jak poniżej.

Коd
dict_scores['Ania']
Wynik:
5
Jeśli klucz, który podajesz, nie istnieje w słowniku, to wtedy zobaczysz wyjątek. Na przykład sprawdźmy, jaką ocenę ma Zuza.

Коd
dict_scores['Zuza']
Wynik:
---------------------------------------------------------------------------
KeyError Traceback (most recent call last)
<ipython-input-47-97aab45da3a7> in <module>
----> 1 dict_scores['Zuza']

KeyError: 'Zuza'

Jak widzisz, jest wyjątek KeyError. Zapamiętaj go, bo znając życie dość często zobaczysz go na własne oczy w przyszłości. Słownika używamy dość często i normą jest odwołanie do słownika, w którym nie ma pewnego klucza. W jaki sposób można upewnić się, że klucz istnieje w słowniku? Odpowiadając na to pytanie, przechodzimy do warunków if.
Коd
if 'Ania' in dict_scores:
    print('Ania jest w słowniku')
    
if 'Zuza' in dict_scores:
    print('Zuza jest w słowniku')
Wynik:
Ania jest w słowniku

Warunek możemy rozbudować dodając else.

Коd
if 'Zuza' in dict_scores:
    print('Zuza jest w słowniku')
else:
    print('Zuza nie ma w słowniku')
Wynik:
Zuza nie ma w słowniku

Zwróć uwagę na kilka rzeczy:

  1. Na końcu linii warunkowej jest dwukropek czyli if ... :
  2. Blok warunkowy ma odstępy. Zapamiętaj. Odstępy w Pythonie są bardzo ważne.
  3. Domyślnie przyjmuje się, że odstęp to powinno być równo 4 spacje (lub jeden tab).
  4. Czasem jest dyskusja, czy lepsza jest spacja czy taby (polecam jednak używać spacji).
  5. Jedno jest pewne w tej dyskusji - należy unikać mieszania spacji z tabami :D
  6. Mądre IDE umożliwiają konwertować tab w spacje (czyli wciskasz tab, a dostajesz 4 spacje. Magia! :) )
  7. W Python nie ma nawiasów klamrowych, co jest często spotykane w innych językach. Jeśli chcemy zaznaczyć, gdzie zaczyna się i kończy blok, używamy odstępów. Dlatego trzeba być bardzo dokładnym w odstępach (każdy blok musi być spójny). Czy już wspominałem, że odstępy są ważne? :)
Można jeszcze bardziej zagnieżdżać warunki (dodając np. elif co jest skrótem od else if). Osoby, które programują w C/C++/Java mogą się poczuć trochę zagubione bez średników :). Spokojnie, przyzwyczaisz się.

Uważaj na nawiasy!

Wiem, że na początku to może być trudniejsze, więc przyjrzyj się na spokojnie :).
  • nawiasy okrągłe (...) np. dla funkcji print('Hello world!') albo w tuple (1, 2, 3)
  • nawiasy kwadratowe [...] np. dla list [1, 2, 3] albo dostęp do poszczególnych elementów w list czy tuple: my_list[0] lub my_tuple[0]
  • nawiasy klamrowe {...} np. dla słowników {'key': 'value'} albo w zbiorach {1, 2, 3}

Python jest językiem dynamicznie typowanym

W praktyce to oznacza, że nie musisz jawnie podawać jakiego typu jest zmienna, interpretator domyśli się sam. Super sprawa! Jednak, jak zwykle to bywa w życiu, takie rozwiązanie ma swoje wady i zalety. Zaletą jest, że kod napisany w Python wygląda elegancko i małą ilością znaków w linijce można wiele osiągnąć. Do wad na pewno warto przypisać wolniejszy czas działania (no bo skoro my nie podajemy typu zmiennej, to interpretator ma wykonać tę pracę za nas). Na szczęście są rozwiązania, które niwelują te wady (między innymi biblioteka numpy/pandas). Poznasz je w kolejnym module.

Przydatne linki:
  1. Style Guide for Python Code
  2. Python Variables and Data Types – A complete guide for beginners
  3. Named Tuple
  4. Python Type Checking (Guide)
  5. How to Use Static Type Checking in Python 3.6
  6. PEP 484 -- Type Hints
  7. TimeComplexity


Tu jest przykładowa lekcja z pierwszego modułu kursu "Python dla Data Science". W sumie jest 15 lekcji + ćwiczenia bonusowe, 15 filmów krok po kroku dla każdej lekcji ze szczegółowymi wyjaśnieniami.
Dostaniesz gotowe środowisko, w którym uczysz się materiału za pomocą tekstu i wideo. Nie musisz niczego instalować ani ustawiać.

Zdobywasz praktykę, piszesz kod już od pierwszej lekcji! Ucz się we własnym tempie - kurs będzie dostępny 24/7.
Dołącz już teraz i rozpocznij swoją wygodną naukę.