Python Language учебник
Начало работы с языком Python

замечания

Версии

Начиная

Python - широко используемый высокоуровневый язык программирования для программирования общего назначения, созданный Guido van Rossum и впервые выпущенный в 1991 году. Python имеет динамическую систему типов и автоматическое управление памятью и поддерживает несколько программных парадигм, включая объектно-ориентированные, функционального программирования и процедурных стилей. Он имеет большую и всеобъемлющую стандартную библиотеку.

В настоящее время активно используются две основные версии Python:

• Python 3.x является текущей версией и находится в активной разработке.
• Python 2.x является устаревшей версией и будет получать только обновления для системы безопасности до 2020 года. Никаких новых функций не будет. Обратите внимание, что многие проекты по-прежнему используют Python 2, хотя переход на Python 3 становится проще.

Вы можете скачать и установить либо версию Python здесь . См. Python 3 и Python 2 для сравнения между ними. Кроме того, некоторые сторонние поставщики предлагают повторно упакованные версии Python, которые добавляют часто используемые библиотеки и другие функции для облегчения настройки для случаев общего использования, таких как математика, анализ данных или научное использование. См. Список на официальном сайте .

Проверьте, установлен ли Python

Чтобы убедиться, что Python установлен правильно, вы можете убедиться, что, выполнив следующую команду в своем любимом терминале (если вы используете ОС Windows, вам нужно добавить путь к python в переменную окружения, прежде чем использовать его в командной строке):

$ python --version

$ python --version
Python 3.6.0

$ python --version
Python 2.7.13

Если вы установили Python 3, но $ python --version выводит версию Python 2, у вас также установлен Python 2. Это часто бывает в MacOS и во многих дистрибутивах Linux. $ python3 этого используйте $ python3 чтобы явно использовать интерпретатор Python 3.

Привет, мир в Python, используя IDLE

IDLE - простой редактор для Python, который поставляется вместе с Python.

Как создать программу Hello, World в IDLE

• Откройте IDLE в вашей системе выбора.
  • В старых версиях Windows его можно найти в разделе « All Programs в меню «Windows».
  • В Windows 8+ найдите IDLE или найдите его в приложениях, присутствующих в вашей системе.
  • В системах на основе Unix (включая Mac) вы можете открыть его из оболочки, набрав $ idle python_file.py .
• Он откроет оболочку с параметрами вверху.

В оболочке есть подсказка из трех прямоугольных скобок:

>>>

Теперь напишите в подсказке следующий код:

>>> print("Hello, World")

Нажмите Enter .

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

Файл Hello World Python

Создайте новый файл hello.py который содержит следующую строку:

print('Hello, World')

from __future__ import print_function

print 'Hello, World'

В своем терминале перейдите в каталог, содержащий файл hello.py .

Введите python hello.py , затем нажмите клавишу Enter .

$ python hello.py
Hello, World

Вы должны увидеть Hello, World напечатанную на консоли.

Вы также можете заменить hello.py на путь к вашему файлу. Например, если у вас есть файл в вашем домашнем каталоге, а ваш пользователь «пользователь» в Linux, вы можете ввести python /home/user/hello.py .

Запустить интерактивную оболочку Python

