Zmienne i typy danych

Witaj z powrotem.

W poprzedniej lekcji zainstalowałeś Pythona, otworzyłeś terminal, utworzyłeś pierwszy plik .py i użyłeś print().

Bardzo dobrze.

Powiedziałeś Pythonowi:

print("Hello, World!")

I Python posłuchał.

Piękny początek.

Ale teraz potrzebujemy czegoś bardziej użytecznego.

Wyświetlanie tekstu jest miłe.

Ale prawdziwe programy muszą pamiętać rzeczy.

Imiona.

Wiek.

Ceny.

Wyniki.

Nazwy użytkowników.

Ścieżki plików.

Informację, czy coś jest prawdą albo fałszem.

I tutaj na scenę wchodzą zmienne.

Zmienne pozwalają programowi przechowywać wartości i używać ich później.

Bez zmiennych twój program miałby pamięć złotej rybki po aktualizacji systemu.

Nieidealnie.

Czego się nauczysz

W tej lekcji nauczysz się:

• czym są zmienne;
• jak tworzyć zmienne w Pythonie;
• jak wyświetlać zmienne;
• jak zmieniać wartości zmiennych;
• jak działają stringi;
• jak działają liczby całkowite;
• jak działają floaty;
• jak działają booleany;
• jak sprawdzać typy danych przez type();
• jak jasno nazywać zmienne;
• typowych błędów początkujących;
• jak ćwiczyć z prostymi danymi.

Pod koniec tej lekcji zrozumiesz, jak Python przechowuje podstawowe informacje.

To ogromny krok.

Bo kiedy program potrafi pamiętać wartości, może zacząć robić użyteczne rzeczy.

Mała pamięć.

Duża moc.

Bardzo Python.

Czym jest zmienna?

Zmienna to nazwa, która przechowuje wartość.

Przykład:

name = "Anna"

Tutaj:

name

to zmienna.

A:

"Anna"

to wartość.

Symbol = oznacza:

zapisz tę wartość pod tą nazwą

Czyli ta linia znaczy:

Zapisz "Anna" w zmiennej o nazwie name.

Teraz Python pamięta, że name oznacza "Anna".

Bardzo przydatne.

Bardzo proste.

Bardzo niebezpieczne, jeśli nazwiesz wszystko cos.

Twoja pierwsza zmienna

Utwórz plik:

variables.py

Napisz:

name = "Anna"

print(name)

Uruchom:

python variables.py

albo:

python3 variables.py

Output:

Anna

Python nie wyświetla słowa name.

Wyświetla wartość zapisaną w name.

O to właśnie chodzi w zmiennych.

Zmienna jest jak etykieta na pudełku.

Wartość jest tym, co znajduje się w pudełku.

Bardzo uporządkowane.

Bardzo pomocne.

W przeciwieństwie do niektórych prawdziwych szuflad w prawdziwych domach.

Zmienne mogą przechowywać różne wartości

Możesz utworzyć więcej zmiennych:

name = "Anna"
age = 25
city = "Rome"

print(name)
print(age)
print(city)

Output:

Anna
25
Rome

Tutaj przechowujemy:

• tekst w name;
• liczbę w age;
• tekst w city.

Python pamięta każdą wartość.

Potem print() je pokazuje.

Twój program nie tylko krzyczy już stały tekst.

Teraz potrafi przechowywać informacje.

Pojawił się mały mózg.

Szanuj go.

Zmienianie wartości zmiennej

Zmienna może się zmienić.

Przykład:

name = "Anna"
print(name)

name = "Marco"
print(name)

Output:

Anna
Marco

Najpierw name przechowuje "Anna".

Potem zastępujemy ją wartością "Marco".

Stara wartość znika z tej zmiennej.

Python nie robi się emocjonalny.

Nie mówi:

Ale Anna była tutaj pierwsza.

Po prostu aktualizuje wartość.

Bardzo zimno.

