Python – Wprowadzenie do języka

Python – Wprowadzenie do języka

Python jest nowoczesnym, obiektowym, wysokopoziomowym językiem programowania, który możemy wykorzystać do wszystkiego.

Cechy charakterystyczne języka Python:

  • czysty i prosty język: intuicyjny kod, bardzo łatwo można się nauczyć, gramatyka jest bardzo minimalistyczna
  • wyrazisty język: mniej błędów, mniej linii kodu

Detale techniczne:

  • dynamicznie alokowany: nie ma potrzeby definiowania typów zmiennych, typu argumentów funkcji czy zwracanego typu.
  • automatyczne zarządzanie pamięcią: nie trzeba alokować pamięci bezpośrednio jeśli chodzi o zmienne, tablice czy różne struktury danych. Z pewnością nie będzie błędów związanych z wyciekiem pamięci.
  • interpretowany: kod nie jest kompilowany. Python Interpreter czyta i wykonuje bezpośrednio kod linijka po linijce.

Zalety:

  • Głównym dobrodziejstwem Pythona jest ułatwienie kodowania, zminimalizowania czasu potrzebnego do wytworzenia kodu, debugowania czy dbania o niego.
  • Świetnie przygotowany język, który pozwoli początkującym wejść w świat programowania
  • Język programowania zorientowany obiektowo
  • Oprogramowanie pip pozwalające na łatwe zarządzenie modułami
  • Dokumentacja zintegrowana z kodem
  • Bardzo duża ilość dodatkowych modułów i bibliotek

Wady:

  • Język Python przez to, że jest to język interpretowany może być znacznie wolniejszy w porównaniu z C++ czy Assemblerem, które są językami kompilowanymi
  • Odrobinę zdecentralizowany, z różnymi środowiskami programistycznymi, pakietami czy dokumentacjami rozrzuconymi po całej sieci. Niekiedy ciężko zacząć.

Podstawowe typy danych i drukowanie

Tak jak większość języków programowania Python posiada kilka standardowych typów danych, w skład który wchodzą:

  • liczby stałe (integer)
  • liczby zmiennoprzecinkowe (float)
  • zmienne logiczne (bool)
  • łańcuchy znaków (string)

Wymienione wyżej typy zachowują się jak w większości innych języków jakie mogłeś już kiedyś poznać. Należy zauważyć, że te obiekty są instancjami klas.

print('This is integer type:\t',   3,         '\t\t', type(3))
print('This is float type:\t',     3.0,       '\t\t', type(3.0))
print('This is complex type:\t',   3 + 1j*3.5,'\t',   type(3 + 1j*3.5))
print('This is string type:\t',    'String',  '\t',   type("String"))
print('This is bool type:\t',      True,      '\t\t', type(True))
print('This is also bool type:\t', False,     '\t\t', type(False))

Funkcja print() pozwala na bardziej zaawansowane wyrażenie numerycznych zmiennych, co może być niekiedy przydatne. Moduł print języka Python jest implementacją dobrze znanego printf z biblioteki stdlib przeznaczonej dla języka C.

Łańcuchy znaków (strings) są listami pojedynczych znaków, które można wyświetlić. Możemy je definiować przy użyciu apostrofu oraz cudzysłowia.

print('Hello, World!')
print("Hello, World!")
print('She asked, "How are you today?"')

Zmienne

Zazwyczaj, kiedy piszemy kod potrzebujemy korzystać z danych w przystępny sposób, żeby móc wykorzystywać zmienne podczas dalszej pracy. Python oferuje operacje przypisywania do zmiennych. Warto zwrócić uwagę, że tytułowy język rozróżnia duże i małe litery, dlatego też 'A’ będzie kompletnie czym innym w porównaniu do 'a’. Nazwy zmiennych mogą zawierać w sobie znaki alfanumeryczne takie jak a-z, A-Z, 0-9 oraz kilka znaków specjalnych (np. _).

Zmienne definiujemy korzystając z operatora przypisania (=):

a = 1
b = '3'

print('Check this variable type:\t', a, '\t\t', type(a))
print('Chekk this variable type:\t', b, '\t\t', type(b))

