Эта статья рассчитана как на новичков в программировании, так и на программистов, которые уже владеют каким-либо языком, но хотят освоить еще и Python. Также она пригодится тем, кто хочет освежить свои знания.
Мы разберем самые основы Python. Начнем с типов данных, а ближе к концу статьи затронем приведение типов и срезы. Также мы познакомимся с некоторыми основными концепциями программирования.
Итак, приступим!
Переменные
Переменные — это именованные участки памяти компьютера, в которых хранятся некоторые значения. Переменные могут хранить любой тип данных. Например, у нас есть пара значений — 10 и 20. Мы хотим их сложить и сохранить сумму для дальнейших операций. Давайте посмотрим, что нам нужно для этого сделать:
a = 10 # переменная a
b = 20 # переменная b
c = a + b # сумма а и b
Примечание редакции Pythonist: рекомендуем очень подробную статью об именах и присваивании значений — «Факты и мифы об именах и значениях в Python».
Типы данных
Тип данных — это атрибут, позволяющий компилятору понять, какие действия можно производить с переменной. В Python есть шесть основных типов данных — числа, строки, списки, кортежи, множества и словари.
Числа
В эту категорию попадают любые числа: целые, с плавающей точкой и комплексные. Чтобы узнать, к какому типу принадлежит число, мы можем воспользоваться функцией type().
a = 5
print(type(a))
# <class 'int'>
b = 1+4j
print(type(b))
# <class 'complex'>
c = 4.5
print(type(c))
# <class 'float'>
Посмотрите на вывод внимательно: класс int переменной a = 5 — предопределенный. Это значит, что его не нужно определять вручную, это уже сделано за нас. Целые числа (int) могут быть любой длины, но есть ограничение — объем вашей памяти. Числа с плавающей точкой (float) имеют ограничение точности — 15 знаков после точки. Если попытаетесь ввести больше — лишние будут отброшены.
a = 1.12345678912345678912
print(a)
# 1.1234567891234568
Строки
Строка (str) — это набор символов Юникод. Для определения строки мы используем одинарные или двойные кавычки.
Пример:
a = 'c'
print(type(a))
# <class 'str'>
b = "hello"
print(type(b))
# <class 'str'>
c = 'hello python'
print(type(c))
# <class 'str'>
Списки
Списки (list) — упорядоченная последовательность элементов. Это один из самых часто используемых типов данных в Python. Списки очень похожи на массивы, но в списках мы можем хранить элементы разного типа.
Списки изменяемы. Это означает, что мы можем изменить любое их значение при помощи индексов.
lst = [1,2,3,4,5.3]
print(type(lst))
# <class 'list'>
lst = [1,'hello',3,4,5.3,'pythonist']
print(type(lst))
# <class 'list'>
lst = ['hello','pythonist']
print(type(lst))
# <class 'list'>
lst = [1,'hello',3,4,5.3,'pythonist']
print(lst[0])
# 1
lst = [1,'hello',3,4,5.3,'pythonist']
lst[0]=10
print(lst)
# [10, 'hello', 3, 4, 5.3, 'pythonist']
Кортежи
Кортежи (tuple) — это также упорядоченные наборы элементов. От списков их отличает одно: кортежи неизменяемы. То есть, после объявления кортежа изменить его элементы мы не сможем.
Кортежи намного быстрее списков. Для получения доступа к элементам кортежа мы можем использовать индексы и срезы.
t = (1,2,3)
print(type(t))
# <class 'tuple'>
t = (1,'hello',3.2)
print(type(t))
# <class 'tuple'>
t = (1,'hello',3.2)
print(t[0])
# 1
Множества
Множество (set) — неупорядоченный набор элементов. Определяется множество с помощью фигурных скобок — {}. Все элементы разделяются запятыми.
В множестве не может быть дубликатов. Это значит, что порой их можно использовать для того, чтобы избавиться от повторяющихся элементов списке. С множествами мы можем производить самые разные операции, например, объединение (union), пересечение (intersection).
Обратите внимание: получить доступ к элементу множества по индексу невозможно — они не упорядочены!
a = {1, 2, 3, 4, 5}
print(type(a))
# <class 'set'>
a = {1, 2, 3, 4, 5}
print(a[0])
# TypeError: 'set' object is not subscriptable
a = {1, 2, 3, 4, 5}
b = {6,5,3,4}
print(a.union(b))
# {1, 2, 3, 4, 5, 6}
a = {1, 2, 3, 4, 5}
b = {6,5,3,4}
print(a.intersection(b))
# {3, 4, 5}
Словари
Словарь (dict) — набор элементов, в котором элементы хранятся в виде пар ключ-значение. Такая система оптимизирована под поиск значений, из-за чего словари часто используют для хранения огромных массивов данных. Определяются словари с помощью фигурных скобок в следующем виде — {ключ: значение}. Пары элементов отделяются запятыми.
dict = {'name':'ivan', 'number':'99029922', 'address':'Moskva'}
print(dict)
# {'name': 'ivan', 'number': '99029922', 'address': 'Moskva'}
print(dict.keys())
# dict_keys(['name', 'number', 'address'])
print(dict.values())
# dict_values(['ivan', '99029922', 'Moskva'])
Операторы
Операторы нужны для проведения операций между двумя элементами. Например, в a + b оператором является +. Он указывает компилятору на то, что нужно сложить две переменные.
В Python есть 7 типов операторов:
Арифметические операторы: *, +, /, **, %, —
Операторы присваивания: =, +=, =+, -=, -=, !=
Операторы сравнения: <, >, !<, !>, =<, >=, ==
Логические операторы: and, or, not
Операторы идентичности: is, is not
Операторы членства: in, not in
Битовые операторы: &, ^, ~, <<, >>
Индексы
Индексы используются для получения доступа к элементам коллекций (например, строк или списков). В Python есть два типа индексов — положительные и отрицательные. Положительные начинаются с 0, а отрицательные — с последнего элемента коллекции.
Пример:
# Положительные индексы
a = 56
print(a[0])
# TypeError: 'int' object is not subscriptable
b = 'python'
print(b[0])
# 'p'
c = 3.14
print(c[0])
# TypeError: 'float' object is not subscriptable
d = [1,2,'hello',4]
print(d[2])
# hello
print(d[2][1])
# e
print(d[2][4])
# o
d = [1,2,'hello',4]
print(d[-1])
# 4
print(d[2][-4])
# e
print(d[2][-1])
# o
str = "hello python"
print(str[-3])
# h
Срезы
Срезы используются для получения доступа к последовательности элементов коллекции. Внимание: верхняя граница всегда отбрасывается. То есть, a[0:3] — это элементы с индексами 0, 1 и 2, а вот элемент с индексом 3 в срез уже не войдет.
b = 'python'
print(b[0:2])
# py
d = [1,2,'hello',4]
print(d[0:2])
# [1,2]
print(d[2][1:4])
# 'ell'
print(d[2][1:-1])
# 'ell'
Функционал среза можно расширить, добавив третий параметр — шаг.
lst = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20]
print(lst[0:20:2])
# выводим все нечетные числа в промежутке от 0 до 20
print(lst[1:20:2])
# выводим все четные числа в промежутке от 0 до 20
strr = "hello python"
print(strr[0:8:4])
# ho
Приведение типов
Приведение типов позволяет сконвертировать один тип данных в другой. Это может оказаться полезным во многих ситуациях.
Пример:
a = 10
print(type(a))
# <class 'int'>
a = str(a)
print(type(a))
# <class 'str'>
a = float(a)
print(type(a))
# <class 'float'>
a = list(str(a))
print(type(a))
# <class 'list'>
print(a)
# ['1', '0', '.', '0']
lst = [1, 2, 3, 4, 5, 1, 2]
lst = set(lst)
print(type(lst))
# <class 'set'>
print(lst)
# {1, 2, 3, 4, 5}
lst = tuple(lst)
print(type(lst))
# <class 'tuple'>
print(lst)
# (1, 2, 3, 4, 5)
Выводы
В этой статье мы разобрали основы Python — самый необходимый минимум. Обратите внимание, что все в статье — обязательно к изучению, если вы новичок.