Spis treści

Koniec na video 24 ............................................................................................................................................... 1

Running Jupyter....................................................................................................................................................... 1
Zasób z Jupyther notebook ............................................................................................................................... 3
Skróty klawiszowe w Jupyter notebooks .................................................................................................. 3
Basic Arithmetics .................................................................................................................................................. 4
Podstawowe komendy ...................................................................................................................................................... 4
Strings ............................................................................................................................................................................... 6
Print formatting ............................................................................................................................................................ 8
Lists [ ] ............................................................................................................................................................................... 9
Methods for list........................................................................................................................................................... 10
Looping through list .................................................................................................................................................... 13
TUPLE .............................................................................................................................................................................. 14
DICTIONARY .................................................................................................................................................................... 15
LOOPS FOR DICTIONATIES .......................................................................................................................................... 17
Nested dictionaries ..................................................................................................................................................... 18
SETS ................................................................................................................................................................................. 19
Testowanie wystepowania wartosci przy uzyciu IN........................................................................................................ 20
FILES ................................................................................................................................................................................ 20
Operator & (ampersand) ................................................................................................................................................ 25
Functions ......................................................................................................................................................................... 26
Modules .......................................................................................................................................................................... 28
OPERATORY ..................................................................................................................................................................... 29
PĘTELE I WARUNKI LOGICZNE ......................................................................................................................................... 30
IF, ELIF, ELSE ................................................................................................................................................................ 30
WHILE .......................................................................................................................................................................... 31
FOR .............................................................................................................................................................................. 33

Koniec na video 29

Running Jupyter
Start > cmd i wybieramy anaconda prompt i wpsujemu jupyter notebook
W przegladarce otworzy się nam http://localhost:8888/tree który będzie Jupyter notrebook

Potem klikamy New i wybieramy Python3.

Shift + enter > uruchamia kod jaki wpisaliśmy, można też wybrać RUN

Po uruchomieniu Anacond aPrompt możemy tez wpisac „Python” w cmd i będziemy działać w edytorze
pythona w komand linie

Programy możemy też pisać w edytorze tekstowym np. notepad i potem zapisać w directory gdzie
mamy zainstalowaną Anaconda
Uruchomienie kodu w pliku to po prostu wpisanie nazwy pliku *.py znajdujacego się w folderze
Anaconda

Zasób z Jupyther notebook

Główny katalog
http://nbviewer.jupyter.org/github/jmportilla/
Katalog dla kursu
http://nbviewer.jupyter.org/github/jmportilla/Complete-Python-Bootcamp/tree/master/

Skróty klawiszowe w Jupyter notebooks

Shitft + enter - runs a cell
Tab – shows a pop up of the method on an object
Shift + Tab - show help popup for doctsring
help() – pokazuje help dla komendy np. help(list) albo help (tuple)
Basic Arithmetics
+ dodwanie, - odejmowanie, * mnożenie, / -dzielenie
** potęga
% - modulo, reszta z dzielenia
To convert string got integer use int() function

Operatory pórwania

== equal to (operator porównania)

= operator przypisania!
> Greater than
>= greater or equal
< lower than
<= lower or equal
!= not equal

Chained comparison operators

1 < 2 < 3 w pythonie nalezy to czytać jako 1 < 2 and 2 < 3
1 < 3 > 2 nalezy rozumie jako 1 < 3 and 3 > 2

Multiple statements on a single line with use of ; (semicollon)

inputdata = input("Podaj swój wiek: "); age=int(inputdata)

if age >= 35:
print ("You are old enough to be a Senator or the President")
elif age>=30:
print("You are old enough to be a Senator")
else:
print ("You are not old enough to be Senator or President")

Multiple statements groups as suites

A group of individual statement which make a single block is called suite
Complex statement and class require a header line and a suite
Header line begins with key word (such as if, elif, def) and ends with : and are followed with
by one or more lines which makes the usite

if expression :
suite
elif expression :
suite
else :
suite

age = int(input("Podaj swój wiek: "))

if age >= 35:
print ("You are old enough to be a Senator or the President")
elif age>=30:
print("You are old enough to be a Senator")
else:
print ("You are not old enough to be Senator or President")

Podstawowe komendy
PODSTAWOWE INFORACJE

Variables
They are case sensitive > Fruit and fruit are 2 different variables

Typy zmiennych
• booleans (which have the value True or False)
• integers (whole numbers such as 42 and 100000000)
• floats (numbers with decimal points such as 3.14159, or sometimes exponents like
1.0e8, which means one times ten to the eighth power, or 100000000.0)
• strings (sequences of text characters)

Przypisanie wartości a=10, nie trzeba wcześniej definiować zmiennej a

1. Names can not start with a number.
2. There can be no spaces in the name, use _ instead.
3. Can't use any of these symbols :'",<>/?|\()!@#$%^&*~-+
3. It's considered best practice (PEP8) that the names are lowercase.

przypisanie wartosci do zmiennej poprzez ' = '

fruit = “apple”

uruchomienie progarmu zapisanego jako .py

>>>python /home/czajka/Desktop/Python_files/61.py

Mozna tez przejsc do lokalizacji gdzie jesten plik I go tam wywylac

>>> cd /home/czajka/Desktop/Python_files
>>> python 61.py

Komenda cat

Komenda cat pozwala nam na sprawdzenie kodu w pliku .py

>>cat 61.py
wyswielti nam zawartosc pliku
Print(“Wywolanie pliku pythona”)

# komentarz jednej lini

'''
larger multiline comments
'''

Continue lines with “ \ “ symbol

>>> litery='abc'\
... 'def'\
... 'ghi'\
... 'jkl'
>>> litery
'abcdefghijkl'

polecenie type() zwraca typ zmiennej lub obiektu

>>> type('pawel')
<class 'str'>

>>> type(44.4)
<class 'float'>

funckcja int() konwertuje 'x' na typ integer

>>> int(True)
1
>>> int(False)
0
>> a=”3”
>> b=2
>>sum = int(a) +b
5
Float() – konwertuje ‘x’ na liczbe typu float (zmienno przecinkowa)

funkcja str() konwertuje wartosc na string

>>> str(98.6)
'98.6'

input () - getting user or other program input

fruit = input ("Jaki jest Twoj ulubiony owoc? : ")
Jaki jest Twoj ulubiony owoc? : jablko
>>> print ("{} to bardzo smaczy owoc!" .format(fruit))
jablko to bardzo smaczy owoc!

Strings
String możemy podawać w pojedyńczych lub podwójnych nawiasach ‘ ‘ albo ” ”
Warto używać ” ” bo jak mamy w stringu ‘ np. w I’m to wtedy nie zwróci błędu

jak w stringu chcemy uzyc znaku “ to dobrze przypisac tekst do zmiennej jako
string = 'I wtedy powiedzial “Do diaska”'

Jak chcemy umiescic znak ' w tekscie to przypisaujemy go poprzez “

string “ co znaczy po ang i'm?”

mozemy uzyc tez symbolu escape \”

string = “I wtedy powiedzial \”Do diaska”\”

string 'co znaczy po and i\'m?'

Wywołanie stringu jako "string 1" zwroci nam 'string 1'

Wywołanie stringu jako print ("string 1") zwroci nam string 1 -> bez zadnych nawiasów

\n - zacznij od nowej linii,

\t - dodaj tabulator

print ("to jest pierwsza linia\nto jest druga linia\nto jest trzecia linia")
to jest pierwsza linia
to jest druga linia
to jest trzecia linia

a ="jakis tekst"
print(a)
>>jakis tekst

Domyślnie każdy string traktowany jest jako lista, pozycja w indexie zaczyna się od 0.

