Python AQA

Коллекции данных

Properties1
tagspython, collections, data-types

время чтения ~27 мин.

Коллекции данных

Списки, словари, кортежи, множества — создание, доступ к элементам, базовые операции.

Содержание:

  1. Индексы в питоне
  2. Методы и функции в пайтон
  3. Коллекции данных
  4. Оператор in в Python
  5. Практика

Индексы в питоне

Note

В Python индекс – это число, которое указывает позицию элемента в последовательности, такой как строка, список или кортеж. Индексы позволяют обращаться к конкретным элементам последовательности. Нумерация индексов начинается с нуля, что значит, что первый элемент находится на позиции 0, второй — на 1, и так далее.

Строки и базовые типы данных мы разбирали в 02.02 - Переменные и Типы данных.

Пример использования индексов:

Для строки:

 
text = "Python"
print(text[0])  # Выведет: 'P'
print(text[1])  # Выведет: 'y'

Отрицательные индексы

Отрицательные индексы позволяют обращаться к элементам с конца последовательности. Например, -1 указывает на последний элемент, -2 — на предпоследний и так далее.

 
text = "Python"
print(text[-1])  # Выведет: 'n'
print(text[-2])  # Выведет: 'o'

🧪 Практика

Example

в файлике “Python_base”

  • Задание#1

    Нужно протестировать как работают индексы

    text = "Написать свой текст" 
print(text[0])  
print(text[1]) 
 
Проверить что будет если мы выведем 6 индекс

    2 Отрицательные индексы

     
text = "Написать свой текст"
print(text[-1])  # Выведет: 'n'
print(text[-2])  # Выведет: 'o'
 
Проверить что будет если мы выведем -6 индекс

Методы и функции в пайтон

Note

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

Note

Функция или метод — это “инструмент”, который выполняет заранее заданное действие. Чтобы вызвать метод или функцию, нужно написать её имя и указать данные в круглых скобках (еще эти данные называют аргументами или параметрами), если они нужны.

Простой пример:

print() - мы уже не раз пользовались этой функцией - давай выведем основные моменты:

  • Используется, чтобы что-то вывести на экран.

  • Данные, которые нужно показать, пишутся в круглых скобках.

  • Пример:

    print("Привет!")  # Показывает текст "Привет!"

Note

Почему круглые скобки?

  • Скобки говорят Python, что нужно выполнить действие.

  • Если просто написать имя функции без скобок, ничего не произойдёт. Например:

    print  # Это просто показывает, что функция существует, но не запускает её.
print("Привет")  # А здесь функция запустится.

Когда мы будем проходить коллекции данных, в примерах и заданиях будут функции и методы отличающиеся от print(), которые надо будет вызвать

Давай разберемся в отличии метода от функции простым языком:

Note

Мы пишем имя функции и передаем внутрь нее аргумент. Этот аргумент может быть текстом/числом/переменной/выражением и тд. Пример: используемый нами ранее print()

Методы мы будем вызывать для конкретных переменных, это делается через символ . Давай рассмотрим на примере метод .upper() для типа данных str (string)

text = "текст"
text_up = text.upper()  # В переменную text_up мы кладем значение метода .upper()
print(text_up)  # Выведет "ТЕКСТ"

Давай рассмотрим пример еще одной функции - type() - она возвращает тип данных

text = "текст"
type_text = type(text)
print(type_text)
# Программа вернет "<class 'str'>", что означает тип данных string

Warning

Как видишь - метод произвел некоторые манипуляции и выдал результат. Важно понять - он это сделал не с самой переменной, а результат записал в новую переменную (в примере это text_up или type_text)

  • Если выведем переменную text - она останется той же самой: “текст”

То есть у метода/функции есть результат выполнения. Пока что нам этого будет достаточно

Практика 🧪

Example

В файлике “Пайтон бейз”

  • Задание №1:
    1. Сделай несколько переменных с различными типами данных (например int, float, bool)
    2. Выведи результат
  • Задание №2:
    1. Сделай переменную типа str
    2. Попробуй вывести на экран тип переменной, передав внутрь функции print() функцию type() с аргументом в виде переменной

Коллекции данных

Массивы в Python (Списки) list

Note

Массивов в классическом понимании в Python нет, но есть списки(list), которые выполняют аналогичную функцию — упорядоченную коллекцию элементов.

Для создания списка(list) применяются квадратные скобки [], внутри которых через запятую перечисляются элементы списка. Например, определим список строк

Тип данных список - на английском называется list

Создание списка

fruits = ["яблоко", "банан", "вишня"]

Note

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

numbers = [1, 2, 3, 4]

Note

Также для создания списка можно использовать функцию-конструктор list():

numbers1 = []
numbers2 = list()
 
'''Оба этих определения списка аналогичны - они создают пустой список'''

Отступление

Здесь следует сделать важное уточнение касательно создания новых списков из уже имеющихся. Если мы используем следующую конструкцию:

numbers1 = [1, 2, 3]
numbers2 = numbers1