Bardzo skutecznie.

Bardzo komputerowo.

Kolejność ma znaczenie

Python wykonuje kod od góry do dołu.

Przykład:

name = "Anna"
print(name)

name = "Sofia"
print(name)

Output:

Anna
Sofia

Przy pierwszym print(name) wartość to "Anna".

Przy drugim print(name) wartość to "Sofia".

Python nie patrzy w przyszłość.

Wykonuje kod linia po linii.

Jak bardzo posłuszny pociąg.

Zwykle punktualny.

Chyba że twój kod wykolei się na zakręcie.

Stringi

String to tekst.

Stringi zapisujemy w cudzysłowie.

Przykład:

name = "Anna"
city = "Rome"
message = "I am learning Python"

Możesz je wyświetlić:

print(name)
print(city)
print(message)

Output:

Anna
Rome
I am learning Python

Stringi mogą używać podwójnych cudzysłowów:

name = "Anna"

Albo pojedynczych:

name = 'Anna'

Oba sposoby działają.

Ale nie mieszaj ich.

Źle:

name = "Anna'

Python będzie narzekał.

I tym razem Python ma rację.

Cudzysłowy muszą do siebie pasować.

String jest jak walizka.

Jeśli otworzysz ją jednym zamkiem, a zamkniesz innym, zaczyna się chaos.

Stringi mogą zawierać spacje

Stringi mogą zawierać spacje:

full_name = "Anna Rossi"
message = "Python is very useful"

print(full_name)
print(message)

Output:

Anna Rossi
Python is very useful

Wszystko, co znajduje się w cudzysłowie, jest częścią stringa.

Spacje też.

Python nie usuwa spacji, bo nagle poczuł potrzebę porządku.

Python zachowuje to, co napiszesz.

Bardzo dosłowny.

Bardzo wierny.

Czasem aż za bardzo.

Liczby: integers

Integer to liczba całkowita.

Przykład:

age = 25
year = 2026
quantity = 10

Liczby całkowite nie potrzebują cudzysłowów.

Poprawnie:

age = 25

To jest coś innego:

age = "25"

Pierwsza wartość to liczba.

Druga wartość to tekst.

Ludzie widzą oba jako 25.

Python widzi dwie różne rzeczy.

Python nie zachwyca się podobieństwem wizualnym.

Python chce typów.

Mały surowy księgowy.

Liczby: floaty

Float to liczba z częścią dziesiętną.

Przykład:

price = 19.99
temperature = 21.5
height = 1.75

Floaty są przydatne przy cenach, pomiarach, średnich i wielu innych wartościach.

Przykład:

price = 19.99

print(price)

Output:

19.99

Ważny szczegół:

price = 19.99

używa kropki.

Nie przecinka.

Poprawnie:

price = 19.99

Źle:

price = 19,99

W Pythonie liczby dziesiętne używają kropki.

Przecinek ma inne znaczenia.

Python nie przejmuje się tym, że w twoim kraju ceny zapisuje się inaczej.

Python ma własne zasady kuchenne.

Booleany

Boolean to wartość, która może być:

True

albo:

False

Przykład:

is_student = True
is_admin = False

print(is_student)
print(is_admin)

Output:

True
False

Booleany są bardzo przydatne przy decyzjach.

Przykłady:

Czy użytkownik jest zalogowany?
Czy plik istnieje?
Czy hasło jest poprawne?
Czy produkt jest dostępny?

Booleany są proste.

Ale potężne.

Jak włącznik światła.

Włączone.

Wyłączone.

Bez dyskusji filozoficznej.

True i False muszą mieć wielką literę

W Pythonie booleany zapisujemy tak:

True
False

Źle:

true
false

Python nie zrozumie ich jako booleanów.

Python jest case-sensitive.

To znaczy, że wielkie i małe litery mają znaczenie.

To są różne rzeczy:

True
true
TRUE

Poprawne jest tylko:

True