[:] extracts the entire sequence from start to end.

[ start :] specifies from the start offset to the end.
[: end ] specifies from the beginning to the end offset minus 1.
[ start : end ] indicates from the start offset to the end offset minus 1.
[ start : end : step ] extracts from the start offset to the end offset minus 1,skipping
characters by step.

>>> letters = 'abcdefghijklmnopqrstuvwxyz'

>>> letters[:]
'abcdefghijklmnopqrstuvwxyz'
>>> letters[20:] – listing since 21 letter
'uvwxyz'
>>> letters[12:15] ----Python does not include the last offset, listing 12, 13, 14
'mno'
>>> letters[-3:] -----The three last characters:
'xyz'
>>> letters[-1]
‘z’
>>> letters[-1::-1] -----This starts at the end and ends at the start, skipping nothing
'zyxwvutsrqponmlkjihgfedcba'

>>litery[::-1] – start from beg to end with step -1

'zyxwvutsrqponmlkjihgfedcba'
>>litery[::1] – list from beg to end use step 1
‘abcdefghijklmnoprstuwxyz'
>>litery[::2] – list from beg to end use step 2
'acegikmortwy'

Łacznie tekstu

>>litery + "1234567890"
'abcdefghijklmnoprstuwxyz1234567890'

>>litera ="a"
>>litera * 5
‘aaaaa’

len () - zwraca dlugosc

>>> len(letters)
26
>>> empty = ""
>>> len(empty)
0

String methods: functions -> string.function(arguments)

Split () – ZAMINIENIA TEKST NA LISTE!!

>>> todos = 'get gloves,get mask,give cat vitamins,call ambulance'

>>> todos.split(',') --- "," separator argument

['get gloves', 'get mask', 'give cat vitamins', 'call ambulance'] –stworzony obiekt to lista

>>> todos.split(‘ ‘) ---- separatorem spacja

['get', 'gloves,get', 'mask,give', 'cat', 'vitamins,call', 'ambulance']

st = 'Print only the words that start with s in this sentence'

for word in st.split(' '): - TWORZY LISTE, PO SPACJI NOWY ELEMENT NA LISCI
if word[0] == 's':
print (word)
start
s
sentence

Join ()

string .join( list )

>>> poem = '''All that doth flow we cannot liquid name

Or else would fire and water be the same;
But that is liquid which is moist and wet
Fire that property can never get.
Then 'tis not cold that doth the fire put out
But 'tis the wet that makes it die, no doubt.'''

>>> len(poem)
250
>>> poem.startswith('All')
True
>>> poem.endswith('That\'s all, folks!')
False
>>> word = 'the'
>>> poem.find(word) - offset of first occurance – return lowest index where string is find
73
>>> poem.rfind(word) - offset of last occurance – returns highest index where string is find
214

>>> poem.count(word)
3

>>> setup = 'a duck goes into a bar...'

>>> setup.strip('.') ---obcina po kropce
'a duck goes into a bar'

>>> setup.capitalize() - capitalize first word

'A duck goes into a bar...'

>>> setup.title() --- capitalize all of the words

'A Duck Goes Into A Bar...'

>>> setup.upper() --- all characters to upper case

'A DUCK GOES INTO A BAR...'

>>> setup.lower() --- all characters to lower case

'a duck goes into a bar...'

>>> setup.replace('duck', 'marmoset')

'a marmoset goes into a bar...

Print formatting
>>a='zmienna typu string'
>>print('Dodaj moja zmienna do wpisanego tekstu: %s' %(a))
Dodaj moja zmienna do wpisanego tekstu: 'zmienna typu string'

Skladania print(”Teskt %s” %zmienna)

%s – odnosie się do tego, że nasza zmienna będzie konwertowana na string, nie jest to nazwa
smiennej, jako %zmienna możemy podać integer a %s zmieni to na string

>>print("Floating point number: %1.2f" %3.141518)

3.14
%1.2f bedzie konwetowac floating to 2 miejsach po przecinku, f oznacza floating typ
1.2 => 1 minimal number of digits, .2 => max number of digits as decimal point

>>print("Floating point number: %25.2f" %13.141518) #wypełni 11 miejsc spacjami

Floating point number: 13.14

Przekazywanie wielu zminneych do print()

>>print("Pierwsza zmienna %s, Druga zmienna %s, Trzecia zmienna %s" %('jeden', 2, 3.0))
Pierwsza zmienna jeden, Druga zmienna 2, Trzecia zmienna 3.0

Do funkcji print zmienne zostana przekazane w koljenosci wpisania ich po %

Methoda .format pozwala nam wspiac zmienne w innej kolejnosci

>>print("Pierwsza zmienna: {x}\nDruga zmienna: {y}\nTrzecia zmienna: {z}".format(z=3, x="Jeden",

y=2))

Pierwsza zmienna: Jeden

Druga zmienna: 2
Trzecia zmienna: 3

formatting strings with {}

print (“I love python”) >> I love python

print (“I {} python” .format('love')) >> I love python
print (“{0} {1} {2}” .format('I', 'love', 'python')) >> I love python
{0} {1} {2} to numery zmiennych przekazywanych w .format()

w {} przekazujemy numer zmminnej I ile minimalnie znakow minimalnie ma ona zajac

>>> print("{0:8} | {1:8}" .format('Fruit', 'Quantity'))

Fruit | Quantity

>>> print ("{0:20} | {1:5}" .format('Apple', 44))

Apple | 44

