Python LanguagePierwsze kroki w języku Python


Uwagi

Logo Python
Python
jest powszechnie używanym językiem programowania. To jest:

  • Wysoki poziom : Python automatyzuje operacje niskiego poziomu, takie jak zarządzanie pamięcią. Pozostawia programistom nieco mniej kontroli, ale ma wiele zalet, w tym czytelność kodu i minimalne wyrażenia kodu.

  • Ogólnego zastosowania : Python jest zbudowany do użycia we wszystkich kontekstach i środowiskach. Przykładem języka nieprzeznaczonego do użytku ogólnego jest PHP: został on zaprojektowany specjalnie jako język skryptowy do tworzenia stron WWW po stronie serwera. W przeciwieństwie do tego, Python może być wykorzystywany do tworzenia stron WWW po stronie serwera, ale także do budowania aplikacji komputerowych.

  • Typowanie dynamiczne : każda zmienna w Pythonie może odwoływać się do dowolnego rodzaju danych. Pojedyncze wyrażenie może oceniać dane różnych typów w różnym czasie. Z tego powodu możliwy jest następujący kod:

    if something:
        x = 1
    else:
        x = 'this is a string'
    print(x)
    
  • Mocno wpisane : podczas wykonywania programu nie wolno robić niczego, co jest niezgodne z rodzajem danych, z którymi pracujesz. Na przykład nie ma ukrytych konwersji ciągów na liczby; ciąg złożony z cyfr nigdy nie będzie traktowany jako liczba, chyba że zostanie on jawnie przekonwertowany:

    1 + '1'  # raises an error
    1 + int('1')  # results with 2
    
  • Przyjazny dla początkujących :) : Składnia i struktura Pythona są bardzo intuicyjne. Jest na wysokim poziomie i zapewnia konstrukcje umożliwiające pisanie przejrzystych programów zarówno na małą, jak i na dużą skalę. Python obsługuje wiele paradygmatów programowania, w tym programowanie obiektowe, imperatywne i funkcjonalne lub style proceduralne. Ma dużą, kompleksową bibliotekę standardową i wiele łatwych do zainstalowania bibliotek stron trzecich.

Jego zasady projektowania są przedstawione w Zen of Python .

Obecnie istnieją dwie główne gałęzie wydania Pythona, które mają pewne znaczące różnice. Python 2.x jest starszą wersją, choć nadal jest szeroko stosowany. Python 3.x wprowadza zestaw niezgodnych wstecz zmian, które mają na celu ograniczenie duplikacji funkcji. Aby dowiedzieć się, która wersja jest dla Ciebie najlepsza, zobacz ten artykuł .

Oficjalna dokumentacja Pythona jest także wszechstronnym i użytecznym źródłem, zawierającym dokumentację dla wszystkich wersji Pythona, a także samouczki, które pomogą Ci zacząć.

Istnieje jedna oficjalna implementacja języka dostarczonego przez Python.org, ogólnie określana jako CPython, oraz kilka alternatywnych implementacji języka na innych platformach wykonawczych. Należą do nich IronPython (uruchamianie Pythona na platformie .NET), Jython (w środowisku wykonawczym Java) i PyPy (implementacja Pythona w jego podzbiorze).

Wersje

Python 3.x

Wersja Data wydania
[3.7] 2017-05-08
3.6 23.12.2016
3.5 13.09.2015
3.4 17.03.2014
3.3 29.09.2012
3.2 2011-02-20
3.1 26.06.2009
3.0 2008-12-03

Python 2.x

Wersja Data wydania
2.7 2010-07-03
2.6 02.10.2008
2.5 2006-09-19
2.4 2004-11-30
2.3 2003-07-29
2.2 2001-12-21
2.1 2001-04-15
2.0 2000-10-16

Pierwsze kroki

Python to szeroko stosowany język programowania wysokiego poziomu do programowania ogólnego, stworzony przez Guido van Rossuma i wydany po raz pierwszy w 1991 roku. Python oferuje system dynamicznego typu i automatyczne zarządzanie pamięcią oraz obsługuje wiele paradygmatów programowania, w tym obiektowe, imperatywne, programowanie funkcjonalne i style proceduralne. Ma dużą i kompleksową standardową bibliotekę.

Aktualnie używane są dwie główne wersje Pythona:

  • Python 3.x jest aktualną wersją i jest w fazie rozwoju.
  • Python 2.x jest starszą wersją i będzie otrzymywać tylko aktualizacje bezpieczeństwa do 2020 r. Nie zostaną wprowadzone żadne nowe funkcje. Zauważ, że wiele projektów nadal korzysta z Python 2, chociaż migracja do Python 3 jest coraz łatwiejsza.

Możesz pobrać i zainstalować dowolną wersję Pythona tutaj . Zobacz porównanie między Python 3 a Python 2 . Ponadto niektóre firmy zewnętrzne oferują przepakowane wersje Pythona, które dodają często używane biblioteki i inne funkcje ułatwiające konfigurację do typowych przypadków użycia, takich jak matematyka, analiza danych lub zastosowania naukowe. Zobacz listę na oficjalnej stronie .

Sprawdź, czy Python jest zainstalowany

Aby potwierdzić, że Python został poprawnie zainstalowany, możesz to sprawdzić, uruchamiając następujące polecenie w swoim ulubionym terminalu (jeśli używasz systemu operacyjnego Windows, musisz dodać ścieżkę Pythona do zmiennej środowiskowej przed użyciem go w wierszu polecenia):

$ python --version
 
Python 3.x 3.0

Jeśli masz zainstalowany Python 3 i jest to Twoja domyślna wersja (więcej informacji na temat rozwiązywania problemów ), powinieneś zobaczyć coś takiego:

$ python --version
Python 3.6.0
 
Python 2.x 2.7

Jeśli masz zainstalowany Python 2 i jest to Twoja domyślna wersja (więcej informacji na temat rozwiązywania problemów ), powinieneś zobaczyć coś takiego:

$ python --version
Python 2.7.13
 

Jeśli zainstalowałeś Python 3, ale $ python --version wyświetla wersję Python 2, masz również zainstalowany Python 2. Często dzieje się tak w MacOS i wielu dystrybucjach Linuksa. $ python3 tego użyj $ python3 aby jawnie użyć interpretera Python 3.

Witaj, World in Python przy użyciu IDLE


IDLE to prosty edytor dla Pythona, dostarczany w pakiecie z Pythonem.

Jak stworzyć program Hello, World w IDLE

  • Otwórz IDLE w wybranym systemie.
    • W starszych wersjach systemu Windows można go znaleźć w All Programs w menu Windows.
    • W Windows 8+ wyszukaj IDLE lub znajdź go w aplikacjach obecnych w twoim systemie.
    • W systemach uniksowych (w tym Mac) możesz otworzyć go z powłoki, wpisując $ idle python_file.py .
  • Otworzy się powłoka z opcjami u góry.

W powłoce pojawia się monit o trzy nawiasy prostokątne:

>>>
 

Teraz napisz następujący kod w wierszu:

>>> print("Hello, World")
 

Naciśnij Enter .

>>> print("Hello, World")
Hello, World
 

Plik Hello World Python

Utwórz nowy plik hello.py który zawiera następujący wiersz:

Python 3.x 3.0
print('Hello, World')
 
Python 2.x 2.6

Możesz użyć funkcji print Python 3 w Python 2 z następującą instrukcją import :

from __future__ import print_function
 

Python 2 ma wiele funkcji, które można opcjonalnie zaimportować z Pythona 3 za pomocą modułu __future__ , jak omówiono tutaj .

Python 2.x 2.7

Jeśli używasz Python 2, możesz także wpisać poniższy wiersz. Zauważ, że nie jest to poprawne w Pythonie 3 i dlatego nie jest zalecane, ponieważ zmniejsza zgodność kodu między wersjami.

print 'Hello, World'
 

W swoim terminalu przejdź do katalogu zawierającego plik hello.py .

Wpisz python hello.py , a następnie naciśnij klawisz Enter .

$ python hello.py
Hello, World
 

Powinieneś zobaczyć Hello, World wydrukowany na konsoli.

