Введение

Примеры

Начало работы

Python - это широко используемый язык программирования высокого уровня для программирования общего назначения, созданный Гвидо ван Россумом и впервые выпущенный в 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 3 *, и это ваша версия по умолчанию (подробнее см. [** Устранение неполадок **] [1]), вы должны увидеть что-то вроде этого:  $ python - версия Python 3.6.0

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

$ python - версия Python 2.7.13

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

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

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

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

  • Откройте IDLE в вашей системе выбора.
  • Это откроет оболочку с параметрами в верхней части.

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

>>>

 

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

>>> печать ( "Hello, World") Нажмите Enter.  >>> print ("Hello, World") Hello, World ## Hello World Python file Создайте новый файл `hello.py`, который содержит следующую строку:  печать («Привет, мир»)   Вы можете использовать функцию Python 3 `print` в Python 2 со следующим оператором` import`: from __future__ import print_function Python 2 имеет ряд функций, которые могут быть дополнительно импортированы из Python 3 с помощью модуля `__future__`, как обсуждалось [обсуждалось здесь] [3].

При использовании Python 2 вы также можете ввести строку ниже. Обратите внимание, что это недопустимо в Python 3 и, следовательно, не рекомендуется, потому что это уменьшает совместимость кода между версиями.

print 'Hello, World'
 

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

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

$ python hello.py Привет, мир

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

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

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

При выполнении (запуск) python команды в терминале, вы с интерактивной оболочкой Python. Это также известно как Python интерпретатора или РЕПЛ (для «Read Оценивать Loop Print»).

$ python Python 2.7.12 (по умолчанию, 28 июня 2016 г., 08:46:01) [GCC 6.1.1 20160602] в linux Для получения дополнительной информации введите «help», «copyright», «credits» или «license».

>>> print 'Hello, World'
Hello, World
>>>
 

Если вы хотите запустить Python 3 с вашего терминала, выполните команду python3 .

$ python3 Python 3.6.0 (по умолчанию, 13 января 2017 г., 00:00:00) [GCC 6.1.1 20160602] в linux Для получения дополнительной информации введите «help», «copyright», «credits» или «license».

>>> print('Hello, World')
Hello, World
>>>
 

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

В командной строке запустите:

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

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

>>> exit()

 

или же

>>> quit()

 

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

Если вы хотите , чтобы отменить команду вы в середине набора текста и вернуться к командной строке чистой, находясь внутри интерпретатора оболочки, используйте сочетание клавиш 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 - Простой и легкий в использовании IDE , которая показывает время выполнения

Запускать команды в виде строки

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

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

 

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

Раковины и дальше

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

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

Программы - Для длительного хранения можно сохранить содержимое в .py файлы и редактировать / выполнять их в виде сценариев или программ с внешними инструментами , например , оболочки, Иды (например , как 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

 
  1. Остальная часть имени вашей переменной может состоять из букв, цифр и символов подчеркивания.
has_0_in_it = "Still Valid" 

 
  1. Имена чувствительны к регистру.
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.

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

То есть:

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 ("Как тебя зовут?") # Out: Как тебя зовут? _> ** Замечание по безопасности ** Не используйте `input ()` в Python2 - введенный текст будет оцениваться так, как если бы он был выражением Python (эквивалентно `eval (input ())` в Python3), что может легко стать уязвимым. См. [Эту статью] [2] для получения дополнительной информации о рисках использования этой функции.  name = input ("Как тебя зовут?") # Out: Как тебя зовут? _

В оставшейся части этого примера будет использоваться синтаксис 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



 

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

IDLE - Python GUI

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 переменной включить каталог вашей установки 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 переменной окружения.

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

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

Arch Linux

По умолчанию Python на Arch Linux (и потомков) является Python 3, поэтому используйте python или python3 для 3.x на Python и 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 : число Integer

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

 

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

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

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

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

complex : Комплексные числа

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

< , <= , > И >= операторы поднимут TypeError исключение , когда любой операнд является комплексным числом. ## Струны

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

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

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

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

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

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

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

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

Не хаси; изменчивый.

set : неупорядоченная коллекция уникальных значений. Детали должны быть hashable .

 a = {1, 2, 'a'} 

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

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

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

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

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

a = Нет # Значение не будет назначено. Любой действительный тип данных может быть назначен позже

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

В питоне, мы можем проверить тип данных объекта , используя встроенную функцию 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() следующим образом: Различия между 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' : Результаты 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 точку на новый объект.

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

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

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

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

  • bytearray
  • list
  • set
  • dict

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

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

 >>> pow(2,3)    #8

 

Чтобы проверить встроенную функцию в Python можно использовать dir(). как правило 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.


 

Встроенный в модулях содержит дополнительный пример functionalities.For , чтобы получить квадратный корень из числа , мы должны включить 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'
 

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

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

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

Python 3 запрещает смешивать использование табуляции и пробелов для отступа. В таком случае генерируется ошибка времени компиляции: Inconsistent use of tabs and spaces in indentation и программа не будет работать.

Python 2 позволяет смешивать табуляцию и пробелы в отступе; это настоятельно не рекомендуется. Символ табуляции завершает предыдущий отступ быть кратным 8 пространств . Так как он является общим , что редактора сконфигурированы так, чтобы показать вкладки , как кратное 4 пробела, то это может привести к тонким ошибкам.

Приводя PEP 8 :

Многие редакторы имеют конфигурацию «табуляции в пробелы». При настройке редактора, следует различать символ табуляции ( «\ т») и клавишу 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 модуль в стандартной библиотеке 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')

 

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

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

 

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

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


 

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

 >>> help(math)
 

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

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

И теперь вы получите список доступных методов в модуле, но только после того, как вы его импортировали.

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

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

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

Модуль может быть создан путем создания .py файла.

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

 

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

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

 $ 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!"

 

Если модуль находится внутри директории и должен быть обнаружен питон, каталог должен содержать файл с именем __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 является вашим другом , когда вам нужно установить любой пакет из множества вариантов , доступных в индексе питона пакета (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 .

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

Вы можете обновить существующую установку pip с помощью следующих команд

В Linux или macOS X:

 $ pip install -U pip 

Вы , возможно , придется использовать sudo с пипс на некоторых системах 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 бок о бок

Чтобы установить и использовать Python 2.x и 3.x параллельно на компьютере с Windows:

Установите Python 2.x, используя установщик MSI.

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

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. Если новый питон в /root/python-2.7.X затем запустить export PATH = $PATH:/root/python-2.7.X

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

 python --version

 

Ubuntu (из источника)

Если вам нужен 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 вместо этого.

Синтаксис

Параметры

Примечания