Выполняя (запуская) команду python в вашем терминале, вы получаете интерактивную оболочку Python. Это также известно как Python Interpreter или REPL (для «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
>>>

Если вы хотите запустить Python 3 из своего терминала, выполните команду 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
>>>

Кроме того, запустите интерактивную подсказку и загрузите файл с помощью python -i <file.py> .

В командной строке выполните:

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

Существует несколько способов закрыть оболочку Python:

>>> exit()

или же

>>> quit()

Кроме того, CTRL + D закроет оболочку и вернет вас в командную строку вашего терминала.

Если вы хотите отменить команду, находящуюся в середине ввода и вернуться к чистой командной строке, оставаясь внутри оболочки Interpreter, используйте CTRL + C.

Попробуйте интерактивную оболочку Python в Интернете .

Другие онлайн-оболочки

Различные веб-сайты предоставляют онлайн-доступ к оболочкам Python.

Онлайн-оболочки могут быть полезны для следующих целей:

• Запустите небольшой фрагмент кода с компьютера, на котором отсутствует установка python (смартфоны, планшеты и т. Д.).
• Изучайте базовый Python.
• Решите проблемы онлайн-судьи.

Примеры:

Отказ от ответственности: автор (ы) документации не связаны ни с какими ресурсами, перечисленными ниже.

• https://www.python.org/shell/ - онлайн-оболочка Python, размещенная на официальном веб-сайте Python.
• https://ideone.com/ - Широко используется в сети для иллюстрации поведения фрагмента кода.
• https://repl.it/languages/python3 - Мощный и простой онлайн-компилятор, IDE и интерпретатор. Код, компилировать и запускать код в Python.
• https://www.tutorialspoint.com/execute_python_online.php - полнофункциональная оболочка UNIX и удобный проводник проекта.
• http://rextester.com/l/python3_online_compiler - Простая и простая в использовании среда разработки, которая показывает время выполнения

Выполнять команды как строку

Python может быть передан произвольным кодом в виде строки в оболочке:

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

Это может быть полезно при объединении результатов скриптов вместе в оболочке.

Оболочки и последующие

Управление пакетами. Рекомендованным PyPA инструментом для установки пакетов Python является PIP . Для установки в командной строке выполните команду pip install <the package name> . Например, pip install numpy . (Примечание. В окнах вы должны добавить pip в переменные среды PATH. Чтобы этого избежать, используйте python -m pip install <the package name> ).

Оболочки. До сих пор мы обсуждали разные способы запуска кода с использованием встроенной интерактивной оболочки Python. Оболочки используют интерпретационную способность Python для экспериментов с кодом в режиме реального времени. Альтернативные оболочки включают IDLE - предварительно объединенный графический интерфейс, IPython - известный для расширения интерактивного опыта и т. Д.

Программы. Для долговременного хранения вы можете сохранять контент в .py-файлах и редактировать / выполнять их как скрипты или программы с помощью внешних инструментов, таких как оболочка, IDE (например, PyCharm ), ноутбуки Jupyter и т. Д. Промежуточные пользователи могут использовать эти инструменты; однако способы, описанные здесь, достаточны для начала.

Наставник Python позволяет вам пройти через код Python, чтобы вы могли визуализировать, как будет работать программа, и поможет вам понять, где ваша программа пошла не так.

PEP8 определяет правила форматирования кода Python. Очень важно правильно форматировать код, чтобы вы могли быстро прочитать, что делает код.

Создание переменных и назначение значений

Чтобы создать переменную в Python, все, что вам нужно сделать, это указать имя переменной и присвоить ей значение.

<variable name> = <value>

Python использует = для назначения значений переменным. Нет необходимости заранее объявлять переменную (или присваивать ей тип данных), присваивая значение самой переменной, объявляет и инициализирует переменную с этим значением. Невозможно объявить переменную без присвоения ей начального значения.

# 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

Переменное назначение работает слева направо. Таким образом, следующее приведет к синтаксической ошибке.

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

Вы не можете использовать ключевые слова python как допустимое имя переменной. Вы можете увидеть список ключевых слов:

import keyword
print(keyword.kwlist)

Правила для именования переменных:

1. Имена переменных должны начинаться с буквы или подчеркивания.

 x  = True   # valid
 _y = True   # valid

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

 $y = False #  starts with symbol 
 => SyntaxError: invalid syntax

2. Остальная часть вашего имени переменной может состоять из букв, цифр и символов подчеркивания.

has_0_in_it = "Still Valid" 

3. Имена чувствительны к регистру.

x = 9  
y = X*5   
=>NameError: name 'X' is not defined

Несмотря на то, что нет необходимости указывать тип данных при объявлении переменной в Python, при распределении необходимой области в памяти для переменной интерпретатор Python автоматически выбирает для нее наиболее подходящий встроенный тип :

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'>

Теперь вы знаете основы задания, давайте сделаем эту тонкость о назначении в python в сторону.

Когда вы используете = для выполнения операции присваивания, то, что слева от = - это имя для объекта справа. Наконец, what = is присваивает ссылку объекта справа на имя слева.

То есть:

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

Так, из многих примеров присваивания выше, если мы выбираем pi = 3.14 , то pi этого имя (не имя, так как объект может иметь несколько имен) для объекта 3.14 . Если вы не понимаете что-то ниже, вернитесь к этому вопросу и прочитайте это снова! Кроме того, вы можете взглянуть на это для лучшего понимания.

Вы можете назначить несколько значений нескольким переменным в одной строке. Обратите внимание, что должно быть такое же количество аргументов в правой и левой сторонах оператора = :

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

Ошибка в последнем примере может быть устранена путем назначения оставшихся значений равным числу произвольных переменных. Эта фиктивная переменная может иметь любое имя, но условно использовать знак подчеркивания ( _ ) для назначения нежелательных значений:

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

Обратите внимание, что число _ и количество оставшихся значений должны быть равны. В противном случае «слишком много значений для распаковки ошибки» выбрасывается, как указано выше:

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)