в таком случае любое изменение numbers1 в последствии так же изменит и numbers2. Пока что запомним, что когда надо сделать новый список из существующего, мы будем использовать метод copy() или list(), например:

numbers1 = [1, 2, 3, 4, 5]
numbers2 = numbers1.copy()  # копирование
numbers3 = list(numbers1)  # создание на основе первого

Почему так происходит? Разберем в следующем модуле, пока что сфокусируемся на самих списках

Note

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

 
objects = [1, 2.6, "Hello", True]

Note

Для проверки элементов списка можно использовать стандартную функцию print, которая выводит содержимое списка в удобочитаемом виде:

 
numbers = [1, 2, 3, 4, 5]
people = ["Tom", "Sam", "Bob"]
print(numbers)  # [1, 2, 3, 4, 5]
print(people)   # ["Tom", "Sam", "Bob"]

Note

Конструктор list может принимать набор значений, на основе которых создается список:

 
numbers1 = [1, 2, 3, 4, 5]
numbers2 = list(numbers1)
print(numbers2)  # [1, 2, 3, 4, 5]
 
letters = list("Hello")
print(letters)      # ['H', 'e', 'l', 'l', 'o']

Обращение к элементам списка

Note

Для обращения к элементам списка надо использовать индексы, которые представляют номер элемента в списке. Индексы начинаются с нуля. То есть первый элемент будет иметь индекс 0, второй элемент - индекс 1 и так далее. Для обращения к элементам с конца можно использовать отрицательные индексы, начиная с -1. То есть у последнего элемента будет индекс -1, у предпоследнего -2 и так далее

people = ["Tom", "Sam", "Bob"]
'''получение элементов с начала списка'''
print(people[0])   # Tom
print(people[1])   # Sam
print(people[2])   # Bob
 
'''получение элементов с конца списка'''
print(people[-2])   # Sam
print(people[-1])   # Bob
print(people[-3])   # Tom

Note

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

people = ["Tom", "Sam", "Bob"]
people[1] = "Mike"  # изменение второго элемента
print(people[1])    # Mike
print(people)       # ["Tom", "Mike", "Bob"]

Сравнение списков

Note

Два списка считаются равными, если они содержат один и тот же набор элементов:

numbers1 = [1, 2, 3, 4, 5]
numbers2 = list([1, 2, 3, 4, 5])
assert numbers1 == numbers2, f"{numbers1} is not equal {numbers2}"

Основные методы работы со списками

Узнать длину списка

• len(list): возвращает длину списка

# len
my_list = [1, 2, "крыша", False]
length = len(my_list)
print(length)  # 4

Example

Повторите это в IDE

Добавление элемента

  • append(item): добавляет элемент item в конец списка
  • insert(index, item): добавляет элемент item в список по индексу index
  • extend(items): добавляет набор элементов items в конец списка
# append
fruits = ["яблоко", "банан", "вишня"]
fruits.append("апельсин")
print(fruits) # ["яблоко", "банан", "вишня", "апельсин"]
 
# insert
fruits = ['банан', 'яблоко']
fruits.insert(1, 'апельсин')
print(fruits)  # ['банан', 'апельсин', 'яблоко']
 
# extend
fruits = ['банан', 'яблоко']
fruits.extend(['груша', 'апельсин', 'вишня'])
print(fruits)  # ['банан', 'яблоко', 'груша', 'апельсин', 'вишня']

Example

Повторите это в IDE

Получение индекса элемента

• index(item): возвращает индекс элемента item. Если элемент не найден, генерирует исключение ValueError

# index
fruits = ['банан', 'яблоко', 'апельсин']
index = fruits.index('апельсин')
print(index)  # 2
 
###
 
fruits = ['банан', 'яблоко', 'апельсин']
index = fruits.index('такого элемента нет в списке')
print(index)
# ValueError: 'такого элемента нет в списке' is not in list

Example

Повторите это в IDE

Удаление элементов

  • remove(item): удаляет элемент item. Удаляется только первое вхождение элемента. Если элемент не найден, генерирует исключение ValueError
  • clear(): удаление всех элементов из списка
  • pop([index]): удаляет и возвращает элемент по индексу index. Если индекс не передан, то просто удаляет последний элемент (по идее “вытащить” из списка)
# remove
fruits = ['банан', 'яблоко', 'апельсин']
fruits.remove('банан')
print(fruits)  # ['яблоко', 'апельсин']
 
# clear
fruits = ['банан', 'яблоко', 'апельсин']
fruits.clear()
print(fruits)  # []
 
# pop
fruits = ['банан', 'яблоко', 'апельсин']
pop = fruits.pop(0)
print(fruits)  # ['яблоко', 'апельсин']
print(pop)  # банан

Example

Повторите это в IDE

Соединение списков

  • Для объединения списков применяется операция сложения (+):
fruits1 = ["яблоко", "банан"]
fruits2 = ["апельсин", "ананс"]
fruits3 = fruits1 + fruits2
print(fruits3)   # ["яблоко", "банан", "апельсин", "ананс"]

