Python 函数

函数是应用最重要的方面。一个函数可以被定义为可重用代码的组织块，它可以在任何需要的时候被调用。

Python 允许我们将一个大型程序划分为称为函数的基本构建块。该函数包含由{}括起来的一组编程语句。一个函数可以被多次调用，为 Python 程序提供可重用性和模块化。

这个函数帮助程序员把程序分成更小的部分。它非常有效地组织了代码，避免了代码的重复。随着程序的增长，函数使程序更有条理。

Python 为我们提供了各种内置功能，如 range() 或 print() 。虽然，用户可以创建它的函数，这些函数可以称为用户定义函数。

主要有两种功能。

• User-Defined Function -用户自定义功能是由用户为执行特定任务而定义的功能。

• 内置函数 -内置函数是那些在 Python 中预定义的函数。

在本教程中，我们将讨论用户定义函数。

Python 中函数的优势

Python 函数有以下优点。

• 使用函数，我们可以避免在程序中一次又一次地重写相同的逻辑/代码。

• 我们可以在一个程序中多次调用 Python 函数，也可以在程序的任何地方调用。

• 当一个大型 Python 程序被分成多个函数时，我们可以很容易地跟踪它。

• 可重用性是 Python 函数的主要成就。

• 然而，在 Python 程序中，函数调用总是开销很大。

创建函数

Python 提供了 def 关键字来定义函数。下面给出了定义函数的语法。

语法:

def my_function(parameters):
      function_block
return expression

让我们理解函数定义的语法。

• def 关键字和函数名一起用于定义函数。

• 标识符规则必须遵循函数名。

• 函数接受参数(参数)，它们可以是可选的。

• 功能块以冒号(:)开头，块语句必须在同一缩进处。

• return 语句用于返回值。一个功能只能有一个返回

函数调用

在 Python 中，创建函数后，我们可以从另一个函数调用它。函数必须在函数调用之前定义；否则，Python 解释器会给出一个错误。要调用该函数，请使用后跟括号的函数名。

考虑下面一个简单示例的例子，该示例打印消息“Hello World”。

#function definition
def hello_world():  
    print("hello world")  
# function calling
hello_world()    

输出:

hello world

return

return 语句用在函数的末尾，并返回函数的结果。它终止函数的执行，并将结果传送到调用函数的地方。return 语句不能在函数外使用。

语法

return [expression_list]

它可以包含表达式，该表达式将被求值并将值返回给调用者函数。如果 return 语句没有表达式或者本身不存在于函数中，那么它返回 None 对象。

考虑以下示例:

例 1

# Defining function
def sum():
    a = 10
    b = 20
    c = a+b
    return c
# calling sum() function in print statement
print("The sum is:",sum())

输出:

The sum is: 30

在上面的代码中，我们定义了名为 sum的函数，它有一个语句 c = a+b 计算给定值，结果由 return 语句返回给调用者函数。

示例 2 创建没有return语句的函数

# Defining function
def sum():
    a = 10
    b = 20
    c = a+b
# calling sum() function in print statement
print(sum())

输出:

None

在上面的代码中，我们定义了相同的没有 return 语句的函数，因为我们可以看到 sum() 函数向调用者函数返回了 None 对象。

函数中的参数

参数是可以传递给函数的信息类型。参数在括号中指定。我们可以传递任意数量的参数，但是它们必须用逗号隔开。

考虑以下示例，其中包含一个接受字符串作为参数的函数。

例 1

#defining the function  
def func (name):  
    print("Hi ",name) 
#calling the function   
func("Devansh")   

输出:

Hi Devansh

例 2

#Python function to calculate the sum of two variables   
#defining the function  
def sum (a,b):  
    return a+b;  

#taking values from the user  
a = int(input("Enter a: "))  
b = int(input("Enter b: "))  

#printing the sum of a and b  
print("Sum = ",sum(a,b))  

输出:

Enter a: 10
Enter b: 20
Sum =  30

Python 中的引用调用

在 Python 中，引用调用意味着将实际值作为参数传递给函数。所有函数都是通过引用调用的，也就是说，对函数内部的引用所做的所有更改都会恢复到引用所引用的原始值。

示例 1 传递不可变对象(list)

#defining the function  
def change_list(list1):  
    list1.append(20) 
    list1.append(30)  
    print("list inside function = ",list1)  

#defining the list  
list1 = [10,30,40,50]  

#calling the function   
change_list(list1)
print("list outside function = ",list1)

输出:

list inside function =  [10, 30, 40, 50, 20, 30]
list outside function =  [10, 30, 40, 50, 20, 30]

示例 2 传递可变对象(str)

#defining the function  
def change_string (str):  
    str = str + " Hows you "
    print("printing the string inside function :",str)

string1 = "Hi I am there"  

#calling the function  
change_string(string1)  

print("printing the string outside function :",string1)  

输出:

printing the string inside function : Hi I am there Hows you 
printing the string outside function : Hi I am there

参数类型

