Штирлиц — Сеть печатных салонов в Перми

Весь комплекс печатных услуг в Перми. Общирная сеть печатных салонов в Перми. Цифровая печать, цветное и черно-белое копирование документов, сканирование документов, ризография в Перми

Анонимные функции: PHP: Анонимные функции — Manual

Лямбда-функции и анонимные функции в Python ~ PythonRu

Как вы уже знаете, ключевое слово def используется для определения стандартных функций в Python. Но, кроме таких обычных функций, в Python существуют так называемые анонимные или лямбда-функции. Для их создания используется ключевое слово lambda. Обычно такая функция не предназначена для повторного применения.

Синтаксис:

Копировать Скопировано Use a different Browser

lambda [аргументы] : выражение

Лямбда-функция может иметь ноль или более аргументов перед символом ‘:’. При вызове такой функции выполняется выражение, указанное после ‘:’.

Пример определения лямбда-функции:

Копировать Скопировано Use a different Browser

get_cube = lambda x : x ** 3

Приведенная выше лямбда-функция начинается с ключевого слова lambda, за которым следует параметр x. Выражение x ** 3 после ‘:’ возвращает вызывающему коду значение куба переданного числа. Сама лямбда-функция lambda x : x ** 3 присваивается переменной get_cube для ее последующего вызова как именованной функции. Имя переменной становится именем функции, чтобы мы могли работать с ней как с обычной функцией.

Пример вызова лямбда-функции:

Копировать Скопировано Use a different Browser

    >>> get_cube(4)
    64

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

Копировать Скопировано Use a different Browser

    def get_cube(x):
        return x ** 3

Выражение не обязательно должно всегда возвращать значение. Следующая лямбда-функция не возвращает ничего.

Пример лямбда-функции, не возвращающей значение:

Копировать Скопировано Use a different Browser

    >>> welcome = lambda user: print('Welcome, ' + name + '!')
    >>> welcome('Anon')
    Welcome, Anon!

Примечание:

Лямбда-функция может иметь только одно выражение. Очевидно, что она не может заменить функцию, тело которой содержит условия, циклы и т.д.

Следующая лямбда-функция содержит несколько параметров.

Пример лямбда-функции с тремя параметрами:

Копировать Скопировано Use a different Browser

    >>> get_prod = lambda a, b, c : a * b * c
    >>> get_prod(3, 5, 7)
    105

Также лямбда-функция может принимать любое количество параметров.

Пример лямбда-функции с неопределенным числом аргументов (используются только первые 3):

Лямбда-функция без параметров

Ниже приведен пример лямбда-функции без параметров.

Копировать Скопировано Use a different Browser

    >>> welcome = lambda : print('Welcome!')
    >>> welcome()
    Welcome!

Анонимная функция

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

Пример анонимной лямбда-функции:

Копировать Скопировано Use a different Browser

    >>> (lambda x: x**3)(10)
    1000

Здесь lambda x: x3 определяет анонимную функцию и вызывает ее один раз, передавая аргументы в скобках (lambda x: x3)(10).

В Python функции, как и литералы, можно передавать в качестве аргументов.

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

Пример передачи лямбда-функции в качестве параметра:


Копировать Скопировано Use a different Browser

def run_task(task):
	    print('Before running the task')
	    task()
	    print('After running the task')
run_task(lambda : print('Task is complete!')) # передача анонимной функции
important_task = lambda : print('Important task is complete!') 
run_task(important_task) # передача лямбда-функции

Вывод:

Копировать Скопировано Use a different Browser

Before running the task
Task is complete!
After running the task
Before running the task
Important task is complete!
After running the task

Представленная выше функция run_task() определена с параметром task, который вызывается как функция внутри run_task().

run_task(lambda : print(‘Task is complete!’)) вызывает функцию run_task() с анонимной лямбда-функцией в качестве аргумента.

В Python есть встроенные функции, которые принимают в качестве аргументов другие функции. Функции map(), filter() и reduce() являются важными инструментами функционального программирования. Все они принимают на вход функцию. Такая функция-аргумент может быть обычной функцией или лямбда-функцией.

Пример передачи лямбда-функции в map():

Копировать Скопировано Use a different Browser

    >>> prime_cube_list = map(lambda x: x**3, [2, 3, 5, 7, 11]) # передача анонимной функции
    >>> next(prime_cube_list)
    8
    >>> next(prime_cube_list)
    27
    >>> next(prime_cube_list)
    125
    >>> next(prime_cube_list)
    343
    >>> next(prime_cube_list)
    1331