Możesz także zastąpić hello.py ścieżką do pliku. Na przykład, jeśli plik znajduje się w katalogu domowym, a użytkownik jest „użytkownikiem” w systemie Linux, możesz wpisać python /home/user/hello.py .

Uruchom interaktywną powłokę Pythona

Wykonując (uruchamiając) komendę python w swoim terminalu, otrzymujesz interaktywną powłokę Pythona. Jest to również znane jako interpreter języka Python lub REPL (w przypadku „Read Evaluate Print Loop”).

$ python
Python 2.7.12 (default, Jun 28 2016, 08:46:01) 
[GCC 6.1.1 20160602] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> print 'Hello, World'
Hello, World
>>>
 

Jeśli chcesz uruchomić Python 3 z terminala, uruchom polecenie python3 .

$ python3
Python 3.6.0 (default, Jan 13 2017, 00:00:00) 
[GCC 6.1.1 20160602] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> print('Hello, World')
Hello, World
>>>
 

Alternatywnie uruchom interaktywny monit i załaduj plik za pomocą python -i <file.py> .

W wierszu polecenia uruchom:

$ python -i hello.py
"Hello World"
>>>
 

Istnieje wiele sposobów zamknięcia powłoki Python:

>>> exit()
 

lub

>>> quit()
 

Alternatywnie, CTRL + D zamknie powłokę i przeniesie cię z powrotem do linii poleceń twojego terminala.

Jeśli chcesz anulować polecenie, jesteś w trakcie pisania i powrócić do czystego wiersza polecenia, pozostając w powłoce interpretera, użyj CTRL + C.

Wypróbuj interaktywną powłokę Python online .

Inne powłoki online

Różne strony internetowe zapewniają dostęp online do powłok Pythona.

Powłoki online mogą być przydatne do następujących celów:

  • Uruchom mały fragment kodu z komputera, na którym nie ma instalacji Pythona (smartfony, tablety itp.).
  • Naucz się lub naucz podstawowego języka Python.
  • Rozwiązywanie problemów z oceną online.

Przykłady:

Oświadczenie: autor (autorzy) dokumentacji nie są powiązani z żadnymi zasobami wymienionymi poniżej.

Uruchamiaj polecenia jako ciąg

Pythonowi można przekazać dowolny kod jako ciąg znaków w powłoce:

$ python -c 'print("Hello, World")'
Hello, World
 

Może to być przydatne podczas łączenia wyników skryptów w powłoce.

Muszle i nie tylko

Zarządzanie pakietami - Zalecanym narzędziem PyPA do instalowania pakietów Python jest PIP . Aby zainstalować, w wierszu polecenia uruchom pip install <the package name> . Na przykład pip install numpy . (Uwaga: W python -m pip install <the package name> Windows musisz dodać pip do zmiennych środowiskowych PATH. Aby tego uniknąć, użyj python -m pip install <the package name> )

Powłoki - do tej pory omawialiśmy różne sposoby uruchamiania kodu przy użyciu natywnej interaktywnej powłoki Pythona. Powłoki używają mocy interpretacyjnej Pythona do eksperymentowania z kodem w czasie rzeczywistym. Alternatywne powłoki to IDLE - wstępnie dołączony GUI, IPython - znany z rozszerzania interaktywnego doświadczenia itp.

Programy - w celu przechowywania długoterminowego możesz zapisywać zawartość w plikach .py i edytować / wykonywać je jako skrypty lub programy za pomocą zewnętrznych narzędzi, np. Powłoki, IDE (takich jak PyCharm ), notatników Jupyter itp. Użytkownicy pośredni mogą korzystać z tych narzędzi; jednak metody omówione tutaj są wystarczające, aby zacząć.

Korepetytor w Pythonie pozwala ci przechodzić przez kod Pythona, dzięki czemu możesz wizualizować przebieg programu i pomaga zrozumieć, gdzie popełnił błąd.

PEP8 definiuje wytyczne dotyczące formatowania kodu Pythona. Dobre formatowanie kodu jest ważne, abyś mógł szybko przeczytać, co robi kod.

Blokuj wcięcia

Python używa wcięć do definiowania konstrukcji sterowania i pętli. Wpływa to na czytelność Pythona, wymaga jednak od programisty zwrócenia szczególnej uwagi na użycie białych znaków. W związku z tym błędna kalibracja edytora może spowodować, że kod zachowa się w nieoczekiwany sposób.

Python używa symbolu okrężnicy ( : ) i wcięcia za pokazanie gdzie bloki kodu rozpoczęcia i zakończenia (Jeśli pochodzą z innego języka, nie należy mylić tego z czym w jakiś sposób związany z operatorem potrójnego ). Oznacza to, że bloki w Pythonie, takie jak funkcje, pętle, if klauzulami i innymi konstrukcjami, nie mają końcowych identyfikatorów. Wszystkie bloki zaczynają się od dwukropka, a następnie zawierają pod nim wcięte linie.

Na przykład:

def my_function():    # This is a function definition. Note the colon (:)
    a = 2             # This line belongs to the function because it's indented
    return a          # This line also belongs to the same function
print(my_function())  # This line is OUTSIDE the function block
 

lub

if a > b:             # If block starts here
    print(a)          # This is part of the if block
else:                 # else must be at the same level as if
    print(b)          # This line is part of the else block
 

Bloki zawierające dokładnie jedną instrukcję jednowierszową można umieścić w tym samym wierszu, chociaż ta forma nie jest ogólnie uważana za dobry styl:

if a > b: print(a)
else: print(b)  
 

Próba zrobienia tego z więcej niż jedną instrukcją nie zadziała:

if x > y: y = x
    print(y) # IndentationError: unexpected indent

if x > y: while y != z: y -= 1  # SyntaxError: invalid syntax
 

Pusty blok powoduje błąd IndentationError . Użyj pass (polecenie, które nic nie robi), gdy masz blok bez zawartości:

def will_be_implemented_later():
    pass
 

Spacje vs. Tabulatory

W skrócie: zawsze używaj 4 spacji do wcięcia.

Używanie wyłącznie tabulatorów jest możliwe, ale PEP 8 , przewodnik po stylu dla kodu Python, stwierdza, że spacje są preferowane.

Python 3.x 3.0

Python 3 nie zezwala na łączenie użycia tabulatorów i spacji do wcięć. W takim przypadku generowany jest błąd czasu kompilacji: Inconsistent use of tabs and spaces in indentation a program nie uruchomi się.

Python 2.x 2.7

Python 2 umożliwia mieszanie tabulatorów i spacji w wcięciach; jest to zdecydowanie odradzane. Znak tabulacji uzupełnia poprzednie wcięcie i jest wielokrotnością 8 spacji . Ponieważ często zdarza się, że edytory są skonfigurowane do wyświetlania tabulatorów jako wielokrotności 4 spacji, może to powodować subtelne błędy.

Powołując się na PEP 8 :

Podczas wywoływania interpretera wiersza poleceń Python 2 z opcją -t wydaje ostrzeżenia o kodzie, który nielegalnie łączy tabulatory i spacje. Podczas używania -tt te ostrzeżenia stają się błędami. Te opcje są wysoce zalecane!

Wielu redaktorów ma konfigurację „tabulatory do spacji”. Podczas konfigurowania edytora należy rozróżniać znak tabulacji („\ t”) i klawisz Tab .

  • Postać zakładka powinna być skonfigurowana, aby pokazać 8 spacji, aby dopasować semantykę języka - przynajmniej w przypadkach, kiedy (przypadkowa) mieszane wcięcia jest możliwe. Redaktorzy mogą także automatycznie konwertować znaki tabulacji na spacje.
  • Pomocne może być jednak skonfigurowanie edytora, tak aby naciśnięcie klawisza Tab wstawiło 4 spacje zamiast znaku tabulacji.

Kod źródłowy Pythona napisany z użyciem kombinacji tabulatorów i spacji lub niestandardowej liczby spacji może być zgodny z pep8 przy użyciu autopep8 . (Mniej wydajna alternatywa pochodzi z większością instalacji Pythona: reindent.py )

Wbudowane moduły i funkcje

Moduł to plik zawierający definicje i instrukcje w języku Python. Funkcja jest fragmentem kodu, który wykonuje pewną logikę.

>>> pow(2,3)    #8
 

