一、函数的形成

　　需求1：来测试一下‘hello word’ 的长度

# 在没有函数的时候，我们可以用for循环实现
s1 = "hello world"
length = 0
for i in s1:length = length+1
print(length)

　　再增加一个需求2：再来测试一下另外一个字符串的长度：‘hello china’

　　然后需求1和需求2的代码就变成下边这样

s1 = "hello world"
length = 0
for i in s1:length = length+1
print(length)s2 = "hello china"
length = 0
for i in s2:length = length+1
print(length)

上边的代码确实可以实现需求，但是有缺点：代码重复，可读性差。我们将上面的代码称之为面向过程的方式

为了解决这种问题就出现了函数

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

二、函数的格式和调用

def mylen():  # 定义一个函数mylen'''计算s1的长度'''s1 = "hello world"length = 0for i in s1:length = length+1print(length)
mylen()  # 函数调用

def 关键词开头，空格之后接函数名称和圆括号()，最后还有一个":"。def 是固定的，不能变，他就是定义函数的关键字。空格 为了将def关键字和函数名分开，必须空(四声)函数名：函数名只能包含字符串、下划线和数字且不能以数字开头。虽然函数名可以随便起，但我们给函数起名字还是要尽量简短，并能表达函数功能括号：是必须加的注释：每一个函数都应该对功能和参数进行相应的说明，应该写在函数下面第一行。以增强代码的可读性。调用：就是 函数名()

二、函数的返回值

1、什么是函数的返回值

在使用内置函数len()方法时，得到的结果会赋值给一个变量，然后得到结果：

str_len = len('hello,world')
print(str_len)

但是自己写的这个函数mylen()，并不会得到这样的结果，如何让他和len函数一样，有返回值呢？

那就是在函数的最后加上一个return，return 后面写你需要的返回值就可以了。

#函数定义
def mylen():"""计算s1的长度"""s1 = "hello world"length = 0for i in s1:length = length+1return length#函数调用
str_len = mylen()
print('str_len : %s'%str_len)return返回值

2、return关键字的作用

　　1、函数中遇到return终止函数。
　　2、返回值返回给了函数的调用者

3、return返回值的的三种情况

第一种：没有return 返回None

def mylen():s1 = "hello world"length = 0for i in s1:length = length+1
str_len = mylen()
print(str_len)  # 因为没有返回值，此时的str_len为None

第二种：return后没有返回值

　　　　return的其他用法，就是一旦遇到return，结束整个函数。

def ret_demo():print(111)  # 此行代码执行return  # 直接种植代码print(222)  # 此行不会输出
ret = ret_demo()
print(ret)  # 因为return后没有任何值， 所以此处结果为None

第三种：单个值返回单个值

#函数定义
def mylen():"""计算s1的长度"""s1 = "hello world"length = 0for i in s1:length = length+1return length#函数调用
str_len = mylen()
print(str_len)  # 返回这个字符串的长度，结果为11

第四种：多个值返回一个由这多个值组成的元组

　　　　可以返回任意多个、任意数据类型的值

def ret_demo1():'''返回多个值'''return 1, 2, 3, 4def ret_demo2():'''返回多个任意类型的值'''return 1, ['a', 'b'], 3, 4print(ret_demo1())  # 结果为(1, 2, 3, 4)
print(ret_demo2())  # 结果为(1, ['a', 'b'], 3, 4)

def ret_demo2():return 1, ['a', 'b'], 3, 4#返回多个值，用一个变量接收
ret2 = ret_demo2()
print(ret2)  # (1, ['a', 'b'], 3, 4)#返回多个值，用多个变量接收
a, b, c, d = ret_demo2()
print(a, b, c, d)  # 1 ['a', 'b'] 3 4#用多个值接收返回值：返回几个值，就用几个变量接收
a, b, c, d = ret_demo2()
print(a, b, c, d)  # 1 ['a', 'b'] 3 4

四、函数的参数

　　1.什么是参数　　

