Python中的函数 - 芒果文档

📌 相关文章

📜 Python中的函数

📅 最后修改于: 2020-10-24 09:11:54 🧑 作者: Mango

Python函数

功能是应用程序最重要的方面。可以将函数定义为可重用代码的组织块，可以在需要时调用它。

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

该功能有助于程序员将程序分成较小的部分。它非常有效地组织了代码，并避免了代码的重复。随着程序的增长，函数使程序更有组织性。

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

功能主要有两种。

用户定义功能-用户定义的功能是由用户定义以执行特定任务的功能。
内置函数-内置函数是那些在Python中预定义的函数。

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

Python函数的优势

Python函数具有以下优点。

使用函数，我们可以避免在程序中一次又一次地重写相同的逻辑/代码。
我们可以在程序中以及程序中的任何地方多次调用Python函数。
当大型Python程序分为多个功能时，我们可以轻松地对其进行跟踪。
可重用性是Python函数的主要成就。
但是，在Python程序中，函数调用始终是开销。

创建一个功能

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

句法：

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

输出：

退货声明

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

输出：

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

示例2：创建没有返回语句的函数

# 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：传递不可变对象(列表)

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

输出：

示例2：传递可变对象(字符串)

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

输出：

参数类型

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

必填参数
关键字参数
默认参数
变长参数

必填参数

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

考虑以下示例。

例子1

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

输出：

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

输出：

例子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.

输出：

默认参数

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

例子1

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

输出：

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

输出：

可变长度参数(* args)

在大型项目中，有时我们可能不知道要预先传递的参数数量。在这种情况下， 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")

输出：

在上面的代码中，我们将* names作为可变长度参数传递。我们调用了函数并传递了在内部被视为元组的值。元组是一个与列表相同的可迭代序列。为了print给定的值，我们使用for循环迭代* arg名称。

关键字参数(** 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，变量是用两种类型的作用域定义的。

全局变量
局部变量

已知在任何函数外部定义的变量具有全局范围，而已知在函数内部定义的变量具有局部范围。

考虑以下示例。

示例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.

输出：

示例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:

输出：