Aby sprawdzić wbudowaną funkcję w pythonie, możemy użyć dir(). Jeśli zostanie wywołany bez argumentu, zwróci nazwy w bieżącym zakresie. W przeciwnym razie zwróć alfabetyczną listę nazw zawierających (niektóre) atrybut danego obiektu i atrybuty, które można z niego uzyskać.

>>> dir(__builtins__)
[
    'ArithmeticError', 
    'AssertionError', 
    'AttributeError', 
    'BaseException', 
    'BufferError', 
    'BytesWarning', 
    'DeprecationWarning', 
    'EOFError', 
    'Ellipsis', 
    'EnvironmentError', 
    'Exception', 
    'False', 
    'FloatingPointError', 
    'FutureWarning', 
    'GeneratorExit', 
    'IOError', 
    'ImportError', 
    'ImportWarning', 
    'IndentationError', 
    'IndexError', 
    'KeyError', 
    'KeyboardInterrupt', 
    'LookupError', 
    'MemoryError', 
    'NameError', 
    'None', 
    'NotImplemented', 
    'NotImplementedError', 
    'OSError', 
    'OverflowError', 
    'PendingDeprecationWarning', 
    'ReferenceError', 
    'RuntimeError', 
    'RuntimeWarning', 
    'StandardError', 
    'StopIteration', 
    'SyntaxError', 
    'SyntaxWarning', 
    'SystemError', 
    'SystemExit', 
    'TabError', 
    'True', 
    'TypeError', 
    'UnboundLocalError', 
    'UnicodeDecodeError', 
    'UnicodeEncodeError', 
    'UnicodeError', 
    'UnicodeTranslateError', 
    'UnicodeWarning', 
    'UserWarning', 
    'ValueError', 
    'Warning', 
    'ZeroDivisionError', 
    '__debug__', 
    '__doc__', 
    '__import__', 
    '__name__', 
    '__package__', 
    'abs', 
    'all', 
    'any', 
    'apply', 
    'basestring', 
    'bin', 
    'bool', 
    'buffer', 
    'bytearray', 
    'bytes', 
    'callable', 
    'chr', 
    'classmethod', 
    'cmp', 
    'coerce', 
    'compile', 
    'complex', 
    'copyright', 
    'credits', 
    'delattr', 
    'dict', 
    'dir', 
    'divmod', 
    'enumerate', 
    'eval', 
    'execfile', 
    'exit', 
    'file', 
    'filter', 
    'float', 
    'format', 
    'frozenset', 
    'getattr', 
    'globals', 
    'hasattr', 
    'hash', 
    'help', 
    'hex', 
    'id', 
    'input', 
    'int', 
    'intern', 
    'isinstance', 
    'issubclass', 
    'iter', 
    'len', 
    'license', 
    'list', 
    'locals', 
    'long', 
    'map', 
    'max', 
    'memoryview', 
    'min', 
    'next', 
    'object', 
    'oct', 
    'open', 
    'ord', 
    'pow', 
    'print', 
    'property', 
    'quit', 
    'range', 
    'raw_input', 
    'reduce', 
    'reload', 
    'repr', 
    'reversed', 
    'round', 
    'set', 
    'setattr', 
    'slice', 
    'sorted', 
    'staticmethod', 
    'str', 
    'sum', 
    'super', 
    'tuple', 
    'type', 
    'unichr', 
    'unicode', 
    'vars', 
    'xrange', 
    'zip'
]
 

Aby poznać funkcjonalność dowolnej funkcji, możemy skorzystać z wbudowanej help funkcji.

>>> help(max)
Help on built-in function max in module __builtin__:
max(...)
    max(iterable[, key=func]) -> value
    max(a, b, c, ...[, key=func]) -> value
    With a single iterable argument, return its largest item.
    With two or more arguments, return the largest argument.
 

Wbudowane moduły zawierają dodatkowe funkcje. Na przykład, aby uzyskać pierwiastek kwadratowy z liczby, musimy dołączyć moduł math .

>>> import math
>>> math.sqrt(16) # 4.0
 

Aby poznać wszystkie funkcje w module, możemy przypisać listę funkcji do zmiennej, a następnie wydrukować zmienną.

>>> import math
>>> dir(math)

   ['__doc__', '__name__', '__package__', 'acos', 'acosh', 
   'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 
   'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 
   'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 
   'hypot', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 
   'log1p', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 
   'tan', 'tanh', 'trunc']
 

wydaje się, że __doc__ jest użyteczny do dostarczenia dokumentacji, powiedzmy, funkcji

>>> math.__doc__
'This module is always available.  It provides access to the\nmathematical
 functions defined by the C standard.'
 

Oprócz funkcji dokumentację można również dostarczyć w modułach. Więc jeśli masz plik o nazwie helloWorld.py taki jak ten:

"""This is the module docstring."""

def sayHello():
    """This is the function docstring."""
    return 'Hello World'
 

Możesz uzyskać dostęp do jego dokumentów w ten sposób:

>>> import helloWorld
>>> helloWorld.__doc__
'This is the module docstring.'
>>> helloWorld.sayHello.__doc__
'This is the function docstring.'
 
  • Dla każdego typu zdefiniowanego przez użytkownika jego atrybuty, atrybuty jego klasy i rekurencyjnie atrybuty klas podstawowych jego klasy można pobrać za pomocą dir ()
>>> class MyClassObject(object):
...     pass
... 
>>> dir(MyClassObject)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__']
 

Dowolny typ danych można po prostu przekonwertować na ciąg znaków za pomocą wbudowanej funkcji o nazwie str . Ta funkcja jest wywoływana domyślnie, gdy typ danych jest przekazywany do print

>>> str(123)    # "123"
 

Rodzaje kolekcji

W Pythonie istnieje wiele typów kolekcji. Podczas gdy typy takie jak int i str zawierają jedną wartość, typy kolekcji zawierają wiele wartości.

Listy

Typ list jest prawdopodobnie najczęściej używanym typem kolekcji w Pythonie. Pomimo nazwy lista jest bardziej podobna do tablicy w innych językach, głównie JavaScript. W Pythonie lista jest jedynie uporządkowanym zbiorem prawidłowych wartości w Pythonie. Listę można utworzyć, umieszczając wartości, oddzielone przecinkami, w nawiasach kwadratowych:

int_list = [1, 2, 3]
string_list = ['abc', 'defghi']
 

Lista może być pusta:

empty_list = []
 

Elementy listy nie są ograniczone do jednego typu danych, co ma sens, biorąc pod uwagę, że Python jest językiem dynamicznym:

mixed_list = [1, 'abc', True, 2.34, None]
 

Lista może zawierać inną listę jako swój element:

nested_list = [['a', 'b', 'c'], [1, 2, 3]]
 

Do elementów listy można uzyskać dostęp za pomocą indeksu lub numerycznej reprezentacji ich pozycji. Listy w Pythonie są indeksowane zerowo, co oznacza, że pierwszy element na liście ma indeks 0, drugi element ma indeks 1 i tak dalej:

names = ['Alice', 'Bob', 'Craig', 'Diana', 'Eric']
print(names[0]) # Alice
print(names[2]) # Craig
 

Wskaźniki mogą być również ujemne, co oznacza zliczanie od końca listy ( -1 oznacza indeks ostatniego elementu). Korzystając z listy z powyższego przykładu:

print(names[-1]) # Eric
print(names[-4]) # Bob
 

Listy są zmienne, więc możesz zmienić wartości na liście:

names[0] = 'Ann'
print(names)
# Outputs ['Ann', 'Bob', 'Craig', 'Diana', 'Eric']
 

Poza tym możliwe jest dodawanie i / lub usuwanie elementów z listy:

Dołącz obiekt na końcu listy za pomocą L.append(object) , zwraca None .

names = ['Alice', 'Bob', 'Craig', 'Diana', 'Eric']
names.append("Sia")
print(names) 
# Outputs ['Alice', 'Bob', 'Craig', 'Diana', 'Eric', 'Sia']
 

Dodaj nowy element do listy pod określonym indeksem. L.insert(index, object)

names.insert(1, "Nikki")
print(names)
# Outputs ['Alice', 'Nikki', 'Bob', 'Craig', 'Diana', 'Eric', 'Sia']
 

