day4大海老师之函数基础

发表于 | 更新于 | 分类于 | 评论数：

图灵logo

day4函数基础图灵python大海老师

1.引入

基于前一部分的学习，我们已经能够写一个简单的小程序了，但是随着程序功能的增多，代码量随着增大，此时仍不区分的把所有功能的实现代码放到一起（简单的说就是对代码进行分类），可读性变差，且程序中需要频繁使用同一功能时，只能重复编写该功能的实现代码，日积月累，程序将变得冗长。

1.1.什么是函数？

1.1.1编程来源于生活

我们完全可以从现实生活中找到简化程序设计的方案:比如一个修理工会事先准备好螺丝刀，锤子等工具，这样在进行修炼的过程中，需要用到螺丝刀的功能时就直接拿来螺丝刀使用，需要用到锤击物体的功能时就直接拿来锤子使用，而无需临时制造。这个例子的核心在于（事先准备好工具，遇到应用场景时，拿来就用）

1654672491516

1.1.2在程序中

在程序中,函数就具备某一功能的工具事先将工具准备好 锤子 扳手 工厂
即函数的定义遇到应用场景拿来就用即函数的调用所以务必记住：
函数的使用必须遵循先定义,后调用的原则（先制造了工具，工具才能使用）

2.函数基础

2.2.如何使用函数

2.2.1如果把函数比喻成一个生产车间，那么员工和机器就是函数内封装的代码

1654672910370

2.2.2函数的语法结构

函数分为2个阶段：定义阶段（制造代码），调用阶段（执行函数内的体代码）

定义阶段
语法
1
2
3
只检测函数体的语法( 工厂合不合格)，不执行函数体代码 （不使用工厂）
def 函数名+括号+冒号
	缩进+体代码
实例
1
2
3
4
5
6
7
8
9
def factory(): # 制造一个工厂
    '''
    这是一个工厂
    :return:
    '''
    print('正在制造手机') # 代码相当于员工和机器
    print('正在制造手机') # 代码相当于员工和机器
    print('正在制造手机') # 代码相当于员工和机器
    print('正在制造手机') # 代码相当于员工和机器
调用阶段
语法
1
2
3
函数的调用：函数名加括号
1 先找到名字，也就是函数名   (找到工厂的位置)
2 根据函数名调用代码   ( 加了括号执行工厂进行加工)
实例
1
2
3
4
# 函数名其实就是函数的内存地址
print(factory)
# 函数名+括号调用执行函数内的体代码
factory()

2.3.函数作用

1
2
3
1.减少重复代码，减少程序冗长问题
2.减少程序的扩展性差
3.减少程序的可读性差

3.函数的三大特性

函数功能，函数参数，函数返回值

3.1.函数功能

3.1.1有功能

1
2
3
4
# 函数内有实际运行的代码(代表有功能)
def factory(): # 制造一个工厂
    print('正在制造手机') # 代码相当于员工和机器
factory()

3.1.2.无功能

1
2
3
4
# pass占位，函数内无实际代码（用来测试，先做好项目的需求）
def shopping():
    pass
shopping()

3.2.函数参数

函数的参数我们把它比喻成现实世界工厂需要的零件

1654678226256

3.2.1.无参函数

1
2
3
4
# 应用场景仅仅只是执行一些操作，比如与用户交互，打印（工厂制造手机，不需要外接资源）
def factory(): # 制造一个工厂
    print('正在制造手机') # 代码相当于员工和机器
factory()

3.2.2.有参函数

1
2
# 有参
# 需要根据外部传进来的参数，才能执行相应的逻辑，计算 （工厂制造手机，需要a零件和b零件）
参数分为形参和实参
形参
1
指的是在定义函数阶段括号内指定变量名,即形参本质就是"变量名"

形参又分为：位置形参，默认形参，不定长形参

实参
1
指的是在调用函数阶段括号内传入的值,即实参本质就是"值"

实参又分为：位置实参，关键字实参

1.位置形参
1
2
3
4
5
6
# 位置形参：按照位置定义的形参
def factory(a,b): # 制造一个工厂，需要a零件和b零件
   # 1 形参: 指的是在定义函数阶段括号内指定变量名,即形参本质就是"变量名"
   #  形参可以看做一个变量名
   print('a是%s'%a)
   print('b是%s'%b)