Максим

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

Python Q https://yandex.ru/q/loves/python Online

Python QCEO [email protected]://secure.gravatar.com/avatar/b16f253879f7349f64830c64d1da4415?s=96&d=mm&r=gCEO PythonruPythonАлександрРедакторhttps://t.me/cashncarryhttps://pythonru.com/https://yandex.ru/q/profile/cashnc/[email protected] Zabrodin2018-10-26OnlinePython, Programming, HTML, CSS, JavaScript

Популярное

Функции · Elixir School

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

Table of Contents

  • Анонимные функции
    • Краткий синтаксис
  • Сопоставление с образцом
  • Именованные функции
    • Наименования и арность функций
    • Функции и сопоставление с образцом
    • Закрытые функции
    • Ограничители
    • Аргументы по умолчанию

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

fn и end. Между ними можно определить любое количество параметров и тел функции (function body), разделённых ->.

Давайте рассмотрим простой пример:

iex> sum = fn (a, b) -> a + b end
iex> sum.(2, 3)
5

Краткий синтаксис

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

iex> sum = &(&1 + &2)
iex> sum.(2, 3)
5

Как вы уже могли догадаться, в сокращенной версии параметры доступны как &1, &2, &3 и так далее.

Сопоставление с образцом в Elixir применяется не только для сопоставления переменных. Этот же инструмент используется в объявлении функций.

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

iex> handle_result = fn
. ..>   {:ok, result} -> IO.puts "Handling result..."
...>   {:ok, _} -> IO.puts "This would be never run as previous will be matched beforehand."
...>   {:error} -> IO.puts "An error has occurred!"
...> end
iex> some_result = 1
1
iex> handle_result.({:ok, some_result})
Handling result...
:ok
iex> handle_result.({:error})
An error has occurred!
:ok

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

Функции, определенные в модуле, доступны из других модулей: Это особенно полезный элемент в Elixir:

defmodule Greeter do
  def hello(name) do
    "Hello, " <> name
  end
end
iex> Greeter.hello("Sean")
"Hello, Sean"

Если функция однострочная, то ее описание можно сократить с использованием do::

defmodule Greeter do
  def hello(name), do: "Hello, " <> name
end

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

defmodule Length do
  def of([]), do: 0
  def of([_ | tail]), do: 1 + of(tail)
end
iex> Length. of []
0
iex> Length.of [1, 2, 3]
3

Наименования и арность функций

Ранее мы отмечали, что функции именуются путём сочетания имени и арности (количества аргументов). Это позволяет делать такое:

defmodule Greeter2 do
  def hello(), do: "Hello, anonymous person!"   # hello/0
  def hello(name), do: "Hello, " <> name        # hello/1
  def hello(name1, name2), do: "Hello, #{name1} and #{name2}"
                                                # hello/2
end
iex> Greeter2.hello()
"Hello, anonymous person!"
iex> Greeter2.hello("Fred")
"Hello, Fred"
iex> Greeter2.hello("Fred", "Jane")
"Hello, Fred and Jane"

В комментариях к функциям мы привели их наименования. Первая функция не принимает аргументы, потому описывается как hello/0; вторая принимает один параметр, потому описывается как hello/1, и т.д. В отличие от перегрузки функций в некоторых других языках, в нашем случае функции стоит считать разными. (Сопоставление с образцом, описанное ранее, применяется только в случае, когда для функций с одинаковым количеством аргументов предоставлены несколько различных описаний.)

Функции и сопоставление с образцом

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

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

defmodule Greeter1 do
  def hello(%{name: person_name}) do
    IO.puts "Hello, " <> person_name
  end
end

Теперь предположим, что у нас есть ассоциативный массив, который представляет человека по имени Fred:

iex> fred = %{
...> name: "Fred",
...> age: "95",
...> favorite_color: "Taupe"
...> }

При вызове Greeter1.hello/1 с данным ассоциативным массивом fred мы получим следующий результат:

# call with entire map
. ..> Greeter1.hello(fred)
"Hello, Fred"

Что будет, если вызвать функцию с ассоциативным массивом, который не содержит ключ :name?

# call without the key we need returns an error
...> Greeter1.hello(%{age: "95", favorite_color: "Taupe"})
** (FunctionClauseError) no function clause matching in Greeter1.hello/1
    The following arguments were given to Greeter1.hello/1:
        # 1
        %{age: "95", favorite_color: "Taupe"}
    iex:12: Greeter1.hello/1

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

Давайте выясним, что происходит при вызове Greeter1.hello/1:

# incoming map
iex> fred = %{
...> name: "Fred",
...> age: "95",
...> favorite_color: "Taupe"
...> }

Greeter1.hello/1 ожидает такой аргумент:

%{name: person_name}

В Greeter1.hello/1 передаваемый ассоциативный массив (fred) сопоставляется с нашим аргументом (%{name: person_name}):

%{name: person_name} = %{name: "Fred", age: "95", favorite_color: "Taupe"}

Функция находит, что есть ключ, который соответствует ключу name в переданном ассоциативном массиве. У нас совпадение! И в результате этого значение ключа :name в ассоциативном массиве справа (т.е. в массиве fred) привязывается к переменной слева (person_name).

Теперь, что если мы все ещё хотим присвоить имя Fred в person_name, но и кроме этого ТАКЖЕ хотим сохранить весь ассоциативный массив человека? Допустим, нам захотелось выполнить IO.inspect(fred) после того, как мы приветствуем его. Сейчас, поскольку мы сопоставили только :name из нашего ассоциативного массив и, таким образом, привязали только значение этого ключа с переменной, функция не знает больше ничего про Фреда.

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

Давайте создадим новую функцию:

defmodule Greeter2 do
  def hello(%{name: person_name} = person) do
    IO.puts "Hello, " <> person_name
    IO. inspect person
  end
end

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

person = %{name: "Fred", age: "95", favorite_color: "Taupe"}

Теперь переменной person присвоена целиком весь ассоциативный массив с данные про Фреда. Двигаемся дальше к следующему сопоставлению с образцом:

%{name: person_name} = %{name: "Fred", age: "95", favorite_color: "Taupe"}

Сейчас это похоже на нашу оригинальную функция Greeter1, где мы сопоставляем образец с ассоциативным массивом и оставляем только имя Фреда. У нас есть две переменные, которые мы можем использовать вместо одной:

  1. person, ссылающаяся на %{name: "Fred", age: "95", favorite_color: "Taupe"}
  2. person_name, ссылающаяся на "Fred"

Так что теперь, когда мы вызываем Greeter2. hello/1, мы можем использовать всю информацию про Фреда:

# call with entire person
...> Greeter2.hello(fred)
"Hello, Fred"
%{age: "95", favorite_color: "Taupe", name: "Fred"}
# call with only the name key
...> Greeter2.hello(%{name: "Fred"})
"Hello, Fred"
%{name: "Fred"}
# call without the name key
...> Greeter2.hello(%{age: "95", favorite_color: "Taupe"})
** (FunctionClauseError) no function clause matching in Greeter2.hello/1
    The following arguments were given to Greeter2.hello/1:
        # 1
        %{age: "95", favorite_color: "Taupe"}
    iex:15: Greeter2.hello/1

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

Если мы изменим порядок %{name: person_name} и person в списке, то получим тот же самый результат, потому что каждый из них соответствует fred сам по себе.

Обмениваем переменную и ассоциативный массив:

defmodule Greeter3 do
  def hello(person = %{name: person_name}) do
    IO.puts "Hello, " <> person_name
    IO.inspect person
  end
end

И теперь вызываем нашу функцию с теми же данными, которые использовали при вызове Greeter2.hello/1:

# call with same old Fred
...> Greeter3.hello(fred)
"Hello, Fred"
%{age: "95", favorite_color: "Taupe", name: "Fred"}

Учтите, что, хотя это выглядит так, что %{name: person_name} = person сопоставляется с образцом %{name: person_name} в переменную person, на самом деле каждое сопоставление с образцом производится на переданном аргументе.

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

Закрытые функции

Когда мы не хотим давать доступ к функции из других модулей, мы определяем закрытые (private) функции. Они могут быть вызваны только из этого же модуля. Такие функции определяются с помощью defp:

defmodule Greeter do
  def hello(name), do: phrase() <> name
  defp phrase, do: "Hello, "
end
iex> Greeter.hello("Sean")
"Hello, Sean"
iex> Greeter.phrase
** (UndefinedFunctionError) function Greeter.phrase/0 is undefined or private
    Greeter.phrase()

Ограничители

Мы уже затрагивали ограничители в главе Управляющие конструкции, теперь же рассмотрим их применение в именованных функциях. Ограничители проверяются только после того как Elixir сопоставил функцию.

В следующем примере у нас есть две функции с одинаковыми сигнатурами. Мы используем ограничители для определения какую из них использовать на основе типа аргумента:

defmodule Greeter do
  def hello(names) when is_list(names) do
    names = Enum.join(names, ", ")
    
    hello(names)
  end
  def hello(name) when is_binary(name) do
    phrase() <> name
  end
  defp phrase, do: "Hello, "
end
iex> Greeter. hello ["Sean", "Steve"]
"Hello, Sean, Steve"

Аргументы по умолчанию

Когда мы хотим иметь некое значение по умолчанию у аргумента — используется синтаксис argument \\ value:

defmodule Greeter do
  def hello(name, language_code \\ "en") do
    phrase(language_code) <> name
  end
  defp phrase("en"), do: "Hello, "
  defp phrase("es"), do: "Hola, "
end
iex> Greeter.hello("Sean", "en")
"Hello, Sean"
iex> Greeter.hello("Sean")
"Hello, Sean"
iex> Greeter.hello("Sean", "es")
"Hola, Sean"

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

defmodule Greeter do
  def hello(names, language_code \\ "en") when is_list(names) do
    names = Enum.join(names, ", ")
    
    hello(names, language_code)
  end
  def hello(name, language_code \\ "en") when is_binary(name) do
    phrase(language_code) <> name
  end
  defp phrase("en"), do: "Hello, "
  defp phrase("es"), do: "Hola, "
end
** (CompileError) iex:8: def hello/2 defines defaults multiple times.  Elixir allows defaults to be declared once per definition.
Instead of:
    def foo(:first_clause, b \\ :default) do ... end
    def foo(:second_clause, b \\ :default) do ... end
one should write:
    def foo(a, b \\ :default)
    def foo(:first_clause, b) do ... end
    def foo(:second_clause, b) do ... end
def hello/2 has multiple clauses and defines defaults in one or more clauses
    iex:31: (module)

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

defmodule Greeter do
  def hello(names, language_code \\ "en")
  def hello(names, language_code) when is_list(names) do
    names = Enum.join(names, ", ")
    hello(names, language_code)
  end
  def hello(name, language_code) when is_binary(name) do
    phrase(language_code) <> name
  end
  defp phrase("en"), do: "Hello, "
  defp phrase("es"), do: "Hola, "
end
iex> Greeter.hello ["Sean", "Steve"]
"Hello, Sean, Steve"
iex> Greeter. hello ["Sean", "Steve"], "es"
"Hola, Sean, Steve"
Caught a mistake or want to contribute to the lesson? Edit this lesson on GitHub!

замыканий и анонимных функций в Go

Поиск

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

Что такое анонимная функция в Go?

Анонимную функцию также можно назвать литералом функции , лямбда-функцией или замыканием . Понятие замыкания обязано своим происхождением математической оценке выражения в лямбда-исчислении. Технически между анонимной функцией и замыканием есть тонкая разница: анонимная функция — это функция без имени, а замыкание — это экземпляр функции. Однако для практической реализации замыкания в Golang ключевое значение имеет написание анонимной функции.

Прочитано: Понимание функций в Go

Как создать замыкание в Go?

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

Вот синтаксис и пример кода для создания замыкания в Go:

 func (a, b int){ return a+b }

Обратите внимание, что такая функция не может быть написана как отдельная функция, поэтому при назначении функции объявляется переменная, например:

сумма := func(a, b int) int {возврат a + b}
fmt.Println (сумма (10, 20))

Кроме того, функция вызывается как sum(10, 20) . Его также можно вызвать непосредственно во время определения следующим образом:

 sum := func(a, b int) int { return a + b }(10, 20)
fmt.Println(сумма)

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

 func() {
сумма := 0
для я := 0; я < 100; я++ {
сумма += я
}
}()

Обратите внимание, что первая скобка () после ключевого слова func представляет собой список параметров, а замыкание не имеет имени. Тело замыкания состоит из фигурных скобок 9. 0028 {} и последняя пара скобок () обозначает вызов функции.

Прочитано: Объяснение методов Go

Как вернуть значение из замыкания в Golang

Как мы видели, замыкание или анонимную функцию можно создать с параметрами или без них. Но можем ли мы вернуть значение из такой функции? Вот пример того, как вернуть значение из замыкания в Go. Давайте напишем функцию, которая при каждом вызове возвращает следующее число Фибоначчи:

 основной пакет

импортировать "фмт"

func fibonacci() func() int {
а, б := -1, 1
вернуть функцию () целое {
а, б = б, а+б
вернуть б
}
}

основная функция () {
Фибоначчи: = Фибоначчи2()
для я := 0; я < 10; я++ {
fmt.Println(фибо())
}
}

