【python函数】-世界杯莫德里奇-南美世界杯预选赛_阿根廷世界杯

文章目录

前言一、函数是什么？（What）二、为什么要使用函数（Why）三、如何使用函数（How）1.定义函数2.调用函数

四、拓展1.参数传递2.调用函数中的参数3.return语句

总结

前言

函数在很多编程语言中都是一种基本的构建块，它们使得程序更加灵活、可维护和可扩展。

一、函数是什么？（What）

函数是组织好的、可重复使用的代码块，用于执行特定的任务。函数的功能是：接受输入参数，并返回一个或多个值。函数就像一个小工具，能帮你完成特定的任务你可以定义一个函数，给他一些数据，然后他就可以按照你设定的规则处理数据，最后返回结果。

二、为什么要使用函数（Why）

假设你需要分别计算多个不同半径的圆形的面积，如果没有函数这个工具，你需要每次都详细的列出计算过程，对半径是1的圆形，你需要计算一次，对半径是2的圆形，你又需要计算一次。有了函数这个工具，我们就可以定义或调用一个计算圆形面积的函数，然后提供圆形的半径，让函数帮我们去计算对应的面积。这避免了大量重复代码的编写，使得代码更具可读性。函数可以让你在处理更复杂问题时不必纠结于具体的计算细节，只需要关注函数的功能和如何使用它去实现你的目的。函数可以独立的进行测试和调试，而不需要运行全部代码。

三、如何使用函数（How）

1.定义函数函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。

圆括号内是需要传入的数据和参数

函数内容以冒号 : 起始，并且缩进。

return [表达式] 结束函数，选择性地返回一个值给调用方，不带表达式的 return 相当于返回 None。

函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。

下面展示根据半径计算圆面积的函数：

def compute_area_circle(x):

"""

这个函数输入圆的半径，计算后返回圆的面积。

"""

return 3.14 * x ** 2

2.调用函数调用函数只需要使用：函数标识符名称（参数）下面展示上面所定义函数的调用

a = compute_area_circle(5)

print(a)

运行结果如下：

PS C:\Users\28077> & C:/Users/28077/AppData/Local/Programs/Python/Python312/python.exe e:/python学习中的案例/函数定义与调用.py

78.5

四、拓展

如上所说，一个函数在定义时有这几个最基本的组成部分：def关键字，函数标识符名称，括号中输入的参数，冒号，以及后面的函数体。而函数在调用时只需要函数标识符名称和括号中输入的参数值。

1.参数传递

在了解参数传递之前，我们需要知道python中类型和对象的关系：在python中，类型是对象的属性，对象有不同类型的区分，变量作为承载对象的盒子，是没有类型的：

a = [1, 2, 3, 4, 5]

a = "hello world"

type(a)

以上代码中的[1,2,3]是List类型，“hello world”是String类型，而变量a没有类型，它仅仅是一个对象的引用（通过指针来实现），可以指向List类型对象，也可以指向String类型对象。

在python的类型中，有些类型是可以更改的，有些类型则不能更改。 strings, tuples, 和 numbers 是不可更改的类型，而 list,dict 等则是可以修改的类型。在 python 中，strings, tuples, 和 numbers 是不可更改的类型，而 list,dict 等则是可以修改的类型。

那么能否更改是如何体现的呢，请看如下案例：

不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变 a 的值，相当于新生成了 a。可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

而python的参数传递根据以上能否更改的特点可分为两类：

不可变类型：类似 C++ 的值传递，如整数、字符串、元组。如 fun(a)，传递的只是 a 的值，没有影响 a 对象本身。如果在 fun(a) 内部修改 a 的值，则是新生成一个 a 的对象。可变类型：类似 C++ 的引用传递，如列表，字典。如 fun(la)，则是将 la 真正的传过去，修改后 fun 外部的 la 也会受影响。python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

以下是python参数传递的实例

python 传不可变对象实例: 通过id函数来查看内存地址的变化：

def change(a):

print(id(a))

a = 10

print(id(a))

a = 1

print(id(a))

change(a)

以上代码输出为

140707492456888

140707492457176

可见在调用函数前后形参和实参指向的是同一个对象（对象id相同），在函数内部修改形参后，形参指向的是不同的id。

传可变对象的实例：可变对象在函数里修改了参数，那么在调用这个函数的函数里，原始的参数也被改变了。例如：

def changelist(list):

#打印传入的列表的id

print(id(list))

#修改列表

list.append(100)

#打印修改后的列表的id

print(id(list))

print("函数内取值：", list)

return

#调用changelist函数

mylist = [1, 2, 3]

print(id(mylist))

changelist(mylist)

print("函数外取值：", mylist)

传入的函数和在末尾添加新内容的对象用的是同一个引用。故输出结果如下：

1754913209792

函数内取值： [1, 2, 3, 100]

函数外取值： [1, 2, 3, 100]

2.调用函数中的参数

调用函数时可使用的正式参数类型有四种：

必须参数关键字参数默认参数不定长参数