Вы также можете назначить одно значение нескольким переменным одновременно.

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

При использовании такого каскадного назначения важно отметить, что все три переменные a , b и c относятся к одному и тому же объекту в памяти, к объекту int со значением 1. Другими словами, a , b и c представляют собой три разных имени заданный одному и тому же объекту int. Назначение другого объекта одному из них впоследствии не изменяет других, как и ожидалось:

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.

Вышеизложенное также верно для изменяемых типов (например, list , dict и т. Д.), Так же как и для неизменяемых типов (например, int , string , tuple и т. Д.):

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]

Все идет нормально. Что-то немного изменилось, когда дело доходило до модификации объекта (в отличие от назначения имени другому объекту, который мы сделали выше), когда каскадное присвоение используется для изменяемых типов. Взгляните ниже, и вы увидите это из первых рук:

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

Вложенные списки также действительны в python. Это означает, что список может содержать другой список как элемент.

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

Наконец, переменные в Python не должны оставаться теми же типами, с которыми они были сначала определены - вы можете просто использовать = для назначения нового значения переменной, даже если это значение имеет другой тип.

a = 2 
print(a)
# Output: 2

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

Если это вас беспокоит, подумайте о том, что то, что находится слева от = - это просто имя для объекта. Во- первых вы вызываете int объект со значением 2 , то вы передумали и решили дать имя a a , к string объекту, имеющему значение «Нового значения». Простой, не так ли?

Вход пользователя

Интерактивный вход

Чтобы получить вход от пользователя, используйте функцию input ( обратите внимание : в Python 2.x вместо этого функция называется raw_input , хотя Python 2.x имеет свою собственную версию input которая совершенно иная):

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

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

Остальная часть этого примера будет использовать синтаксис Python 3.

Функция принимает строковый аргумент, который отображает его как приглашение и возвращает строку. В приведенном выше коде содержится запрос, ожидающий ввода пользователем.

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

Если пользователь вводит «Боб» и попадает, name переменной будет присвоено строке "Bob" :

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

Обратите внимание, что input всегда имеет тип str , что важно, если вы хотите, чтобы пользователь вводил числа. Поэтому вам нужно преобразовать str прежде чем пытаться использовать его как число:

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

Примечание. Рекомендуется использовать блоки try / except чтобы перехватывать исключения при работе с пользовательскими вводами . Например, если ваш код хочет raw_input в int , и то, что пользователь пишет, является непередаваемым, оно вызывает ValueError .

IDLE - графический интерфейс Python

IDLE - это интегрированная среда разработки и обучения Python и является альтернативой командной строке. Как следует из названия, IDLE очень полезно для разработки нового кода или обучения python. В Windows это поставляется с интерпретатором Python, но в других операционных системах вам может потребоваться установить его через диспетчер пакетов.

Основными целями IDLE являются:

• Многострочный текстовый редактор с подсветкой синтаксиса, автозаполнением и интеллектуальным отступом
• Оболочка Python с подсветкой синтаксиса
• Интегрированный отладчик с степпингом, постоянными точками останова и видимостью стека вызовов
• Автоматический отступ (полезно для начинающих, изучающих отступ Python)
• Сохраняя программу Python как .py-файлы, запустите их и отредактируйте позже в любом из них с помощью IDLE.

В IDLE нажмите F5 или run Python Shell чтобы запустить интерпретатор. Использование IDLE может быть лучшим опытом обучения для новых пользователей, потому что код интерпретируется как пользователь пишет.

Обратите внимание, что существует множество альтернатив, см., Например, эту дискуссию или этот список .

Поиск проблемы

• Windows

  Если вы работаете в Windows, команда по умолчанию - python . Если вы получаете ошибку "'python' is not recognized" , наиболее вероятной причиной является то, что местоположение Python не входит в PATH среды PATH вашей системы. Доступ к нему можно получить, щелкнув правой кнопкой мыши на «Мой компьютер» и выбрав «Свойства» или перейдя в «Система» через «Панель управления». Нажмите «Дополнительные системные настройки», а затем «Переменные среды ...». Измените переменную PATH чтобы включить каталог вашей установки Python, а также папку сценария (обычно C:\Python27;C:\Python27\Scripts ). Для этого требуются административные привилегии и может потребоваться перезагрузка.

  При использовании нескольких версий Python на одном и том же компьютере возможным решением является переименование одного из файлов python.exe . Например, именование одной версии python27.exe приведет к тому, что python27 станет командой Python для этой версии.

  Вы также можете использовать Python Launcher для Windows, который доступен через установщик и поставляется по умолчанию. Он позволяет вам выбрать версию Python для запуска с помощью py -[xy] вместо python[xy] . Вы можете использовать последнюю версию Python 2, запустив скрипты с py -2 и последней версией Python 3, запустив скрипты с py -3 .