Usuń pierwsze wystąpienie wartości za pomocą L.remove(value) , zwraca None

names.remove("Bob")
print(names) # Outputs ['Alice', 'Nikki', 'Craig', 'Diana', 'Eric', 'Sia']
 

Pobierz indeks z listy pierwszego elementu, którego wartość wynosi x. Wyświetli błąd, jeśli nie ma takiego elementu.

name.index("Alice")
0
 

Policz długość listy

len(names)
6
 

policz wystąpienie dowolnego elementu na liście

a = [1, 1, 1, 2, 3, 4]
a.count(1)
3
 

Odwróć listę

a.reverse()
[4, 3, 2, 1, 1, 1]
# or
a[::-1]
[4, 3, 2, 1, 1, 1]
 

Usuń i zwróć element o indeksie (domyślnie ostatni element) za pomocą L.pop([index]) , zwraca element

names.pop() # Outputs 'Sia'
 

Możesz iterować elementy listy, takie jak poniżej:

for element in my_list:
    print (element)
 

Krotki

tuple jest podobna do listy, z tą różnicą, że ma stałą długość i jest niezmienna. Tak więc wartości w krotce nie można zmienić ani dodać ani usunąć wartości z krotki. Krotki są powszechnie używane do małych kolekcji wartości, których nie trzeba zmieniać, takich jak adres IP i port. Krotki są reprezentowane nawiasami zamiast nawiasów kwadratowych:

ip_address = ('10.20.30.40', 8080)
 

Te same reguły indeksowania list mają również zastosowanie do krotek. Krotki mogą być również zagnieżdżone, a wartości mogą być dowolnymi poprawnymi Pythonami.

Krotka z tylko jednym elementem musi być zdefiniowana w następujący sposób:

one_member_tuple = ('Only member',)
 

lub

one_member_tuple = 'Only member',   # No brackets
 

lub po prostu używając składni tuple

one_member_tuple = tuple(['Only member'])
 

Słowniki

dictionary w Pythonie to zbiór par klucz-wartość. Słownik jest otoczony nawiasami klamrowymi. Każda para jest oddzielona przecinkiem, a klucz i wartość są oddzielone dwukropkiem. Oto przykład:

state_capitals = {
    'Arkansas': 'Little Rock',
    'Colorado': 'Denver',
    'California': 'Sacramento', 
    'Georgia': 'Atlanta'
}
 

Aby uzyskać wartość, odwołaj się do niej po jej kluczu:

ca_capital = state_capitals['California']
 

Możesz również pobrać wszystkie klucze ze słownika, a następnie iterować nad nimi:

for k in state_capitals.keys():
    print('{} is the capital of {}'.format(state_capitals[k], k))
 

Słowniki bardzo przypominają składnię JSON. json modułu json w standardowej bibliotece Pythona można używać do konwersji między JSON a słownikami.

zestaw

set to zbiór elementów bez powtórzeń i bez kolejności wstawiania, ale uporządkowanej. Są używane w sytuacjach, w których ważne jest tylko, że niektóre rzeczy są zgrupowane razem, a nie w jakiej kolejności zostały uwzględnione. W przypadku dużych grup danych znacznie szybciej jest sprawdzić, czy element jest w set niż zrobić to samo dla list .

Definiowanie set jest bardzo podobne do definiowania dictionary :

first_names = {'Adam', 'Beth', 'Charlie'}
 

Lub możesz zbudować set korzystając z istniejącej list :

my_list = [1,2,3]
my_set = set(my_list)
 

Sprawdzić przynależność do set , używając in :

if name in first_names:
    print(name)
 

Możesz iterować set dokładnie tak jak listę, ale pamiętaj: wartości będą w dowolnej kolejności zdefiniowanej w implementacji.

defaultdict

defaultdict to słownik z domyślną wartością dla kluczy, dzięki czemu dostęp do kluczy, dla których nie zdefiniowano żadnej wartości, można uzyskać bez błędów. defaultdict jest szczególnie użyteczny, gdy wartości w słowniku są kolekcjami (listami, nagraniami itp.) w tym sensie, że nie trzeba go inicjować za każdym razem, gdy używany jest nowy klucz.

defaultdict nigdy nie zgłosi KeyError. Każdy nieistniejący klucz otrzymuje wartość domyślną.

Weźmy na przykład następujący słownik

>>> state_capitals = {
    'Arkansas': 'Little Rock',
    'Colorado': 'Denver',
    'California': 'Sacramento', 
    'Georgia': 'Atlanta'
}
 

Jeśli próbujemy uzyskać dostęp do nieistniejącego klucza, python zwraca nam następujący błąd

>>> state_capitals['Alabama']
Traceback (most recent call last):

  File "<ipython-input-61-236329695e6f>", line 1, in <module>
    state_capitals['Alabama']

KeyError: 'Alabama'
 

Spróbujmy z defaultdict . Można go znaleźć w module kolekcji.

>>> from collections import defaultdict
>>> state_capitals = defaultdict(lambda: 'Boston')
 

To, co zrobiliśmy tutaj, to ustawienie wartości domyślnej ( Boston ) na wypadek, gdyby klucz dawania nie istniał. Teraz wypełnij dykt tak jak poprzednio:

>>> state_capitals['Arkansas'] = 'Little Rock'
>>> state_capitals['California'] = 'Sacramento'
>>> state_capitals['Colorado'] = 'Denver'
>>> state_capitals['Georgia'] = 'Atlanta'
 

Jeśli spróbujemy uzyskać dostęp do dykta za pomocą nieistniejącego klucza, Python zwróci nam wartość domyślną, tj. Boston

>>> state_capitals['Alabama']
'Boston'
 

i zwraca utworzone wartości dla istniejącego klucza, tak jak normalny dictionary

>>> state_capitals['Arkansas']
'Little Rock'
 

Tworzenie modułu

Moduł to plik do importu zawierający definicje i instrukcje.

Moduł można utworzyć, tworząc plik .py .

# hello.py
def say_hello():
    print("Hello!")
 

Funkcje w module można wykorzystać, importując moduł.

W przypadku modułów, które utworzyłeś, muszą one znajdować się w tym samym katalogu, co plik, do którego je importujesz. (Można jednak również umieścić je w katalogu lib Pythona za pomocą wstępnie dołączonych modułów, ale należy tego unikać, jeśli to możliwe).

$ python
>>> import hello
>>> hello.say_hello()
=> "Hello!"
 

Moduły mogą być importowane przez inne moduły.

# greet.py
import hello
hello.say_hello()
 

Konkretne funkcje modułu można importować.

# greet.py
from hello import say_hello
say_hello()
 

Moduły można aliasować.

# greet.py
import hello as ai
ai.say_hello()
 

Moduł może być samodzielnym skryptem uruchamialnym.

# run_hello.py
if __name__ == '__main__':
    from hello import say_hello
    say_hello()
 

Uruchom!

$ python run_hello.py
=> "Hello!"
 

Jeśli moduł znajduje się w katalogu i musi zostać wykryty przez python, katalog powinien zawierać plik o nazwie __init__.py .

Tworzenie zmiennych i przypisywanie wartości

Aby utworzyć zmienną w Pythonie, wystarczy podać nazwę zmiennej, a następnie przypisać jej wartość.

<variable name> = <value>
 

Python używa = do przypisywania wartości do zmiennych. Nie ma potrzeby wcześniejszego deklarowania zmiennej (ani przypisywania jej typu danych), przypisywanie wartości samej zmiennej deklaruje i inicjuje zmienną tą wartością. Nie ma możliwości zadeklarowania zmiennej bez przypisania jej wartości początkowej.

# Integer
a = 2
print(a)
# Output: 2

# Integer    
b = 9223372036854775807
print(b)
# Output: 9223372036854775807

# Floating point
pi = 3.14
print(pi)
# Output: 3.14

# String
c = 'A'
print(c)
# Output: A

# String    
name = 'John Doe'
print(name)
# Output: John Doe

# Boolean    
q = True
print(q)
# Output: True

# Empty value or null data type
x = None
print(x)
# Output: None
 

Zmienne przypisanie działa od lewej do prawej. Zatem poniższe polecenie spowoduje błąd składniowy.

