python函数篇

一、函数定义：

　　1、函数的命名规则和变量名命名一模一样；(不能以关键字)

　　　　变量：可以通过变量名找到变量对应的值

　　　　函数:可以通过函数名+括号，找到函数体所对应的代码并执行

　　2、函数就是工具，并且函数必须先定义后调用（函数名+括号）

　　3、固定格式：

　　　　def + 函数名 + (形参1，形参2，...):

　　　　　　"""  函数的注释，用来描述该函数的作用以及各个形参的类型  """

　　　　　　函数代码1

　　　　　　函数代码2

　　　　　　...

　　　　　　return 函数的返回值  

　　　　　　（代码中遇到函数名加括号，优先级最高

　　　　　　先去执行函数，再看下面的代码）

　　4、函数的返回值 return：

　　　4.1

　　　　函数内要想返回给调用者值 必须用关键字return

　　　　不写return:函数默认返回None

　　　　只写return:return除了可以返回值之外 还可以直接结束整个函数的运行

　　　　只写return 返回的也是None(None就表示什么都没有)

　　　　写return返回一个值：这个值可以是python任意数据类型

def func():
    return '123'
def func1():
    return [1,2,3]
def func2():
    return {'name':'jason'}
def func3():
    return (1,)
def func4():
    return {1,2,3,4,5}
def func5():
    return True
print(func(),func1(),func2(),func3(),func4(),func5())
#123 [1, 2, 3] {'name': 'jason'} (1,) {1, 2, 3, 4, 5} True

　　　　写return返回多个值:return会自动将多个值以元组的形式返回给调用者

　　　　ps ： 返回多个值 并且不想让return帮你做处理 自己手动加上你想返回的数据类型符号

def func():
    return [[1,2,3,4],[1,2,3,4],[1,2,34]]
res = func()
print(res)  # [[1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 34]]

　　　4.2

　　　　1.所有的函数都有返回值,无论你写不写return

　　　　　python中所有的函数都有返回值 不写的情况下默认返回None

　　　　2.光写return 或者return None并不是为了考虑返回值 而是为了结束函数的运行

二、函数的参数概要：

　　1、函数参数两大类型

　　　　形参：在函数的定义阶段 括号内写的变量名 叫做该函数的形式参数     简称 形参

　　　　实参：在函数的调用阶段 括号内实际传入的值 叫做实际参数       简称 实参

　　　　两者关系：

　　　　　　形参就相当于变量名,而实参就相当于变量的值

　　　　　　函数调用传参的过程 就是给形参变量名赋值的过程

　　　　注意:形参和实参的绑定关系只在函数的调用阶段有效，函数运行结束关系自动解除。

　　　　　　只在函数内部有效，函数外部无任何影响。

　　2、位置参数、默认值参数和可变长参数
　　　2.1位置参数
　　　　ps ：在调用函数的时候，少一个实参和多一个实参都不行
　　　　三种传参方式：
　　　　　　直接按照位置传，一一对应
　　　　　　指名道姓传  >>>: 关键字传参
　　　　　　位置和关键字混合使用
　　　　注意：
　　　　　　在函数调用阶段，位置参数和关键字参数可以混合使用，但必须保证两点：
　　　　　　　　1.位置参数必须在关键字参数的前面（越短越靠前，越长越复杂越靠后）
　　　　　　　　　 2.同一个形参不能被多次赋值

　　　　2.2 默认值参数    定义默认参数要牢记一点：默认参数必须指向不变对象！

　　　　　默认值参数:在函数的定义阶段,形参(变量名)就已经被赋值了

　　　　　在调用的时候可以不为默认值形参传值,默认使用定义阶段就已经绑定的值

　　　　　在调用的时候如果可以给默认值形参传值 传了那么就使用你传的值

　　　　2.3 可变长参数

　　　　　　*和**来接收多余的(溢出的)位置参数和关键字参数

　　　　　　形参  

　　　　　　　　*  会接收多余的(溢出的)位置实参，统一用元组的形式处理，赋值传递给*后面的变量名

　　　　　　　　* * 会接收所有多余的关键字参数，并将关键字参数转换成字典的形式，字典的key就是关键字的名字

　　　　　　　　　字典的value就是关键字的名字指向的值 将字典交给**后面的变量名

　　　　　　实参  （* 只能将列表 元组 集合 字符串打散 ，内部可以看成是for循环）

　　　　　　　　* 会将列表打散成位置实参

　　　　　　　　* * 会将字典拆封成 key = value的形式　　　　　

