Python入门之函数

1、初识函数

1.1 什么是函数？

<1> 将某个功能封装到一个空间中就是一个函数
<2> 减少重复代码

1.2 定义函数

# def  --   python中的关键字
#（）  --   必须要写   格式规定
# ：   --   语句结束

def func():    
	函数体

# 定义my_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("歇会,上个班")

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)       # 实参

def info(name,age,job,moeny,sex="男"):    
	print(f"姓名:{name} 年龄:{age} 性别:{sex} 岗位:{job} 薪资:{moeny}")
while True:    
	name = input("name:")         # marry
	age = input("age:")           # 89    
	sex = input("sex(男性回车):")  # 女    
	job = input("job:")           # teacher   
	money = input("moeny:")       # 10000    
	if sex == "女":        
		info(name,age,job,money,sex)    
	else:        
		info(name, age, job, money)

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

<1> 位置参数: 一一对应
<2> 默认参数: 函数定义的时括号中写好的就是默认参数,不进行传参使用默认参数,进行传参时使用传递的参数

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

<1> 位置参数: 一一对应
<2> 关键字参数: 按照名字进行传参

（3）混合参数: 位置参数和关键字参数一起使用

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

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

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> 加载顺序：内置空间 -> 全局空间 -> 局部空间
<2> 取值顺序：局部空间 -> 全局空间 -> 内置空间

（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

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))       # 11

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]())       # 5
print((lambda :5)())          # 5
a = lambda :5
a()                           # 5

lst = [lambda :i for i in range(5)]
print(lst[0]())                        # 4

# 试题拆解:
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)

5、三元运算符（三目运算符）：（只支持if else）

语法：条件成立的结果条件条件不成立的结果

def func(a,b):    
	return a if a > b else b
print(func(6,9))

posted @ 2019-08-30 10:40 永亮阅读(304) 评论(0) 编辑收藏举报

刷新页面返回顶部

YongLiangのBOKE

———————————————— 我曾十步一回头@CYL

Python入门之函数

1、初识函数

1.1 什么是函数？

1.2 定义函数

1.3 函数的调用

1.4 函数的返回值

（1）函数的返回值，返回给函数的调用者

（2）return：

1.5 函数的参数

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

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

（3）混合参数: 位置参数和关键字参数一起使用

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

2、函数进阶

2.1 动态位置参数

2.2 形参：

<1> 位置参数

<2> 默认参数

2.3 函数的注释：

（1）函数名. doc # 查看函数的注释

（2）函数名. name # 查看函数的名字

2.4 名称空间

2.5 函数的嵌套：

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

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

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

（1）函数名可以当做值，赋值给变量：

（2）函数名可以当做容器中的元素：

（3）函数名可以当做函数的参数：

（4）函数名可以当做函数的返回值：

4、匿名函数 == 一句话函数（一行函数）

（1）lambda x:x

5、三元运算符（三目运算符）：（只支持if else）

公告

YongLiangのBOKE

———————————————— 我曾十步一回头@CYL

Python入门之 函数

1、初识函数

1.1 什么是函数？

1.2 定义函数

1.3 函数的调用

1.4 函数的返回值

（1）函数的返回值，返回给函数的调用者

（2）return：

1.5 函数的参数

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

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

（3）混合参数: 位置参数和关键字参数一起使用

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

2、函数进阶

2.1 动态位置参数

2.2 形参：

<1> 位置参数

<2> 默认参数

2.3 函数的注释：

（1）函数名.__ doc__ # 查看函数的注释

（2）函数名.__ name__ # 查看函数的名字

2.4 名称空间

2.5 函数的嵌套：

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

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

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

（1）函数名可以当做值，赋值给变量 ：

（2）函数名可以当做容器中的元素：

（3）函数名可以当做函数的参数：

（4）函数名可以当做函数的返回值：

4、匿名函数 == 一句话函数（一行函数）

（1）lambda x:x

5、三元运算符（三目运算符）：（只支持if else）

公告

Python入门之函数

（1）函数名. doc # 查看函数的注释

（2）函数名. name # 查看函数的名字

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

（1）函数名可以当做值，赋值给变量：