0 = x
=> Output: SyntaxError: can't assign to literal
 

Nie można używać słów kluczowych Pythona jako prawidłowej nazwy zmiennej. Możesz zobaczyć listę słów kluczowych według:

import keyword
print(keyword.kwlist)
 

Zasady nazywania zmiennych:

  1. Nazwy zmiennych muszą zaczynać się od litery lub znaku podkreślenia.
 x  = True   # valid
 _y = True   # valid

 9x = False  # starts with numeral 
 => SyntaxError: invalid syntax   

 $y = False #  starts with symbol 
 => SyntaxError: invalid syntax
 
  1. Pozostała część nazwy zmiennej może składać się z liter, cyfr i znaków podkreślenia.
has_0_in_it = "Still Valid" 
 
  1. W nazwach rozróżniana jest wielkość liter.
x = 9  
y = X*5   
=>NameError: name 'X' is not defined
 

Chociaż nie ma potrzeby określania typu danych podczas deklarowania zmiennej w Pythonie, przy przydzielaniu niezbędnego obszaru w pamięci dla zmiennej, interpreter Pythona automatycznie wybiera najbardziej odpowiedni wbudowany typ dla niej:

a = 2
print(type(a))
# Output: <type 'int'>

b = 9223372036854775807
print(type(b))
# Output: <type 'int'>

pi = 3.14
print(type(pi))
# Output: <type 'float'>

c = 'A'
print(type(c))
# Output: <type 'str'>

name = 'John Doe'
print(type(name))
# Output: <type 'str'>

q = True
print(type(q))
# Output: <type 'bool'>

x = None
print(type(x))
# Output: <type 'NoneType'>
 

Teraz, gdy znasz podstawy przypisywania, usuńmy tę subtelność dotyczącą przypisywania w pythonie.

Kiedy używasz = aby wykonać operację przypisania, to po lewej stronie = jest nazwa obiektu po prawej stronie. Wreszcie, co = robi, przypisuje odwołanie do obiektu po prawej stronie do nazwy po lewej stronie.

To jest:

a_name = an_object  # "a_name" is now a name for the reference to the object "an_object"
 

Tak więc, od wielu przykładów przypisania powyżej, jeżeli możemy odebrać pi = 3.14 , następnie pi jest nazwą (nie nazwę, ponieważ obiekt może mieć wiele nazw) dla obiektu 3.14 . Jeśli nie rozumiesz czegoś poniżej, wróć do tego punktu i przeczytaj to jeszcze raz! Możesz także przyjrzeć się temu, aby lepiej zrozumieć.


Możesz przypisać wiele wartości do wielu zmiennych w jednym wierszu. Zauważ, że po prawej i lewej stronie operatora = musi znajdować się taka sama liczba argumentów:

a, b, c = 1, 2, 3
print(a, b, c)
# Output: 1 2 3

a, b, c = 1, 2
=> Traceback (most recent call last):
=>   File "name.py", line N, in <module>
=>     a, b, c = 1, 2
=> ValueError: need more than 2 values to unpack

a, b = 1, 2, 3
=> Traceback (most recent call last):
=>   File "name.py", line N, in <module>
=>     a, b = 1, 2, 3
=> ValueError: too many values to unpack
 

Błąd w ostatnim przykładzie można usunąć, przypisując pozostałe wartości do równej liczby dowolnych zmiennych. Ta zmienna fikcyjna może mieć dowolną nazwę, ale konwencjonalne jest używanie podkreślnika ( _ ) do przypisywania niepożądanych wartości:

a, b, _ = 1, 2, 3
print(a, b)
# Output: 1, 2
 

Zauważ, że liczba _ i liczba pozostałych wartości muszą być równe. W przeciwnym razie wyrzucane jest „zbyt wiele wartości, aby rozpakować błąd”, jak wyżej:

a, b, _ = 1,2,3,4
=>Traceback (most recent call last):
=>File "name.py", line N, in <module>
=>a, b, _ = 1,2,3,4
=>ValueError: too many values to unpack (expected 3)
 

Możesz także przypisać jedną wartość do kilku zmiennych jednocześnie.

a = b = c = 1
print(a, b, c)
# Output: 1 1 1
 

Przy stosowaniu takiego przypisania kaskadowego należy zauważyć, że wszystkie trzy zmienne a , b i c odnoszą się do tego samego obiektu w pamięci, obiektu int o wartości 1. Innymi słowy, a , b i c to trzy różne nazwy podany do tego samego obiektu int. Przypisanie innego obiektu do jednego z nich później nie zmienia innych, zgodnie z oczekiwaniami:

a = b = c = 1    # all three names a, b and c refer to same int object with value 1
print(a, b, c)
# Output: 1 1 1
b = 2            # b now refers to another int object, one with a value of 2
print(a, b, c)
# Output: 1 2 1  # so output is as expected.
 

Powyższe dotyczy również typów zmiennych (takich jak list , dict itp.), Podobnie jak typy niezmienne (takie jak int , string , tuple itp.):

x = y = [7, 8, 9]   # x and y refer to the same list object just created, [7, 8, 9]
x = [13, 8, 9]      # x now refers to a different list object just created, [13, 8, 9]
print(y)            # y still refers to the list it was first assigned
# Output: [7, 8, 9]
 

Jak na razie dobrze. Sytuacja wygląda nieco inaczej, jeśli chodzi o modyfikację obiektu (w przeciwieństwie do przypisywania nazwy innemu obiektowi, co zrobiliśmy powyżej), gdy przypisanie kaskadowe jest używane dla typów zmiennych. Spójrz poniżej, a zobaczysz to z pierwszej ręki:

x = y = [7, 8, 9]     # x and y are two different names for the same list object just created, [7, 8, 9]
x[0] = 13             # we are updating the value of the list [7, 8, 9] through one of its names, x in this case
print(y)              # printing the value of the list using its other name
# Output: [13, 8, 9]  # hence, naturally the change is reflected
 

Listy zagnieżdżone są również poprawne w Pythonie. Oznacza to, że lista może zawierać inną listę jako element.

x = [1, 2, [3, 4, 5], 6, 7] # this is nested list
print x[2]
# Output: [3, 4, 5]
print x[2][1]
# Output: 4
 

Wreszcie, zmienne w Pythonie nie muszą pozostać tego samego typu, co zostały zdefiniowane po raz pierwszy - możesz po prostu użyć = aby przypisać nową wartość do zmiennej, nawet jeśli ta wartość jest innego typu.

a = 2 
print(a)
# Output: 2

a = "New value"
print(a)
# Output: New value
 

Jeśli ci to przeszkadza, pomyśl o tym, że to, co jest po lewej stronie = to tylko nazwa obiektu. Najpierw wywołujesz obiekt int o wartości 2 a , następnie zmieniasz zdanie i decydujesz się na nadać nazwę a obiektowi string o wartości „Nowa wartość”. Proste, prawda?

Typy danych

Wbudowane typy

Booleany

bool : Wartość logiczna True lub False . Operacje logiczne, takie jak and , or , not można wykonywać na boolach.

x or y    # if x is False then y otherwise x 
x and y   # if x is False then x otherwise y
not x     # if x is True then False, otherwise True
 

W Python 2.xi Python 3.x wartość logiczna jest również liczbą int . Typ bool jest podklasą typu int a True i False to jedyne jego wystąpienia:

issubclass(bool, int) # True

isinstance(True, bool) # True
isinstance(False, bool) # True
 

Jeśli wartości logiczne są używane w operacjach arytmetycznych, ich wartości całkowite ( 1 i 0 dla True i False ) zostaną użyte do zwrócenia wyniku liczb całkowitych:

True + False == 1 # 1 + 0 == 1
True * True  == 1 # 1 * 1 == 1
 

Liczby

  • int : liczba całkowita

    a = 2
    b = 100
    c = 123456789
    d = 38563846326424324
     

    Liczby całkowite w Pythonie mają dowolne rozmiary.

    Uwaga: w starszych wersjach Pythona dostępny był long typ, który różnił się od int . Oba zostały zjednoczone.

  • float : liczba zmiennoprzecinkowa; precyzja zależy od implementacji i architektury systemu, dla CPython typ danych typu float odpowiada podwójnemu C.

    a = 2.0
    b = 100.e0
    c = 123456789.e1
     
  • complex : liczby zespolone

    a = 2 + 1j
    b = 100 + 10j
     