"""
注意python推荐形参*和**通用的写法
"""
def func2(*args,**kwargs):
    print(args,kwargs)
func2(1,2,3,4,5,6,x=1,y=2,z = 3)
# (1, 2, 3, 4, 5, 6) {'x': 1, 'y': 2, 'z': 3}

 三、定义函数的三种方式：

　　1.空函数：可以快速帮助你构建项目框架，是项目架构清晰明了

　　　　应用频率非常高　　

　　　　　　购物车功能　　

 

def register():
    pass
def login():
     pass
 def shopping():
    pass
def pay():
    pass    

 

　　2.无参函数：

def func():
    print('from func')

　　3.有参函数：

def func(x,y,*args,**kwargs):
     pass

 

四、函数对象：

　　1、函数名可以被传递

　　2、函数名可以被当做参数传递给其他函数

def func():
    print('from func')

def index(args):
    print(args)
    args()
    print('from index')
# index(1) # 因为args() 会报错
index(func)
'''
输出结果
<function func at 0x00000000005D1E18>
from func
from index
'''

　　3、函数名可以被当做函数的返回值　　

def index():
    print('index')

def func():
    print('func')
    return index
res = func()
print(res)
res()

'''
输出结果
func
<function index at 0x0000000002081E18>
index
'''

　　4、函数名可以被当做容器类型的参数

def func():
    print('func')
print(func())   # 输出  func   None
l = [1,2,func,func()]  
print(l)  #输出 [1,2,<function func at 0x000001F7D79899D8>,None]

　　ps：循环打印项目功能提示信息 供用户选择 用户选择谁就执行谁

def register():
    username = input('username>>>:').strip()
    pwd = input('password>>>:').strip()
    print(username,pwd)
    print('register ...')
def login():
    print('login ...')
def transfer():
    print('transfer ...')
def shopping():
    print('shopping...')
def pay():
    print('pay ...')

msg = """
1 注册
2 登陆
3 转账
4 购物
5 支付
"""
func_dict = {
    '1':register,
    '2':login,
    '3':transfer,
    '4':shopping,
    '5':pay,
}
while True:
    print(msg)
    choice = input('请现在你想要执行的功能>>>:').strip()
    if choice in func_dict:
        func_dict.get(choice)()  # 函数名()

 

五、函数的嵌套

　　调用：

　　在函数内部调用其他函数，可以将复杂的逻辑简单化

　　例：比大小

def my_max(x,y):
    if x > y:
        return x
    return y

def my_max4(a,b,c,d):
    res1 = my_max(a,b)
    res2 = my_max(res1,c)
    res3 = my_max(res2,d)
    return res3
print(my_max4(1,2,10,4))

　　嵌套定义：

def outer():
    x = 1
    print('outer')
    def inner():
        print('inner')

    return inner

res = outer()  # res 接受的是innerr()函数的空间地址（函数对象）
print(res())
res()
'''
输出结果
outer
inner
None
inner
'''

　　名称空间：

　　　1.定义：

　　　　1.内置名称空间:python解释器提前给你定义好的名字(已经存放到内置名称空间中了)

　　　　2.全局名称空间:文件级别的代码

　　　　　　ps：if for while 无论嵌套多少层 它们内部所创建的名字都是全局名称空间的

　　　　3.局部名称空间:函数体内创建的名字都属于局部名称空间

　　　2、ps：查找顺序：

　　　　 需要先确定你当前在哪(大前提)

　　　　1.站在全局: 全局 >>> 内置

　　　　2.站在局部: 局部 >>> 全局 >>> 内置

　　　3.作用域

　　　　global:局部修改全局 如果想修改多个 逗号隔开 /    nonlocal:局部修局部 如果想修改多个 逗号隔开

　　　　global 在局部修改全局的

# x = []  # 因为列表是可变类型
x = 1  # 不可变类型
username = 'jason'
def func():
    # x.append('嘿嘿嘿')
    global x,username  # 修改全局变量 而不是创建局部名称空间
    x = 999
    username = 'egon'
func()
print(x)        #  输出  999   
print(username)   # 输出  egon

　　　　nonlocal 局部修改局部

def func():
    x = 1
    def index():
        nonlocal x
        x = 2
    index()
    print(x)   #  输出 2
func()

 

　　生命周期：

　　　　内置名称空间:只要python解释器已启动立马创建 关闭python解释器的时候内置名称空间自动销毁

　　　　全局名称空间:只要你右键运行py文件会自动创建 py文件程序运行结束自动销毁

　　　　局部名称空间:函数被调用的时候自动创建 函数指向结束立即销毁(动态创建动态销毁)