python中求差的函数_Python入门之函数

Python入门之 函数

1、初识函数

1.1 什么是函数？

<1> 将某个功能封装到一个空间中就是一个函数

<2> 减少重复代码

1.2 定义函数

def -- python中的关键字

()-- 必须要写 格式规定

： -- 语句结束

def len():

函数体

def my_len():

n = 0

for i in dic:

n += 1

print(n)

1.3 函数的调用

函数名 + () 就是在调用函数

def yue():

print("掏出手机")

print("打开微信")

rint("摇一摇")

print("聊一聊")

print("约吗?")

print("....")

yue()

yue()

面向过程：

print("掏出手机")

print("打开微信")

print("摇一摇")

print("聊一聊")

print("约吗?")

print("....")

print("上班")

print("掏出手机")

print("打开微信")

print("摇一摇")

print("聊一聊")

print("约吗?")

print("....")

print("检查一下")

面向函数编程：

def work():

print("打开电脑")

print("查看邮件")

print("打开找到微信")

print("进行群聊")

print("开始撸代码")

print("撸完")

print("下班")

def yue():

print("掏出手机")

print("打开微信")

print("摇一摇")

print("聊一聊")

print("约吗?")

print("....")

yue()

work()

yue()

print("检查一下")

yue()

print("6块钱的麻辣烫")

yue()

print("歇会,上个班")

推荐Python大牛在线分享技术 扣qun：855408893

领域：web开发，爬虫，数据分析，数据挖掘，人工智能

零基础到项目实战，7天学习上手做项目

1.4 函数的返回值

def yue():

print("打开手机")

print("打开微信")

print("打开附近的人")

print("聊一聊")

print("见一见")

print("......")

return 1,2,3,4,5

print(1111)

girl = yue()

print(girl)

(1)函数的返回值，返回给函数的调用者

return 值 (返回值)

(2)return：

<1> 可以返回任意类型数据

<2> return返回多个内容时是元组的形式

<3> return下方不执行，并且会终止当前这个函数

<4> return不写或者写了return后面不写值都返回None

函数名+()

启动函数

接受返回值

1.5 函数的参数

def yue(app1,app2,app3,app4): # 形参

print("打开手机")

print(f"打开{app1} {app2}")

print("聊一聊")

print("见一见")

print("......")

yue("微信","探探","陌陌","soul") # 实参

def yue(a,b,c,app1="微信"): # 形参

print("打开手机")

print(f"打开{a} {app1}")

print("聊一聊")

print("见一见")

print("......")

yue("探探","陌陌","微信") # 实参

def yue(a,b,c,a1="微信"): # 形参

print("打开手机")

print(f"打开{a} {b} {c} {a1}")

print("聊一聊")

print("见一见")

print("......")

yue(11,c=5,b=1) # 实参

三元运算符*(三目运算符)：(只支持if else)

条件成立的结果 条件 条件不成立的结果

def func(a,b):

return a if a > b else b

print(func(6,9))

def info(name,age,job,moeny,sex="男"):

print(f"姓名:{name} 年龄:{age} 性别:{sex} 岗位:{job} 薪资:{moeny}")

while True:

name = input("name:") # rimo

age = input("age:") # 89

sex = input("sex(男性回车):") # 女

job = input("job:") # wc

money = input("moeny:") # 10

if sex == "女":

info(name,age,job,money,sex)

else:

info(name, age, job, money)

(1)形参:

<1> 位置参数:

​ 一一对应

<2> 默认参数: 函数定义的时括号中写好的就是默认参数

​ 不进行传参使用默认参数,进行传参时使用传递的参数

(2)实参:

<1>位置参数:

​ 一一对应

<2> 关键字参数:

​ 按照名字进行传参

(3)混合参数:

​ 位置参数和关键字参数一起使用

​ 位置参数 > 默认参数(关键字参数)

形参: 函数定义阶段括号中的参数叫做形参

实参: 函数调用阶段括号中的参数叫做实参

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

2、函数进阶：