Operatory < , <= , > i >= TypeError wyjątek TypeError gdy dowolny argument jest liczbą zespoloną.

Smyczki

Python 3.x 3.0
  • str : ciąg znaków Unicode . Rodzaj 'hello'
  • bytes : ciąg bajtów . Rodzaj b'hello'
Python 2.x 2.7
  • str : ciąg bajtów . Rodzaj 'hello'
  • bytes : synonim str
  • unicode : ciąg znaków Unicode . Rodzaj u'hello'

Sekwencje i kolekcje

Python rozróżnia uporządkowane sekwencje i nieuporządkowane kolekcje (takie jak set i dict ).

  • ciągi ( str , bytes , unicode ) są sekwencjami

  • reversed : odwrócona kolejność str z funkcją reversed

    a = reversed('hello')
     
  • tuple : Uporządkowany zbiór n wartości dowolnego typu ( n >= 0 ).

    a = (1, 2, 3)
    b = ('a', 1, 'python', (1, 2))
    b[2] = 'something else' # returns a TypeError
     

    Obsługuje indeksowanie; niezmienny; hashable, jeśli wszyscy jego członkowie są haszowalni

  • list : Uporządkowana kolekcja n wartości ( n >= 0 )

    a = [1, 2, 3]
    b = ['a', 1, 'python', (1, 2), [1, 2]]
    b[2] = 'something else' # allowed
     

    Nie do skrócenia; zmienny.

  • set : nieuporządkowany zbiór unikalnych wartości. Przedmioty muszą być haszowalne .

    a = {1, 2, 'a'}
     
  • dict : nieuporządkowany zbiór unikalnych par klucz-wartość; klucze muszą być haszowalne .

    a = {1: 'one',
         2: 'two'}
    
    b = {'a': [1, 2, 3],
         'b': 'a string'}
     

Obiekt jest haszowalny, jeśli ma wartość skrótu, która nigdy się nie zmienia w trakcie jego życia (potrzebuje __hash__() ), i można go porównać do innych obiektów (potrzebuje __eq__() ). Obiekty haszujące, które porównują równość, muszą mieć tę samą wartość skrótu.

Wbudowane stałe

W połączeniu z wbudowanymi typami danych istnieje niewielka liczba wbudowanych stałych we wbudowanej przestrzeni nazw:

  • True : prawdziwa wartość wbudowanego typu bool
  • False : Fałszywa wartość wbudowanego typu bool
  • None : obiekt typu singleton używany do sygnalizowania braku wartości.
  • Ellipsis lub ... : używane w rdzeniu Python3 + w dowolnym miejscu i ograniczone użycie w Python2.7 + jako część notacji tablicowej. numpy i powiązane pakiety używają tego jako odwołania do tablic.
  • NotImplemented : singleton używany do wskazania Pythonowi, że specjalna metoda nie obsługuje określonych argumentów, a Python spróbuje alternatyw, jeśli są dostępne.
a = None # No value will be assigned. Any valid datatype can be assigned later
 
Python 3.x 3.0

None nie ma naturalnego porządku. Korzystanie z operatorów porównania zamówień ( < , <= , >= , > ) nie jest już obsługiwane i spowoduje wystąpienie TypeError .

Python 2.x 2.7

None jest zawsze mniejsza niż dowolna liczba ( None < -32 wartość True ).

Testowanie typu zmiennych

W pythonie możemy sprawdzić typ danych obiektu, używając wbudowanego type funkcji.

a = '123'
print(type(a))
# Out: <class 'str'>
b = 123
print(type(b))
# Out: <class 'int'>
 

W instrukcjach warunkowych można przetestować typ danych za pomocą isinstance . Jednak zwykle nie zaleca się polegania na typie zmiennej.

i = 7
if isinstance(i, int):
    i += 1
elif isinstance(i, str):
    i = int(i)
    i += 1
 

Aby uzyskać informacje na temat różnic między type() a isinstance() przeczytaj: Różnice między isinstance a typem w Pythonie

Aby sprawdzić, czy coś jest typu NoneType :

x = None
if x is None:
    print('Not a surprise, I just defined x as None.')
 

Konwersja między typami danych

Możesz wykonać jawną konwersję typu danych.

Na przykład „123” jest typu str i można go przekonwertować na liczbę całkowitą za pomocą funkcji int .

a = '123'
b = int(a)
 

Konwersję z ciągu zmiennoprzecinkowego, takiego jak „123.456”, można wykonać za pomocą funkcji float .

a = '123.456'
b = float(a)
c = int(a)    # ValueError: invalid literal for int() with base 10: '123.456'
d = int(b)    # 123
 

Możesz także konwertować typy sekwencji lub kolekcji

a = 'hello'
list(a)  # ['h', 'e', 'l', 'l', 'o']
set(a)   # {'o', 'e', 'l', 'h'}
tuple(a) # ('h', 'e', 'l', 'l', 'o')
 

Jawny typ ciągu przy definicji literałów

Za pomocą etykiet z jedną literą przed cudzysłowami możesz określić, jaki typ ciągu chcesz zdefiniować.

  • b'foo bar' : wyniki bytes w Python 3, str w Python 2
  • u'foo bar' : wyniki str w Pythonie 3, unicode w Pythonie 2
  • 'foo bar' : str wyników
  • r'foo bar' : powoduje powstanie tak zwanego surowego ciągu znaków, w którym nie jest konieczne unikanie znaków specjalnych, wszystko jest pisane dosłownie podczas pisania
normal  = 'foo\nbar'   # foo
                       # bar
escaped = 'foo\\nbar'  # foo\nbar   
raw     = r'foo\nbar'  # foo\nbar
 

Zmienne i niezmienne typy danych

Obiekt nazywa się mutable, jeśli można go zmienić. Na przykład, gdy przekazujesz listę do jakiejś funkcji, listę można zmienić:

def f(m):
    m.append(3)  # adds a number to the list. This is a mutation.

x = [1, 2]
f(x)
x == [1, 2]  # False now, since an item was added to the list
 

Obiekt nazywany jest niezmiennym, jeśli nie można go w żaden sposób zmienić. Na przykład liczby całkowite są niezmienne, ponieważ nie ma możliwości ich zmiany:

def bar():
    x = (1, 2)
    g(x)
    x == (1, 2)  # Will always be True, since no function can change the object (1, 2)
 

Należy pamiętać, że same zmienne są zmienne, więc możemy przypisać zmiennej x , ale nie zmienia to obiekt, który x wcześniej wskazał. Oznaczało to, że x wskazuje tylko na nowy obiekt.

Typy danych, których instancje są zmienne, nazywane są zmiennymi typami danych i podobnie dla niezmiennych obiektów i typów danych.

Przykłady niezmiennych typów danych:

  • int , long , float , complex
  • str
  • bytes
  • tuple
  • frozenset

Przykłady zmiennych typów danych:

  • bytearray
  • list
  • set
  • dict

Narzędzie pomocy

Python ma kilka funkcji wbudowanych w interpreter. Jeśli chcesz uzyskać informacje o słowach kluczowych, wbudowanych funkcjach, modułach lub tematach, otwórz konsolę Python i wprowadź:

>>> help()
 

Otrzymasz informacje, wpisując słowa kluczowe bezpośrednio:

>>> help(help)
 

lub w ramach narzędzia:

help> help
 

który pokaże wyjaśnienie:

Help on _Helper in module _sitebuiltins object:

class _Helper(builtins.object)
 |  Define the builtin 'help'.
 |  
 |  This is a wrapper around pydoc.help that provides a helpful message
 |  when 'help' is typed at the Python interactive prompt.
 |  
 |  Calling help() at the Python prompt starts an interactive help session.
 |  Calling help(thing) prints help for the python object 'thing'.
 |  
 |  Methods defined here:
 |  
 |  __call__(self, *args, **kwds)
 |  
 |  __repr__(self)
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 

Możesz również poprosić o podklasy modułów:

help(pymysql.connections)
 

