Как передать список в качестве ввода функции в Python
Вы можете использовать глобальный список и соответственно изменять его в теле функции. Это не должно возвращать список.
Судя по вашим комментариям, ответы здесь решили проблему. Культура SO побуждает вас пометить ответ, который решил вашу проблему, как принятый. Однако это не обязательно.
7 ответов
В настоящее время вы возвращаете значение из своей функции в первой итерации цикла for . Из-за этого вторая и третья итерации вашего цикла for никогда не происходят. Вам нужно переместить оператор return за пределы цикла следующим образом:
import math def square(x): result = [] for y in x: result.append(math.pow(y,2.0)) return result print(square([1,2,3])) Как кто-то раньше использовал программирование на основе, а не на основе отступов, я должен сказать, что изменение одной вкладки, откуда возвращается функция, — это то, что я считаю ужасно не интуитивным
Почему бы не устранить проблему вообще?
def square(vals): return [v*v for v in vals] Изменить:. Первая проблема, как отметили несколько человек, заключается в том, что вы замыкаете цикл for . Ваш return должен появиться после цикла, а не в нем.
Следующая проблема заключается в использовании list.append — вам нужно вызвать ее, а не назначать ей, то есть result.append(y*y) . result.append = y*y вместо этого перезаписывает метод с числовым значением, возможно, выдает ошибку при следующем вызове.
Как только вы исправите это, вы обнаружите еще одну менее очевидную ошибку, если вы повторно назовете свою функцию:
print(square([1,2,3]) # => [1, 4, 9] print(square([1,2,3]) # => [1, 4, 9, 1, 4, 9] Поскольку вы передаете изменяемый элемент (список) по умолчанию, все дальнейшее использование этого элемента по умолчанию указывает на тот же исходный список.
def square(vals, result=None): if result is None: result = [] result.extend(v*v for v in vals) return result Это на самом деле не говорит оператору, где они идут не так, как надо, и является лишь одним из указателей того, как возвести в квадрат массив
Извините, мой первый комментарий выше был основан на вашем первоначальном кратком ответе. Голосуй вверх 🙂
Мы даже используем result ? Вы можете использовать понимание списка, чтобы сгенерировать результат, который вы затем вернете. Я не уверен, почему вы передали result в качестве переменной в функцию, так как она не используется.
Кроме того, наличие return result внутри вашего цикла означает, что функция возвращает значение на первой итерации, поэтому он просто возвращает квадрат первого числа в списке.
import math def square(x): return [math.pow(y, 2) for y in x] >>> print(square([1,2,3])) [1.0, 4.0, 9.0] Ну, это можно рассматривать как начальное значение, например. Возможно, OP намеревался вернуть square([1,2,3],[100,200,300]) [100,200,300,1,4,9] .
Вам может быть интересно использовать yield
def square(x): for y in x: yield math.pow(y, 2.0) таким образом вы можете вызвать
который не будет генерировать весь список квадратов одновременно, а скорее один элемент на итерацию, или использовать list(square(x)) для получения полного списка по запросу.
Как передать массив в функцию в Python?
Программирование и разработка
В этой статье мы обсудим, как массив или список можно передать функции в качестве параметра в Python.
Передать массив функции в Python
Так, например, если у нас есть тысячи значений, хранящихся в массиве, и мы хотим выполнить манипуляцию с этими значениями в определенной функции, тогда нам нужно передать весь массив конкретной функции.
Syntax: array(data_type, value_list)
Давайте разберемся в этом с помощью пары примеров
Нам нужно импортировать массив, после чего мы создадим массив с его типом данных и элементами, а затем передадим его функции для перебора элементов в списке.
16, 27, 77, 71, 70, 75, 48, 19, 110
Нам нужно импортировать массив, после чего мы создадим массив и передадим его функции для умножения элементов в списке.
Product: 134.31599601554856
Передать список функции в Python
Передача параметров не ограничивается типами данных. Это означает, что в эту процедуру можно передавать переменные различных типов данных. Так, например, если у нас есть тысячи значений, хранящихся в списке, и мы хотим манипулировать этими значениями в определенной функции, нам нужно передать весь список в конкретную функцию.
Syntax: var_name = [ele1, ele2. ]
Список создается путем помещения элементов в квадратные скобки [], разделенных запятыми.
Давайте разберемся в этом с помощью пары примеров
Был создан список с именами животных, и список животных, который мы создали ранее, полностью передается определяемой пользователем функции с именем print_animals, где мы будем печатать все элементы списка животных. Создается определяемая пользователем функция с именем print_animals, которая получает на вход список животных. Его простая цель состоит в том, чтобы напечатать каждый элемент списка животных, используя цикл for.
Покоряем Python — уроки для начинающих
Передача аргументов — способ передачи объектов в функции. Если вспомнить, то мы знаем, что передача аргументов происходит с помощью операции присваивания.
• Аргументы передаются через автоматическое присваивание объектов локальным переменным (передача по указателям).
• Операция присваивания именам аргументов внутри функции не оказывает влияния на вызывающую программу.
• Изменение внутри функции аргумента, который является изменяемым
объектом, может оказывать влияние на вызывающую программу.
Передача аргументов очень близка к языку С:
• Неизменяемые объекты передаются «по значению». Такие объекты, как целые числа и строки, передаются в виде ссылок на объекты, а не в виде копий объектов.
• Изменяемые объекты передаются «по указателю». Такие объекты, как списки и словари, также передаются в виде ссылок на объекты, что очень похоже на то, как в языке C передаются указатели на массивы, – изменяемые объекты допускают возможность непосредственного изменения внутри функции так же, как и массивы в языке C.
Пример:
>>> def f(a): # Имени a присваивается переданный объект
. a = 99 # Изменяется только локальная переменная
.
>>> b = 88
>>> f(b)# Первоначально имена a и b ссылаются на одно и то же число 88
>>> print(b) # Переменная b не изменилась
88
В этом фрагменте в момент вызова функции f(b) переменной a присваивается объект 88, но переменная a существует только внутри вызванной функции. Изменение переменной a внутри функции не оказывает влияния на окружение, откуда была вызвана функция, – просто в момент вызова создается совершенно новый объект a .
——————————————————————
Когда в аргументах передаются изменяемые объекты, такие как списки и словари, мы должны понимать, что непосредственные изменения в таких объектах никуда не исчезнут после завершения функции и тем самым могут оказывать влияние на вызывающую программу. Ниже приводится пример, который демонстрирует эту особенность:
В b передался изменяемый объект, и в результате мы получаем его измененным.
——————————————————————
Как избежать воздействий на изменяемые аргументы.
По умолчанию аргументы передаются по ссылкам(по указателям), то есть мы можем передавать большие объекты в любые точки программы не создавая их копии, и можно будет легко их изменять.
В случае с аргументами функций мы всегда можем скопировать список в точке вызова:
L = [1, 2]
changer(X, L[:]) # Передается копия, поэтому переменная ‘L’ не изменится
Можно также создать копию внутри функции, если для нас нежелательно, чтобы функция изменяла объект, независимо от способа его передачи:
При попытке изменения кортежа будет возбуждено исключение:
L = [1, 2]
changer(X, tuple(L)) # Передается кортеж, поэтому попытка изменения
# возбудит исключение
Здесь используется встроенная функция tuple , которая создает новый кортеж из всех элементов последовательности (в действительности – любого итерируе мого объекта). Это особенно важно, потому что вынуждает писать функцию так, чтобы она никогда не пыталась изменять передаваемые ей аргументы. Од нако такое решение накладывает на функцию больше ограничений, чем следу ет, поэтому его вообще следует избегать (нельзя знать заранее, когда изменение аргументов окажется необходимым). Кроме того, при таком подходе функция
теряет возможность применять к аргументу методы списков, включая методы,
которые не производят непосредственных изменений.
Имитация выходных параметров:
Мы уже обсудили инструкцию return и использовали ее в нескольких примерах. Эта инструкция может возвращать объект любого типа, поэтому с ее помощью можно возвращать сразу несколько значений, упаковав их в кортеж или в коллекцию любого другого типа.
>>> def multiple(x, y):
. x = 2 # Изменяется только локальное имя
. y = [3, 4]
. return x, y # Новые значения возвращаются в виде кортежа
.
>>> X = 1
>>> L = [1, 2]
>>> X, L = multiple(X, L) # Результаты присваиваются именам
>>> X, L # в вызывающей программе
(2, [3, 4])
Синтаксис сопоставления, синтаксис использования специальных режимов сопоставления:
func(value)- Вызывающая программа — Обычный аргумент: сопоставление производится по позиции
func(name=value) — Вызывающая программа — Именованный аргумент: сопоставление производится по указанному имени
func(*sequence) — Вызывающая программа — Все объекты в указанной последовательности передаются как отдельные позиционные аргументы
func(**dict) — Вызывающая программа — Все пары ключ/значение в указанном словаре передаются как отдельные именованные аргументы
def func(name) — Функция — Обычный аргумент: сопоставление производится по позиции
или по имени
def func(name=value) — Функция — Значение аргумента по умолчанию, на случай, если аргумент не передается функции
def func(*name) — Функция — Определяет и объединяет все дополнительные аргументы
в кортеж
def func(**name) — Функция — Определяет и объединяет все
дополнительные именованные аргументы в словарь
def func(*args, name)
def func(*, name=value) — Функция — Аргументы, которые должны передаваться функции только по именам (3.0).
Случаи вызова функции и определения функции:
• В инструкции вызова функции (первые четыре строки таблицы) при использовании простых значений соответствие именам аргументов определяется по позиции, но при использовании формы name=value соответствие определяется по именам аргументов – это называется передачей именованных аргументов. Использование форм *sequence и **dict в вызовах функций позволяет передавать произвольное число объектов по позиции или по именам в виде последовательностей и словарей соответственно.
• В заголовке функции (остальная часть таблицы) при использовании простых значений соответствие определяется по позиции или по имени, в зависимости от того, как вызывающая программа передает значения, но при использовании формы name=value определяются значения по умолчанию. При использовании формы *name все дополнительные позиционные аргументы объединяются в кортеж, а при использовании формы **name все дополнительные именованные аргументы объединяются в словарь. В версии Python 3.0 и выше любые обычные аргументы или аргументы со значениями по умолчанию, следующие за формой *name или за единственным символом * , являются именованными аргументами, которые при вызове функции должны передаваться только по имени.