Что такое Data Science? Объясняем простыми словами
Наука о данных (Data Science) включает в себя все инструменты, методы и технологии, помогающие нам обрабатывать данные и использовать их для нашего блага. Это междисциплинарная смесь статистических выводов, анализа данных, разработки алгоритмов и технологий для решения аналитически сложных задач.
Освойте профессию «Data Scientist» на курсе с МГУ
Data Scientist с нуля до PRO
Освойте профессию Data Scientist с нуля до уровня PRO на углубленном курсе совместно с академиком РАН из МГУ. Изучите продвинутую математику с азов, получите реальный опыт на практических проектах и начните работать удаленно из любой точки мира.
25 месяцев
Data Scientist с нуля до PRO
Создавайте ML-модели и работайте с нейронными сетями
11 317 ₽/мес 6 790 ₽/мес
- Организация данных — хранение и форматирование. Также сюда входят практики управления данными (Data Management).
- Агрегация данных — объединение исходных данных в новое представление и/или пакет.
- Доставка данных — обеспечение доступа к массивам агрегированных данных.
Наука о данных — обширная и субъективная тема для обсуждения, которую практически невозможно уместить в одну статью. Сама по себе Data Science не самостоятельная наука, а скорее сочетание нескольких смежных дисциплин: математики и статистики, программирования, бизнес-аналитики и стратегического планирования.
На диаграмме Венна, показано, как все дисциплины сочетаются и работают вместе.
Big Data
Big Data — это различные инструменты, подходы и методы обработки как структурированных, так и неструктурированных данных, которые позволяют использовать эти данные для решения конкретных задач и достижения целей.
Используя анализ Big Data, розничные продавцы смогут заранее узнать, какие продукты будут хорошо продаваться, телекоммуникационные компании смогут предсказать, захочет ли клиент сменить оператора и когда это произойдёт, а страховые компании смогут оценить, насколько безопасно их клиенты управляют автомобилем. Среди прочего, анализ Big Data позволяет нам лучше понимать и прогнозировать эпидемии болезней и находить самые эффективные способы лечения.
Машинное Обучение
Цитируя Тома Митчела: Машинное обучения изучает вопрос создания программ, способных улучшаться в процессе обучения.
Машинное Обучение носит междисциплинарный характер и использует, среди прочего, методы из области информатики, статистики и искусственного интеллекта.
Основной областью исследований в Машинном Обучении являются алгоритмы, которые способны обучаться и запоминать и могут применяться в различных областях науки и бизнеса.
Data Mining (Сбор и интеллектуальный анализ данных)
Файяд, Пятецкий-Шапиро и Смайт дают следующее определение Data Mining:
«Применение специальных алгоритмов для извлечения шаблонов из данных. В интеллектуальном анализе данных акцент делается на применение алгоритмов, а не на сами алгоритмы.»
Мы можем определить взаимосвязь машинного обучения и Data Mining следующим образом: интеллектуальный анализ данных — это процесс, в ходе которого алгоритмы МО используются в качестве инструментов для извлечения потенциально ценных шаблонов, содержащихся в наборах данных.
Станьте дата-сайентистом на курсе с МГУ и решайте амбициозные задачи с помощью нейросетей
Deep Learning
Deep Learning — относительно новый термин, однако существовавший ещё до резкого роста повышения внимания к науке о данных.
Deep Learning — это процесс применения технологий глубоких нейронных сетей — архитектур нейронных сетей с несколькими скрытыми уровнями — для решения поставленных задач.
По сути это Data Mining, в котором используются архитектуры глубоких нейронных сетей — особого типа алгоритмов машинного обучения.
Читайте также 8 причин стать дата-сайентистом в 2023 году
Искусственный интеллект
Искусственный интеллект — научное направление, в рамках которого ставятся и решаются задачи аппаратного или программного моделирования тех видов человеческой деятельности, которые традиционно считаются интеллектуальными.
Исследования, связанные с ИИ, высокотехнологичны и узкоспециализированны. Одной из ключевых задач искусственного интеллекта является программирование компьютеров, которые демонстрируют такие способности, как понимание, рассуждение, решение проблем, восприятие, обучение, планирование и т. д. Основные составляющие ИИ — машинное обучение, инженерия знаний (knowledge engineering) и робототехника.
Принимая во внимание перечисленные научные области, концепции, и инструменты, мы можем без труда заключить: Data Science — это наше будущее, причем ближайшее.
Введение в Data classes
Одна из новых возможностей, появившихся в Python 3.7 — классы данных (Data classes). Они призваны автоматизировать генерацию кода классов, которые используются для хранения данных. Не смотря на то, что они используют другие механизмы работы, их можно сравнить с «изменяемыми именованными кортежами со значениями по умолчанию».
Введение
Все приведенные примеры требуют для своей работы Python 3.7 или выше
Большинству python-разработчикам приходится регулярно писать такие классы:
class RegularBook: def __init__(self, title, author): self.title = title self.author = authorУже на этом примере видна избыточность. Идентификаторы title и author используются несколько раз. Реальный класс же будет ещё содержать переопределенные методы __eq__ и __repr__ .
Модуль dataclasses содержит декоратор @dataclass . С его использованием аналогичный код будет выглядеть так:
from dataclasses import dataclass @dataclass class Book: title: str author: strВажно отметить, что аннотации типов обязательны. Все поля, которые не имеют отметок о типе будут проигнорированы. Конечно, если вы не хотите использовать конкретный тип, вы можете указать Any из модуля typing .
Что же вы получаете в результате? Вы автоматически получаете класс, с реализованными методами __init__ , __repr__ , __str__ и __eq__ . Кроме того, это будет обычный класс и вы можете наследоваться от него или добавлять произвольные методы.
>>> book = Book(title="Fahrenheit 451", author="Bradbury") >>> book Book(title='Fahrenheit 451', author='Bradbury') >>> book.author 'Bradbury' >>> other = Book("Fahrenheit 451", "Bradbury") >>> book == other TrueАльтернативы
Кортеж или словарь
Конечно, если структура довольна простая, можно сохранить данные в словарь или кортеж:
book = ("Fahrenheit 451", "Bradbury") other =
Однако у такого подхода есть недостатки:
- Необходимо помнить, что переменная содержит данные, относящиеся к данной структуре.
- В случае словаря, вы должны следить за названиями ключей. Такая инициализация словаря тоже будет формально корректной.
- В случае кортежа вы должны следить за порядком значений, так как они не имеют имен.
Есть вариант получше:
Namedtuple
from collections import namedtuple NamedTupleBook = namedtuple("NamedTupleBook", ["title", "author"])Если мы воспользуемся классом, созданным таким образом, мы получим фактически то же самое, что и использованием с data class.
>>> book = NamedTupleBook("Fahrenheit 451", "Bradbury") >>> book.author 'Bradbury' >>> book NamedTupleBook(title='Fahrenheit 451', author='Bradbury') >>> book == NamedTupleBook("Fahrenheit 451", "Bradbury")) TrueНо несмотря на общую схожесть, именованные кортежи имеют свои ограничения. Они происходят из того, что именованные кортежи все ещё являются кортежами.
Во-первых, вы все ещё можете сравнивать экземпляры разных классов.
>>> Car = namedtuple("Car", ["model", "owner"]) >>> book = NamedTupleBook("Fahrenheit 451", "Bradbury")) >>> book == Car("Fahrenheit 451", "Bradbury") TrueВо-вторых, именованные кортежи неизменяемы. В некоторых ситуациях это бывает полезно, но хотелось бы большей гибкости.
И наконец, вы можете оперировать именованным кортежем так же как обычным. Например, итерироваться.
Другие проекты
Если не ограничиваться стандартной библиотекой, можно найти другие решения данной задачи. В частности, проект attrs. Он умеет даже больше чем dataclass и работает на более старых версиях python таких как 2.7 и 3.4. И тем не менее, то, что он не является частью стандартной библиотеки, может быть неудобно
Создание
Для создания класса данных можно воспользоваться декоратором @dataclass . В этом случае, все поля класса, определенные с аннотацией типов будут использоваться в соответствующих методах результирующего класса.
В качестве альтернативы есть функция make_dataclass , которая работает аналогично созданию именованных кортежей.
from dataclasses import make_dataclass Book = make_dataclass("Book", ["title", "author"]) book = Book("Fahrenheit 451", "Bradbury")Значения по умолчанию
Одна из полезных особенностей — легкость добавления к полям значений по умолчанию. Все ещё не требуется переопределять метод __init__ , достаточно указать значения прямо в классе.
@dataclass class Book: title: str = "Unknown" author: str = "Unknown author"Они будут учтены в сгенерированном методе __init__
>>> Book() Book(title='Unknown', author='Unknown author') >>> Book("Farenheit 451") Book(title='Farenheit 451', author='Unknown author')Но как и в случае с обычными классами и методами надо быть аккуратным с использованием изменяемых значений по умолчанию. Если вам, например, необходимо использовать список в качестве значения по умолчанию, есть другой способ, но об этом ниже.
Кроме того, важно следить за порядком определения полей, имеющих значения по умолчанию, так как он в точности соответствует их порядку в методе __init__
Иммутабельные классы данных
Экземпляры именованных кортежей неизменяемые. Во многих ситуациях, это хорошая идея. Для классов данных вы тоже можете сделать это. Просто укажите параметр frozen=True при создании класса и если вы попытаетесь изменять его поля, выбросится исключение FrozenInstanceError
@dataclass(frozen=True) class Book: title: str author: str>>> book = Book("Fahrenheit 451", "Bradbury") >>> book.title = "1984" dataclasses.FrozenInstanceError: cannot assign to field 'title'Настройка класса данных
Кроме параметра frozen , декоратор @dataclass обладает другими параметрами:
- init : если он равен True (по умолчанию), генерируется метод __init__ . Если у класса уже определен метод __init__ , параметр игнорируется.
- repr : включает (по умолчанию) создание метода __repr__ . Сгенерированная строка содержит имя класса и название и представление всех полей, определенных в классе. При этом можно исключить отдельные поля (см. ниже)
- eq : включает (по умолчанию) создание метода __eq__ . Объекты сравниваются так же, как если бы это были кортежи, содержащие соответствующие значения полей. Дополнительно проверяется совпадение типов.
- order включает (по умолчанию выключен) создание методов __lt__ , __le__ , __gt__ и __ge__ . Объекты сравниваются так же, как соответствующие кортежи из значений полей. При этом так же проверяется тип объектов. Если order задан, а eq — нет, будет сгенерировано исключение ValueError . Так же, класс не должен содержать уже определенных методов сравнения.
- unsafe_hash влияет на генерацию метода __hash__ . Поведение так же зависит от значений параметров eq и frozen
Настройка отдельных полей
В большинстве стандартных ситуаций это не потребуется, однако есть возможность настроить поведение класса данных вплоть до отдельных полей с использованием функции field.
Изменяемые значения по умолчанию
Типичная ситуация, о которой говорилось выше — использование списков или других изменяемых значений по умолчанию. Мы можете захотеть класс «книжная полка», содержащий список книг. Если вы запустите следующий код:
@dataclass class Bookshelf: books: List[Book] = []интерпретатор сообщит об ошибке:
ValueError: mutable default for field books is not allowed: use default_factoryОднако для других изменяемых значений это предупреждение не сработает и приведет к некорректному поведению программы.
Чтобы избежать проблем, предлагается использовать параметр default_factory функции field . В качестве его значения может быть любой вызываемый объект или функция без параметров.
Корректная версия класса выглядит так:
@dataclass class Bookshelf: books: List[Book] = field(default_factory=list)Другие параметры
Кроме указанного default_factory функция field имеет следующие параметры:
- default : значение по умолчанию. Этот параметр необходим, так как вызов field заменяет задание значения поля по умолчанию
- init : включает (задан по умолчанию) использование поля в методе __init__
- repr : включает (задан по умолчанию) использование поля в методе __repr__
- compare включает (задан по умолчанию) использование поля в методах сравнения ( __eq__ , __le__ и других)
- hash : может быть булевое значение или None . Если он равен True , поле используется при вычислении хэша. Если указано None (по умолчанию) — используется значение параметра compare .
Одной из причин указать hash=False при заданном compare=True может быть сложность вычисления хэша поля при том, что оно необходимо для сравнения. - metadata : произвольный словарь или None . Значение оборачивается в MappingProxyType , чтобы оно стало неизменяемым. Этот параметр не используется самими классами данных и предназначено для работы сторонних расширений.
Обработка после инициализации
Автосгенерированный метод __init__ вызывает метод __post_init__ , если он определен в классе. Как правило он вызывается в форме self.__post_init__() , однако если в классе определены переменные типа InitVar , они будут переданы в качестве параметров метода.
Если метод __init__ не был сгенерирован, то он __post_init__ не будет вызываться.
Например, добавим сгенерированное описание книги
@dataclass class Book: title: str author: str desc: str = None def __post_init__(self): self.desc = self.desc or "`%s` by %s" % (self.title, self.author)
>>> Book("Fareneheit 481", "Bradbury") Book(title='Fareneheit 481', author='Bradbury', desc='`Fareneheit 481` by Bradbury')Параметры только для инициализации
Одна из возможностей, связанных с методом __post_init__ — параметры, используемые только для инициализации. Если при объявления поля указать в качестве его типа InitVar , его значение будет передано как параметр метода __post_init__ . Никак по-другому такие поля не используются в классе данных.
@dataclass class Book: title: str author: str gen_desc: InitVar[bool] = True desc: str = None def __post_init__(self, gen_desc: str): if gen_desc and self.desc is None: self.desc = "`%s` by %s" % (self.title, self.author)>>> Book("Fareneheit 481", "Bradbury") Book(title='Fareneheit 481', author='Bradbury', desc='`Fareneheit 481` by Bradbury') >>> Book("Fareneheit 481", "Bradbury", gen_desc=False) Book(title='Fareneheit 481', author='Bradbury', desc=None)Наследование
Когда вы используете декоратор @dataclass , он проходит по всем родительским классам начиная с object и для каждого найденного класса данных сохраняет поля в упорядоченный словарь (ordered mapping), затем добавляя свойства обрабатываемого класса. Все сгенерированные методы используют поля из полученного упорядоченного словаря.
Как следствие, если родительский класс определяет значения по умолчанию, вы должны будете поля определять со значениями по умолчанию.
Так как упорядоченный словарь хранит значения в порядке вставки, то для следующих классов
@dataclass class BaseBook: title: Any = None author: str = None @dataclass class Book(BaseBook): desc: str = None title: str = "Unknown"будет сгенерирован __init__ метод с такой сигнатурой:
def __init__(self, title: str="Unknown", author: str=None, desc: str=None)Что значит data в питоне
Модуль dataclasses предоставляет декоратор dataclass , который позволяет создавать data-классы — подобные позволяют значительно сократить шаблонный код классов. Как правило, такие классы предназначены для хранения некоторого состояния, некоторых данных и когда не требуется какое-то поведение в виде функций.
Рассмотрим простейший пример:
class Person: def __init__(self, name, age): self.name = name self.age = age tom = Person("Tom", 38) print(f"Name: Age: ") # Name: Tom Age: 38
Здесь определен класс Person, у которого в функции конструктора определены два атрибута: name и age. Далее создаем один объект этого класса и выводим значения его атрибутов на консоль.
Теперь изменим эту программу, сделав класс Person data-классом:
from dataclasses import dataclass @dataclass class Person: name: str age: int tom = Person("Tom", 38) print(f"Name: Age: ") # Name: Tom Age: 38
Для создания data-класса импортируем из модуля dataclasses декоратор dataclass и применяем его к классу Person. И в этом случае в самом классе нам уже не надо указывать конструктор — функцию __init__ . Мы просто указываем атрибуты. А Python потом сам сгенерирует конструктор, в который также мы можем передать значения для атрибутов объекта.
Таким образом, мы уже сократили определение класса и сделали его более простым. Но генерацией метода __init__ функциональность декоратора dataclass не ограничивается. В реальности data-класс
@dataclass class Person: name: str age: int
будет аналогичен следующему:
class Person: def __init__(self, name, age): self.name = name self.age = age def __repr__(self): return f"Person(name=, age=" def __eq__(self, other): if other.__class__ is self.__class__: return (self.name, self.age) == (other.name, other.age) return NotImplemented
В данном случае мы видим, что кроме функции __init__, также определяется функция __repr__() для возвращения строкового представления и функция __eq__() для сравнения двух объектов. Применение данных функций:
from dataclasses import dataclass @dataclass class Person: name: str age: int tom = Person("Tom", 38) bob = Person("Bob", 42) tomas = Person("Tom", 38) print(tom == tomas) # True print(tom == bob) # False print(tom) # Person(name="Tom", age=38)
Параметры декоратора dataclass
С помощью параметров декоратор dataclass позволяет сгенерировать дополнительный шаблонный код и вообще настроить генерацию кода:
def dataclass(cls=None, /, *, init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=False, match_args=True, kw_only=False, slots=False)
Рассмотрим базовые параметры:
- init : если равно True , то генерируется функция __init__() . По умолчанию равно True
- repr : если равно True , то генерируется функция __repr__() , которая возвращает строковое представление объекта. По умолчанию равно True
- eq : если равно True , то генерируется функция __eq__() , которая сравнивает два объекта. По умолчанию равно True
- order : если равно True , то генерируются функции __lt__ (операция <), __le__ (<=), __gt__ (>), __ge__ (>=), которые применяются для упорядочивания объектов. По умолчанию равно False
- unsafe_hash : если равно True , то генерируется функция __hash__() , которая возвращает хеш объекта. По умолчанию равно False
Кроме того, те функции, которые создаются по умолчанию, могут быть переопределены.
from dataclasses import dataclass @dataclass(unsafe_hash=True, order=True) class Person: name: str age: int def __repr__(self): return f"Person. Name: Age: " tom = Person("Tom", 38) print(tom.__hash__()) # -421667297069596717 print(tom) # Person. Name: Tom Age: 38
В данном случае включаем генерирование хеша и функций упорядочивания, а также явным образом переопределяем функцию __repr__ для создания строкового представления объекта.
значения по умолчанию
При необходимости атрибутам можно присвоить значения по умолчанию, если в конструкторе им не передаются значения:
from dataclasses import dataclass @dataclass class Person: name: str age: int = 18 tom = Person("Tom", 38) print(tom) # Person(name="Tom", age=38) bob = Person("Bob") print(bob) # Person(name="Bob", age=18)
Добавление дополнительного функционала
Хотя data-классы предназначены прежде всего для хранения различных данных, но также в них можно определять поведение с помощью дополнительных функций:
from dataclasses import dataclass @dataclass class Person: name: str age: int def say_hello(self): print(f" says hello") tom = Person("Tom", 38) tom.say_hello() # Tom says hello
Приступая к работе с данными¶
Как мы уже отмечали выше, Python поддерживает парадигму объектно-ориентированного программирования. Это означает, что в фокус процесса решения задачи им ставятся данные. В Python, как и в любом другом объектно-ориентированном языке программирования, мы определяем класс, являющийся описанием того, как, собственно, выглядят данные (состояние) и что они могут делать (поведение). Классы аналогичны абстрактным типам данных, поскольку пользователь видит только состояние и поведение единицы данных. Такие единицы в объектно-ориентированной парадигме называются объектами. Объект является экземпляром класса.
Встроенные элементарные типы данных¶
Начнём наш обзор с рассмотрения элементарных типов данных. У Python есть два основных встроенных числовых класса, реализующих типы для целых чисел и чисел с плавающей запятой. Они называются int и float . Стандартные арифметические операции +, -, , / и * (возведение в степень) могут использоваться со скобками, задающими порядок операций, отличный от обусловленного обычным приоритетом операторов. Другими полезными операциями являются операторы получения остатка от деления % и собственно целочисленного деления //. Обратите внимание, что при делении двух целых чисел результат — число с плавающей запятой. Оператор целочисленного деления возвращает целую часть частного путём отсечения от неё дробной части.
Run Save Load Show in Codelens
Основные арифметические операторы (intro_1)
Логический тип данных, реализованный в Python как класс bool , будет весьма полезен для представления значений истинности. Возможными значениями для логического объекта являются True и False со стандартными булевыми операторами and , or и not .
>>> True True >>> False False >>> False or True True >>> not (False or True) False >>> True and True True
Объекты булева типа данных также используются в качестве результатов операций сравнения (например, “равно” (==) и “больше, чем” ( \(>\) )). Кроме того, операторы отношений и логических операций могут быть скомбинированы вместе в форме сложных логических вопросов. В таблице 1 показаны операторы отношений и логические операторы вместе с примерами их использования.
| Название | Оператор | Описание |
|---|---|---|
| меньше | \( | Оператор “меньше” |
| больше | \(>\) | Оператор “больше” |
| меньше или равно | \( | Оператор “меньше или равно” |
| больше или равно | \(>=\) | Оператор “больше или равно” |
| равно | \(==\) | Оператор равенства |
| не равно | \(!=\) | Оператор неравенства |
| логическое “и” | \(and\) | Если оба операнда истинны, то результат тоже истина |
| логическое “или” | \(or\) | Если хотя бы один из операндов истина, то результат — истина |
| логическое “не” | \(not\) | Инвертирует значение: False становится True и наоборот |
Run Save Load Show in Codelens
Основные логические операторы и операторы отношений (intro_2)
В качестве имён в языках программирования используются идентификаторы. В Python они начинаются с буквы или подчёркивания (_), чувствительны к регистру и могут быть произвольной длины. Не забывайте о том, что давать имена, отражающие смысл переменной, — всегда здравая идея, делающая ваш код более простым для чтения и понимания.
В Python переменная создаётся при первом использовании имени с левой стороны от оператора присваивания. Присваивание предоставляет возможность ассоциировать имя со значением. Переменная будет содержать ссылку на кусочек данных, а не сами данные. Рассмотрим следующий код:
>>> theSum = 0 >>> theSum 0 >>> theSum = theSum + 1 >>> theSum 1 >>> theSum = True >>> theSum True
Присваивание theSum = 0 создаёт переменную с именем theSum , содержащую ссылку на объект данных 0 (см. рисунок 3). В целом, когда правая часть оператора присваивания вычисляется, ссылка на результат “назначается” имени в левой части. В данный момент в нашем примере тип переменной — целое, и это тип данных, на которые сейчас ссылается theSum . Если он изменится (см. рисунок 4), как показано выше, на булево значение True , то изменится и тип переменной (сейчас theSum имеет тип bool ). Оператор присваивания меняет ссылки, хранящиеся в переменной. Это динамическая характеристика Python. Одна и та же переменная может ссылаться на различные типы данных.
Рисунок 3: Переменная содержит ссылку на объект данных
Рисунок 4: Присваивание изменяет ссылку
Встроенные составные типы данных¶
Кроме числовых и булева типов у Python есть несколько мощных встроенных составных классов. Списки, строки и кортежи являются упорядоченными коллекциями. Они весьма схожи по общей структуре, но имеют специфические различия, понимать которые необходимо для уместного их использования. К неупорядоченным коллекциям относятся множества и словари.
Список — это упорядоченная коллекция из нуля или более ссылок на объекты данных Python. Списки записываются как разделённые запятыми значения, заключённые в квадратные скобки. Пустой список выглядит просто [] . Списки гетерогенны. Это означает, что их объекты не обязательно должны иметь один и тот же тип, и коллекция может быть присвоена переменной, как показано ниже. Следующий фрагмент показывает различные объекты данных Python, объединённые в список.
>>> [1,3,True,6.5] [1, 3, True, 6.5] >>> myList = [1,3,True,6.5] >>> myList [1, 3, True, 6.5]
Обратите внимание, что результатом вычисления списка в Python является он сам. Тем не менее, чтобы запомнить список для последующей обработки, ссылка на него должна быть присвоена переменной.
Поскольку списки считаются последовательно упорядоченными, то они поддерживают ряд операций, которые могут быть применены к любой Python-последовательности. Эти операции собраны в таблице 2 вместе с примерами их использования.
| Имя оператора | Оператор | Пояснение |
|---|---|---|
| индексирование | [ ] | Доступ к элементу последовательности |
| конкантенация | + | Объединение двух последовательностей |
| повторение | * | Конкатенация повторений заданное количество раз |
| принадлежность элемента | in | Запрос о принадлежности элемента данной последовательности |
| длина | len | Запрос количества элементов в последовательности |
| срез | [ : ] | Выделение части последовательности |
Обратите внимание, что индексы элементов списка начинаются с 0. Операция среза myList[1:3] возвращает список, начинающийся с элемента под индексом 1, но при этом не включает в себя элемент под индексом 3.
Иногда у вас может возникнуть желание проинициализировать список. Этого легко достичь, используя повторения. Например,
>>> myList = [0] * 6 >>> myList [0, 0, 0, 0, 0, 0]
Одно важное отступление, касающееся оператора повторения: его результатом будет последовательность повторений ссылок на объект данных. Это хорошо видно в следующем примере:
Run Save Load Show in Codelens
Повторение ссылок (intro_3)
Переменная А содержит коллекцию из трёх ссылок на оригинальный список myList . Обратите внимание, что изменение одного элемента в myList отражается на всех трёх вхождениях в А .
Списки поддерживают ряд методов, которые будут использоваться для построения структур данных. В таблице 3 представлено обобщение методов для работы со списками. Ниже идут примеры их применения.
| Название метода | Использование | Пояснение |
|---|---|---|
| append | alist.append(item) | Добавить новый элемент в конец списка |
| insert | alist.insert(i,item) | Вставить элемент в i-ую позицию списка |
| pop | alist.pop() | Удалить из списка и вернуть последний элемент |
| pop | alist.pop(i) | Удалить из списка и вернуть i-й элемент |
| sort | alist.sort() | Отсортировать список (изменяет оригинал) |
| reverse | alist.reverse() | Изменить список, чтобы элементы шли в обратном порядке |
| del | del alist[i] | Удалить элемент на i-й позиции |
| index | alist.index(item) | Вернуть индекс первого вхождения item |
| count | alist.count(item) | Вернуть число вхождений item в список |
| remove | alist.remove(item) | Удалить первое вхождения item |
Run Save Load Show in Codelens
Примеры методов для списков (intro_5)
Как вы можете видеть, некоторые методы (например, pop ) возвращают значение и при этом модифицируют список. Другие (как reverse ) просто изменяют список. По умолчанию pop применяется к концу списка, но может также удалять и возвращать конкретное значение. Для всех этих методов индексация по прежнему начинается с нуля. Вы также могли отметить знакомую “dot”-нотацию, запрашивающую у объекта вызов метода. myList.append(False) можно прочитать как “запросить у объекта myList , выполнить его метод append , с чей помощью добавить в список значение False ”. Даже такие простые объекты данных, как целые числа, могут вызывать свои методы подобным образом.
>>> (54).__add__(21) 75 >>>
В этом фрагменте мы просим объект целочисленного типа 54 выполнить его метод add (в Python называется __add__ ), передав в него 21 , как число, которое нужно прибавить. Результатом будет сумма 75 . Конечно, обычно мы это пишем как 54+21 . Подробнее об этих методах мы поговорим чуть позже.
Ещё одной распространённой функцией, часто обсуждаемой в связке со списками, является функция range . Она производит объект “диапазон”, представляющий из себя последовательность значений. Используя функцию list , можно представить значение такого объекта в виде списка. Это проиллюстрировано ниже:
>>> range(10) range(0, 10) >>> list(range(10)) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> range(5,10) range(5, 10) >>> list(range(5,10)) [5, 6, 7, 8, 9] >>> list(range(5,10,2)) [5, 7, 9] >>> list(range(10,1,-1)) [10, 9, 8, 7, 6, 5, 4, 3, 2] >>>
Объект “диапазон” представляет из себя последовательность целых чисел. По умолчанию он начинается с нуля. Если вы предоставите больше параметров, то он будет начинаться и заканчиваться в конкретных точках и сможет даже пропускать некоторые элементы. В нашем первом примере — range(10) — последовательность начинается с 0 и продолжается до 9 (не включая 10). Во втором примере — range(5,10) — начинается с 5 и заканчивается 9 (опять же, не включая 10). range(5,10,2) работает аналогично, но пропускает каждый второй элемент (10 по прежнему не включается).
Строки представляют собой коллекции с последовательным доступом из нуля или более букв, чисел и прочих знаков. Мы называем все эти элементы символами. Строковый литерал отличается от идентификатора использованием кавычек (одинарных или двойных).
>>> "David" 'David' >>> myName = "David" >>> myName[3] 'i' >>> myName*2 'DavidDavid' >>> len(myName) 5 >>>
Поскольку строки — это последовательности, то все описанные выше операции будут с ними работать так, как ожидается. Дополнительно у строк есть ещё несколько методов, некоторые из которых представлены в таблице 4. Например,
>>> myName 'David' >>> myName.upper() 'DAVID' >>> myName.center(10) ' David ' >>> myName.find('v') 2 >>> myName.split('v') ['Da', 'id']
Из них очень полезным для обработки данных является метод split . Он принимает строку и возвращает список строк, используя расщепляющий символ как точку разделения. В нашем примере таковым является v . Если разделитель не указан, то split ищет пробельные символы (табуляции, переходы на новую строку и пробелы).
| Название метода | Использование | Пояснение |
|---|---|---|
| center | astring.center(w) | Возвращает строку, центрированную в поле размера w |
| count | astring.count(item) | Возвращает число вхождений item в строку |
| ljust | astring.ljust(w) | Возвращает строку с выравниванием по левому краю поля размером w |
| lower | astring.lower() | Возвращает строку из символов в нижнем регистре |
| rjust | astring.rjust(w) | Возвращает строку с выравниванием по правому краю поля размером w |
| find | astring.find(item) | Возвращает индекс первого вхождения item |
| split | astring.split(schar) | Разбивает строку на подстроки по символу schar |
Основное различие между списками и строками заключается в том, что списки можно изменять, а строки — нет. Это свойство называется мутабельностью. Списки мутабельны, строки иммутабельны. Например, вы легко можете изменить элемент списка, используя индексацию и присваивание. Для строк такие операции не допускаются.
>>> myList [1, 3, True, 6.5] >>> myList[0]=2**10 >>> myList [1024, 3, True, 6.5] >>> >>> myName 'David' >>> myName[0]='X' Traceback (most recent call last): File "", line 1, in -toplevel- myName[0]='X' TypeError: object doesn't support item assignment >>>
Кортежи очень похожи на списки тем, что также являются гетерогенными последовательностями данных. Различие заключается в иммутабельности кортежей подобно строкам. Они не могут быть изменены. Кортежи записываются как разделённые запятыми значения, заключённые в круглые скобки. Будучи последовательностями, они могут использовать любые операции, описанные выше. Например:
>>> myTuple = (2,True,4.96) >>> myTuple (2, True, 4.96) >>> len(myTuple) 3 >>> myTuple[0] 2 >>> myTuple * 3 (2, True, 4.96, 2, True, 4.96, 2, True, 4.96) >>> myTuple[0:2] (2, True) >>>
Однако, если вы попытаетесь изменить элемент кортежа, то получите сообщение об ошибке. Обратите внимание, что такое сообщение содержит место и причину возникновения проблемы.
>>> myTuple[1]=False Traceback (most recent call last): File "", line 1, in -toplevel- myTuple[1]=False TypeError: object doesn't support item assignment >>>
Множеством называется неупорядоченная коллекция из нуля или более неизменяемых объектов данных Python. Множества не допускают дубликатов и записываются как разделённые запятыми значения, заключённые в фигурные скобки. Пустое множество обозначается как set() . Множества гетерогенны и могут присваиваться переменным, как показано ниже.
>>> 3,6,"cat",4.5,False> >>> mySet = 3,6,"cat",4.5,False> >>> mySet >>>
Не смотря на то, что множества не считаются последовательностями, они поддерживают некоторые знакомые операции из рассмотренных выше. Обзор таких операций представлен в таблице 5, а дальнейший код демонстрирует примеры их использования.
| Название оператора | Оператор | Пояснение |
|---|---|---|
| membership | in | Принадлежность множеству |
| length | len | Возвращает количество элементов множества |
| | | aset | otherset | Возвращает новое множество, содержащее все элементы обоих множеств |
| & | aset & otherset | Возвращает новое множество из элементов, общих для обоих множеств |
| - | aset - otherset | Возвращает новое множество из элементов первого множества, не входящих во второе |
| aset | Спрашивает, все ли элементы первого множества входят во второе |
>>> mySet >>> len(mySet) 5 >>> False in mySet True >>> "dog" in mySet False >>>
Множества поддерживают некоторые операции, которые будут знакомы тем, кто работал с ними в области математики. Обобщение по таким операциям дано в таблице 6, ниже идут примеры. Обратите внимание, что union , intersection , issubset и difference имеют специальные операторы, которые можно использовать вместо них.
| Название | Использование | Пояснение |
|---|---|---|
| union | aset.union(otherset) | Возвращает новое множество, состоящее из всех элементов обоих исходных множеств |
| intersection | aset.intersection(otherset) | Возвращает новое множество, состоящее только из элементов, общих для обоих исходных множеств |
| difference | aset.difference(otherset) | Возвращает новое множество, содержащее все элементы первого множества, не принадлежащие второму |
| issubset | aset.issubset(otherset) | Спрашивает, все ли элементы первого множества входят во второе |
| add | aset.add(item) | Добавляет новый элемент в множество |
| remove | aset.remove(item) | Удаляет элемент из множества |
| pop | aset.pop() | Удаляет произвольный элемент из множества |
| clear | aset.clear() | Удаляет все элементы из множества |
>>> mySet >>> yourSet = 99,3,100> >>> mySet.union(yourSet) >>> mySet | yourSet >>> mySet.intersection(yourSet) >>> mySet & yourSet >>> mySet.difference(yourSet) >>> mySet - yourSet >>> 3,100>.issubset(yourSet) True >>> 3,100>yourSet True >>> mySet.add("house") >>> mySet >>> mySet.remove(4.5) >>> mySet >>> mySet.pop() False >>> mySet >>> mySet.clear() >>> mySet set() >>>
Заключительной из рассматриваемых нами коллекций Python станет неупорядоченная структура, называемая словарём. Словари - это коллекции ассоциированных пар элементов, каждая из которых состоит из ключа и значения. Эти пары обычно записываются как ключ:значение. Словари выглядят, как разделённые запятыми пары ключ:значение, заключённые в фигурные скобки. Например,
>>> capitals = 'Iowa':'DesMoines','Wisconsin':'Madison'> >>> capitals >>>
Мы можем манипулировать словарём с помощью доступа к значению по его ключу или добавляя ещё одну пару ключ-значение. Синтаксис доступа выглядит очень похоже на аналогичный для последовательностей, за исключением того момента, что вместо индекса элемента, мы используем его ключ. Добавление новых элементов тоже похоже.