　　之前我们使用len函数的时候得是length = len("hello world")，但是这个函数，只能计算一个“hello world”的长度，换一个字符串就需要写多个函数，很不方便

def mylen(s1):  # 定一个一个参数s1"""计算s1的长度"""length = 0for i in s1:length = length+1return lengthstr_len = mylen("hello world")  # 将hello world传递给s1
print(str_len)

我们告诉mylen函数要计算的字符串是谁，这个过程就叫做 传递参数，简称传参，我们调用函数时传递的这个“hello world”和定义函数时的s1就是参数。

　　2.认识实参和形参　　

我们调用函数时传递的这个“hello world”被称为实际参数，因为这个是实际的要交给函数的内容，简称实参。

定义函数时的s1，只是一个变量的名字，被称为形式参数，因为在定义函数的时候它只是一个形式，表示这里有一个参数，简称形参。　

　　3.参数的传递　　

第一种：可以传递字符串，前边已经举例

第二种：可以传递列表

l1 = [1, 2, 34, 55, 66]
def my_len(s):  # 形參s接收到实参l1的值c = 0for i in s:c += 1return cret = my_len(l1)  # 将字符串l1传递给函数
print(ret)

　　4.按照实参角度传參　　

第一种：位置参数：从前至后一一对应

def mymax(x, y):  # x接收10，y接收20the_max = x if x > y else yreturn the_maxma = mymax(10, 20)
print(ma)

第二种：关键字传參：不用按照顺序，按变量名一一对应

def mymax(x, y):  # 此时x = 20,y = 10the_max = x if x > y else yreturn the_maxma = mymax(y = 10, x = 20)
print(ma)

第三种：混合传參：位置参数一定在前面

def mymax(x, y):  # 此时x = 10,y = 20the_max = x if x > y else yreturn the_maxma = mymax(10, y = 20)  # 位置参数一定要在关键字参数前面
print(ma)

小总结：位置参数必须在关键字参数的前面

　　　　对于一个形参只能赋值一次

　　5.按照形參角度传參　　

第一种：位置传参: 按照顺序，一一对应，未给形參传值会报错

def func1(a, b, c, d):print(a, b, c)
func1(1, 2, 3)  # 结果会报错， 没有给位置参数d传值

第二种：默认传参: 如果不传，则默认使用默认参数，传参则覆盖。

　　　　为什么要有默认参数：将变化比较小的值设置成默认参数

def func2(name, age, sex='男'):  # sex接收传来的参数'女'print(name, age, sex)func2('大锤', 18, sex='女')  # 结果：大锤 18 女

利用默认传參可以设置默认输入

def wfile(name, age, sex='男'):  # 定义函数wfile，形參name、age,默认参数sex"""建立登记表函数，由于班中大部分学生都是男生，所以设置默认参数sex的默认值为'男'"""
    with open('登记表', encoding='utf-8', mode='a') as f1:f1.write('{}|{}|{}\n'.format(name, age, sex))  # 格式化输入三个参数while 1:  # 可以循环输入name = input('姓名(输入Q/q退出)：')if name.upper() == 'Q':break  # 如果输入Q/q退出程序age = input('年龄：')if name.startswith('王'):  # 设置一个规则，如果姓名以'王'开头wfile(name, age)  # 函数只执行 name和age。sex无需执行，直接记录默认值'男'else:  # 否则(即：如果姓名不是以'王'开头) 就需要输入sex,并且执行name, age, sexsex = input('性别：')wfile(name, age, sex)  # 这一步会把输入的sex覆盖默认值的值

默认参数是一个可变的数据类型

def func(a, l=[]):  # 定义形參a,实参l=[]l.append(a)  # 将a的值添加至列表l中print(l)func('aaa')  # ['aaa'],
func('bbb')  # ['aaa', 'bbb']
func('ccc')  # ['aaa', 'bbb', 'ccc']

　　6.万能参数　　

　　万能参数也叫动态参数：*args **kwargs 也叫不定长传参