Operacje arytmetyczne

Domyślnie Python implementuje kilka operacji arytmetycznych, których działanie możemy obserwować poniżej:

x = 3
print(x)
print(x + 1) # addition
print(x - 1) # subtraction
print(x / 10) # division
print(x % 2) # modulo
print(x * 2) # multiplication
print(x // 2) # extraction of a root
print(x ** 2) # exponentiation

Kontenery danych

Python dołącza kilka wbudowanych kontenerów na dane: listy, słowniki, zestawy i zmienne typu tuple.

Listy

Lista w Pythonie jest odpowiednikiem tablicy zmiennych, jednak jej wielkość możemy modyfikować, natomiast same zmienne mogą być różnego typu:

L = [5, 10, 23, 34, 56]

print(L) # prints [5, 10, 23, 34, 56]
print(L[2]) # prints 23
print(L[-2]) # prints 34

L.append('text') # adds 'text' element to the end of array
print(L[-1]) # prints it

L.append([2.5, 'second text']) # add list to L
print(L[-1]) # prints [2.5, 'second text']

print(L) # [5, 10, 23, 34, 56, 'text', [2.5, 'second text']]

L.pop() # removes last element of list
print(L[-1]) # prints 'text'

Wykrojenia / Wycinki

Podczas korzystania z list możemy tworzyć tzw. sub listy. Żeby takie uzyskać należy skorzystać z metod wycinania bądź wykrajania:

L = list(range(5))     # range is a built-in function that creates a list of integers
print(L)         # Prints "[0, 1, 2, 3, 4]"
print(L[2:4])    # Get a slice from index 2 to 4 (exclusive); prints "[2, 3]"
print(L[2:])     # Get a slice from index 2 to the end; prints "[2, 3, 4]"
print(L[:2])     # Get a slice from the start to index 2 (exclusive); prints "[0, 1]"
print(L[:])      # Get a slice of the whole list; prints ["0, 1, 2, 3, 4]"
print(L[:-1])    # Slice indices can be negative; prints ["0, 1, 2, 3]"
L[2:4] = [8, 9]  # Assign a new sublist to a slice
print(L) # prints "[0, 1, 8, 9, 4]"
L[2:4] = [8, 9, 10] # check adding more elements
print(L)         # Prints "[0, 1, 8, 9, 10, 4]"

Pętle

Iteracje przez każdy element wchodzący w skład listy możemy wykonać jak poniżej:

animals = ['cat', 'dog', 'monkey']
for animal in animals:
    print(animal)

Jeśli potrzebujemy uzyskać indeks każdego elementy w ciele pętli, należy skorzystać z wbudowanej funkcji enumerate:

animals = ['cat', 'dog', 'monkey']
for idx, animal in enumerate(animals):
    print('#%d: %s' % (idx + 1, animal))

Output:
#1: cat
#2: dog
#3: monkey

Wyrażenia listowe (list comprehensions)

Podczas wytwarzania oprogramowania nadchodzi potrzeba transformacji pewnego typu danych na zgoła odmienny. Żeby dobrze zrozumieć, co mam na myśli polecam spojrzeć na prosty przykład obliczania wyliczania kwadratów liczb w liście:

nums = [0, 1, 2, 3, 4]
squares = []
for x in nums:
    squares.append(x ** 2)
print(squares)

Kod możemy wykonać znacznie prostszym poprzez skorzystania z wyrażeń listowych:

nums = [0, 1, 2, 3, 4]
squares = [x ** 2 for x in nums]
print(squares)

Słowniki

Słowniki generalnie pracują na zasadzie pary klucza i wartości (key, value). Rozwiązanie jest bardzo podobne do std::map, które możemy zobaczyć w C++. Kilka przykładów znajduje się poniżej:

d = {'cat': 'cute', 'dog': 'furry'}  # Create a new dictionary with some data
print(d['cat'])     # Get an entry from a dictionary; prints "cute"
print('cat' in d)     # Check if a dictionary has a given key; prints "True"
d['fish'] = 'wet'    # Set an entry in a dictionary
print(d['fish'])      # Prints "wet"
print(d.get('monkey', 'N/A'))  # Get an element with a default; prints "N/A"
print(d.get('fish', 'N/A'))    # Get an element with a default; prints "wet"
del d['fish']        # Remove an element from a dictionary
print(d.get('fish', 'N/A')) # "fish" is no longer a key; prints "N/A"

Z łatwością możemy iterować po wszystkich elementach słownika korzystając z klucza:

d = {'person': 2, 'cat': 4, 'spider': 8}
for animal in d:
    legs = d[animal]
    print('A %s has %d legs' % (animal, legs))

Jeśli podczas iteracji potrzebujemy uzyskać dostęp do klucza i wartości należy skorzystać z metody items:

d = {'person': 2, 'cat': 4, 'spider': 8}
for animal, legs in d.items():
    print('A %s has %d legs' % (animal, legs))

Wyrażenia słownikowe (dict comprehensions)

Działają na tej samej zasadzie co wyżej wspomniane wyrażenia listowe, jednak te jak nazwa wskazuje pozwalają korzystać z słowników:

nums = [0, 1, 2, 3, 4]
even_num_to_square = {x: x ** 2 for x in nums if x % 2 == 0}
print(even_num_to_square)

Zestawy

Zestaw to nieuporządkowana lista elementów. Jako prosty przykład polecam przeanalizować poniższy przykład:

animals = {'cat', 'dog'}
print('cat' in animals)   # Check if an element is in a set; prints "True"
animals.add('fish')      # Add an element to a set
print('fish' in animals) #  Check if an element is in a set; prints "True"
print(len(animals))       # Number of elements in a set;

Zmienne typu tuple

Zmienne typu tuple są to (niezmienne) uporządkowane listy wartości. Na swój sposób jest bardzo podobna do listy. Jedną znaczącą różnicą jest fakt, iż taka struktura możemy używana jako klucz w słownikach oraz jako element w zestawach. Poniżej znajduje się trywialny przykład takich zmiennych:

d = {(x, x + 1): x for x in range(10)}  # Create a dictionary with tuple keys
t = (5, 6)       # Create a tuple
print(type(t))
print(d[t])   
print(d[(1, 2)])

Funkcje

Żeby zdefiniować funkcje w Pythonie należy wykorzystać słowo kluczowe def. Jak wspomniane w wprowadzeniu język nie wymaga definiowania typu danych, który będzie zwracany, tak jak typów argumentów przekazywanych do funkcji. Można jednak dodać zmienne opcjonalne, czyli takie które mają dodaną domyślną wartość, w przypadku nie podania tego argumentu zostają przypisane dane standardowe.

def fun(arg1, arg2, arg_opt=0):
    # Body of the function
    return arg1 + arg2 - arg_opt # Returned value

x = fun(0, 4)
y = fun(0, 4, 10)
print('fun returned: ', x)
print('fun with 3 args returned: ', y)

Klasy

Python oferuje bardzo dobre wsparcie dla programowania zorientowanego obiektowo. Zdecydowana większość wszystkich elementów zdefiniowanych w Pythonie są instancją jakiejś klasy.

Składnia definiowania klas jest taka jak poniżej:

class Greeter:

    # Constructor
    def __init__(self, name):
        self.name = name  # Create an instance variable

    # Instance method
    def greet(self, loud=False):
        if loud:
            print('HELLO, %s!' % self.name.upper())
        else:
            print('Hello, %s' % self.name)

g = Greeter('Fred')  # Construct an instance of the Greeter class
g.greet()            # Call an instance method; prints "Hello, Fred"
g.greet(loud=True)   # Call an instance method; prints "HELLO, FRED!"

Podsumowanie

To było szybkie wprowadzenie do języka Pythona oraz zaprezentowanie co może zaoferować programistom. Moją propozycją jest uruchomienie wszystkich kodów i przekonanie się jakie wyniki zostaną wydrukowane. Learn by doing!

Linki referencyjne:

Python 3: from None to Machine Learning

Python (Wiki)

Tagi: , ,

Dodaj komentarz

Twój adres e-mail nie zostanie opublikowany. Wymagane pola są oznaczone *