Note

Списки кроме стандартных данных типа строк, чисел, также могут содержать другие списки. Подобные списки можно ассоциировать с таблицами, где вложенные списки выполняют роль строк. Например:

fruits = [
    ["яблоко", "розовые"],
    ["апельсин", "цитрусовые"],
    ["ананас", "бромелиевые"]
]
 
print(fruits[0])  # ["яблоко", "розовые"]
print(fruits[0][0])  # яблоко
print(fruits[0][1])  # розовые

Note

Чтобы обратиться к элементу вложенного списка, необходимо использовать пару индексов: fruits[0][1] - обращение ко второму элементу первого вложенного списка

fruits = [
    ["яблоко", "розовые"],
    ["апельсин", "цитрусовые"],
    ["ананас", "бромелиевые"]
]
 
print(fruits[0])  # ["яблоко", "розовые"]
print(fruits[0][0])  # яблоко
print(fruits[0][1])  # розовые
 
fruits = [
    ["яблоко", "розовые"],
    ["апельсин", "цитрусовые"],
    ["ананас", "бромелиевые"]
]
 
# создание вложенного списка
new_fruit = list()
new_fruit.append("банан")
new_fruit.append("банановые")
# добавление вложенного списка
fruits.append(new_fruit)
 
print(fruits[-1])  # ["банан", "банановые"]
 
# добавление во вложенный список
fruits[-1].append("желтый")
 
print(fruits[-1])  # ["банан", "банановые", "желтый"]
 
# удаление последнего элемента из вложенного списка
fruits[-1].pop()
print(fruits[-1])  # ["банан", "банановые"]
 
# удаление всего последнего вложенного списка
fruits.pop(-1)

Example

Повторите это в IDE

🧪 Практическое задание

Example

Задание 1

  1. Есть два списка чисел: a = [1, 2, 3] и b = [4, 5, 6]. Нужно создать новый список c, который объединяет элементы из a и b.
  2. Убедиться, что длина нового списка равна сумме длин списков a и b. используя операцию сложения списков и метод assert.

Задание 2

  1. Дан список чисел numbers = [10, 20, 40, 50]
  2. Добавить число 30 между 20 и 40
  3. Вывести список при помощи print
  4. Очистить список полностью (удалить все элементы)

Задание 3

  1. Создать список, который содержит три других списка
    • [1, 2, 3]
    • ["a", "b", "c"]
    • [True, False]
  2. Извлечь второй элемент второго списка и убедитесь, что это “b”
  3. Удалите последний элемент первого списка и сохранить его в переменной last_item. Проверить, что last_item равен 3

Словари dict

Note

Словарь в Python — это Упорядоченная коллекция элементов, где каждый элемент хранится как пара ключ-значение

Внешне словарь напоминает JSON, но имеет отличия

Note

1️⃣

Форматирование

  • JSON:
    • Ключи и строки должны быть в двойных кавычках:{"name": "Alice"} (правильно).{'name': 'Alice'} (неправильно)
  • Словарь в Python:
    • Ключи и строки могут быть в одинарных или двойных кавычках:{'name': 'Alice'} или {"name": "Alice"} (оба правильно)

Note

2️⃣

Типы данных

  • JSON: Поддерживает только базовые типы:

    • string → строки
    • number → числа (целые и дробные)
    • boolean → true, false
    • null → None в Python
    • array → списки
    • object → словари

  • Словарь в Python:

    Помимо типов JSON, может содержать сложные типы Python:

    • Кортежи (tuple)
    • Множества (set)
    • Вложенные объекты Python, функции и тд — пока что мы это запомним, функции и кортежи со множествами мы рассмотрим в следующих темах

Основные методы работы со словарями

Создание словаря

Note

Определение словаря имеет следующий синтаксис: dictionary = { ключ1:значение1, ключ2:значение2, ....}

dictionary = {"имя": "Алиса", "возраст": 30}

Note

В фигурных скобках через запятую определяется последовательность элементов, где для каждого элемента сначала указывается ключ и через двоеточие его значение

То есть в словаре dictionary первый ключ “имя” имеет значение “Алиса”, элемент с ключом 2 “возраст” имеет значение 30

Мы можем также вообще определить пустой словарь без элементов:

objects = {}
objects = dict()

Tip

Так же как и со списками мы можем скопировать словарь из одного в другой при помощи метода copy()

Получение элементов словаря

  • Получение значения через ключ

    my_dict = {
	"name": "Alice", 
	"age": 25, 
	"city": "Phuket"
	}
 
# Получение значения по ключу
print(my_dict["name"])  # Вывод: Alice
print(my_dict["age"])   # Вывод: 25

  • С использованием метода get

Note

Метод get позволяет безопасно получить значение. Если ключ отсутствует, можно указать значение по умолчанию get(ключ, значение по умолчанию)

Если значение по умолчанию не задано - вернется None как результат метода get

```python
print(my_dict.get("name"))         # Вывод: Alice
print(my_dict.get("country", "USA"))  # Вывод: USA (значение по умолчанию)
```