　　需要传给函数的参数很多，不定个数，那这种情况下，你就用*args，**kwargs接收

l1 = [1, 2, 3]
l2 = [11, 22, 33]
l3 = (55, 66, 77)
dic = {'name': 'alex'}
dic1 = {'age': '12'}def func4(*args, **kwargs):print(args)print(kwargs)func4(*l1, *l2, *l3, **dic, **dic1)  # (1, 2, 3, 11, 22, 33, 55, 66, 77)  {'name': 'alex', 'age': '12'}
func4(l1, l2, l3, dic, dic1)  # ([1, 2, 3], [11, 22, 33], (55, 66, 77), {'name': 'alex'}, {'age': '12'})  {}

注意1：args是元祖形式，接收除去键值对以外的所有参数，kwargs接收的只是键值对的参数，并保存在字典中。

如果未接收到传来的参数，那么就会输出空值

def func4(*args, **kwargs):print(args)  # ([1, 2, 3], [11, 22, 33], (55, 66, 77))print(kwargs)  # {},**kwargs未接收到键值对的参数，所有输出的结果是一个空的字典func4([1, 2, 3], [11, 22, 33], (55, 66, 77))

　　7.位置参数、默认参数、万能参数混合使用　　

# 默认参数未被更改
def func5(a, b, *args, sex='男'):print(a)  # 1 位置参数a接收第一个参数1print(b)  # 2 位置参数b接收第二个参数2print(sex)  # 男 默认参数未被更改，还是默认的值print(args)  # (4, 5, 6, 7, 8, 9) 剩下的全部使用*args接收func5(1, 2, 4, 5, 6, 7, 8, 9)# 默认参数已被更改
def func5(a, b, *args, sex='男', **kwargs):print(a)  # 1 位置参数a接收第一个参数1print(b)  # 2 位置参数b接收第二个参数2print(sex)  # 女 默认参数已被更改，所以输出新值print(args)  # (4, 5, 6, 7, 8, 9) 剩下的全部使用*args接收func5(1, 2, 4, 5, 6, 7, 8, 9, sex='女')

五、名称空间

　　先认识一下什么叫名称空间　　

def func1():m = 1print(m)
func1()print(m)  # 报错 NameError: name 'm' is not defined

上面为什么会报错呢？

　　函数被调用的时候，python解释器会再开辟一块内存来储存这个函数里面的内容，函数中的变量会储存在新开辟出来的内存中，函数中的变量只能在函数内部使用

　　当函数执行完毕，这块内存中的所有内容也会被清空。

存放名字与值的关系的空间起了一个名字-------名称空间。

python中的名称空间：　　

　　全局名称空间：代码在运行开始，创建的存储“变量名与值的关系”的空间
　　临时（局部）名称空间：在函数的运行中开辟的临时的空间
　　内置名称空间: len print 等内置函数等等。

加载顺序：内置名称空间 ---> 全局名称空间 ---> 函数执行时：临时（局部）名称空间

取值顺序: 函数执行时：临时（局部）名称空间 ---> 全局名称空间 ----> 内置名称空间
　　　　　（取值顺序满足就近原则）

六、函数的作用域和嵌套

　　1、什么是作用域　　

　　作用域： 作用域就是作用范围

　　全局作用域：包含内置名称空间、全局名称空间，在整个文件的任意位置都能被引用、全局有效

　　局部作用域：局部名称空间，只能在局部范围内生效

a = 1
print(a)  # 1
def func1():a = 99print(a)  # 99 满足就近原则，取最近的值
func1()

　　2、作用域中会遇到的坑　　

　　局部只能引用全局的变量但是不能修改，修改就会报错

a = 1
print(a)  # 1
def func1():a += 1print(a)  # 会报错，不能引用全部变量a
func1()

　　global
　　　　可以修改全局变量
　　　　在局部空间可以声明一个全局变量

　　　　可变数据类型（list，dict，set）可以直接引用不用通过global。

# 修改全局变量a = 1
print(a)  # 1
def func1():global a  # 引用全局变量a,此时a的值为1a += 1print(a)  # 2
func1()

