Функции в python

Краткое введение в ООП

Объектно-ориентированное программирование (ООП) – технология разработки сложного программного обеспечения, в которой программа строится в виде совокупности объектов и их взаимосвязей.

Объединение данных и действий, производимых над этими данными, в единое целое, которое называется объектом – является одним из основных принципов ООП.

Основными понятиями являются понятие класса и объекта.

Класс является типом данных, определяемым пользователем и представляет собой структуру в виде данных и методов для работы с данными.

Формально Класс — это шаблон, по которому будет сделан объект.

Объект является экземпляром класса. Объект  и экземпляр - это одно и то же.

Вот пример. Форма для изготовления печенья – это класс, а само печенье это объект или экземпляр класса, т.е. это конкретное изделие. Печенье имеет размеры, цвет, состав – это атрибуты класса. Также в классе описываются методы, которые предназначены для чтения или изменения данных объекта.

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

Объект = атрибуты + методы 

Функции vs процедуры — в чем отличие?

Для языка нет различий между функциями и процедурами. Но с точки зрения программиста — это разные сущности.

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

Она успешно отработает, но не вернёт нам результат. Поэтому добавляем ключевое слово , и вот этот код обретает смысл:

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

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

Передача списка функции на Python

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

>>> def square(numbers):
…     «»»Вычисление квадрата числа»»»
…     for number in numbers:
…             print(number ** 2)
…
>>> numbers =
>>> square(numbers)1
25
36
225
49
2.25

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

Добавление элементов в список

Python предоставляет функцию append(), которая используется для добавления элемента в список. Однако функция append() может добавлять значение только в конец списка.

Рассмотрим следующий пример, в котором мы берем элементы списка у пользователя и выводим список на консоль.

 
#Declaring the empty list 
l =[] 
#Number of elements will be entered by the user   
n = int(input("Enter the number of elements in the list:")) 
# for loop to take the input 
for i in range(0,n):    
    # The input is taken from the user and added to the list as the item 
    l.append(input("Enter the item:"))    
print("printing the list items..")  
# traversal loop to print the list items   
for i in l:  
    print(i, end = "  ")    

Выход:

Enter the number of elements in the list:5 
Enter the item:25 
Enter the item:46 
Enter the item:12 
Enter the item:75 
Enter the item:42 
printing the list items 
25  46  12  75  42   

Default Arguments

A default argument is an argument that assumes a default value if a value is not provided in the function call for that argument. The following example gives an idea on default arguments, it prints default age if it is not passed −

#!/usr/bin/python3

# Function definition is here
def printinfo( name, age = 35 ):
   "This prints a passed info into this function"
   print ("Name: ", name)
   print ("Age ", age)
   return

# Now you can call printinfo function
printinfo( age = 50, name = "miki" )
printinfo( name = "miki" )

When the above code is executed, it produces the following result −

Name:  miki
Age  50
Name:  miki
Age  35

Определение и вызов простой функции в Python

Ниже приведен пример базовой функции. В ней нет оператора return, и никаких параметров она тоже не принимает.

Эта функция просто выводит hello world при каждом вызове.

def hello_world_func():
    print("hello world")

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

Вызывать функцию можно столько раз, сколько вам нужно.

Для вызова функции используется следующий синтаксис:

function_name(arguments)

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

Для вызова функции из нашего примера пишем следующий код:

hello_world_func()

# Результат:
# hello world 

Как определять параметр со значением по умолчанию

Аргументы функции также могут иметь значения по умолчанию.

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

Делается это в формате .

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

def fave_language(language="Python"):
    print(f"My favorite  programming language is {language}!")
    
fave_language()
# Выводит в консоль "My favorite  programming language is Python!" 

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

В нашем примере, если не передан аргумент, значением всегда будет .

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

def fave_language(language="python"):
    print(f"My favorite  programming language is {language}!")
    
fave_language("Java")
# Выводит в консоль "My favorite  programming language is Java!" 

В функции может быть и несколько значений по умолчанию.

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