Tak samo z:

False

Python jest uprzejmy.

Ale tutaj nie akceptuje kreatywnej pisowni.

Sprawdzanie typów przez type()

Python może powiedzieć, jaki typ ma wartość.

Użyj type().

Przykład:

name = "Anna"
age = 25
price = 19.99
is_student = True

print(type(name))
print(type(age))
print(type(price))
print(type(is_student))

Output:

<class 'str'>
<class 'int'>
<class 'float'>
<class 'bool'>

To oznacza:

str    string
int    liczba całkowita
float  liczba dziesiętna
bool   boolean

type() jest przydatne, kiedy nie jesteś pewien, jakiego typu wartość masz.

Bardzo przydatne podczas debugowania.

A debugowanie to praca detektywa z większą ilością kawy.

Cztery podstawowe typy danych

Na razie zapamiętaj te cztery:

str    tekst
int    liczba całkowita
float  liczba dziesiętna
bool   True albo False

Przykłady:

name = "Anna"        # str
age = 25             # int
price = 19.99        # float
is_active = True     # bool

Te typy danych są wszędzie.

Będziesz ich używać ciągle.

Są jak podstawowe składniki kuchni Pythonowej.

Tekst.

Liczby.

Dziesiętne.

Prawda.

Dziwny przepis.

Ale działa.

Wyświetlanie tekstu i zmiennych razem

Możesz wyświetlać tekst i zmienne razem, używając przecinków:

name = "Anna"
age = 25

print("Name:", name)
print("Age:", age)

Output:

Name: Anna
Age: 25

To proste i przydatne.

print() może przyjmować wiele wartości oddzielonych przecinkami.

Python automatycznie dodaje między nimi spacje.

Bardzo miło.

Jak na niego.

Używanie f-stringów

Bardzo popularnym sposobem łączenia tekstu i zmiennych jest f-string.

Przykład:

name = "Anna"
age = 25

print(f"My name is {name}.")
print(f"I am {age} years old.")

Output:

My name is Anna.
I am 25 years old.

Litera f przed cudzysłowem oznacza:

Ten string może zawierać zmienne w nawiasach klamrowych.

Przykład:

f"My name is {name}"

Python zastępuje:

{name}

wartością zmiennej.

f-stringi są bardzo przydatne.

Bardzo czytelne.

Bardzo Python.

Używaj ich często.

Przyszły ty będzie zadowolony.

Proste obliczenia ze zmiennymi

Zmienne można używać w obliczeniach.

Przykład:

price = 10
quantity = 3

total = price * quantity

print(total)

Output:

30

Tutaj Python oblicza:

10 * 3

i zapisuje wynik w:

total

Potem wyświetlamy total.

Bardzo przydatne.

To początek prawdziwej logiki programowania.

Mały sklep.

Małe obliczenie.

Duży koncept.

Więcej przykładów obliczeń

Spróbuj:

a = 10
b = 5

print(a + b)
print(a - b)
print(a * b)
print(a / b)

Output:

15
5
50
2.0

Możesz też zapisać wyniki:

a = 10
b = 5

sum_result = a + b
difference = a - b
product = a * b
division = a / b

print(sum_result)
print(difference)
print(product)
print(division)

To jest czytelniejsze, gdy programy rosną.

Jasne nazwy mają znaczenie.

Bo przyszły ty nie chce rozwiązywać zagadki pod tytułem:

x = a * b

Przyszły ty już wystarczająco cierpiał.

Aktualizowanie liczby

Możesz zaktualizować zmienną, używając jej starej wartości.

Przykład:

score = 10
score = score + 5

print(score)

Output:

15

To oznacza:

Weź starą wartość score.
Dodaj 5.
Zapisz nową wartość z powrotem w score.

To jest bardzo częste.

Na początku może wyglądać dziwnie.

W matematyce byłoby dziwne.

W programowaniu jest normalne.

Symbol = w Pythonie oznacza przypisanie.