# 声明全局变量def func():                                            global a  # 没有全局变量的时候也可以使用，在函数内部直接声明了全局变量          a = 1
func()
print(a)  # 1

# 引用可变的数据类型，无需globalli = [1, 2, 3]
dic = {'a': 'b'}                                 def change():                                    li.append('a')  # 无需global，可以直接引用            dic['q'] = 'g'  # # 无需global，可以直接引用          print(dic)  # {'a': 'b', 'q': 'g'}           print(li)  # [1, 2, 3, 'a']
change()
print(li)  # [1, 2, 3, 'a']
print(dic)   # {'a': 'b', 'q': 'g'}

　　nonlocal　　

　　　不能操作全局变量

　　　　在局部作用域中，对父级作用域（或者更外层作用域非全局作用域）的变量进行引用和修改，且引用的哪层，从那层及以下此变量全部发生改变。

　　　　子名称空间只能引用父名称空间的变量，但是不能修改，如果修改就会报错

#只引用未修改
def func1():  # 父名称空间a = 1def inner():  # 子名称空间print(a)  # 结果：1  函数执行的第二步输出print(a)  # 结果：1 函数执行的第一步输出
    inner()print(a)  # 结果：1 函数执行的第三步输出
func1()# 未使用nonlocal,引用并且修改,会报错
def func1():  # 父名称空间a = 1def inner():  # 子名称空间a += 1  # 修改变量aprint(a)  # 会报错：local variable 'a' referenced before assignment
    inner()print(a)
func1()# 使用nonlocal后既可引用，也可修改
def func1():  # 父名称空间a = 1def inner():  # 子名称空间nonlocal a  # 引用父名称空间的变量aa += 1  # 修改变量a，这层及以下此变量全部发生改变print(a)  # 结果：2  函数执行的第二步输出print(a)  # 结果：1 函数执行的第一步输出
    inner()print(a)  # 结果：2 函数执行的第三步输出
func1()# 不能修改全局变量
b = 3
def func1():  # 父名称空间a = 1def inner():  # 子名称空间nonlocal a  # 引用父名称空间的变量aa += 1  # 修改变量a，这层及以下此变量全部发生改变b += 1  # 会报错，不能修改全局变量：local variable 'a' referenced before assignmentprint(a)  # 结果：2  函数执行的第二步输出print(a)  # 结果：1 函数执行的第一步输出
    inner()print(a)  # 结果：2 函数执行的第三步输出
func1()

　　3.函数的嵌套　　

# 第一种函数嵌套
def func1():  # 第二步执行func1print(111) # 第三步，输出111def func2():  # 第六步执行func2print(222)  # 第七步 输出222print(333)  # 第四步，读到这一行,输出333
    func2()  # 第五步执行func2print(444)  # 第八步，输出444

func1()  # 函数执行时先读这一行# 第二种函数嵌套
def func1():  # 第七步 执行func1print(111)  # 第八步 输出111def func2():  # 第四步 执行func2print(222)  # 第五步 输出222func1()  # 第六步 读到这一行def func3():  # 第二步 执行func3func2()  # 第三步，读到这一行print(333)  # 第九步，输出333，因为其余内嵌的函数已经全部执行完了

func3()  # 函数执行时先读到这一行

　　4.函数的作用域　　

　　小范围作用域可以使用大范围的变量，但是反之不行，他是单向的。

# 大范围的作用域不能使用小范围的变量
# 第一种  大作用域f1中未定义变量，试着使用小作用域f2中的a的值，会报错
def f1():def f2():a = 2print(a)f2()print(a)  # 第二步，f1中未定义变量a,无法取f2中的值，所以会报错 name 'a' is not defined

f1()# 修改上边的报错：在大作用域f1中定义a
def f1():a = 1def f2():a = 2print(a)  # 先输出a的值为2
    f2()print(a)  # 再输出a的值为1,此a是f1中的a,与f2中的a无关，只是名字相同