• Debian / Ubuntu / MacOS

  В этом разделе предполагается, что местоположение исполняемого файла python добавлено в PATH среды PATH .

  Если вы находитесь в Debian / Ubuntu / MacOS, откройте терминал и введите python для Python 2.x или python3 для Python 3.x.

  Введите, which python будет видеть, какой интерпретатор Python будет использоваться.

• Arch Linux

  По умолчанию Python на Arch Linux (и потомки) - это Python 3, поэтому используйте python или python3 для Python 3.x и python2 для Python 2.x.

• Другие системы

  Python 3 иногда связан с python вместо python3 . Чтобы использовать Python 2 в этих системах, где он установлен, вы можете использовать python2 .

Типы данных

Встроенные типы

Булевы

bool : Логическое значение True или False . Логические операции, такие как and , or , not могут выполняться по булевым.

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

В Python 2.x и в Python 3.x логическое значение также является int . Тип bool является подклассом типа int а True и False являются его единственными экземплярами:

issubclass(bool, int) # True

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

Если в арифметических операциях используются логические значения, их целочисленные значения ( 1 и 0 для True и False ) будут использованы для возврата целочисленного результата:

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

чисел

• int : целое число

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

  Целые числа в Python имеют произвольные размеры.

  Примечание: в более старых версиях Python был доступен long тип, и это отличалось от int . Они были объединены.

• float : число с плавающей точкой; точность зависит от реализации и архитектуры системы, для CPython тип данных float соответствует C double.

  a = 2.0
  b = 100.e0
  c = 123456789.e1
  

• complex : комплексные номера

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

Операторы < , <= , > и >= будут вызывать исключение TypeError если любой операнд является сложным числом.

Струны

Последовательности и коллекции

Python различает упорядоченные последовательности и неупорядоченные коллекции (такие как set и dict ).

• строки ( str , bytes , unicode ) являются последовательностями

• reversed : обратный порядок str с reversed функцией

  a = reversed('hello')
  

• tuple : упорядоченный набор n значений любого типа ( n >= 0 ).

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

  Поддерживает индексирование; неизменный; hashable, если все его члены являются хешируемыми

• list : упорядоченный набор n значений ( n >= 0 )

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

  Не хешируется; изменчивый.

• set : неупорядоченный набор уникальных значений. Элементы должны быть хешируемыми .

  a = {1, 2, 'a'}
  

• dict : неупорядоченный набор уникальных пар ключ-значение; ключи должны быть хешируемыми .

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

Объект hashable, если он имеет значение хэша, которое никогда не изменяется в течение его жизненного __hash__() (ему нужен __hash__() ), и его можно сравнить с другими объектами (ему нужен __eq__() ). Объекты Hashable, которые сравнивают равенство, должны иметь одно и то же значение хэш-функции.

Встроенные константы

В сочетании со встроенными типами данных в встроенном пространстве имен имеется небольшое количество встроенных констант:

• True : истинное значение встроенного типа bool
• False : ложное значение встроенного типа bool
• None : Объект singleton используется для обозначения того, что значение отсутствует.
• Ellipsis или ... : используется в основном Python3 + в любом месте и ограниченное использование в Python2.7 + как часть нотации массива. numpy и связанные с ним пакеты используют это как ссылку «включить все» в массивы.
• NotImplemented : singleton используется для указания Python, что специальный метод не поддерживает конкретные аргументы, а Python будет пытаться использовать альтернативы, если они доступны.

a = None # No value will be assigned. Any valid datatype can be assigned later

Тестирование типа переменных

В python мы можем проверить тип данных объекта с помощью встроенного type функции.

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

В условных операторах можно проверить тип данных с помощью isinstance . Однако обычно не рекомендуется полагаться на тип переменной.

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

Для получения информации о различиях между type() и isinstance() read: Различия между isinstance и типом в Python

Чтобы проверить, имеет ли что-то значение NoneType :

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

Преобразование между типами данных