Nie “jest równe na zawsze”.

Oznacza:

włóż tę wartość do tej zmiennej

Bardzo ważne.

Krótsza składnia aktualizacji

Python ma krótszy sposób:

score = 10
score += 5

print(score)

Output:

15

To:

score += 5

oznacza:

score = score + 5

Możesz też używać:

score -= 2
score *= 3
score /= 2

Na razie nie przejmuj się tym za bardzo.

Po prostu wiedz, że taka składnia istnieje.

Programiści Pythona często jej używają.

Bo najwyraźniej oszczędzenie kilku znaków daje nam poczucie mocy.

Zasady nazywania zmiennych

Nazwy zmiennych muszą przestrzegać zasad.

Dobre nazwy:

name = "Anna"
user_age = 25
product_price = 19.99
is_active = True

Zasady:

• używaj liter, cyfr i underscores;
• nie zaczynaj od cyfry;
• nie używaj spacji;
• nie używaj słów kluczowych Pythona;
• nazwy są case-sensitive.

Źle:

2name = "Anna"
user age = 25
product-price = 19.99

To nie zadziała.

Nazwy zmiennych w Pythonie muszą być poprawne.

Python nie jest tutaj elastyczny.

Nawet jeśli poprosisz grzecznie.

Używaj jasnych nazw

Źle:

x = "Anna"
y = 25
z = 19.99

Lepiej:

name = "Anna"
age = 25
price = 19.99

Jasne nazwy sprawiają, że kod łatwiej zrozumieć.

To ważniejsze, niż początkującym się wydaje.

Program czyta się częściej, niż się go pisze.

Zwłaszcza przez ciebie.

O północy.

Po tym, jak zapomniałeś, co napisałeś.

Więc nie karz przyszłego siebie.

Używaj dobrych nazw.

Snake case

W Pythonie nazwy zmiennych zwykle używają snake_case.

Przykład:

first_name = "Anna"
last_name = "Rossi"
user_age = 25
product_price = 19.99

Snake case oznacza:

małe litery rozdzielone underscores

Tak:

very_clear_variable_name

Nazywa się snake_case, bo wygląda jak wąż.

Bardzo zorganizowany wąż.

Ponieważ jesteśmy w Pythonie, brzmi to odpowiednio.

Case sensitivity

Python jest case-sensitive.

To są różne zmienne:

name = "Anna"
Name = "Marco"
NAME = "Sofia"

print(name)
print(Name)
print(NAME)

Output:

Anna
Marco
Sofia

Python widzi je jako trzy różne nazwy.

Ale proszę, nie rób tak w prawdziwym kodzie.

To jest mylące.

Mylący kod to miejsce, gdzie bugi wynajmują mieszkania.

Używaj jednego jasnego stylu.

Wybieraj:

name

a nie:

Name
NAME
nAmE

Twój kod nie jest listem od porywacza.

Typowy błąd: użycie zmiennej przed jej utworzeniem

Źle:

print(name)

name = "Anna"

Python wykonuje kod od góry do dołu.

W pierwszej linii name jeszcze nie istnieje.

Więc Python narzeka:

NameError: name 'name' is not defined

Poprawnie:

name = "Anna"

print(name)

Najpierw utwórz zmienną.

Potem jej użyj.

Bardzo proste.

Bardzo ważne.

Jak założenie butów przed wyjściem na zewnątrz.

Zwykle zalecane.

Typowy błąd: brak cudzysłowów wokół tekstu

Źle:

name = Anna

Python myśli, że Anna to zmienna.

Ale nie stworzyliśmy zmiennej o nazwie Anna.

Poprawnie:

name = "Anna"

Tekst potrzebuje cudzysłowów.

Nazwy zmiennych nie.

Porównaj:

name = "Anna"
print(name)

To wyświetla:

Anna

Cudzysłowy tworzą tekst.

Zmienna go przechowuje.

