Определение функции в си: Функции в языке Си : вызов функции, возвращаемое значение

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

1. Позиционные или ключевые аргументы
2. Только позиционные параметры
3. Только ключевые аргументы

1. Позиционные или ключевые аргументы

Если / и * отсутствуют в определении функции, аргументы могут быть переданы в функцию по позиции или по ключевому слову

  def  add(a,b,c): 
  return  a+b+c 
 print (add(3,4,5)) 
  #Output:12  
 
 print (add(3,c=1,b=2)) 
  #Output:6  
 

2. Позиционное только параметры

Только позиционные параметры помещаются перед / (косая черта) в определении функции. / используется для логического отделения параметров, предназначенных только для позиционирования, от остальных параметров. Параметры, следующие за /, могут быть позиционными или ключевыми словами или только ключевыми словами .

  def  add(a,b,/,c,d): 
  return  a+b+c+d 
 print (add(3,4,5,6)) 
  #Output:12  
 
 print (add(3,4,c=1,d=2)) 
  #Output:6  
 

Если мы укажем аргументы ключевого слова для позиционных аргументов, он поднимет Ошибка типа.

  def  add(a,b,/,c,d): 
  return  a+b+c+d 
 print (add(3,b=4,c=1,d=2)) 
  #Output:TypeError: add() получил некоторые позиционные аргументы, переданные как аргументы ключевого слова: 'b'  
 

3. Аргументы только ключевого слова

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

  по умолч.  добавить(а,б,*,в,г): 
  return  a+b+c+d 
 print (add(3,4,c=1,d=2)) 
  #Output:10  
 

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

  def  add(a,b,*,c,d): 
  return  a+b+c+d 
 print (add(3,4,1,d=2)) 
  #Вывод :TypeError: add() принимает 2 позиционных аргумента, но было задано 3 позиционных аргумента (и 1 аргумент только с ключевым словом)  
 

Все 3 соглашения о вызовах используются в одной и той же функции

В приведенном ниже примере функция add имеет все три аргумента

a , b — только позиционные аргументы

  def  add(a,b,/,c,*,d): 
  return  a+b+c+d 
 print (add(3,4,1,d=2)) 
  # Вывод: 10  
 

Важно помнить:

1. Используйте позиционно-только , если вы хотите, чтобы имя параметра было недоступно для пользователя. Это полезно, когда имена параметров не имеют реального значения.
2. Используйте только позиционный , если вы хотите принудительно указать порядок аргументов при вызове функции.
3. Используйте только ключевое слово , когда имена имеют значение, а определение функции более понятно благодаря явному использованию имен.
4. Используйте только ключевое слово , если вы хотите, чтобы пользователи не полагались на позицию передаваемого аргумента.

Мой другой блог Ссылки

Все, что вы хотели знать о Python Операторы возврата

Ресурсы (документация Python):

Определение функций

В этом разделе вы найдете больше статей о Python и DataScience. Если вы хотите прочитать больше моих руководств, подписывайтесь на меня по телефону Medium , LinkedIn , Twitter .

Спасибо за внимание!

Спасибо, что являетесь частью нашего сообщества! Level Up трансформирует рекрутинг в сфере технологий. Найдите свою идеальную работу в лучших компаниях .

Повышение уровня — трансформация процесса найма

🔥 Предоставление инженерам-программистам возможности найти идеальную должность, которую они любят 🧠 Поиск талантов — самая болезненная часть…

jobs.levelup.dev

Функции — Python для вас и меня Документация 0.5.beta1

Многократное использование одного и того же кода в одной и той же программе. Функции помогите нам сделать это. Мы пишем то, что нам нужно делать неоднократно, в функции затем вызовите его, где когда-либо потребуется. Мы уже видели встроенные функции, такие как len() , divmod() .

Определение функции

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

 определение имя_функции (параметры):
    заявление1
    заявление2
 

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

 >>> сумма по умолчанию (a, b):
... вернуть а + б
 

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

 >>> res = sum(234234, 34453546464)
>>> разрешение
34453780698Л
 

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

 по определению больше (данные, максимальный размер):
    """Возврат, если длина данных больше заданного максимального размера.
    """
    вернуть len (данные) > максимальный размер
 

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

 >>> s = "Я Кушал."
>>> print(больше(s, 10))
ЛОЖЬ
 

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

Но при использовании этих функций в Python трудно понять, что именно аргументы функции, какие данные они ожидают. Мы читаем документации, чтобы узнать как можно больше, а затем во многих случаях это означает постоянное переключение между кодом и документацией. Современные редакторы пытается помочь, например, давайте посмотрим, что показывает нам VS Code, когда мы пытаемся использовать выше большая функция .

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