可能有几种类型的参数可以在函数调用时传递。

1. 必需的参数

2. 关键字参数

3. 默认参数

4. 可变长度参数

必需的参数

到目前为止，我们已经了解了 Python 中的函数调用。但是，我们可以在函数调用时提供参数。就所需参数而言，这些是在函数调用时需要传递的参数，它们在函数调用和函数定义中的位置完全匹配。如果函数调用中没有提供任何一个参数，或者参数的位置发生了变化，Python 解释器将显示错误。

考虑下面的例子。

例 1

def func(name):  
    message = "Hi "+name
    return message
name = input("Enter the name:")  
print(func(name))  

输出:

Enter the name: John
Hi John

例 2

#the function simple_interest accepts three arguments and returns the simple interest accordingly  
def simple_interest(p,t,r):  
    return (p*t*r)/100  
p = float(input("Enter the principle amount? "))  
r = float(input("Enter the rate of interest? "))  
t = float(input("Enter the time in years? "))  
print("Simple Interest: ",simple_interest(p,r,t))  

输出:

Enter the principle amount: 5000
Enter the rate of interest: 5
Enter the time in years: 3
Simple Interest:  750.0

例 3

#the function calculate returns the sum of two arguments a and b  
def calculate(a,b):  
    return a+b  
calculate(10) # this causes an error as we are missing a required arguments b.  

输出:

TypeError: calculate() missing 1 required positional argument: 'b'

默认参数

Python 允许我们在函数定义中初始化参数。如果在函数调用时没有提供任何参数的值，那么即使在函数调用时没有指定参数，也可以用定义中给出的值初始化该参数。

例 1

def printme(name,age=22):  
    print("My name is",name,"and age is",age)  
printme(name = "john")

输出:

My name is John and age is 22

例 2

def printme(name,age=22):  
    print("My name is",name,"and age is",age)  
printme(name = "john") #the variable age is not passed into the function however the default value of age is considered in the function  
printme(age = 10,name="David") #the value of age is overwritten here, 10 will be printed as age 

输出:

My name is john and age is 22
My name is David and age is 10

可变长度参数(*参数)

在大型项目中，有时我们可能不知道要提前传递的参数数量。在这种情况下，Python 为我们提供了提供逗号分隔值的灵活性，这些值在函数调用时在内部被视为元组。通过使用可变长度参数，我们可以传递任意数量的参数。

然而，在函数定义中，我们使用 args (star)将变长参数定义为 <变量名>。

考虑下面的例子。

例

def printme(*names):  
    print("type of passed argument is ",type(names))  
    print("printing the passed arguments...")  
    for name in names:  
        print(name)  
printme("john","David","smith","nick")  

输出:

type of passed argument is  <class 'tuple'>
printing the passed arguments...
john
David
smith
nick

在上面的代码中，我们传递了name 作为变长参数。我们调用了函数，并传递了在内部被视为元组的值。元组是与列表相同的可迭代序列。为了打印给定值，我们迭代了用于循环的*参数名。

关键字参数(**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") 

输出:

printing the message with John and  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))   

输出:

Simple Interest:  1900.0

如果我们在函数调用时提供不同的参数名称，将会抛出一个错误。

考虑下面的例子。

例 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)) 

输出:

TypeError: simple_interest() got an unexpected keyword argument 'time'

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") 

输出:

printing the message with John , hello ,and David

下面的示例将导致一个错误，因为在函数调用中传递了关键字和必需参数的不正确组合。

例 5

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

输出:

SyntaxError: positional argument follows keyword argument

Python 提供了传递多个关键字参数的工具，这些参数可以表示为 **kwargs 。它与 *args 相似，但它以字典格式存储参数。

当我们事先不知道参数的数量时，这种类型的参数是有用的。

考虑以下示例:

示例 6:使用关键字参数的多个参数

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

输出:

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

变量的范围

变量的范围取决于变量被声明的位置。程序的一部分中声明的变量可能无法被其他部分访问。

在 python 中，变量是用两种类型的作用域定义的。

1. 全局变量

2. 局部变量

任何函数外部定义的变量都具有全局作用域，而函数内部定义的变量具有局部作用域。

考虑下面的例子。

示例 1 局部变量

def print_message():  
    message = "hello !! I am going to print a message." # the variable message is local to the function itself  
    print(message)  
print_message()  
print(message) # this will cause an error since a local variable cannot be accessible here.    

输出:

hello !! I am going to print a message.
  File "/root/PycharmProjects/PythonTest/Test1.py", line 5, in 
    print(message)
NameError: name 'message' is not defined

示例 2 全局变量

def calculate(*args):  
    sum=0  
    for arg in args:  
        sum = sum +arg  
    print("The sum is",sum)  
sum=0  
calculate(10,20,30) #60 will be printed as the sum  
print("Value of sum outside the function:",sum) # 0 will be printed  Output:

输出:

The sum is 60
Value of sum outside the function: 0

原文：https://www.javatpoint.com/python-functions

---