Вы можете выполнить явное преобразование типов данных.

Например, «123» имеет тип str и может быть преобразован в целое число с использованием функции int .

a = '123'
b = int(a)

Преобразование из строки с плавающей точкой, например, «123.456», может быть выполнено с помощью функции float .

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

Вы также можете конвертировать последовательности или типы коллекций

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

Явный тип строки при определении литералов

С одним буквенным надписью непосредственно перед кавычками вы можете указать, какую строку вы хотите определить.

• b'foo bar' : результаты bytes в Python 3, str в Python 2
• u'foo bar' : результаты str в Python 3, unicode в Python 2
• 'foo bar' : results str
• r'foo bar' : результат так называемой сырой строки, где экранирование специальных символов не требуется, все принимается дословно, когда вы ввели

normal  = 'foo\nbar'   # foo
                       # bar
escaped = 'foo\\nbar'  # foo\nbar   
raw     = r'foo\nbar'  # foo\nbar

Переменные и неизменяемые типы данных

Объект называется изменчивым, если его можно изменить. Например, когда вы передаете список какой-либо функции, список можно изменить:

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

Объект называется неизменяемым, если его нельзя каким-либо образом изменить. Например, целые числа неизменяемы, поскольку их невозможно изменить:

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

Обратите внимание, что сами переменные изменяемы, поэтому мы можем переназначить переменную x , но это не изменяет объект, x который ранее указывал x . Он только сделал x указывать на новый объект.

Типы данных, экземпляры которых изменяемы, называются изменяемыми типами данных , а также для неизменяемых объектов и типов данных.

Примеры неизменяемых типов данных:

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

Примеры изменяемых типов данных:

• bytearray
• list
• set
• dict

Встроенные модули и функции

Модуль - это файл, содержащий определения и утверждения Python. Функция - это фрагмент кода, который выполняет некоторую логику.

>>> pow(2,3)    #8

Чтобы проверить встроенную функцию в python, мы можем использовать dir(). Если вызывается без аргумента, верните имена в текущую область. В противном случае верните алфавитный список имен, содержащих (некоторые) атрибут данного объекта и атрибуты, доступные из него.

>>> 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'
]

Чтобы узнать функциональность любой функции, мы можем использовать встроенную функцию help .

>>> 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.

Встроенные модули содержат дополнительные функции. Например, чтобы получить квадратный корень из числа, нам нужно включить math модуль.

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

Чтобы узнать все функции в модуле, мы можем назначить список функций переменной, а затем распечатать переменную.

>>> 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']

кажется __doc__ полезно предоставить некоторую документацию, например, в функциях

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

В дополнение к функциям документация также может предоставляться в модулях. Итак, если у вас есть файл helloWorld.py вот так:

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

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

Вы можете получить доступ к своим docstrings следующим образом:

>>> import helloWorld
>>> helloWorld.__doc__
'This is the module docstring.'
>>> helloWorld.sayHello.__doc__
'This is the function docstring.'

• Для любого пользовательского типа, его атрибутов, атрибутов его класса и рекурсивно атрибуты базовых классов его класса можно получить с помощью 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__']

Любой тип данных может быть просто преобразован в строку с помощью встроенной функции str . Эта функция вызывается по умолчанию, когда тип данных передается для print

>>> str(123)    # "123"

Отступ блока

Python использует отступы для определения конструкций управления и контуров. Это способствует читаемости Python, однако для этого требуется, чтобы программист уделял пристальное внимание использованию пробелов. Таким образом, просчет редактора может привести к тому, что код, который ведет себя непредсказуемым образом.

Python использует символ двоеточия ( : ) и отступы для показа , где блоки кода начинаются и заканчивается (Если вы пришли из другого языка, не путайте это с каким - то образом быть связаны с троичным оператором ). То есть блоки в Python, такие как функции, петля, if пункты и другие конструкции, не имеют идентификаторов концовки. Все блоки начинаются с двоеточия, а затем содержат отступы под ним.

Например:

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

или же

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

Блоки, которые содержат ровно один однострочный оператор, могут быть помещены в одну строку, хотя эта форма обычно не считается хорошим стилем:

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

Попытка сделать это более чем с одним заявлением не будет работать:

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

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

Пустой блок вызывает IndentationError . Используйте pass (команда, которая ничего не делает), когда у вас есть блок без содержимого:

def will_be_implemented_later():
    pass

Пробелы против вкладок

Короче: всегда используйте 4 пробела для отступов.