def eat(a,b,c,d,e,f):

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

eat("麻辣烫","大烧饼","大煎饼","大腰子","韭菜","羊蝎子")

如何解决参数数量太多？

2.1 动态位置参数：

def eat(*args): # 函数的定义阶段 *聚合(打包)

print(args) # tuple

print(*args) # 函数体中的 * 打散(解包)

eat("麻辣烫","大烧饼","大煎饼","大腰子","韭菜","羊蝎子")

def eat(a,b,*c): #位置参数 > 动态位置参数

print(a)

print(b)

print(c) # tuple

eat("面条","米饭","馒头","大饼")

def eat(a,b,*args,d=2,**c): # 位置参数 > 动态位置参数 > 默认参数 > 动态默认参数

print(a)

print(b)

print(d)

print(args) # tuple

print(c) # dict

eat("面条","米饭","大烧饼","大煎饼",a1=1,b1=2) # 位置 > 关键字

def eat(*args,**kwargs): # (万能传参)

print(args) # tulpe

print(kwargs) #

lst = [1,23,4,6,7]

dic = {"key1":1,"key2":3}

应用场景

eat(lst,dic)

eat(*lst,**dic) # eat(1,23,4,6,7,"key1"=1,"key2"=2)

总结：

<1> *args (聚合位置参数) 大家伙都用的名字，可以进行修改但是不建议修改

<2> **kwargs (聚合关键字参数) 大家伙都用的名字，可以进行修改但是不建议修改

函数的定义阶段 * 和 ** 都是聚合

函数体中 * 就是打散，* args将元组中的元素进行打散，* kwargs将字典的键获取

2.2 形参：

<1> 位置参数

动态位置参数：先执行位置参数，位置参数接受后额外的参数由动态位置参数进行接受 ，获取的是一个元组

<2> 默认参数

动态关键字参数(默认)：先执行默认参数，默认参数接受后额外的由默认参数进行接受，获取的是一个字典

实参和函数体：

*打撒

**实参时能够使用

2.3 函数的注释：

def a(a:int,b:int):

"""

求和

:param a: int

:param b: int

:return: int

"""

return a + b

def b(a:int,b:int):

"""

求差

:param a: int

:param b: int

:return: int

"""

return a - b

(1)函数名._ doc _ #查看函数的注释

(2)函数名._ name _ #查看函数的名字

2.4 名称空间

(1)内置空间：Python解释器自带的空间

(2)全局空间：py文件中顶格写的就是全局空间

(3)局部空间：函数体中就是局部空间

<1> 加载顺序：

​ 内置空间

​ 全局空间

​ 局部空间

def func():

a = 1

print(a)

func()

<2> 取值顺序：

​ 局部空间

​ 全局空间

​ 内置空间

a = 10

def func():

print(a)

func()

(4)作用域:

全局作用域：全局 + 内置

局部作用域： 局部

作用域的作用就是保护数据的安全性

2.5 函数的嵌套：

不管在什么位置，只要是函数名() 就是在调用一个函数

混合嵌套：

def f1():

print(11)

def f2():

print(22)

f1()

def f3():

print(33)

f1()

def run():

f3()

f2()

f1()

run()

def foo(a):

a = 10

def f1(b):

c = b

def foo(c):

print(c)

print(foo.__doc__)

foo(c)

print(b)

f1(a)

print(a)

foo(25)

2.6 global :只修改全局，没有时就创建一个

a = 10

def func():

global a

a = a - 6

print(a)

print(a)

func()

print(a)

2.7 nonlocal :只修改局部，修改离nonlocal最近的一层，上一层没有继续向上上层查找，只限在局部，没有就报错

a = 100

def func():

b = 10

def foo():

b = a

def f1():

nonlocal b

b = b + 5

print(b) # 105

f1()

print(b) # 105

foo()

print(b) # 10

func()

print(a) # 100

​ enumerate() #枚举 默认从0开始数 第一个参数是可迭代对象 第二个对象是起始值

3 、 函数的第一类对象及使用

