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

函数基础

定义

def func( )

def 关键字 -- 定义     func 函数名 -- 和变量定义规则一样     () 必须要写格式     : 声明语句结束

def my_len()     函数体

函数的返回值

关键字   return

返回

def func( ):     print(123)     ruturn 456

有return

返回 return后的值

没return

返回 None

位置传参

def func(a):     print(a) func(1)

a -- 形参 1 -- 实参

形参

函数定义的时候叫做形参 # 位置参数 # 默认参数 # 混合参数

实参

函数调用的时候叫做实参 # 位置参数 # 关键字参数 # 混合参数

传参

将实参传递给形参的过程叫做传参

位置参数

def func(a,b):     pass

默认参数

def func(a,b=1):     pass

关键字参数

def func(b,c,a=3 ):     print(a,b,c) func(a=5,b=3,c=2)

混合参数

def func(a,b,c)     print(a,b,c) func(1,2,c=5)

函数的动态参数

*args

接收动态的位置参数

万能的(接受任意多个)的位置参数

在函数定义的时候叫做聚合

在函数中叫做打散

**args

接收动态的关键字参数

输出的是字典

万能传参

def func(*agrs,**kwargs):     print(agrs,kwargs) func(1,2,3,4,5,6,7,8,a=1,b=2,c=3)

函数的注释

name.__doc__

查看函数注释

name.__name__

查看函数命名

名称空间

命名空间分类

内置空间

print( ),len( ),input( )

全局空间

当前py文件需要开辟的空间存放在全局空间

局部空间

函数中开辟的空间就是局部空间

加载顺序

内置空间 - 全局空间 - 局部空间

取值空间

局部空间 - 全局空间 - 内置空间(找不到就报错)

作用域

内置空间 + 全局空间

局部空间

函数的嵌套

def func():     a = 1     def foo():         b = 2         print(b)         print(a)     def f1():         print(b)         return f1()         return foo() print(func())          # 2 1 2 None

函数的互相引用

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

global

声明修改的是全局变量的值

nonlocal

在外层的函数中,修改局部空间的变量值.完全不涉及全局变量

只修改离它最近的一层,最近的一层没有变量继续向上找,直到找到最外层函数

文件操作

文件基础

创建一个文件"asdf"

f = open("asdf",mode="r",encoding="utf-8")

open( )

# 打开

file

# 文件的位置(路径)

mode

# 操作文件的模式

encoding

# 文件编码方式

f

# 文件句柄

文件的打开和关闭

f = open("asdf",mode="r",encoding="utf-8") print(f.read()) f.close()

with open("asdf","r",encoding="utf-8")as f : 

文件的操作模式

r  rb  r+

w  wb  w+

a  ab  a+

文件具体操作

f = open("文件的路径(文件放的位置)",mode="操作文件的模式",encoding="文件的编码")

f 是文件句柄

文件详解

路径

绝对路径

例如:   f = open("F:\s24\day08\asdf","r",encoding="utf-8")           print(f.read())

相对路径

例如:   f = open("../day03/asdf","r",encoding="utf-8")           print(f.read())                         # / 返回上一层

路径转义

所有 \ 前加 \ ,使用\\ 进行转义

路径引号前加 r

文件操作的模式

r  w  a

r

读文本

read( )

全部读取

read(3)

看文件的前三个字符

readline( )

读取一行(自带换行符)

readlins( )

一行一行读取存放在列表

w

清空,写

步骤

1.先清空文件

2.写入文件

a

追加

在源文件的基础上进行添加

rb  wb  ab

rb

读字节

wb

清空,写

ab

追加

r+  w+  a+ 

r+

读写

错误的方式是写读 应先读后写

w+

清空写,读

清空文件写入

读取内容(默认为空)

a+

追加写,读

先写后读

注意点

(a,ab,a+)将光标移动到某个位置进行,写入的时候还是在文件的末尾

在r+模式下. 如果读取了内容. 不论读取内容多少. 光标显示的是多少. 再写入或者操作文件的时候都是在结尾进行的操作.

其他操作

光标

tell( ) 查看光标位置

返回的是字节数

seek( ) 移动光标

seek(0,0) 移动到文件头部

seek(0,1) 当前位置

seek(0,2) 移动到文件末尾

seek(3) 按照字节进行移动(具体移动参照编码集)

文件修改

创建一个新文件

将文件中的内容替换

替换后的内容写入新文件

改变文件名

with as

with open("文件路径","操作模式",编码")as f:     操作文件

优点

可以同时打开多个文件

能够自动关闭文件

函数名的第一类对象及使用

函数名可以当做值被赋值

def func():     print(1) print(func) a = func a()      # <function func at 0x000001A24F8E9B70>    1

函数名可以当做元素存放在容器中

def func():     print(1) lst = [func,func,func] for i in lst:     i()           # 1 1 1

函数名可以当做另一个函数的参数

def func(f):     f() def foo():     print(123) func(foo)           # 123

函数名可以当做返回值

def func():     def foo():         print(123)     return foo a = func() a()            # 123

格式化f""

f""格式化的作用

填充字符串

填充变量

填充计算公式

填充表达式

填充大括号

迭代器

可迭代对象

list,dict,str,set,tuple

可迭代对象使用灵活

查看是否可迭代

方法一

list.__iter__()

方法二

查看源码

方法三

print(dir( ))

优点及缺点

优点

使用灵活

可以直接查看值

缺点

消耗内存

迭代器

文件句柄"f"是个迭代器

f = open("xxxx","w") f.__iter__() f.__next__()

将可迭代对象转换成迭代器

lst = [1,2,3,4,6] new_list = lst.__iter__()  new_list.__iter__() new_list.__next__()

for循环的本质

s = "12345" new_s = s.__iter__() while True:     try: print(new_s.__next__()) except StopIteration:     break

递归

定义

自己调用自己

有明确的终止条件

递与归

递

一直执行直到碰到结束条件

归

从结束条件开始往回退

生成器

生成器与迭代器的区别

迭代器是python中内置的一种节省空间的工具

生成器的本质就是一个迭代器

迭代器是python自带的

生成器是程序员自己写的

定义

基于函数,函数中存在yield就是一个生成器

函数名 + ( )就是产生一个生成器

def func():     if 3>2:     yield "你好"      if 4>2:     yield "我好" yield "大家好" g = func()  print(g.__next__()) print(g.__next__()) print(g.__next__())

优点及注意事项

节省空间 -- 惰性机制 不能逆行 一次性 一个next对应一个yield yield 能够进行返回内容,还能够返回多次 yield能够临时停止循环 yield 能够记录执行的位置

输出方式

def foo():     for i in range(10):         pass         yield i     count = 1     while True:         yield count         count += 1 g = foo() print(next(g)) # ---- 推荐使用 print(next(g)) print(next(g)) print(next(g)) print(next(g))

坑

最后输出时调用函数要找变量接收 否则会循环输出

生成器应用场景

一次性打印全部结果,数据过大时特别消耗内存

def func():     lst = []     for i in range(100000):         lst.append(i)     return lst print(func())

每次打印可选的一部分,不用的部分不打印,节省空间

def func():     for i in range(100000):         yield i g = func() for i in range(50):     print(next(g))

yield from

将一个可迭代对象的元素逐个返回

def func():     lst1 = ["牛羊配","老奶奶花生米","卫龙","虾扯蛋","米老头","老干妈"]     lst2 = ["小浣熊","老干爹","亲嘴烧","麻辣烫","黄焖鸡","井盖"]     yield from lst1     yield from lst2 g = func() print(next(g)) print(next(g)) print(next(g)) print(next(g)) # 牛羊配 # 老奶奶花生米 # 卫龙 # 虾扯蛋

所以循环第一个列表直到全部打印再循环第二个

推导式

列表

循环模式

[i for i in range(20)]

筛选模式

[i for i in range(20) if i % 2 == 0]

[变量(加工后的变量) for循环加工方式]

生成器

循环模式

g = (i for i in range(20)) print(next(g)) print(next(g)) print(next(g))

转换成列表