Использование вкладок исключительно возможно, но PEP 8 , руководство по стилю для кода Python, указывает, что пробелы предпочтительнее.

У многих редакторов есть конфигурация «tabs to spaces». При настройке редактора следует различать символ табуляции ('\ t') и клавишу Tab .

• Вкладка символ должен быть настроен , чтобы показать 8 пробелов, чтобы соответствовать семантике языка - по крайней мере , в тех случаях , когда (случайно) смешанные отступы возможно. Редакторы также могут автоматически преобразовывать символ табуляции в пробелы.
• Однако было бы полезно настроить редактор так, чтобы нажатие клавиши Tab вставляло 4 пробела вместо того, чтобы вставлять символ табуляции.

Исходный код Python, написанный сочетанием вкладок и пробелов, или с нестандартным числом пространств отступа можно сделать pep8-совместимым с помощью autopep8 . (Менее мощная альтернатива поставляется с большинством установок Python: reindent.py )

Типы коллекций

В Python существует несколько типов коллекций. Хотя типы, такие как int и str содержат одно значение, типы коллекции содержат несколько значений.

Списки

Тип list вероятно, является наиболее часто используемым типом коллекции в Python. Несмотря на свое имя, список больше похож на массив на других языках, в основном на JavaScript. В Python список представляет собой просто упорядоченный набор действительных значений Python. Список может быть создан путем включения значений, разделенных запятыми, в квадратных скобках:

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

Список может быть пустым:

empty_list = []

Элементы списка не ограничены одним типом данных, что имеет смысл, учитывая, что Python является динамическим языком:

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

Список может содержать другой список:

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

Элементы списка могут быть доступны через индекс или числовое представление их позиции. Списки в Python имеют нулевое индексирование, означающее, что первый элемент в списке имеет индекс 0, второй элемент - в индексе 1 и так далее:

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

Индексы также могут быть отрицательными, что означает подсчет с конца списка ( -1 - индекс последнего элемента). Итак, используя список из приведенного выше примера:

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

Списки изменяются, поэтому вы можете изменить значения в списке:

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

Кроме того, можно добавлять и / или удалять элементы из списка:

Добавить объект в конец списка с помощью L.append(object) , возвращает None .

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

Добавьте новый элемент для отображения по определенному индексу. L.insert(index, object)

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

Удалите первое вхождение значения с L.remove(value) , возвращает None

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

Получить индекс в списке первого элемента, значение которого равно x. Он покажет ошибку, если такого элемента нет.

name.index("Alice")
0

Подсчитать длину списка

len(names)
6

подсчет количества элементов в списке

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

Изменить список

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

Удалите и верните элемент по индексу (по умолчанию последний элемент) с L.pop([index]) , возвращает элемент

names.pop() # Outputs 'Sia'

Вы можете перебирать элементы списка, как показано ниже:

for element in my_list:
    print (element)

Кортеж

tuple похож на список, за исключением того, что он является фиксированным и неизменным. Таким образом, значения в кортеже не могут быть изменены, а значения не будут добавлены или исключены из кортежа. Кортежи обычно используются для небольших коллекций значений, которые не нужно изменять, например, IP-адрес и порт. Кортежи представлены скобками вместо квадратных скобок:

ip_address = ('10.20.30.40', 8080)

Те же правила индексирования списков также применяются к кортежам. Кортежи также могут быть вложенными, и значения могут быть действительными действительными действительными Python.

Кортеж с одним членом должен быть определен (обратите внимание на запятую) следующим образом:

one_member_tuple = ('Only member',)

или же

one_member_tuple = 'Only member',   # No brackets

или просто используя синтаксис tuple

one_member_tuple = tuple(['Only member'])

Словари

dictionary в Python представляет собой набор пар ключ-значение. Словарь окружен фигурными фигурными скобками. Каждая пара разделяется запятой, а ключ и значение разделяются двоеточием. Вот пример:

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

Чтобы получить значение, обратитесь к нему по его ключу:

ca_capital = state_capitals['California']

Вы также можете получить все ключи в словаре, а затем перебрать их:

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

Словари сильно напоминают синтаксис JSON. json модуль json в стандартной библиотеке Python может использоваться для преобразования между JSON и словарями.

задавать

set представляет собой набор элементов без повторов и без порядка вставки, но отсортированный порядок. Они используются в ситуациях, когда важно, чтобы некоторые вещи были сгруппированы вместе, а не какой порядок они были включены. Для больших групп данных гораздо быстрее проверить, находится ли элемент в set чем он должен делать то же самое для list .

