4. Основы Python
Данный раздел разделен на несколько частей(каждый пункт - это ссылка на соответствующий раздел):
Переход по внутренним ссылкам происходит только при открытом разделе блока в котором находится ссылка.
- Основы Python
- Типы данных в Python
Нажать, чтобы раскрыть
Переменная в Python - это контейнер для хранения данных. Она является именованным местом в памяти, в котором хранится значение. В Python переменные создаются при присваивании значения и уничтожаются, когда они больше не используются.>>> a = 5
>>> b = "Hello"
>>> c = 5.0В Python переменные не требуется объявлять, они создаются при первом присваивании значения. Тип переменной определяется автоматически во время выполнения программы.
>>> a = 5
>>> print(type(a))
<class 'int'>
>>> b = "Hello"
>>> print(type(b))
<class 'str'>
>>> c = 5.0
>>> print(type(c))
<class 'float'>
>>> d = True
>>> print(type(d))
<class 'bool'>
>>> e = None
>>> print(type(e))
<class 'NoneType'>
>>> f = [1, 2, 3]
>>> print(type(f))
<class 'list'>
>>> g = (1, 2, 3)
>>> print(type(g))
<class 'tuple'>
>>> h = {1, 2, 3}
>>> print(type(h))
<class 'set'>
>>> i = {"a": 1, "b": 2, "c": 3}
>>> print(type(i))
<class 'dict'>Также в Python существует возможность одновременного присваивания нескольких переменных:
>>> a, b, c = 5, "Hello", 5.0Имена переменных в Python могут содержать буквы, цифры и символ подчеркивания, но не могут начинаться с цифры. Имена переменных чувствительны к регистру, то есть a и A - это разные переменные.
>>> a = 5
>>> A = 10Имена переменных не могут быть ключевыми словами Python, такими как if, else, for, while, break, continue, class, def, return, import, from, as, with, try, except, finally, raise, assert, global, nonlocal, lambda, and, or, not, is, in, None, True, False, del, pass, yield, async, await, elif, else, except, finally, for, from, global, if, import, in, is, lambda, nonlocal, not, or, pass, raise, return, try, while, with.
>>> if = 5 # ОшибкаИмена переменных в Python обычно пишутся в нижнем регистре, а слова разделяются символом подчеркивания. Это называется стилем snake_case. Данные рекомендации описаны в PEP 8 - руководстве по написанию кода на Python. Ссылка на PEP 8: https://www.python.org/dev/peps/pep-0008/
>>> my_variable = 5В Python нет специального синтаксиса для объявления констант, но общепринятой практикой является использование имен переменных в верхнем регистре для обозначения констант.
>>> PI = 3.14
>>> GRAVITY = 9.8Нажать, чтобы раскрыть
Для ввода данных в Python используется функция input().
>>> name = input()
>>> print("Hello, " + name)Функция input() выводит сообщение, которое передается в качестве аргумента, и ждет, пока пользователь введет данные с клавиатуры. После этого она возвращает введенные данные в виде строки. Если необходимо ввести данные определенного типа, то их можно привести к нужному типу с помощью функций int(), float(), bool().
>>> age = input("Enter your age: ")
>>> print("You are " + age + " years old.")Нажать, чтобы раскрыть
Для вывода данных в Python используется функция print().
>>> print("Hello, World!")Функция print() может принимать несколько аргументов и выводить их через пробел.
>>> print("Hello", "World!")
Hello World!Функция print() также может принимать именованные аргументы, такие как sep и end.
>>> print("Hello", "World!", sep=", ", end="!")
Hello, World!! sep - это разделитель между аргументами, по умолчанию это пробел. End - это символ, который будет добавлен в конце вывода, по умолчанию это символ новой строки.
sep может быть любым символом, например, запятой, пробелом, точкой и т.д.
#for formatting a date
>>> print('09','12','2016', sep='-')
09-12-2016
>>> print('practik','python', sep='@')
practik@pythonend может быть любым символом, например, пробелом, точкой, восклицательным знаком и т.д.
>>> print('practik','words', sep='_', end='@')
practik_words@Нажать, чтобы раскрыть
Операторы в Python - это символы, которые выполняют операции над переменными и значениями. Например, + - это оператор сложения, - - оператор вычитания, * - оператор умножения, / - оператор деления, // - оператор целочисленного деления, % - оператор остатка от деления, ** - оператор возведения в степень.
>>> a = 5
>>> b = 2
>>> print(a + b)
7
>>> print(a - b)
3
>>> print(a * b)
10
>>> print(a / b)
2.5
>>> print(a // b)
2 (целочисленное деление. Возвращает целую часть от деления(сколько раз b влезет в a))
>>> print(a % b)
1 (остаток от деления. Возвращает остаток от деления a на b(сколько останется после деления a на b))
>>> print(a ** b)
25 (возведение в степень. Возводит a в степень b(в данном случае 5 возводится в степень 2(умножается само на себя 2 раза)))Операторы сравнения в Python - это символы, которые используются для сравнения двух значений. Они возвращают булево значение True или False.
>>> a = 5
>>> b = 2
>>> print(a > b)
True
>>> print(a < b)
False
>>> print(a >= b) # (больше или равно)
True
>>> print(a <= b) # (меньше или равно)
False
>>> print(a == b) # (равно. Важно отметить, что для сравнения используется двойное равно)
False
>>> print(a != b) # (не равно. Важно отметить, что для сравнения используется восклицательный знак(знак отрицания) и равно)
True Логические операторы в Python - это операторы, которые используются для комбинирования условий. Они возвращают булево значение True или False.
>>> a = 5
>>> b = 2
>>> print(a > 3 and b > 1) #(и. Возвращает True, если оба условия истинны)
True
>>> print(a > 3 or b > 3) # (или. Возвращает True, если хотя бы одно условие истинно)
True
>>> print(not (a > 3 and b > 1)) # (не. Возвращает True, если условие ложно)
False
Последнее выражение можно переписать так:
>>> print(not True)
FalseЕсли в выражении указано and , то оба условия должны быть истинными, чтобы результат был истинным. Если в выражении указано or, то хотя бы одно условие должно быть истинным, чтобы результат был истинным. Если в выражении указано not, то результат будет противоположным.
Если в выражении указано or, то хотя бы одно условие должно быть истинным, чтобы результат был истинным. Если в выражении указано not, то результат будет противоположным.
Операторы присваивания в Python - это операторы, которые используются для присваивания значения переменной.
>>> a = 5 # Присваивание значения переменной
>>> a += 5 # Присваивание суммы переменной
полная форма a = a + 5
>>> a -= 5 # Присваивание разности переменной
полная форма a = a - 5
>>> a *= 5 # Присваивание произведения переменной
полная форма a = a * 5
>>> a /= 5 # Присваивание частного переменной
полная форма a = a / 5
>>> a //= 5 # Присваивание целочисленного деления переменной
полная форма a = a // 5
>>> a %= 5 # Присваивание остатка от деления переменной
полная форма a = a % 5
>>> a **= 5 # Присваивание возведения в степень переменной
полная форма a = a ** 5Также есть моржовый оператор :=, который используется для присваивания значения переменной. В том же выражении, в котором она используется.
>>> a = 5
>>> print(b := a + 5)
10
# Пример использования в разных выражениях
>>> print((a := 5) + (b := 5))
10
>>> print(a)
5
>>> print(b)
5При попытке использовать обычный оператор присваивания в выражении, возникнет ошибка:
>>> print(a = 5 + 5) # Ошибка синтаксиса, так как оператор присваивания не возвращает значение. А вот моржовый оператор возвращает значение переменной.
TypeErrorНажать, чтобы раскрыть
Python является языком с динамической типизацией, что означает, что тип переменной определяется во время выполнения программы, а не во время компиляции. Это означает, что переменная может содержать любой тип данных, и его тип может изменяться во время выполнения программы.>>> a = 5
>>> a = "Hello"Python является языком с сильной типизацией, что означает, что переменная имеет строго определенный тип данных и не может быть изменена на другой тип данных без явного преобразования.
>>> a = 5
>>> b = "Hello"
>>> c = a + b # ОшибкаНажать, чтобы раскрыть
Целые числа в Python, это числа без дробной части. Они могут быть положительными или отрицательными. Например, 2, -2, 0, 1000.
Целые числа в Python задаются следующим образом:
>>> number = 123Python, так же как и любой другой язык программирования, позволяет работать с целыми числами и совершать операции между ними. Базовые операции с целыми числами в Python выглядят следующи образом:
# Сложение
>>> number = 123 + 321
# Вычитание
>>> number = 123 - 321
# Деление
>>> number = 123 / 321
# Целочисленное деление (возвращает целую часть от деления)
>>> number = 123 // 321
# Остаток от деления (возвращает остаток от деления)
>>> number = 123 % 321
# Умножение
>>> number = 123 * 321
# Возведение в степень (возводит число в степень)
>>> number = 123 ** 321
# Математические выражение выполняются по правилам арифметики (сначала умножение и деление, потом сложение и вычитание), но при необходимости можно использовать скобки для изменения порядка выполнения операций.
>>> number = (123 + 321) * 213Для того чтобы записать в двоичной системе, необходимо использовать префикс 0b:
>>> number = 0b1010 # (это число в десятичной системе равно 10)Для того чтобы записать в восьмеричной системе, необходимо использовать префикс 0o:
>>> number = 0o12 # (это число в десятичной системе равно 10)Для того чтобы записать в шестнадцатеричной системе, необходимо использовать префикс 0x:
>>> number = 0xA # (это число в десятичной системе равно 10)Дробные числа это числа с дробной частью. Они могут быть положительными или отрицательными. Например, 2.6, -2.0, 0.0, 1000.0. И записываются с помощью точки. Дробные числа в Python задаются следующим образом:
>>> number = 123.321Дробные или вещественные числа в Python поддерживают те же операции, что и целые.
Важно отметить: Из-за особенности представления чисел в компьютере, вещественные числа могут быть неточными и приводить к ошибкам.
Пример:
>>> 0.1 + 0.2
0.30000000000000004Мы ожидали получить 0.3, но получили 0.30000000000000004. Это связано с тем, что вещественные числа в Python представлены в двоичной системе счисления и могут быть неточными. https://0.30000000000000004.com/ - сайт, который посвящен этой проблеме.
Модуль math(нажмите для открытия)
Модуль math содержит в себе большое количество функций для работы с числами и включает сложные математические операции.
Для того чтобы использовать функции из модуля math, его необходимо импортировать и можно использовать следующие вызовы:
>>> import math
# Вывод числа пи
>>> math.pi
# Возведение числа X в степень Y
>>> math.pow(X, Y)
# Факториал числа X
>>> math.factorial(X)
# Модуль числа X
>>> math.fabs(X)
# Округление X до ближайшего большего числа
>>> math.celi(X)
# Округление X вниз
>>> math.floor(X)Модуль random(нажмите для открытия)
Для генерации случайных данных можно использовать модуль `random`. Он содержит в себе большое количество функций для генерации случайных чисел, выбора случайных элементов из последовательности и т.д. Чтобы использовать функции из модуля `random`, его необходимо импортировать и можно использовать следующие вызовы:>>> import random
# Генерация случайного целого числа в диапазоне от 1 до 10
>>> a = random.randint(1, 10)Важно: Нужно помнить что в авто тестах использование случайных данных не рекомендуется, так как это может привести к непредсказуемому поведению тестов, так как мы не можем контролировать входные данные. Или же в случае использования случайных данных, их нужно контролировать, как например в случае генерации случайных чисел, но в заданном диапазоне. Это нужно для того чтобы тесты были предсказуемыми(что числа точно будут в данном диапазоне, а не в разброс от 1 до 10000000) и стабильными. Чтобы получить стабильные рандомные данные, нужно использовать seed, который будет генерировать одинаковые данные при каждом запуске тестов. Следующий пример показывает как использовать seed:
>>> import random
>>> random.seed(1) # В скобках указывается любое значение(число или строка), которое будет использоваться для генерации случайных чисел
>>> print(random.randint(1, 10))
3Модуль Faker(нажмите для открытия)
Модуль `Faker` позволяет генерировать случайные данные, такие как имена, адреса, тексты, числа и т.д. Это может быть полезно для генерации тестовых данных, например для тестирования форм, где нужно вводить данные пользователя. Для того чтобы использовать функции из модуля `Faker`, его необходимо импортировать и можно использовать следующие вызовы:>>> from faker import Faker
>>> fake = Faker()
# Генерация случайного имени
>>> fake.name()
'Maureen Guerrero'
# Генерация случайного адреса
>>> fake.address()
'651 Greg Station\nMurillotown, MN 66520'Функция round позволяет округлить число до заданного количества знаков после запятой. По умолчанию округление происходит до целого числа.
# Округление числа до целого
>>> round(1.5)
2
# Округление числа до 2 знаков после запятой
>>> round(1.333333, 2)
1.33Нажать, чтобы раскрыть
Строки в Python это последовательность символов, которые могут быть буквами, цифрами, знаками препинания и т.д и задаются с помощью кавычек. Строки в Python задаются одним из следующих образов:>>> s = "Python"
>>> s = 'Python'Кавычки могут быть одинарными, двойными или тройными. При этом важно чтобы открывающая и закрывающая кавычки были одинаковыми. При использовании одинарных кавычек в строке можно использовать двойные и наоборот.
>>> s = "I'm a string"
>>> s = 'I"m a string'Чтобы использовать одинарные и двойные кавычки в одной строке, можно использовать экранирование. Экранирование это специальные символы, которые обычно не могут быть использованы в строках. Пример использования экранирования:
>>> s = "I'm a string with \"quotes\""
>>> s = 'I"m a string with \'quotes\''Где \" и \' это экранированные символы, которые позволяют использовать кавычки в строке.
Многострочные строки можно задавать следующим образом:
>>> multiline_string = """first
second
third"""
>>> multiline_string = "first\nsecond\nthird"
>>> multiline_string = "first\n" \
"second\n" \
"third"Сырые строки это строки, в которых экранированные символы не обрабатываются и позволяют использовать специальные символы в строке.
Сырые строки задаются с помощью префикса r перед строкой:
s = r"I'm a string with \"quotes\""Или же с помощью экранирования:
>>> s = 'first \\nsecond \\nthird'Индексы в Python позволяют получать доступ к отдельным символам строки. Слайсы позволяют получать доступ к нескольким символам строки. Элементы строк в Python индексируются с нуля. Поэтому если необходимо получить из строки первый элемент, то запросить надо нулевой.
>>> s = "abcdefg"
>>> print(s[0])Также можно получить элементы с конца строки, используя отрицательные индексы:
>>> s = "abcdefg"
>>> print(s[-1])Важно: Индексы с конца строки начинаются с -1, что позволяет удобно получать элементы с конца строки. А индексы с начала строки начинаются с 0.
Также есть возможность получить не один символ из строки, а сразу несколько. При этом для этого в Python можно обойтись без циклов и воспользоваться встроенным решением.
>>> s[x:y:z]
"""
Где:
x — начальный индекс;
y — конечный индекс(не включительно);
z — шаг(по умолчанию 1).
"""Примеры:
>>> s = "abcdefg"
>>> print(s[0:3])
abc
>>> print(s[0:-1])
abcdef
>>> print(s[0:-1:2])
aceЗначение 0 в срезе можно опустить, так как оно подразумевается по умолчанию:
>>> s = "abcdefg"
>>> print(s[:3])
abcТакже можно получить все элементы строки с начала до конца:
>>> s = "abcdefg"
>>> print(s[:])
abcdefgМожно получить все элементы строки с конца до начала(перевернуть), в обратном порядке:
>>> s = "abcdefg"
>>> print(s[::-1])
gfedcbaВсе операции, которые можно совершать со строками доступны через точку после строки:
# Замена слов в строке
>>> "Hello, world!".replace("Hello", "Bye") # первый аргумент - что заменить, второй - на что заменить
Bye, world!
# Разделение строки
>>> "Hello, world!".split()
['Hello,', 'world!']
# Проверка начала строки
>>> "Hello, world!".startswith("Hello") # Возвращает True, если строка начинается с указанной подстроки
True
# Первый символ строки заглавный
>>> "hello, world!".capitalize()
Hello, world!
# Все символы заглавными буквами
>>> "hello, world!".upper()
HELLO, WORLD!
# Все символы строчными буквами
>>> "HELLO, WORLD!".lower()
hello, world!
# Проверка на то, что строка состоит только из букв
>>> "Hello, world!".isalpha()
False
# Проверка на то, что строка состоит только из цифр
>>> "123".isdigit()
TrueФорматирование в Python позволяет удобно склеивать строки и вставлять в них значения переменных. В Python есть несколько способов «склеивания» строк:
# Строки без переменных
>>> print("first " "second " "third ")
first second third
# Строки в переменных
>>> first = "first"
>>> second = "second"
>>> third = "third"
>>> print(first + second + third)
firstsecondthird
# С пробелами
>>> print(first + " " + second + " " + third)
first second thirdДля более удобной конкатенации («склеивания») строк в Python предусмотрены так называемые f-строки:
>>> first = "first"
>>> second = "second"
>>> third = "third"
# Без пробелов
>>> print(f"{fist}{second}{third}")
firstsecondthird
# С пробелами
>>> print(f"{first} {second} {third}")
first second thirdВнутри фигурных скобок можно вызывать функции и выполнять выражения:
>>> print(f"{first} {second} {third.upper()} {10 + 10}")
first second THIRD 20До появления f-строк в Python был доступен следующий способ форматирования(format):
>>> print("{} {} {}".format(first, second, third))
first second thirdf-строки это не замена, а удобная альтернатива методу format. У format есть свои преимущества в виде отложенного форматирования шаблона и возможности использовать именованные аргументы.
Данная конструкция позволяет вставлять значения переменных в строку в порядке их следования в методе format:
>>> print("{first} {second} {third}".format(first=first, second=second, third=third))
first second thirdТакже можно использовать метод format для вставки значений переменных в строку в порядке их следования в методе format:
>>> url_template = "https://yourserver.com/v1/api/{}"
>>> users_url = url_template.format("users")
>>> groups_url = url_template.format("groups")
>>> print(users_url)
https://yourserver.com/v1/api/users
>>> print(groups_url)
https://yourserver.com/v1/api/groupsДоступен и еще более старый способ форматирования, который иногда встречается в проектах:
>>> print("%s %s %s" % (first, second, third))
first second third>>> s = "123"
>>> n = 123
>>> assert s == n # Будет ошибка, так как типы разные
>>> assert s == str(n) # Переменную n приводим к строке и сравниваем. Будет истина, так как n приведено к строке
>>> assert int(s) == n # Переменную s приводим к числу и сравниваем. Будет истина, так как s приведено к числуПроверка на то, что переменная состоит только из цифр:
>>> s = "123"
>>> s.isdigit() # Если True, то переменная состоит только из цифр
TrueПроверка на то, что переменная состоит только из букв:
>>> s = "123ffsdfs"
>>> s.isalpha() # Если True, то переменная состоит только из букв
FalseНажать, чтобы раскрыть
Составные типы данных в Python это списки, кортежи, словари и множества. В данном разделе рассмотрим списки.
Списки в Python задаются с помощью квадратных скобок ([]). Содержимым списков могут быть любые типы данных и даже сами списки. При этом один список может содержать в себе сразу несколько типов данных.
>>> l = ["list", 123, 12.3, ["another_list", 321]]Пустой список задается следующим образом:
>>> l = []Также список можно задать следующим образом:
>>> l = list("first")
>>> print(l)
['f', 'i', 'r', 's', 't']Списки поддерживают индексы и слайсы, что позволяет удобно работать с их содержимым:
>>> l = ["first", "second", "third", ["another_list", 321]]
>>> print(l[0]) # Получение первого элемента
first
>>> print(l[0:2]) # Получение первых двух элементов
['first', 'second']
>>> print(l[-1]) # Получение последнего элемента
['another_list', 321]
>>> print(l[-1][0]) # Получение элемента из вложенного списка
another_listВажно учесть: У списков нет размерности, что позволяет удобно с ними работать. При этом надо внимательнее следить за размером содержимого списков. Нумерация списков начинается с нуля и списки поддерживают слайсы.
# Добавление элемента x в конец списка
>>> list.append(x)
# Расширение списка list элементами списка L
>>> list.extend(L)
# Вставка на i-ое место списка элемента x
>>> list.insert(i, x)
# Удаление первого элемента в списке со значением x
>>> list.remove(x)
# Возвращение количества элементов списка list со значением x
>>> list.count(x)
# Разворачивание списка в обратном порядке
>>> list.reverse()
# Очистка списка
>>> list.clear()
# Сортировка списка
>>> list.sort() # Сортирует список по возрастанию
>>> list.sort(reverse=True) # Сортирует список по убыванию
>>> len(list) # Возвращает длину спискаЧтобы удалить дубликаты из списка, можно воспользоваться множеством:
>>> l = [1, 2, 3, 4, 5, 5, 5, 5, 5]
>>> l = list(set(l)) # Удаляет дубликаты из списка, так как множество не содержит дубликатов. После чего преобразует множество обратно в список, но при этом порядок элементов может измениться
[1, 2, 3, 4, 5]Нажать, чтобы раскрыть
Множества в Python это неупорядоченные коллекции уникальных элементов.
Множества в Python задаются с помощью фигурных скобок ({}):
>>> s1 = {1, 2, 3, 4, 5}
>>> s2 = {1, 2, 3, 4, 5, 5, 5, 5, 5} # При этом все дубликаты будут удалены
>>> print(s2)
{1, 2, 3, 4, 5}Множества поддерживают операции объединения, пересечения и разности:
>>> s1 = {1, 2, 3, 4, 5}
>>> s2 = {4, 5, 6, 7, 8}
# Объединение множеств
>>> s3 = s1 | s2 или s1.union(s2)
>>> print(s3)
{1, 2, 3, 4, 5, 6, 7, 8}
# Пересечение множеств
>>> s3 = s1 & s2 или s1.intersection(s2)
>>> print(s3)
{4, 5}
# Разность множеств
>>> s3 = s1 - s2 или s1.difference(s2)
>>> print(s3)
{1, 2, 3}
>>> s1.intersection(s2) # Пересечение множеств
{4, 5}Нажать, чтобы раскрыть
Словари в Python представляют собой неупорядоченные коллекции произвольных объектов с доступом по ключу. Часто их называют хеш-таблицами или массивами.
Задать словарь можно следующим образом:
>>> d = {
"key": "value"
}Получать значения можно по ключу. Для этого достаточно обратиться к ключу:
>>> d = {
"name": "John",
"age": 30
}
>>> print(d["name"])
John
>>> print(d["age"])
30Также можно изменить значение по ключу:
>>> d = {
"name": "John",
"age": 30
}
>>> d["name"] = "Mike"
>>> print(d["name"])
MikeДобавить новую пару ключ-значение можно следующим образом:
>>> d = {
"name": "John",
"age": 30
}
>>> d["city"] = "New York"
>>> print(d)
{'name': 'John', 'age': 30, 'city': 'New York'}Удалить пару ключ-значение можно следующим образом:
>>> d = {
"name": "John",
"age": 30
}
>>> del d["name"]
>>> print(d)
{'age': 30}При работе с вложенными словарями можно использовать следующий синтаксис:
>>> d = {
"name": "John",
"age": 30,
"address": {
"city": "New York",
"street": "Broadway"
}
}
>>> print(d["address"]["city"])
New YorkМожно отдельно получить список ключей и значений, что позволяет удобно работать с ними:
>>> print(d.keys()) # Получение списка ключей
dict_keys(['name', 'age', 'address'])
>>> print(d.values()) # Получение списка значений
dict_values(['John', 30, {'city': 'New York', 'street': 'Broadway'}])
>>> print(d.list()) # Получение списка пар ключ-значение
dict_items([('name', 'John'), ('age', 30), ('address', {'city': 'New York', 'street': 'Broadway'})])Пары значений можно получить следующим образом:
>>> print(d.items()) # Получение списка пар ключ-значение в виде кортежей
dict_items([('name', 'John'), ('age', 30)])Можно проверить наличие ключа в словаре:
>>> d = {
"name": "John",
"age": 30
}
>>> print("name" in d)
True
>>> print("city" in d)
Falsepprint - библиотека для красивого вывода сложных структур данных.
Пример использования pprint:
user1 = {
"name": "Vasya",
"age": 18,
}
user2 = {
"name": "Petya",
"age": 20,
}
users = {25: user1, 42: user2, 55: {"name": "Oleg", "age": 25}}
from pprint import pprint
pprint(list(users.items()))
>>> d = {
"name": "John",
"age": 30
}
# Получение значения по ключу.
>>> print(d.get("name"))
John
# Получение значения по ключу, если его нет, то возвращает значение по умолчанию
>>> print(d.get("name", "Mike"))
John
# Получение значения по ключу, которого нет в словаре и вставка значения по умолчанию
>>> print(d.get("city", {"city": "New York"}))
{'city': 'New York'}
# Удаление пары ключ-значение по ключу. Возвращает значение по ключу
>>> print(d.pop("name"))
John
>>> print(d) # Что осталось в словаре после удаления
{'age': 30}
# Удаление всех пар ключ-значение
>>> print(d.clear())
None
>>> print(d)
{}
# Копирование словаря
>>> print(d.copy())
{'name': 'John', 'age': 30}
>>> print(d)
{'name': 'John', 'age': 30}
# Обновление словаря
>>> d.update({"name": "Mike"})
>>> print(d)
{'name': 'Mike', 'age': 30}Нажать, чтобы раскрыть
Списки, словари и множества являются изменяемыми объектами, что позволяет изменять их содержимое. Это означает, что при изменении списка, словаря или множества, изменения будут происходить в самом объекте, а не в его копии.
Следующий пример показывает, что при изменении списка, изменения происходят в самом списке:
>>> l1 = [1, 2, 3, 4, 5]
>>> l2 = l1
>>> l2.append(6)
>>> print(l1)
[1, 2, 3, 4, 5, 6]
>>> print(l2)
[1, 2, 3, 4, 5, 6]Также это относится и к словарям и множествам:
>>> d1 = {"name": "John", "age": 30}
>>> d2 = d1
>>> d2["city"] = "New York"
>>> print(d1)
{'name': 'John', 'age': 30, 'city': 'New York'}
>>> print(d2)
{'name': 'John', 'age': 30, 'city': 'New York'}>>> s1 = {1, 2, 3, 4, 5}
>>> s2 = s1
>>> s2.add(6)
>>> print(s1)
{1, 2, 3, 4, 5, 6}
>>> print(s2)
{1, 2, 3, 4, 5, 6}Чтобы создать копию списка, словаря или множества, можно использовать следующий синтаксис:
>>> l1 = [1, 2, 3, 4, 5]
>>> l2 = l1.copy()
>>> l2.append(6)
>>> print(l1)
[1, 2, 3, 4, 5]
>>> print(l2)
[1, 2, 3, 4, 5, 6]
>>> d1 = {"name": "John", "age": 30}
>>> d2 = d1.copy()
>>> d2["city"] = "New York"
>>> print(d1)
{'name': 'John', 'age': 30}
>>> print(d2)
{'name': 'John', 'age': 30, 'city': 'New York'}
>>> s1 = {1, 2, 3, 4, 5}
>>> s2 = s1.copy()
>>> s2.add(6)
>>> print(s1)
{1, 2, 3, 4, 5}
>>> print(s2)
{1, 2, 3, 4, 5, 6}Со вложенными списками, словарями и множествами ситуация несколько сложнее. При изменении вложенного объекта, изменения будут происходить в самом объекте, а не в его копии:
>>> l1 = [1, 2, 3, [4, 5, 6]]
>>> l2 = l1.copy()
>>> l2[3].append(7)
>>> print(l1)
[1, 2, 3, [4, 5, 6, 7]]
>>> print(l2)
[1, 2, 3, [4, 5, 6, 7]]Чтобы создать копию вложенного списка, словаря или множества, можно использовать следующий синтаксис:
>>> import copy
>>> l1 = [1, 2, 3, [4, 5, 6]]
>>> l2 = copy.deepcopy(l1)
>>> l2[3].append(7)
>>> print(l1)
[1, 2, 3, [4, 5, 6]]
>>> print(l2)
[1, 2, 3, [4, 5, 6, 7]]Нажать, чтобы раскрыть
Кортежи представляют собой списки, которые нельзя менять. Во многих случаях кортежи занимают меньше места в памяти, чем списки, а задаются следующим образом:
>>> t = (1, 2, 3, 4, 5)Над кортежами можно применять любые операции, не изменяющие список(например, получение элементов по индексу, слайсы и т.д).
При присвоении кортежа новой переменной, создается новый кортеж, а не его копия:
>>> t1 = (1, 2, 3, 4, 5)
>>> t2 = t1
>>> t2 += (6, 7, 8) # При этом создается новый кортеж, а не изменяется старый. Данный синтаксис эквивалентен t2 = t2 + (6, 7, 8)
>>> print(t1)
(1, 2, 3, 4, 5)
>>> print(t2)
(1, 2, 3, 4, 5, 6, 7, 8)Нажать, чтобы раскрыть
Frozenset это неизменяемое множество, которое задается следующим образом:
>>> f = frozenset([1, 2, 3, 4, 5])Frozenset поддерживает те же операции, что и множества, но при этом не поддерживает операции, которые изменяют множество.
Смотрите только когда не можете понять что делать(нажать, чтобы раскрыть)
В тесте test_random_list нужно создать список из 10 случайных чисел от 1 до 100 (включая обе границы) и отсортировать его по возрастанию.
def test_random_list():
"""
Создайте список из 10 случайных чисел от 1 до 100 (включая обе границы) и отсортируйте его по возрастанию.
"""
# TODO создайте список
l = []Чтобы не создавать дубли кода, и не писать вручную 10 раз:
l1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
l2 = [5, 7, 9, 12, 99, 66, 80, 39, 99, 100]
l3 = [4, 5, 9, 19, 20, 21, 22, 23, 24, 25]
l4 = [1, 88, 8, 66, 55, 44, 33, 22, 11, 10]
l5 = [70, 71, 72, 73, 74, 75, 76, 77, 78, 79]
l6 = [55, 59, 63, 67, 71, 75, 79, 83, 87, 91]
l7 = [4, 8, 12, 16, 20, 24, 28, 32, 36, 40]
l8 = [7, 14, 21, 28, 35, 42, 49, 56, 63, 70]
l9 = [99, 98, 97, 96, 95, 94, 93, 92, 91, 90]
l10 = [5, 15, 25, 35, 45, 55, 65, 75, 85, 95]Можно использовать функцию random.randint из модуля random как в примере ниже:
import random
def test_random_list():
"""
Создайте список из 20 случайных чисел от 5 до 200 (включая обе границы)
"""
# TODO создайте список
l = [random.randint(5, 200) for _ in range(20)]
print(l)
Результат:
[103, 199, 112, 15, 71, 135, 129, 108, 82, 127, 96, 154, 60, 134, 40, 77, 40, 198, 29, 163]Или можно использовать random.sample для получения уникальных случайных чисел: random.sample - это функция, которая возвращает список уникальных случайных чисел из диапазона.
import random
def test_random_list():
"""
Создайте список из 20 случайных чисел от 2 до 200 (включая обе границы)
"""
# TODO создайте список
l = random.sample(range(2, 201), 20) # Указано 201, так как второй аргумент всегда не включается(-1)
print(l)