Potem print(name) pokazuje zapisaną wartość.

Bardzo czysto.

Bardzo Python.

Typowy błąd: mylenie liczb i stringów

Spójrz na to:

age = 25

To jest integer.

A teraz to:

age = "25"

To jest string.

To nie jest to samo.

Spróbuj:

age = "25"

print(type(age))

Output:

<class 'str'>

Chociaż wygląda jak liczba, Python traktuje to jako tekst, bo jest w cudzysłowie.

To ma znaczenie.

Duże znaczenie.

Zwłaszcza przy obliczeniach.

Przykład: stringa nie można używać jak liczby

Spróbuj:

age = "25"
next_year = age + 1

print(next_year)

To spowoduje błąd.

Dlaczego?

Bo age jest tekstem.

Python nie może dodać liczby 1 do tekstu "25".

Poprawnie:

age = 25
next_year = age + 1

print(next_year)

Output:

26

Typy danych mają znaczenie.

Python nie zgaduje.

Python nie mówi:

To wygląda jak liczba, więc może...

Nie.

Python trzyma się typu.

Surowy.

Ale sprawiedliwy.

Przeważnie.

Konwertowanie typów

Czasami trzeba przekonwertować wartość z jednego typu na inny.

Przykłady:

age_text = "25"
age_number = int(age_text)

print(age_number + 1)

Output:

26

Tutaj:

int(age_text)

zamienia string "25" na integer 25.

Możesz też używać:

str()
float()
bool()

Przykłady:

number = 25
text = str(number)

price_text = "19.99"
price = float(price_text)

Konwersję typów poćwiczymy bardziej później.

Na razie po prostu wiedz, że istnieje.

To jak powiedzenie Pythonowi:

Proszę, potraktuj tę wartość jako inny typ.

Python może się zgodzić.

Chyba że wartość nie ma sensu.

Przykład:

int("banana")

Python zdecydowanie się nie zgodzi.

Zrozumiałe.

Mini program: cena produktu

Utwórz plik:

product.py

Napisz:

product_name = "Notebook"
price = 5.99
quantity = 3

total = price * quantity

print(f"Product: {product_name}")
print(f"Price: {price}")
print(f"Quantity: {quantity}")
print(f"Total: {total}")

Uruchom:

python product.py

albo:

python3 product.py

Output:

Product: Notebook
Price: 5.99
Quantity: 3
Total: 17.97

To już jest przydatna logika.

Przechowujesz dane.

Obliczasz wynik.

Wyświetlasz czytelny komunikat.

Malutki program.

Prawdziwa idea.

Bardzo dobrze.

Mini program: profil użytkownika

Utwórz kolejny plik:

profile.py

Napisz:

first_name = "Anna"
last_name = "Rossi"
age = 25
city = "Rome"
is_student = True

print(f"Name: {first_name} {last_name}")
print(f"Age: {age}")
print(f"City: {city}")
print(f"Student: {is_student}")

Output:

Name: Anna Rossi
Age: 25
City: Rome
Student: True

To prosty profil użytkownika.

Wiele prawdziwych aplikacji przechowuje takie informacje.

Oczywiście prawdziwe aplikacje przechowują je w bazach danych.

Ale przed bazami danych potrzebujemy zmiennych.

Zmienna to pierwsza mała pamięć.

Baza danych to duża, poważna pamięć z papierologią.

Praktyka

Utwórz plik:

practice_variables.py

Napisz zmienne dla:

• swojego imienia;
• swojego wieku;
• swojego miasta;
• ulubionego języka programowania;
• informacji, czy uczysz się Pythona;
• ceny czegoś, co kupiłeś;
• ilości.

Przykład:

name = "Viktor"
age = 33
city = "Vigevano"
favorite_language = "Python"
is_learning_python = True
price = 12.50
quantity = 2

total = price * quantity