(1)函数名可以当做值，赋值给变量 ：

def func():

print(1)

print(func) # 函数的内存地址

a = func

print(a)

a()

(2)函数名可以当做容器中的元素：

def login():

print("这是登录")

def register():

print("这是注册")

def index():

print("这是博客园的主页")

msg = """

1 登录

2 注册

3 主页

"""

choose = input(msg) # 1

if choose.isdecimal():

if choose == "1":

login()

elif choose == "2":

register()

elif choose == "3":

index()

​ 改良：

def login():

print("这是登录")

def register():

print("这是注册")

def index():

print("这是博客园的主页")

dic = {"1":login,"2":register,"3":index}

msg = """

1 登录

2 注册

3 主页

"""

choose = input(msg) # 1

if choose.isdecimal():

if dic.get(choose):

dic[choose]()

else:

print("请正确输入!")

(3)函数名可以当做函数的参数：

def func(a):

print(111)

a()

def foo():

print(222)

func(foo)

(4)函数名可以当做函数的返回值：

def func():

def foo():

print(111)

return foo

a = func()

a()

func()() # foo()

练习：

def f1(c):

def a():

def f3():

print(3333)

return [f3,a,f1]

print(11)

return f3()

ret = a()

return c(ret)

def aa(b):

print(111)

return b

print(f1(aa))

4、匿名函数 == 一句话函数(一行函数)

匿名函数是有名字的 叫做 lambda

(1)lambda x:x

<1> lambda 关键字

<2> x 是普通函数的形参(位置，关键字·····)可以不接收参数，可以不写

<3> :x 冒号后边的x是普通函数的函数值 (只能返回一个数据类型)，必须要有返回值

print((lambda x:x+6)(5))

f = lambda x:x+6

print(f.__name__)

f = lambda x,y,z,b=1:x,y,z,b

print(f(1,2,3))

print([lambda :5][0]())

print((lambda :5)())

a = lambda :5

a()

lst = [lambda :i for i in range(5)]

print(lst[0]())

lst = [lambda :i for i in range(5)]

print(lst[0]())

面试题拆解:

lst = []

for i in range(5):

def func():

return i

lst.append(func)

lst = [] # [lambda x:x+1,lambda x:x+1]

for i in range(2):

lst.append(lambda x:x+1)

print(lst[-1](5))

lst = [lambda x:x+1 for i in range(5)]

print(lst[0](5))

tu = (lambda :i for i in range(3))

print(next(tu)())

print(next(tu)())

print(next(tu)())

def func():

for i in range(3): # i = 0 1 2

def foo(): # foo1 foo2 foo3

return i

yield foo # foo1 foo2 foo3

g = func()

print(next(g)()) # foo1

print(next(g)) # foo2

print(next(g)) # foo3

lst = [lambda :i for i in range(3)]

print(lst[0]())

tu = (lambda :i for i in range(3))

print(next(tu)())

lst = [lambda x:x+5 for i in range(2)]

print([i(2) for i in lst])

lst = [] # [lambda x:x+5,lambda x:x+5]

for i in range(2):

lst.append(lambda x:x+5)

new_lst = []

for i in lst:

new_lst.append(i(2))

print(new_lst)

lst = (lambda x:x+5 for i in range(2))

print([i(2) for i in lst])

def func():

for i in range(2):

f = lambda x: x + 5

yield f

g = func()

lst = []

for i in g:

lst.append(i(2))

print(lst)

lst = [lambda x:x*i for i in range(2)]

print([i(2) for i in lst]) #[2,2]

lst = [] # [lambda x:x*i,lambda x:x*i]

for i in range(2):

lst.append(lambda x:x*i)

# print(i)

new_lst = []

for em in lst:

new_lst.append(em(2))

print(new_lst)

lst = (lambda x:x*i for i in range(2))

print([i(2) for i in lst]) #[0,2]

def func():

for i in range(2):

f = lambda x:x*i

yield f

g = func()

lst = []

for i in g:

lst.append(i(2))

print(lst)