Изучите основы Python с нуля
за 1 час
Статья позволит вам довольно быстро погрузиться в основы Python. Материал полностью представлен в интерактивном редакторе кода — стремитесь изменять код примеров и запускать его.
Практика в программировании — самое главное.

Что такое Python?
Python известен как язык для разработки веб-приложений, автоматизации процессов и Data Science: машинного обучения, анализа и визуализации данных

Гвидо ван Россум, автор языка и великодушный пожизненный диктатор проекта, описывает Python следующими словами:
Это высокоуровневый язык программирования, философия проектирования которого ориентирована на читаемость кода и синтаксис, позволяющий программистам выражать концепции в нескольких строках кода
Гвидо ван Россум
Создатель Python
Основы Python
Hello, World!
Существует традиция начинать изучение нового язык программирования с «Привет, Мир!». Это программа, которая просто выводит надпись «Hello, World!». Не будем нарушать эту традицию и приступим к освоению Python.
# Выражение print выводит переданную строку print("Hello, World!")
Комментарии
Комментарии — пояснения к исходному коду программы. Они ни на что не влияют и используются программистами для объяснения неочевидных участков кода.
# Однострочные комментарии начинаются с решетки, после решетки можно писать любой текст. """ Бывают еще многострочные комментарии Много строчные комментарии обрамляются в тройные кавычки и чаще всего используются для документирования. """ # Попробуйте запустить этот код — ничего не произойдет, т.к. в нем только комментарии.
Примитивные типы данных и операторы
Тип данных характеризует одновременно:

  • множество допустимых значений, которые могут принимать данные, принадлежащие к этому типу;
  • набор операций, которые можно осуществлять над данными, принадлежащими к этому типу.
Примитивные типы Python включают в себя целые числа (integer) и числа с плавающей точкой (float), строки (string), булевые значения (boolean) и специальный тип None, означающий нейтральное или «нулевое».

Рассмотрим целые числа и математические операции над ними.
# Числа поддерживают базовые арифметические операции print(1 + 1) # => 2 print(8 - 1) # => 7 print(10 * 2) # => 20 print(35 / 5) # => 7.0
В программировании числа с плавающей точкой отличаются целых чисел по типам — в первом случае тип называется integer, во втором float. Это связано с особенностями работы процессора.

