83 KiB
83 KiB
Podstawy języka Python
sides = [5, 6, 7]
# calculate the semi-perimeter
s = sum(sides) / 2
# calculate the area
area = s
for side in sides:
area = area * (s - side)
area = area ** 0.5
print(f'The area of the triangle is {area}')The area of the triangle is 14.696938456699069
Zmienne
user1 = "Alicja"
user2 = "Bartosz"
user3 = "Cecylia"user = "jakub.pokrywka"
mail_domain = "amu.edu.pl"
email = user + '@' + mail_domainprint(email)jakub.pokrywka@amu.edu.pl
x = 'a'x'a'
Zmienne
- Nazwy zmiennych muszą być unikatowe.
- Wielkość liter w nazwie zmiennych ma znaczenie.
- Brak konieczności określenia typu.
Funkcja print
print('Hello Python!')Hello Python!
print('Hello')
print('Python')
print('Hello', 'Python', '!')Hello Python Hello Python !
user = 'jakub'
print(user)
print('Użytkownik:', user)jakub Użytkownik: jakub
Typy liczbowe
- liczby całkowite:
int - liczby rzeczywiste (zmiennoprzecinkowe):
float
year = 2021
pi = 3.14159day = 17
month = 10
year = 2021
print('Dziś jest', day, '/', month, '/', year)Dziś jest 17 / 10 / 2021
Operacje arytmetyczne na liczbach:
- dodawanie
+, np.2 + 3 - odejmowanie
-, np.10-9 - mnożenie
*, np.2.0 * 3.0 - dzielenie
/, np.3 / 4( == 0.75) - dzielenie całkowite
//, np.3 / 4(0) - reszta z dzielenia
%, np.6 % 4(2) - potęgowanie
**, np.10 ** 3(1000) - nawiasy
(...)
15 // 43
a15 % 43
100**31000000
hour = 4
minutes = 14
seconds = ((60 * 60 * hour) + 60 * minutes)
print("Dziś upłynęło", seconds, "sekund.")Dziś upłynęło 15240 sekund.
print( 1 + (20 // 3) + (4 * -5) % 6)11
Operacje na zmiennej
x = 5x = x + 5x10
x += 5x15
x = 5
x = x + 5
x += 5Operatory
Na przykład:
+=-=/=*=
Konwersja typów
3 3
'3''a''a'
3 + int('1')4
int(-3.9)-3
type(float(-3))float
pi_int = int(-3.14)
print(pi_int)
trzy = float(3)
print(trzy)
print(3)-3 3.0 3
4/31.3333333333333333
3 * 2.36.8999999999999995
3 * int(2.3)6
x = '3.14'
print(float(x) * 2)
print(int('42') / 6)6.28 7.0
type('a')str
type('aaaa')str
Wartości logiczne
W Pythonie są dwie wartości logiczne:
- prawda (
True), - fałsz (
False).
x = False
print(x)False
- Wszystkie liczby różne od 0 mają wartość logiczną
True. - Funkcja
boolpozwala na konwersję do zmiennej logicznej. - Do negacji służy słowo kluczowe
not.
TrueTrue
FalseFalse
True and FalseFalse
True or FalseTrue
suma = 1 + 2
print('Wartość logiczna sumy:', bool(suma))
print('Wartość logiczna zera to: ', bool(0), bool(0.0))
print(not False)Wartość logiczna sumy: True Wartość logiczna zera to: False False True
bool(0.0)False
bool(5.2)True
a =3 4 >= 4False
Operatory porównania
- równość:
== - różne:
!= - większy:
> - większy lub równy:
>= - mniejszy:
< - mniejszy lub równy
<=
user = 'bob'
print(user == 'bob')
print(3 < 7)
print(0 != 0.0)True True False
print(1 != 1.0)False
Do łączenia warunków logicznych służą dwa słowa kluczowe:
and: koniunkcja,or: alternatywa.
print(True and True)
print(True and False)
print(True or False)
print(False or False)True False True False
W Pythonie istnieje jeszcze jeden typ wartości None, który oznacza brak wartości lub wartość pustą.
user = None
print('Wartość zmiennej:', user)
print('Wartość logiczna zmiennej:', bool(user))
print(user == False)
Wartość zmiennej: None Wartość logiczna zmiennej: False False
Czas na pierwsze zadanie (1a i 1b).
"""
* stwórz zmienną o nazwie `pi` i o wartości 3.14.
* stwórz zmienną o nazwie `promien` i o wartości 12.
* oblicz pole koła i przypisz wynik do zmniennej `pole`. P = pi * r ** 2
* wyświetl wynik na ekran.
"""
'\n * stwórz zmienną o nazwie `pi` i o wartości 3.14.\n * stwórz zmienną o nazwie `promien` i o wartości 12.\n * oblicz pole koła i przypisz wynik do zmniennej `pole`. P = pi * r ** 2\n * wyświetl wynik na ekran.\n'
pi = 3.14promien=12P = pi * promien **2print(P)452.16
"""
Zamień typ zmiennych `a`, `b` i `c` na typy liczbowe (int lub float) i oblicz ich sumę.
Wynik zapisz do zmiennej `wynik` i wyświetl go na ekranie
"""
# zmienne do zadania
a = "12"
b = "35.5"
c = Truetype(4.2)float
type("4.2")[0;31m---------------------------------------------------------------------------[0m [0;31mValueError[0m Traceback (most recent call last) Cell [0;32mIn[150], line 1[0m [0;32m----> 1[0m [38;5;28mfloat[39m([38;5;124m"[39m[38;5;124m4.2a[39m[38;5;124m"[39m) [0;31mValueError[0m: could not convert string to float: '4.2a'
4.2 == "4.2"False
a = float(a)b = float(b)c = float(c)wynik = a + b + cwynik48.5
Komentarze
- Komentarze nie są interpretowane.
- Komentarze w Pythonie zaczynają się od znaku '#'
- Istnieją komentarze wielolinijkowe tagowane potrójnym ", czyli """ """
print("Bardzo ważna wiadomość") # A to jest komentarz
"""
Komentarz
wielo-
linijkowy
"""
# print("Nie chcę być wydrukowanym")
print("Mamy piękną jesień.")Bardzo ważna wiadomość Mamy piękną jesień.
Ciągi znaków (łańcuchy znakowe lub stringi)
- Możemy zdefiniować je na 3 sposoby:
'',""lubstr. - Python preferuje pojedynczy cudzysłów.
- Domyślne kodowanie to UTF-8.
user0 = 'John'
user1 = "Alice"
nun_users = str(2)str(2)'2'
'sfdsf"sd"fdsfs"dfsd''sfdsf"sd"fdsfs"dfsd'
sent = "It's f' ' ' 'ine."
sent = 'It\'s fine.'
print(sent)It's fine.
var = str(2021)
print('rok:', var)
print(var == 2021)
print(var == '2021')rok: 2021 False True
# Pusty ciąg znaków
x = ''x''
Operacje na stringach
- łączenie:
+ - powtórzenie:
*
'2' + '3''23'
username = 'j.pokrywka'
domain = 'amu.edu.pl'
email = username + '@' + domain
print(email)j.pokrywka@amu.edu.pl
'O' * 8'OOOOOOOO'
big_no = 'N' + 'O' * 8 + '!'
print(big_no)NOOOOOOOO!
date = str(2021) + '/' + str(10) + '/' + str(17)
print('Dziś jest', date)Dziś jest 2021/10/17
Operacje na stringach, cd.
- długość łańcucha znakowego:
len: np.len('Ala') == 3, - zamiana na małe litery
lowerlub na wielkie:upper, - zamiana liter:
replace, - usuwanie białych znaków:
strip, - sprawdzenie czy string rozpoczyna sie danych prefiksem:
startswith.
'PythoFDSFDSn'.lower()'pythofdsfdsn'
user'mickiewicz'
user.replace('i', 'X')'mXckXewXcz'
' 2021 '
' 2021 '
print(' 2021 '.strip())
2021
user = 'mickiewicz'
print('Słowo', user, 'ma', len(user), 'liter.')
print('Python'.lower())
print(user.replace('T', 'R'))
print(' 2021 '.strip())
print(user.startswith('mic'))Słowo mickiewicz ma 10 liter. python mickiewicz 2021 True
'a' + 'b''ab'
'Słowo {user} ma {len(user)} liter.''Słowo {user} ma {len(user)} liter.'user = 'tomasz'
print('Słowo', user, 'ma', len(user), 'liter.')
print(f'Słowo {user} ma {len(user)} liter.')
print(len(str(123)))Słowo tomasz ma 6 liter. Słowo tomasz ma 6 liter. 3
Czas na zadanie (1c).
"""
* Stwórz 2 zmiennie: firstname i surname, które będą zawierać Twoje imię i nazwisko.
* Połącz te zmiennie w takim sposób, żeby było rozdzielone spacją i zapisz wynik do zmiennej fullname.
* Wykorzystaj f-string i wyświetl na ekran zawartość zmiennej fullname, w taki sposób, żeby zawartość zmiennej była poprzedzona słowami "Nazywam się ".
* Wyświetl sumaryczną długość zmiennych firstname i surname.
"""
firstname = "Jakub"
surname = "Pokrywka"
print(f"Nazywam się {firstname} {surname}.")
print(firstname.lower())
print("Nazywam się %s %s" % (firstname, surname))
firstname = "Jakub"
surname = "Pokrywka"fullname = firstname + ' ' + surnamefullname'Jakub Pokrywka'
print(f"Nazywam sie {fullname}")Nazywam sie Jakub Pokrywka
Listy (list)
- Typ danych, który pozwala przechowywać wiele wartości.
- Dostęp do poszczególnych elementów jest przez indeks elementu.
- Indeksowanie zaczyna się od 0.
- Funkcja
listzamienia obiekt na listę.
x = [] # albo równoważnie
y = list()
oceny = [5, 4, 3, 5, 5]
misc = [3.14, "pi", ["pi"], 3]
list_0_9 = list(range(10))numbers = [6, 7, 9, 11]
print('Liczba elementów:', len(numbers))Liczba elementów: 4
numbers = [6, 7, 9, 11]
print(numbers[1])7
Dodawanie i usuwanie elementów z listy
Istnieją dwie metody:
append(x): dodaje x na koniec listyextend(x): rozszerza listę o każdy element z x
engines = []
engines.append('duck-duck-go')
engines.append("yahoo")
print(engines)['duck-duck-go', 'yahoo']
engines = ['duck-duck-go', 'yahoo']
searches = ["google", 'bing']
engines.extend(searches)
print(engines)['duck-duck-go', 'yahoo', 'google', 'bing']
engines = ['duck-duck-go', 'yahoo']
searches = ["google", 'bing']
print(engines + searches)
print(engines)['duck-duck-go', 'yahoo', 'google', 'bing'] ['duck-duck-go', 'yahoo']
liczby = [1, 2, 3, 2, 3, 1, 2, 4]
liczby.pop(1) # Domyślnie usuwa ostatni element z listy
print(liczby)
liczby.remove(2)
print(liczby)[1, 3, 2, 3, 1, 2, 4] [1, 3, 3, 1, 2, 4]
Inne przydatne metody:
sort(): sortuje listę rosnącocount(x): zlicza wystąpienia x w liścieindex(x): zwraca indeks pierwszego wystąpienia x
len(liczby)8
liczby = [1,2,3,2,3,1,2,4]
print(liczby.count(1))
print(liczby.index(4))
liczby.sort()
print(liczby)2 7 [1, 1, 2, 2, 2, 3, 3, 4]
Indeksowanie
oceny[:5][1, 3, 2, 3, 1]
oceny = [1, 3, 2, 3, 1, 2, 4]
print('pierwszy element:', oceny[0])
print('ostatni element:', oceny[-1])
print('5 pierwszych:', oceny[:5])
print('5 ostatnich', oceny[-5:])
print('od drugiego, do piątego', oceny[1:5])
print('parzyste:', oceny[1:6:2])
print('od tyłu', oceny[::-1])pierwszy element: 1 ostatni element: 4 5 pierwszych: [1, 3, 2, 3, 1] 5 ostatnich [2, 3, 1, 2, 4] od drugiego, do piątego [3, 2, 3, 1] parzyste: [3, 3, 2] od tyłu [4, 2, 1, 3, 2, 3, 1]
Funkcje wbudowane
len- zwraca liczbę elementów listy.min- zwraca wartość najmniejszgo elementu.max- zwraca wartość największego elementu.sum- zwraca sumę elementów.all- zwracaTrue, gdy wszystkie elementy mają wartośćTrue.any- ZwracaTrue, gdy przynajmniej jeden element ma wartośćTrue.
numbers = [4, 8, 12, 18, 0, 32]
print('Liczba elementów:', len(numbers))
print('Najmniejszy element:', min(numbers))
print('Największy element:', max(numbers))
print('Suma elementów:', sum(numbers))
print(all(numbers))
print(any(numbers))Liczba elementów: 6 Najmniejszy element: 0 Największy element: 32 Suma elementów: 74 False True
Krotki (tuple)
Podobnym typem do listy jest krotka (tuple):
- definiuje się ją
()lubtuple(), - nie można zmieniać krotki: nie można dodawać ani usuwać elementów,
- nie można również zmieniać elementów*,
- Indeksowanie identyczne jak w listach.
numbers = [4, 5, 7]
numbers[2]7
numbers[2] = 10users = ([0], [1, 2], [3, 4, 5])
users[0].append(1)
print(users)([0, 1], [1, 2], [3, 4, 5])
Czas na zadanie (2a, 2b, 2c).
Słowniki (dict)
Pewnego rodzaju uogólnieniem listy jest słownik (dict), który przechowuje dane jako klucz: wartość.
- Słowniki pozwala na dodawanie, usuwanie i zmianę elementów.
- Definiujemy jako
{}lubdict(). - Klucze słownika muszą być niezmienialne (haszowalne).
store = {}
store = dict()
s_oceny = {
"Justyna": [5,5,5],
"Bartek": [3,4,5],
"Ola": [3,3,3]}
s_oceny = dict([("Justyna", [5,5,5]), ("Bartek", [3,4,5]), ("Ola", [3,3,3])])
s_oceny = {"Justyna" : [5,5,5], "Bartek" : [3,4,5], "Ola": [3,3,3]}
print(s_oceny){'Justyna': [5, 5, 5], 'Bartek': [3, 4, 5], 'Ola': [3, 3, 3]}
s_oceny = {"Justyna" : [5,5,5], "Bartek" : [3,4,5], "Ola": [3,3,3]}
user = 'Bartek'
print(s_oceny[user])[3, 4, 5]
s_oceny = {"Justyna" : [5,5,5], "Bartek" : [3,4,5], "Ola": [3,3,3]}
s_oceny['Jan'] = [4, 4, 5]
print(s_oceny){'Justyna': [5, 5, 5], 'Bartek': [3, 4, 5], 'Ola': [3, 3, 3], 'Jan': [4, 4, 5]}
s_oceny = {"Justyna" : [5,5,5], "Bartek" : [3,4,5], "Ola": [3,3,3]}
s_oceny['Ola'].extend([1,4])
print(s_oceny){'Justyna': [5, 5, 5], 'Bartek': [3, 4, 5], 'Ola': [3, 3, 3, 1, 4]}
s_oceny = {"Justyna" : [5,5,5], "Bartek" : [3,4,5], "Ola": [3,3,3]}
del s_oceny["Justyna"]
print(s_oceny){'Bartek': [3, 4, 5], 'Ola': [3, 3, 3]}
Operacje
- Funkcja
lenzwraca liczbę elementów w słowniku. - Domyślnie operacje funkcji wykonywane są na kluczach.
- metoda
keys()zwraca klucze słownika,values()-- wartości, aitems()-- pary (klucz, wartość).
binary_ones = {1: 1, 3: 2, 5: 2, 11: 3}
max(binary_ones)
print(binary_ones.keys())
print(binary_ones.values())
print(binary_ones.items())dict_keys([1, 3, 5, 11]) dict_values([1, 2, 2, 3]) dict_items([(1, 1), (3, 2), (5, 2), (11, 3)])
s_oceny = {"Justyna" : [5,5,5], "Bartek" : [3,4,5], "Ola": [3,4,3]}
print(s_oceny["Ola"][1])4
users = {'ali99': {'name': 'Alice', 'age': 28}, 'bob90': {'name': 'Bob', 'age': 19}}
print(users['ali99']['age'])28
Czas na zadanie (3).
Instrukcja warunkowa (if ... elif ... else)
- Pozwala na wykonanie (wciętego) fragmentu kodu w zależności od czy podany warunek jest spełniony:
if <warunek>: instrukcja 1 ... elifpozwala na sprawdzenie kolejnego warunku.elsezostanie wykonany, gdy żaden warunek nie został spełniony.- Elementy
elifielsenie są obowiązkowe.
score_theory = 40
score_practical = 45
if score_theory + score_practical > 100:
print("Zdobyłeś wystarczającą liczbę punktów.")
print('------')Zdobyłeś wystarczającą liczbę punktów. ------
Jedną ważną rzeczą jest to, że kod, który następuje po instrukcji if jest wcięty. Dzięki temu interpreter Pythona jest w stanie określić, które instrucje wchodzą w skład bloku warunkowego, a które nie.
Blok else jest opcjonalny i jest wykonywany, gdy warunek zawarty w instrukcji if nie jest spełniony.
Na poniższym przykładnie mamy własnie taki przypadek. Warunek w ifie: score_theory + score_practical > 100 nie jest spełniony, stąd wykonają się instrukcje z bloku else.
score_theory = 140
score_practical = 45
if score_theory + score_practical > 100:
print("Zdobyłeś wystarczającą liczbę punktów.")
print('------')
else:
print("Nie zdobyłeś wystarczającej liczby punktów.")Zdobyłeś wystarczającą liczbę punktów. ------
Instrukcja warunkowa if pozwala na sprawdzenie wielu warunków -- służy do tego instrukcja elif (else if). Warunki są sprawdzane po kolei (od góry): jeżeli warunek zawarty po if nie jest spełniony, wtedy sprawdzany jest pierszy warunek z elif. Gdy żaden warunek nie jest spełniony, wtedy wykona się kod zawarty w bloku else.
score_theory = 40
score_practical = 45
if score_theory + score_practical > 100:
print("Zdobyłeś wystarczającą liczbę punktów.")
print('------')
elif score_theory + score_practical > 80:
print("Będziesz mieć dodatkowy egzamin.")
else:
print("Nie zdobyłeś wystarczającej liczby punktów.")Będziesz mieć dodatkowy egzamin.
Nic nie stoi na przeszkodzie, żeby zagnieżdżać instrukcje warunkowe. W poniższym przykładzie widzimy, że druga instrukcja warunkowa jest zawarta w bloku po pierwszym if.
score_theory = 55
score_practical = 50
if score_theory + score_practical > 100:
print("Zdobyłeś wystarczającą liczbę punktów.")
if score_theory > score_practical:
print('Wolisz teorię od praktyki')Zdobyłeś wystarczającą liczbę punktów. Wolisz teorię od praktyki
Sprawdzenie obecności w kolekcji (in)
- Słowo kluczowe
insprawdza czy dany element znajduje sie w kolekcji (np. lista, słownik). - Jego negacja to
not in.
Python zawiera bardzo przydatny warunek in, który sprawdza czy dany element jest zawarty w danej kolecji, np. w liście lub w słowniku.
W poniższym przykładzie sprawdzamy, czy liczba 67 jest zawarta w liście.
numbers = [67, 101, 303]
if 67 in numbers:
print('67 jest na liście.')67 jest na liście.
W przypadku słowników (dict) sprawdzane jest czy istnieje w słowniku zadany klucz.
ingredients = {'apple': 4, 'lemon': 1, 'cherry': 14}
if 'apple' in ingredients:
print('Jabłko jest składnikiem.')Jabłko jest składnikiem.
Możemy wykorzystać warunek in do sprawdzenie, czy dany tekst jest podciągiem w drugim.
my_programming_lang = "Python"
if "on" in my_programming_lang:
print('Yes!')Yes!
Żeby sprawdzić czy dany element nie występuje możemy wykorzystać instrukcję not in.
shopping_list = ['apples', 'bread', 'carrots']
if 'cookies' not in shopping_list:
print('Omiń alejkę ze słodyczami.')Omiń alejkę ze słodyczami.
Obiekty o wartości logicznej False
00.0[](){}None
Bardzo często można spotkać się, gdy chcemy sprawdzić np. czy data lista jest pusta.
numbers = []
if numbers:
print('średnia liczb to:', sum(numbers) / len(numbers))Czas na zadanie (4a, 4b).
Pętla typu for
- W Pythonie pętla _for działa jak pętla for each w innych językach;
for zmienna in kolekcja: instukcja 1 instrukcja 2 ... - Pętla pozwala na zapętlenie kodu, który znajduje w wciętym bloku.
- Konstrukcja pętli jest następująca: po słowie
formusimy podać nazwę zmiennej, która po kolei będzie przyjmować wartości z kolekcji, np. z listy. Pętla wykona się tyle razy, ile jest elementów w kolekcji. - Funkcja
range(n)zwraca kolekcję liczb od0don-1.
To na co warto zwrócić uwagę to wcięcie. Kod, który ma zostać wykonany w pętli musi być wcięty.
list(range(10))[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
for i in [4,6,7]:
print(i**2)16 36 49
ingredients = ['apples', 'cherries', 'pineapple']
for ingredient in ingredients:
print('element', ingredient)element apples element cherries element pineapple
Funkcja range(n) zwraca obiekt, który możemy przekonwertowąć na listę elementów od 0 do n-1.
print(list(range(5)))[0, 1, 2, 3, 4]
Bardzo często można spotkać poniżsżą kombinację funkcji range i len w kontekście pętli:
ingredients = ['apples', 'cherries', 'pineapple']
for i in range(len(ingredients)):
print(ingredients[i])apples cherries pineapple
W przypadku połączenia słownika i pętli, do zmiennej przypisywane są kolejne klucze ze słownika (przykład poniżej):
shopping_list = {'apple': 4, 'lemon': 1, 'cherry': 14}
for item in shopping_list:
print(item)apple lemon cherry
Jak wcześniej wspomniałem, metoda items() zwraca listę krotek: (klucz, wartość) i możemy wykorzystać to w pętli for. W tym przypadku musimy podać dwie zmienne:
shopping_list = {'apples': 4, 'lemon': 1, 'cherries': 14}
for item, number in shopping_list.items():
print('Buy', number, item)Buy 4 apples Buy 1 lemon Buy 14 cherries
Możemy też iterować po stringu -- znak po znaku:
'Python'[1]'y'
for char in 'Python':
print(char)P y t h o n
Ćwiczenie: czy rozumiesz kod, który był na początku zajęć?
sides = [5, 6, 7]
# calculate the semi-perimeter
s = sum(sides) / 2
# calculate the area
area = s
for side in sides:
area = area * (s - side)
area = area ** 0.5
print(f'The area of the triangle is {area}')The area of the triangle is 14.696938456699069
Zagnieżdżając dwie pętle musimy pamiętać o dodatkowym wcięciu (tak jak w przykładzie poniżej).
for i in range(3):
print(i)
for j in range(10,12):
print(i+j)
print('aaa')0 10 11 aaa 1 11 12 aaa 2 12 13 aaa
Czas na zadanie (5a, 5b, 5c i 5d).
Funkcje
- Pozwalają na uniknięcie pisania tego samego kodu za każdym razem.
- Pozwalają na wielokrotne wykorzystanie tego samego fragmentu kodu.
- Zwiększają czytelność kodu.
Definicja funkcji wygląda następująco:
- najpierw piszemy słowo kłuczowe
def, następnie nazwę funkcji, później w nawiasach okrągłych listę argumentów i kończymy dwukropkiem. - następnie wcięty blok to będzie kod funkcji.
len(numbers)3
def hello():
print('Hello!')
hello()Hello!
W powyższym przykładzie zdefiniowaliśmy funkcje hello, która nie przyjmuje żadnych argumentów. Wywołanie tej funkcji nie różni się od wywołań innych funkcji.
Słowo kluczowe return pozwala na zwrócenie wartości przez funkcję. Poniższa funkcja get_five zwraca liczbę pięć.
def get_five():
return 5
x = get_five()
print(x)5
Argumenty funkcji umieszczamy w nawiasach:
def nazwa_funkcji(arg_1, arg_2, arg_3):
instrukcja 1
instrukcja 2
return jakaś wartość
Przykład: poniższa funkcja get_bigger przyjmuje dwa argumenty: a i b, które rozdzielamy przecinkiem.
def get_bigger(a, b):
if a >= b:
return a
return b
print(get_bigger(56, 512))512
def srednia(lista):
s = 0
for item in lista:
s += item
return s / len(lista)
print(srednia([7,8,9]))8.0
def count(lista, item):
l = 0
for i in lista:
if i == item:
l += 1
return lPodczas wywoływania funkcji możemy dopowiedzieć, która argument jaką przyjmuje wartość.
count([5,5,5,4], 5)
count(lista=[5,5,5,4], item=5)
count(item=5, lista=[5,5,5,4])3
Czas na zadanie (7a i 7b).
Korzystanie z bibliotek
Python posiada bogatą kolekcję bibliotek wbudowanych, tzn. które są dostarczone wraz z interpreterem.
Żeby móc wykorzystać daną bibliotekę, to musimy ją zaimportować. Możemy to zrobić na dwa sposoby:
import <nazwa_biblioteki>. Dostęp do elementów jest poprzez<nazwa_biblioteki>.nazwa_funkcji.from <nazwa_biblioteki> import <nazwa funkcji>: pozwala na dołączenie elementów biblioteki, tak jakby były częścią naszego skryptu.Przykłady:
import osos.getenv("USER")'kubapok'
from os import getenvgetenv("USER")'kubapok'
import os
print(os.name)
from os import getenv
print('Nazwa uzytkownika: {}'.format(getenv("USER")))posix Nazwa uzytkownika: kuba
- Importujemy bibliotekę
os. Dostęp do stałej jest "przez kropkę". - Z biblioreki
osimportujemy funkcjęgetenv(zwraca wartości zmiennych systemowych).
Wystarczy, że zaimportujemy raz daną bibliotekę:
import math
math.cos(math.pi)-1.0
Jeżeli nazwa biblioteki jest za długa, to możemy użyć aliasu: import <nazwa_biblioteki> as <alias>:
import calendar as cal
cal.TextCalendar().prmonth(2021, 10) October 2021
Mo Tu We Th Fr Sa Su
1 2 3
4 5 6 7 8 9 10
11 12 13 14 15 16 17
18 19 20 21 22 23 24
25 26 27 28 29 30 31
Ważniejsze biblioteki wbudowane:
os,sys: obsługa rzeczy dt. systemu i środowiskadatetime: wszystko co jest związane z czasemcollections: zawieraCounteridefaultdict
Czas na zadanie (9a i 9b).
Obsługa plików
zen_file = open('./zen_of_python.txt')
zen_text = zen_file.read()
print(zen_text[:95])
zen_file.close()Beautiful is better than ugly. Explicit is better than implicit. Simple is better than complex.
zen_file = open('./zen_of_python.txt')
zen_file.close()zen_file = open('./zen_of_python.txt')
zen_lines = list(zen_file)
for line in zen_lines[:3]:
print(line.strip())
zen_file.close()Beautiful is better than ugly. Explicit is better than implicit. Simple is better than complex.
zen_lines
['Beautiful is better than ugly.\n', 'Explicit is better than implicit.\n', 'Simple is better than complex.\n', 'Complex is better than complicated.\n', 'Flat is better than nested.\n', 'Sparse is better than dense.\n', 'Readability counts.\n', "Special cases aren't special enough to break the rules.\n", 'Although practicality beats purity.\n', 'Errors should never pass silently.\n', 'Unless explicitly silenced.\n', 'In the face of ambiguity, refuse the temptation to guess.\n', 'There should be one-- and preferably only one --obvious way to do it.\n', "Although that way may not be obvious at first unless you're Dutch.\n", 'Now is better than never.\n', 'Although never is often better than *right* now.\n', "If the implementation is hard to explain, it's a bad idea.\n", 'If the implementation is easy to explain, it may be a good idea.\n', "Namespaces are one honking great idea -- let's do more of those!\n"]
with open('./zen_of_python.txt') as zen_file:
print(zen_file.read()[:95])Beautiful is better than ugly. Explicit is better than implicit. Simple is better than complex.
!ls1_wprowadzenie_do_python.ipynb 2_podstawy.ipynb zadania zen_of_python.txt
tree_per_sqkm = {
"Brazil": 39542,
"Bulgaria": 24987,
}
with open('./zalesienie.txt', mode='w') as plik:
for country, num_trees in tree_per_sqkm.items():
plik.write(country + ',' + str(num_trees) + '\n')
!ls1_wprowadzenie_do_python.ipynb zadania zen_of_python.txt 2_podstawy.ipynb zalesienie.txt
!cat zalesienie.txtBrazil,39542 Bulgaria,24987
Podstawy Obiektowości
- W Pythonie każda wartość jest obiektem, tzn. może zostać przypisana do zmiennej lub zostać przekazane do funkcji.
- Każda wartość może mieć metody lub atrybuty.
from datetime import date
today = date(2022, 11, 5)
print(today.month) # atrybut
print(today.weekday()) # metoda11 5
class Item():
def __init__(self, a):
self.aaa = a + 10item = Item(x)item.aaa15