Od zera do mistrza Big Data i uczenia maszynowego w Pythonie. Część 2

    2 komentarze

    Anaconda i notatniki Jupitera

    Do zabawy z Pythonem wykorzystałem Anaconda i dostępne notatniki Jupitera.

    Downloads

    Pobrałem wersję 64 bitową z obsługa Pythona 3.

    Po pomyślnej instalacji uruchamiamy Anaconda Navigator

    Wybieramy jupyter notebook, przycisk Launch i naszym oczom otwiera się strona

    http://localhost:8888/tree

    Tworzymy notatnik wybierając język Python 3.

    Przygotowaliśmy nasz pierwszy notatnik o nazwie Nowy, nazwę można łatwo zmienic z poziomu menu File lub klikając na nazwę.

     

    Podstawowe operacje dostępne w notatniku można wylistować za pomocą klawisza H.  Należy pamiętać, by kursor nie był umieszczony w komórce.

    Notatnik można rozumieć jako interkatywny skrypt, który składa się z dwóch rodzajów komórek: opisowych (w składni Markdown)  i tych, w których wpisujemy kod języka.

    Opis składni Markdown można znaleźć w wielu miejscach. Ja korzystałem z

    https://github.com/adam-p/markdown-here/wiki/Markdown-Here-Cheatsheet

    Próbujmy sprawdzić wersję  naszych narzędzi

    U mnie wyglada to tak:

    Siłą języka, nie tylko w zakresie uczenia maszynowego (ML), jest dostępna ogromna list  gotowych pakietów, które znacznie upraszczają budowę skomplikowanych algorytmów.

    Pakiety gromadzone są w repozytorium zwanym PyPI (Python Package Index). Instalacja modułów  może być wykonana również z poziomu notatnika.
    Kod zaczynamy od !pip, co oznacza wykorzystanie instrukcji powłoki pip. Przykładem takiego pakietu jest folium pozwalający na obsługę map.

    Krótka demonstracja możliwości

    Kod umieszczony na GitHub

    Podgląd:

    https://nbviewer.jupyter.org/github/djkormo/PythonForML/blob/master/intro/MapaPolski.ipynb

    Uruchomienie:

    https://mybinder.org/v2/gh/djkormo/PythonForML/master?filepath=intro/MapaPolski.ipynb

    Po uruchomieniu kontenera należy wyczyścić informacje wyjściowe za pomocą menu Kernel -> Restart & Clear Output.

    Reenderowane wtyczką WP:

    In [8]:
    # importujemy pakiet folium
    import folium
    
    # konfiguracja obiektu mapy
    mapa = folium.Map(location=[52.325, 18.94], zoom_start=6)
    
    # wyswietlamy mape
    mapa
    
    Out[8]:

    Na tym kończę pierwszą demonstrację. Nie można być astronautą z marszu.

    Wracamy do podstaw

    • Na początku warto zaznajomić się z czterema podstawowymi typami skalarnymi:
      całkowitym,
      rzeczywistym,
      logicznym,
      łańcuchowym
      Należy zwrócić uwagę na to, że mamy do czynienia z dynamicznym typowaniem, co w praktyce oznacza zmianę typu zmiennej w czasie i wymaga kontroli typu przez programistę. To na czym chcę się dodatkowo skoncentrować to jawna konwersja typów, system pomocy, wbudowane funkcje.

    Przykładowy  notatnik  umieszczony na githubie:

    https://github.com/djkormo/PythonForML/blob/master/intro/Kurs_1_typy_zmienne.ipynb

    Podgląd:

    https://nbviewer.jupyter.org/github/djkormo/PythonForML/blob/master/intro/Kurs_1_typy_zmienne.ipynb

    Uruchomienie:

    https://mybinder.org/v2/gh/djkormo/PythonForML/master?filepath=intro/Kurs_1_typy_zmienne.ipynb

    Po uruchomieniu kontenera należy wyczyścić informacje wyjściowe za pomocą menu Kernel -> Restart & Clear Output.

    Reenderowane wtyczką WP:

    In [1]:
    print("Powitanie!")
    
    Powitanie!
    

    Podstawowe typy danych

    całkowite

    rzeczywiste

    logiczne

    napisy

    In [2]:
    # Python jako kalkulator
    
    1+2
    
    Out[2]:
    3
    In [3]:
    # Priorytety operatorów  dodawania i mnożenia
    
    1+2*3
    
    Out[3]:
    7
    In [4]:
    # wymuszanie priorytetow operacji
    
    (1+2)*3
    
    Out[4]:
    9
    In [5]:
    # dzielenie
    
    1/2
    
    Out[5]:
    0.5
    In [6]:
    # dzielenie, ktorego wynikiem jest wartość rzeczywista
    
    4.0/2.0
    
    Out[6]:
    2.0
    In [7]:
    # dzielenie calkowite
    
    5//2
    
    Out[7]:
    2
    In [8]:
    # nie mylić dzielenia całkowitego // z resztą z dzielenia całkowitego %
    5%2
    
    Out[8]:
    1
    In [9]:
    # typ całkowity
    
    type(2)
    
    Out[9]:
    int
    In [10]:
    # typ rzeczywisty
    
    type(2.0)
    
    Out[10]:
    float
    In [11]:
    # konwersja typu całkowitego na rzeczywisty
    
    float(1)
    
    Out[11]:
    1.0
    In [12]:
    # konwersja typu rzeczywistego na całkowity
    
    int(1.0)
    
    Out[12]:
    1
    In [13]:
    # zapiszmy wartość w zmiennej a
    
    a=1
    
    # wyświetlamy jej wartość
    
    print(a)
    
    # wyświetlamy jej typ
    
    print(type(a))
    
    1
    <class 'int'>
    
    In [14]:
    # python jest typowany dynamiczne, typ zmiennej a moze się zmieniać w czasie
    
    a=2.1
    
    # wyswietlmy jej wartość
    
    print(a)
    
    # wyswietlmy jej typ
    
    print(type(a))
    
    2.1
    <class 'float'>
    
    In [15]:
    #usuwanie zmiennych
    
    a=2.5
    print(a)
    
    #usuwamy zmienną a
    
    del a
    
    #uzycie usuniętej zmiennej konczy się błędem
    
    print(a)
    
    2.5
    
    ---------------------------------------------------------------------------
    NameError                                 Traceback (most recent call last)
    <ipython-input-15-a90c5f43f700> in <module>()
         10 #uzycie usuniętej zmiennej konczy się błędem
         11 
    ---> 12 print(a)
    
    NameError: name 'a' is not defined
    In [16]:
    #Python rozróżnia duże i małe litery
    
    b=1.0
    print(B) #name 'B' is not defined
    
    ---------------------------------------------------------------------------
    NameError                                 Traceback (most recent call last)
    <ipython-input-16-6d77e211bb3c> in <module>()
          2 
          3 b=1.0
    ----> 4 print(B) #name 'B' is not defined
    
    NameError: name 'B' is not defined
    In [17]:
    # dwie różne zmienne  o dwóch różnych typach
    
    b=1.0
    B=102
    print(b,type(b),B,type(B))
    
    1.0 <class 'float'> 102 <class 'int'>
    
    In [18]:
    # utworzenie zmiennych typu napis, możemy stosować jak ograniczniki znaki " jak rownież '
    
    s1="NApis1"
    s2='Napis2'
    
    # powielamy pięć razy zawartość zmiennej s1 i umieszczamy całość w zmiennje s3
    
    s3=5*s1
    print(s3)
    
    # sklejanie napisów za pomocą operatora +
    
    s4=s1+" "+s2
    print(s4)
    
    # postawowe funkcje operujące na napisach
    
    print(len(s4)) # dlugość napisu
    print(s4.upper()) # zamiana na duze litery
    print(s4.lower()) # zamiana na male litery
    
    print(s4.capitalize())  # kapitalizacja napisu
    print(s4.replace('N', 'NN'))  #zamiana N na NN
    print(s4.rjust(20)) #dopasowanie do prawej napisu , pozostałe znaki wypełnione spacją 
    print(s4.ljust(20)) #dopasowanie do lewej napisu, pozostałe znaki wypełnione spacją-
    print(s4.center(20)) #dopasowanie do lewej napisu, pozostałe znaki wypełnione spacją-
    print('  napis ze spacjami po obu stronach     '.strip())
    
    # formatowanie napisu wyjściowego
    
    s5 ='{0} {1} {2}'.format('Witamy', 'w roku',2018)
    print(s5)  
    
    NApis1NApis1NApis1NApis1NApis1
    NApis1 Napis2
    13
    NAPIS1 NAPIS2
    napis1 napis2
    Napis1 napis2
    NNApis1 NNapis2
           NApis1 Napis2
    NApis1 Napis2       
       NApis1 Napis2    
    napis ze spacjami po obu stronach
    Witamy w roku 2018
    
    In [19]:
    #typy logiczne przyjmują tylko dwie wartości prawda/fałsz
    
    l1=True
    l2=False
    
    #wyswietlamy wartośc obu zmiennych
    
    print(l1,l2)
    print(type(l1))
    
    #operator  iloczynu logicznego AND
    
    print(l1 and l2)
    
    #operator sumy logicznej OR
    
    print(l1 or l2)
    
    # operator negacji NOT
    
    print (not l2)
    
    # alternatywa rozłączna XOR
    
    print (l1 != l2)
    
    True False
    <class 'bool'>
    False
    True
    True
    True
    

    System pomocy

    In [20]:
    #  polecenie help pozwala na dostęp do systemowej pomocy  Pythona
    help(print)
    help(len)
    
    Help on built-in function print in module builtins:
    
    print(...)
        print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
        
        Prints the values to a stream, or to sys.stdout by default.
        Optional keyword arguments:
        file:  a file-like object (stream); defaults to the current sys.stdout.
        sep:   string inserted between values, default a space.
        end:   string appended after the last value, default a newline.
        flush: whether to forcibly flush the stream.
    
    Help on built-in function len in module builtins:
    
    len(obj, /)
        Return the number of items in a container.
    
    
    In [22]:
    # istnieje też możliwość otrzymania pomocy wykorzystując składnię Jupitera. To nie jest część języka Python (!)
    
    # dodajemy znak ? przed nazwą funkcji
    
    ?print
    
    # to samo jeśli dodamy znak ? po nazwie funkcji
    
    print?
    

    Konwersja typów

    In [23]:
    #konwersja typu logicznego na całkowity 
    
    a1=int(True)
    a2=int(False)
    print('poczatek: ',a1,a2)
    
    #konwersja typu całkowitego na logiczny 0 -> False, pozostałe liczby -> True
    
    b1=bool(-1)
    b2=bool(0)
    b3=bool(1)
    b4=bool(2)
    print('konwersja z int: ',b1,b2,b3,b4)
    
    
    #konwersja typu  rzeczywistego na logiczny 0.0 -> False, pozostałe liczby -> True
    
    b11=bool(-1.0)
    b21=bool(0.0)
    b31=bool(1.5)
    b41=bool(5.6)
    print('konwersja z float:', b11,b21,b31,b41)
    
    
    # konwersja napisu na typ logiczny, pusty napis -> False, pozostałe -> True
    
    b12=bool('')
    b22=bool('Ala')
    b32=bool('ma')
    b42=bool('kota')
    print('KOnwersja ze string: ',b12,b22,b32,b42)
    
    poczatek:  1 0
    konwersja z int:  True False True True
    konwersja z float: True False True True
    KOnwersja ze string:  False True True True
    
    In [24]:
    #konwesja typu łańcuchowego i liczowego
    
    s1='13'
    s2='12'
    a1=int(s1+s2)
    print(a1)
    print(type(a1))
    
    # konwersja połączona z operarorem potęgowania **
    
    a2=int(s1)**2
    print(a2)
    print(type(a2))
    
    # konwersja typu łańcuchowego przez typ całowity do typu rzeczywistego
    
    f1 = float(int(a1)-int(a2))
    print(f1, type(f1))
    
    # konwersja typu rzeczywistego na łańcuchowy
    
    s3=str(f1)
    print(s3,type(s3))
    
    1312
    <class 'int'>
    169
    <class 'int'>
    1143.0 <class 'float'>
    1143.0 <class 'str'>
    

    Kilka sztuczek

    In [25]:
    # zamiana wartości dwoch zmiennych
    
    z1 =5
    z2 =7
    
    print('Stan wejściowy: ',z1,z2, type(z1),type(z2))
    
    # klasycznie za pomocą dodatkowej zmiennej
    
    temp= z1
    z1  = z2
    z2  = temp
    
    print('Stan wyjściowy  z dodatkową zmienną: ',z1,z2, type(z1),type(z2))
    
    # sprytnie, bez pomocy dodatkowej zmiennej
    # tu zastosowano krotkę (tuple) 
    # będzie o tym w dalszej cześć kursu
    
    print('Stan wejściowy: ',z1,z2, type(z1),type(z2))
    
    # krotka w tle
    z1, z2 = z2, z1
    
    print('Stan wyjściowy z krotką: ',z1,z2, type(z1),type(z2))
    
    Stan wejściowy:  5 7 <class 'int'> <class 'int'>
    Stan wyjściowy  z dodatkową zmienną:  7 5 <class 'int'> <class 'int'>
    Stan wejściowy:  7 5 <class 'int'> <class 'int'>
    Stan wyjściowy z krotką:  5 7 <class 'int'> <class 'int'>
    
    In [26]:
    # Komentarze w Języku Python to znak #, po którym wszystkie znaki do końca linii sa ignorowane przez interpreter
    
    a, b,c,d,s = 1, 2,3,4.5,'Jest parno' # deklarujemy wartość kilku zmiennych w jednej linii 
    # Na szczęście można też tworzyć komentarze  o zakresie wielu linii 
    '''
    To jest komentarz, który można zapisać w wielu liniach.
    Często jest stosowany na początku definicji funkcji.
    '''
    print(a,b,c,d,s, type(a),type(b),type(c),type(d),type(s))
    
    1 2 3 4.5 Jest parno <class 'int'> <class 'int'> <class 'int'> <class 'float'> <class 'str'>
    
    In [27]:
    # potegowanie ma wyższy priorytet niż mnożenie, dodawanie, ale również zmianę znaku (operator unarny) (!)
    
    print(-2**8)   # wynik -256
    
    # w takiej sytuacji zawsze można wymusić priorytet wykorzystująca nawiasy ()
    
    print((-2)**8) # wynik 256
    
    -256
    256
    
    In [28]:
    # Dzielenie modulo % i // ma zastosowanie nie tylko dla liczb całkowitych dodatnich, ale również dla liczb całkowitych ujemnych
    # a nawet liczb rzeczywistych
    
    # Dzielenie całkowite dla liczb całkowitych ujemnych
    
    print(-13//-5)
    
    # Dzielenie całkowite dla liczb całkowitych ujemnych
    
    print(-13%-5)
    
    
    # Dzielenie całkowite dla liczb rzeczywistych
    
    print(2.4//1.3)
    
    # Dzielenie modulo  dla liczb rzeczywistych
    
    print(2.4%1.3)
    
    2
    -3
    1.0
    1.0999999999999999
    
    In [29]:
    # Python udostępnia również odpowiednik liczb zespolonych
    
    
    c1=2+5j
    c2=2-4j
    
    print(c1,c2,type(c1),type(c2))
    
    
    # dodawanie
    
    c3=c1+c2
    
    # odejmowanie
    
    c4 =c1-c2
    
    # mnozenie 
    
    c5=c1*c2
    
    # dzielenie
    
    c6=c1/c2
    
    print(c3,c4,c5,c6,type(c3),type(c4),type(c5),type(c6))
    
    # są też dostępne inne operacje
    
    # moduł 
    
    print(abs(3+4j))  #   
    
    # potegowanie
    
    print(pow(c1, 2))
    
    # tworzenie zmiennej typu zespolonego
    c7=complex(2,5) # 2+5j
    print(c7.real,type(c7.real)) # część rzeczywista  2.0
    print(c7.imag,type(c7.imag)) # część urojona 5.0
    print(c7.conjugate(),type(c7.conjugate())) 
    
    # do bardziej skompilowanych wyrażeń mozna wykorzystać modul cmath
    
    import cmath
    print(cmath.sin(2 + 5j), type(cmath.sin(2 + 5j)))
    
    (2+5j) (2-4j) <class 'complex'> <class 'complex'>
    (4+1j) 9j (24+2j) (-0.8+0.9j) <class 'complex'> <class 'complex'> <class 'complex'> <class 'complex'>
    5.0
    (-21+20j)
    2.0 <class 'float'>
    5.0 <class 'float'>
    (2-5j) <class 'complex'>
    (67.47891523845588-30.879431343588244j) <class 'complex'>
    
    In [47]:
    import sys
    
    # maksymalnia wartość liczby całkowitej 64 bitowej
    
    print(sys.maxsize)
    
    amax=amax=2**63 -1
    
    print(amax,type(amax))
    
    # przekraczamy wartość maksymalną, czy pojawi się błąd ?
    amax=2**128
    
    print(amax,type(amax)) # nadal typu int
    
    9223372036854775807
    9223372036854775807 <class 'int'>
    340282366920938463463374607431768211456 <class 'int'>
    
    In [58]:
    # przykład z poprzedniej komorki, który obrazuje dodawania kolejnych bajtów dla zmiennej całkowitej
    # rozszerzanie on demand
    
    #  mały przedsmak  wykorzystania pętli for
    
    x=256
    for i in range(1,6):
      x=x*x
      print ("size:", x.__sizeof__(), "value:", x)
    
    size: 28 value: 65536
    size: 32 value: 4294967296
    size: 36 value: 18446744073709551616
    size: 44 value: 340282366920938463463374607431768211456
    size: 60 value: 115792089237316195423570985008687907853269984665640564039457584007913129639936
    
    In [51]:
    # liczby całkowite mogą stosować inne systemy niż dziesiętny
    
    # system dwójkowy -> liczbe rozpoczybamy od 0b
    
    abin=0b1111 # 1*2**3 + 1*2**2 + 1*2**1 +1*2**0 = 8 + 4 + 2 + 1 =15
    
    # system usemkowy -> liczbe rozpoczybamy od 0o
    
    aoct = 0o123 # 1*8**2 + 2*8**1 + 3 * 8**0 = 64 + 16 +3 = 83
    
    # system szestnastkowy -> liczbe rozpoczybamy od 0x
    
    ahex =0xff # 15*16**1 + 15*16**0 =  240 + 15 = 255
    
    print(abin,aoct,ahex)
    
    15 83 255
    

    Literatura:
    Opis podłączenia notatnika z Githuba do WordPressa

    https://github.com/ghandic/nbconvert

    Cheat sheet

    https://perso.limsi.fr/pointal/_media/python:cours:mementopython3-english.pdf

    Tutorial z Kaggle

    https://www.kaggle.com/learn/python

     

    Categories: migawka, Python

    2 Replies to “Od zera do mistrza Big Data i uczenia maszynowego w Pythonie. Część 2”

    Dodaj komentarz

    Twój adres email nie zostanie opublikowany. Pola, których wypełnienie jest wymagane, są oznaczone symbolem *