Мы можем исправить это с помощью аннотации типа . Что увеличивает читабельность нашего кода, а также помогает разработчику, который будет использовать функцию в будущем. Автоматизированные инструменты в таких редакторах, как VS Code (или даже в Vim/Emacs). Итак, мы перепишет нашу функцию, как показано ниже.

 по определению больше (данные: str, maxsize: int) -> bool:
    """Возврат, если длина данных больше заданного максимального размера.
    """
    вернуть len (данные) > максимальный размер
 

Здесь после имени переменной и двоеточия мы указываем, какие данные она исключение, и мы также упоминаем тип данных, возвращаемых функция с ->. Это не проверяется во время выполнения, как обычно языки программирования, но в помощь есть специальные отдельные инструменты. Но это мгновенно повышает читаемость кода. Теперь мы знаем, что должны передать строку и целое число в функцию. Даже VS Code скажет нам об этом.

Теперь, если мы добавим аннотацию к нашему 9Функция 0684 sum будет выглядеть следующим образом.

 сумма по определению (a: целое, b: целое) -> целое:
    вернуть а + б
 

Помните программу-палиндром, которую мы написали в предыдущей главе. Давайте напишем функция, которая проверит, является ли данная строка палиндромом или нет, а затем вернет Верно или Ложно .

 #!/usr/bin/env python3
защитный палиндром(ы):
    вернуть с == с[::-1]
если __name__ == "__main__":
    s = input("Введите строку:")
    если палиндром(ы):
        print("Да палиндром")
    еще:
        print("О нет, это не палиндром")
 

Теперь запустите файл 🙂

Локальные и глобальные переменные

Чтобы понять локальные и глобальные переменные, рассмотрим два примера.

 #!/usr/bin/env Python
изменить определение (а):
    а = 90
    print(f"Внутри функции изменения {a}")
а = 9
print(f"Перед вызовом функции {a}")
изменить (а)
print(f"После вызова функции {a}")
 

Вывод

 $ ./local.py
Перед вызовом функции 9
Внутри функции изменения 90
После вызова функции 9

Сначала мы присваиваем 9 a , затем вызываем функцию изменения внутри этого мы присваиваем 90 и печатаем . После вызова функции мы снова печатая значение a . Когда мы пишем a = 90 внутри функция, она фактически создает новую переменную с именем a , которая только доступны внутри функции и будут уничтожены после завершения функции. Итак, хотя имя такое же для переменной и , но они отличаются и вне функции.

 #!/usr/bin/env python3
изменить определение (б):
    глобальный
    а = 90
    печать (а)
а = 9
print("Перед вызовом функции ", а)
print("внутри функции изменения", end=' ')
изменить (а)
print("После вызова функции ", а)
 

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

Вывод

 $ ./local.py
Перед вызовом функции 9
внутренняя функция изменения 90
После вызова функции 90
 

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

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

 >>> тест определения (a, b=-99):
... если а>б:
... вернуть Истина
...     еще:
... вернуть ложь
 

В приведенном выше примере мы написали b = -99 в списке параметров функции. Это означает, что если значение для b не указано, то значение b равно -99 . Это очень простой пример аргументов по умолчанию. Вы можете протестировать код с помощью

 >>> test(12, 23)
ЛОЖЬ
>>> тест(12)
Истинный
 

Важно

Важно

Помните, что у вас не может быть аргумента без аргумента по умолчанию, если перед ним уже есть один аргумент со значениями по умолчанию. Как f(a, b=90, c) является недопустимым, поскольку b имеет значение по умолчанию, но после этого c не имеет никакого значения по умолчанию.

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

 >>> def f(a, data=[]):
. .. data.append(a)
... вернуть данные
...
>>> напечатать (ф (1))
[1]
>>> напечатать(f(2))
[1, 2]
>>> напечатать (f (3))
[1, 2, 3]
 

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

 >>> def f(a, data=None):
... если данные отсутствуют:
... данные = []
... data.append(a)
... вернуть данные
...
>>> напечатать (ф (1))
[1]
>>> напечатать(f(2))
[2]
 

Примечание

Чтобы понять больше, прочитайте этот URL.

Аргументы ключевого слова

 >>> def func(a, b=5, c=10):
... print('a есть', a, 'и b есть', b, 'и c есть', c)
...
>>> функция(12, 24)
a равно 12, b равно 24 и c равно 10
>>> функция(12, с = 24)
a равно 12, b равно 5 и c равно 24.
>>> функция (b=12, c = 24, a = -1)
a равно -1, b равно 12 и c равно 24.
 

