函数初识

目录

• 函数
  • 1.1认识函数
    • 1.1.1定义函数：
  • 1.2函数的返回值
  • 1.3函数的参数
  • 1.4函数的动态参数
  • 1.5函数的注释
  • 1.6函数的命名空间
  • 1.7函数的嵌套
  • 1.8 global及nonlocal
  • 1.9函数名的第一类对象及使用
    • 1.9.1可以当做值被赋值给变量
    • 1.9.2当做元素存在容器中
    • 1.9.3函数名可以当作函数的参数
    • 1.9.4函数名可以当作函数的返回值
  • 1.10'f'格式化
    • 1.10.1字符串填充
    • 1.10.2填充变量
    • 1.10.3填充计算公式
    • 1.10.4填充表达式
    • 1.10.5填充大括号
    • 1.10.6包含print()
    • 1.10.7包含函数
    • 1.10.8包含函数嵌套返回值
    • 1.10.9包含列表
    • 1.10.10包含字典
  • 1.11递归

函数

1.1认识函数

函数将一些代码进行封装:减少代码重复性 (冗余),代码可读性高,将功能进行封装(造工具)

1.1.1定义函数：

# def 关键字  函数名():
	函数体(代码块)
def make():
    print('1')
    print('2')
    print('3')
    print('4')
    print('5')
    return 多个返回值是元组
make()  #函数名 + 小括号 == 调用
msg = make() # make == None  make() == '美女一枚'
print(msg)

1.2函数的返回值

def func():
    print('今天是周二')
    print('明天是周三')
    return 0.125
	print('后天是周四')
# return 返回值
# return 返回一个内容(就是内容本身) 可以返回任意类型
# return 返回多个内容,以元组的形式返回
# return 终止函数 ,切记不能终止循环
# return 下方的代码不执行
# return 不写返回值或者没有return就返回None
# return 将内容返回给了函数的调用

1.3函数的参数

# 参数
# 参数 定义的参数 形参
# 调用的参数是 实参			形参和实参的数量  一一对应
# 从实参到形参的过程 传参
# addr 是不是一个变量  addr = '家'
def func(addr,school): # 形参
    print(f'我在{addr}睡觉{school}')
    
func(addr = '家'，age = 18)
# 实参的角度：
    # func('清华','东莞')         位置
    # func(addr = '清华',school = '东莞')   关键字
    # func('清华',school = '东莞')         混合
# 实参的角度：
    # func(addr,school)             位置
    # func(school = '东莞')         默认参数
    # func(addr,school = '东莞')    混合   
    
#函数形参规则       位置参数 > 默认参数
#函数实参规则		  位置参数 > 关键字参数

1.4函数的动态参数

def eat(a,b*args):	    # 聚合 打包
    print(a,b,args)     # 元组
    # 形参位置    ：    位置参数   >   动态位置参数
 eat('1','2','3','4','5')
def eat(**kwargs):
    print(kwargs)		# 字典
 eat('q' = '1','w' = '2','e' = '3')   

def func(a,b,*args):	#聚合  
    print(a,b,*args)	#打散
# args 返回的是元组  *args 将元组打回原来的数组
func(1,2,3,4,5,6,7)

def func(a = 1,b = 2,**kwargs):    # 默认参数  ** 聚合
    print(a,b,kwargs)
func(a = 56, c = 22, b = 333, d = 66)

 def func(a,b,c = 1,*arg,**kwargs):  # 位置 > 动态位置 > 默认参数 > 动态默认参数
        print(a,b,c,args,kwargs)
 func(1,2,3,4,5,6,7,8,c = 33,d = 123,f = 345)

def func(*args,**kwargs):  #万能   无敌
    print(args,kwargs)
func(1,2,3,4,a = 1,b = 2)   # 位置  关键字  混合

'''
参数的优先级: 位置参数 > 动态位置参数 > 默认参数(关键字参数) > 动态关键字参数
1.万能传参: 动态位置参数,动态关键字参数 (最常用******)
2.位置参数,动态位置参数
3 动态位置参数,关键字参数,动态关键字参数
'''

1.5函数的注释

def func(*args,**kwargs):
    '''
    逻辑判断...
    :param args: 万能的位置参数
    :param kwargs: 万能的默认参数
    :return: 返回值
    '''
    print(args)
    print(kwargs)
    return

print(func.__doc__)   # 查看函数的注释 函数名.__doc__
print(func.__name__)  # 查看函数名 函数名__name__

1.6函数的命名空间