Python поддерживает деление с остатком ( косая черта / между числами) и без остатка (две косые черты // между числами).
# Отрицательные числа начинаются со знака минус # Выражение // делит положительные и отрицательные числа без остатка print(5 // 3) # => 1 print(-5 // 3) # => -2 print(5.0 // 3.0) # => 1.0 # Применимо и к числам с плавающей точкой (float) print(-5.0 // 3.0) # => -2.0 # Результатом деления с остатком будет числом с плавающей точкой (float) print(10.0 / 3) # => 3.3333333333333335
Рассмотрим оператор модуля и возведение числа в степень.

В Python оператор модуля — знак процента процента между чилами, дает остаток от левого значения, деленного на правое значение.

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

Как и в математике, в Python операции умножения и деления приоритетны перед операциями сложения и вычитания. Скобками можно управлять приоритетами.
# Оператор модуля; дает остаток от левого значения, деленного на правое значение print(7 % 3) # => 1 # Возведение в степень (x**y, x в степени y) print(2**3) # => 8 # Как и в математике, скобками обозначается приоритет операций print((1 + 3) * 2) # => 8
Существуют логические (или булевые, от англ. boolean) типы True (истина) и False (ложь).
# Логические значения как и числа являются примитивами # Значение ачинаются с большой буквы print(True) print(False) # not производит инверсию логических значений print(not True) # => False print(not False) # => True
Поддерживаются операторы and и or. Согласно булевой алгебре, and соответствует знаку умножения, а or знаку сложения и имеет соответствующие приоритеты.

По сути True — это единица (1), а False — это ноль (0).
# Помните, что "and" и "or" регистрозависимы print(True and False) # => False print(False or True) # => True # True и False соответствуют 1 и 0, но в другой нотации print(True + True) # => 2 print(True * 8) # => 8 print(False - 5) # => -5 # Операторы сравнения сравнивают числовое значение True и False print(0 == False) # => True print(1 == True) # => True print(2 == True) # => False print(-5 != False) # => True
Операторы сравнения сравнивают левое значение с правым. В случае, если условие сравнение выполняется, выражение возвращает True, иначе False.

Два знака равно (==) проверяет что левое выражение == равно правому. А восклицательный знак и равно (!=) проверяет что левое выражение != не равно правому.

Выражение больше (>) проверяет, что левое значение > больше правого.
Выражение меньше (<) проверяет, что левое значение < меньше правого.

Выражение больше или равно (>=) проверяет, что левое значение >= больше или равно правому.
Выражение меньше (<=) проверяет, что левое значение <= меньше или равно правому.

# Оператор сравнения "равно" (==) print(1 == 1) # => True print(2 == 1) # => False # Оператор сравнения "не равно" (!=) print(1 != 1) # => False print(2 != 1) # => True # Другие операторы сравнения print(1 < 10) # => True print(1 > 10) # => False print(2 <= 2) # => True print(2 >= 2) # => True
Операторы сравнения можно комбинировать с помощью and или or

# Проверка вхождения значений в множество print(1 < 2 and 2 < 3) # => True print(2 < 3 and 3 < 2) # => False # Связывания выглядит красивее print(1 < 2 < 3) # => True print(2 < 3 < 2) # => False
Помимо оператора сравнения == есть еще оператор is. Если оператор == проверяет равенство значений двух объектов, то оператор is проверяет идентичность самих объектов. Его используют, чтобы удостовериться, что переменные указывают на один и тот же объект в памяти.
# "is" проверяет, что две переменные ссылаются на один и тот же объект # тогда как "==" проверяет, что значения равны a = [1, 2, 3, 4] # Присвоим переменной a новый список: [1, 2, 3, 4] b = a # Присвоим переменной b ссылку объект переменной a print(b is a) # => True, a и b ссылаются на один и тот же объект print(b == a) # => True, значения в переменных a и b равны b = [1, 2, 3, 4] # Присвоим переменной b новый список: [1, 2, 3, 4] print(b is a) # => False, a и b ссылаются на разные объекты print(b == a) # => True, значения в переменных a и b равны
Строки (англ. string) в Python — упорядоченные последовательности символов, используемые для хранения и представления текстовой информации.

С помощью строк можно работать со всем, что может быть представлено в текстовой форме.
# Строки создаются с помощью одинарных (') или двойных (") кавычек print('Это строка.') print("Это тоже строка.") # Сложение строк называется конкатенацией. print("Hello " + "world!") # => "Hello world!" # Строковые литералы (но не переменные) могут конкатенироваться без знака сложения (+) print("Hello " "world!") # => "Hello world!"
Python позволяет работать со строками как со списками.

Списки мы рассмотрим немного позже, а сейчас рассмотрим примеры измерения длины строк и получения символа по номеру элемента в строке:
# Узнать длину строки len("Это строка") # => 10 # Строка может рассматриваться как список символов "Это строка"[0] # => 'Э'
Довольно часто возникают ситуации, когда нужно подставить в строку некоторые данные, полученные в процессе выполнения программы.

Такая подстановка называется форматированием строки.
# для форматирование строк используется метод .format print("{} могут быть {}".format("Строки", "интерполированы")) # => "Строки могут быть интерполированы" # Аргументы могут повторяться, у каждого есть свой номер print("Вот {1} построил {0}, {1} построил {0}, {1} построил {0}".format("Джек", "дом, который построил")) # => "Вот дом, который построил построил Джек, дом, который построил построил Джек, дом, который построил построил Джек" # Еще их можно именовать print("{name} хочет съесть {food}".format(name="Дима", food="краба")) # => "Дима хочет съесть краба"
В Python None дает нейтральное или «нулевое» поведение. В других языках программирования эквивалентом None часто выступает выражение null.

None — буквально означает «ничего».
# None это объект print(None) # => None # Не используйте сравнение по значению (==) для проверки объекта на None # Вместо сравнения по значению (==) используйте сравнение по объекту (is). print("тест" is None) # => False print(None is None) # => True
None, 0, пустые строки, списки, словари, кортежи эквивалентны False при приведении к логическому типу. Все остальное эквивалентно True.
# Выражение bool приводит значение в логический тип print(bool(0)) # => False print(bool("")) # => False print(bool([])) # => False print(bool({})) # => False print(bool(())) # => False
Переменные и коллекции
Переменная хранит данные. Название переменной в Python должно начинаться с алфавитного символа или со знака подчеркивания и может содержать алфавитно-цифровые символы и знак подчеркивания. По конвенции, переменную нужно именовать нижним_регистром_с_подчеркиваниями.
# Объявлять переменную в python не нужно, сразу назначайте значение some_var = 5 print(some_var) # => 5
Списки в Python позволяют хранить последовательности элементов произвольных типов. Объявлять список можно пустым или предзаполненным.
# Пустой список li = [] print(li) # => [] # Предзаполненный список other_li = [4, 5, 6] print(other_li) # => [4, 5, 6]
Python позволяет добавлять элементы в список и удалять их оттуда.
# Объявим пустой список li = [] # Добавим несколько элементов в конец списока li.append(1) # li равен [1] li.append(2) # li равен [1, 2] li.append(4) # li равен [1, 2, 4] li.append(3) # li равен [1, 2, 4, 3] print(li) # => [1, 2, 4, 3] # Удалим последний элемент из списка print(li.pop()) # => вернет 3, а li теперь равен [1, 2, 4] print(li) # => [1, 2, 4] # Вернем элемент обратно li.append(3) # li снова равен [1, 2, 4, 3] print(li) # => [1, 2, 4, 3]
Для обращения к элементам списка используются индексы, которые представляют номер элемента в списке. Индексы начинаются с нуля. Это означает, что первый элемент будет иметь индекс 0, а второй элемент — индекс 1. Для обращения к элементам списка с конца, используются отрицательные индексы, начиная с -1. То есть у последнего элемента будет индекс -1, у предпоследнего -2 и так далее.

Если обратиться по индексу к несуществующему элементу, python выкинет исключение IndexError.
# Объявление списка li = [1, 2, 4, 3] # К элементам списка можно обращаться как к массивам print(li[0]) # => 1 # Возьмем последний элемент print(li[-1]) # => 3 # Обращение к несуществующему элементу по индексу выкинет исключение IndexError li[4] # Исключение IndexError
Списки поддерживают слайсинг. Слайсинг в python позволяет получать диапазоны списка, при этом стартовый элемента индекса включен в результат, а конечный нет.
# Объявление списка li = [1, 2, 4, 3] # Взять элементы с первого индекса по третий print(li[1:3]) # => [2, 4] # Пропустить элемент первого индекса print(li[2:]) # => [4, 3] # Вернуть все до третьего индекса print(li[:3]) # => [1, 2, 4] # Взять каждый элементы списка с шагом два print(li[::2]) # =>[1, 4] # Вернуть развернутый список print(li[::-1]) # => [3, 4, 2, 1] # Можно использовать любую комбинацию # li[начало:конец:шаг]
Элементы из списка удаляются выражением del.

Выражение in в python позволяет проверить вхождение элемента в список.

Для определения длины списка необходимо воспользоваться функцией len.
# Объявим список li li = [1, 2, 4, 3] # Провка на вхождения элемента "1" в список print(1 in li) # => True # Узнать длину списка можно с помощью выражения "len()" print(len(li)) # => 4 # Удалить элемент можно с помощью выражения "del" del li[2] # теперь li равен [1, 2, 3] print(li) # => [1, 2, 3]
Списки в python содержат методы insert, remove, index и extend.

Метод insert позволяет вставить элемент в специфичное место (append добавляет элемент в конец списка). Метод remove удаляет элемент по индексу (так же как и del). Метод index позволяет найти индекс первого элемента по значению.

Списки можно конкатенировать (присоединять) с помощью метода extend, либо с помощью знака «+».
# Объявим список li и other_li li = [1, 2, 3] other_li = [4, 5, 6] # Удалим значение 2 из списка li.remove(2) # li теперь равен [1, 3] # Вставим элемент 2 в индекс 1 li.insert(1, 2) # li снова равен [1, 2, 3] again # Получим индекс первого найденого элемента print(li.index(2)) # => 1 # Списки можно складывать # Замечание: заначение li и other_li не изменятся. print(li + other_li) # => [1, 2, 3, 4, 5, 6] # Конкатенация списков методом "extend()" li.extend(other_li) # li равен [1, 2, 3, 4, 5, 6] print(li) # => [1, 2, 3, 4, 5, 6]
Кортежи в python похожи на списки, отличаются тем, что они неизменяемы (immutable) — то есть в кортеж нельзя добавить элемент или удалить его оттуда.
# Кортежи неизменяемые (immutable). Если попытаться добавить элемент в кортеж, возникнет исключение TypeError. tup = (1, 2, 3) print(tup[0]) # => 1 # Кортеж из одного элемента объявляется с запятой в конце, иначе интерпретатор посчитает, что это обычное значение print(type((1))) # => class 'int' print(type((1,))) # => class 'tuple' print(type(())) # => class 'tuple' # Кортежи позволяют производить большинство операций от списков print(len(tup)) # => 3 print(tup + (4, 5, 6)) # => (1, 2, 3, 4, 5, 6) print(tup[:2]) # => (1, 2) print(2 in tup) # => True
Кортежи в python похожи на списки, отличаются тем, что они неизменяемы — то есть в кортеж нельзя добавить элемент или удалить его оттуда.
# Кортежи неизменяемые (immutable). Если попытаться добавить элемент в кортеж, возникнет исключение TypeError. tup = (1, 2, 3) print(tup[0]) # => 1 # Кортеж из одного элемента объявляется с запятой в конце, иначе интерпретатор посчитает, что это обычное значение print(type((1))) # => class 'int' print(type((1,))) # => class 'tuple' print(type(())) # => class 'tuple' # Кортежи позволяют производить большинство операций от списков print(len(tup)) # => 3 print(tup + (4, 5, 6)) # => (1, 2, 3, 4, 5, 6) print(tup[:2]) # => (1, 2) print(2 in tup) # => True
Словари в Python — неупорядоченные коллекции произвольных объектов с доступом по ключу. В других языках программирования их ещё называют хеш-таблицами и ассоциативными массивами.
# Словарь можно объявить пустым empty_dict = {} print(empty_dict) # => {} # Или предзаполненным # one, two и three - ключи, а 1, 2 и 3 - значения filled_dict = {"one": 1, "two": 2, "three": 3} print(filled_dict) # => {"one": 1, "two": 2, "three": 3} # Поиск значение осуществляется с помощью [] print(filled_dict["one"]) # => 1
Обратите внимание, что ключи словарей должны быть неизменяемыми типами. Это связано с тем, что из ключа вычисляется хеш-значение. Неизменяемые типы включают в себя числа, строки и кортежи.
# Кортеж - неизменяемый тип, его можно использовать в качестве ключа valid_dict = {(1,2,3):[1,2,3]} # Values can be of any type, however. print(valid_dict) # => {(1,2,3):[1,2,3]} # А список - изменяемый, если попытаться использовать его в качестве ключа, возникнет ошибка TypeError invalid_dict = {[1,2,3]: "123"} # => TypeError: unhashable type: 'list'
Получить все ключи словаря в качестве итерируемого объекта можно с помощью метода "keys()". Чтобы получить список, нужно обернуть вызов в "list()". Мы рассмотрим итерируемые объекты позже.

Чтобы получить все значения словаря в качестве итерируемого объекта, нужно вызвать метод "values()". Аналогично, нужно обернуть вызов в "list()" чтобы получился список.
# Создадим заполненный словарь filled_dict = {"one": 1, "two": 2, "three": 3} # Получить список ключей словаря print(list(filled_dict.keys())) # => ["three", "two", "one"] # Получить список значений словаря print(list(filled_dict.values())) # => [3, 2, 1]
Проверить вхождение ключа в словарь можно с помощью оператора in, алогично проверке вхождения значения в список.
# Создадим заполненный словарь filled_dict = {"one": 1, "two": 2, "three": 3} # Ключ "one" существует в списке filled_dict, а "1" - нет print("one" in filled_dict) # => True print(1 in filled_dict) # => False
Если попытаться получить несуществующий ключ с помощью нотации [], то Python выкинет исключение KeyError.
# Создадим заполненный словарь filled_dict = {"one": 1, "two": 2, "three": 3} # Ключ "four" отсутствует в filled_dict filled_dict["four"] # KeyError
Чтобы исключение KeyError не возникало при получении значения по несуществующему ключу словаря, можно получить значение по ключу с помощью метода "get()".

По-умолчанию, метод get словаря возвращает None, если ключ не найден. Значение по-умолчанию можно изменить.
# Создадим заполненный словарь filled_dict = {"one": 1, "two": 2, "three": 3} # Используете метод "get()" чтобы исключить KeyError print(filled_dict.get("one")) # => 1 print(filled_dict.get("four")) # => None # Метод "get()" позволяет изменить значение по-умолчанию для случаев, когда ключ не существует в словаре print(filled_dict.get("one", 4)) # => 1 print(filled_dict.get("four", 4)) # => 4
Добавить значение в словарь можно с помощью нотации [], либо метода update.

Удалить значение словаря по ключу в python можно с помощью выражения del.
# Создадим заполненный словарь filled_dict = {"one": 1, "two": 2, "three": 3} # Добавление значение в список filled_dict.update({"four":4}) # => {"one": 1, "two": 2, "three": 3, "four": 4} filled_dict["four"] = 4 # Второй способ добавить значение в список # Теми же методами можно изменять значение в словаре по ключу filled_dict["two"] = 20 # => {"one": 1, "two": 20, "three": 3, "four": 4} filled_dict.update({"three":40}) # => {"one": 1, "two": 20, "three": 30, "four": 4} # Удаление ключа из словаря del del filled_dict["one"] # Удаляет ключ "one" из filled_dict print(filled_dict) # => {"two": 20, "three": 30, "four": 4}