Списки(list) в python

Способ 4: введение типа и методы набора () ()

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

Для тех, кто не делает много с наборы они один из четырех питона Встроенный типы данных. Они являются неупорядоченной и неиспользованной коллекцией данных, и они приходят с некоторыми очень умными методами, которые мы можем использовать. Есть 17 методов для использования на наборах, и я сначала познакомим вас с двумя из тех, кого я чувствую, лучше всего подходит. Первый дает нам много так же, как мы сделали, используя а также , в то время как второй дает элегантный способ возврата предметов, общих до двух списков.

• – возвращает ли другой набор этот набор или нет

• – Возвращает набор, то есть пересечение двух других наборов

И вот код, использующий оба метода на каждом из наших трех сравнений списка.

# Main list
lst_a = 

# ALL items are in lst_a
lst_b = 

# SOME items are in lst_a
lst_c = 

# NO items are in lst_a
lst_d = 

print(set(lst_b).issubset(lst_a))
print(set(lst_c).issubset(lst_a))
print(set(lst_d).issubset(lst_a), '\n')

print(list(set(lst_a).intersection(set(lst_b))))
print(list(set(lst_a).intersection(set(lst_c))))
print(list(set(lst_a).intersection(set(lst_d))))

# Result #
True
False
False 



[]

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

Если это не важно для вас, вы сохраните немного кода и верните набор

Фильтр Python Список нескольких условий

То же самое относится же, если вы хотите объединить несколько условий. Скажем, вы хотите отфильтровать все элементы X> 9 и X <1. Это два (простых) условия. Вы можете определить все сложные условия в элементе списка, чтобы решить, следует ли выфильтировать его или нет. Для этого создайте функцию (E.g., ), которая принимает один элемент списка в качестве ввода и возвращает логическое значение Если условие будет выполнено или иначе.

Вот тот же пример кода, что и раньше:

def condition(x):
    '''Define your arbitrarily
    complicated condition here'''

    return x<10 and x>0

lst = 

# Filter out all elements that do
# not meet condition
filtered = 
print(filtered)
# 

Все элементы, которые меньше 10 и больше, чем 0, включены в отфильтрованный список. Таким образом, только один элемент 3 остается.

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

Для работы с символами (строками) отлично работают основные методы. Сохранить такой список построчно в файл listfile.txt можно следующим образом:

# define list of places
places = 

with open('listfile.txt', 'w') as filehandle:
    for listitem in places:
        filehandle.write('%s\n' % listitem)

В строке 6 элемент списка, во-первых, расширяется переносом строки «\n» и, во-вторых, сохраняется в выходном файле. Чтобы прочитать весь список из файла listfile.txt, этот код Python показывает вам, как это работает:

# define an empty list
places = []

# open file and read the content in a list
with open('listfile.txt', 'r') as filehandle:
    for line in filehandle:
        # remove linebreak which is the last character of the string
        currentPlace = line

        # add item to the list
        places.append(currentPlace)

Имейте в виду, что вам нужно удалить перенос строки с конца строки. В этом случае нам помогает то, что Python также допускает операции со списком для строк. В строке 8 приведенного выше кода это удаление просто выполняется, как операция списка над самой строкой, которая сохраняет все, кроме последнего элемента. Этот элемент содержит символ «\n», обозначающий разрыв строки в системах UNIX и Linux.

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

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

>>> cars =
>>> cars
>>> cars’bmw’
>>> cars.title()’Bmw’

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

2.2. Индексы начинаются с 0, а не с 1.

В Python, как и во многих других языках, первый элемент имеет индекс , а не 1. Если при выполнении программы, вы получили неожиданный результат, то проверьте не допустили ли вы ошибку по смещению на 1. Второй элемент списка идет под индексом 1. Например, чтобы обратиться к третьему элементу списка, следует запросить элемент с номером 2. В следующем примеры выводятся элементы с индексом 1 и 3.

>>> cars =       
>>> cars’bmw’
>>> cars’kia’

>>> cars’land rover’
>>> cars’ford’