def personal_details(name="Jimmy",age=28,city="Berlin"):
    print(f"I am {name},{age} years old and live in {city}") 
    
# Мы можем вызывать эту функцию так:

personal_details()
# Результат:
# I am Jimmy,28 years old and live in Berlin

personal_details(age=30)
# I am Jimmy,30 years old and live in Berlin

personal_details(city="Athens",name="Ben",age=24)
# I am Ben,24 years old and live in Athens

Аргументы со значениями по умолчанию можно комбинировать с оыбчными.

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

def fave_language(name,language="Python"):
    print(f"My name is {name} and my favorite  programming language is {language}!")
    
fave_language("Dionysia")
# Результат:
#"My name is Dionysia and my favorite  programming language is Python!" 

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

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

Вот такой код не сработал бы:

def fave_language(language="Python",name):
    print(f"My name is {name} and my favorite  programming language is {language}!")
    
fave_language("Dionysia")

# Результат:
 File "<stdin>", line 1
SyntaxError: non-default argument follows default argument

От редакции Pythonist. Иногда нельзя предсказать, сколько аргументов получит функция. Чтобы обработать их, используются специальные конструкции и . Почитать подробнее можно в статье «Что такое *args и **kwargs?».

5.1.1. Основные понятия и механизм работы¶

Подпрограмма должна быть объявлена и в общем случае содержать:

• имя;

• список имен и типов передаваемых параметров (необязательно);

• тип возвращаемого значения (необязательно).

Если подпрограмма возвращает значение вызывающему коду (одно или несколько), она называется функцией, иначе — .

Большинство современных языков программирования для управления вызовом подпрограмм используют стек вызовов.

Примерный цикл работы стека вызова следующий (Видео 5.1.1, Видео 5.1.2):

1. Вызов подпрограммы создает запись в стеке; каждая запись может содержать информацию о данных вызова (аргументах, результате, а также адресе возврата).

2. Когда подпрограмма завершается, запись удаляется из стека и программа продолжает выполняться, начиная с адреса возврата.

Видео 5.1.1 — Cтек вызовов (пример, Нетология)

Your browser does not support the video tag.

Видео 5.1.2 — Cтек вызовов (пример, Stepik.org)

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

Python позволяет нам вызывать функцию с аргументами ключевых слов. Такой вызов функции позволит нам передавать аргументы в случайном порядке.

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

Рассмотрим следующие примеры.

Пример 1.

#function func is called with the name and message as the keyword arguments  
def func(name,message):  
    print("printing the message with",name,"and ",message)  
    
    #name and message is copied with the values John and hello respectively  
    func(name = "John",message="hello") 

Выход:

Пример 2. С указанием значений в другом порядке при вызове.

#The function simple_interest(p, t, r) is called with the keyword arguments the order of arguments doesn't matter in this case  
def simple_interest(p,t,r):  
    return(p*t*r)/100  
print("Simple Interest: ",simple_interest(t=10,r=10,p=1900))   

Выход:
Если мы предоставим другое имя аргументов во время вызова функции, будет выдана ошибка.

Рассмотрим следующий пример.

Пример 3.

#The function simple_interest(p, t, r) is called with the keyword arguments.   
def simple_interest(p,t,r):  
    return(p*t*r)/100  

# doesn't find the exact match of the name of the arguments(keywords)    
print("Simple Interest: ",simple_interest(time=10,rate=10,principle=1900)) 

Выход:

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

Рассмотрим следующие примеры.

Пример 4.

def func(name1,message,name2):  
    print("printing the message with",name1,",",message,",and",name2)  
#the first argument is not the keyword argument  
func("John",message="hello",name2="David") 

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

Пример 5.

def func(name1,message,name2): 
    print("printing the message with",name1,",",message,",and",name2)  
func("John",message="hello","David")      

Выход:
Python предоставляет возможность передавать несколько аргументов ключевого слова, которые могут быть представлены как ** kwargs. Похож на * args, но сохраняет аргумент в формате словаря. Этот тип аргументов полезен, когда мы не знаем заранее количество аргументов.