Możesz skorzystać z pomocy, aby uzyskać dostęp do dokumentów różnych zaimportowanych modułów, np. Spróbuj wykonać następujące czynności:

>>> help(math)
 

i dostaniesz błąd

>>> import math
>>> help(math)
 

A teraz otrzymasz listę dostępnych metod w module, ale dopiero PO zaimportowaniu go.

Zamknij pomocnika, quit

IDLE - graficzny interfejs użytkownika w języku Python

IDLE jest zintegrowanym środowiskiem programistycznym i edukacyjnym Pythona i jest alternatywą dla wiersza poleceń. Jak sama nazwa wskazuje, IDLE jest bardzo przydatne do tworzenia nowego kodu lub uczenia się języka Python. W systemie Windows jest on wyposażony w interpreter języka Python, ale w innych systemach operacyjnych może być konieczne zainstalowanie go za pośrednictwem menedżera pakietów.

Główne cele IDLE to:

  • Edytor tekstu z wieloma oknami z podświetlaniem składni, autouzupełnianiem i inteligentnym wcięciem
  • Powłoka Python z podświetlaniem składni
  • Zintegrowany debugger z krokami, trwałymi punktami przerwania i widocznością stosu wywołań
  • Automatyczne wcięcie (przydatne dla początkujących, którzy poznają wcięcie Pythona)
  • Zapisywanie programu Python jako plików .py, uruchamianie i edytowanie ich później w dowolnym przy użyciu IDLE.

W IDLE, naciśnij F5 lub run Python Shell aby uruchomić interpreter. Korzystanie z IDLE może być lepszym doświadczeniem dla nowych użytkowników, ponieważ kod jest interpretowany podczas pisania przez użytkownika.

Pamiętaj, że istnieje wiele alternatyw, zobacz na przykład tę dyskusję lub tę listę .

Rozwiązywanie problemów

  • Windows

    W systemie Windows domyślnym poleceniem jest python . Jeśli pojawi się błąd "'python' is not recognized" , najbardziej prawdopodobną przyczyną jest to, że lokalizacja Pythona nie znajduje się w zmiennej środowiskowej PATH systemu. Można to uzyskać, klikając prawym przyciskiem myszy „Mój komputer” i wybierając „Właściwości” lub przechodząc do „Systemu” poprzez „Panel sterowania”. Kliknij „Zaawansowane ustawienia systemu”, a następnie „Zmienne środowiskowe ...”. Zmodyfikuj zmienną PATH , aby uwzględnić katalog instalacji Pythona, a także folder Script (zwykle C:\Python27;C:\Python27\Scripts ). Wymaga to uprawnień administracyjnych i może wymagać ponownego uruchomienia.

    Podczas korzystania z wielu wersji Pythona na tym samym komputerze, możliwym rozwiązaniem jest zmiana nazwy jednego z plików python.exe . Na przykład nazwanie jednej wersji python27.exe spowoduje, że python27 stanie się poleceniem Python dla tej wersji.

    Możesz także użyć programu uruchamiającego Python dla systemu Windows, który jest dostępny za pośrednictwem instalatora i jest domyślnie dostępny. Pozwala wybrać wersję Pythona do uruchomienia przy użyciu py -[xy] zamiast python[xy] . Możesz użyć najnowszej wersji Python 2, uruchamiając skrypty z py -2 i najnowszą wersję Python 3, uruchamiając skrypty z py -3 .

  • Debian / Ubuntu / MacOS

    W tej sekcji założono, że lokalizacja pliku wykonywalnego python została dodana do zmiennej środowiskowej PATH .

    Jeśli korzystasz z Debian / Ubuntu / MacOS, otwórz terminal i wpisz python dla Python 2.x lub python3 dla Python 3.x.

    Wpisz, which python aby zobaczyć, który interpreter będzie używany.

  • Arch Linux

    Domyślnym Pythonem w Arch Linux (i potomkach) jest Python 3, więc użyj python lub python3 dla Python 3.x i python2 dla Python 2.x.

  • Inne systemy

    Python 3 jest czasem związana z python zamiast python3 . Aby używać Python 2 w tych systemach, w których jest on zainstalowany, możesz użyć python2 .

Instalacja Python 2.7.x i 3.x

Uwaga : Poniższe instrukcje są napisane dla Python 2.7 (chyba że podano inaczej): instrukcje dla Python 3.x są podobne.

OKNA