В Python есть возможность для обращения сразу к последнему элементу списка. Для этого нужно запросить элемент с индексом .  Этот синтаксис так же распространяется и на другие отрицательные значения индексов. Индекс  возвращает третий элемент с конца, и т.д.

Вопрос 10. Как объединить два списка в список кортежей?

Сложность: (> ⌒ <)

Для объединения двух списков в список кортежей можно использовать функцию zip, причём не только для двух, но и для трёх и более списков. Это полезно для формирования, например, матриц из векторов.

В первых двух строчках мы создали два списка, которые надо объединить. В третьей с помощью конструкции, похожей на двойной генератор, создали список, состоящий из кортежей вида (k, v), где k и v берутся из двух наших списков с помощью функции zip(). К слову, она не зря носит такое название: в переводе zip означает «застёжка-молния», и эта функция как бы сшивает два списка в один.

Список фильтра Python с лямбда

Функция принимает функцию фильтра в качестве аргумента, который принимает один элемент списка в качестве ввода и возвращает логическое значение Если условие будет выполнено или иначе. Эта функция решает, включен ли элемент в отфильтрованный список или нет.

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

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

# Create the list
lst = 

# Get all odd values
print(list(filter(lambda x: x%2, lst)))
# 

Лямбда функция принимает один аргумент – элемент для проверки на фильтре и возвращает результат выражения Отказ Это выражение модуля возвращает 1, если целое число нечетное и 0, если это даже. Таким образом, все нечетные элементы передают тест.

Метод collection.counter()

Метод collection.counter() может использоваться для сравнения списков. Функция counter() подсчитывает частоту элементов в списке и сохраняет данные в виде словаря, представленного в формате <значение>: <частота>. Если два списка имеют одинаковый выходной словарь, то они одинаковы.

Примечание: порядок элементов списка не влияет на результат работы метода counter().

Пример

import collections 

l1 = 
l2 = 
l3 = 

if collections.Counter(l1) == collections.Counter(l2):
	print ("Списки l1 и l2 одинаковые")
else:
	print ("Списки l1 и l2 неодинаковые")

if collections.Counter(l1) == collections.Counter(l3):
	print ("Списки l1 и l3 одинаковые")
else:
	print ("Списки l1 и l3 неодинаковые")

Вывод

Списки l1 и l2 неодинаковые
Списки l1 и l3 одинаковые

1. В каких ситуациях лучше использовать списки, а в каких кортежи, словари или множества?

Материал во введении кажется довольно простым, когда вы просто читаете его, но когда вы на самом деле работаете над небольшим скриптом на Python или над целым проектом, выбор списка или какого-либо другого типа последовательности может быть не таким очевидным для вас.

Но выбор правильной структуры для ваших данных очень важен!

Списки против кортежей

Кортежи используются для хранения неизменяемых упорядоченных наборов элементов. Это означает следующее:

• вы не можете добавлять элементы в кортеж. Таким образом, методов или для кортежей не существует;
• вы не можете удалять элементы из кортежа. Значит, методов и также нет;
• но вы можете находить элементы в кортеже, так как это его не изменяет;
• также вы можете использовать оператор для проверки нахождения элемента в кортеже.

Таким образом, если у вас есть постоянное множество значений и вы не собираетесь ничего с ним делать (кроме перебора), то используйте кортежи вместо списков. Их использование будет быстрей и безопасней, так как они защищены от записи.

Списки против словарей

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

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

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

Списки против множеств

• Как и словари, множества это неупорядоченные наборы данных (в отличие от списков).
• Множества требуют, чтобы данные, хранящиеся в них, были хэшируемыми. Списки поддерживают хранение нехэшируемых типов данных.
• Множества требуют, чтобы элементы, содержащиеся в них, были уникальными и неизменяемыми. Дубликаты недопустимы во множествах, в то время как в списках они возможны, равно как и возможно и изменять сами элементы.

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

Вы не уверены, какие значения можно хэшировать?

Взгляните на таблицу ниже:

Хэшируемые объекты	нехэшируемые объекты
Floats	Dictionaries
Integers	Sets
Tuples	Lists
Strings
frozenset()

Не верьте нам на слово! Поэксперементируйте сами!

# Импортируем библиотеку `collections`
import collections

