Wprowadzenie do Pythona

Wprowadzenie

Witamy w samouczku online Google dotyczącym języka Python. Jest on oparty na wewnętrznym kursie wprowadzającym do języka Python. Jak wspomnieliśmy na stronie konfiguracji, materiały te dotyczą języka Python 3.

Jeśli szukasz towarzyszącego kursu MOOC, wypróbuj te z Udacity i Coursera (wprowadzenie do programowania [dla początkujących] lub wprowadzenie do Pythona). Jeśli szukasz kursów online, które możesz ukończyć we własnym tempie bez oglądania filmów, wypróbuj te wymienione pod koniec tego posta. Każdy z nich zawiera treści edukacyjne oraz interaktywny interpreter Pythona, w którym możesz ćwiczyć. Czym jest wspomniany „tłumacz”? Dowiesz się tego w następnej sekcji.

Wprowadzenie do języka

Python to dynamiczny język interpretowany (kompilowany do kodu bajtowego). W kodzie źródłowym nie ma deklaracji typów zmiennych, parametrów, funkcji ani metod. Dzięki temu kod jest krótki i elastyczny, ale tracisz sprawdzanie typu kodu źródłowego w czasie kompilacji. Python śledzi typy wszystkich wartości w czasie działania programu i oznacza kod, który nie ma sensu.

Świetnym sposobem na sprawdzenie, jak działa kod Pythona, jest uruchomienie interpretera Pythona i wpisanie w nim kodu. Jeśli kiedykolwiek zadasz sobie pytanie „Co się stanie, jeśli dodam int do list?”, wpisanie go w interpreterze Pythona będzie szybkim i prawdopodobnie najlepszym sposobem na sprawdzenie, co się stanie. (Poniżej dowiesz się, co się stanie w rzeczywistości).

$ python3        ## Run the Python interpreter
Python 3.X.X (XXX, XXX XX XXXX, XX:XX:XX) [XXX] on XXX
Type "help", "copyright", "credits" or "license" for more information.
>>> a = 6       ## set a variable in this interpreter session
>>> a           ## entering an expression prints its value
6
>>> a + 2
8
>>> a = 'hi'    ## 'a' can hold a string just as well
>>> a
'hi'
>>> len(a)      ## call the len() function on a string
2
>>> a + len(a)  ## try something that doesn't work
Traceback (most recent call last):
  File "", line 1, in 
TypeError: can only concatenate str (not "int") to str
>>> a + str(len(a))  ## probably what you really wanted
'hi2'
>>> foo         ## try something else that doesn't work
Traceback (most recent call last):
  File "", line 1, in 
NameError: name 'foo' is not defined
>>> ^D          ## type CTRL-d to exit (CTRL-z in Windows/DOS terminal)

Dwa wiersze, które Python wyświetla po wpisaniu polecenia python i przed wyświetleniem prompta >>>, zawierają informacje o wersji Pythona, której używasz, i o tym, gdzie została utworzona. Dopóki pierwszym wydrukowanym tekstem jest „Python 3.”, te przykłady powinny działać.

Jak widać powyżej, eksperymentowanie ze zmiennymi i operatorami jest proste. Interpreter zgłasza też błąd wykonania, jeśli kod próbuje odczytać zmienną, której nie przypisano wartości. Podobnie jak C++ i Java, Python rozróżnia wielkość liter, więc „a” i „A” to różne zmienne. Koniec wiersza oznacza koniec instrukcji, więc w przeciwieństwie do języków C++ i Java Python nie wymaga średnika na końcu każdej instrukcji. Komentarze zaczynają się od znaku „#” i trwają do końca wiersza.

Kod źródłowy w Pythonie

Pliki źródłowe Pythona mają rozszerzenie „.py” i są nazywane „modułami”. W przypadku modułu Pythona hello.py najłatwiej uruchomić go za pomocą polecenia powłoki „python hello.py Alice”, które wywołuje interpreter Pythona w celu wykonania kodu w hello.py, przekazując mu argument wiersza poleceń „Alice”. Wszystkie opcje uruchamiania Pythona z wiersza poleceń znajdziesz na oficjalnej stronie dokumentacji.

Oto bardzo prosty program w języku hello.py (zwróć uwagę, że bloki kodu są ściśle rozdzielane za pomocą wcięć, a nie nawiasów klamrowych – więcej informacji na ten temat znajdziesz w dalszej części artykułu):

#!/usr/bin/python3

# import modules used here -- sys is a very standard one
import sys

# Gather our code in a main() function
def main():
    print('Hello there', sys.argv[1])
    # Command line args are in sys.argv[1], sys.argv[2] ...
    # sys.argv[0] is the script name itself and can be ignored

# Standard boilerplate to call the main() function to begin
# the program.
if __name__ == '__main__':
    main()

