函数

函数定义与调用

1先定义后调用

2定义阶段不执行代码

3调用函数才会执行代码 （调用的时候一定要在函数名后加括号，若有参数，则传递参数）

4函数名就相当于变量名指向的是内存中的函数代码所在的位置

func()  # 报错  name 'func' is not defined
# 定义函数
def func():
    print('hello world')
# 调用函数
# func()  就是去内存中找到函数体代码并执行

函数的分类

内置函数

python解释器提前定义好可以直接调用的函数

eg:len、open... # 如何查看代码的内部源码ctrl+鼠标左键
2.自定义函数
程序员自己编写的函数
2.1.无参函数
2.2.有参函数
2.3.空函数

# 无参函数:在函数定义阶段括号内没有参数
 def index():
     print('色即是空 空即是色')
# 调用无参函数:括号内也不需要写参数
 index()

# 有参函数:在函数定义阶段括号内有参数>>>:类似于变量名
 def index(a):
      print('嘿嘿嘿 妹纸有事冲我来',a)
 调用有参函数:在函数调用阶段括号内也必须传参数>>>:类似于变量值
 index(123)

# 空函数:在定义阶段函数体代码是用pass或者...占位
 def index():
     pass
"""
空函数感觉一点用都没有啊 但是非常有用
    前期能够通过空函数快速的罗列出程序中大致的功能
    让程序整体框架清晰  空函数大量的使用在项目前期的功能框架搭建
eg:编写一套钢铁侠程序
    功能也可以看成是函数 函数也可以看成是功能

def fight():
    pass
def run():
    pass
def study():
    pass
def communication():
    pass

函数的返回值

 如何操作返回值
  1.当函数体代码没有return关键字的时候 返回值是None
      def index():
        print('春困秋乏夏打盹儿')
    res = index()
    print(res)  # None
  2.当函数体代码写了return但是没有跟任何值得时候 返回值也是None
      def index():
        print('春困秋乏夏打盹儿')
        return 
        res = index()
        print(res)  # None
  3.当函数体代码写了return并且跟了数据 那么写什么就返回什么
          如果写的是值那么直接返回值(任意数据类型)
        如果写的是变量名那么返回变量名指向的值
      def index():
        print('春困秋乏夏打盹儿')
        name = 'jason'
        return name
    res = index()
    print(res)  # jason
  4.return后面还可以跟多个值 逗号隔开  会自动组织成元组返回出去后
        def index():
        print('春困秋乏夏打盹儿')
        return 111,'jason',222
    res = index()
    print(res)  # (111,'jason',222)
  5.函数体代码遇到return会立刻结束函数运行
      函数体代码里面写return相当于循环体代码里面写break
    遇到了就立刻结束函数和循环的执行

函数的参数（重要）

1.函数的参数可以分为两大类
      1.函数在定义阶段括号内写的参数
             我们称之为'形式参数' 简称为>>>:形参
        2.函数在调用阶段括号内写的参数
            我们称之为'实际参数' 简称为>>>:实参

2.形参与实参的关系
          形参类似于是变量名、实参类似于是变量的值
         在调用函数的时候传入实参 会与形参临时绑定
         函数运行结束之后自动解除绑定

def index(a,b):  # a和b就是index函数的形参
    print(a,b)
# index(1,2)  # 1和2就是index函数的实参

1会临时绑定给形参a       2会临时绑定给形参b
    函数体代码运行期间 可以通过形参直接使用到实参
    函数体代码运行完毕之后 解除绑定 
    形参ab处于没有绑定值得状态 等待下一次函数调用传入实参进行绑定

m = 1000
n = 9999
index(m,n) # 将变量名m、n指向的1000、9999临时绑定给形参ab

位置参数

位置形参
    在函数定义阶段括号内从左往右依次填写的变量名
      def index(name,pwd):  # name和pwd就是位置形参
      pass

位置实参
    在函数调用阶段括号内从左往右依次传入的真实数据
      index('jason',123)  # jason和123就是位置实参
  
位置参数的特征
    1.位置形参与位置实参在绑定关系的时候就是按照从左往右的顺序依次绑定
  2.位置形参与位置实参的个数要一致 多一个不行少一个也不行

关键字参数

在形参中，经常使用的值设为默认，不传新的值就不改，传入就更改
比如这款软件大部分使用的是男生，输入性别默认男
（默认参数也打破了形参与实参之间个数一致的情况，默认参数必须定义在位置参数后面）

def register(name, age, gender='猛男'):
    """
    函数的形参在命名的时候也应该见名知意
    """
    print("""
    学员姓名:%s
    学员年龄:%s
    学员性别:%s
    """ % (name, age, gender))
register('jason', 18)  # 不传就使用默认的
register('kevin', 28)
register('jerry',22,'美女')  # 传了就使用自己的

可变长参数（重要）

"""需求:定义一个函数 无论传多少位置实参都可以正常执行"""
def func(*a):              #（*只能传值）
    print(a)
func()  # ()
func(1,2)  # (1, 2)
func(1,2,3,4,5,6)  # (1, 2, 3, 4, 5, 6)
"""
*号在形参中
    可以接收多余的位置参数 并组织成元组的形式赋值给*号后面的变量名