# Проверяем, можно ли хэшировать словарь
print(isinstance({}, collections.Hashable))

# Проверяем на хэшируемость число с плавающей запятой
print(isinstance(0.125, collections.Hashable))

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

Функция All()

Функция возвращает True, если все элементы в итерируемом типе являются истинными. Рассмотрим следующий пример:

item_list = 
print (all(item_list))

При вызове функции в качестве аргумента в неё передаётся итерируемый объект . После выполнения кода выше вы получите следующий результат:

True

В данном случае функция вернула значение True, так как все элементы в итерируемом объекте равны True. 

Любые непустые строки всегда рассматриваются как True.

item_list = 
print (all(item_list))

Код вернёт следующий результат:

Если список совершенно пуст, всегда будет возвращать True.

item_list = []
print (all(item_list))

Получаем:

Если некоторые элементы итерируемого объекта  – пустые строки, при вызове они считаются False:

item_list = 
print (all(item_list))

При запуске данного фрагмента кода вы получите следующий результат:

Так как последний элемент (пустая строка) в был False, функция вернула значение False.

Если элемент равен 0 (тип , пишется без кавычек), функция расценит его как False:

item_list = 
print (all(item_list))

Результат:

И, наконец, если элемент просто равен False (булево значение), вернёт False:

item_list = 
print (all(item_list))

Результат:

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

• «» (пустая строка)
• 0 (без кавычек, тип )
• False (без кавычек, тип boolean)

Иногда вам может понадобиться преобразовать каждое значение итерируемого типа в True или False на основании определённых условий и затем вызвать для результата функцию . В этом случае вы можете использовать синтаксис списковых включений, чтобы напрямую передавать значения True или False в функцию:

item_list = 
print (all(item > 2 for item in item_list))

В функции синтаксис списковых включений используется там, где цикл пробегает по элементам . Каждый элемент в сравнивается с 2, и, если он больше, он становится True, в противном случае — False. Затем функция проверяет на истинность каждый элемент.

Вы можете проверить результат, добавив ещё один :

item_list = 
print (all(item > 2 for item in item_list))
print ()

Данный код выведет следующий результат:

Не все значения здесь истинны, поэтому функция вернёт False.

В чем разница между методами append() и extend()?

Давайте возьмемся за этот вопрос, вернувшись к концепции итерируемости, которую мы объяснили в начале нашей статьи.

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

Совет: чтобы проверить, является ли переменная итерируемой, воспользуйтесь методом __iter__. Вот пример такого кода:

# Эта ваш список
list = 
# Проверим, итерируемый он или нет
list.__iter__

Запустите данный код самостоятельно и убедитесь, что списки являются итерируемыми объектами.

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

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

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

# Добавляем список  в список `shortList`
shortList.append()
# Используем метод print() для вывода shortList на экран
print(shortList)
# Расширяем `longerList` при помощи списка 
longerList.extend()
# Используем метод print() для вывода longerList на экран
print(longerList)

Результат:

Сортировка списков в Python

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

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

Примечание. Вызов метода изменяет существующий список и не создает нового. Если вы хотите получить новый список с отсортированными элементами, а старый оставить в исходном состоянии, используйте метод .

shopping_list.sort()
print(shopping_list)
# Вывод
>> 

Еще один полезный метод — . С его помощью можно узнать, сколько раз определенный элемент встречается в списке. вернет количество вхождений в список .

Способы Итерации по списку в Python

В этом уроке мы подробно обсудим все 11 способов перебора списка в python, которые заключаются в следующем:

<сильный>1. Перебирайте список в Python, Используя For Loop2. Итерация по Списку в Python С Помощью While Loop3. Итерация по Списку в Python С Помощью Модуля Numpy4. Итерация по Списку в Python С Использованием Метода Enumerate5. Итерация по Списку в Python С Использованием Понимания списка6. Итерация по списку в Python С использованием цикла и диапазона7. Перебирайте список в Python С помощью Map и Lambda8. Перебирайте список в Python С помощью Iter() и Next()9. Перебирайте список в Python С Помощью zip()10. Перебирайте список в Python С помощью Itertools.Цикл11. Итерация по списку в Python с помощью Itertools Grouper