В приведенном выше примере вы можете видеть, что мы вызываем функцию с переменной имена, такие как func(12, c = 24) , тем самым мы присваиваем 24 c и b получение значения по умолчанию. Также помните, что вы не можете иметь без ключевого слова аргумент на основе после аргумента на основе ключевого слова. как

 >>> def func(a, b=13, v):
... печать (а, б, в)
...
Файл "", строка 1
SyntaxError: аргумент не по умолчанию следует за аргументом по умолчанию
 

Только ключевое слово аргумент

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

 >>> def hello(*, name: str = 'Пользователь'):
... print("Привет %s" % имя)
...
>>> привет ("Кушал")
Traceback (последний последний вызов):
  Файл "", строка 1, в 
TypeError: hello() принимает 0 позиционных аргументов, но был передан 1
>>> привет(имя='Кушал')
Привет Кушал
 

Примечание

Чтобы узнать больше, прочтите PEP-3102.

Только позиционный аргумент

Начиная с Python3.8, мы также можем пометить любую функцию как имеющую только позиционные аргументы. Писать / в конце всех позиционных аргументов в определении функции, чтобы иметь эту функцию.

 >>> def add(a: int, b: int, /):
... вернуть а + б
...
>>> добавить(2, 3)
5
>>> добавить(а=2, б=3)
Traceback (последний последний вызов):
Файл "", строка 1, в 
TypeError: add() получил некоторые позиционные аргументы, переданные как аргументы ключевого слова: 'a, b'
 

Вы можете видеть, что когда мы пытались вызвать add с аргументами ключевого слова, это вызвало TypeError .

Строки документации

В Python мы используем строки документации, чтобы объяснить, как использовать код, это будет полезно в интерактивном режиме и для создания автодокументации. Ниже мы видим пример строка документации для функции с именем longest_side .

 #!/usr/bin/env python3
импортировать математику
def самая длинная_сторона (a: целое число, b: целое число):
    """
    Функция нахождения длины наибольшей стороны прямоугольного треугольника. 
    :arg a: Сторона a треугольника
    :arg b: Сторона b треугольника
    :return: Длина самой длинной стороны c как float
    """
    вернуть math.sqrt(a*a + b*b)
если __name__ == '__main__':
    печать (самая длинная_сторона (4, 5))
 

Мы узнаем больше о строках документации в главе reStructuredText.

Функция высшего порядка

Функция высшего порядка или функтор – это функция, которая выполняет хотя бы одно из следующих действий: следующий шаг внутри:

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

В Python любая функция может действовать как функция высшего порядка.

 >>> высокий уровень (функция, значение):
... вернуть функцию (значение)
...
>>> lst = высокий (режим, интервал)
>>> напечатать(лст[-3:])
['имаг', 'числитель', 'реальный']
>>> печать (список)
 

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

 по умолчанию дать пять ():
    def add5(x: int) -> int:
        вернуть х + 5
    вернуть add5
>>> myadder = givemefive()
>>> напечатать(моя гадюка(10))
15
>>> печатать (тип (мой аддер))
<класс 'функция'>
 

Здесь, когда мы вызываем givemefive , на самом деле возвращается функция add5 , и сохранение в мой гадюка . Наконец, когда мы вызываем myadder , он добавляет 5 к заданный аргумент и возвращает его. Мы также напечатали тип из myadder

 def givemeadder(num):
    определение внутреннего (x):
        вернуть число + х
    вернуть внутренний
>>> add10 = дайте мне(10)
>>> напечатать (добавить10(20))
30
 

В этом примере внутренняя функция использует переменную x ​​ из внешний размах. Это также известно как закрытие , где функция использует закрытая среда. Если нам нужна новая функция, которая добавит 100 к заданному номер, мы можем сделать это легко вот так.

 add_big = даймеддер(100)
>>> печать (добавить_большой (1))
101
 

Примечание

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

map

map — очень полезный класс в Python. Выполняет одну функцию и итератор в качестве входных данных, а затем применяет функцию к каждому значению итератор и возвращает итератор.

Пример:

 >>> lst = [1, 2, 3, 4, 5]
>>> квадрат определения (число: целое число) -> целое число:
... "Возвращает квадрат заданного числа."
... вернуть число * число
...
>>> print(list(map(square, lst)))
[1, 4, 9, 16, 25]
 

В Python2 карта была функцией и использовалась для возврата списка.

Параметры и аргументы

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

 привет привет (имя, возраст):
    return f"Здравствуйте, {имя}, вам {возраст} лет"
привет ("кушал", 90)
 

В вышеприведенном примере имя и возраст являются параметрами hello , а кушал и 90 являются аргументы, переданные функции.