Note

Преимущество get: использование этого метода не вызовет ошибку, если ключ отсутствует.

```python
print(my_dict.get("unknown"))  # Вывод: None
print(my_dict["unknown"])      # Ошибка: KeyError
```

Изменение и добавление элемента в словарь

Note

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

my_dict = {"name": "Alice", "age": 25}
 
# Добавление нового элемента
my_dict["city"] = "New York"
print(my_dict)  # Вывод: {'name': 'Alice', 'age': 25, 'city': 'New York'}

Warning

Если ключ уже существует, то значение будет перезаписано

Удаление элемента

Note

  • pop(item) - удаляет элемент по ключу и возвращает его значение
  • del - оператор, который удалит из словаря пару ключ-значение по ключу (или весь словарь можно удалить не передавая параметр ключа)
  • clear - удаляет все элементы словаря
my_dict = {"name": "Alice", "age": 25, "city": "New York"}
 
# **pop**
removed_value = my_dict.pop("age")
print(removed_value)  # Вывод: 25
print(my_dict)        # Вывод: {'name': 'Alice', 'city': 'New York'}
 
# del
del my_dict["city"]
print(my_dict)  # Вывод: {'name': 'Alice'}
 
# clear
my_dict.clear()
print(my_dict)  # Вывод: {}

Объединение словарей

Note

  • оператор | объединит 2 словаря
  • update - метод объединяющий 2 словаря в один (аналогично как и оператор | )
dict1 = {"name": "Alice", "age": 25}
dict2 = {"city": "New York", "age": 30}
 
result = dict1 | dict2
print(result)  # Вывод: {'name': 'Alice', 'age': 30, 'city': 'New York'}

Note

Если при объединении будет передан ключ который есть в исходном словаре - он будет перезаписан. Как видно на примере значение ключа “age” было перезаписано.

Warning

Исходные словари остаются неизменными.

dict1 = {"name": "Alice", "age": 25}
dict2 = {"city": "New York", "age": 30}
 
dict1.update(dict2)
print(dict1)  # Вывод: {'name': 'Alice', 'age': 30, 'city': 'New York'}

Вложенные словари

Note

Кроме простейших объектов типа чисел и строк словари также могут хранить и более сложные объекты - те же списки, кортежи или другие словари:

users = {
    "Alice": {
        "phone": "+971478745",
        "email": "alice12@gmail.com"
    },
    "Bob": {
        "phone": "+876390444",
        "email": "bob@gmail.com",
        "skype": "bob123"
    }
}

Note

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

Note

Для обращения к элементам вложенного словаря соответственно необходимо использовать два ключа:

extracted_email = users["Alice"]["email"]
print(extracted_email)  # alice12@gmail.com

Важно! про ключи словаря

Словарь в Python хранит пары «ключ → значение». Мы уже использовали строки в качестве ключей

{'строка': 'значение'}

Чаще всего и будем пользоваться строками, НО Python позволяет использовать в качестве ключей не только строки. Главное правило:

Ключ словаря должен быть хешируемым и неизменяемым объектом (immutable)

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

  • Можно использовать как ключи НЕизменяемые:
    • str int, float; и tuple (если внутри них только неизменяемые объекты)
  • Нельзя использовать как ключи изменяемые:
    • list set dict и любые другие изменяемые объекты

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

bad_dict = {
    [1, 2, 3]: "numbers"
}
 
# Вывод интерпретатора -> TypeError: unhashable type: 'list'

🧪 Практика

Example

Задание 1

  1. Создай словарь со своими персональными данными (допустим анкету) который будет содержать имя, возраст, имейл.
  2. Попробуй скопировать его методом copy() в другую переменную
  3. При помощи assert сравни оба словаря и проверь результат работы программы