2.位置实参
1
2
3
4
5
6
7
8
9
10
# 实参: 指的是在调用函数阶段括号内传入的值,即实参本质就是"值"
# 调用函数的参数称为实参
# 形参与实参的关系:在调用函数时,会将实参(值)赋值(绑定)给形参(变量名)
# 位置实参:按位置传入数据给函数的形参的方式
factory(3,2)
# 注意:但凡按照位置定义的形参,必须被实参传值,多一个不行,少一个也不行
# 位置参数 *****
# 错误示范
# factory(3,2,1)
# factory(3)
3.关键字实参
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 关键字实参：在调用函数阶段,按照key=value的形式指名道姓地为形参传值
#注意:
#1. 可以完全打乱顺序,但仍然能指名道姓为指定的形参传值
#2. 可以混合使用位置实参与关键字实参,但是必须注意:
#    2.1 位置实参必须放到关键字实参前面
#    2.2 不能对一个形参重复赋值
# 正确使用
factory(a=1,b=2)
factory(b=1,a=2)
# 错误示范
# factory(a=1,a=2)
# factory(a=1,2)
# factory(1,a=1)
# 位置实参必须放到关键字实参前面
factory(1,b=2)
4.默认形参
1
2
3
4
5
6
7
8
9
10
#默认参数  *****
#默认参数:指的是在定义函数阶段,就已经为某个形参赋值了,该形参称之为有默认值的形参,简称默认形参
#注意:
#1. 在定义阶段就已经被赋值,意味着在调用阶段可以不用为其赋值
#2. 位置形参应该放到默认形参前面
#3. 默认参数的值在函数定义阶段就已经固定死了
def factory(a,b=2):#  在定义阶段就已经被赋值，意味着在调用可以不用为其赋值,也可以对其重新赋值
    print(a)
    print(b)
factory(1,6)
位置形参vs默认形参
1
2
3
4
5
6
7
8
9
10
11
# 对于大多情况下传的值都不相同的,应该定义成位置形参
# 对于大多情况下传的值都相同的,应该定义成默认形参

def register(name,age,sex='男'):
    print(name,age,sex)
register('大海',18)
register('夏洛',12)
register('xiao海',14)
register('hong海',15)
register('西施',18,'女')
register('hong海',15)
5.不定长形参
5.1.在形参中带*
1
2
3
4
5
6
7
#  在形参中带*:会将调用函数时溢出位置实参保存成元组的形式,然后赋值*后的变量名
def foo(x,y,*z):
    print(x)
    print(y)
    print(z)
    print(*z)
foo(1,2,3,4,5,6,7,8)
5.2.序列类型的实参*打散成位置实参
1
2
3
4
5
6
7
8
9
def foo(x,y,z):
    print(x,y,z)
# 实参打散
foo(1,*(2,3))
foo(*(1,2,3))
foo(*[1,2,3])
foo(*'abc')
print(1,2,3)
print(*[1,2,3])
5.3.在形参中带**
1
2
3
4
5
6
7
8
9
10
11
12
# 在形参中带**:会将调用函数时溢出关键字实参保存成字典的形式,然后赋值**后的变量名
def foo(x,y,**z):
    print(x)
    print(y)
    print(z)
    # 字典不能这样打散，字典无序，无法独立打散
    # print(**z)
# # 错误
# foo(1,2,a=1,b=2,c=3,x=1)
# foo(1,2,3)
# # 正确
foo(1,2,a=1,b=2,c=3)
5.4.字典实参可以打散成关键字实参传参
1
2
3
4
5
6
7
8
# 打散字典
# 实参可以打散字典变成关键字实参进行传参
# 为何字典可以打散成关键字，因为字典是无序的，关键字也是无序的。
a = {'a':1,'b':2,'c':3}
foo(1,2,**a)
foo(1,2,b=2,c=3,a=1)
# 字典独立打散不行
# print(**a)
5.5.不定长参数的规范
1
2
3
4
5
6
7
#5. 规范: 在形参中带*与**的,*后的变量名应该为args,**后跟的变量名应该时kwargs
# 无敌 可以接收 0 到 无穷个位置参数和关键字参数
def factory(*args,**kwargs):
    print(args)
    print(kwargs)
factory()
factory(1,2,3,a=1,b=2)

3.2.3.参数的顺序

1
2
# 形参 位置参数 < 默认参数 < 不定长参数
# 实参 位置参数 < 关键字参数

3.2.函数的返回值

函数的返回值我们把它比喻成现实世界工厂里面的物流，将产品分发给全世界

1654678697624

3.2.1.参考内置函数返回值

1
2
3
4
5
6
7
8
9
10
11
12
13
# @Author : 大海
# @File : 3.函数的返回值.py
L = [1,2,3,4]
n=L.pop()
# 原值
print(L)
# 返回值
print(n)
meiyou=L.append(5)
# 原值
print(L)
# 返回值
print(meiyou)

3.2.2.我们刚才学习的自定义函数

1
2
3
4
5
6
7
8
9
10
11
# 返回值是一个函数的处理结果（物流）return
# 函数属于局部
def factory():
    # 函数里面用
    print('正在制造手机') # 代码相当于员工和机器
    # print('自己玩自己做的手机')
    # 函数外面用
    return '给全世界玩自己做的手机'
# # 全局
a=factory()
print(a)

3.2.3.return的特性