f1()# 第二种  小范围的作用域能使用大范围的变量
def f1():a = 1def f2():print(a)  # 取的是f1中的a的值1
    f2()
f1()

七、函数名的运用

　　1、直接输出函数名（输出函数的内存地址）　　

def func1():print(111)print(func1)  # 输出函数func1的内存地址 <function func1 at 0x10fdf31e0>
f1 = func1  # 将func1的函数名传给f1
f2 = f1  # 将f1的值赋值给f2
print(f2)  # 输出f2，既输出f1，即输出func1的内存地址，<function func1 at 0x10fdf31e0>
f2()  # ，执行f2，即执行f1，即执行func1，结果为 111

　　2、函数名可以作为函数的参数　　

def func1():  # 第五步 执行此函数print(111)  # 第六步 输出111def func2(x):  # 第二步 x接收传来的值func1print(x)  # 第三步 输出func1的内存地址x()  # 第四步 执行x函数，即执行func1
func2(func1)  # 第一步，代码读到这一行，将func1传给x

　　3、函数名可以作为函数的返回值　　

# 当作函数的返回值
# 第一种
def f1():  # 第四步 执行f1函数print(111)  # 第五步 输出111def func1(argv):  # 第二步 argv 接收到函数名f1argv()  # 第三步 执行argv()，即执行f1()，第五步执行完的结果为111return argv  # 第六步 将argv的函数名返回给func1

f = func1(f1)  # 第一步 将函数名f1传给argv，第六步执行完，func1(f1) = argv
f()  # 第七步 f()本质上就是argv(),执行argv()# 从第三步得知，执行argv()即执行f1，最后输出结果为111# 第二种
def func1():  # 第五步，执行func1print(111)  # 第六步 输出111def func2(x):  # 第二步 执行func2，x接收到函数名func1， x = func1return x  # 第三步 将x返回给函数的调用者func2,即将函数名func1返回给函数func2

ret = func2(func1)  # 第一步 执行等号后的func2(func1),将函数名func1传给x# 并将函数func2的值传给ret# 第三步执行完，此时func2(func1)的值为func1，这个等式可以写成ret = func1
ret()  #  第四步 执行ret(),其实就是执行func1()

　　4、函数名可以作为容器类数据类型的参数　　

# 函数名作为列表中的元素
# 第一种  直接调用
def func1():  # 第三步 执行此函数print(111)  # 第四步 输出111def func2():print(222)def func3():print(333)li = [func1, func2, func3]  # 第一步，先读到这行，函数名作为列表的元素
li[0]()  # 第二步  li的0号元素是func1,li[0]()本质上就是func1()# 第二种  循环调用
def func1():print(111)def func2():print(222)def func3():print(333)li = [func1, func2, func3]  # 第一步，先读到这行，函数名作为列表的元素for i in li:  # 循环执行三个函数
    i()# 函数名作为字典中键的值
# 第一种 直接调用
def f1():print('111')def f2():  # 第三步，代码读到这行，执行此函数print('222')  # 第四步输出222def f3():print('333')dic = {'x': f1, 'y': f2, 'z': f3}  # 第一步 读到这行，函数作为了字典中键的值
dic['y']()  # 第二步  dic中'y'键的值是f2，dic['y']()本质上就是f2()# 第二种循环输出
def func1():print(111)def func2():print(222)def func3():print(333)def func4():print(444)dic = {         # 第一步先读到这行1: func1,   # 输入哪个数字，就执行哪个数字对应的函数2: func2,3: func3,4: func4,
}
while 1:  # 第二步 读到这行choice = int(input('请输入数字：'))  # 第三步将输入的数字转化成int类型dic[choice]()  # 第四步 dic[choice]()本质上就是执行输入的数字对应的 键的值 对应的函数

八、闭包

　　1、什么是闭包　　

　　1、闭包是嵌套在函数中的
　　2、闭包是内层函数对外层函数的变量(非全局变量)的引用（改变）
　　3、闭包需要将其作为一个对象返回，而且必须逐层返回直至最外层函数的返回值