String alignment < Left ^ Center > Right (by default left alignmet is used )
Musimy zawsze podac {0: I dopiero potem znacznik alignmentu
>>> print ("{0:^20} | {1:>20}" .format('Lewe', 'Prawe'))
Lewe | Prawe

przekazywanie zmiennych do print przy użycu .format

animal ="dog"
vegatable = "carrot"
mineral = "silver"

print("The animal is: {a}, the vegetable is: {v}, the mineral is {s}"\
.format(a=animal, v=vegatable, s = mineral))

Przyklad:

user_text = raw_input("Podaj tekst dla kota:... ") #raw_input to input() z pythona3

#tworzenie bubble to wyswietlenia podanego przez usera tekstu
dlugosc = len(user_text)
print (" {}" .format('_' * dlugosc))#gorna obramowanie tekstu
print(" < {} >" .format(user_text))
print (" {}" .format('-' * dlugosc)) # dolna obramowanie tekstu
print(" /")
print(" /\_/\ /")
print("( o.o )")
print(" > ^ <")

Lists [ ]
>>> list = ['Groucho', 'Chico', 'Harpo'] - lista []
>>> tuple = 'Groucho', 'Chico', 'Harpo' = tuple przecinki ',' albo ()
>>> dict = {'Groucho': 'banjo', 'Chico': 'piano', 'Harpo': 'harp'} - dictionary {}

Lista tworzy sie przy uzyciu []

>>lista=[1,2,3]
>>lista[0]
1

Może zawierać elementy różnego typu – string, integer, floating

>>lista2=[1,"string",3.1415]
>>lista[2]
3.1415

Dodawanie elementu do listy

>>lista +["czwarty elemet"] #musi być w [ ]
[1, 2, 3, 'czwarty elemet']

>>len(lista)
3

Listy mozna wypisywać tak samo jak indexy dla string przy użyciu []

>>imiona=['Pawel', 'Kasia', 'Zygi']

>>miesiace = ['marzec', 'sierpien', 'maj']
>>imiona + ['Hania']
['Pawel', 'Kasia', 'Zygi', 'Hania'] – ZNAK + doda do output nowy element ale nie zmieni samej
listy
>>imiona
['Pawel', 'Kasia', 'Zygi']
>>imiona = imiona +['Hania'] – dopiero nowe przypisanie to zrobi
>>imiona
['Pawel', 'Kasia', 'Zygi', 'Hania']

Zamiana elementu listy

>>imiona[3] ='Zosia'
['Pawel', 'Kasia', 'Zygi', 'Zosia']

Methods for list

append () - dodawanie nowego elementu na koniec listy
>>imiona.append('Marek')
['Pawel', 'Kasia', 'Zygi', 'Zosia', 'Marek']

Extend () – dodawania listy do listy

imiona=['Pawel', 'Kasia', 'Zygi', 'Zosia', 'Marek']

imiona2 = ['Kuba', 'Asia']
imiona.extend(imiona2)

List.pop() - zwróć wartość z listy i potem ja usuń

pop () = uses pop (-1) - takes tail/end of the list

pop (0) - takes head/start of the list

>> imiona
['Pawel', 'Kasia', 'Zygi', 'Zosia', 'Marek']
>>imiona.pop()
'Marek'
>>imiona
['Pawel', 'Kasia', 'Zygi', 'Zosia']
>>imiona.pop(2) - zwraca i usuwa 3 element z listy
'Zygi'

Lista.sort() – sortuje wartości z listy – ascending order

>> imiona
['Pawel', 'Kasia', 'Zosia']
>>imiona.sort()
['Kasia', 'Pawel', 'Zosia']

Lista.reverse() – przepisanie listy w odrotnej kolejnosci – ostatni element staje się pierwszym,
itd.

>> miesiace
['marzec', 'sierpien', 'maj']
>> miesiace.reverse()
['maj', 'sierpien', 'marzec']

Lists and Tuples

Both contains zero or more elements
Each element could be different python object

difference - Tuple cannot be changed once defined, lists could be changed , we can insert and
delete elements

Lists are good to keep track of things by their order when order and elements could change

List [ ] vs list( )
[] - definjuje 1xN wymiarowa tablice
empty_list = [ ]
weekdays = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
big_birds = ['emu', 'ostrich', 'cassowary']
first_names = ['Graham', 'John', 'Terry', 'Terry', 'Michael']

() - to funkcja do tworzenia list []

>>> list('cat')
['c', 'a', 't']

daje to samo co split ()

>>> birthday = '1/6/1952'

>>> birthday.split('/')
['1', '6', '1952']

RANGE ( ) - the output is list!

Range(start, stop, step), range(3) bedzie listowal cyfry od zera do 3, 3 sie nie zawiera

>> list(range(3)) – tworzy liste od 0 do 3

[0, 1, 2]
>>list(range(1,5))
[1, 2, 3, 4]
>> list(range(0,11,2)) – wypisuje parzyste numery od 0 do 10 (bo skok co 2)
[0, 2, 4, 6, 8, 10]

>>for num in range(1, 6):

>> print(num)

1
2
3
4
5

List of List

>> systemy=['windows', 'linux', 'mac os']

>>prod=['microsoft', 'gnu', 'apple']
>> bazy=['oracle', 'mysql', 'ms_sql']
>>calosc=[systemy, prod, bazy]
>>calosc

[['windows', 'linux', 'mac os'], ['microsoft', 'gnu', 'apple'], ['oracle', 'mysql', 'ms_sql']]

Calosc to lista skladajaca się z 3 innych list, element calosc[0] listy to będzie cala lista systemy, [1] to cala lista prod, [2] to cala
lista bazy

>>calosc[1]
['microsoft', 'gnu', 'apple']

>> calosc[0][2] – wybranie pierwszej listy tworzacej liste calosc i wypisanie z niej elementu 3go
‘mac os’

Zamiana elementu listy

>>> marxes = ['Groucho', 'Chico', 'Harpo']
>>> marxes[2] = 'Wanda' ---zamiana elementu 3-go [2] w liscie
>>> marxes
['Groucho', 'Chico', 'Wanda']
Kombinacja dwóch list - extend () albo =+

>>> marxes = ['Groucho', 'Chico', 'Harpo', 'Zeppo']

>>> others = ['Gummo', 'Karl']
>>> marxes.extend(others)
>>> marxes
['Groucho', 'Chico', 'Harpo', 'Zeppo', 'Gummo', 'Karl']

>>> marxes = ['Groucho', 'Chico', 'Harpo', 'Zeppo']

>>> others = ['Gummo', 'Karl']
>>> marxes += others
>>> marxes
['Groucho', 'Chico', 'Harpo', 'Zeppo', 'Gummo', 'Karl']

jakbysmy uzyli append () to inny wynik, dwa imiona dodane jako jeden obiekt na koniec listy

>>> marxes = ['Groucho', 'Chico', 'Harpo', 'Zeppo']

>>> others = ['Gummo', 'Karl']
>>> marxes.append(others)
>>> marxes
['Groucho', 'Chico', 'Harpo', 'Zeppo', ['Gummo', 'Karl']]

wstawienie nowego elementu do listy - insert ()

>>> marxes = ['Groucho', 'Chico', 'Harpo', 'Zeppo']

>>> marxes.insert(3, 'Gummo') ----wstawienie nowego imienia na pozycje 4 w liscie [3]
>>> marxes
['Groucho', 'Chico', 'Harpo', 'Gummo', 'Zeppo']

usuwanie elementu z listy - del

Usuwamy pozycje z listy

>>> marxes
['Groucho', 'Chico', 'Harpo', 'Gummo', 'Zeppo', 'Karl']
>>> del marxes[-1] ----usuwanie ostatniego elementu z listy
>>> marxes
['Groucho', 'Chico', 'Harpo', 'Gummo', 'Zeppo']

Po usunieciu elementu z listy, nastepny po nim wchodzi na jego miejsce

>>> marxes = ['Groucho', 'Chico', 'Harpo', 'Gummo', 'Zeppo']
>>> marxes[2]
'Harpo'
>>> del marxes[2]
>>> marxes
['Groucho', 'Chico', 'Gummo', 'Zeppo']
>>> marxes[2]
'Gummo'

>> calosc
[['windows', 'linux', 'mac os'],
['microsoft', 'gnu', 'apple'],
['oracle', 'mysql', 'ms_sql']]
>> del calosc[1][1] – usuwany 2gi element w 2giej liscie
>>calosc
[['windows', 'linux', 'mac os'],
['microsoft', 'apple'],
['oracle', 'mysql', 'ms_sql']]

Usuwanie wartosci z listy na podstawie jej wartosci a nie pozycji - remove()

Wyszukaj wartosc i ja usuń
>>> marxes = ['Groucho', 'Chico', 'Harpo', 'Gummo', 'Zeppo']
>>> marxes.remove('Gummo')
>>> marxes
['Groucho', 'Chico', 'Harpo', 'Zeppo']

index () – znajdowanie pozycji na liscie, jaki indeks

>>> marxes = ['Groucho', 'Chico', 'Harpo', 'Zeppo']

>>> marxes.index('Chico')
1

Exceptions przy .index()

animals = ["kot", "pies", "tygrys"]

dzik_index = animals.index("dzik")
print(dzik_index)

Jak nie ma wartości na liście to zwrócone będzie excpetion

dzik_index=animals.index("dzik")
ValueError: 'dzik' is not in list

Możemy sami podać jaki błąd zostanie nam zwrócony przy wystąpieniu exception

animals =["kot", "pies", "tygrys"]

try:
dzik_index=animals.index("dzik")
except:
dzik_index = "Nie znaleziono dzika na liscie zwierzat"

print(dzik_index)

Testowanie czy wartosc jest obecna na liscie – in

>>> 'Groucho' in marxes
True
>>> 'Bob' in marxes
False

Sorting list - sort () - sortuje pozycje na liscie, sorted () - zwraca posortowana kopie listy
By default ascending sorting

>>> marxes = ['Groucho', 'Chico', 'Harpo']

>>> sorted_marxes = sorted(marxes)
>>> sorted_marxes
['Chico', 'Groucho', 'Harpo']
>>> marxes
['Groucho', 'Chico', 'Harpo']
>>> marxes.sort()
>>> marxes
['Chico', 'Groucho', 'Harpo']

DESCENDING SORT - sort(reverse=True)

>>> numbers = [2, 1, 4.0, 3]

>>> numbers.sort(reverse=True)
>>> numbers
[4.0, 3, 2, 1]

Looping through list

FOR LOOP
For item_variable in list_name:
#Code block

Następuje przypisanie item_variable = list[0], potem item_variable=list[1] …. Item_variable=list[N]

WHILE LOOP

While condition:
#Code block
While index < len(animals):
Print (animals[index])
Index += 1

Taka pętal wypisze wszystkie pozycje z naszej listy

RANGES (start, stop, step)

For number in range(3):

Print(number)

Wynik 0, 1, 2

For number in range(1, 3): # start at 1 stop at 3

Print(number)

Wynik 1,2

For number in range(1, 10, 2): # start at 1 stop at 10, wypisuje co 2

Print(number)
Wynik 1,3,5,6,9

TUPLE
Tuple w odroznieniu od list są niezmienialemn, nie można modyfikowac jej komponentów.
Dobre do przetrzymywania wartości, które nie powinny się zmienić podczas wykonywania programu –
np. lista dni tygodnia jest stala

Definiowanie tuple (), definiowanie listy bylo []

>>> empty_tuple = () --- definiowanie pustego tuple

>>> empty_tuple
()

Definiowanie tuple!
>>> marx_tuple = 'Groucho', 'Chico', 'Harpo' --musza byc 'wartosc'--jak bysmy definiowali liste
to marx_list=['Groucho', 'Chico', 'Harpo']
>>> marx_tuple
('Groucho', 'Chico', 'Harpo')

Przypisanie wielu zmiennych na raz z tuple

>>> tuple=('raz', 'dwa', 'trzy')

>>> tuple
('raz', 'dwa', 'trzy')
>>> a, b, c = tuple
>>> a
'raz'
>>> b
'dwa'
>>> c
'trzy'

Methoda count() zlicza ile razy dany element wystepuje w tuple

>>t = (1,2,3,1,2,1,4,5,1,2,4,5)
>>t.count(1)
4
>>t.count(4)
2
Funckja tuple () tworzy obiekt tuple z innych rzeczy, np z listy

>>> marx_list = ['Groucho', 'Chico', 'Harpo']

>>> tuple(marx_list)
('Groucho', 'Chico', 'Harpo')

Usuwanie tupple

Del tupple_name

Tuple maja duzo mniej funkcji niz listy - nie ma np. append() czy insert () - Nie moga byc
modyfikowane po utworzeniu
Tuple zajmuja mniej miejsca niz listy, przez pomylke nie mozna zmienic elementu tuple
Mozna uzywac tuple jako dictionary key albo przekazywac argumenty funkcji przez tuple

FOR LOOP

dni_tygodnia = ('Poniedzialek', 'Wtorek', 'Sroda', 'Czwartek', 'Piatek')

for dzien in dni_tygodnia:

print(dzien)

For item_variable in tupple_name:

#Code block

Następuje przypisanie item_variable = tupple[0], potem item_variable=tupple[1] …. Item_variable=tupple[N]

W pętli FOR możemy podać tez odniesienie do całego tupple

#lista lotniska składa sie z 3 tupple

lotniska=[('Warszawa', 'WAW'), ('Krakow', 'KRA'), ('Gdansk', 'GDA')]
print(lotniska)

#w petli for mozemy podac bezposrednio odwolanie do wartosci w tuple tworzacyh liste
#kazda para (miasto, kod) to jedna pozycja na liscie, czyli jakbysmy sie odwolywali
bezposrednio do elementu listy
for (miasto, kod) in lotniska:
print("Lotinsko w: {} ma kod {}" .format(miasto, kod))

DICTIONARY
Podobne do listy ale kolejnosc nie ma znaczenia i elementy nie sa wybierane przez offset (offset
to pozycja na liscie 0, 1, 2,itd)
Zamiast offset do kazdej wartosci w dictionary przypisywany jest unique key
Mozna zmieniac, dodawac i usuwac elemety dictionary

Wartości dla listy wywyołujemy poprzez index np list[0], dla dictionary wartości wywołujemy poprzez klucz np.
Dicttionary[‘key1’]
Definiowanie poprzez {}

Dictionary={} ----lista=['raz', 'dwa', 'trzy'], tuple=('raz', 'dwa', 'trzy')

dictionary={"klucz":"wartosc"}
Klucz to wartosc unikalna, jezeli bedzie uzyty wiec niz raz w dictionary to ostatnia wartosc
wygywa

mozna definiowac klucze i wartosci z ' ' albo " "

>> miesiace={1:"styczen", 2:"luty", 3: "marzec"}

{1: 'styczen', 2: 'luty', 3: 'marzec'}

>>mies ={4:"kwie", 5:"maj"}

>>> mies
{4: 'kwie', 5: 'maj'}

dodanie kolejnego wpisu do dictionary – [ ]

dictionary['klucz']='wartosc'

>>> mies['6']='cze'
>>> mies
{'6': 'cze', '4': 'kwie', '5': 'maj'}

zmiana wartosci w dictionary po kluczu

>>> mies[6]="cze"
mies
>>> mies
{4: 'kwie', 5: 'maj', 6: 'cze'}

Zmiana obecnej wartości – [ ]

W dictionary tak jak w listach można zmieniać obecne wartości ale robi się to po
kluczu przypisanym do wartości nie po indeksie dla danej pozycji

>>mies[6]="czerwiec"
>>mies
{4: 'kwie', 5: 'maj', 6: 'czerwiec'}

Polaczenie dwoch dictionary - metoda update()

>>miesiace.update(mies)
>>miesiace
{1: 'styczen', 2: 'luty', 3: 'marzec', 4: 'kwie', 5: 'maj', 6: 'czerwiec'}

Metoda update()

Jak w tabeli która dodajemy (mies2) wystepuje ten sam klucz co w tabeli poczatkowej (mies)
wartosc klucza z dodawanego dictionary wygrywa

>> mies
{4: 'kwie', 5: 'maj', 6: 'czerwiec'}
>>mies2
{5: 'ma', 6: 'cze', 7: 'lipiec'}
>> mies.update(mies2)
>>mies
{4: 'kwie', 5: 'ma', 6: 'cze', 7: 'lipiec'}

Usuwanie wartosci po kluczu - del dictionary['key']

>>> mies
{'6': 'cze', '7': 'lip', '8': 'sie', '4': 'kwie', '9': 'wrze', '5': 'maj'}
>>> del mies['9']
>>> mies
{'6': 'cze', '7': 'lip', '8': 'sie', '4': 'kwie', '5': 'maj'}

Usuwanie wszystkich wartosci dictionary - otrzymam pusty dictionary - dictionary.clear()

>>> mies2
{'7': 'lip', '6': 'cze', '9': 'wrze', '8': 'sie'}
>>> mies2.clear()
>>> mies2
{}

Wybieranie wartosci po kluczu w dictionary – w [ ]

>>> mies
{'6': 'cze', '7': 'lip', '8': 'sie', '4': 'kwie', '5': 'maj'}
>>> mies['6']
'cze'

Listowanie wysztkich kluczy w dictionary - metoda dictionary.keys()

>>> mies.keys()
dict_keys(['6', '7', '8', '4', '5'])

Listowanie wyszystkich wartosc w dictionary - metoda dictionary.values()

>>> mies.values()
dict.values(['cze', 'lip', 'sie', 'kwie', 'maj'])

assign with =, copy with dictionary.copy()

new_dictionary=old_dictionary vs new_dictionary=old_dictionary.copy()

funckja dict()
zamienia na sekwencje klucz-wartosc na obiekt dictionary

>>> lol = [ ['a', 'b'], ['c', 'd'], ['e', 'f'] ]

>>> dict(lol)
{'c': 'd', 'a': 'b', 'e': 'f'} -- kolejnosc prezentacji wartosci klucz:wartosc jest losowa i
nie ma znaczenia

>>words = [[1,"a"], [2,"b"],[3,"c"]]

>>new_dict=dict(words)
>>new_dict
{1: 'a', 2: 'b', 3: 'c'}
>>contacts={'Jason':'555-0123', 'Carl':'555-0987'}
>>jason_phone = contacts['Jason']

>>print("Dial {} to call Jason" .format(jason_phone))

>>print("Dial {} to call Carl" .format(contacts['Carl']))

Dial 555-0123 to call Jason

Dial 555-0987 to call Carl

>>print(contacts)
{'Jason': '555-0123', 'Carl': '555-0987'}

LOOPS FOR DICTIONATIES

IF STATEMENT FOR DICTIONARIES

>>contacts = {'Jason': '555-0123', 'Carl': ['555-0987', '555-0999'], 'Tony': '555-0570'}
#wartosc przypisana do klucza Carl to tablica
>>if 'Jason' in contacts.keys():
>> print("Jason's number is: {}" .format(contacts['Jason']))

>>if 'Carl' in contacts.keys():

>> print("Carl's number is: {}" .format(contacts['Carl'][0]))
#wywołanie pierwszej wartosc z tablicy dla klucza Carl

FOR LOOP

For key_variable in dictionary_name:

#Code block
Dictionary_name[key_variable]

Python bedzie oczekiwał, że zmienna będzie odnosi się do ‘key’ w dictionary

>>for contact in contacts:

>> print("The number for {a} is: {b}" . format(a=contact, b = contacts[contact]))

The number for Jason is: 555-0123

The number for Carl is: ['555-0987', '555-0999']
The number for Tony is: 555-0570

Drugi sposób wywoływania FOR LOOP dla dictionaries to looping with 2 variables
For key_variable, value_variable in dictionary_name.items():
#Code block

Python bedzie oczekiwal, że pierwsza zmienna będzie odnosić się do ‘key’ a druga zmienna do ‘value’

>>for person, phone_number in contacts.items():

>> print("The number for {a} is: {b}" .format(a=person, b=phone_number))

The number for Jason is: 555-0123

The number for Carl is: ['555-0987', '555-0999']
The number for Tony is: 555-0570

def display_facts(facts):
"""Displays facts from dictionary"""
for fact in facts:
print("{}: {}". format(fact, facts[fact]))

dictionary = {'Kasia':'Najszczuplejsza panna mloda w Stolicy', 'Pawel':'Po slubie zgolil brode', 'Zygi': 'Ich syn oczko w
glowie'}

display_facts(dictionary)

dictionary['Pawel']='Ma siwa brode'

dictionary['Zosia'] = 'Studiuje za granica'

display_facts(dictionary)

Nested dictionaries
Do każdego klucza w dictionary przypisane value tez będzie dictionary
contacts2 ={
'Jason': {
 'phone':'555-0123',
'email':'jasnon@example.com'
},
'Carl': {
'phone':'555-0456',
'email':'carl@example.com'
}
}

>>Print(contacts2)

{'Jason': {'phone': '555-0123', 'email': 'jasnon@example.com'}, 'Carl': {'phone': '555-0456', 'email':

'carl@example.com'}}

for contact in contacts2:

print("{} 's contact info: ".format(contact))
print(contacts2[contact]['phone'])
print(contacts2[contact]['email'])

Jason 's contact info:

555-0123
jasnon@example.com
Carl 's contact info:
555-0456
carl@example.com

SETS
Set is like dictionary but contains only keys without values assigned to it. Each key must be
unique

Tworzenie pustego set > set()

>>> pusty_zbior=set()

Tworzenie niepustego zbioru tak jak dictionary - uzywamy {}

>>> even_numb={0, 2, 4, 6, 8}
>>> even_numb
{0, 2, 4, 6, 8} - w set nie ma znaczenia kolejsność, moze byc prezentowany posortowany lub nie
>>> odd_numb={1, 3, 5, 7, 9}
>>> odd_numb
{1, 3, 5, 7, 9}

Konwertowanie innych typów na set - fukcja set()

Funkcja set wybiera tylko unique wartości, np z listy

>> l=[1,2,2,3,3,3,4,4,4,4,5,5,5,5]
>> set(l)
{1, 2, 3, 4, 5}

>>> set_litery=set('litery')
>>> set_litery
{'y', 'r', 'l', 'e', 'i', 't'}

>>> set_lista=set(['jeden','dwa','trzy'])
>>> set_lista
{'dwa', 'trzy', 'jeden'}
>>> set_tuple=set(('Pawel','Kasia','Zygi'))
>>> set_tuple
{'Kasia', 'Zygi', 'Pawel'}

>>> set_dict=set({'1':'jeden', '2':'dwa', '3':'trzy'})

>>> set_dict
{'1', '3', '2'} --- przy konwertowaniu dictionary przenoszone sa tylko klucze bez wartosci

Deklarowanie sets { } jak przy dictionary

>>>parzyste={0,2,4,6,8}

Dodawania nowego elementu do SETS – metoda add()

>>parzyste.add(10)
{0, 2, 4, 6, 8, 10}

Testowanie wystepowania wartosci przy uzyciu IN

>>> drinks = {
'martini': {'vodka', 'vermouth'},
'black russian': {'vodka', 'kahlua'},
'white russian': {'cream', 'kahlua', 'vodka'},
'manhattan': {'rye', 'vermouth', 'bitters'},
'screwdriver': {'orange juice', 'vodka'}
}

>>> for name, contents in drinks.items(): #name przypisaujemy do klucza dictionary, contento wartosc
if 'vodka' in contents:
print(name)
screwdriver
martini
black russian
white russian

>>> for name, contents in drinks.items():

if 'vodka' in contents and not ('vermouth' in contents or
'cream' in contents):
print(name)

screwdriver
black russian

FILES

import os

#full path to the directory a Python file is contained in that file

dir_path=os.path.dirname(os.path.realpath(__file__))

#To get the current working directory use

cwd=os.getcwd()

>>print("Dir_path: {}" .format(dir_path))

Dir_path: C:\Users\Pc\Documents\NAUKA\Python

>>print("CWD: {}" .format(cwd))

CWD: C:\Users\Pc\Documents\NAUKA\Python

>>print("Path at terminal when executing this file")

>>print(os.getcwd() + "\n")
C:\Users\Pc\Documents\NAUKA\Python

>>print("This file path, relative to os.getcwd()")

>>print(__file__ + "\n")
C:/Users/Pc/Documents/NAUKA/Python/testpwd.py

>>print("This file full path (following symlinks)")

>>full_path = os.path.realpath(__file__)
>>print(full_path + "\n")
C:\Users\Pc\Documents\NAUKA\Python\testpwd.py

>>print("This file directory and name")

>>path, filename = os.path.split(full_path)
>>print(path + ' --> ' + filename + "\n")
C:\Users\Pc\Documents\NAUKA\Python --> testpwd.py

print("This file directory only")

print(os.path.dirname(full_path))
>>C:\Users\Pc\Documents\NAUKA\Python

W JUPYTHER NOTEBOOKS używamy pwd  zwróci nam ściezke gdzie zainstalowana jest Anaconda3

Input() – function accepting the standard inout for the user

Print() - function wrtiting standard output

To store data process from program or read data that will be used we need use the files
Open () – built-in functions that opens a file and returns a file object

Open(path_to_file)
Path_to_file – can be absolute (entire path to directory) or relative (only file name)

Python can reads both / and \ in file directory – bo oblsuguje roznie srodowiska – windows i linux.

Absolute:
Open(‘C:\Users\Pc\Documents\NAUKA\Python\test.txt’)
OR
Open(‘C:/Users/Pc/Documents/NAUKA/Python’)

Relative
Open(‘Documents\NAUKA\Python\test.txt’)

#W windows przy podawaniu sciezku do \users znaki '\u' traktowane sa jako unicode
#escape i beda zwracaly blad odczytu pliku
#f= open('C:\Users\Pc\test.txt')

#zeby to obejsc trzeba podac sciezke albo z dwoma \\

f= open('C:\\Users\\Pc\\test.txt')
f_content = f.read()
print(f_content)
#albo trzeba wywolac funkcje open z parametrem "r"

f= open(r'C:\Users\Pc\test.txt', "r")
f_content = f.read()
print(f_content)

Metoda . read ( )

Przypisujemy do zmiennej plik, jak nie przypiszemy to nie możemy wywolac metody rad()

hosts= open('C:\Windows\System32\drivers\etc\hosts')
host_file_content = hosts.read()
print(host_file_content)

Zwróci nam cała zawartość pliku hosts

# Copyright (c) 1993-2009 Microsoft Corp.

#
# This is a sample HOSTS file used by Microsoft TCP/IP for Windows.
#
# This file contains the mappings of IP addresses to host names. Each
# entry should be kept on an individual line. The IP address should

Methoda readlines – zczytuje wszystkie linie, caly plik

f = open(r'C:\\Users\\Pc\\test.txt', "r")
print(f.readlines()) #zczytuje plik i kazda linijke tekstu traktuje jako elemnt listy
print(f.readlines(2)) #zwóric wartośc pustą

Metoda readline () – reading the fie line by line

#readline - reading file line by line

plik = open(r'C:\\Users\\Pc\\test.txt', "r")
plik.seek(0)
for line in plik:
print(plik.readline())

Wypisaywanie każdej linii pliku pojedyńczo – rózne sposoby

Uzywajac triku z time.sleep

#zeby wypisac kazda linie pliku pojedynczo trzeb uyzć triku z sleep
import time
f = open(r'C:\\Users\\Pc\\test.txt', "r")
for line in f:
print(line)
time.sleep(1)

używając metody readline ()

f = open(r'C:\\Users\\Pc\\test.txt', "r")
line=f.readline() #line zczytuje 1-sza linie tekstu
while line:
print(line)
line=f.readline() #radline zczytuje kolejna linie tekstu
f.close()

uzywając ITER ()

#The iter() method creates an object which can be iterated one element at a time
#iter(object[, sentinel])

f = open(r'C:\\Users\\Pc\\test.txt', "r")
for line in iter(f):
print(line, ' ')
f.close()
print()

ITER
samogloski = ['a', 'e', 'i', 'o', 'u', 'y']
sam = iter(samogloski)
print(next(sam))#a
print(next(sam))#e

FILE POSITION

Read() – returns the entire file

Seek (offset) – change the current position to offset
Seek (0) – go to the beginning of the file
Seek(5) – go to the 5th byte of the file
Tell () – determine the current position in the file
#wypisuej caly plim przy uzyciu read()
hosts= open('C:\Windows\System32\drivers\etc\hosts')
host_file_content = hosts.read()
print(host_file_content)

print ("*****" * 10)

print("Pierwsze wypisanie")

print()
print("Current position: {}" .format(hosts.tell() ))
print ("___" *5)
print()
print(hosts.read()) #nic nie wypisze bo jesteśmy na koncu pliku

#powracamy na poczatek pliku seek(0) i znów wypisze na cały plik

hosts.seek(0)
print("Current position: {}" .format(hosts.tell() ))
print(hosts.read())

W Jupyher notebooks tez trzeba uzywać methody seek żeby wrócic na początek pliku i moć go jeszcze raz przeczytać.
Methoda read() będzie szukała pliku w lokalizacji zwróconej przez polecenie pwd
closing file with .close () method

hosts= open('C:\Windows\System32\drivers\etc\hosts')
host_file_content = hosts.read() #read file
print(host_file_content) # print the file content
hosts.close() # close the file

hosts= open('C:\Windows\System32\drivers\etc\hosts')
host_file_content = hosts.read() #read file
print("File closed? {}" .format(hosts.closed)) #hosts.closed zwraca info o tym czy plik
zamkniety czy nie – True albo False
if not hosts.closed:
hosts.close() #zamkniecei pliki jezeli nie byl do tej pory zamkniety
print("File closed? {}" .format(hosts.closed))

Automatically closing the file -with open

With open (file_path) as file_oject_variable_name:

#code block

Po tym jak code block skończy się wykonywać python automatycznie zamknie plik, Jak w kodzie pojawu się jakies
exception to python automatycznie zamknie plik.

print("Started reading the file...")

with open ('C:\Windows\System32\drivers\etc\hosts') as hosts:
print("File closed? {}" .format(hosts.closed))
print(hosts.read()) #wypisuje zawartosc pliku
# code block skonczy sie wykonywać, python automatycznie zamknal plik
print("Finished reading the file....")
print("File closed? {}" .format (hosts.closed))

Reading one row of the file at a time – FOR LOOP

#zeby wypisac kazda linie pliku pojedynczo trzeb uyzć triku z sleep
import time
f = open(r'C:\\Users\\Pc\\test.txt', "r")
for line in f:
print(line)
time.sleep(1)

Write to file

#writing to a file
#write method wirtes any string to an open file
#write does not add a newline character \n to the end of string

days=['PN', 'WT', 'SR', 'CZW', 'PT']

#mozemy zapisac tylko string wiec zamieniamy na string
dni =str(days)
#otwieramy z parametrem "w" -> write do zapisu
days_file=open('C:\\Users\\Pc\\Documents\\NAUKA\\Python\\WriteExample.txt', 'w')
days_file.write(dni)
days_file.close()

W pliku zostanie zapisany taki string ['PN', 'WT', 'SR', 'CZW', 'PT']

Zapisanie do pliku kazdego dnia w nowej linii:

days=['PN\n', 'WT\n', 'SR\n', 'CZW\n', 'PT\n']

days_file=open('C:\\Users\\Pc\\Documents\\NAUKA\\Python\\WriteExample.txt', 'w')
for d in days:
days_file.write(d)

days_file.close()

w pliku zapisze to jako:

PN
WT
SR
CZW
PT

Write to files in Jupyther notebook

Znacznik %% to oznaczenie uzycia tzw. „magic functions w jupyther notebooks, nie ma takich funckji w zwyklym
pythonie

# %%writefile stworzy plik w sciezce zwracanej przez polecenie pwd

>>%%writefile JupytherNew.txt
>>Jupyther first line text
>>Jupyther second line text

for words in open("JupytherNew.txt"):

print (words)

Jupyther first line text

Jupyther second line text

Operator & (ampersand)

 Find any drink that contain orange juice or vermuoth.

The result of the & operator is a set, which contains all the items that appear in both lists
that you compare. If neither of those ingredients were in contents, the & returns an
empty set, which is considered False.

>>> for name, contents in drinks.items():

if contents & {'vermouth', 'orange juice'}: #& => contents 'vermouth' or 'orange juice'
print(name)

screwdriver
martini
manhattan
  List the drinks that contain vodka but neither cream nor vermouth

>>> for name, contents in drinks.items():

if 'vodka' in contents and not contents & {'vermouth', 'cream'}:
print(name)

screwdriver
black russian

IDE = Integrated Development Environment (general term)

IDLE = Integrated DeveLopment Envoronment – Python IDE

Functions
Tworzenie funckji def

Def function_name() :
#code block

Def say_hi() :
Print(“Hi!”)

say_hi() <<< wywyłanie funkcji

Fukcja z argumentem

def say_hi(name):
print("Hi {} !" .format(name))

say_hi("Jason")
say_hi("Everybody")

>> Hi Jason
>> Hi everybody

Funkcja z argumentem i wartości domyślną jak się go nie poda

def say_hello(name="there"): #there jest wartosci domylsna dla parametru name

print ("Hello {} !!".format(name))

say_hello() # przy braku podania parametru dla fukcji wartosc domyslna zostanie
uzyta
say_hello("Kasia")

Funkcja z wieloma argumentami i wartości domyślną jak się go nie poda

def powitanie(first = "Bezimienia", last = "Beznazwiska"):
print("Witaj {a} {b} ...!!!" .format(a=first, b=last))

powitanie("Kasia", "Kisazek") # bez przypisania do zmiennych uzywamy kolejnosci

zdefiniowanej w fukcji
powitanie()
powitanie(last="Czajkowski", first="Pawel") #przypisujac wartosci do parametrow
fukcji możemy je podac w innej kolejnosci

Witaj Kasia Kisazek ...!!!

Witaj Bezimienia Beznazwiska ...!!!
Documentation string dla fukcji ””” tekst ””” >> help

def powitanie2(first = "Bezimienia", last = "Beznazwiska"):

""" Fucntion to say hello"""
print("Witaj {a} {b} ...!!!" .format(a=first, b=last))

help(powitanie2)

powitanie2(first='Bezimienia', last='Beznazwiska')
Fucntion to say hello

Funckja zwracajaca wynik – return

##Bardzo ważne są wciecia w definiowaniu bloku, bez nich polecenie może nie
dzialac!!!
def odd_or_even(number):
"""Determine if a numer is odd or even."""
if number % 2 == 0:
return "Even"
else:
return "Odd"

Lambda expressions

Ad hoc functions that we do not need to define properly using def keyword, single expression not a blokck of
statement

Zamiast definiowac cala funckje możemy uzyc lambda żeby powiedziec programowi co ma robic

#lambda expresion
lambda argument_list: expression

>>sum = lambda x, y: x+y

>>sum (3,4)
7

lambda expression da to samo co zdefiniowana fukcja

>>def sum2(x,y):
>> return x + y

>>FirstletterFromString("Pawel")
P

>>first = lambda s: s[0]

>>first("Pawel")
P

#function that reverses the string

>>def reverse (s):
>> return s[::-1]

>>reverse("Pawel")
'lewaP'

>>rev = lambda s: s[::-1]

>>rev("Pawel")
lewaP'
Modules
Python modules are files that have a .py extensions
They can be implemented as set of attributes (variables), methods (functions) and
classes (types)

Module can be included in another Python program by using IMPORTstatement follwed by

module name

For example
>>import time
Then we can use methods and attributes for imported module
>>time.method_name()
>>time.attribure_name

>>import time
>>print (time.asctime()) #shows local time
>>print(time.timezone) #numer of second between utc and local time

Sun Jan 14 16:59:42 2018

-3600

Mozmemy tez importowac tylko niektóre metody z danego modulu,bez koniecznosci

importowania calego modulu

>>from module_name import method_name

>>method_name()

Example:
>>From time import asctime
>>print(asctime())

Jezeli chcemy zaimportowac wiecej niz jedna metode mozemy je podac po przecinku
>>from module_name import method_name1, method_nameN

example:
>>form time import asctime, sleep
>>print(asctime())
>>sleep(3) #suspend execution of program for given number of seconds
>>print(asctime())

po zaimportowaniu methody mozemy sie do niej odwolywac bezposrednio

czyli np: sleep() zamiast time.sleep()

Zeby zobaczyc jakie klasy, metody i atrybuty istnieja w module mozemy

uzyc funkcji dir ()

>>import time
>>dir(time)

Default module search patch - sys.path

>>import sys
>>for path in sys.path:
print(path)

/home/czajka/Desktop/Python_files
/home/czajka
/usr/bin
/usr/lib/python2.7
/usr/lib/python2.7/plat-linux2
/usr/lib/python2.7/lib-tk
/usr/lib/python2.7/lib-old
/usr/lib/python2.7/lib-dynload
/usr/local/lib/python2.7/dist-packages
/usr/lib/python2.7/dist-package

to add additional location where modules are located and from where they can be imprt
ted we need to manipulate the sys.path like any other list

>>import sys
>>sys.path.append('tu wpisujemy dodatkowa lokalizcje modulow')
#zeby sprawdzic czy dodatkowa lokalizacja modulow dodala sie poprawnie
>>for path in sys.path:
>> print(path)

We can also manipulae the PYTHONPATH environmental varaible i.e. windows dodatkowe
sciezki do modulow dodajemy po semicolon

PYTHONPATH = path1;pathN

dostepne biblioteki dla pythona 3

https://docs.python.org/3/library/

Tworzenie wlasnego modulu to zapisanie kodu w postaci pliku .py potem musi tylko uzyc
import module_name i bedziemy mieli dostepne tam funckcie i metody

np. uzycie napisanej przez nas funckji say_hi z pliku say_hi.py

import say_hi #de facto onosimy sie do pliku .pu

say_hi.say_hi() #wywolanie fukcji

nasz modul musi byc zapisany w lokalizacji dla sys.path albo trzeba do sys.path dpdac
nowa sciezke

if we want to import program for moduel but we don't want that our main program execute
the imported one

Zapis:
if __name__ == '__main__'
wylacza wykonywanie funckcji podczas importu modulu az do czasu kiedy taka funckja
zostanie wywolana w nowym programie Normalnie podczas importu modulu wykonuja sie
zapisane w nim operacje / funkcje

OPERATORY
& lub .intersection() --- czesc wspolna

>>> a={1,2}
>>> b={2,3}
>>> a&b
{2}
>>> a.intersection(b)
{2}

| lub .union() --- polaczenie obu zbiorow

>>> a|b
{1, 2, 3}
>>> a.union(b)
{1, 2, 3}

roznica zbiorow - (minus) lub .difference()----

>>> a={1,2}
>>> b={2,3}
>>> a-b
{1}
>>> b-a
{3}
>>> a.difference(b)
{1}

---- exclusive or wartosc wystepujaca w jednym lub drugim zbiorze ale nie czesc wspolna

^ lub symmetric_difference()

>>> a^b
{1, 3}
>>> a.symmetric_difference(b)
{1, 3}

One set is subset of the other (all values from first subset are also in second one) <= or
.issubset()

>>> a <= b
False
>>> a.issubset(b)
False

Proper subset - second set have all the values from first set and more '< '

PĘTELE I WARUNKI LOGICZNE

IF, ELIF, ELSE

Elif to tak naprawde nastepny warunek if

if case1:
perform action1
elif case2:
perform action2
else:
perform action3

>>> disaster=0
>>> disaster
0
>>> if disaster: \
... print("Zle")
... else:
... print("Dobrze")
Dobrze

>>> maly=1
>>> siersc=1
>>> if siersc:
... if maly:
... print("To jest kot")
... else:
... print("To jest niedziwiedz, uciekaj!")
... else:
... if maly:
... print("To jest skunks, uciekaj!")
... else:
... print("To jest czlowiek albo lysy niedziedz")
...
To jest kot

ELIF – jakbysmy uzywali else if

if kolor=='zielony': print('Groszek')\
elif kolor=='zolty': print('Banan')\
elif kolor=='czerwony': print('Pomidor')

Operatory porównań
równość == nierówność !=
mniejszy niz < mniejsz równy <=
wiekszy > wiekszy równy =>
zawiera sie – IN

False operators

boolean -> False

null → None
zero integer → 0
zero float → 0.0
empty string → ''
empty list → []
empty tuple → ()
empty dict → {}
empty set → set()

WHILE

While test:
Code statement
Else:
Code statement

count =1
while count <= 5: ### Wazne zeby na koncu warunku bylo :
print (count)
count+=1

1
2
3
4
5

Break, Continue, Pass

Break: breaks out of the current closest ending loop

Continue: Goes to the top of the closest enclosing loop
Pass: Does nothing at all

While test:
Code statement
 If test:
Break
If test:
Continue
Else:

BREAK – to cancel loop, if we want to loop works until something occurs but we are not sure when
it might happen. BREAK works only in case of FOR loops, does not work for a WHILE loop !!!!

while True: #warunek while konczy sie :

slowo = input ("String to capitalize [type q to exit]: ")
print (slowo.upper()) #drukowanie slowa w caps lock
if slowo == "q": break #quit, warunke if konczy sie :

CONTINUE – skip ahead iteration in loop without break out of the loop, works for FOR loop,
doesn't work for WHILE loop

funkcja input – pobiera wprowadzona wartosc przez uzytkownika

Read the integer provided by user (funkcja input), jak liczba parzysta wydrukuj to na ektanie,
jak liczba nieparzysta to podnies do potegi i wydrukuj. Jak chcesz zrezygnowac wcisnij q

Bardzo ważne są wcięcia tabulatorami w fukcjach if, jak nie bedzie wciecia to traktowane jak
opuszczenie sprawdzenia warunku lub opuszczenie petli !!!!

while True:

value = input("Please put integer value, [press q to quit] ")

if value =="q":
break #quit the loop
number = int(value)
if number % 2 ==0:
print ("liczba parzysta")
continue #liczba parzysta
print (number, "squared is ", number*number)

Please put integer value, [press q to quit] 1

1 squared is 1
Please put integer value, [press q to quit] 2
liczba parzysta
Please put integer value, [press q to quit] 3
3 squared is 9
Please put integer value, [press q to quit] 4
liczba parzysta
Please put integer value, [press q to quit] 5
5 squared is 25
Please put integer value, [press q to quit] q
=> None

ELSE – if WHILE function ends normally (no break call) control passes to optional ELSE. You can
use ELSE if you are looking for something in WHILE loop and ends it as soon as it is found, the
ELSE would run if WHILE completed without break call

numbers=[1,2,5]
position = 0

while position <len(numbers):

number=numbers[position]
if number % 2 == 0:
print("Znaleziono liczbe parzysta", number)
break
position +=1

else: #break not called

print("Nie znaleziono liczby parzystej")

Znaleziono liczbe parzysta 2

=> None

numbers=[1,3,5]
position = 0

while position <len(numbers):

number=numbers[position]
if number % 2 == 0:
print("Znaleziono liczbe parzysta", number)
break
position +=1

else: #break not called

print("Nie znaleziono liczby parzystej")
Nie znaleziono liczby parzystej
=> None

FOR – dla powtarzania iteracji, mozna wykonywac kolejne itreacji petli uzywaja FOR zamiast
while. FOR jest uzyteczne przy wykonywaniu kolejnych iteracji nie wiedzac jak duzy jest zbior
danych

For item in object:

#Code to do smth

W petli nie musimy definiowac zmiennej num!!

>>l = [1,2,3,4,5]
>>for num in l:
>> print(num)

1
2
3
4
5

kroliki =['puszek', 'maluszek', 'kicek', 'pimpuszek']

current = 0
while current < len(kroliki):
print(kroliki[current])
current += 1
puszek
maluszek
kicek
pimpuszek
=> None

kroliki =['puszek', 'maluszek', 'kicek', 'pimpuszek']

FOR krolik in kroliki: #for zamiast while
print(krolik)

puszek
maluszek
kicek
pimpuszek
=> None
String iteration with FOR

slowo ='kot'
for litera in slowo:
print(litera)

k
o
t
=> None
Dictionary iteration with FOR

dictionary = {'karta1':'AS PIK', 'karta2':'Dama Karo', 'karta3':'Krol Kier'}

for keys in dictionary.keys(): #zwarca klucz
print(keys)
for values in dictionary.values(): #zwraca wartosc
print(values)
for items in dictionary.items(): #zwraca klucz i wartosc
print(items)

karta1
karta3
karta2
AS PIK
Krol Kier
Dama Karo
('karta1', 'AS PIK')
('karta3', 'Krol Kier')
('karta2', 'Dama Karo')

ZIP () - iteracja na kilku sekwencjach danych jednoczesnie,

s79

SCOPES
4 scopes: local, enclosing function, global, biult-in

Local Scope – names assigned in any way within a fucntion (def or lambda) not declared global in that function

Enclosing function – name in the local scope of any and all enclosing functions (def or lambda) from inner to outer

Global – names assigned at the top-level of a module file or declared global in def within the file

Biult-in – names preasigned in the biult-in names modules like open, range

Built-in functions globals () and locals () check whether we are using global or local function

Cwiczenia
create a list of all numbers between 1 and 50 that are divisble by 3.
[x for x in range(1,51) if x%3 ==0]

st = 'Print only the words that start with s in this sentence'

for word in st.split(' '):
if word[0] == 's':
print (word)

print all the even numbers from 0 to 10.

list(range(0,11,2))

st = 'Print every word in this sentence that has an even number of letters'
for word in st.split(' '):
if len(word)%2 ==0:
 print("word >> " + word + " << has even number of characters")

Write a program that prints the integers from 1 to 100. But for multiples of three print "Fizz" instead of the
number, and for the multiples of five print "Buzz". For numbers which are multiples of both three and five print
"FizzBuzz".

for num in range(1,101):

if num%5 ==0 and num%3 ==0:
print("FizzBuzz")
elif num%3 ==0:
print("Buzz")
elif num%5 ==0:
print("Fizz")
else:
print(num)

st = 'Create a list of the first letters of every word in this string'

[word[0] for word in st.split(' ')]

# CREATING A LIST – lsita zadan na dzis 😊

ToDo=[]
finished = False

while not finished:

task=input("Podaj zadanie na dzis...")
if task.lower() == "koniec":
finished = True
elif len(task) == 0: #obsluga wcisniecia enter
finished = True
else:
ToDo.append(task)
print("Zadanie dodane!")

#Displat ToDo list

print()
print("Twoja lista zadan na dzis....")
print("-"*20)
for task in ToDo:
print(task)

funckja zaliczajaca duze I male litery w stringu

def cal (st):
upper =0
lower= 0
for letter in st:
if letter.isupper():
upper= upper +1
elif letter.islower():
lower = lower+1
return (upper, lower)