Определение set очень похоже на определение dictionary :

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

Или вы можете построить set используя существующий list :

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

Проверьте членство в set с использованием in :

if name in first_names:
    print(name)

Вы можете перебирать set точно так же, как и список, но помните: значения будут в произвольном порядке реализации.

defaultdict

defaultdict - это словарь со значением по умолчанию для ключей, поэтому ключи, для которых не было явно определено значение, могут быть доступны без ошибок. defaultdict особенно полезен, когда значения в словаре представляют собой коллекции (списки, dicts и т. д.) в том смысле, что его не нужно инициализировать каждый раз, когда используется новый ключ.

Значение defaultdict никогда не вызовет KeyError. Любой ключ, который не существует, возвращает значение по умолчанию.

Например, рассмотрим следующий словарь

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

Если мы попытаемся получить доступ к несуществующему ключу, python возвращает нам ошибку следующим образом

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

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

KeyError: 'Alabama'

Давайте попробуем с defaultdict . Его можно найти в модуле коллекций.

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

То, что мы здесь сделали, - установить значение по умолчанию ( Boston ), если ключ-ключ не существует. Теперь заселите диктофон, как раньше:

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

Если мы попытаемся получить доступ к dict с несуществующим ключом, python вернет нам значение по умолчанию, то есть Boston

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

и возвращает созданные значения для существующего ключа, как обычный dictionary

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

Полезная утилита

Python имеет несколько функций, встроенных в интерпретатор. Если вы хотите получить информацию о ключевых словах, встроенные функции, модули или темы, откройте консоль Python и введите:

>>> help()

Вы получите информацию, непосредственно введя ключевые слова:

>>> help(help)

или внутри утилиты:

help> help

который покажет объяснение:

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)

Вы также можете запросить подклассы модулей:

help(pymysql.connections)

Вы можете использовать помощь для доступа к docstrings из разных модулей, которые вы импортировали, например, попробуйте следующее:

>>> help(math)

и вы получите сообщение об ошибке

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

Теперь вы получите список доступных методов в модуле, но только ПОСЛЕ того, как вы его импортировали.

Закрой помощник с quit

Создание модуля

Модуль - это импортируемый файл, содержащий определения и утверждения.

Модуль можно создать, создав файл .py .

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

Функции в модуле можно использовать, импортируя модуль.

Для модулей, которые вы создали, они должны быть в том же каталоге, что и файл, в который вы их импортируете. (Однако вы также можете поместить их в каталог Python lib с предустановленными модулями, но по возможности следует избегать).

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

Модули могут быть импортированы другими модулями.

# greet.py
import hello
hello.say_hello()

Конкретные функции модуля можно импортировать.

# greet.py
from hello import say_hello
say_hello()

Модули могут быть сглажены.

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

Модуль может быть автономным исполняемым скриптом.

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

Запустить его!

$ python run_hello.py
=> "Hello!"

Если модуль находится внутри каталога и должен быть обнаружен с помощью python, каталог должен содержать файл с именем __init__.py .

Строковая функция - str () и repr ()

Существуют две функции, которые можно использовать для получения читаемого представления объекта.

repr(x) вызывает x.__repr__() : представление x . eval обычно преобразует результат этой функции обратно в исходный объект.

str(x) вызывает x.__str__() : человекочитаемая строка, описывающая объект. Это может привести к некоторым техническим деталям.

магнезии ()

Для многих типов эта функция пытается вернуть строку, которая даст объект с тем же значением при передаче в eval() . В противном случае представление представляет собой строку, заключенную в угловые скобки, которая содержит имя типа объекта вместе с дополнительной информацией. Это часто включает имя и адрес объекта.

ул ()

Для строк это возвращает строку. Разница между этим и представлением repr(object) заключается в том, что str(object) не всегда пытается вернуть строку, приемлемую для eval() . Скорее, его цель - вернуть печатную или «удобочитаемую» строку. Если аргумент не задан, это возвращает пустую строку, '' .

Пример 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

Пример 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)'

При написании класса вы можете переопределить эти методы, чтобы делать все, что хотите:

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)

Используя вышеприведенный класс, мы можем увидеть результаты:

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

Установка внешних модулей с помощью pip

pip - ваш друг, когда вам нужно установить любой пакет из множества вариантов, доступных в индексе пакета python (PyPI). pip уже установлен, если вы используете Python 2> = 2.7.9 или Python 3> = 3.4, загруженный с python.org. Для компьютеров под управлением Linux или другого * nix с собственным менеджером пакетов, pip часто должен быть установлен вручную.