Рассмотрим следующий пример:

Пример 6. Многие аргументы используют аргумент ключевого слова.

def food(**kwargs):
    print(kwargs)
food(a="Apple")
food(fruits="Orange", Vagitables="Carrot")

Выход:

{'a': 'Apple'}
{'fruits': 'Orange', 'Vagitables': 'Carrot'}

Как определять и вызывать функции с параметрами в Python

Пока что мы рассмотрели самый базовый вариант функции. Она лишь выводит что-то в консоль.

Но что, если в функцию нужно передать какие-то дополнительные данные?

Здесь мы используем такие термины, как параметры и аргументы.

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

def hello_to_you(name):
    print("Hello " + name)

В нашем примере мы указали один параметр — .

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

def hello_to_you(name):
    print(f"Hello {name}")

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

def name_and_age(name,age):
    print(f"I am {name} and I am {age} years old!")

Здесь параметры функции — и .

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

Аргументы — это информация, переданная в функцию. Они представляют собой настоящие значения, соответствующие параметрам, которые были указаны при объявлении функции.

Марк Лутц «Изучаем Python»

Скачивайте книгу у нас в телеграм

Скачать

×

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

def hello_to_you(name):
    print(f"Hello {name}")
    
    
hello_to_you("Timmy")
# Результат:
# Hello Timmy

Функцию можно вызывать многократно, каждый раз передавая разные значения в качестве аргументов:

def hello_to_you(name):
    print(f"Hello {name}")
    
hello_to_you("Timmy")
hello_to_you("Kristy")
hello_to_you("Jackie")
hello_to_you("Liv")

# Результат:
# "Hello Timmy"
# "Hello Kristy"
# "Hello Jackie"
# "Hello Liv"

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

Область действия переменной

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

#editor
def example_function():
  word = "inevitable"
  return word

print(word)

#console
NameError: name 'word' is not defined

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

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

#editor
word = "inevitable"
def example_function():
  return word

print(word)

#console
inevitable

Возвращаемые значения (return)

Распаковка возвращаемых значений

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

️ Обратите внимание, что количество возвращаемых значение в кортеже должно совпадать с количеством переменных при распаковке. Иначе произойдет ошибка:

Пустая функция

Иногда разработчики оставляют реализацию на потом, и чтобы объявленная функция не генерировала ошибки из-за отсутствия тела, в качестве заглушки используется ключевое слово

The return Statement

The statement return exits a function, optionally passing back an expression to the caller. A return statement with no arguments is the same as return None.

All the above examples are not returning any value. You can return a value from a function as follows −

#!/usr/bin/python

# Function definition is here
def sum( arg1, arg2 ):
   # Add both the parameters and return them."
   total = arg1 + arg2
   print "Inside the function : ", total
   return total;

# Now you can call sum function
total = sum( 10, 20 );
print "Outside the function : ", total 

When the above code is executed, it produces the following result −

Inside the function :  30
Outside the function :  30

Зачем использовать лямбда функцию в Python?

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

#the function table(n) prints the table of n    
def table(n):    
    return lambda a:a*n # a will contain the iteration variable i and a multiple of n is returned at each function call    
n = int(input("Enter the number:"))    
b = table(n) #the entered number is passed into the function table. b will contain a lambda function which is called again and again with the iteration variable i    
for i in range(1,11):    
    print(n,"X",i,"=",b(i)) #the lambda function b is called with the iteration variable i

Вывод

Enter the number:10
10 X 1 = 10 
10 X 2 = 20
10 X 3 = 30
10 X 4 = 40
10 X 5 = 50
10 X 6 = 60
10 X 7 = 70
10 X 8 = 80
10 X 9 = 90
10 X 10 = 100

Лямбда-функция обычно используется со встроенными функциями Python, функциями filter() и map().

Возврат нескольких значений из одной функции