　　2、闭包的格式　　

# 闭包的基本格式
def func():name = '大锤'def inner():print(name)  # 引用外部函数func的变量namereturn innerf = func()
f()# 闭包举例
# 第一个 这步是闭包
def func1():'''此函数满足前闭包定义的前两个条件，但还不是闭包因为没有返回值return'''name = '太白'def func2():print(name)# 第二个 这也不是闭包
ame = 'alex'
def wrapper():def inner():print(name)  # 调用的是全部变量，非外层函数变量return inner# 第三个 这是闭包
def wrapper():name = '太白'def inner():print(name)return inner# 第四个 这个也是闭包
def wrapper(name):def inner():print(name)return inner
n1 = 'wusir'
wrapper(n1)

　　3、怎么样判断是不是闭包　　

# 输出的__closure__有cell元素 ：是闭包函数
def func():name = '大锤'def inner():print(name)print(inner.__closure__)return innerf = func()
f()# 输出的__closure__为None ：不是闭包函数
name = '大锤'
def func2():def inner():print(name)print(inner.__closure__)return innerf2 = func2()
f2()

　　4、闭包的作用　　

# 非闭包函数 随着函数的结束临时空间关闭
def func1(s1):n = 1n += s1print(n)func1(5)  # 6
func1(5)  # 6
func1(5)  # 6# 闭包函数
def wrapper(s1):n = 1def inner():nonlocal nn += s1print(n)return innerret = wrapper(5)
ret()  # 6
ret()  # 11
ret()  # 16

小总结：

　　闭包的机制：python遇到闭包，产生一个空间，这个空间不会随着函数的结束而消失。

　　5、闭包的嵌套　　

def wrapper():  # 第二步 执行此韩式money = 100  # 第三步def func():  # 第四步执行此函数name = '大锤'def inner():print(name, money)return innerreturn func  # 第五步 将函数名func返回给上层函数wrapper

f = wrapper()  # 第一步 代码读到这，第五步执行完，f=func
i = f()  # 第六步 执行f()，即执行func()，执行完func()后将函数名func再次传给i，此时i=func
i()  # 第七步 i()即func()，执行func,输出结果： 大锤 100

转载于:https://www.cnblogs.com/caoyinshan/p/10086580.html

python （六）函数相关推荐