Функции Go, возвращающие другую функцию

Объявленные локальные переменные имеют ограниченную область действия и существуют только внутри блока или функции, в которой они объявлены. Когда переменная теряет свою область видимости, она сбрасывается из памяти. Однако с помощью замыкания можно удерживать локальные переменные даже после того, как выполнение вышло за пределы блока. Мы можем написать функцию, которая возвращает другую функцию, используя замыкания Go. Вот пример:

 func square() func(num int) int {
функция возврата (число int) int {
вернуть число * число
}
}

func mul(n1 int) func(n2 int) int {
функция возврата (n2 int) int {
вернуть n1 * n2
}
}

основная функция () {

// создаем квадратную функцию, даем ей имя f2 и вызываем ее:
f2 := квадрат()
fmt.Printf("Кол-квадрат для 3 дает: %v\n", f2(3))
// делаем специальную функцию mul, n1 получает значение 3:
f3 := мул(3)
fmt.Printf("Результат: %v\n", f3(3))
}

Прочитано: Понимание каналов в Go

Передача анонимных функций в качестве аргументов в Go

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

 package main

импорт (
"ФМТ"
"математика / ранд"
"время"
)

func xyValues ​​(f func (max int) (int, int)) {
х, у := f(35)
fmt. Println(x, y)
х, у = f(50)
fmt.Println(x, y)
}

основная функция () {
fn := func(max int) (int, int) {
r := rand.New(rand.NewSource(time.Now().UnixNano()))
x_axis := r.Intn (макс.)
y_axis := r.Intn (макс.)
вернуть ось x, ось y
}

xyValues(fn)
х, у := fn(20)
fmt.Println(x, y)
}

В приведенном выше примере кода анонимная функция объявлена ​​в основной функции . Он просто генерирует два случайных целых числа для x_axis и y_axis в пределах диапазона max значения, переданного в качестве аргумента функции и возвращенного как то же самое. Анонимная функция назначается переменной fn и передает значение функции другой функции с именем xyValues ​​ . Функция xyValues ​​ получает в свою очередь функцию в качестве аргумента, а именно fn аргумент функции.

Несколько замечаний: в main значения анонимной функции служат двум целям:

  • Она вызывает функцию xyValues ​​, передавая значение функции в качестве аргумента.
  • Непосредственно вызывает значение функции, предоставляя значение в качестве аргумента.

Заключительные мысли о замыканиях в Go и анонимных функциях

Замыкание — это специальная функция, полученная из функциональных языков. Функции, которые могут возвращать другую функцию, и функции, которые могут принимать другую функцию в качестве аргумента, называются функции высшего порядка . Эта функция очень специфична для функциональных языков программирования, таких как Go. Имея это в виду, знайте, что функцию можно рассматривать как значение. Как мы видим, эти характеристики функциональных языков разработки предлагает Golang. На самом деле использование замыканий довольно распространено в Go и часто используется с горутинами и каналами.

Прочитано: Введение в горутины в Go

Похожие статьи

Анонимные функции :: Типы функций (программирование)

Анонимные функции :: Типы функций (программирование)
Программирование    

Анонимные функции

Анонимные функции позволяют быстро создавать простые функции без необходимости каждый раз создавать М-файлы. Вы можете создать анонимную функцию либо в командной строке MATLAB, либо в любой функции или сценарии М-файла.

Этот раздел охватывает

  • Создание анонимной функции
  • Массивы анонимных функций
  • Переменные, используемые в выражении
  • Примеры анонимных функций

Создание анонимной функции

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

Начиная с правой части этого синтаксического оператора, термин expr представляет собой тело функции: код, выполняющий основную задачу, которую должна выполнить ваша функция. Он состоит из любого единственного допустимого выражения MATLAB. Далее arglist , который представляет собой разделенный запятыми список входных аргументов, которые необходимо передать функции. Эти два компонента аналогичны компонентам тела и списка аргументов любой функции.

Всю правую часть этого оператора ведет знак @ . Знак @ является оператором MATLAB, который создает дескриптор функции. Создание дескриптора функции для анонимной функции дает вам возможность вызывать функцию. Это также полезно, когда вы хотите передать свою анонимную функцию при вызове какой-либо другой функции. 9Знак 0174 @ является обязательной частью определения анонимной функции.

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

Простой пример

Приведенный ниже оператор создает анонимную функцию, которая находит квадрат числа. Когда вы вызываете эту функцию, MATLAB присваивает значение, которое вы передаете, переменной 9.2;

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

Оставить комментарий

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *