函数思维导图模板_ProcessOn思维导图、流程图

函数的调用以及返回值

函数的结构

def 函数名():
函数体
def 关键字定义一个函数
函数名与变量名设置规则相同，要具有可描述性，多个单词组成一定是用下划线。
小括号：里面设置形参。
一个函数式一个功能。

函数的返回值

一个函数代表一个功能，执行完毕这个功能，总会得到一个结果。真假，最终的结算结果或者是None等等。

关键字return

函数中遇到return直接终止函数

def func():
print(111)
print(222)
print(333)
return
print(444)
print(555)

func()

函数可以给函数的执行者(函数名())返回值

只写return后面什么都不写或者不写return返回值都是None

def func():
a = 1
b = 2
# return
ret = func()
print(ret)

返回单个值。不会改变返回值的数据类型

def func(): a = 1 b = 2 # return a + b # return '太白' return [11, 22, 33] ret = func() print(ret)

返回多个值，一定是以元组的形式返回多个值

def func(): a = 1 b = 2 # return a + b # return '太白' # return [11, 22, 33] # return a+b,a-b,a*b return '天百','barry',[22, 33] ret = func() print(ret)

函数的调用

函数名()调用一个函数，只有执行到了函数名()才会执行此函数里面的代码。遇到一次，执行一次

def len_(argv):
count = 0
for i in argv:
count += 1
print(count)
len_(s1)
len_(s1)
len_(s1)
len_(s1)

作用域

全局作用域

内置名称空间与全局名称空间

局部作用域

临时命名空间

globals

获取的是全局作用域（截止到此行代码之前）的所有的变量与值的对应关系

name = 'barry'
a = 100
def func():
name = '太白'
b = 200
print(globals())
print(locals())
c = 666
"""
{'__name__': '__main__', '__doc__': '\n此py文件研究的是内置函数xxxxx\n', '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000022726EA5A48>, '__spec__': None, '__annotations__': {}, '__file__': 'E:/19级人工智能/19级人工智能 02班/1902code/day13/04 globals locals.py', '__cached__': None,
'__builtins__': <module 'builtins' (built-in)>,'name': 'barry', 'a': 100, 'func': <function func at 0x0000022728B15048>}
"""

locals

当前作用域内（截至到此行代码之前）变量与值的对应关系

name = 'barry' a = 100 def func(): name = '太白' b = 200 print(globals()) print(locals()) # 当前作用域内(截止到此行代码之前)变量与值的对应关系 func()

global、nonlocal

global

在局部声明一个全局变量

def func(): global name name = 'barry' # 测试1 print(globals()) print(name) func() # 测试2： func() print(globals()) print(name)

在局部可以更改一个全局变量

name = '太白' def func(): global name name = 'barry' print(name) func() print(name)

注意！！！局部修改全局变量有坑：可变的数据类型。
只要，局部空间修改了全局的变量的指向关系，就会报错，无论是不是可变的数据类型。

l1 = [11,22] def func(): # 这不叫修改变量，这叫修改列表里面的内容。 l1.append(666) func() print(l1)

l1 = [11,22] def func(): l1 += [5] func() l1 = [11, 22] print(id(l1)) print(id(l1+[5]))

nonlocal

不能操作全局变量

def func(): # 不能操作全局变量 nonlocal a a = 6566 func()

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

def func(): a = 1 def inner(): nonlocal a a = 666 print(a) inner() print(a) func()

格式化输出

语法

name = 'barry' age = 30 hobby = '工作，挣奶粉钱' s1 = F'我叫{name}，今年{age}，爱好{hobby}' s2 = f'我叫{name}，今年{age}，爱好{hobby}' print(s1,s2)

可以加入任意表达式

s1 = f'计算结果{2*23}' print(s1) name = 'barry' s2 = f'大写名字{name.upper()}' print(s2) dic = {'name': '达哥', 'age': 30,'hobby': '偷偷看'} s3 = f'姓名{dic["name"]},年龄{dic["age"]}，爱好{dic["hobby"]}' print(s3)

可执行函数

def sum_(a,b): return a+b s4 = f'最终结果{sum_(4,5)}' print(s4)

换行字符串

name = 'barry' age = 30 hobby = '工作，挣奶粉钱' home = '保定' s5 = f""" 我是{name}，今年{age}，老家{home} """ print(s5) name = 'barry' age = 18 ajd = 'handsome' speaker = f'Hi {name}.\n'\ f'You are {age} years old.\n'\ f'You are a {ajd} guy!' print(speaker)

注意点

! , : { } ;这些标点不能出现在{} 这里面。 # print(f"{{73}}") # {73} # print(f"{{{73}}}") # {73} # print(f"{{{{73}}}}") # {{73}} lambda 匿名函数

迭代器

定义

字面解释

一个可以重复取值的一个工具

专业角度

实现了无参数的next方法，返回序列中的下一个元素，如果没有元素了，
那么抛出StopIteration异常。python中的迭代器还实现了iter方法，因此迭代器也可以迭代
如果一个对象内部含有iter以及next方法，那么他就是迭代器

判断一个对象是否是迭代器

with open('01 函数名的应用.py',encoding='utf-8') as f1: # print(f1) # <_io.TextIOWrapper name='01 函数名的应用.py' mode='r' encoding='utf-8'> print('__iter__' in dir(f1) and "__next__" in dir(f1)) l1 = [22, 33, 44] for i in enumerate(l1): print(i) for i in enumerate(l1,start=100): print(i) print('__iter__' in dir(enumerate(l1)) and "__next__" in dir(enumerate(l1)))

可迭代对象转化迭代器

通过iter或者__iter__()

l1 = [22, 33, 44, 55, 66]
# 转化成迭代器
iterator1 = iter(l1)
iterator1 = l1.__iter__()
print(iterator1)

通过next方法对迭代器进行取值

# 通过next方法取值 # iterator1.__next__() print(next(iterator1)) print(next(iterator1)) print(next(iterator1)) print(next(iterator1)) print(next(iterator1)) print(next(iterator1)) # 报错 StopIteration

利用while循环模拟for循环一个可迭代对象的原理

l1 = [22, 33, 44, 55, 66] # 现将可迭代对象转化成迭代器 iter1 = iter(l1) while 1: try: print(next(iter1)) except StopIteration: break

小结

迭代器的优点

节省内存

如果是含有上百万元素的列表，占内存就上百空间，但是含有上百万元素的迭代器，占内存只是一个空间

惰性机制。next一次，取一个值，绝不过多取值

迭代是数据处理的基石。扫描内存中放不下的数据集时，
我们要找到一种惰性获取数据项的方式，即按需一次获取一个数据项。这就是迭代器模式

缺点

操作方法少。只能使用next

取值时不能走回头路，只能一直向下取值

不能直观数据

import time
l1 = [1, 2, 3, 4, 5, 6]
iter1 = iter(l1)
for i in range(3):
print(next(iter1))

name = 2
b = 3
c = name + b
print(c)
time.sleep(2)

for i in range(3):
print(next(iter1))

迭代器与可迭代对象对比

可迭代对象

是一个私有的方法比较多，操作灵活（比如列表。字典的增删改查
，字符串的常用操作方法），比较直观，但是占内存而且不能直接通过循环迭代取值
的这么一个数据集

应用

当你侧重于对于数据可以灵活处理，并且内存空间足够，将数据集设置为可迭代对象是明确的选择

迭代器

是一个非常节省内存，可以记录取值位置，可以直接通过循环+next方法取值，但是不直观，操作方法比较单一的数据集

应用

当你的数据量过大，大到足以撑爆你的内存或者你以节省内存为首选元素时，将数据集设置为迭代器是一个不错的选择（可参考
python为什么把文件句柄设置成迭代器）

列表的推导式与生成器表达式

跌表推导式

解释

一行代码构建一个有规律的列表

# l1 = []
# for i in range(1,11):
# l1.append(i)
# print(l1)

print([i for i in range(1,11)])

语法

# 循环模式
[变量（加工后的变量） for 变量 in iterable]
# 筛选模式
[变量（加工后的变量） for 变量 in iterable if 条件]

循环模式

print([f'{i}级人工智能' for i in range(18,51)])

print([i*i for i in range(11)])
print([i**2 for i in range(11)])

筛选模式

过滤掉长度小于3的字符串列表，并将剩下的转换成大写字母

l1 = ['barry', 'ab', 'vb', 'chongge'] print([i for i in l1 if len(i) > 3]) print([i.upper() for i in l1 if len(i) > 3])

小结

列表推导式只能构建较为复杂的有规律的列表，不能构建所有的列表。

一般如果循环超过3层，就不要用列表推导式了。

列表推导式有毒，慎重使用。

生成器表达式

生成器表达式与列表推导式构建的方式一模一样，也有循环模式以及筛选模式。只有一点不同。它是用小括号括起来并且形成的结果是生成器。

# print((i for i in range(1,101))) # <generator object <genexpr> at 0x0000018095E1F6C8> obj = (i for i in range(1,101)) # 对生成器取值的三种方式： # next # print(next(obj)) # print(next(obj)) # print(next(obj)) # for循环 for i in obj: print(i)

生成器与可迭代对象的转化

可迭代对象转化成生成器（迭代器）

iter(iterable)

生成器转化成可迭代对象（也是对生成器进行取值的方式）

转化成可迭代对象

print(list(obj))

生成器表达式和列表推导式的区别:

列表推导式比较耗内存,所有数据一次性加载到内存。而.生成器表达式遵循迭代器协议，逐个产生元素。

得到的值不一样,列表推导式得到的是一个列表.生成器表达式获取的是一个生成器

列表推导式一目了然，生成器表达式只是一个内存地址。

无论是生成器表达式，还是列表推导式，他只是Python给你提供了一个相对简单的构造方式，因为使用推导式非常简单，所以大多数都会为之着迷，这个一定要深重，推导式只能构建相对复杂的并且有规律的对象，对于没有什么规律，而且嵌套层数比较多（for循环超过三层）这样就不建议大家用推导式构建。

生成器的惰性机制:

生成器只有在访问的时候才取值,说白了.你找他要才给你值.不找他要.他是不会执行的.

其他的推导式

字典推导式

l1 = ['joy', 'SHE', 'JJ'] l2 = ['周杰伦', '女团', '林俊杰'] print({l1[index]: l2[index] for index in range(len(l1))})

集合推导式

l1 = [2, 3, -5, 4, 2, 3, 5, -4] print({abs(i) for i in l1}) print({abs(i) for i in l1 if i > 2})

函数的参数

实参角度

位置参数

按照从左至右的顺序，与形参一一对应。

def meet(sex,age,hobby):
print('打开探探已经定位')
print('选择性别%s，爱好%s，年龄%d' %(sex,hobby,age))
print('左滑一下')
print('右滑一下')
print('选中目标')
print('直奔主题')

meet('女',20,'看电影，游泳，健身....')

关键字参数

实参的关键字参数一定要与形参的参数一一对应

def meet(sex,age,hobby): print('打开探探已经定位') print('选择性别%s，爱好%s，年龄%d' %(sex,hobby,age)) print('左滑一下') print('右滑一下') print('选中目标') print('直奔主题') meet(age=20,hobby='看电影，游泳，健身....',sex='女')

混合参数

位置参数一定要在关键字参数前面，一一对应

def meet(sex,age,hobby): print('打开探探已经定位') print('选择性别%s，爱好%s，年龄%d' %(sex,hobby,age)) print('左滑一下') print('右滑一下') print('选中目标') print('直奔主题') # meet(age=18,'nv','瑜伽') # 位置参数一定要在关键字参数前面 meet('女',hobby='健美操',age=18)

形参角度

位置参数

形参角度的位置参数与实参角度的位置参数一样，从左至右一一对应

def meet(sex,age,hobby):
print('打开探探已经定位')
print('选择性别%s，爱好%s，年龄%d' %(sex,hobby,age))
print('左滑一下')
print('右滑一下')
print('选中目标')
print('直奔主题')
meet('女',20,'看电影，游泳，健身....')

默认值参数

一般我们把经常使用的数据设置成默认值参数。
不给默认值参数传值，则沿用默认值，如果给默认值参数传值则覆盖默认值。

def recognize(name,age,sex='男'):
"""模拟写入文件"""
print(name,sex,age)
n = input('请输入姓名').strip()
a = input('请输入年龄').strip()
s = input('请输入性别').strip()
recognize(n,a,s)

三元运算

变量1 = 变量2（数值） if 条件 else 变量3（数值）

万能参数

动态参数，将实参角度所用的位置参数以及关键字参数全部接受

聚合

函数定义时，*代表聚合一颗星会将实参角度所有的位置参数聚合成元组赋值给args
函数定义时，*代表聚合两颗星会将实参角度所有的关键字参数聚合成字典赋值给kwargs

def sum_(*args,**kwargs):
# print(args)
# return a + b + c + d
print(kwargs)
count = 0
for i in args:
count += i
return count
sum_(1,2,3,4,10,name='barry',age=20,hobby='smoke')

打散

函数的执行时，*代表打散，*dict会将字典里面的所有键值对打散成关键字参数
函数的执行时，*代表打散，*iterable 会将可迭代对象里面的所有的元素打散成位置参数

形参的顺序

*的使用

函数中，定义时代表聚合；函数的执行时代表打散。

*可以处理剩余元素。

a,b = (1,2) # * 得到的是列表类型 a,*b,c = [22,33,44,55,66,77] a,b,*c = [22,33,44,55,66,77] print(a,b,c) a,b,*c = (22,33,44,55,66,77) print(a,b,c)

形参的顺序

最终顺序：位置参数，*args，默认值参数，**kwargs.

# *args不能放在位置参数前面 def func(*args,a,b,sex='男'): print(a,b,sex), func(1,2,3,4,sex='女') # 这样写，你的默认值参数无意义了，不合理 def func(a,b,sex='男',*args): print(a,b,sex) print(args) func(1,2,3,4) def func(a,b,*args,sex='男'): print(a,b,sex) print(args) func(1,2,3,4,sex='女') def func(a,b,*args,sex='男',**kwargs,): print(a,b,sex) print(args) print(kwargs) func(1,2,3,4,hobby='大宝剑',age=18,sex='女')

仅限关键字参数

3.5之后的更新。这个参数一定是放在*args的后面的
最终顺序：位置参数，*args，仅限关键字参数，默认值参数，**kwargs.

def func(a,b,*args,c,sex='男',**kwargs): print(a,b,sex) print(c) print(args) print(kwargs) func(1,2,3,4,c=666,hobby='乒乓球')

函数式编程：函数式编程是面向过程式编程的一种升级，本质还是面向过程式编程。一个函数封装了一个功能。

名称空间

当程序运行时，整个py文件会创建一个全局名称空间，存储整个py文件变量与值得对应关系
当函数执行时，会在内存中创建一个临时命名空间，存储此函数内部的变量与值对应关系，随着函数的结束而消失
内置命名空间：当程序运行时，会在内存中产生一个内置名称空间，存储内置的函数、模块等变量与值得对应关系。

全局命名空间

我们直接在py文件中，函数外声明的变量都属于全局命名空间

局部命名空间

在函数中声明的变量会放在局部命名空间

内置命名空间

存放python解释器为我们提供的名字，list、tuple、str、int这些都是内置命名空间

加载顺序与取值顺序

加载顺序

当程序运行时先加载内置名称空间--->全局名称空间--->函数执行时临时名称空间

取值顺序

全局名称空间寻找变量先从全局找，全局没有再从内置空间找
就近原则

input = 666 # print(input) def func1(): input = 777 print(input) func1()

满足就近原则
如果你是在局部名称空间寻找变量：不可逆
局部名称空间--->全局名称空间--->内置名称空间

高阶函数

引子

列表，字典都可以嵌套很多的列表，字典，函数里面也可以嵌套函数，一般不超过三层。一般考察的就是执行顺序

例子

# # 例1： def func1(): print('in func1') # 1 print(3) # 2 def func2(): print('in func2') # 4 print(4) # 5 func1() print(1) # 3 func2() print(2) # 6 # # 例2： def func1(): print('in func1') # 3 print(3) # 4 def func2(): print('in func2') # 2 func1() print(4) # 5 print(1) # 1 func2() print(2) # 6 # # 例3： def fun2(): print(2) # 2 def fun3(): print(6) # 4 print(4) # 3 fun3() print(8) # 5 print(3) # 1 fun2() print(5) # 6

函数名的使用

函数名的本质就是变量

函数名指向的数据就是函数的内存地址

def func():
print('in func')
print(func) # <function func at 0x00000259EB5A5048>
func()
a = 1
b = a
c = b
print(c)
f1 = func
f2 = f1
f3 = f2
f3()

函数名可以作为容器类类型的元素

def func3(): print('in func3') func1() func2() func3() a = 1 b = 2 c = 3 l1 = [a,b,c] print(l1) l1 = [func1, func2, func3] for i in l1: i() dic = { 1: func1, 2: func2, 3: func3, }

函数名可以作为函数的实参

def func1(): print('in func1') def func2(f): # f= func1 f() # func1() print('in func2') a = 666 func2(a) func2(func1)

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

def func1(): print('in func1') def func2(f): print('in func2') return f # func1内存地址 ret = func2(func1) # func1内存地址 ret()

可迭代对象

定义

如果一个对象里面含有多个数据，可迭代对象，（不准确）

字面意思

什么是对象

python中一切皆对象，str、bool、dict、函数、文件句柄

什么是可迭代对象

更新迭代，必须可以一个一个去执行，并且每次执行的结果稍有不同

总结

一个可以重复取值的实实在在的东西（内容数据等等）

获取一个对象内部所有的方法

内置函数dir

s1 = 'barry' i = 100 # str print(dir(s1)) print(dir(i))

判断一个对象是否可迭代

print('__iter__' in dir(s1)) print('__iter__' in dir(tuple)) print('__iter__' in dir(list)) print('__iter__' in dir(dict)) print('__iter__' in dir(bool))

小结

优点

可迭代对象内容直观，操作速度快
操作方法多

缺点

占内存
可迭代对象不可以直接取值（除去索引与键以外）

生成器

字面意思

可以生成数据的工具。生成器与迭代器很多人都认为是一种。生成器与迭代器如果要找到唯一的不同：迭代器都是python的内置函数或者其他的功能（文件句柄）或者由可迭代对象转化得来的（iter()）。而生成器就是我们自己通过python代码构建的。

构建方式

生成器函数

def func(): print(111) yield 666 print(2222) print(3333) yield 'barry' gen_obj = func() # print(gen_obj) # 生成器对象 print(next(gen_obj)) print(next(gen_obj))

return vs yield

return结束函数，并且给函数的执行者返回值，一个函数中一般直设置一个return

yield不会结束函数，给next返回值，一个生成器函数可以设置多个yield

yield from

def gen(): yield 1 # yield from 是将一个可迭代对象转化成了一个迭代器 yield from ['barry', '冲哥', '龙哥'] obj = gen() print(next(obj)) print(next(obj)) print(next(obj)) print(next(obj))

补充

函数的传参实际上是变量的赋值运算的过程

l1 = [11,22]
def func(l:list):
l.append(666) # 2645029704200
print(id(l))
return l
print(id(l1)) # 2645029704200
print(l1)
func(l1)
print(l1)

内置函数

本节我们讲内置函数。首先来说，函数就是以功能为导向，一个函数封装一个功能，那么Python将一些常用的功能（比如len）给我们封装成了一个一个的函数，供我们使用，他们不仅效率高（底层都是用C语言写的），而且是拿来即用，避免重复早轮子，那么这些函数就称为内置函数，到目前为止python给我们提供的内置函数一共是68个，由于时间关系以及考虑这些函数的不同重要性我们会挑常用的重要的内置函数去讲，就是下面红色黄色背景的内置函数，剩下的内置函数你们参照着我的博客自己课下练习一下即可。

一带而过

all() any() bytes() callable() chr() complex() divmod() eval() exec() format() frozenset() globals() hash() help() id() input() int() iter() locals() next() oct() ord() pow() repr() round()

重点讲解

abs() enumerate() filter() map() max() min() open() range() print() len() list() dict() str() float() reversed() set() sorted() sum() tuple() type() zip() dir()

未来会讲

classmethod() delattr() getattr() hasattr() issubclass() isinstance() object() property() setattr() staticmethod() super()

eval执行字符串里面的代码（有返回值）

慎用：如果数据来源不明（通过网络得来的或者客户输入的指令），不要使用。

s1 = '3 + 2' # print(s1) ret = eval(s1) print(ret,type(ret)) s1 = '[1, 2, 3]' ret = eval(s1) print(ret,type(ret)) # list类型

exec 执行字符串类型的代码（代码流没有返回值）。

s1 = """ for i in range(3): print(i) """ # exec(s1)

hash 得到不可变的数据的哈希值。

print(hash(123)) print(hash('bafddf')) print(hash((1,2,3))) # print(hash([1,2,3]))

help：函数用于查看函数或模块用途的详细说明。

import time # print(help(str)) print(help(time))

callable：函数用于检查一个对象是否是可调用的。如果返回True，object仍然可能调用失败；但如果返回False，调用对象ojbect绝对不会成功。