新手学习：Python函数和函数参数

函数和函数参数

问题一：什么是函数？函数有什么作用？

#函数

函数使用时时：函数名（参数）

print（‘xxx’）

input（“xxx”）

#关键字

关键字使用：关键字名 python表达式

del li[0]

if 条件语句

#方法：

方法的使用：对象.方法名（参数）

li = [11,22,33]

li.append()

问题二：已经学过了哪些内置函数？分别有什么作用？

print：输出

input：输入

type：查看数据类型

id：获取数据内存地址

range：生成数据

len：获取数据的长度（元素总数）

int、float、bool、str、list、tuple、dict、set：代表对应的数据类型

问题三：自己如何去定义函数？

一、 函数定义和调用

1、函数的定义

定义函数关键字：def

为什么要写函数：方便好用、复用性高

语法：

def 函数名（）：

#函数内部代码

2、函数的调用：函数名（）

二、函数的返回值：return

return的作用

返回值数目=0：返回None

返回值数目=1：返回object

返回值数目>1：返回tuple

疑问：为啥要用return？什么时候用return

根据需求，当需要返回的时候就返回，不需要返回的时候就不用返回。

注意点：

1、 return是用来给函数返回结果的。

2、 当函数执行到return是函数执行结束。

3、 函数没有定义return，默认的返回值为None

三、函数参数

1、参数的定义：函数名后面的括号中定义参数

2、参数的传递：

参数传递的两种形式：

位置参数：位置参数（按位置进行传递）

关键字参数：通过关键字指定传给某个参数

注意：关键字参数写在位置参数之后

定义的参数称为：形参

调用实际的传递称为：实参

这样就实现了我们刚刚所说的通用性，

刚刚老师说到了形参，实参；那什么是实参，什么是形参呢

1、 定义时小括号中的参数，用来接收参数用的，称为“形参”

2、 调用时小括号中的参数，用来传递给函数用的，称为“实参”

画图演示：型参 实参的传入过程

一、必备参数

那如果我要定义三个数相加的函数呢，怎么定义呢，是不是就要用到三个形参

def addition_2(a,b,c):

d = a + b + c

print(d)

那么调用函数的时候我们要输入几个参数呢？我们先来试一下两个参数看行不行？

addition_1(11,22)

#运行结果：报错

为什么会报错呢，因为我们在定义函数的时候声明了需要三个参数，调用时的数量必须和声明时的一样，而且传入的位置和定义的位置顺序是一致的，这种叫做必备参数

addition_1(11,22,33)

参数在传入的时候还可以指定名称，指定名称的参数可以不按顺序写；

addition_1(b = 11,c = 22,a = 33)

指定名称的参数我们叫做命名参数

二、默认参数（缺省参数）

当然有必备参数，那么函数中还有一种不是必须要传入的参数，叫做缺省参数，也可以称为默认参数，默认参数是什么样的一个形式呢，大家跟着我来看一下：

def student_info(name,age,course = python):

print(“名字：”,name)

print(“年龄：”,age)

print(“学科：”,course)

调用函数时，默认参数（缺省参数）的值如果没有传入，则被认为是默认值

student_info(“小王”,18)

#运行结果

名字：小王

年龄：18

学科：python

调用函数时，如果传入了参数，则使用传入的参数

student_info(“小王”,18,”java”)

#运行结果

名字：小王

年龄：18

学科：java

注意：带有默认值的参数一定要位于参数列表的最后面

def student_info(name,course = python,age):

print(“名字：”,name)

print(“年龄：”,age)

print(“学科：”,course)

student_info(“小王”,”java”,18)

报错

默认参数：在定义的时候可以设置默认值，调用的时候可以传，也可以不传

三、不定长参数

接下来给大家介绍不定长参数，有时可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，声明时不会命名。

def func_argument(a,b,*args):

“””不定长参数演示”””

print(a)

print(b)

print(args)

func_argument(11,22,33,44,55)

#运行结果：

11

22

(33,44,55)

大家刚刚看到我在变量中写了个*号，那么这个*有什么有什么功能呢

我们来运行一下刚刚写好的代码，打印出来的结果，这里怎么多了个元组呢，我们打印的args出来的结果是一个元组，有点意思，元组里面的元素就是我们刚刚多传进去的几个参数，这就是我们所说的不定长参数。

大家注意注意听，重点来了，在我们定义函数的时候，给某个参数加上一个*，那么这个参数叫做不定长参数，它可以接收所有未被其他参数接收的所有未命名参数，并且以一个元组的形式保存。

那么关于不定长参数，还有一个加两个**的，

def func_argument(a,b,*args,**kwargs):

“””不定长参数演示”””

print(a)

print(b)

print(args)

print(kwargs)

func_argument(11,22,33,44,55)

#运行结果：

11

22

(33,44,55)

{}

好像加了个带两个**的kwargs并没有什么反应，结果还是没有变化，我们命名是多传了几个参数进去，而kwargs一个都没有接收到。这是为什么呢。

我们再传入几个命名参数到这个函数里看一下

def func_argument2(a,b,*args,**kwargs):

“””不定长参数演示”””

print(a)

print(b)

print(args)

print(kwargs)

func_argument(11,22,33,44,55,c = 888,d = 666)

#运行结果：

11

22

(33,44,55)

{“c”:888,”d”:666}

有没有发现这个运行结果里面多了点什么，是不是我们刚刚传进去的几个命名参数以字典的形式保存到了kwargs里面了，现在发现了我们这个带两个**号参数的作用了。