Najpierw pobierz najnowszą wersję Python 2.7 z oficjalnej strony internetowej ( https://www.python.org/downloads/) . Wersja jest dostarczana jako pakiet MSI. Aby zainstalować go ręcznie, wystarczy dwukrotnie kliknąć plik.

Domyślnie Python instaluje się w katalogu:

 C:\Python27\
 

Ostrzeżenie: instalacja nie modyfikuje automatycznie zmiennej środowiskowej PATH.

Zakładając, że instalacja Pythona odbywa się w C: \ Python27, dodaj to do ŚCIEŻKI:

C:\Python27\;C:\Python27\Scripts\
 

Teraz, aby sprawdzić, czy instalacja w Pythonie jest poprawna, napisz w cmd:

python --version
 

Python 2.x i 3.x Side-by-Side

Aby zainstalować i używać jednocześnie Python 2.x i 3.x na komputerze z systemem Windows:

  1. Zainstaluj Python 2.x przy użyciu instalatora MSI.

    • Upewnij się, że Python jest zainstalowany dla wszystkich użytkowników.
    • Opcjonalnie: dodaj Pythona do PATH aby Python 2.x był możliwy do wywołania z wiersza poleceń za pomocą python .
  2. Zainstaluj Python 3.x za pomocą odpowiedniego instalatora.

    • Ponownie upewnij się, że Python jest zainstalowany dla wszystkich użytkowników.
    • Opcjonalnie: dodaj Pythona do PATH aby Python 3.x był możliwy do wywołania z wiersza poleceń za pomocą python . Może to zastąpić ustawienia PATH Pythonie 2.x, dlatego dokładnie sprawdź PATH i upewnij się, że jest skonfigurowany zgodnie z Twoimi preferencjami.
    • Zainstaluj program py launcher dla wszystkich użytkowników.

Python 3 zainstaluje program uruchamiający Python, który może być używany do uruchamiania Python 2.xi Python 3.x zamiennie z wiersza poleceń:

P:\>py -3
Python 3.6.1 (v3.6.1:69c0db5, Mar 21 2017, 17:54:52) [MSC v.1900 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>

C:\>py -2
Python 2.7.13 (v2.7.13:a06454b1afa1, Dec 17 2016, 20:42:59) [MSC v.1500 32 Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>
 

Aby użyć odpowiedniej wersji pip dla konkretnej wersji Pythona, użyj:

C:\>py -3 -m pip -V
pip 9.0.1 from C:\Python36\lib\site-packages (python 3.6)

C:\>py -2 -m pip -V
pip 9.0.1 from C:\Python27\lib\site-packages (python 2.7)
 

LINUX

Najnowsze wersje CentOS, Fedora, Redhat Enterprise (RHEL) i Ubuntu są dostarczane z Python 2.7.

Aby ręcznie zainstalować Python 2.7 na systemie Linux, wykonaj następujące czynności w terminalu:

wget --no-check-certificate https://www.python.org/ftp/python/2.7.X/Python-2.7.X.tgz
tar -xzf Python-2.7.X.tgz  
cd Python-2.7.X
./configure  
make  
sudo make install
 

Dodaj także ścieżkę nowego pytona do zmiennej środowiskowej PATH. Jeśli nowy python znajduje się w /root/python-2.7.X uruchom export PATH = $PATH:/root/python-2.7.X

Teraz, aby sprawdzić, czy instalacja w języku Python jest poprawna, wpisz w terminalu:

python --version
 

Ubuntu (ze źródła)

Jeśli potrzebujesz Python 3.6, możesz go zainstalować ze źródła, jak pokazano poniżej (Ubuntu 16.10 i 17.04 mają wersję 3.6 w uniwersalnym repozytorium). W przypadku Ubuntu 16.04 i niższych wersji należy wykonać następujące kroki:

sudo apt install build-essential checkinstall
sudo apt install libreadline-gplv2-dev libncursesw5-dev libssl-dev libsqlite3-dev tk-dev libgdbm-dev libc6-dev libbz2-dev
wget https://www.python.org/ftp/python/3.6.1/Python-3.6.1.tar.xz
tar xvf Python-3.6.1.tar.xz 
cd Python-3.6.1/
./configure --enable-optimizations
sudo make altinstall
 

System operacyjny Mac

Jak mówimy, macOS jest instalowany z Pythonem 2.7.10, ale ta wersja jest przestarzała i nieco zmodyfikowana w stosunku do zwykłego Pythona.

Wersja Pythona dostarczana z systemem OS X jest świetna do nauki, ale nie nadaje się do programowania. Wersja dostarczana z systemem OS X może być nieaktualna w stosunku do oficjalnej bieżącej wersji Pythona, która jest uważana za stabilną wersję produkcyjną. ( źródło )

Zainstaluj Homebrew :

/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
 

Zainstaluj Python 2.7:

brew install python
 

W przypadku Python 3.x zamiast tego użyj polecenia brew install python3 .

Instalowanie modułów zewnętrznych za pomocą pip

pip jest Twoim przyjacielem, gdy musisz zainstalować dowolny pakiet z wielu opcji dostępnych w indeksie pakietów Pythona (PyPI). pip jest już zainstalowany, jeśli używasz Python 2> = 2.7.9 lub Python 3> = 3.4 pobrany z python.org. W przypadku komputerów z systemem Linux lub innym * nix z natywnym menedżerem pakietów, pip często musi być instalowany ręcznie.

W instancjach, w których zainstalowany jest zarówno Python 2, jak i Python 3, pip często odnosi się do Python 2, a pip3 do Python 3. Użycie pip spowoduje zainstalowanie tylko pakietów dla Python 2, a pip3 zainstaluje tylko pakiety dla Python 3.

Znajdowanie / instalowanie pakietu

Wyszukiwanie pakietu jest tak proste, jak pisanie

$ pip search <query>
# Searches for packages whose name or summary contains <query>
 

Instalowanie pakietu jest tak proste, jak pisanie (w terminalu / wierszu polecenia, a nie w interprecie Pythona)

$ pip install [package_name]           # latest version of the package

$ pip install [package_name]==x.x.x    # specific version of the package

$ pip install '[package_name]>=x.x.x'  # minimum version of the package
 

gdzie xxx to numer wersji pakietu, który chcesz zainstalować.

Gdy Twój serwer znajduje się za serwerem proxy, możesz zainstalować pakiet, używając poniższego polecenia:

$ pip --proxy http://<server address>:<port> install
 

Aktualizacja zainstalowanych pakietów

Gdy pojawią się nowe wersje zainstalowanych pakietów, nie są one automatycznie instalowane w systemie. Aby uzyskać przegląd tego, które z zainstalowanych pakietów stały się nieaktualne, uruchom:

$ pip list --outdated
 

Aby zaktualizować konkretny pakiet użyj

$ pip install [package_name] --upgrade
 

Aktualizacja wszystkich nieaktualnych pakietów nie jest standardową funkcjonalnością pip .

Aktualizacja pip

Możesz zaktualizować istniejącą instalację pip za pomocą następujących poleceń

  • W systemie Linux lub macOS X:

    $ pip install -U pip
     

    W niektórych systemach Linux może być konieczne użycie sudo z pipem

  • W systemie Windows:

    py -m pip install -U pip
     

    lub

    python -m pip install -U pip
     

Aby uzyskać więcej informacji dotyczących pip, przeczytaj tutaj .

Funkcja ciągu - str () i repr ()

Istnieją dwie funkcje, których można użyć do uzyskania czytelnej reprezentacji obiektu.

repr(x) wywołuje x.__repr__() : reprezentacja x . eval zwykle konwertuje wynik tej funkcji z powrotem do oryginalnego obiektu.

str(x) wywołuje x.__str__() : czytelny dla człowieka ciąg opisujący obiekt. Może to zawierać pewne szczegóły techniczne.


repr ()

W przypadku wielu typów funkcja ta próbuje zwrócić ciąg znaków, który dałby obiekt o tej samej wartości po przekazaniu do eval() . W przeciwnym razie reprezentacja jest ciągiem zamkniętym w nawiasach kątowych, który zawiera nazwę typu obiektu wraz z dodatkowymi informacjami. Często obejmuje to nazwę i adres obiektu.

str ()

W przypadku ciągów zwraca to sam ciąg. Różnica między tym a repr(object) polega na tym, że str(object) nie zawsze próbuje zwrócić ciąg znaków, który można zaakceptować eval() . Jego celem jest raczej zwrócenie drukowalnego lub „czytelnego dla człowieka” ciągu. Jeśli nie podano żadnego argumentu, zwraca pusty ciąg '' .


Przykład 1:

s = """w'o"w"""
repr(s) # Output: '\'w\\\'o"w\''  
str(s)  # Output: 'w\'o"w'
eval(str(s)) == s  # Gives a SyntaxError 
eval(repr(s)) == s # Output: True
 

Przykład 2:

import datetime
today = datetime.datetime.now()
str(today)  # Output: '2016-09-15 06:58:46.915000'
repr(today) # Output: 'datetime.datetime(2016, 9, 15, 6, 58, 46, 915000)'
 

Pisząc klasę, możesz zastąpić te metody, aby zrobić, co chcesz:

class Represent(object):

    def __init__(self, x, y):
        self.x, self.y = x, y

    def __repr__(self):
        return "Represent(x={},y=\"{}\")".format(self.x, self.y)

    def __str__(self):
        return "Representing x as {} and y as {}".format(self.x, self.y)
 

Korzystając z powyższej klasy możemy zobaczyć wyniki:

r = Represent(1, "Hopper")
print(r)  # prints __str__
print(r.__repr__)  # prints __repr__: '<bound method Represent.__repr__ of Represent(x=1,y="Hopper")>'
rep = r.__repr__()  # sets the execution of __repr__ to a new variable
print(rep)  # prints 'Represent(x=1,y="Hopper")'
r2 = eval(rep) # evaluates rep
print(r2)  # prints __str__ from new object
print(r2 == r)  # prints 'False' because they are different objects
 

Wprowadzane przez użytkownika

Wejście interaktywne

Aby uzyskać dane wejściowe od użytkownika, użyj funkcji input ( uwaga : w Pythonie 2.x funkcja nazywa się zamiast tego raw_input , chociaż Python 2.x ma własną wersję danych input która jest zupełnie inna):

Python 2.x 2.3
name = raw_input("What is your name? ")
# Out: What is your name? _
 

Uwaga dotycząca bezpieczeństwa Nie używaj input() w Python2 - wprowadzony tekst będzie oceniany tak, jakby był wyrażeniem Python (równoważnym eval(input()) w Python3), co może łatwo stać się podatnością. Więcej informacji na temat ryzyka związanego z korzystaniem z tej funkcji można znaleźć w tym artykule .

Python 3.x 3.0
name = input("What is your name? ")
# Out: What is your name? _
 

Pozostała część tego przykładu będzie używać składni Python 3.

Funkcja pobiera argument ciągu, który wyświetla go jako monit i zwraca ciąg. Powyższy kod wyświetla monit, który oczekuje na wprowadzenie danych przez użytkownika.

name = input("What is your name? ")
# Out: What is your name?
 

Jeśli użytkownik wpisze „Bob”, a hity wejdą, name zmiennej zostanie przypisana do ciągu "Bob" :

name = input("What is your name? ")
# Out: What is your name? Bob
print(name)
# Out: Bob
 

Zauważ, że dane input są zawsze typu str , co jest ważne, jeśli chcesz, aby użytkownik wprowadzał liczby. Dlatego musisz przekonwertować str zanim spróbujesz użyć go jako liczby:

x = input("Write a number:")
# Out: Write a number: 10
x / 2
# Out: TypeError: unsupported operand type(s) for /: 'str' and 'int'
float(x) / 2
# Out: 5.0
 

Uwaga: Zaleca się stosowanie bloków try / except do wychwytywania wyjątków podczas obsługi danych wejściowych użytkownika . Na przykład, jeśli twój kod chce rzutować raw_input na int , a to, co pisze użytkownik, jest nie do wyemitowania, wywołuje błąd ValueError .