Пропустить до содержимого
CodeMDD.io | Coding Tutorials

Как использовать Python namedtuple?

[

Напишите питон-туториал “Python namedtuply” на основе статьи

Python namedtuples (именованные кортежи) предоставляют специальный способ создания неизменяемых типов данных, которые позволяют обращаться к их значениям, используя описательные имена полей вместо неясных целочисленных индексов. Этот модуль предоставляет фабричную функцию namedtuple(), которая помогает сделать ваш код более питоническим при работе с кортежами.

Использование namedtuple для написания питонического кода

namedtuple - это класс фабрики, который создает новый класс, производный от tuple и дополненный описательными именами полей, представляемых в виде строк. Он позволяет создавать классы, которые имеют полезные атрибуты и работают как обычные кортежи python.

Для создания namedtuple используется функция namedtuple(), которая принимает два аргумента: имя класса и перечисление полей, разделенных запятой. Например, если вы хотите создать namedtuple с именем Person и полями name и age, вы можете сделать это следующим образом:

from collections import namedtuple


Person = namedtuple('Person', ['name', 'age'])

Теперь у вас есть класс Person, который может использоваться для создания объектов, представляющих людей с именем и возрастом. Например, вы можете создать объект person1 следующим образом:

person1 = Person(name='John', age=30)

У объекта person1 есть атрибуты name и age, которые представляют его имя и возраст соответственно. Вы можете получить доступ к этим атрибутам, используя точечную нотацию:

print(person1.name)  # Output: John
print(person1.age)   # Output: 30

Этот код делает ваш код более понятным и питоническим, так как вы можете обращаться к значениям по их именам, а не по индексам.

Создание классов Tuple-Like с использованием namedtuple()

namedtuple может также использоваться для создания классов, которые представляются кортежами с определенной структурой, но идентичными полями. Например, вы можете создать namedtuple с именем Point и полями x и y:

Point = namedtuple('Point', ['x', 'y'])

Теперь у вас есть класс Point, который представляет собой точку на плоскости с координатами x и y. Вы можете создать объект point1 следующим образом:

point1 = Point(x=1, y=2)

У point1 есть атрибуты x и y, которые представляют его координаты. Вы можете получить доступ к этим атрибутам так же, как и раньше:

print(point1.x)  # Output: 1
print(point1.y)  # Output: 2

Это делает код более читаемым и ясным, так как комментарии или дополнительная документация могут описывать, что представляют эти параметры.

Использование необязательных аргументов с namedtuple()

namedtuple также поддерживает необязательные аргументы для дополнительных возможностей. Например, вы можете указать аргумент defaults, чтобы задать значения по умолчанию для полей. Рассмотрим пример с классом Person, но на этот раз поле age будет иметь значение по умолчанию 18:

Person = namedtuple('Person', ['name', 'age'], defaults=['John', 18])

Теперь, если вы создадите новый объект person2, у которого нет аргументов, по умолчанию будет использоваться имя John и возраст 18:

person2 = Person()
print(person2.name)  # Output: John
print(person2.age)   # Output: 18

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

Person = namedtuple('Person', ['name', 'age'], defaults=[None, 18])
person3 = Person(name='Alice')


print(person3.name)  # Output: Alice
print(person3.age)   # Output: 18

Теперь, если вы хотите создать объект person3 только с именем Alice, возраст будет иметь значение по умолчанию 18.

Исследование дополнительных возможностей классов namedtuple

namedtuple предоставляет еще некоторые полезные функции и атрибуты, которые могут помочь вам манипулировать данными. Давайте рассмотрим некоторые из них:

Создание экземпляров namedtuple из итерируемых объектов

namedtuple предоставляет метод ._make(), который позволяет создавать экземпляры namedtuple из итерируемых объектов. Например, вы можете создать список значений и передать его в качестве аргумента для создания экземпляра namedtuple:

values = ['John', 30]
person4 = Person._make(values)


print(person4.name)  # Output: John
print(person4.age)   # Output: 30

Преобразование экземпляров namedtuple в словари

namedtuple имеет метод _asdict(), который позволяет преобразовывать экземпляры namedtuple в словари. Например, если у вас есть экземпляр person1, вы можете преобразовать его в словарь следующим образом:

person1_dict = person1._asdict()


print(person1_dict)  # Output: {'name': 'John', 'age': 30}

Замена полей в существующих экземплярах namedtuple

namedtuple поддерживает метод _replace(), который позволяет создавать новые экземпляры namedtuple с замененными значениями полей. Например, если у вас есть экземпляр person1, вы можете заменить его возраст и создать новый экземпляр person1_new_age следующим образом:

person1_new_age = person1._replace(age=35)


print(person1_new_age)  # Output: Person(name='John', age=35)

Исследование дополнительных атрибутов namedtuple

namedtuple имеет еще несколько полезных атрибутов, которые вы можете использовать для получения информации о нем. Например, атрибут ._fields вернет список полей namedtuple. Вы можете использовать этот атрибут, чтобы узнать имена полей класса Person:

print(Person._fields)  # Output: ('name', 'age')

Атрибут ._source предоставляет строку с исходным кодом для определения класса namedtuple. Вы можете использовать его для отладки или для анализа структуры namedtuple:

print(Person._source)  # Output: "class Person(tuple):\n    'Person(name, age)'\n    __slots__ = ()\n    _fields = ('name', 'age')\n    ... (rest of the source code)"

Написание питонического кода с использованием namedtuple

namedtuple позволяет вам писать более питонический код, так как вы можете использовать имена полей вместо индексов. Давайте рассмотрим несколько примеров использования namedtuple для написания кода:

Использование имен полей вместо индексов

def calculate_rectangle_area(rectangle):
    return rectangle.width * rectangle.height


Rectangle = namedtuple('Rectangle', ['width', 'height'])
rectangle1 = Rectangle(width=10, height=5)
area = calculate_rectangle_area(rectangle1)


print(area)  # Output: 50

Вместо передачи width и height в функцию по отдельности, мы передаем целый объект rectangle, который имеет понятные имена полей.

Возврат нескольких именованных значений из функций

def get_user_info(user_id):
    # Perform some database query
    # and get user's name and age
    # ...


    # Return multiple named values using namedtuple
    User = namedtuple('User', ['name', 'age'])
    return User(name='John', age=30)


user_info = get_user_info(1)
print(user_info.name)  # Output: John
print(user_info.age)   # Output: 30

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

Уменьшение количества аргументов у функций

def calculate_sum(numbers):
    return sum(numbers)


Numbers = namedtuple('Numbers', ['one', 'two', 'three'])
numbers = Numbers(one=1, two=2, three=3)
total = calculate_sum(numbers)


print(total)  # Output: 6

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

Чтение табличных данных из файлов и баз данных

import csv


with open('data.csv', 'r') as csvfile:
    reader = csv.DictReader(csvfile)
    Person = namedtuple('Person', reader.fieldnames)
    for row in reader:
        person = Person(**row)
        # Do something with the person object
        # ...

Здесь мы используем namedtuple, чтобы представить каждую строку данных из CSV-файла в виде объекта person с именами полей, соответствующими заголовкам столбцов.

Использование namedtuple по сравнению с другими структурами данных

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

namedtuple против словаря

namedtuple подходит, когда вы знаете точную структуру данных и не планируете изменять ее. Он обеспечивает быстрый доступ к полям за счет использования целочисленных индексов, а также предоставляет понятные имена полей.

Словарь, с другой стороны, предоставляет гибкость для добавления, удаления и изменения полей. Однако он обладает дополнительными накладными расходами на хранение и обращение к данным.

namedtuple против класса данных

namedtuple предоставляет простой и компактный способ задания структуры данных. Он менее гибок по сравнению с полноценным классом данных, но проще в использовании.

Если вам нужно добавить дополнительные методы или функциональность к вашей структуре данных, то может иметь смысл использовать полноценный класс данных.

namedtuple против typing.NamedTuple

typing.NamedTuple - это аннотация типов, которая предоставляет механизм для определения структур данных с явными типами полей. Это может быть полезно при разработке больших проектов с четкими требованиями к типам данных.

namedtuple позволяет определять структуры данных без указания типов и является более простым в использовании. Однако он не предоставляет строгих гарантий типов во время выполнения.

Подклассирование классов namedtuple

namedtuple можно наследовать, чтобы добавить новые методы и атрибуты или переопределить существующие. Например, вы можете создать подкласс Person с дополнительным методом full_name, который возвращает полное имя человека из имени и фамилии:

class Person(namedtuple('Person', ['first_name', 'last_name'])):
    def full_name(self):
        return f"{self.first_name} {self.last_name}"


person = Person(first_name='John', last_name='Doe')
print(person.full_name())  # Output: John Doe

Измерение времени создания: кортеж против namedtuple

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

Однако разница в скорости создания между namedtuple и обычными кортежами незначительна и обычно не является критичной для большинства приложений.

Заключение

namedtuple - это мощный инструмент, который делает ваш код более понятным и питоническим. Он обеспечивает простое и удобное создание неизменяемых типов данных с понятными именами полей.

В этом туториале вы научились создавать namedtuple классы с помощью функции namedtuple(), использовать дополнительные функции и атрибуты классов namedtuple, а также написанию питонического кода с использованием namedtuple.

Используйте namedtuple, чтобы сделать ваш код более понятным и эффективным!