Задание 2

  1. В созданном раннее словаре добавь новую пару ключ-значение - свой номер телефона
  2. Выведи результат полученный номер телефона в консоль при помощи print()
  3. после этого перезапиши значение этого элемента сделав его отфильтрованным 🍻 (добавь символы * что бы персональные данные были скрыты. Например: 797*****33

Задание 3

  1. Создать второй словарь, который будет вложенным, где будет находиться информация о твоем месте жительства (можно фейково) Например:
residence = {
    "residence": {
        "country": "Thailand",
        "city": "Phuket",
        "district": "Thalang"
    }
}
  1. Объедини списки, добавив в анкету о себе информацию о месте жительства
  2. После этого выведи город (или другой созданный элемент) из вложенного списка который мы добавили к первому

Кортежи tuple

Note

Кортеж — это неизменяемая упорядоченная коллекция элементов. Похож на список, но не позволяет изменять элементы после создания.

Создание кортежа

Note

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

my_tuple = (1, 2, 3)
print(my_tuple)  # (1, 2, 3)

Note

Также для определения кортежа мы можем просто перечислить значения через запятую без применения скобок:

my_tuple = 1, 2, 3
print(my_tuple)  # (1, 2, 3)

Note

Если вдруг кортеж состоит из одного элемента, то после единственного элемента кортежа необходимо поставить запятую и убедиться, что переменная имеет тип tuple

my_tuple = (1,)
print(type(my_tuple))  # <class 'tuple'>

Note

Для создания пустого кортежа достаточно передать круглые скобки

empty_tuple = ()
print(empty_tuple)  # ()

Note

Для создания кортежа из другого набора элементов, например, из списка, можно передать список в функцию tuple(), которая возвратит кортеж

fruits = ["яблоко", "банан", "вишня"]
fruits_tuple = tuple(fruits)
print(fruits_tuple)  # Вывод: ('яблоко', 'банан', 'вишня')

Неизменяемость кортежей

Note

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

my_tuple = (1, 4, 6)
my_tuple[1] = 10

TypeError: 'tuple' object does not support item assignment

🧪 Практика

Example

  1. Сделай кортеж из нескольких элементов
  2. Попробуй удалить элемент кортежа
  3. Попробуй добавить элемент в кортеж с ранее используемыми методами, прочти сообщение об ошибке
  4. Выведи элемент кортежа по индексу с помощью print()

Обращение к элементам кортежа

Note

Обращение к элементам в кортеже происходит также, как и в списке, по индексу. Индексация начинается также с нуля при получении элементов с начала списка и с -1 при получении элементов с конца списка

my_tuple = (10, 20, 30)
print(my_tuple[0])  # 10
print(my_tuple[1])  # 20
 
print(my_tuple[-1])  # 30 (последний элемент)
print(my_tuple[-2])  # 20

Сравнение кортежей

Note

кортежи так же можно сравнивать между собой при помощи операции равенства ==

при этом последовательность элементов имеет значение

tuple1 = ({"object": "in_tuple"}, 2)
tuple2 = (3, ["стринга", 1, True])
assert tuple1 == tuple2, f'кортеж {tuple1} не равен {tuple2}'

AssertionError: кортеж ({'object': 'in_tuple'}, 2) не равен (3, ['стринга', 1, True])

tuple1 = ({"object": "in_tuple"}, 2)
tuple2 = tuple(tuple1)
assert tuple1 == tuple2, f'кортеж {tuple1} не равен {tuple2}'
print(tuple1 == tuple2)  # Вывод: True

🧪 ****Практика:

Example

  1. Сделай кортеж с данными состоящий из несколько элементов
  2. Сделай проверку соответствия кортежей при помощи assert аналогично показанному выше

Основные методы работы с кортежами

Узнать длину кортежа

Tip

len(tuple): возвращает длину кортежа

# len
my_tuple = (1, 2, 3)
print(len(my_tuple))  # 3

Example

Повторите эти операции и выведите в терминал результаты их выполнения

Разложение (распакоууувка) кортежа по переменным

Note

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

coordinates = (10, 20)
 
x, y = coordinates  # Распаковываем кортеж
print(x)  # Вывод: 10
print(y)  # Вывод: 20

Note

Если кортеж содержит больше элементов, чем указано переменных, можно использовать * для сбора “лишних” элементов в список:

values = (1, 2, 3, 4, 5)
 
a, b, *rest = values
print(a)     # Вывод: 1
print(b)     # Вывод: 2
print(rest)  # Вывод: [3, 4, 5]

Note

Распаковать вышло - давайте упакуем, тут все предельно просто:

x = 10
y = 20
 
coordinates = (x, y)  # Создаем кортеж из переменных
print(coordinates)  # Вывод: (10, 20)

Example

Повторите эти операции и выведите в терминал результаты их выполнения

Соединение кортежей

Tip

Объединение кортежей (конкатенация):

tuple1 = ({"object": "in_tuple"}, 2)
tuple2 = (3, ["стринга", 1, True])
combined = tuple1 + tuple2
print(combined)  # ({'object': 'in_tuple'}, 2, 3, ['стринга', 1, True])

Note

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

Note

Чтобы обратиться к элементу вложенного списка, необходимо использовать пару индексов или индекс и ключ для словарей, например: combined[0]['object'] - обращение к значению элемента objectпервого элемента кортежа

print(combined[0]['object'])  # Вывод: in_tuple

Example

Повторите эти операции и выведите в терминал результаты их выполнения

Получение индекса и кол-ва схожих элементов

Note

index: Возвращает индекс первого вхождения элемента:

my_tuple = (10, 20, 30)
print(my_tuple.index(20))  # 1

Note

Здесь надо отметить, что в кортеже элементы могут повторяться, поэтому метод index вернем индекс именно по первому найденному совпадению

# count
my_tuple = (1, 2, 3, 3)
print(my_tuple.count(3))  # 2
 
# index
print(my_tuple.index(3))  # 2

🧪 Практическое задание

Example

Задание 1

Дан кортеж ("apple", "banana", "cherry", "apple")

  1. Найти индекс первого вхождения “apple”
  2. Вывести в консоль сколько раз в кортеже встречается "apple"
  3. Распаковать "apple" и "banana" в переменные a и b, а остальное - в массив rest
  4. На основе полученного массива сделать кортеж tuple_2
  5. написать assert на длину tuple_2 , что она равна 2, с выводом ошибки

Множества set

Note

Множество (set) представляют еще один вид набора, который хранит только уникальные элементы

Создание множества

Note

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

my_set = {1, 2, 3}
print(my_set)  # Вывод: {1, 2, 3}

Note

Для создания пустого множества делается через set()

Вспомним, что {} создаёт пустой словарь, а не множество, не перепутай!

empty_set = set()
print(empty_set)  # Вывод: set()

Note

Для создания множества из другого набора элементов, например, из списка, можно передать список в функцию set**()**, которая вернет множество

fruits = ["яблоко", "банан", "вишня"]
fruits_set = set(fruits)
print(fruits_set )  # Вывод: {'яблоко', 'банан', 'вишня'}

Note

С помощью метода copy() можно скопировать содержимое одного множества в другую переменную:

fruits = ["яблоко", "банан", "вишня", "яблоко"]
fruits_set = set(fruits)
fruits_set2 = fruits_set.copy()
print(fruits_set2)

Уникальность значений множества

Note

Каждое значение может встречаться только один раз

Рассмотрим пример, если передать несколько одинаковых значений:

fruits = ["яблоко", "банан", "вишня", "яблоко"]
fruits_set = set(fruits)
print(fruits_set)  # Вывод: {'яблоко', 'вишня', 'банан'}

Note

Несмотря на то, что функция print вывела один раз элемент “яблоко”, хотя в определении множества этот элемент содержится два раза. Все потому что множество содержит только уникальные значения.

И теперь мы разберем - какие же типы данных множество может использовать: Множества могут содержать только хэшируемые (immutable) объекты. Это означает, что элементы множества должны быть неизменяемыми. Подробнее что это за объекты затронем в теме неизменяемых данных, а пока давай запомним, что внутрь нам следует передавать следующие типы:

int, float, str, tuple

🧪 Практика

Example

  • Задание №1
    1. Сделай список элементов где 1 из них встретится несколько раз
    2. Сделай из этого списка множество
    3. выведи print() результат
  • Задание №2

    1. Сделай множество, где один из элементов будет список

    2. Попробуй вывести это множество в консоль при помощи print()

      ознакомься с текстом ошибки.

Обращение к элементам множества

Note

Множества (set) в Python не поддерживают доступ к элементам по индексу, так как они неупорядоченные. Это означает, что элементы множества не имеют фиксированных позиций

Тем не менее можно достать эти элементы методом pop() для получения и удаления случайного элемента

my_set = {1, 2, 3, 4}
element = my_set.pop()
print(element)  # Случайный элемент
print(my_set)   # Оставшиеся элементы

Основные методы работы с множествами

Добавление и удаление элементов в множество

Note

Метод add() добавляет элемент в множество. Если элемент уже существует, он не добавляется

my_set = {1, 2, 3}
my_set.add(4)
print(my_set)  # Вывод: {1, 2, 3, 4}
 
# Попытка добавить дубликат
my_set.add(2)
print(my_set)  # Вывод: {1, 2, 3, 4} (без изменений)

Note

Для удаления элементов у нас есть все те же знакомые инструменты + еще один новый, давай разберем их:

  • remove(element) — удаляет элемент, вызывает ошибку KeyError, если элемент не найден
  • discard(element) — удаляет элемент, но ошибки не вызывает
  • pop() — удаляет и возвращает случайный элемент
  • clear() — удаляет все элементы
my_set = {1, 2, 3}
 
# Удаление с remove()
my_set.remove(2)
print(my_set)  # Вывод: {1, 3}
 
# Удаление с discard()
my_set.discard(4)  # Ошибки нет, хотя 4 не в множестве
 
# Удаление случайного элемента с pop()
removed = my_set.pop()
print(removed)  # Вывод: 1 или 3 (случайно)
print(my_set)   # Оставшиеся элементы
 
# Очистка множества
my_set.clear()
print(my_set)  # Вывод: set()

🧪 ****Практика:

Example

  1. Сделай множество с данными состоящий из 4-х элементов
  2. Добавь в него новый элемент. После добавь уже существующий. При помощи print() выведи результат и проанализируй его
  3. Попробуй методом remove() удалить несуществующий элемент и прочти ошибку
  4. Попробуй сделать то же самое с методом discard()
  5. попробуй удалить случайный элемент при помощи метода pop() - выполни несколько раз программу и убедись, что извлекается случайный элемент

Узнать длину множества

Tip

Здесь используется все та же встроенная функция len() - все просто

# len
my_set = {1, 2, 3}
print(len(my_set))  # 3

Example

Повторите эти операции и выведите в терминал результаты их выполнения

Объединение множеств

Note

Оператор | объединяет элементы двух множеств

set1 = {1, 2, 3}
set2 = {3, 4, 5}
 
union_set = set1 | set2
print(union_set)  # Вывод: {1, 2, 3, 4, 5}

Note

Так же это можно сделать при помощи метода union()

set1 = {1, 2, 3}
set2 = {3, 4, 5}
 
union_sets = set1.union(set2)
print(union_sets)  # Вывод: {1, 2, 3, 4, 5}

Example

🧪 Практическое задание:

  1. Попробуй сделать 2 множества и в новую переменную сделать их объединенную версию
  2. После этого выведи оба множества при помощи print() - убедись, что изначальные множества не изменились

Пересечение множеств

Note

Оператор & или метод intersection() возвращает элементы, которые есть в обоих множествах.

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

set1 = {1, 2, 3}
set2 = {3, 4, 5}
 
intersection_set = set1 & set2  # пример с оператором
intersection_set2 = set1.intersection(set2)  # пример с методом
print(intersection_set)  # Вывод: {3}

Example

Практическое задание :

  1. Попробуй сделать аналогично
  2. А теперь сделай так, чтобы оба множества не содержали одинаковых элементов и попробуй сделать ту же самую операцию - проанализируй вывод результата.

Разность множеств

Note

Оператор - или метод difference() возвращает элементы, которые есть в первом множестве, но отсутствуют во втором

set1 = {1, 2, 3}
set2 = {3, 4, 5}
 
difference_set = set1 - set2  # пример через оператор
difference_set_1 = set1.difference(set2)  # Пример через метод
print(difference_set)  # Вывод: {1, 2}
print(difference_set_1)  # Вывод: {1, 2}

Note

Отдельная разновидность разности множеств - симметрическая разность производится с помощью метода symmetric_difference() или с помощью операции ^. Она возвращает все элементы обоих множеств за исключением общих:

set1 = {1, 2, 3}
set2 = {3, 4, 5}
 
symmetric_diff = set1 ^ set2  # Пример через оператор
symmetric_diff_1 = set1.symmetric_difference(set2)  # Пример через метод
print(symmetric_diff)  # Вывод: {1, 2, 4, 5}
print(symmetric_diff_1)  # Вывод: {1, 2, 4, 5}

Сравнение множеств (опционально учить не надо)

Множества в Python можно сравнивать с использованием операторов <, <=, >, >=. Эти операторы проверяют, являются ли множества подмножествами или надмножествами друг друга

  • Подмножество (<, <=):

    Множество A является подмножеством множества B, если все элементы A присутствуют в B.

    • Оператор < проверяет, что A является строгим подмножеством B (должны быть элементы в B, которых нет в A).
    • Оператор <= проверяет, что A является подмножеством B (включая равенство).

  • Надмножество (>, >=):

    Множество A является надмножеством множества B, если все элементы B присутствуют в A.

    • Оператор > проверяет, что A является строгим надмножеством B.
    • Оператор >= проверяет, что A является надмножеством B (включая равенство).

  • Равенство множеств:

    Два множества равны, если содержат одни и те же элементы, независимо от порядка.

Примеры сравнения:

  • Пример 1. Подмножество и надмножество

    set1 = {1, 2}
set2 = {1, 2, 3}
 
# Проверка подмножества
print(set1 < set2)   # True: set1 строго подмножество set2
print(set1 <= set2)  # True: set1 подмножество set2
 
# Проверка надмножества
print(set2 > set1)   # True: set2 строго надмножество set1
print(set2 >= set1)  # True: set2 надмножество set1

  • Пример 2. Равные множества:

    set1 = {1, 2, 3}
set2 = {3, 2, 1}
 
print(set1 == set2)  # True: элементы одинаковые
print(set1 <= set2)  # True: set1 подмножество set2
print(set1 >= set2)  # True: set1 надмножество set2
print(set1 < set2)   # False: set1 не строго подмножество set2

  • Пример 3. Несравнимые множества:

    set1 = {1, 2, 3}
set2 = {3, 4, 5}
 
print(set1 < set2)   # False: set1 не подмножество set2
print(set1 > set2)   # False: set1 не надмножество set2
print(set1 == set2)  # False: множества не равны

Так же можно проверить подмножество/надмножество с помощью методов

  • issubset(): Проверяет, является ли множество подмножеством другого.
  • issuperset(): Проверяет, является ли множество надмножеством другого.
set1 = {1, 2}
set2 = {1, 2, 3}
 
# Проверка подмножества
print(set1.issubset(set2))  # True
print(set2.issubset(set1))  # False
 
# Проверка надмножества
print(set2.issuperset(set1))  # True
print(set1.issuperset(set2))  # False

🧪 Практическое задание

Example

Повторить все примеры и получить результаты Данные операции встречаются редко, нам будет достаточно просто знать о их существовании и возвращать к ним в случае необходимости.

🧪 Практическое задание

Example

Задание 1

Даны 2 списка:

list1: [10, 20, 30, 40, 50]
list2: [20, 25, 30, 35, 40]
  1. Вывести при помощи print() список, который будет содержать в себе элементы:
    1. Которые присутствуют в 1 списке(list1), но отсутствуют во втором (list2)
    2. Уникальные элементы для обоих списков
    3. Элементы, которые встречаются как в первом, так и во втором списке

Диапазоны range

Note

Диапазон — это последовательность чисел, которая создаётся с помощью функции range().

Диапазон часто используется, когда нужно работать с числами в определённом порядке

Создание диапазонов

  • Синтаксис функции range():

    range(start, stop, step)
    • start — начальное значение (включительно). Если не указано, по умолчанию начинается с 0
    • stop — конечное значение (не включается в диапазон)
    • step — шаг, то есть разница между последовательными числами. Если не указано, шаг равен 1

  • Простой диапазон от 0 до 5:

    r = range(5)
print(r)  # Вывод: range(0, 5)
print(list(r))  # Вывод: [0, 1, 2, 3, 4]

Note

Здесь start не указан, поэтому диапазон начинается с 0 step тоже не указан - поэтому 1

🧪 Практическое задание

Example

Сделай диапазоны, где:

  1. начинается с 2 и заканчивается перед 6
  2. числа увеличиваются на 2 на каждом шаге
  3. идёт в обратном порядке, уменьшая значение на 2 на каждом шаге то есть с отрицательным шагом
  4. где start диапазона > stop - попробуй преобразовать его в список и ознакомься с результатом

Основные методы работы с диапазонами

Узнать длину диапазона

Ничего нового - все та же функция len()

print(len(range(5, 15, 2)))  # Вывод: 5

Если интересно из чего состоит - преобразуй в список и выведи его

Оператор in в Python

Tip

in — это оператор, который проверяет наличие элемента в контейнере. Он работает с различными типами данных, такими как строки, списки, кортежи, множества и словари

Про операторы в целом мы говорили в 02.03 - Операции с данными.

Оператор in возвращает:

  • True, если элемент содержится в контейнере.
  • False, если элемент отсутствует.

Строка str

При помощи оператора in можно проверить наличие символа или подстроки в строке:

text = "Hello, world!"
 
# Проверяем наличие подстроки
print("Hello" in text)  # True
print("world" in text)  # True
print("Прикол" in text)  # False
 
# Проверяем наличие отдельного символа
print("H" in text)  # True
print("h" in text)  # False
print("z" in text)  # False

Warning

Объяснение

  • "Hello" in text возвращает True, потому что подстрока "Hello" есть в строке которая хранится в переменнойtext
  • "z" in text возвращает False, потому что символ "z" отсутствует
  • "h" in text возвращает False , потому что h не тоже самое, что и H

    • Поскольку строка содержит символы Unicode, то с помощью функции ord() мы можем получить числовое значение для символа в кодировке Unicode:

      print('значение h: ', ord("h"))
print('значение H: ', ord("H"))

Example

Попробуй выполнить код выше и убедись, в том что эти символы имеют разное числовое значение

Массив list

Проверка элемента в списке

numbers = [1, 2, 3, 4, 5]
 
print(3 in numbers)  # True
print(10 in numbers)  # False

Warning

Объяснение:

  • 3 in numbers возвращает True, потому что число 3 есть в списке
  • 10 in numbers возвращает False, потому что числа 10 нет в списке

Кортеж tuple

Проверка элемента в кортеже

colors = ("red", "blue", "green")
 
print("red" in colors)  # True
print("yellow" in colors)  # False

Warning

Объяснение:

  • "red" in colors возвращает True, потому что цвет "red" есть в кортеже
  • "yellow" in colors возвращает False, потому что цвета "yellow" нет в кортеже

Словарь dict

Проверка ключа в словаре

Оператор in проверяет наличие ключей, а не значений.

user_info = {"name": "Alice", "age": 25, "city": "New York"}
 
print("name" in user_info)  # True
print("Alice" in user_info)  # False
print("age" in user_info)  # True

Warning

Объяснение:

  • "name" in user_info возвращает True, потому что ключ "name" есть в словаре.
  • "Alice" in user_info возвращает False, потому что in проверяет ключи, а не значения.

Множество set

Проверка элемента в множестве

my_set = {1, 2, 3, 4, 5}
 
print(2 in my_set )  # True
print(6 in my_set )  # False

Warning

Объяснение:

  • 2 in my_set возвращает True, потому что 2 есть в множестве.
  • 6 in my_set возвращает False, потому что 6 отсутствует.

Диапазон range

Проверка числа в диапазоне

print(5 in range(10))  # Вывод: True
print(15 in range(10))  # Вывод: False

Warning

Объяснение:

  • 5 in range(10) возвращает True, потому что 5 есть в диапазоне от 0 до 10
  • 15 in range(10) возвращает False, потому что 15 отсутствует в диапазоне от 0 до 10

🧪 Практика

Example

Попробуй повторить все примеры. В будущих темах этот оператор нам очень поможет!

🧪 Практическое задание

Example

  1. Сделать конспект темы в миро

⬅️ Назад: 02.03 - Операции с данными | Далее: 02.05 - Изменяемые и неизменяемые типы данных ➡️ Модуль: 02 - MOC

Вид графа

Обратные ссылки