В Python существует возможность возвращать из функции несколько значений.

Вот простой пример:

def f():
    a = 5
    b = 6
    c = 7
    return a, b, c
var1, var2, var3 = f()

print("var1={0} var2={1} var3={2}".format(var1, var2, var3))

Результат:

var1=5 var2=6 var3=7

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

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

Этот пример можно было бы записать и так:

def f():
    a = 5
    b = 6
    c = 7
    return a, b, c
return_value = f()

print(return_value)

Результат:

(5, 6, 7)

В таком случае return_value было бы кортежем, содержащим все три возвращенные переменные.

Иногда разумнее возвращать несколько значений не в виде кортежа, а в виде словаря:

def f():
    a = 5
    b = 6
    c = 7
    return {'a' : a, 'b' : b, 'c' : c}

return_value = f()

print(return_value)

Результат:

{'a': 5, 'b': 6, 'c': 7}

Python Tutorial

Python HOMEPython IntroPython Get StartedPython SyntaxPython CommentsPython Variables
Python Variables
Variable Names
Assign Multiple Values
Output Variables
Global Variables
Variable Exercises

Python Data TypesPython NumbersPython CastingPython Strings
Python Strings
Slicing Strings
Modify Strings
Concatenate Strings
Format Strings
Escape Characters
String Methods
String Exercises

Python BooleansPython OperatorsPython Lists
Python Lists
Access List Items
Change List Items
Add List Items
Remove List Items
Loop Lists
List Comprehension
Sort Lists
Copy Lists
Join Lists
List Methods
List Exercises

Python Tuples
Python Tuples
Access Tuples
Update Tuples
Unpack Tuples
Loop Tuples
Join Tuples
Tuple Methods
Tuple Exercises

Python Sets
Python Sets
Access Set Items
Add Set Items
Remove Set Items
Loop Sets
Join Sets
Set Methods
Set Exercises

Python Dictionaries
Python Dictionaries
Access Items
Change Items
Add Items
Remove Items
Loop Dictionaries
Copy Dictionaries
Nested Dictionaries
Dictionary Methods
Dictionary Exercise

Python If…ElsePython While LoopsPython For LoopsPython FunctionsPython LambdaPython ArraysPython Classes/ObjectsPython InheritancePython IteratorsPython ScopePython ModulesPython DatesPython MathPython JSONPython RegExPython PIPPython Try…ExceptPython User InputPython String Formatting

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

Функции в Python – это организованный блок многократно используемого кода, который можно вызывать при необходимости.

Функция содержит набор программных операторов, заключенных в {}. Функцию можно вызывать несколько раз, чтобы обеспечить возможность повторного использования и модульность программы Python.

Функция помогает программисту разбить программу на более мелкие части. Она очень эффективно организует код и избегает повторения кода. По мере роста программы функция делает ее более организованной.

Python предоставляет нам различные встроенные функции, такие как range() или print(). Пользователь также может создавать свои функции, которые можно назвать пользовательскими функциями.

В основном есть два типа функций:

• Функции, определяемые пользователем. Определяются пользователем для выполнения конкретной задачи.
• Встроенные функции. Это те функции, которые предварительно определены в Python.

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

Синтаксис для определения анонимной функции

lambda arguments: expression     

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

Рассмотрим следующий пример лямбда-функции.

Пример 1

# a is an argument and a+10 is an expression which got evaluated and returned.  
x = lambda a:a+10 
# Here we are printing the function object
print(x)
print("sum = ",x(20))

Выход:

<function <lambda> at 0x0000019E285D16A8>
sum =  30

В приведенном выше примере мы определили анонимную функцию лямбда a: a + 10, где a – аргумент, а a + 10 – выражение. Данное выражение оценивается и возвращает результат. Вышеупомянутая лямбда-функция такая же, как и обычная функция.

def x(a):
 return a+10
print(sum = x(10))

Обязательные (позиционные) аргументы

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