必需参数必需参数须以正确的顺序传入函数，调用时的数量必须和声明时一样。例如调用print_str函数时，你必须传入一个参数，不然会出现语法错误：

def print_str(str):

"打印任何传入的字符串"

print(str)

print_str()

以上实例输出结果：

---------------------------------------------------------------------------

TypeError Traceback (most recent call last)

Cell In[101], line 4

2 "打印任何传入的字符串"

3 print(str)

----> 4 print_str()

TypeError: print_str() missing 1 required positional argument: 'str'

关键字参数函数调用使用关键字参数来确定传入的参数值。关键字参数允许函数调用时参数的顺序与声明的不一致，因为python解释器能够用参数名称匹配参数值。以下实例在函数muti_print_str调用时使用参数名：

def muti_print_str(str, n):

"重复打印字符串n次"

print(str * n)

muti_print_str(str = "Hello\n",n = 3)

以上实例输出结果：

Hello

以下实例中演示了函数参数的使用不需要使用指定顺序：

def printinfo( name, age ):

"打印任何传入的字符串"

print ("名字: ", name)

print ("年龄: ", age)

return

#调用printinfo函数

printinfo( age=50, name="brainbot" )

以上实例输出结果：

名字: brainbot

年龄: 50

默认参数调用函数时，如果没有传递参数，则会使用默认参数。以下实例中如果没有传入 age 参数，则使用默认值，默认值需要在函数声明中提前设置：

def printinfo( name, age=15 ):

"打印任何传入的字符串"

print ("名字: ", name)

print ("年龄: ", age)

return

#调用printinfo函数

printinfo( name="brainbot" )

printinfo( name="brainbot", age=20 )

以上实例输出结果：

名字: brainbot

年龄: 15

名字: brainbot

年龄: 20

不定长参数：你可能需要一个函数能处理比当初声明时更多的参数，这些参数叫做不定长参数，本质是使用元组或字典来存放未命名的参数，基本语法如下：加了一个星号*的参数（argment）会以元组（tuple）的形式导入，加了两个星号*的参数会以字典的形式导入（ dictionary）

def fuctionname([formal_args,] *var_args_tuple):

"不定长参数-元组语法"

fuction_suite

return [expression]

以下是一个元组参数实例：

def printinfo(*vartuple):

"打印所有传入的参数"

print ("传入的参数: ", vartuple)

return

#调用printinfo函数

printinfo("Emma", "John", "Michael")

printinfo(1, 2, 3, 4, 5,"Emma", "John", "Michael")

输出结果：

('Emma', 'John', 'Michael')

(1, 2, 3, 4, 5, 'Emma', 'John', 'Michael')

如果在函数调用时没有指定参数，它就是一个空元组。我们也可以不向函数传递未命名的变量。如下实例：

def printinfo(arg1,*vartuple):

"打印所有传入的参数"

print ("定长参数:",arg1)

print ("可变参数:")

for var in vartuple:

print (var)

return

#调用printinfo函数

printinfo(1)

printinfo(70, 60, 50)

输出为：

定长参数: 1

可变参数:

定长参数: 70

可变参数:

参数带两个星号**基本语法如下：

def functionname([formal_args,] **var_args_dict ):

"不定长参数-字典语法"

function_suite

return [expression]

加了两个星号 ** 的参数会以字典的形式导入,在调用函数时要使用=(赋值符号)分割键和值，如下实例：

def printinfo(**vardict):

"以字典的形式打印传入的参数"

print ("输出: ")

print (vardict)

return

printinfo(name="John", age=30, city="New York")片

输出：

输出:

{'name': 'John', 'age': 30, 'city': 'New York'}

声明函数时，参数中星号*可以单独出现，例如:

def f(a,b,*,c):

return a+b+c

如果单独出现星号 *，则星号*后的参数必须用关键字传入

>>> def f(a,b,*,c):

... return a+b+c

...

>>> f(1,2,3) # 报错

Traceback (most recent call last):

File "", line 1, in

TypeError: f() takes 2 positional arguments but 3 were given

>>> f(1,2,c=3) # 正常

>>>

强制位置参数： Python3.8 新增了一个函数形参语法 / 用来指明函数形参必须使用指定位置参数，不能使用关键字参数的形式。注意：/必须要出现在*之前

在以下的例子中，形参 a 和 b 必须使用指定位置参数，c 或 d 可以是位置形参或关键字形参，而 e 和 f 要求为关键字形参:

def f(a, b, /, c, d, *, e, f):

print(a, b, c, d, e, f)

3.return语句

return [表达式] 语句用于退出函数，并选择性地向调用方返回一个表达式。不带参数值的 return 语句返回 None。以下实例演示了return语句的用法：

def sum( arg1, arg2 ):

# 返回2个参数的和."

total = arg1 + arg2

print ("函数内 : ", total)

return total

# 调用sum函数

total = sum( 10, 20 )

print ("函数外 : ", total)

以上实例输出结果：

函数内 : 30

函数外 : 30

总结

以上就是python函数的一些基本知识点。函数的本质包含在WWH(what，why，how)中，其余的用法其实都是基本概念的延申，以及与其他独立模块的组合。