Uruchomienie tego programu z wiersza poleceń wygląda tak:

$ python3 hello.py Guido
Hello there Guido
$ ./hello.py Alice  ## without needing 'python3' first (Unix)
Hello there Alice

Importy, argumenty wiersza poleceń i len()

Instrukcje najwyższego poziomu w pliku Pythona, czyli „module”, wykonują jednorazową konfigurację – są one wykonywane od góry do dołu przy pierwszym zaimportowaniu modułu w innym miejscu, konfigurując jego zmienne i funkcje. Moduł Pythona można uruchomić bezpośrednio – jak powyżej python3 hello.py Bob – lub zaimportować i użyć w innym module. Gdy plik Pythona jest uruchamiany bezpośrednio, specjalna zmienna „__name__” jest ustawiana na „__main__”. Dlatego często stosuje się powyższy kod if __name__ ==..., aby wywołać funkcję main(), gdy moduł jest uruchamiany bezpośrednio, ale nie wtedy, gdy jest importowany przez inny moduł.

W standardowym programie w języku Python lista sys.argv zawiera argumenty wiersza poleceń w standardowy sposób: sys.argv[0] to sam program, sys.argv[1] to pierwszy argument itd. Jeśli znasz wartość argv lub liczbę argumentów, możesz po prostu poprosić o nią Pythona za pomocą len(sys.argv), tak jak w przypadku kodu interaktywnego interpretera powyżej, gdy prosiliśmy o długość ciągu znaków. Ogólnie rzecz biorąc, funkcja len() może podać długość ciągu znaków, liczbę elementów na listach i w krotkach (innej strukturze danych podobnej do tablicy) oraz liczbę par klucz-wartość w słowniku.

Funkcje zdefiniowane przez użytkownika

Funkcje w Pythonie są definiowane w ten sposób:

# Defines a "repeat" function that takes 2 arguments.
def repeat(s, exclaim):
    """
    Returns the string 's' repeated 3 times.
    If exclaim is true, add exclamation marks.
    """

    result = s + s + s # can also use "s * 3" which is faster (Why?)
    if exclaim:
        result = result + '!!!'
    return result

Zwróć też uwagę, jak wiersze tworzące funkcję lub instrukcję warunkową są pogrupowane, ponieważ wszystkie mają ten sam poziom wcięcia. Pokazaliśmy też 2 różne sposoby powtarzania ciągów znaków: za pomocą operatora +, który jest bardziej przyjazny dla użytkownika, oraz operatora *, który również działa, ponieważ jest operatorem „powtarzania” w Pythonie. Oznacza to, że '-' * 10 daje '----------', co jest dobrym sposobem na utworzenie „linii” na ekranie. W komentarzu do kodu wspomnieliśmy, że operator * działa szybciej niż operator +, ponieważ operator * oblicza rozmiar wynikowego obiektu tylko raz, a operator + wykonuje to obliczenie za każdym razem, gdy jest wywoływany. Zarówno operator +, jak i * są „przeciążone”, ponieważ mają inne znaczenie w przypadku liczb niż w przypadku ciągów znaków (i innych typów danych).

Słowo kluczowe def definiuje funkcję z parametrami w nawiasach i wcięciami w kodzie. Pierwszy wiersz funkcji może być ciągiem dokumentacji („docstring”), który opisuje, co robi funkcja. Ciąg dokumentujący może być jedno- lub wielowierszowym opisem, jak w przykładzie powyżej. (Tak, to „potrójne cudzysłowy”, funkcja dostępna tylko w Pythonie). Zmienne zdefiniowane w funkcji są lokalne dla tej funkcji, więc „result” w powyższej funkcji jest oddzielony od zmiennej „result” w innej funkcji. Instrukcja return może przyjmować argument, w którym to przypadku jest to wartość zwracana do wywołującego.

Oto kod, który wywołuje powyższą funkcję repeat() i wyświetla to, co zwraca:

def main():
    print(repeat('Yay', False))      ## YayYayYay
    print(repeat('Woo Hoo', True))   ## Woo HooWoo HooWoo Hoo!!!

W czasie działania funkcji muszą być zdefiniowane przez wykonanie „def” przed ich wywołaniem. Zwykle funkcja main() jest definiowana u dołu pliku, a funkcje, które wywołuje, znajdują się powyżej niej.

Wcięcie

Jedną z nietypowych cech Pythona jest to, że wcięcia w kodzie mają wpływ na jego znaczenie. Logiczny blok instrukcji, taki jak instrukcje tworzące funkcję, powinien mieć takie samo wcięcie, które jest ustawione względem wcięcia funkcji nadrzędnej lub instrukcji „if” itp. Jeśli jeden z wierszy w grupie ma inne wcięcie, jest oznaczany jako błąd składni.