python函数模块关键代码_从零开始学Python(六):函数,模块和类的使用
从这章开始,我们不在使用sublime文本编译器进行编码了,主要是我们每次运行的使用还得去命令行执行pyhon ***.py命令查看结果,操作比较麻烦.推荐大家使用Pycharm(具体安装使用教程大家 ...
python编程入门教程第6讲_Python开发的入门教程(六)-函数
介绍本文主要介绍Python中函数的基本知识和使用 Python之什么是函数我们知道圆的面积计算公式为: S = πr² 当我们知道半径r的值时,就可以根据公式计算出面积.假设我们需要计算3个不同 ...
第三章：Python基础の函数和文件操作实战
本課主題 Set 集合和操作实战函数介紹和操作实战参数的深入介绍和操作实战 format 函数操作实战 lambda 表达式介绍文件操作函数介紹和操作实战本周作业 Set 集合和操作实战 Se ...
Python自定义函数的创建、调用和函数的参数详解
这篇文章主要介绍了Python自定义函数的创建.调用和函数的参数.变量作用域等常见问题,需要的朋友可以参考下函数是组织好的,可重复使用的,用来实现单一,或相关联功能的代码段. 函数能提高应用的模块性 ...
python进行linux编程,Python之函数进阶
本节内容递归函数嵌套函数与闭包匿名函数高阶函数内置函数总结一.递归函数函数是可以被调用的,且一个函数内部可以调用其他函数.如果一个函数在内部调用本身,这个函数就是一个递归函数.函数递归 ...
python函数定义错误_[转载]python之函数的使用及异常处理2021.1.30
2.1 定义函数 def 函数名(参数): 代码1 代码2 ...... 2.2 调⽤函数函数名(参数) 注意: 1. 不同的需求,参数可有可⽆. 2. 在Python中,函数必须先定义后使⽤. 2 ...
python入门之函数调用-python之函数入门
python之函数入门一. 什么是函数二. 函数定义, 函数名, 函数体以及函数的调用三. 函数的返回值四. 函数的参数五.函数名->第一类对象六.闭包一,什么是函数函数: 对代 ...
Python map 函数 - Python零基础入门教程
目录一.前言二.Python map 函数语法简介三.Python map 函数实战 1.使用 map 函数 2.map 函数配合 lambda 匿名函数一起使用四.Python map 函数 ...
Python Chainmap函数 - Python零基础入门教程
目录一.前言二.Python ChainMap 合并多个字典三.Python ChainMap 查询和遍历四.Python ChainMap 修改五.Python ChainMap 增加六 ...
Python map 函数 -Python零基础入门教程
目录一.前言二.Python map 函数语法简介三.Python map 函数实战 1.使用 map 函数 2.map 函数配合 lambda 匿名函数一起使用四.Python map 函数 ...

python （六）函数

一、函数的形成

二、函数的格式和调用

二、函数的返回值

1、什么是函数的返回值

2、return关键字的作用

3、return返回值的的三种情况

四、函数的参数

1.什么是参数

2.认识实参和形参

3.参数的传递

4.按照实参角度传參

5.按照形參角度传參

6.万能参数

7.位置参数、默认参数、万能参数混合使用

五、名称空间

先认识一下什么叫名称空间

六、函数的作用域和嵌套

1、什么是作用域

2、作用域中会遇到的坑

3.函数的嵌套

4.函数的作用域

七、函数名的运用

1、直接输出函数名（输出函数的内存地址）

2、函数名可以作为函数的参数

3、函数名可以作为函数的返回值

4、函数名可以作为容器类数据类型的参数

八、闭包

1、什么是闭包

2、闭包的格式

3、怎么样判断是不是闭包

4、闭包的作用

5、闭包的嵌套

python （六）函数相关推荐

最新文章

热门文章

python （六）函数

一、函数的形成

二、函数的格式和调用

二、函数的返回值

1、什么是函数的返回值

2、return关键字的作用

3、return返回值的的三种情况

四、函数的参数

1.什么是参数

2.认识实参和形参

3.参数的传递

4.按照实参角度传參

5.按照形參角度传參

6.万能参数

7.位置参数、默认参数、万能参数混合使用

五、名称空间

先认识一下什么叫名称空间

六、函数的作用域和嵌套

1、什么是作用域

2、作用域中会遇到的坑

3.函数的嵌套

4.函数的作用域

七、函数名的运用

1、直接输出函数名（输出函数的内存地址）

2、函数名可以作为函数的参数

3、函数名可以作为函数的返回值

4、函数名可以作为容器类数据类型的参数

八、闭包

1、什么是闭包

2、闭包的格式

3、 怎么样判断是不是闭包

4、闭包的作用

5、闭包的嵌套

python （六）函数相关推荐

最新文章

热门文章

　　1.什么是参数　　

　　2.认识实参和形参　　

　　3.参数的传递　　

　　4.按照实参角度传參　　

　　5.按照形參角度传參　　

　　6.万能参数　　

　　7.位置参数、默认参数、万能参数混合使用　　

　　先认识一下什么叫名称空间　　

　　1、什么是作用域　　

　　2、作用域中会遇到的坑　　

　　3.函数的嵌套　　

　　4.函数的作用域　　

　　1、直接输出函数名（输出函数的内存地址）　　

　　2、函数名可以作为函数的参数　　

　　3、函数名可以作为函数的返回值　　

　　4、函数名可以作为容器类数据类型的参数　　

　　1、什么是闭包　　

　　2、闭包的格式　　

　　3、怎么样判断是不是闭包　　

　　4、闭包的作用　　

　　5、闭包的嵌套　　