Как передать параметры в виде словаря в функцию?
Суть: Нужна возможость использовать функцию как самостоятельно (просто передать в нее параметры), так и внутри большой функции (передать в большую функцию список словарей, чтобы рабочая функция «съела» ключи как параметры).
Вопрос: Есть ли возможность передать в функцию список словарей, чтобы она нашла соответствия своих параметров в ключах словаря? Или же, обработать словарь перед подачей в функцию, чтобы он передался не в формате «ключ:значение», а формате «ключ=значение»?
Пример кода:
subparams = [< 'param1': 12, 'param2': 'smth' >, < 'param1': 15, 'param3': 2535 >] # Большая функция def main_function(main_param, subparams): # Тут что-то происходит # Прохожусь по словарям в списке for sub in subparams: # Передаю словарь в функцию subfunction(sub) # Что-то возвращается # Рабочая функция def subfunction(param1=1, param2='', param3=1000): # Тут тоже что-то происходит и возвращаетсяЕсли есть более адекватное решение или я упускаю какую-то важную деталь — буду благодарен за любой совет 🙂
- Вопрос задан более трёх лет назад
- 485 просмотров
Распаковка аргументов для передачи в функцию Python
Бывают ситуации, когда для функции, требующей отдельных позиционных аргументов, значения этих аргументов уже находятся в списке или кортеже, и для вызова функции должны быть распакованы.
Например, встроенная range() функция ожидает отдельные аргументы start и stop . Если они не доступны отдельно, то можно распаковать аргументы из списка list или кортежа tuple , вызвав функцию с переменной этого списка/кортежа, а впереди нее поставить символ одной звездочки * :
# обычный вызов с отдельными аргументами >>> list(range(3, 6)) # [3, 4, 5] >>> args = [3, 6] # вызов с аргументами, распакованными из списка >>> list(range(*args)) # [3, 4, 5]
Таким же образом, из словаря dict в функцию можно передать ключевые аргументы, только в этом случае, перед переменной словаря ставится два символов звездочки ** :
>>> def parrot(voltage, state='a stiff', action='voom'): . print("-- This parrot wouldn't", action, end=' ') . print("if you put", voltage, "volts through it.", end=' ') . print("E's", state, "!") . >>> d = "voltage": "four million", "state": "bleedin' demised", "action": "VOOM"> >>> parrot(**d) # -- This parrot wouldn't VOOM if you put four million volts through it. E's bleedin' demis
- символом * — распаковывают последовательности в качестве элементов которых одно значение (списки, кортежи, множества)
- два символа ** — распаковывают последовательности в качестве элементов которых имеется ключ и значение (словари)
Примеры распаковки списков и словарей с аргументами для функции:
date_inf = 'year': "2020", 'month': "12", 'day': "06"> f_name = " - - .txt".format(**date_inf) print(f_name) # 2020-12-06.txt fruits = ['lemon', 'orange', 'banana', 'tomato'] print(*fruits) # lemon orange banana tomato
Распаковку аргументов можно использовать несколько раз в функции:
date_info = 'year': "2020", 'month': "01", 'day': "01"> track_info = 'artist': "Beethoven", 'title': 'Symphony No 5'> filename = " - - - - .txt".format(**date_info, **track_info) print(filename) # 2020-01-01-Beethoven-Symphony No 5.txt
fruits = ['lemon', 'orange', 'banana', 'tomato'] first, second, *orher = fruits print(orher) # ['banana', 'tomato'] first, *orher = fruits print(orher) # ['orange', 'banana', 'tomato'] first, *middle, last = fruits print(middle) # ['orange', 'banana']
- КРАТКИЙ ОБЗОР МАТЕРИАЛА.
- Функции это объекты
- Функции могут иметь атрибуты
- Функции могут храниться в структурах данных
- Функции могут быть вложенными
- Передача функции в качестве аргумента другой функции
- Область видимости переменных функции
- Операторы global и nonlocal
- Параметры (аргументы) функции
- Ключевые аргументы в определении функции Python
- Значение аргумента по умолчанию в функциях Python
- Варианты передачи аргументов в функцию Python
- Переменные аргументов *args и **kwargs в функции Python
- Распаковка аргументов для передачи в функцию Python
- Как оцениваются аргументы при вызове функции?
- Строгие правила передачи аргументов в функцию Python
- Инструкция return
- Анонимные функции (lambda-выражения)
- Строки документации в функциях Python
- Рекурсия
- Замыкания в функциях Python
- Перегрузка функций
Python. Аргументы в функциях. Передача аргументов в функцию. Изменение аргументов в теле функции
В функцию могут передаваться аргументы. Аргументы – это изменяемые или неизменяемые объекты. В языке Python имеет значение, к какой категории объектов (изменяемых или неизменяемых) принадлежит аргумент.
Например, к изменяемым объектам относятся списки и словари. К неизменяемым объектам относятся числа, строки, кортежи.
Если в функцию передается неизменяемый объект, то этот объект передается «по значению». Это значит, что изменение этого объекта внутри функции не изменит его в вызывающем коде.
Если в функцию передается изменяемый объект, то этот объект передается по «указателю». Изменение такого объекта внутри функции повлияет на этот объект в вызывающем коде.
2. Примеры передачи неизменяемых объектов в функцию
2.1. Передача числа в функцию.
В примере, в демонстрационных целях реализована функция Mult2() , которая получает параметром число. В теле функции это число удваивается. Полученный результат выводится.
# Передача числа в функцию # Число - это неизменяемый объект, значит передается "по значению" # Объявить функцию, которая получает некоторое число и умножает его на 2 def Mult2(number): # умножить число на 2 number = number*2 # вивести значение числа всередине функции print("Mult2.number color: #ff0000;"># Использовать функцию num = 25 # некоторое число Mult2(num) # вызвать функцию # вывести число num после вызова функции print("num color: #ff0000;"># num = 25 - число не изменилось
После запуска программа выдаст следующий результат
Mult2.number = 50 num = 25
Как видно из результата, в функции значение числа num умножается на 2 и составляет 50. Однако, этот результат не передается в вызывающий код, здесь значение num остается равным 25 как до вызова функции. Это подтверждает передачу «по значению» неизменяемого объекта, которым есть число.
2.2. Передача строки в функцию
Демонстрируется работа функции ReverseStr() , которая реверсирует строку, получаемую параметром.
# Передача строки в функцию # Строка - это неизменяемый объект, поэтому передается "по значению" # Объявить функцию, получающую строку, # реверсирует ее и выводит на экран def ReverseStr(text): # Реверсировать строку txt = '' # цикл перебора строки for c in text: txt = c + txt text = txt # вывести реверсованный текст print('ReveseStr.text = ', text) # Вызов функции ReverseStr() Text = "Hello world!" ReverseStr(Text) print("Text color: #333300;">⇑2.3. Передача кортежа в функцию
# Передача кортежа в функцию # Функция, получающая параметром кортеж def PassTuple(T): # Изменить кортеж T = ([1,2], 'a', 25.88) print('PassTuple.T = ', T) # Создать кортеж TT = ( [2, 3.5], True, 'abcd') # Вызвать функцию и передать ей кортеж TT PassTuple(TT) # Вывести кортеж TT print('TT = ', TT)Результат выполнения программы
PassTuple.T = ([1, 2], 'a', 25.88) TT = ([2, 3.5], True, 'abcd')Так же, как и в предыдущих двух примерах, передача кортежа в функцию происходит по значению.
3. Примеры передачи изменяемых объектов в функцию
3.1. Передача списка в функцию
Демонстрируется функция, которая получает список в качестве параметра. Затем в теле функции этот список изменяется (изменяются первый и второй элементы списка).
# Передача списка в функцию. Список - изменяемый объект # Функция, которая получает параметром список def ChangeList(L): # Изменить список L[0] = 777 # Изменить первый элемент списка L[1] = (2, 3) # Изменить второй элемент списка # Вывести список в теле функции print('ChangeList.L = ', L) # Создать список LL = [ [2, 3.5], True, 'abcd' ] # Вывести список LL для контроля print('LL = ', LL) # Вызвать функцию и передать ей список LL ChangeList(LL) # Вывести список LL после вызова функции print('LL = ', LL)Результат работы программы
LL = [[2, 3.5], True, 'abcd'] ChangeList.L = [777, (2, 3), 'abcd'] LL = [777, (2, 3), 'abcd']Как видно из результата, изменение списка в теле функции приводит к изменению этого списка в вызывающем коде. Это означает, что список передается по принципу указателя языка C.
3.2. Передача словаря в функцию
Демонстрируется функция ChangeDict() которая получает словарь в качестве параметра. В теле функции изменяются отдельные элементы словаря, лежащие на позициях с номерами 0 и 2.
# Передача словаря в функцию. Словарь - изменяемый объект # Функция, получающая параметром словарь def ChangeDict(D): # Изменить словарь D['A'] = 100 # Изменить первый элемент списка D['C'] = 300 # Изменить третий элемент списка # Вывести список в теле функции print('ChangeDict.D = ', D) # Создать словарь DD = < 'A':5, 'B':10, 'C':20 > # Вывести словарь DD для контроля print('DD = ', DD) # Вызвать функцию и передать ей словарь DD ChangeDict(DD) # Вывести список DD после вызова функции print('DD = ', DD)Результат работы программы
DD = ChangeDict.D = DD =
4. Способы избежания изменения объектов-аргументов в вызывающем коде
В случаях, когда нужно запретить изменение объекта списка внутри функции, можно использовать способы которые описаны ниже.
Способ 1. При передаче списка в функцию можно конвертировать этот список в кортеж с помощью операции tuple() . После этого изменить список в теле функции не удастся.
Нижеследующий код демонстрирует использование операции tuple() для конвертирования списка в кортеж.
# Передача списка в функцию с конвертированием в кортеж def PassList(L): # Попытка изменить список L[0] = 100 # Ошибка! # Вывести список в теле функции print('PassList.L = ', L) # Создать список LL = [ 1, 3, 8, 10 ] # Вызвать функцию и передать ей список LL, который конвертирован в кортеж PassList(tuple(LL)) # Вывести список L после вызова функции print('LL = ', LL)Список LL передается в функцию PassList() как кортеж
PassList(tuple(LL))После этого, изменить элемент списка LL в функции PassList() не удастся. Если запустить программу, то будет сгенерировано исключение с сообщением
TypeError: 'tuple' object does not support item assignmentСпособ 2. При передаче списка в функцию можно использовать операцию среза [:] , как показано в следующей программе
# Передача списка в функцию с конвертированием в срез def PassList(L): # Попытка изменить список L[0] = 100 # Это изменение не повлияет на вызывающй код # Вывести список в теле функции print('PassList.L = ', L) # Создать список LL = [ 1, 3, 8, 10 ] # Вызвать функцию и передать ей список как срез [:] PassList(LL[:]) # Вывести список L после вызова функции print('LL = ', LL)В вышеприведенном коде при вызове функции с помощью строки
. PassList(LL[:]) .срез LL[:] осуществляет копию списка. Таким образом, изменения списка внутри функции не приведут к изменению списка в вызывающем коде, поскольку эти изменения будут выполняться над копией.
После запуска на выполнение, программа выдаст такой результат
PassList.L = [100, 3, 8, 10] LL = [1, 3, 8, 10]5. Особенности передачи аргументов в функцию. Итоги
Для аргументов, которые передаются в функцию, можно выделить следующие особенности:
1. Если из внешнего кода вызывается функция с передачей ей аргумента, то в теле функции этот аргумент (объект) автоматически присваивается соответствующей локальной переменной функции.
Например. Демонстрируется автоматическое присвоение локальной переменной функции значения аргумента.
# Аргументы. # Передача аргумента в функцию # Функция, которая получает аргумент и выводит его на экран def Argument(v): print('Argument.v = ', v) return # Демонстрация неявного присваивания value = 'Hello world!' # некоторый объект # передать объект value в функцию Argument(), # происходит неявное присваивание Argument.v = value Argument(value) # Argument.v = Hello world!2. Аргументы функции – это ссылки на объекты. При передаче аргумента в функцию передается ссылка на объект. Передаваемые ссылки реализованы как указатели в языке C. Поскольку, при передаче в функцию аргумента, копируется ссылка на объект, то сам объект никогда не копируется. Иными словами, не создается автоматическая копия объекта при передаче его в функцию, осуществляется только копия ссылки.
3. Если в теле функции присвоить значение имени переданного параметра, то это не повлияет на значение внешнего аргумента в вызывающем коде. Это связано с тем, что имена аргументов в вызывающем коде становятся новыми именами в области видимости функции.
Например. В примере, в функции Func() изменяется значение параметра D на 25. В вызывающем коде был передан аргумент с таким самым именем D со значением 30. Однако, после вызова функции из вызывающего кода, значение внешнего аргумента D не изменилось, что и надо было доказать.
# Аргументы. # Передача аргумента в функцию - копия объекта не делается # Функция, которая получает аргумент-список def Func(D): D = 25 # здесь D - новое имя print('Func.D = ', D) D = 30 Func(D) # вызов функции print('D = ', D) # D = 30 - значение объекта в функции не изменилось4. Если в функцию передается аргумент (объект), который есть изменяемым (список, словарь), то изменение этого аргумента внутри функции приведет к изменению аргумента в вызывающем коде. Это касается только изменения составных элементов объекта (отдельный элемент словаря или списка). Если попробовать изменить объект по его общему имени (с помощью операции присваивания = ), то изменений в вызывающем коде не будет (передается ссылка на объект, а именно ссылку изменить нельзя).
Например. В нижеследующем примере объявляются две функции, которые делают попытку изменить входной параметр-список по его имени:
- функция ChangeList() – пробует изменить список по имени ссылки L . Это изменение не влияет на внешний список LL , переданный из вызывающего кода. Это связано с тем, что делается копия ссылки, изменения копии не изменяют оригинал;
- функция ChangeList2() – пробует изменить элемент списка по имени ссылки L и позицией элемента. Результат – изменение влияет на внешний список LL в вызывающем коде. Это связано с тем, что копия и оригинал указывают на одни и те же данные (один и тот же участок памяти);
# Аргументы. # Передача изменяемого объекта в качестве аргумента # Функция, которая получает параметр-список и изменяет весь список def ChangeList(L): # Изменить список всередине функции по имени L = [ 1, 2, 3] # не влияет на внешний код # Вывести измененный список print('ChangeList.L = ', L) # ChangeList.L = [1, 2, 3] # Функция, которая получает параметр-список и изменяет элемент списка def ChangeList2(L): # Изменить составной элемент списка L[1] = 'abcd' # влияет на внешний код print('ChangeList2.L = ', L) # ----- Вызывающий код модуля ------- LL = [ 'a', 'b', 'c' ] # некоторый список # 1. Передача списка в функцию ChangeList() и его вывод ChangeList(LL) # передать список в функцию print('LL = ', LL) # LL = ['а', 'b', 'с'] - список не изменился # 2. Передать список LL в функцию ChangeList2() ChangeList2(LL) print('LL = ', LL) # LL = ['a', 'abcd', 'c' ] - список изменился
После выполнения программа выдаст следующий результат
ChangeList.L = [1, 2, 3] LL = ['a', 'b', 'c'] ChangeList2.L = ['a', 'abcd', 'c'] LL = ['a', 'abcd', 'c']
Связанные темы
- Режимы сопоставления аргументов. Классификация. Сопоставление по позиции. Сопоставление по именам. Аргументы по умолчанию
- Режимы сопоставления аргументов. Аргументы переменной длины. Комбинирование разных способов сопоставления аргументов. Примеры
Словари в Python 3 — основные методы и функции
В Python есть много встроенных структур данных, используемых для хранения разных типов информации. Словарь ( dict ) — одна из таких структур, которая хранит данные в формате пар ключ-значение. Получить доступ к значениям словаря Python можно с помощью ключей. Этот материал посвящен подробному обсуждению словаря.
Создание словаря
Для создания словаря в Python необходимо передать последовательность элементов внутри фигурных скобок <> , разделив их запятыми ( , ). Каждый элемент имеет ключ и значение, выраженное парой «ключ: значение».
Значения могут быть представлять собой любые типы данных и повторяться, но ключи обязаны быть уникальными.
Следующие примеры показывают, как создавать словари Python:
Создание пустого словаря:
dict_sample = > Cловарь, где ключи являются целыми числами:
dict_sample = 1: 'mango', 2: 'pawpaw'> Создание словаря с ключами разных типов:
dict_sample = 'fruit': 'mango', 1: [4, 6, 8]> Можно также создать словарь, явно вызвав метод dict() :
dict_sample = dict(1:'mango', 2:'pawpaw'>) Словарь можно создать с помощью последовательности, как в примере внизу:
dict_sample = dict([(1,'mango'), (2,'pawpaw')]) Словари могут быть вложенными. Это значит, что можно создавать словари внутри существующего словаря. Например:
dict_sample = 1: 'student1': 'Nicholas', 'student2': 'John', 'student3': 'Mercy'>, 2: 'course1': 'Computer Science', 'course2': 'Mathematics', 'course3': 'Accounting'> > Чтобы вывести содержимое словаря, можно использовать функцию print() и передать название словаря в качестве аргумента. Например:
dict_sample = "Company": "Toyota", "model": "Premio", "year": 2012 > print(dict_sample) Доступ к элементами
Чтобы получить доступ к элементам словаря, нужно передать ключ в квадратных скобках [] . Например:
dict_sample = "Company": "Toyota", "model": "Premio", "year": 2012 > x = dict_sample["model"] print(x) Premio Был создан словарь dict_sample . Затем была создана переменная x . Ее значение — это значение ключа ["model"] из словаря.
Вот другой пример:
dict = 'Name': 'Mercy', 'Age': 23, 'Course': 'Accounting'> print("Student Name:", dict['Name']) print("Course:", dict['Course']) print("Age:", dict['Age']) Student Name: Mercy Course: Accounting Age: 23 Объект словаря также имеет функцию get() , которой можно пользоваться для доступа к элементам словаря. Ее нужно добавлять к словаря через точку и затем передавать название ключа как аргумент функции. Например:
dict_sample = "Company": "Toyota", "model": "Premio", "year": 2012 > x = dict_sample.get("model") print(x) Premio Теперь вы знаете, как получать доступ к элементам словаря с помощью разных методов. В следующем разделе речь пойдет о добавлении новых элементов в уже существующий словарь.
Добавление элементов
Существует множество способов для добавления новых элементов в словарь. Можно использовать новый ключ и присвоить ему значение. Например:
dict_sample = "Company": "Toyota", "model": "Premio", "year": 2012 > dict_sample["Capacity"] = "1800CC" print(dict_sample) У нового элемента ключ "Capacity" и значение — "180CC" . Он был добавлен в качестве первого элемента словаря.
Вот другой пример. Для начала нужно создать пустой словарь:
MyDictionary = > print("An Empty Dictionary: ") print(MyDictionary) An Empty Dictionary: Словарь ничего не возвращает, потому что в нем ничего не хранится. Добавим в нему элементы, один за одним:
MyDictionary[0] = 'Apples' MyDictionary[2] = 'Mangoes' MyDictionary[3] = 20 print("\n3 elements have been added: ") print(MyDictionary) 3 elements have been added:
Для добавления элементов были отдельно указаны ключи и соответствующие значения. Например:
MyDictionary[0] = 'Apples' В этом примере 0 является ключом, а "Apples" — значение.
Можно даже добавить несколько значений для одного ключа. Например:
MyDictionary['Values'] = 1, "Pairs", 4 print("\n3 elements have been added: ") print(MyDictionary) 3 elements have been added:
В этом примере название ключа — "Value" , а все что после знака = — его значения в формате множества ( Set ).
Помимо добавления новых элементов в словарь, их можно обновлять или изменять. Об этом в следующем разделе.
Обновление элементов
После добавления значения в словарь существующий элемент словаря можно изменить. Для изменения значения используется соответствующий ключ. Например:
dict_sample = "Company": "Toyota", "model": "Premio", "year": 2012 > dict_sample["year"] = 2014 print(dict_sample) В этом примере видно, что было обновлено значение ключа "year" с 2012 на 2014 .
Удаление элементов
Удалить элемент из словаря можно несколькими способами. В этом разделе они будут рассмотрены по одному:
Ключевое слово del можно использовать для удаления элемента с конкретным ключом. Например:
dict_sample = "Company": "Toyota", "model": "Premio", "year": 2012 > del dict_sample["year"] print(dict_sample) Вызывается ключевое слово del , а следом за ним — название словаря. В квадратных скобках следом за словарем идет ключ элемента, который требуется удалить. В этом примере это "year" . Запись "year" удаляется из словаря.
Другой способ удалить пару ключ-значение — функция pop() с ключом записи в виде аргумента. Например:
dict_sample = "Company": "Toyota", "model": "Premio", "year": 2012 > dict_sample.pop("year") print(dict_sample) Функция pop() была вызвана добавлением ее к названию словаря. В этом случае будет удалена запись с ключом "year" .
Функция popitem() удаляет последний элемент в словаре. Для нее не нужно указывать конкретный ключ. Примеры:
dict_sample = "Company": "Toyota", "model": "Premio", "year": 2012 > dict_sample.popitem() print(dict_sample) Последней записью в словаре была "year" . Она пропала из словаря после вызова функции popitem() .
Что делать, если нужно удалить целый словарь? Это будет сложно и займет много времени, если пользоваться этими методами к каждому ключу. Вместо этого можно использовать ключевое слово del для целого словаря. Например:
dict_sample = "Company": "Toyota", "model": "Premio", "year": 2012 > del dict_sample print(dict_sample) NameError: name 'dict_sample' is not defined Код вернет ошибку, потому что функция print() пытается получить доступ к словарю, который уже не существует.
В определенных случаях может потребоваться удалить все элементы словаря, оставив его пустым. Этого можно добиться, воспользовавшись функцией clear() :
dict_sample = "Company": "Toyota", "model": "Premio", "year": 2012 > dict_sample.clear() print(dict_sample) Код вернет пустой словарь, поскольку все его элементы уже удалены.
Другие распространенные методы словарей
Метод len()
С помощью этого метода можно посчитать количество элементов в словаре. Например:
dict_sample = "Company": "Toyota", "model": "Premio", "year": 2012 > print(len(dict_sample)) В этом словаре три записи, поэтому метод вернет 3.
Метод copy()
Этот метод возвращает копию существующего словаря. Например:
dict_sample = "Company": "Toyota", "model": "Premio", "year": 2012 > x = dict_sample.copy() print(x) Была создана копия словаря dict_sample . Она присвоена переменной x . Если вывести x в консоль, то в ней будут те же элементы, что и в словаре dict_sample .
Это удобно, потому что изменения в скопированном словаре не затрагивают оригинальный словарь.
Метод items()
Этот метод возвращает итерируемый объект. Такой объект содержит пары ключ-значение для словаря по аналогии с кортежами в списке. Метод используется, когда нужно перебрать значения словаря.
Этот метод нужно вызывать вместе со словарем, как в примере ниже:
dict_sample = "Company": "Toyota", "model": "Premio", "year": 2012 > for k, v in dict_sample.items(): print(k, v) ('Company', 'Toyota') ('model', 'Premio') ('year', 2012) Объект, который возвращает items() , можно использовать, чтобы показать изменения в словаре. Вот как это работает.
dict_sample = "Company": "Toyota", "model": "Premio", "year": 2012 > x = dict_sample.items() print(x) dict_sample["model"] = "Mark X" print(x) dict_items([('Company', 'Toyota'), ('model', 'Premio'), ('year', 2012)]) dict_items([('Company', 'Toyota'), ('model', 'Mark X'), ('year', 2012)]) Вывод демонстрирует, что когда вы меняете значение в словаре, объекты элементов также обновляются.
Метод fromkeys()
Этот метод возвращает словарь с указанными ключами и значениями. У него следующий синтаксис:
dictionary.fromkeys(keys, value) Значение требуемого параметра keys — итерируемые объекты. Оно отвечает за ключи нового словаря. Значение для параметра value указывать необязательно. Оно отвечает за значение по умолчанию для всех ключей. По умолчанию — None .
Предположим, что нужно создать словарь с тремя ключами и одинаковым значением. Это можно сделать следующим образом:
name = ('John', 'Nicholas', 'Mercy') age = 25 dict_sample = dict.fromkeys(name, age) print(dict_sample) В коде вверху определены ключи и одно значение. Метод fromkeys() перебирает ключи и объединяет их со значением для создания заполненного словаря.
Значение для параметра keys является обязательным. В следующем примере показано, что происходит, если параметр values не определен:
name = ('John', 'Nicholas', 'Mercy') dict_sample = dict.fromkeys(name) print(dict_sample) Используется значение по умолчанию, None .
Метод setdefault()
Этот метод используется, когда нужно получить значение элемента с конкретным ключом. Если ключ не найден, он будет вставлен в словарь вместе с указанным значением.
У метода следующий синтаксис:
dictionary.setdefault(keyname, value) В этой функции параметр keyname является обязательным. Он обозначает название ключа, значение которого нужно вернуть. Параметр value необязательный. Если в словаре уже есть ключ, параметр не будет иметь никакого эффекта. Если ключ не существует, тогда значение функции станет значением ключа. Значение по умолчанию — None .
dict_sample = "Company": "Toyota", "model": "Premio", "year": 2012 > x = dict_sample.setdefault("color", "Gray") print(x) Gray В словаре нет ключа color . Метод setdefault() вставляет этот ключ вместе со значением "Gray" .
Следующий пример показывает, как работает метод, если такой ключ уже есть:
dict_sample = "Company": "Toyota", "model": "Premio", "year": 2012 > x = dict_sample.setdefault("model", "Allion") print(x) Premio Значение "Allion" не повлияло на словарь, потому что у ключа уже есть значение.
Метод keys()
Этот метод также возвращает итерируемый объект. Он является списком всех ключей в словаре. Как и метод items() , этот отображает изменения в самом словаре.
Для использования метода нужно всего лишь использовать его с именем словаря, как показано ниже:
dictionary.keys() dict_sample = "Company": "Toyota", "model": "Premio", "year": 2012 > x = dict_sample.keys() print(x) dict_keys(['model', 'Company', 'year']) Часто этот метод используется, чтобы перебрать все ключи в словаре:
dict_sample = "Company": "Toyota", "model": "Premio", "year": 2012 > for k in dict_sample.keys(): print(k) Company model year Выводы
Это все, что нужно знать о словарях Python. Они хранят информацию в парах «ключ: значение». «Ключ» выступает идентификатором объекта, а «значение» — это определенные данные. В Python много функций, которые могут быть использовать для извлечения и обработки данных. В этой статье были рассмотрены способы создания, изменения и удаления словаря, а также самые распространенные методы для работы с этим типом данных.