Чтобы вызвать функцию printme() , вам обязательно нужно передать один аргумент, иначе она выдаст следующую синтаксическую ошибку:

# Определение функции
def printme( str ):
   """This prints a passed string into this function"""
   print(str)
   return

# Теперь вы можете вызвать функцию printme
printme()

Ошибка (в функции Printme не указан аргумент):

Traceback (most recent call last):
  File "C:/Users/User/Desktop/CodePythonFunc.py", line 8, in <module>
    printme()
TypeError: printme() missing 1 required positional argument: 'str'

Правильно указать аргумент так:

# Определение функции
def printme( str ):
   """This prints a passed string into this function"""
   print(str)
   return

# Теперь вы можете вызвать функцию printme
printme("Текстовая переменная")

Основные операторы

Оператор

Краткое описание

+

Сложение (сумма x и y)

—

Вычитание (разность x и y)

*

Умножение (произведение x и y)

Деление
Внимание! Если x и y целые, то результат всегда будет целым числом! Для получения вещественного результата хотя бы одно из чисел должно быть вещественным. Пример: 40/5 → 8, а вот 40/5.0 → 8.0

=

Присвоение

+=

y+=x; эквивалентно y = y + x;

-=

y-=x; эквивалентно y = y — x;

*=

y*=x; эквивалентно y = y * x;

/=

y/=x; эквивалентно y = y / x;

%=

y%=x; эквивалентно y = y % x;

==

Равно

!=

не равно

> 

Больше

=

больше или равно

Часть после запятой отбрасывается
4 // 3 в результате будет 125 // 6 в результате будет 4

**

Возведение в степень
5 ** 2 в результате будет 25

and

логическое И

or

логическое ИЛИ

not

логическое отрицание НЕ

Метод 2: Используйте атрибут __qualname__

Чтобы извлечь имя из любого объекта или класса, вы также можете использовать его атрибут. Например, звонок дает строковое значение Отказ Вы бы использовали над Если вам также понадобится какой-то контекст, такой как класс, определяющий метод.

Следующий код создает функцию и способ внутри класса. Затем он сравнивает вывод и Атрибуты как функции, так и класса:

def my_function():
    pass


class My_Class(object):
    def my_method(self):
        pass


print(my_function.__name__)             # "my_function"
print(My_Class.my_method.__name__)      # "my_method"

print(my_function.__qualname__)         # "my_function"
print(My_Class.my_method.__qualname__)  # "My_Class.my_method"

Вы можете погрузиться глубже в идиосинкразиях здесь и здесь Отказ

Спасибо за прочтение этой статьи. Чтобы повысить свои навыки Python, подумайте о том, чтобы присоединиться к бесплатной академии электронной почты Finxter с большим количеством чит-листов, учебников Python и забиты забавных программиров!

Работая в качестве исследователя в распределенных системах, доктор Кристиан Майер нашел свою любовь к учению студентов компьютерных наук.

Чтобы помочь студентам достичь более высоких уровней успеха Python, он основал сайт программирования образования Finxter.com Отказ Он автор популярной книги программирования Python одноклассники (Nostarch 2020), Coauthor of Кофе-брейк Python Серия самооставленных книг, энтузиаста компьютерных наук, Фрилансера и владелец одного из лучших 10 крупнейших Питон блоги по всему миру.

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

Оригинал: “https://blog.finxter.com/how-to-get-a-function-name-as-a-string-in-python/”

Scope and Lifetime of variables

Scope of a variable is the portion of a program where the variable is recognized. Parameters and variables defined inside a function are not visible from outside the function. Hence, they have a local scope.

The lifetime of a variable is the period throughout which the variable exists in the memory. The lifetime of variables inside a function is as long as the function executes.

They are destroyed once we return from the function. Hence, a function does not remember the value of a variable from its previous calls.

Here is an example to illustrate the scope of a variable inside a function.

Output

Value inside function: 10
Value outside function: 20

Here, we can see that the value of x is 20 initially. Even though the function changed the value of x to 10, it did not affect the value outside the function.

