Как передать кортеж в функцию python
Кортеж (tuple) представляет последовательность элементов, которая во многом похожа на список за тем исключением, что кортеж является неизменяемым (immutable) типом. Поэтому мы не можем добавлять или удалять элементы в кортеже, изменять его.
Для создания кортежа используются круглые скобки, в которые помещаются его значения, разделенные запятыми:
tom = ("Tom", 23) print(tom) # ("Tom", 23)
Также для определения кортежа мы можем просто перечислить значения через запятую без применения скобок:
tom = "Tom", 23 print(tom) # ("Tom", 23)
Если вдруг кортеж состоит из одного элемента, то после единственного элемента кортежа необходимо поставить запятую:
tom = ("Tom",)
Для создания кортежа из другого набора элементов, например, из списка, можно передать список в функцию tuple() , которая возвратит кортеж:
data = ["Tom", 37, "Google"] tom = tuple(data) print(tom) # ("Tom", 37, "Google")
С помощью встроенной функции len() можно получить длину кортежа:
tom = ("Tom", 37, "Google") print(len(tom)) # 3
Обращение к элементам кортежа
Обращение к элементам в кортеже происходит также, как и в списке, по индексу. Индексация начинается также с нуля при получении элементов с начала списка и с -1 при получении элементов с конца списка:
tom = ("Tom", 37, "Google", "software developer") print(tom[0]) # Tom print(tom[1]) # 37 print(tom[-1]) # software developer
Но так как кортеж — неизменяемый тип (immutable), то мы не сможем изменить его элементы. То есть следующая запись работать не будет:
tom[1] = "Tim"
При необходимости мы можем разложить кортеж на отдельные переменные:
name, age, company, position = ("Tom", 37, "Google", "software developer") print(name) # Tom print(age) # 37 print(position) # software developer print(company) # Google
Получение подкортежей
Как и в списках, можно получить часть кортежа в виде другого кортежа
tom = ("Tom", 37, "Google", "software developer") # получем подкортеж с 1 по 3 элемента (не включая) print(tom[1:3]) # (37, "Google") # получем подкортеж с 0 по 3 элемента (не включая) print(tom[:3]) # ("Tom", 37, "Google") # получем подкортеж с 1 по послдений элемент print(tom[1:]) # (37, "Google", "software developer")
Кортеж как параметр и результат функций
Особенно удобно использовать кортежи, когда необходимо возвратить из функции сразу несколько значений. Когда функция возвращает несколько значений, фактически она возвращает в кортеж:
def get_user(): name = "Tom" age = 22 company = "Google" return name, age, company user = get_user() print(user) # ("Tom", 37, "Google")
При передаче кортежа в функцию с помощью оператора * его можно разложить на отдельные значения, которые передаются параметрам функции:
def print_person(name, age, company): print(f"Name: Age: Company: ") tom = ("Tom", 22) print_person(*tom, "Microsoft") # Name: Tom Age: 22 Company: Microsoft bob = ("Bob", 41, "Apple") print_person(*bob) # Name: Bob Age: 41 Company: Apple
Перебор кортежей
Для перебора кортежа можно использовать стандартные циклы for и while . С помощью цикла for:
tom = ("Tom", 22, "Google") for item in tom: print(item)
С помощью цикла while:
tom = ("Tom", 22, "Google") i = 0 while i < len(tom): print(tom[i]) i += 1
Проверка наличия значения
Как для списка с помощью выражения элемент in кортеж можно проверить наличие элемента в кортеже:
user = ("Tom", 22, "Google") name = "Tom" if name in user: print("Пользователя зовут Tom") else: print("Пользователь имеет другое имя")
Кортежи
Кортежи (tuple) в Python – это те же списки за одним исключением. Кортежи неизменяемые структуры данных. Так же как списки они могут состоять из элементов разных типов, перечисленных через запятую. Кортежи заключаются в круглые, а не квадратные скобки.
>>> a = (10, 2.13, "square", 89, 'C') >>> a (10, 2.13, 'square', 89, 'C')
Из кортежа можно извлекать элементы и брать срезы:
>>> a[3] 89 >>> a[1:3] (2.13, 'square')
Однако изменять его элементы нельзя:
>>> a[0] = 11 Traceback (most recent call last): File "", line 1, in TypeError: 'tuple' object does not support item assignment
Также у типа tuple нет методов для добавления и удаления элементов.
Возникает резонный вопрос. Зачем в язык программирования был введен этот тип данных, по-сути представляющий собой неизменяемый список? Дело в том, что иногда надо защитить список от изменений. Преобразовать же кортеж в список, если это потребуется, как и выполнить обратную операцию легко с помощью встроенных в Python функций list() и tuple() :
>>> a = (10, 2.13, "square", 89, 'C') >>> b = [1, 2, 3] >>> c = list(a) >>> d = tuple(b) >>> c [10, 2.13, 'square', 89, 'C'] >>> d (1, 2, 3)
Рассмотрим случай, когда уместно использовать кортежи. В Python изменяемые объекты передаются в функцию по ссылке. Это значит, что не создается копия объекта, а переменной-параметру присваивается ссылка на уже существующий объект. В итоге, если в теле функции объект изменяется, то эти изменения касаются глобального объекта.
def add_num(seq, num): for i in range(len(seq)): seq[i] += num return seq origin = [3, 6, 2, 6] changed = add_num(origin, 3) print(origin) print(changed)
Данная программа неправильная. Хотя никаких выбросов исключений не произойдет, она содержит логическую ошибку. На выводе получаем:
[6, 9, 5, 9] [6, 9, 5, 9]
То есть исходный список был также изменен. Параметр seq содержал ссылку не на свой локальный список, а на список-оригинал. Таким образом, в операторе return здесь нет смыла. Если функция замысливалась как изменяющая глобальный список, то программа должна выглядеть так:
def add_num(seq, num): for i in range(len(seq)): seq[i] += num origin = [3, 6, 2, 6] add_num(origin, 3) print(origin)
Что делать, если все же требуется не изменять исходный список, а сформировать по нему новый. Задачу можно решить несколькими способами. Во первых, в функции можно создать локальный список, после чего возвращать его:
def add_num(seq, num): new_seq = [] for i in seq: new_seq.append(i + num) return new_seq origin = [3, 6, 2, 6] changed = add_num(origin, 3) print(origin) print(changed)
[3, 6, 2, 6] [6, 9, 5, 9]
Исходный список в функции не меняется. Его элементы лишь перебираются.
Второй способ защитить список-оригинал – использовать кортеж. Этот способ более надежный, так как в больших программах трудно отследить, что ни одна функция не содержит команд изменения глобальных данных.
Хотя преобразовывать к кортежу можно как при передаче в функцию, так и в самой функции, лучше сразу делать глобальный список кортежем. Поскольку неизменяемые объекты передаются по значению, а не по ссылке, то в функцию будет поступать копия структуры, а не оригинал. Даже если туда передается оригинал, изменить его невозможно. Можно лишь, как вариант, скопировать его и/или изменить тип, создав тем самым локальную структуру, и делать с ней все, что заблагорассудится.
def add_num(seq, num): seq = list(seq) for i in range(len(seq)): seq[i] += num return seq origin = (3, 6, 2, 6) changed = add_num(origin, 3) print(origin) print(changed)
Списки в кортежах
Кортежи могут содержать списки, также как списки быть вложенными в другие списки.
>>> nested = (1, "do", ["param", 10, 20])
Как вы думаете, можем ли мы изменить список ["param", 10, 20] вложенный в кортеж nested ? Список изменяем, кортеж – нет. Если вам кажется, что нельзя, то вам кажется неправильно. На самом деле можно:
>>> nested[2][1] = 15 >>> nested (1, 'do', ['param', 15, 20])
Примечание. Выражения типа nested[2][1] используются для обращения к вложенным объектам. Первый индекс указывает на позицию вложенного объекта, второй – индекс элемента внутри вложенного объекта. Так в данном случае сам список внутри кортежа имеет индекс 2, а элемент списка 10 – индекс 1 в списке.
Странная ситуация. Кортеж неизменяем, но мы все-таки можем изменить его. На самом деле кортеж остается неизменяемым. Просто в нем содержится не сам список, а ссылка на него. Ее изменить нельзя. Но менять сам список можно.
Чтобы было проще понять, перепишем кортеж так:
>>> l = ["param", 10, 20] >>> t = (1, "do", l) >>> t (1, 'do', ['param', 10, 20])
Кортеж содержит переменную-ссылку. Поменять ее на другую ссылку нельзя. Но кортеж не содержит самого списка. Поэтому его можно менять как угодно:
>>> l.pop(0) 'param' >>> t (1, 'do', [10, 20])
Однако такой номер не проходит с неизменяемыми типами:
>>> a = "Kat" >>> t = (a, l) >>> t ('Kat', [10, 20]) >>> a = "Bat" >>> t ('Kat', [10, 20])
Они передаются в кортеж как и в функцию – по значению. То есть их значение копируется в момент передачи.
Практическая работа
- Чтобы избежать изменения исходного списка, не обязательно использовать кортеж. Можно создать его копию с помощью метода списка copy() или взять срез от начала до конца [:] . Скопируйте список первым и вторым способом и убедитесь, что изменение копий никак не отражается на оригинале.
- Заполните один кортеж десятью случайными целыми числами от 0 до 5 включительно. Также заполните второй кортеж числами от -5 до 0. Для заполнения кортежей числами напишите одну функцию. Объедините два кортежа с помощью оператора +, создав тем самым третий кортеж. С помощью метода кортежа count() определите в нем количество нулей. Выведите на экран третий кортеж и количество нулей в нем.
Примеры решения и дополнительные уроки в pdf-версии курса
X Скрыть Наверх
Python. Введение в программирование
Программа Python для передачи кортежа в качестве аргументов функции
Кортежи — это важный тип данных в Python, который часто используется для хранения фиксированного набора элементов. В этой статье мы обсудим, как передать кортеж в качестве аргументов функции в Python. Мы рассмотрим синтаксис передачи аргументов кортежа и приведем примеры того, как это сделать.
Давайте сначала поймем основы, которые нам понадобятся, чтобы начать подходить к проблеме. Задача требует от нас передать кортеж в качестве аргумента функции, для этого нам нужно знать, что такое функция в Python, что такое аргументы функции и что такое кортежи в Python.
Что такое функция в Python?
Функция на любом языке программирования — это фрагмент кода, содержащий блок операторов, которые выполняют определенную функцию или задачу и могут потребоваться более одного раза во время выполнения. Это важно, поскольку они обеспечивают возможность повторного использования кода и помогают поддерживать код, менее подверженный ошибкам из-за уменьшения избыточности.
Функции в Python могут быть объявлены с использованием ключевого слова «def», весь код внутри функции должен иметь правильные отступы, чтобы компилятор знал правильное определение функции. Функцию в Python можно определить следующим образом:
def functionName(): statement 1 statement 2 # End of function Функция обычно вызывается с использованием имени функции, за которым следуют круглые скобки. Ниже приведен пример вызова функции.
functionName() Определенная выше функция — это простейшая форма функции, которая не принимает никаких входных данных и ничего не возвращает. Но Python предоставляет нам возможность делать и эти вещи.
Аргументы функции
Бывают случаи, когда нам нужна функция, которая принимает для обработки некоторую форму входных данных. Итак, как мы можем достичь этого? Мы можем сделать это, используя аргументы функции.
Аргумент функции — это входные данные, которые функция должна иметь при каждом вызове. Аргументы функции определяются в круговых скобках вызова функции. Например —
# Function definition def functionWithArgs(argument1, argument2): statement 1 statement 2 functionWithArgs(arg1, arg2) # function call Мы не ограничены каким-либо типом данных или количеством аргументов, которые мы можем передать функции. Мы можем передавать любые встроенные типы данных, а также определяемые пользователем типы данных и экземпляры класса. Помимо передачи входных параметров, мы также можем возвращать значения.
Теперь мы знаем, что такое функция в Python и как мы можем использовать аргументы для передачи входных данных функции для дальнейшей обработки. Давайте теперь посмотрим, что такое кортеж.
Кортеж в Python
Кортеж в Python — это заранее определенный тип данных, который действует как контейнер и может хранить в себе различные типы разнородных данных. Следует отметить, что они неизменяемы, поэтому их нельзя изменить после создания. Все элементы кортежа хранятся в круглых скобках, разделенных запятой. Синтаксис определения кортежа приведен ниже.
A = (1, 2, 3) Теперь у нас есть все основы, которые нам нужно знать для решения проблемы. Давайте теперь обсудим способы подхода к этому.
Передача статических кортежей в качестве аргументов
Как мы знаем, мы можем использовать аргументы для передачи входных данных в функцию. Чтобы передать кортеж, нам просто нужно указать объект кортежа в круглых скобках во время определения функции.
Обратите внимание, что нам просто нужно указать имя переменной, ее значением будет кортеж, который мы определяем во время вызова функции.
Алгоритм
Шаг 1. Определите функцию с переменной в качестве параметра.
Шаг 2. Внутри функции выведите значение, которое содержит переменная.
Шаг 3. Создайте значение функции с кортежем внутри круглых скобок.
Пример
def tupleArg(inputTuple): print("Tuple argument passed as input to the function is: ", inputTuple) tupleArg((1, 2, 3)) Выход
Tuple argument passed as input to the function is: (1, 2, 3) Использование кортежей пользовательского ввода
В приведенной выше программе обсуждалось, как мы можем передать статический кортеж в качестве аргумента. Но во многих случаях эти кортежи носят динамический характер. Вот почему сейчас мы сосредоточимся на том, чтобы взять кортеж в качестве входных данных от пользователя и передать его в качестве аргумента функции.
Алгоритм
Шаг 1. Создайте переменную для хранения кортежа.
Шаг 2. Возьмите строку значений от пользователя в качестве входных данных.
Шаг 3. Разделите входную строку, сопоставьте каждый элемент с целым числом и преобразуйте весь объект карты в кортеж.
Шаг 4. Создайте функцию, которая принимает переменную в качестве параметра.
Шаг 5. Внутри функции распечатайте входной кортеж.
Шаг 6. Вызов функции с вводным пользователем кортежем в качестве аргумента.
Пример
A = tuple(map(int, input("Enter the elements of tuple : ").split())) def tupleArg(inputTuple): print("Tuple argument passed as input to the function is: ", inputTuple) tupleArg(A) Выход
Enter the elements of tuple : 12 33 776 339 Tuple argument passed as input to the function is: (12, 33, 776, 339) Заключение
В этой статье мы сосредоточились на трех различных способах передачи кортежа в качестве аргумента функции. Мы узнали, что такое функция в Python, что подразумевается под аргументом функции и как мы можем передавать как статические, так и динамические кортежи.
Все права защищены. © Linux-Console.net • 2019-2023
Распаковка аргументов для передачи в функцию 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
- Перегрузка функций