{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Введение в программирование на Python. Занятие 2.\n", "# Контейнерные типы данных. Списки, кортежи, множества, словари и операции с ними" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## 0. Концепция массива\n", "\n", "**Массив (array)** — структура данных, хранящая набор значений (элементов массива), идентифицируемых по индексу или набору индексов, принимающих целые значения из некоторого заданного непрерывного диапазона.\n", "\n", "https://ru.wikipedia.org/wiki/%D0%9C%D0%B0%D1%81%D1%81%D0%B8%D0%B2_(%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5)\n", "\n", "**Размерность массива** — это количество индексов, необходимое для однозначной адресации элемента в рамках массива. По количеству используемых индексов массивы делятся на одномерные, двумерные, трёхмерные и т. д. Аналогия из математики: одномерный массив - вектор, двумерный - матрица, трёх- и более -мерный — многомерная матрица или тензор.\n", "\n", "**Форма или структура массива** — сведения о количестве размерностей и размере (протяжённости) массива по каждой из размерностей.\n", "\n", "Пример одномерного массива.\n", "![Image](https://ykl-res.azureedge.net/cc602d0d-2036-4e74-8730-305cc705835d/1.png)\n", "\n", "Картинка с сайта https://www.yaklass.ru/p/informatika/9-klass/algoritmizatciia-i-programmirovanie-14692/odnomernye-massivy-tcelykh-chisel-14603/re-84b191be-cf7c-4763-abc2-9d338b6b5198.\n", "\n", "**Динамическими** называются массивы, размер которых может изменяться во время выполнения программы. Нединамические массивы называют ещё фиксированными или **статическими**.\n", "\n", "**Гетерогенным** называется массив, в разные элементы которого могут быть записаны значения, относящиеся к различным типам данных. Гетерогенные массивы удобны как универсальная структура для хранения наборов данных произвольных типов. Реализация гетерогенности требует усложнения механизма поддержки массивов в трансляторе языка.\n", "\n", "Стандартная библиотека Python имеет контейнерные типы, схожие с массивом, — это список и кортеж. Список — гетерогенный динамический массив, а кортеж — гетерогенный статический массив.\n", "\n", "##### Достоинства\n", "* лёгкость доступа к элементу по его индексу (поскольку элементы массива располагаются один за другим)\n", "* одинаковое время доступа ко всем элементам\n", "\n", "##### Недостатки\n", "* для статического массива — отсутствие динамики, невозможность удаления или добавления элемента без сдвига других\n", "* для динамического и/или гетерогенного массива — более низкое (по сравнению со статическим) быстродействие и дополнительные накладные расходы на поддержку динамических свойств и гетерогенности\n", "* при отсутствии дополнительных средств контроля — угроза выхода за границы массива и повреждения данных." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 1. Список / List" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 1.1. Создание списков и печать\n", "Составные (контейнерные) типы данных используются для группировки значений вместе. Наиболее гибкий из них — список (list). Список задаётся через разделённые запятыми значения (элементы), заключённые в квадратные скобки. Элементы списка могут быть разных типов.\n", "\n", "Список — ближайшая аналогия массива в Python." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['milk', 'sugar', 'kefir', 'butter']\n", "Length of my_list is 4\n", "Type of list object is \n", "['word', 1, 'Python', 5]\n", "['other_word', ['milk', 'sugar', 'kefir', 'butter'], ['word', 1, 'Python', 5]]\n" ] } ], "source": [ "# Create list by listing elements\n", "# Создаём список, перечисляя элементы в нём\n", "my_list = ['milk', 'sugar', 'kefir', 'butter']\n", "print(my_list)\n", "\n", "# Print some useful information about the list: len(), type()\n", "# Печать полезной информации о списке: длина len(), тип данных type()\n", "print('Length of my_list is ' + str(len(my_list)))\n", "print('Type of list object is ' + str(type(my_list)))\n", "\n", "# 2 ways of creating empty list\n", "# 2 способа создания пустого списка\n", "my_other_list = []\n", "my_third_list = list()\n", "\n", "# A list may contain objects of different types\n", "# В списке могут содержаться объекты разных типов\n", "my_many_types_list = ['word', 1, 'Python', 5]\n", "print(my_many_types_list)\n", "\n", "# A list may contain even other lists in it\n", "# Список может быть составлен из других списков\n", "list_of_2_lists = ['other_word', my_list, my_many_types_list]\n", "print(list_of_2_lists)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 1.2. Обращение к элементам списка\n", "Индексы списков начинаются с нуля, как и индексы строк. Самая частая операция при работе со списками - обращение к элементу по индексу. Похожая операция - обращение к группе соседних элементов - срез списка." ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "Отрицательные индексы в Python удобны для обращения к элементам с конца.\n", "\n", "![Image](http://antakova.ru/wp-content/uploads/2018/10/main-qimg-601.jpeg)\n", "\n", "https://qph.fs.quoracdn.net/main-qimg-a380b1bc159589df5e0b9842e5b56b6d" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "milk\n", "kefir\n", "butter\n", "['sugar', 'kefir']\n", "['milk', 'sugar', 'cheese', 'sugar']\n" ] } ], "source": [ "# Accessing list element by index\n", "# Обращение к элементу списка по индексу\n", "print(my_list[0])\n", "print(my_list[2])\n", "print(my_list[-1])\n", "\n", "# Slicing the list: get elements of my_list from 1 to 3, excluding 3d\n", "# Обращение к части списка - срезка списка. Здесь элементы от первого до третьего, исключая третий\n", "print(my_list[1:3])\n", "\n", "# New list is created from elements 0, 1 of original list and appending another list\n", "# Создание нового списка из части старого и присоединения нового\n", "new_list = my_list[:2] + ['cheese', 'sugar']\n", "print(new_list)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 1.3. Изменение элементов и всего списка" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['cottage_cheese', 'sugar', 'kefir_activia', 'butter']\n", "['salted_cheese', 'icecream', 'kefir_activia', 'butter']\n", "['salted_cheese', 'icecream']\n", "[]\n" ] } ], "source": [ "# Appending string to existing list element and updating the element with index 0\n", "# Присоединение строки к элементу списка c индексом 2 (тоже строке)\n", "# Обновление элемента с индексом 0\n", "my_list[2] = my_list[2] + '_activia'\n", "my_list[0] = 'cottage_cheese'\n", "print(my_list)\n", "\n", "# Updating part of list by assigning new values to list slice\n", "# Можно обновить список, присвоив его срезу другой список\n", "my_list[0:2] = ['salted_cheese', 'icecream']\n", "print(my_list)\n", "\n", "# Deleting part of list by assigning empty list to list slice\n", "# Можно удалить часть списка, присвоив срезу пустой список\n", "my_list[2:4] = []\n", "print(my_list)\n", "\n", "# Deleting all list by assigning empty list\n", "# Присвоение полному срезу списка пустого списка очищает его\n", "my_list[:] = []\n", "print(my_list)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 1.2. Добавление элементов в список, удаление элементов" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[3, 3, 4]\n", "4\n", "[3, 3]\n", "[3, 3]\n" ] } ], "source": [ "# Adding elements to list end\n", "# Добавление элемента в конец списка\n", "my_third_list.append(3)\n", "my_third_list.append(4)\n", "print(my_third_list)\n", "\n", "# pop() always removes last element of the list \n", "# pop() возвращает и удаляет последний элемент списка\n", "elem = my_third_list.pop()\n", "print(elem)\n", "print(my_third_list)\n", "\n", "# Remove element by index\n", "# Можно удалять через pop() по индексу элемента\n", "# Есть и другие операции по добавлению и удалению элементов списка, но они менее эффективны.\n", "# my_third_list.pop(2)\n", "print(my_third_list)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 1.3. Итерирование по списку" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "To Buy:\n", "- milk\n", "- sugar\n", "- cheese\n", "- sugar\n", "\n", "0. milk\n", "1. sugar\n", "2. cheese\n", "3. sugar\n", "\n", "list[1] = sugar\n", "list[2] = cheese\n" ] } ], "source": [ "print(\"To Buy:\")\n", "\n", "# Simple iterating over list (does not use or imply indexes)\n", "# Итерирование по списку (не использует индексы)\n", "for item in new_list:\n", " print('- ' + item)\n", "\n", "print()\n", "\n", "# Loop over a list while keeping track of indexes with enumerate()\n", "# Встроенная функция enumerate() позволяет следить за индексами при итерировании\n", "for num, item in enumerate(new_list):\n", " print(str(num) + '. ' + item)\n", " \n", "print()\n", "\n", "# Loop over a list with index in some range\n", "# Цикл по списку с внешним для списка индексом из некоторого промежутка range()\n", "for index in range(1, 3):\n", " print('list[' + str(index) + '] = ' + new_list[index])" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Average age of survived on Titanic: 23.9\n" ] } ], "source": [ "# Example from data analysis: calculating mean with iteration over list\n", "# Пример из анализа данных: подсчёт среднего возраста в списке\n", "titanic_survived_ages = [16, 20, 3, 5, 11, 66, 40, 32, 38, 22, 10]\n", "mean = 0\n", "count = len(titanic_survived_ages)\n", "\n", "for age in titanic_survived_ages:\n", " mean = mean + age\n", " \n", "mean = mean / count\n", "print('Average age of survived on Titanic: %.1f' % mean)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 1.4. Другие методы списка\n", "\n", "insert(), remove(), extend(), index(), reverse(), copy(), sort(), any(), all(), sum()...\n", "\n", "Можно изучить подробнее здесь: https://www.programiz.com/python-programming/methods/list" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 1.5. Практика" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "To Buy:\n", "0. milk\n", "1. sugar\n", "2. cheese\n", "3. sugar\n" ] } ], "source": [ "# Make this a human-readable list starting with 1.\n", "# Напечатать список покупок, чтобы номера начинались с 1.\n", "print(\"To Buy:\")\n", "for num, item in enumerate(new_list):\n", " print(str(num) + '. ' + item)" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "To Buy:\n", "1. milk\n", "2. sugar\n", "3. cheese\n", "4. sugar\n" ] } ], "source": [ "# Solution / решение: num + 1\n", "# Make this a human-readable list starting with 1.\n", "# Напечатать список покупок, чтобы номера начинались с 1.\n", "print(\"To Buy:\")\n", "for num, item in enumerate(new_list):\n", " print(str(num + 1) + '. ' + item)" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "14\n", "9\n" ] } ], "source": [ "# Calculate how many persons survived 's' = survived, 'd' = died\n", "# Посчитать, сколько людей выжило, по списку. Здесь 's' = survived (выжил), 'd' = died (погиб)\n", "titanic_survival_data = ['s','d','d','d','s','s','d','s','s','s','d','s','d','d','d','d','s','s','s','s','s','s','s']\n", "\n", "# Solution / решение\n", "def count_elem_in_list(element, list):\n", " count = 0\n", " for item in list:\n", " if(item == element):\n", " count += 1\n", " return count\n", "\n", "print(count_elem_in_list('s', titanic_survival_data))\n", "print(count_elem_in_list('d', titanic_survival_data))" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [], "source": [ "# Find strings starting with 'A' in the list\n", "# Найти все строки, начинающиеся на 'A' (латинское) в списке и записать их в новый список\n", "titanic_some_surnames = ['Arriba', 'Antello', 'Bentham', 'Gordon', 'Daniels', 'Angellini', 'Guaro', 'Heins', 'Valley', 'Amaro']\n", "surnames_on_a = []" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "**MSE = Mean Squared Error - среднеквадратичная ошибка.** Сумма квадратов отклонений реального значения функции от смоделированного значения, делённая на количество значений. Часто применяемая метрика для моделей машинного обучения и анализа данных.\n", "\n", "![image.png](https://www.researchgate.net/profile/Alexandros_Karatzoglou/publication/221515860/figure/fig1/AS:339586132791298@1457975051470/Mean-Squared-Error-formula-used-to-evaluate-the-user-model.png)\n", "\n", "https://www.researchgate.net/figure/Mean-Squared-Error-formula-used-to-evaluate-the-user-model_fig1_221515860" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "None\n" ] } ], "source": [ "# Homework 1: calculate median of titanic_survived_ages list\n", "# Дома 1: посчитать медиану возраста в titanic_survived_ages\n", "\n", "# Homework 2: create a function for calculating median of any list passed as parameter\n", "# Дома 2: написать функцию, которая считает медианное значение списка\n", "\n", "# Homework 3 from data analysis: calculate mean square error MSE of two lists of the same length if they are list of predictions and actual values.\n", "# Дома 3 - из анализа данных: посчитать среднюю квадратичную ошибку между списком предсказаний модели и реальных значений функции.\n", "# https://en.wikipedia.org/wiki/Mean_squared_error\n", "# http://statistica.ru/glossary/general/srednekvadraticheskaya-oshibka/\n", "list_predictions = [10, 100, 15.2, 4, 86, 134, 3.2, 3, 12]\n", "list_actuals = [10, 90, 14, 3, 80, 100, 3, 4, 12.5]\n", "\n", "def calculate_mse(list1, list2):\n", " # Your code here\n", " # Ваш код вычислений будет здесь\n", " pass\n", "\n", "print(calculate_mse(list_predictions, list_actuals))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 2. Кортеж (неизменяемый список) / Tuple\n", "\n", "Это упорядоченный неизменный набор элементов. У элементов кортежа есть индексы. Создаётся tuple (кортеж) круглыми скобками. Элементы перечисляются через запятую. \n", "\n", "Неизменность tuple (кортежа) помогает сохранять целостность данных, избегать ошибок и также позволяет использовать его как ключ в словарях.\n", "\n", "*Tuples are for heterogeneous data, list are for homogeneous data.\n", "Tuples are not read-only lists. —Guido van Rossum*\n", "\n", "### 2.1. Операции с кортежами" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "('December', 'January', 'February')\n", "Length of tuple is 3\n", "Type of list object is \n", "Winter month at index -1 February\n", "Winter months slice 0:2 is ('December', 'January')\n" ] } ], "source": [ "winter_months = ('December','January', 'February')\n", "\n", "print(winter_months)\n", "print('Length of tuple is ' + str(len(winter_months)))\n", "print('Type of list object is ' + str(type(winter_months)))\n", "\n", "# Access to tuple elements works the same as for list: with index, with slice\n", "# Доступ к элементам кортежа работает так же, как и для списка: доступ по индексу или по срезу\n", "print('Winter month at index -1 ' + winter_months[-1])\n", "print('Winter months slice 0:2 is ' + str(winter_months[0:2]))" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "('December', 'January', 'February', 'March', 'April', 'May')\n" ] } ], "source": [ "# It is not possible to change element in tuple. This throws TypeError exception\n", "# Изменять элементы кортежа запрещено. Это бросает исключение TypeError\n", "# winter_months[0] = 100;\n", "\n", "spring_months = ('March', 'April', 'May');\n", "\n", "# We can create new tuples as a concatenation of others\n", "# Можно создавать новые кортежи как объединения старых\n", "winter_and_spring = winter_months + spring_months;\n", "print (winter_and_spring);" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "March\n", "April\n", "May\n", "\n", "0 March\n", "1 April\n", "2 May\n" ] } ], "source": [ "# Iterating in tuple\n", "# Итерирование по кортежу - аналогично списку\n", "for x in spring_months:\n", " print(x)\n", "\n", "print()\n", "\n", "for i, x in enumerate(spring_months):\n", " print(i, x)" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "No, 'apple' is not in months tuple\n" ] } ], "source": [ "# Checking if element exists in tuple (or list)\n", "# Проверка, что элемент есть в кортеже (или в списке :))\n", "if \"apple\" in spring_months:\n", " print(\"Yes, 'apple' is in the tuple\")\n", "else:\n", " print(\"No, 'apple' is not in months tuple\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 2.2. Другие функции работы с кортежами\n", "\n", "С кортежем работают многие встроенные функции Python, такие как *all()*, *any()*, *enumerate()*, *len()*, *max()*, *min()*, *sorted()*, *tuple()*.\n", "\n", "|Функция|Описание|\n", "| :---| :---|\n", "|all()|Вернёт True если все элементы кортежа приводятся к булевому True и также если кортеж пустой.|\n", "|any()|Вернёт True если хотя бы один элемент кортежа приводится к True. Вернёт False для пустого кортежа.|\n", "|len()|Вернёт количество элементов кортежа.|\n", "|max()|Вернёт максимальный элемент кортежа.|\n", "|min()|Вернёт минимальный элемент кортежа.|\n", "|sorted()|Возвращает новый отсортированный список из элементов кортежа.|\n", "|sum()|Вернёт сумму всех элементов кортежа.|\n", "|tuple()|Создаёт кортеж tuple из контейнера (список, строка, множество или словарь).|" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 2.3. Практика с кортежами (tuple)" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "# What age has the youngest Titanic survival?\n", "# Сколько лет самому молодому выжившему на Титанике?\n", "titanic_survived_ages = (16, 20, 32, 5, 11, 66, 40, 32, 38, 22, 10, 62, 4, 8, 33, 11, 12, 12, 18, 31, 34, 45, 6)\n", "\n", "# Hint / подсказка:\n", "# Use standard functions for tuples like max(), min()\n", "# Используйте стандартные фунции вроде max(), min()" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [], "source": [ "# Get average age of survivals using sum() and len() functions for tuple\n", "# Узнать средний возраст выживших, используя функции кортежа sum() и len()" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Error: function returned common element for different tuples.\n", "Test 2 pass.\n", "Error: function returned common element for different tuples.\n", "Error: function returned common element for different tuples.\n" ] } ], "source": [ "# Homework: Write a Python function that takes two tuples and returns True if they have at least one common member\n", "# There are 4 tests that should pass for this function\n", "# Дома: Написать функцию, принимающую два кортежа и возвращающую True, если у них есть хотя бы один совпадающий элемент\n", "# В коде ниже созданы 4 теста, которые должны проходить (печатать Test N pass), когда функция будет написана верно\n", "\n", "def tuples_have_common_element(tuple1, tuple2):\n", " # Your code here\n", " # Добавьте ваш код здесь\n", " return True\n", "\n", "tup1 = (0, 1)\n", "tup2 = (2, 2)\n", "tup3 = (1, '2')\n", "tup4 = ('0', '1')\n", "tup5 = ()\n", "\n", "# Tests for this fucntion tuples_have_common_element()\n", "# Тесты для новой функции tuples_have_common_element()\n", "if(tuples_have_common_element(tup1, tup2)):\n", " print ('Error: function returned common element for different tuples.')\n", "else:\n", " print ('Test 1 pass.')\n", " \n", "if(tuples_have_common_element(tup1, tup3)):\n", " print ('Test 2 pass.')\n", "else:\n", " print ('Error: function did not find common element in tuples.')\n", " \n", "if(tuples_have_common_element(tup3, tup4)):\n", " print ('Error: function returned common element for different tuples.')\n", "else:\n", " print ('Test 3 pass.')\n", " \n", "if(tuples_have_common_element(tup3, tup5)):\n", " print ('Error: function returned common element for different tuples.')\n", "else:\n", " print ('Test 4 pass.')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 3. Множество / Set\n", "В математике множество - это набор разных элементов, не обязательно упорядоченных. Множество (set) в Python отражает это определение. Элементы в нём не повторяются. Их нельзя изменять, но можно изменять само множество. У элементов нет индексов (номеров) и нельзя обращаться к ним по индексам и делать срезы (slice)." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 3.1. Создание множества (set)" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['my', 'name', 'is', 'Kate', 'and', 'Kate', 'is', 'my', 'name']\n", "{'is', 'my', 'name', 'and', 'Kate'}\n", "{1, 10, 20}\n", "{'Test', 2.2, (1, 2, 3)}\n" ] } ], "source": [ "list_of_words = \"my name is Kate and Kate is my name\".split()\n", "print(list_of_words)\n", "\n", "# Creation of set from a list \n", "# Создание множества из списка\n", "set_of_words = set(list_of_words)\n", "print(set_of_words)\n", "\n", "# Creation of set of integer values with curly brackets\n", "# Создание множества из элементов - через фигурные скобки\n", "my_set = {1, 10, 20}\n", "print(my_set)\n", "\n", "# Creation of set with mixed datatypes\n", "# Создание множества с элементами разных типов данных\n", "new_mix_type_set = {\"Test\", 2.2, (1, 2, 3)}\n", "print(new_mix_type_set)\n", "\n", "# Elements of set should be immutable. Adding mutable elements is prohibited and throws error.\n", "# Элементы множества должны быть неизменяемыми. Добавление изменяемого элемента, например, списка, запрещено и даёт ошибку.\n", "# new_mix_type_set = {\"Test\", [10, 20]}" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 3.2. Операции с множествами" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{'Fri', 'Wed', 'Thu', 'Tue', 'Mon', 'Sun', 'Sat'}\n", "{'Fri', 'Wed', 'Thu', 'Tue', 'Mon', 'Sat'}\n", "Test\n", "2.2\n", "(1, 2, 3)\n", "Sunday is not in set\n" ] } ], "source": [ "# Add elemenets: add() method\n", "# Добавление элементов: метод add()\n", "Days=set([\"Mon\",\"Tue\",\"Wed\",\"Thu\",\"Fri\",\"Sat\"])\n", "Days.add(\"Sun\")\n", "print(Days)\n", "\n", "# Remove elements: remove() and discard()\n", "# Удаление элементов: remove() и discard()\n", "# remove() will throw an error if element does not exist in set\n", "# remove() выдаст ошибку, если удалять несуществующий элемент\n", "Days.remove(\"Sun\")\n", "\n", "# This will throw an error\n", "# Такой вызов породит ошибку\n", "# Days.remove(\"Sun\")\n", " \n", "# discard() will not throw an error for nonexistent element\n", "# discard() не выдаст ошибку на удаление несуществующего элемента - можно удалять что угодно\n", "Days.discard(\"OOO\")\n", "print(Days)\n", "\n", "# Iterating in set is done similarly to the list and tuple\n", "# Итерирование по множеству - аналогично списку и кортежу\n", "for elem in new_mix_type_set:\n", " print(elem)\n", " \n", "# Check if element is present in set\n", "# Проверка наличия элемента в множестве\n", "if(\"Sun\" in Days):\n", " print (\"Sunday is included in set\")\n", "else:\n", " print (\"Sunday is not in set\")" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "#### 3.2.1. Пересечение множеств\n", "![image.png](http://fastread.aitechtonic.com/submittutorial/uploads/python/set-intersection.jpg)\n", "http://fastread.aitechtonic.com/submittutorial/tutorial.php?selecttutormenu=905" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{'James', 'Kate'}\n", "\n", "{'James', 'Kate'}\n", "{'James', 'Kate'}\n", "\n" ] } ], "source": [ "meetup1_attendees = set([\"Alice\", \"Kate\", \"James\"])\n", "meetup2_attendees = set([\"Victor\", \"Kate\", \"James\"])\n", "\n", "# intersection() function finds elements present in both sets\n", "# Функция intersection() находит пересечение множеств - набор элементов, входящих в оба множества.\n", "intersect = meetup1_attendees.intersection(meetup2_attendees)\n", "print(intersect)\n", "print(type(intersect))\n", "\n", "# Other method of making intersection: & operator \n", "# Другой способ построить пересечение - оператор &\n", "both_meetup_attendees = meetup1_attendees&meetup2_attendees\n", "print(both_meetup_attendees)\n", "print(type(both_meetup_attendees))" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "#### 3.2.2. Объединение множеств\n", "![image.png](http://fastread.aitechtonic.com/submittutorial/uploads/python/set-union.jpg)\n", "http://fastread.aitechtonic.com/submittutorial/tutorial.php?selecttutormenu=905" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{'Fri', 'Wed', 'Thu', 'Tue', 'Mon'}\n", "{'Fri', 'Mon', 'Sun', 'Sat', 'Wed', 'Thu', 'Tue'}\n", "{'Fri', 'Mon', 'Sun', 'Sat', 'Wed', 'Thu', 'Tue'}\n" ] } ], "source": [ "# Union of sets - method union()\n", "# Объединение множеств - возвращает тоже множество\n", "weekdays = {\"Mon\",\"Tue\",\"Wed\",\"Thu\",\"Fri\"}\n", "weekends = {\"Sat\",\"Sun\"}\n", "all_days = weekdays.union(weekends)\n", "print(weekdays)\n", "print(all_days)\n", "\n", "other_all_days = weekdays|weekends\n", "print(other_all_days)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "#### 3.2.3. Разность множеств (Set Difference)\n", "![image.png](http://fastread.aitechtonic.com/submittutorial/uploads/python/set-difference.jpg)\n", "http://fastread.aitechtonic.com/submittutorial/tutorial.php?selecttutormenu=905" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{'Sun', 'Sat'}\n", "{'Sun', 'Sat'}\n" ] } ], "source": [ "# difference() method on a set\n", "# Метод difference() применим к множеству и \"вычитает из него\" другое множество\n", "print(all_days.difference(weekdays))\n", "\n", "# Operator - also makes a difference of sets\n", "# Аналогично разность делается оператором -\n", "print(all_days - weekdays)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 3.3. Другие полезные методы множеств в Python\n", "\n", "https://www.programiz.com/python-programming/set#methods" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 3.4. Практика" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Python set has a method issubset() checking that one set is completely a subset of another. \n", "# The task is to implement this method by hands.\n", "# В Python есть метод множества issubset(), проверяющий, что одно множество - подмножество другого.\n", "# Задание - написать этот метод самостоятельно." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Find max and min element in set\n", "# Найти максимальный и минимальный элемент в множестве" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [], "source": [ "# Homework. With help of strings and sets, print all unique surnames of titanic passengers.\n", "# Suppose they all have only one-word first name and one-word surname without middle name.\n", "# Дома. Работая со строками и множествами, вывести список уникальных фамилий пассажиров титаника.\n", "# Предполагаем, что у каждого из них имя и фамилия из одного слова и нет вторых имён.\n", "titanic_passengers = ['Win Adams', 'James Adams', 'May Connor', 'Al Sinn', 'Beth Sinn', 'Jay Hughes', 'Jenny Adams', 'Wes Garrett',\n", " 'William Young', 'Howard Connor', 'Din Hughes', 'Mary Jane']" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Картинки взяты из онлайн-обучающей страницы https://www.programiz.com/python-programming/set\n", "\n", "Images used are courtesy of https://www.programiz.com/python-programming/set" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 4. Словарь" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "Типы в Python можно разделить на **изменяемые(mutable)** и **неизменные(immutable)**. Словарь, множество и список - изменяемые типы. Простые типы, строки и tuple - неизменные.\n", "\n", "Словарь в Python — это неупорядоченный набор элементов. У них нет индексов, но есть ключи. Особенности словарей:\n", "\n", "* Ключи в словаре уникальны, а значения могут повторяться.\n", "* Доступ к элементу осуществляется по ключу, а не по индексу.\n", "* Значения словаря хранятся в неотсортированном порядке, ключи могут храниться не в том порядке, в котором они добавляются.\n", "* По аналогии со списками, словарь может хранить вложенные словари. Словарь может хранить в качестве значений объекты любого типа. Ключ в словаре — immutable (неизменный) тип, может быть строкой, целым числом, float либо кортежем, состоящим из указанных типов.\n", "* Словари реализованы как хеш-таблицы с быстрым доступом.\n", "* Словари, как и списки, хранят ссылки на объекты, а не сами объекты.\n", "\n", "Основные операции со словарями: создание, удаление, доступ к элементам, вставка, проверка на вхождение, итерирование по словарю.\n", "\n", "Описание словаря в Python (источник: https://younglinux.info/python/dictionary.php)\n", "\n", "![image.png](https://younglinux.info/sites/default/files/images/python/dictionary.gif)\n", "\n" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "dict['Name']: Zara\n", "dict['Age']: 7\n", "Name key exists in this dictionary\n" ] } ], "source": [ "dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}\n", "print (\"dict['Name']: \", dict['Name'])\n", "print (\"dict['Age']: \", dict['Age'])\n", "\n", "# Update existing entry in dict\n", "# Обновление существующего элемента\n", "dict['Age'] = 8; # update existing entry\n", "\n", "# Add new entry\n", "# Добавление нового элемента\n", "dict['School'] = \"My School 40\";" ] }, { "cell_type": "code", "execution_count": 38, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Name key exists in this dictionary\n", "There is something with number 8 there\n", "Name\n", "Age\n", "Class\n", "School\n", "\n", "\n", "\n", "\n", "The Name data set has value \"Zara\".\n", "The Age data set has value \"8\".\n", "The Class data set has value \"First\".\n", "The School data set has value \"My School 40\".\n" ] } ], "source": [ "# Other operations.Looping and iterating\n", "# Другие операция со словарями, итерирование\n", "\n", "# Проверка ключа на вхождение в словарь\n", "if('Name' in dict.keys()):\n", " print (\"Name key exists in this dictionary\")\n", "\n", "# Проверка значения на вхождение в словарь\n", "if(8 in dict.values()):\n", " print (\"There is something with number 8 there\")\n", "\n", "# Цикл по ключам словаря\n", "for key in dict.keys():\n", " print(key)\n", "\n", "# Цикл по значениям\n", "for val in dict.values():\n", " print(type(val))\n", " \n", "# Цикл по ключам и значениям одновременно\n", "for key, val in dict.items():\n", " print(f'The {key} data set has value \"{val}\".')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 4.3. Дополнительная информация о словарях\n", "\n", "1. https://www.dataquest.io/blog/python-dictionary-tutorial/\n", "2. https://www.tutorialspoint.com/python/python_dictionary.htm\n", "3. https://www.ibm.com/developerworks/ru/library/l-python_part_4/index.html" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 4.4. Практика" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# 1. Dictionary with list of groceries with prices\n", "# The task is to calculate sum price of all groceries planned\n", "# 1. Дан словарь со списком покупок и их стоимостью\n", "# Задача: посчитать суммарную стоимость всех покупок\n", "to_buy_prices = {apples: 150, oranges: 100, bananas: 80, kiwi: 120, plum: 200}" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# 2. This dictionary contains people names and their mobile phones brand\n", "# The task is to get a set of all differen phones brand in this dict\n", "# 2. Задан словарь с именами людей и марками их телефонов\n", "# Задача: получить множество (set) всех марок телефонов у этих людей\n", "to_buy_prices = {'Kate': 'iphone', 'Alex': 'samsung', 'Mike': 'iphone', 'Val': 'lg', 'Vic':'iphone', 'Nataly':'asus'}" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "login failed...\n" ] } ], "source": [ "# Homework / Дома: Задан словарь имён пользователей и их паролей\n", "users = { \"user1\" : \"password1\", \"user2\" : \"password2\", \"user3\" : \"password3\" }\n", "\n", "# Написать функцию accept_login() с параметрами – словарь пользоватлей и паролей, \n", "# и то, что пользователь ввёл: имя пользователя и пароль.\n", "def accept_login(dict, username, password):\n", " pass\n", "\n", "# Пример, как функция будет вызваться. \n", "# Проверьте такие варианты: существующий пользователь с верным паролем, с неверным, несуществующий пользователь.\n", "if accept_login(users, \"wronguser\", \"wrongpassword\"):\n", " print(\"login successful!\")\n", "else:\n", " print(\"login failed...\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 5. Что поучить, почитать и послушать, чтобы научиться программировать\n", "1. Пройти от начала до конца один курс. Например, на [Stepik](https://stepik.org/course/67/) или [Coursera](https://www.coursera.org/learn/diving-in-python)\n", " Если затянет, пройти [специализацию из 4 курсов](https://www.coursera.org/specializations/programming-in-python).\n", " \n", "2. Для само-мотивации послушать подкаст [Python Junior](https://podcast.python.ru/)\n", "\n", "3. Процти целиком онлайн-обучающие программы вроде [PythonTutor.ru](http://pythontutor.ru/)\n", "\n", "4. Пойти на курсы offline или найти преподавателя (ментора)\n", "\n", "5. Выучить английский\n" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.6.5" } }, "nbformat": 4, "nbformat_minor": 2 }