Używanie białych znaków w Pythonie wydaje się na początku nieco dziwne, ale jest logiczne i szybko się do niego przyzwyczaiłem. Unikaj używania znaków TAB, ponieważ bardzo komplikują one schemat wcięcia (nie wspominając o tym, że na różnych platformach mogą oznaczać różne rzeczy). Skonfiguruj edytor tak, aby w przypadku kodu w Pythonie wstawiał spacje zamiast tabulatorów.

Początkujący często pytają: „Ile spacji należy wstawić na początku wiersza?”. Zgodnie z oficjalnym przewodnikiem po stylu Pythona (PEP 8) wcięcia powinny mieć 4 spacje. (Ciekawostka: wewnętrzne wytyczne Google dotyczące stylu wymagają wcięcia o 2 spacje).

Kod sprawdzany w czasie działania

Python wykonuje bardzo mało sprawdzeń w czasie kompilacji, odkładając prawie wszystkie sprawdzenia typu, nazwy itp. w każdej linii do momentu jej uruchomienia. Załóżmy, że funkcja main() wywołuje funkcję repeat() w ten sposób:

def main():
    if name == 'Guido':
        print(repeeeet(name) + '!!!')
    else:
        print(repeat(name))

Instrukcja if zawiera oczywisty błąd, w którym funkcja repeat() została przypadkowo wpisana jako repeeeet(). Zabawne w Pythonie jest to, że ten kod kompiluje się i działa prawidłowo, o ile w czasie działania nazwa nie jest „Guido”. Dopiero gdy uruchomienie spróbuje wykonać funkcję repeeeet(), zauważy, że nie istnieje, i wygeneruje błąd. W tym fragmencie kodu jest też drugi błąd: zmiennej name nie przypisano wartości przed porównaniem jej z wartością „Guido”. Jeśli spróbujesz obliczyć wartość zmiennej, do której nie przypisano wartości, Python zgłosi błąd „NameError”. Oto kilka przykładów pokazujących, że gdy po raz pierwszy uruchomisz program w Pythonie, niektóre z pierwszych błędów, które zobaczysz, będą prostymi literówkami lub niezainicjowanymi zmiennymi, takimi jak te. W tym przypadku przewagę mają języki z bardziej rozbudowanym systemem typów, takie jak Java. Mogą one wykrywać takie błędy w czasie kompilacji (ale oczywiście trzeba utrzymywać wszystkie te informacje o typach – to kompromis).

W Pythonie 3 wprowadzono wskazówki dotyczące typów. Podpowiedzi dotyczące typu pozwalają określić typ każdego argumentu w funkcji, a także typ obiektu zwracanego przez funkcję. Na przykład w funkcji z adnotacjami def is_positive(n: int) -> bool: argument n jest typu int, a wartość zwracana jest typu bool. Później wyjaśnimy, co oznaczają te typy. Wskazówki dotyczące typów są jednak całkowicie opcjonalne. Coraz więcej kodu będzie korzystać z podpowiedzi dotyczących typów, ponieważ jeśli ich używasz, niektóre edytory, takie jak cider-v i VS.code, mogą przeprowadzać sprawdzanie, aby upewnić się, że funkcje są wywoływane z odpowiednimi typami argumentów. Mogą nawet sugerować i weryfikować argumenty podczas edytowania kodu. Ten samouczek nie obejmuje wskazówek dotyczących typów, ale chcemy, abyś o nich wiedział(a), jeśli o nich usłyszysz lub zobaczysz je w praktyce.

Nazwy zmiennych

Zmienne w języku Python nie mają w kodzie źródłowym określonego typu, dlatego warto nadawać im znaczące nazwy, aby pamiętać, co się dzieje. Użyj więc słowa „name”, jeśli jest to pojedyncza nazwa, „names”, jeśli jest to lista nazw, a „tuples”, jeśli jest to lista krotek. Wiele podstawowych błędów w języku Python wynika z zapominania, jaki typ wartości znajduje się w poszczególnych zmiennych. Używaj więc nazw zmiennych (to jedyne, co masz), aby zachować porządek.

Jeśli chodzi o nazewnictwo, w przypadku nazw zmiennych składających się z „więcej niż jednego słowa” w niektórych językach stosuje się podkreślenia_między_słowami, a w innych notację camelCase. Ogólnie rzecz biorąc, Python preferuje metodę z podkreśleniem, ale zaleca deweloperom stosowanie notacji camelCase, jeśli integrują kod z istniejącym kodem w Pythonie, który już używa tego stylu. Czytelność się liczy. Więcej informacji znajdziesz w sekcji dotyczącej konwencji nazewnictwa w PEP 8.