带**的不定长参数是用来接收所有未被接收的命名参数，并且以字典的的形式，即key=value键值对保存在里面，既然kwargs是一个字典，那么我们也可以通过for循环把kwargs里面的键值遍历出来

def func_argument2(a,b,*args,**kwargs):

“””不定长参数演示”””

print(a)

print(b)

print(args)

print(kwargs)

for key value in kwargs：

print(key,”=”,value)

func_argument2(11,22,33,44,55,c = 888,d = 666)

#运行结果：

11

22

(33,44,55)

{“c”:888,”d”:666}

c = 888

d = 666

这是个最复杂的传参函数

四、拆包

接下里教给大家一个新的知识点叫做拆包

既然我们函数中可以传入多个参数，那么我们在传入参数的时候可不可以传入列表和字典来当做参数呢？

func_argument(11,22,33,44,55,[1,2,3,4])

#运行结果

11

22

(33,44,55,[1,2,3,4])

{}

有没有发现我们传入的列表参数，以一个字符串的形式被args接收了，我们如果想把列表中的元素一个一个传进去，那应该怎么做呢，想一想有没有什么办法，刚刚我们在接收的形参前面加个*，就成了一个不定长参数，可以用来接收我们的未命名参数，那如果在传入的列表这个参数前加一个*号，会怎么样呢

func_argument(11,22,33,44,55,*[1,2,3,4])

#运行结果

11

22

(33,44,55,1,2,3,4)

{}

有没有发现结果不一样了，列表里的元素被一个一个的传了进去，是不是很神奇，这个就是我刚刚跟你们提到的新知识点，叫做拆包。

列表进行拆包，那么元组呢

func_argument(11,22,33,44,55,*(1,2,3,4))

#运行结果

11

22

(33,44,55,1,2,3,4)

{}

是不是同样也能行，既然一个*号可以用来对列表和元组进行拆包，那么字典可以进行拆包吗？还记得刚刚我们接收命名参数的不定长参数是什么形式的吗？是不是两个**号，那么同样对字典进行拆包我们也是要用两个**

func_argument(11,22,33,44,55,*(1,2,3,4),**{“a”:888,”b”:999})

#运行结果

11

22

(33,44,55,1,2,3,4)

{“a”:888,”b”:999}

那么现在我们来总结一下函数参数的几种类型：

必备参数：在函数调用的时候必须传入，且必须按顺序传递

命名参数：传入时可以不按顺序，命名参数要写在参数最后面，

缺省参数（默认参数）：在函数调用的时候可以传也可以不传，不传时使用默认值

不定长参数：在函数调用时，不定长参数可以传入任意长度参数，也可以不传，定义时元组形式可以放到参数最前面，也可以放到其他位置，字典形式只能放到最后面

1、 无参数，无返回值

def fun():

print(“你好”)

2、 有参数，无返回值

def func2(a):

print(“传进来的参数是%s”%a)

3、 无参数，有返回值

def func3():

c = 33

return c

4、 有参数，有返回值

def func4(a,b):

c = a + b

return c

四、函数的作用域

1、全局变量：

函数外部定义的变量，叫做全局变量，全局变量顾名思义就知道不管是函数内部还是函数外部都能够访问。

2、局部变量

局部变量，就是在函数内部定义的变量，仅限函数内部可以使用，在函数外部无法调用

注意点：

不同的函数，可以定义相同的名字的局部变量，但是各用各的不会产生影响

局部变量的作用，为了临时保存数据需要在函数中定义变量来进行存储这就是他的作用

3、global

问题：函数内部可不可以修改全局变量，要修改全局变量该怎么做？

注意点：

使用global关键字修饰的变量之前可以并不存在

在函数内部变量定义前，引用变量会提示错误，局部变量错误：在分配前引用的局部变量‘x’ UnboundLocalError: local variable ‘x’ referenced before assignment

五、内置函数

1、常见内置函数

学过的内置函数

print：输出

input：输入

type：查看数据类型

id：获取数据内存地址

range：生成数据

len：获取数据的长度（元素总数）

int、float、bool、str、list、tuple、dict、set：代表对应的数据类型

2、最大值 最小值的内置函数

min求最小值

max求最大值

sum求和

3、python中高级内置函数

3.1、enmerate

返回一个可以枚举对象，enmerate将其组成一个索引序列，利用它可以同时获得索引和值

3.2、eval：

取出字符串中的内容

将字符串str当成有效的表达式来求值并返回计算结果

#取出字符串中的值：

str = “[1,2,3,4]”

eval(str)

[1,2,3,4]

x = 7

eval(‘3 * x’)

#计算结果

21

3.3、filter过滤器

filter（参数1，参数2）

参数1：过滤规则的函数

参数2：要过滤的数据

应用案例：请过滤列表li = [1,2,3,4,5,6,7,8,9,10]中，大于5的数值

3.4、zip：聚合打包

应用案例：

#现有数据如下

users_title = [“name”,”age”,”gender”]

users_info = [‘小明’,18,’男’],[‘小李’,19,’男’],[‘小美’,17,’女’]

#要求：将上述数据转换为以下以下格式

users =[

{‘name’:’小明’,’age’:18,’gender’:’男’},

{‘name’:’小李’,’age’:19,’gender’:’男’},

{‘name’:’小美’,’age’:17,’gender’:’女’}

]

users = []

for user in users_info:

data = zip(users_title,user)

users.append(dict(data))

print(users)