# 内置空间
# 全局空间
# 局部空间
    
# python关键字是存在内置空间的
# py文件中顶头写的内容就存在全局空间
# 函数内写的变量存在局部空间

# a = 1
# b = 2
y = 9
def func():
    y = 3     # 局部空间
    print(y)   #  3
def func1():
    print(y)   #  9  局部空间不能共享

# 找值顺序：局部空间 > 全局空间 > 内置空间
# 加载顺序：内置空间 > 全局空间 > 内置空间

#命名空间: 
   # 全局作用域: 内置空间 + 全局空间
   # 局部作用域: 局部空间

1.7函数的嵌套

def func():
    print(1)
    def f1():
        print(2)
    return f1()
func()

# 不管在什么位置,只要是函数名+() 就是在调用此函数
# 函数调用执行后,函数体中开辟的空间就自动销毁了

1.8 global及nonlocal

 # 内置空间 +  全局空间 = 全局 globals()
 # 局部空间 				loacals()
a = 10
def func():
	a = 20
    print(a)
    print(globals())    # 查看全局作用域的内容
    print(locals())     # 查看局部作用域的内容
func()

a = 10
def func():
    global a	# 声明我要修改全局的变量a的值
    a = 20
    print(a)
func()
print(a)

n = 1
def func():
    n = 10
    def fun2():
        def func1():
            nolocal n  # 修改离得最近上一次里的变量值 上一层没有就继续往上找，找到全局最外层局部
            n = 100
            print(n)   # 10
        func1()
    func2()
func()
print(n)

# golbal  : 修改全局空间的变量对应的值
# nonlocal: 在外层的函数中，修改局部空间的变量值完全不涉及全局变量。只修改离它最近的一层，最近的一层没有变量继续向上找，直到找到最外层函数。

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

1.9.1可以当做值被赋值给变量

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

1.9.2当做元素存在容器中

def func():
    print(123)
lst = [func,func,func]

for i in lst:
    i()

1.9.3函数名可以当作函数的参数

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

1.9.4函数名可以当作函数的返回值

def func():
    def foo():
        print(123)
    return  foo
res = func()
res()

1.10'f'格式化

python3.6版本及以上才能够使用

1.10.1字符串填充

s = f"你好{'小冯'}"		 # 字符串填充
s1 = F"你好{'常鑫'}"
print(s,s1)

1.10.2填充变量

s1 = f"你还是挺好的{s}"
print(s1)

1.10.3填充计算公式

s1 = f"{35 + 54}"
print(s1)

1.10.4填充表达式

a = 10
b = 20
s1 = f"{a if a>b else b}"
print(s1)

1.10.5填充大括号

s1 = f"{{{{{{'啦啦啦..'}}}}}}"
print(s1)    # {{{'啦啦啦..'}}}

s1 = f"{{}}"
print(s1)    # {}

s1 = f"{'{}{}{}{}{}'}"
print(s1)    # {}{}{}{}{}

1.10.6包含print()

s1 = f"{print(123)}"
print(s1)   # 123 None

1.10.7包含函数

def func(a):
    print(a)
s1 = f"func(123)"    # 123 None

1.10.8包含函数嵌套返回值

def foo():
    def func():
        a = 1
        return a
    return func()
s1 = f"foo()"
print(s1)    # 1

1.10.9包含列表

lst = [1,2,3,4]
s1 = f"lst[0:5]"
print(s1)    # [1,2,3,4]

1.10.10包含字典

dic = {'key1':1,'key2':2}
s1 = f"dic['key1']"
print(s1)    # 1

1.11递归

'''
1. 自己调用自己（不断调用自己本身）  -- 死递归
2. 有明确的终止条件
满足以上两个才是有效递归

递: 一直执行直到碰到结束条件
归: 从结束条件开始往回退

官方声明：最大层次1000，实际测试 998/997
'''

1.宝元  18-2-2-2
2.太白  18-2-2
3.wusir 18-2
4.alex  18

def age(n):
    if n == 4:
        return 18
    else:
        return age(n+1)-2
print(age(1))


def age4(n):
    if n == 4:
        return 18
def age3(n):
    if n == 4: # 问的是不是第四个了
        return 18
    else:
        return age4(n+1)-2
def age2(n):
    if n == 4:  # 问的是不是第四个了
        return 18
    else:
        return age3(n+1)-2
def age1(n):
    if n == 4: # 问的是不是第四个了
        return 18
    else:
        return age2(n+1)-2
print(age1(1))