Итерационный словарь

Словарь можно повторять с помощью цикла for, как указано ниже.

Пример 1:

# цикл для печати всех ключей словаря

Employee = {"Name": "John", "Age": 29, "salary":25000,"Company":"GOOGLE"}  
for x in Employee:  
    print(x)

Выход:

Name
Age
salary
Company

Пример 2:

#for цикл для печати всех значений словаря

Employee = {"Name": "John", "Age": 29, "salary":25000,"Company":"GOOGLE"}  
for x in Employee:  
    print(Employee)

Выход:

John
29
25000
GOOGLE

Пример 3:

#for цикл для печати значений словаря с помощью метода values().

Employee = {"Name": "John", "Age": 29, "salary":25000,"Company":"GOOGLE"}  
for x in Employee.values():  
    print(x)

Выход:

John
29
25000
GOOGLE

Пример 4:

#for цикл для печати элементов словаря с помощью метода items().

Employee = {"Name": "John", "Age": 29, "salary":25000,"Company":"GOOGLE"}  
for x in Employee.items():  
    print(x)

Выход:

('Name', 'John')('Age', 29)('salary', 25000)('Company', 'GOOGLE')

Условный оператор if

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

if  условие:    # блок if    <операторы>else:    # блок else    <операторы>

Блок инструкций if будет выполнен, если условие истинно. Если условие ложно, будет выполнен блок инструкций else.

В условном операторе  может отсутствовать слово else и последующий блок. Такая инструкция называется неполным ветвлением.

Пример 5.  Записать следующее   выражение  на языке Python.Если a  >  0,  то  b  =  1,   иначе  a  =  0. 

print («Введите значение a: «) a = int(input())if a > :     b = 1       else:     b = print(«b = «, b)

Условный оператор  elif

if условие_1:   # блок if   <операторы>elif условие_2:   # первый блок elif   <операторы>elif условие_3:   <операторы>...else   # блок else   <операторы>   

Ключевое слово elifрасшифровывается, как else + if. Это конструкция позволяет  реализовать алгоритм  выбора   необходимого варианта из нескольких альтернативных вариантов.  Оператор elif позволяет упростить код. Сделать его легче читаемым и позволяет избежать написание несколько условий  if.

Когда исполняется инструкция if-elif-else, в первую очередь  проверяется условие_1.  Если условие истинно, тогда исполняется блок инструкций if .  Следующие условия и операторы пропускаются, и управление переходит к оператору  за  условным оператором if-elif-else.

Если условие_1 оказывается ложным, тогда управление переходит к следующему условию elif,  и проверяется условие_2.  Если оно истинно, тогда исполняются инструкции внутри первого блока elif. Последующие инструкции внутри этого блока пропускаются. Этот процесс повторяется, пока не находится условие elif, которое оказывается истинным. Если такого нет, тогда исполняется блок операторов else

 Пример.  

x = int(input())
y = int(input())if x > and y > print("Первая четверть")elif x > and y < print("Четвертая четверть")elif y > print("Вторая четверть")else: print("Третья четверть")

sort(ключ, реверс)

Эта функция используется для сортировки элементов. Элементы списка должны реализовывать функцию __lt __ (self, other).

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

reverse принимает логическое значение. Если True, то список сортируется в обратном порядке. Значение по умолчанию Reverse — False, и элементы сортируются в естественном порядке.

>>> list_num = 
>>> list_num.sort()
>>> list_num

>>> list_num.sort(reverse=True)
>>> list_num

>>> 

6. Как разбить список Python на равные части?

Чтобы разбить список на равные части, можно воспользоваться функцией в сочетании с функцией .

# Наш список `x`
x = 

# Разбиваем `x` на 3 части
y = zip(**3)

# Выводим результат
list(y)

Результат:

Данный код работает следующим образом:

• Функция создает итератор последовательности.
• Выражение  создает три объекта типа  , каждый из них — итератор списка .
• Символ ««, стоящий перед аргументом в функции , распаковывает стоящее после него выражение таким образом, как будто мы передаем один и тот же итератор в функцию три раза, и из каждого итератора функция извлекает элемент.