This is because the variable x inside the function is different (local to the function) from the one outside. Although they have the same names, they are two different variables with different scopes.

On the other hand, variables outside of the function are visible from inside. They have a global scope.

We can read these values from inside the function but cannot change (write) them. In order to modify the value of variables outside the function, they must be declared as global variables using the keyword .

Встроенные функции

print (x, sep = 'y') печатает x объектов, разделенных y

len (x) возвращает длину x (s, L или D)

min (L ) возвращает минимальное значение в L

max (L) возвращает максимальное значение в L

sum (L) возвращает сумму значений в диапазоне L

range(n1,n2,n) (n1, n2, n) возвращает последовательность чисел от n1 до n2 с шагом n

abs (n) возвращает абсолютное значение n

round (n1, n) возвращает число n1, округленное до n цифр

type (x) возвращает тип x (string, float, list, dict…)

str (x) преобразует x в string 

list (x) преобразует x в список

int (x) преобразует x в целое число

float (x) преобразует x в число с плавающей запятой

help (s) печатает справку о x

map (function, L) Применяет функцию к значениям в L

Как вызвать функцию в Python

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

>>> def say_hello():
...     print('Hello')
...
>>> say_hello()
Hello

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

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

>>> a = 1
>>> b = 10
>>> def fn():
...     print(a)    # local a is not assigned, no enclosing function, global a referenced.
...     b = 20      # local b is assigned in the local symbol table for the function.
...     print(b)    # local b is referenced.
...
>>> fn()
1
20
>>> b               # global b is not changed by the function call.
10

Фактические параметры (аргументы) к вызовам функции вводятся в локальной таблице символов вызываемой функции, когда она называется; Таким образом, аргументы передаются с использованием вызова по значению (где значение всегда является ссылкой на объект, а не значение объекта). Когда функция вызывает другую функцию, для этого вызова создается новая локальная таблица символов.

>>> def greet(s):
...     s = "Hello " + s    # s in local symbol table is reassigned.
...     print(s)
...
>>> person = "Bob"
>>> greet(person)
Hello Bob
>>> person                  # person used to call remains bound to original object, 'Bob'.
'Bob'

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

>>> def fn(arg):
...     arg.append(1)
...
>>> a = 
>>> fn(a)
>>> a

Вызов функции

В определении функции указывается имя функции, её параметры, а также тело функции (реализация требуемой функциональности).

Как только базовая структура функции создана, вы можете выполнить ее, вызвав ее из другой функции или непосредственно из Python prompt (командной оболочки). Ниже приведен пример вызова функции printme():

# Определение функции
def printme( str ):
    """This prints a passed string into this function"""
    print(str)
    return

# Теперь вы можете вызвать функцию printme
printme("I'm first call to user defined function!")
printme("Again second call to the same function")

Результат:

I'm first call to user defined function!
Again second call to the same function

Аргументы функции

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

• Обязательные аргументы
• Ключевые аргументы
• Аргументы по умолчанию
• Аргументы переменной длины

Команда if со списками.

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

>>> cars =
>>> for brand in cars:
…     if brand == ‘audi’
…             print(f»Гарантия на автомобиль {brand.title()} 2 года»)
…     elif brand == ‘bmw’
…             print(f»Гарантия на автомобиль {brand.title()} 3 года»)
…     else:
…             print(f»Гарантия на автомобиль {brand.title()} 5 лет»)
…Гарантия на автомобиль Ford 5 лет
Гарантия на автомобиль Opel 5 лет
Гарантия на автомобиль Audi 2 года
Гарантия на автомобиль Land Rover 5 лет
Гарантия на автомобиль Bmw 3 года

В данном примере с помощью команды мы перебираем весь список автомобилей. Если марка автомобиля соответствует условия if-elif, то выводится для этих марок свое сообщение по условиям гарантии. В случае не совпадения условий, выдается общее сообщение для всех остальных марок. 

Please enable JavaScript to view the comments powered by Disqus.