В случаях, когда установлены оба Python 2 и Python 3, pip часто ссылается на Python 2 и pip3 на Python 3. Использование pip будет устанавливать пакеты только для Python 2, а pip3 будет устанавливать пакеты только для Python 3.

Поиск / установка пакета

Поиск пакета так же просто, как ввод текста

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

Установка пакета так же проста, как набирать (в терминале / командной строке, а не в интерпретаторе Python)

$ 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

где xxx - номер версии пакета, который вы хотите установить.

Когда ваш сервер находится за прокси-сервером, вы можете установить пакет, используя следующую команду:

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

Обновление установленных пакетов

Когда появляются новые версии установленных пакетов, они автоматически не устанавливаются в вашу систему. Чтобы узнать, какой из установленных пакетов устарел, запустите:

$ pip list --outdated

Чтобы обновить использование определенного пакета

$ pip install [package_name] --upgrade

Обновление всех устаревших пакетов не является стандартной функциональностью pip .

Модернизация

Вы можете обновить существующую установку на пике, используя следующие команды:

• В Linux или macOS X:

  $ pip install -U pip
  

  Возможно, вам понадобится использовать sudo with pip в некоторых Linux-системах

• В Windows:

  py -m pip install -U pip
  

  или же

  python -m pip install -U pip
  

Для получения дополнительной информации о пипе читайте здесь .

Установка Python 2.7.x и 3.x

Примечание . Следующие инструкции написаны для Python 2.7 (если не указано): инструкции для Python 3.x аналогичны.

WINDOWS

Сначала загрузите последнюю версию Python 2.7 с официального сайта ( https://www.python.org/downloads/) . Версия предоставляется как пакет MSI. Чтобы установить его вручную, просто дважды щелкните файл.

По умолчанию Python устанавливается в каталог:

 C:\Python27\

Предупреждение: установка автоматически не изменяет переменную среды PATH.

Предполагая, что ваша установка Python находится в C: \ Python27, добавьте это в свой PATH:

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

Теперь, чтобы проверить правильность установки Python, напишите в cmd:

python --version

Python 2.x и 3.x Side-By-Side

Чтобы установить и использовать оба Python 2.x и 3.x рядом с Windows-машиной:

1. Установите Python 2.x с помощью установщика MSI.

   • Убедитесь, что Python установлен для всех пользователей.
   • Необязательно: добавьте Python в PATH чтобы сделать Python 2.x доступным из командной строки с помощью python .

2. Установите Python 3.x с помощью соответствующего установщика.

   • Опять же, убедитесь, что Python установлен для всех пользователей.
   • Необязательно: добавьте Python в PATH чтобы сделать Python 3.x доступным из командной строки с помощью python . Это может переопределить настройки Python 2.x PATH , поэтому дважды проверьте свой PATH и убедитесь, что он настроен на ваши предпочтения.
   • Обязательно установите py launcher установку py launcher для всех пользователей.

Python 3 установит пусковую установку Python, которая может использоваться для запуска Python 2.x и Python 3.x взаимозаменяемо из командной строки:

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.
>>>

Чтобы использовать соответствующую версию pip для конкретной версии Python, используйте:

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

Последние версии CentOS, Fedora, Redhat Enterprise (RHEL) и Ubuntu поставляются с Python 2.7.

Чтобы установить Python 2.7 на Linux вручную, просто выполните следующие действия в терминале:

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

Также добавьте путь к новому питону в переменной среды PATH. Если новый python находится в /root/python-2.7.X тогда выполните export PATH = $PATH:/root/python-2.7.X

Теперь, чтобы проверить правильность установки Python, напишите в терминале:

python --version

Ubuntu (From Source)

Если вам нужен Python 3.6, вы можете установить его из источника, как показано ниже (Ubuntu 16.10 и 17.04 имеют версию 3.6 в универсальном репозитории). Ниже приведены шаги для Ubuntu 16.04 и более низких версий:

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

Macos

Как мы говорим, macOS поставляется с Python 2.7.10, но эта версия устарела и немного изменена из обычного Python.

Версия Python, поставляемая с OS X, отлично подходит для обучения, но это не хорошо для разработки. Версия, поставляемая с OS X, может быть устаревшей из официальной текущей версии Python, которая считается стабильной производственной версией. ( источник )

Установить Homebrew :

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

Установите Python 2.7:

brew install python

Для Python 3.x используйте команду brew install python3 .