Jak można się domyślić, słów kluczowych takich jak „if” i „while” nie można używać jako nazw zmiennych – w takim przypadku pojawi się błąd składni. Uważaj jednak, aby nie używać wbudowanych funkcji jako nazw zmiennych. Na przykład nazwy „str”, „list” i „print” mogą się wydawać odpowiednie, ale w ten sposób zastąpisz zmienne systemowe. Funkcje wbudowane nie są słowami kluczowymi, dlatego nowi programiści w Pythonie mogą ich nieświadomie używać.

Więcej informacji o modułach i ich przestrzeniach nazw

Załóżmy, że masz moduł „binky.py”, który zawiera „def foo()”. Pełna nazwa tej funkcji foo to „binky.foo”. Dzięki temu różne moduły Pythona mogą nazywać swoje funkcje i zmienne w dowolny sposób, a nazwy zmiennych nie będą ze sobą kolidować – module1.foo różni się od module2.foo. W terminologii Pythona powiedzielibyśmy, że binky, module1 i module2 mają własne „przestrzenie nazw”, które, jak można się domyślać, są powiązaniami nazwy zmiennej z obiektem.

Na przykład mamy standardowy moduł „sys”, który zawiera niektóre standardowe funkcje systemowe, takie jak lista argv i funkcja exit(). Za pomocą instrukcji „import sys” możesz uzyskać dostęp do definicji w module sys i udostępnić je za pomocą ich w pełni kwalifikowanej nazwy, np.sys. exit(). (Tak, „sys” też ma przestrzeń nazw).

  import sys

  # Now can refer to sys.xxx facilities
  sys.exit(0)

Istnieje inny formularz importu, który wygląda tak: „from sys import argv, exit”. Dzięki temu zmienne argv i funkcja exit() są dostępne pod krótkimi nazwami. Zalecamy jednak używanie oryginalnej formy z pełnymi nazwami, ponieważ łatwiej jest wtedy określić, skąd pochodzi funkcja lub atrybut.

W standardowej instalacji interpretera Pythona jest wiele modułów i pakietów, więc nie musisz nic robić, aby ich używać. Są one określane zbiorczo jako „Biblioteka standardowa Pythona”. Najczęściej używane moduły i pakiety to:

  • sys – dostęp do funkcji exit(), argv, stdin, stdout itp.
  • re – wyrażenia regularne
  • os – interfejs systemu operacyjnego, system plików

Dokumentację wszystkich modułów i pakietów biblioteki standardowej znajdziesz na stronie http://docs.python.org/library.

Pomoc online, help() i dir()

Istnieje wiele sposobów uzyskania pomocy dotyczącej Pythona.

  • Wyszukaj w Google hasło zaczynające się od słowa „python”, np. „python list” lub „python string lowercase”. Pierwszy wynik wyszukiwania jest często odpowiedzią. Z jakiegoś powodu ta technika sprawdza się lepiej w przypadku Pythona niż innych języków.
  • Oficjalna strona dokumentacji Pythona – docs.python.org – zawiera dokumentację wysokiej jakości. Często jednak szybciej jest wyszukać w Google kilka słów.
  • Istnieje też oficjalna lista adresowa Tutor, która jest przeznaczona specjalnie dla osób, które dopiero zaczynają przygodę z Pythonem lub programowaniem.
  • Wiele pytań (i odpowiedzi) znajdziesz na StackOverflow i Quora.
  • Użyj funkcji help() i dir() (patrz poniżej).

W interpreterze Pythona funkcja help() wyświetla ciągi dokumentacji dla różnych modułów, funkcji i metod. Te ciągi dokumentujące są podobne do javadoc w języku Java. Funkcja dir() informuje o atrybutach obiektu. Oto kilka sposobów wywołania funkcji help() i dir() z interpretera:

  • help(len) – ciąg pomocy dla wbudowanej funkcji len(); zwróć uwagę, że jest to „len”, a nie „len()”, czyli wywołanie funkcji, którego nie chcemy.
  • help(sys) – ciąg pomocy dla modułu sys (najpierw musisz wykonać import sys)
  • dir(sys) – dir() jest podobne do help(), ale zawiera tylko krótką listę zdefiniowanych symboli lub „atrybutów”.
  • help(sys.exit) – ciąg pomocy dla funkcji exit() w module sys
  • help('xyz'.split) – ciąg pomocy dla metody split() w przypadku obiektów ciągów znaków. Możesz wywołać help() za pomocą samego obiektu lub jego przykładu oraz atrybutu. Na przykład dzwonienie pod numer help('xyz'.split) jest tym samym co dzwonienie pod numer help(str.split).
  • help(list) – ciąg pomocy dla list obiektów
  • dir(list) – wyświetla atrybuty obiektu list, w tym jego metody.
  • help(list.append) – ciąg pomocy dla metody append() w przypadku obiektów list