print(f"Name: {name}")
print(f"Age: {age}")
print(f"City: {city}")
print(f"Favorite language: {favorite_language}")
print(f"Learning Python: {is_learning_python}")
print(f"Total price: {total}")

Uruchom plik.

Potem zmień wartości.

Uruchom ponownie.

Cel to zrozumieć ten cykl:

zmień wartości
uruchom program
zobacz inny output

To jedna z głównych mocy zmiennych.

Kod może zostać taki sam.

Dane mogą się zmieniać.

Bardzo przydatne.

Bardzo programistyczne.

Mini wyzwanie

Utwórz plik:

small_shop.py

Twój program powinien przechowywać:

• nazwę produktu;
• cenę produktu;
• ilość;
• imię klienta;
• informację, czy produkt jest dostępny.

Potem oblicz:

cena całkowita = cena * ilość

Wyświetl paragon tak:

Customer: Anna
Product: Keyboard
Available: True
Price: 70.0
Quantity: 2
Total: 140.0

Przykładowe rozwiązanie:

customer_name = "Anna"
product_name = "Keyboard"
is_available = True
price = 70.0
quantity = 2

total = price * quantity

print(f"Customer: {customer_name}")
print(f"Product: {product_name}")
print(f"Available: {is_available}")
print(f"Price: {price}")
print(f"Quantity: {quantity}")
print(f"Total: {total}")

Teraz zmień produkt.

Zmień ilość.

Zmień cenę.

Uruchom ponownie.

Tak się uczysz.

Nie przez patrzenie na teorię, aż dusza wyjdzie z pokoju.

Tylko przez zmienianie kodu i sprawdzanie, co się stanie.

Checklist dla początkujących

Kiedy program nie działa, sprawdź:

Czy zapisałem plik?
Czy uruchamiam właściwy plik?
Czy jestem w odpowiednim folderze?
Czy dobrze napisałem nazwę zmiennej?
Czy utworzyłem zmienną przed jej użyciem?
Czy tekst jest w cudzysłowie?
Czy użyłem kropki przy liczbach dziesiętnych?
Czy przypadkiem nie użyłem spacji w nazwie zmiennej?
Czy napisałem True i False wielką literą?

Ta checklist oszczędzi ci czas.

Wiele błędów początkujących jest małych.

Mały błąd.

Duży dramat.

Klasyczne programowanie.

Podsumowanie

Dzisiaj nauczyłeś się:

• zmienne przechowują wartości;
• = przypisuje wartość do zmiennej;
• Python wykonuje kod od góry do dołu;
• zmienne mogą się zmieniać;
• stringi przechowują tekst;
• integery przechowują liczby całkowite;
• floaty przechowują liczby dziesiętne;
• booleany przechowują True albo False;
• type() pokazuje typ wartości;
• f-stringi jasno łączą tekst i zmienne;
• zmienne mogą być używane w obliczeniach;
• nazwy zmiennych powinny być jasne;
• Python zwykle używa snake_case;
• Python jest case-sensitive;
• tekst potrzebuje cudzysłowów;
• liczby nie potrzebują cudzysłowów;
• typy danych mają znaczenie.

To jedna z najważniejszych lekcji w programowaniu.

Zmienne są wszędzie.

Każdy użyteczny program przechowuje wartości.

Imię.

Liczbę.

Cenę.

Wynik.

Stan.

Prawdę.

Błąd.

Może nie sam błąd.

Ale dane o błędzie.

Bardzo nowocześnie.

Bardzo Python.

Następna lekcja

W następnej lekcji nauczymy się input.

Nauczysz się pytać użytkownika o informacje:

name = input("What is your name? ")

Wtedy twoje programy staną się interaktywne.

Zamiast tylko wyświetlać stałe wartości, będą zadawać pytania i odpowiadać.

To moment, kiedy program zaczyna wyglądać, jakby żył.

Nie za bardzo żył.

Nie budujemy buntu robotów.

Tylko mały program w Pythonie.

Na razie.