"""


def index(a, b, *ag):
    print(a, b, ag)
index(999)  # 会报错  因为形参ab的存在 意味着index最少要给两个参数
index(1, 2)  # 1 2 ()
index(1, 2, 3, 4, 5, 6, 7)  # 1 2 (3, 4, 5, 6, 7)
index(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)  # 1 2 (3, 4, 5, 6, 7, 8, 9, 10)
# 结合print方法 理解*号的含义 暂时不要管self形参

**在形参中
    用于接收多余的关键字参数 并且组织成字典的形式赋值给**后面的变量名
"""
def index(a, b, **k):
    print(a, b, k)
index(a=1, b=2)  # 1 2 {}
index(a=1, b=2, c=3, name='jason')  # 1 2 {'c': 3, 'name': 'jason'}
index(1,2,name='jason',age=18,pwd=123)  # 1 2 {'name': 'jason', 'age': 18, 'pwd': 123}
'''需求:定义一个函数 无论传入多少关键字参数都可以正常执行'''
def func(**k):
    print(k)
func()  # {}
func(a=1,b=2)  # {'a': 1, 'b': 2}
func(a=1,b=2,c=3,d=4)  # {'a': 1, 'b': 2, 'c': 3, 'd': 4}

可变长形参

"""
思考题:如何定义一个无论接收多少个任意类型的参数都可以正常执行的函数
"""
def func(*a,**k):
    print(a,k)
func()  # () {}
func(1,2,3,4,name='jason',age=18)  # (1, 2, 3, 4) {'name': 'jason', 'age': 18}
# 以后在定义函数的时候 如果不确定这个函数将来需要多个实参 那么可以采用上述的方法
"""*和**在形参中的使用 后面的变量名并不是关键 但是针对这两个特殊符号后面的变量名 有推荐的写法"""
def index(*args, **kwargs):
    pass

补充说明(重要)

*号在实参中 
    可以将列表或者元组打散成位置参数一一传入
def index(*[11,22,33])  等价于 index(11,22,33)
def index(*(11,22,33))  等价于 index(11,22,33)
如果真的理解不了 可以看成是*号会将列表和元组的括号去除 暴露出里面一个个元素
"""
# index(*['jason', 'kevin', 'tony', 'oscar', 'jerry'])  # ('jason', 'kevin', 'tony', 'oscar', 'jerry') {}
# index(*('jason', 'kevin', 'tony', 'oscar', 'jerry'))  # ('jason', 'kevin', 'tony', 'oscar', 'jerry') {}
# index(['jason', 'kevin', 'tony', 'oscar', 'jerry'])  # (['jason', 'kevin', 'tony', 'oscar', 'jerry'],) {}   直接传入不带*号，直接只有一个元素

# print(*[1,2,3])  # print(1,2,3)

**号在实参中
    可以将字典打散成关键字参数一一传入          **号会将列表和元组的括号去除 暴露出里面一个个元素

def index(**{'name':'jason'}) 等价于 index(name='jason') """ index(**{'name':'jason','age':18,'pwd':123}) #  {'name': 'jason', 'age': 18, 'pwd': 123} 
index({'name':'jason','age':18,'pwd':123}) # ({'name': 'jason', 'age': 18, 'pwd': 123},) {}        直接传入不带**号，直接只有一个元素