1.函数结束的标志
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
'''
1、return是一个函数结束的标志，函数内可以有多个return，
            但只要执行一次，整个函数就会结束运行
            默认return None  
'''
def factory(a):
    # 这个是在函数里面用的，工厂里面自己用
    # c = a+1
    # print(c)
    if a == '1':
        return '你选择的是1'
    else:
        return '你选择的不是1'
b=factory(input('输入一个数字1或者其他'))
print(b)
2.无类型限制
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
'''
2、return 的返回值无类型限制，即可以是任意数据类型，变量名，函数名
'''
def factory(a):
#     # 这个是在函数里面用的，工厂里面自己用
    c = a+1
    print(c)
    def inner():
        print('factory里面的函数')
    
    return 'adasdasda'
    return c
    return inner
#     # return None
b=factory(1)
print(b)
3.无个数限制
1
2
3
4
5
6
7
8
9
10
11
12
13
14
'''
3、return 的返回值无个数限制，即可以用逗号分隔开多个任意类型的值  *****
            0个：返回None，ps：不写return默认会在函数的最后一行添加return None
            1个:返回的值就是该值本身
            多个：返回值是元组
'''
def factory(a):
    # 这个是在函数里面用的，工厂里面自己用
    c = a+1
    # print(c)
    return [1,23,4],True,4,'adasdasda',c
    # return None
b=factory(1)
print(b)
4.利用return结束循环
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
'''
4.return关键字:return也可以作为函数结束的标志, 
         那么利用这一点就可以结束循环
'''
def factory(a):
    print('=====')
    print('=====')
    print('=====')
    while True:
        while True:
            while True:
                if a == 3:
                    return
                a += 1
                print(a)

factory(1)

4.函数调用的三种方式.py

4.1.语句形式

1
2
3
4
# 1 语句形式
def foo():
    print('from foo')
foo()

4.2.表达式形式

1
2
3
4
5
6
7
def foo(x,y):
    res = x + y
    return res
res = foo(1,2)
print(res)
res1 = foo(1,2)*100
print(res1)

4.3.可以当作参数传给另外一个函数

1
2
3
4
5
6
7
def max2(x,y):
    if x > y:
        return x
    else:
        return y
print(max2(1,2))
print(max2(max2(1,2),max2(4,5)))

5.函数局部变量和全局变量的修改.py

5.1.全局变量和局部变量和函数的关系

5.1.1.外部不能访问函数内部的变量

1
2
3
def fun1():
    x = 1
print(x)

5.1.2.函数内部能够访问函数外部的变量

1
2
3
4
x = 123
def fun2():
    print(x)
fun2()

5.1.3.函数里面不能修改函数外部的变量

1
2
3
4
5
x = 123
def func2():
    # print(x)
    x = x+1
func2()

5.1.4.global修改全局变量

1
2
3
4
5
6
7
8
x = 123
def func2():
    # print(x)
    global x
    x = x+1
    print(x)
func2()
print(x)

5.1.5.nonlocal让嵌套函数能够修改嵌套函数之外的值

1
2
3
4
5
6
7
8
9
10
11
12
# 只检测函数体的语法( 工厂合不合格)，不执行函数体代码 （不使用工厂）
def func2():
    b = 100
    # 没有被定义func3
    def func3():
        print('======')
        nonlocal b
        b +=1
        print(b)
    func3()
# # 运行了func2 所以才定义func3
func2()

6.常用的内置函数.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
# @Author : 大海
# @File : 6.常用的内置函数.py
#1 已经写好的一些函数   美观，强大  拿来主义
#
# # 绝对值
# print(abs(-5))
# print(abs(5))
#
# # all(可迭代对象)# 返回的是布尔值
# #  可迭代对象里面的值全部为真才是真,其余为假
# #  可迭代对象是空则为真
# # 很像and
# print(all([1,'',None]))
# print(all([1,'aa',2]))
# print(all([]))
# # # any(可迭代对象)
# # #  可迭代对象里面的值全部为假才是假，其余为真
# # #  可迭代对象是空则为假
# # 像or
# print(any([1,'',None]))
# print(any([0,'',None]))
# print(any([]))
#
# # 聚合函数
# # # 求最大值
# a= [1,2,3,4,5,6]
# print(max(a))
# # # 求最小值
# print(min(a))
# # # 求和
# print(sum(a))

# asill码 百度百科
# ord() 可以把字符转换成编码
# chr() 可以把编码转换成字符

# print(ord('a'))
# print(chr(97))
#
# print(ord('A'))
# print(chr(65))

# 拉链函数 zip
# t1 = ['a','b','c','d','e']# e被抛弃
# t2 = [1,2,3,4]
#
# print(list(zip(t1,t2)))
# # 最好的
# print(dict(zip(t1,t2)))

# 介绍 exec 函数   可以执行字符串里面的代码 支持python语法
exec('print(1)')

exec('''
for i in range(0,10):
    print(i)
''')
图灵python大海老师 wechat
python分享公众号
坚持原创技术分享，您的支持将鼓励我继续创作！