Стоп! Последний шаг абсолютно непонятен!

Давайте еще раз пройдемся по шагам:

У нас есть три объекта итератора списка x

Представим их следующим образом:
В первый раз функция берет по одному элементу последовательно из итераторов списка, что дает нам следующую картину:Обратите внимание, что объекты итератора внимательно отслеживают, какой элемент идет следующим!
Во второй раз следующие элементы будут добавлены в три наши списка, что соответственно даст нам:
И в последний раз, после выполнения данной процедуры мы получим:
Соединение этих списков вместе даст нам следующий список из трех кортежей:. Если вы хотите применить эту логику в самостоятельно написанной функции, то можете получить вот такой результат:

Если вы хотите применить эту логику в самостоятельно написанной функции, то можете получить вот такой результат:

# Данная функция разбивает список на равные части
def chunks(list, chunkSize):
    """Yield successive chunkSize-sized chunks from list."""
    for i in range(0, len(list), chunkSize):
        yield list

# Выводим результаты на экран
import pprint
pprint.pprint(list(chunks(range(10, 75), 10)))

Результат:

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

Внутри нее вы видите цикл, диапазон которого задается функцией . Он начинается от 0 и заканчивается целым числом, обозначающим длину списка. Величина шага задается числом , которое является аргументом функции .

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

Заметим, что для более красивой печати мы используем функцию , что расшифровывается как pretty print.

Вместо написания функции мы также можем использовать представление списков:

# Определим наш список и размер блока
list = range(0, 50)
chunk = 5

# Разбиваем список на блоки
 for i in range(0, len(list), chunk)]

Результат:

Предварительные сведения

Списки в Python это на редкость популярная тема как для начинающих свой путь программировании, так и для опытных экспертов в языке Python. Если верить Google Trends, то интерес к этой теме растет из года в год.

Если вы регулярно посещаете форумы, где можно задать вопросы по программированию на Python, например Stack Overflow, Quora или Reddit, то наверняка понимаете причину такой популярности этой темы.

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

В данной статье мы кратко пройдемся по самым распространенным вопросам на тему списков в языке Python.

Вопрос 11. Как работает функция range?

Сложность: (ー_ー)

Функция range() генерирует три разных вида последовательностей из целых чисел и часто используется для быстрого создания списков — поэтому этот вопрос и попал в нашу подборку. Да и объяснять работу функции удобнее всего именно с помощью списка.

Последовательность от нуля до n

Используется range(n):

Функция range(n) сгенерировала последовательность от нуля до n (исключая n), а мы эту последовательность двумя способами обернули в список. Первый способ вы уже узнали — это генератор списков, а второй использует функцию list, которая превращает подходящий аргумент в список.

Попробуйте передать в range() отрицательное (-7) или дробное (3.14) число. Получится ли какой-нибудь список из этого, и если да, то какой?

Последовательность от n до m

Здесь в функцию range() нужно передать уже два аргумента: тогда range(n, m) сгенерирует целые числа от n до m (исключая m):

Последовательность от n до m с шагом k

Если в функцию range() передать три аргумента n, m, k, то она снова создаст последовательность от n до m (снова исключая m), но уже с шагом k:

Что такое списки в Python?

Списки, наряду со словарями, кортежами и множествами, это одна из четырех встроенных в Python структур данных. Списки используются для хранения упорядоченных коллекций элементов. Сами элементы при этом могут быть разных типов, но, как правило, все же имеют один и тот же тип. Эти элементы помещены в квадратные скобки и разделены запятыми. Вот пример таких списков:

# Здесь все элементы одного типа
zoo = 
print(zoo)

# А здесь - нет
biggerZoo = ]
print(biggerZoo)

Можно заметить, что список, хранящийся во второй переменной , похож на список из первой переменной , первые четыре элемента совпадают. Но он также содержит в себе список с названиями обезьян.

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

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

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

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

Наследование класса в Python

Создавая новые классы не обязательно их создавать с нуля. Новый класс может наследовать свои атрибуты (переменные) и методы (функции принадлежащие классам) от ранее определенного исходного класса ( суперкласса ). Также исходный класс называют родителем, а новый класс — потомком или подклассом. В класс-потомок можно добавлять собственные атрибуты и методы. Напишем новый класс , который будет создан на базе класса :

class Car():
    «»»Описание автомобиля»»»
    def __init__(self, brand, model, years):
        «»»Инициализирует атрибуты brand и model»»»
        self.brand = brand
        self.model = model
        self.years = years
        self.mileage = 0

    def get_full_name(self):
        «»»Автомобиль»»»
        name = f»Автомобиль {self.brand} {self.model} {self.years}»
        return name.title()

    def read_mileage(self):
        «»»Пробег автомобиля»»»
        print(f»Пробег автомобиля {self.mileage} км.»)

    def update_mileage(self, new_mileage):
        «»»Устанавливает новое значение пробега»»»
        self.mileage = new_mileage
    
    def add_mileage(self, km):
        «»»Добавляет пробег»»»
        self.mileage += km

class ElectricCar(Car):
    «»»Описывает электромобиль»»»
    def __init__(self, brand, model, years):
        «»»Инициализирует атрибуты класса родителя»»»
        super().__init__(brand, model, years)
        # атрибут класса-потомка
        self.battery_size = 100

    def battery_power(self):
        «»»Выводит мощность аккумулятора авто»»»
        print(«Мощность аккумулятора {self.battery_size} кВт⋅ч»)

Мы создали класс на базе класса. Имя класса-родителя в этом случае ставится в круглые скобки( class ElectricCar(Car) ). Метод __init__  в классе потомка (подклассе) инициализирует атрибуты класса-родителя и создает экземпляр класса . Функция super() .- специальная функция, которая приказывает Python вызвать метод __init__() родительского класса Car, в результате чего экземпляр ElectricCar получает доступ ко всем атрибутам класса-родителя. Имя super как раз и происходит из-за того, что класс-родителя называют суперклассом, а класс-потомок — подклассом.          

Далее мы добавили новый атрибут и присвоили исходное значение 100. Этот атрибут будет присутствовать во всех экземплярах класса . Добавим новый метод battery_power(), который будет выводить информацию о мощности аккумулятора.         

Создадим экземпляр класса  и сохраним его в переменную tesla_1

tesla_1 = ElectricCar(‘tesla’, ‘model x’, 2021)
print(tesla_1.get_full_name())
tesla_1.battery_power()

При вызове двух методов мы получим:

Автомобиль Tesla Model X 2021
Мощность аккумулятора 100 кВт⋅ч

В новый класс  мы можем добавлять любое количество атрибутов и методов связанных и не связанных с классом-родителем .    

3.1. Переопределение методов класса-родителя

Методы, которые используются в родительском классе можно переопределить в классе-потомке (подклассе). Для этого в классе-потомке определяется метод с тем же именем, что и у класса-родителя. Python игнорирует метод родителя и переходит на метод, написанный в классе-потомке (подклассе). Переопределим метод def get_full_name() чтобы сразу выводилась мощность аккумуляторов. 

class ElectricCar(Car):
    «»»Описывает электромобиль»»»
    def __init__(self, brand, model, years):
        «»»Инициализирует атрибуты класса родителя»»»
        super().__init__(brand, model, years)
        # атрибут класса-потомка
        self.battery_size = 100

    def battery_power(self):
        «»»Выводит мощность аккумулятора авто»»»
        print(«Мощность аккумулятора {self.battery_size} кВт⋅ч»)

    def get_full_name(self):
        «»»Автомобиль»»»
        name = f»Автомобиль {self.brand} {self.model} {self.years} {self.battery_size}-кВт⋅ч »
         name.
 

В результате при запросе полного названия автомобиля Python проигнорирует метод def get_full_name() в классе-родителя и сразу перейдет к методу def get_full_name() написанный в классе .          

tesla_1 = ElectricCar(‘tesla’, ‘model x’, 2021)
print(tesla_1.get_full_name())

Автомобиль Tesla Model X 2021 100-Квт⋅Ч

Please enable JavaScript to view the comments powered by Disqus.