函数相关的内容

1. 函数的定义与调用

# 1.函数一定要遵循先定义后调用的原则
#         定义函数的代码一定要比调用函数的代码先执行
# 2.函数在定义阶段只检测语法不执行代码
# 3.函数体代码只有在调用函数的时候才会执行
#         调用函数的方式: 函数名加括号  
#       如果有参数则传递参数,如果没有参数,那么就直接括号
# 4.函数名就像变量名一样,是指向的是内存中函数体代码所在的位置

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

 

2. 函数的分类

# 1.内置函数
#     python解释器提前定义好可以直接调用的函数
#       如len、del  
#       如何查看代码的内部源码ctrl+鼠标左键
# 2.自定义函数
#     自定义函数为程序员自己编写的函数
#       2.1.无参函数
#       2.2.有参函数
#       2.3.空函数

# 1. 无参函数:在函数定义阶段,不需要传入任何数据,直接进行调用
# def index():
#     print('python cat')
# 调用无参函数:括号内也不需要写参数
# index()

# 2. 有参函数:在函数定义阶,需要传入数据,那么就在括号内写入你需要传入参数的个数
# def index(name):
#     print('python cat是我的%s' % (name))
# 调用有参函数:在函数调用阶段括号内也必须传对应个数的变量值,就像我们给变量名赋值一样,需要传变量的值

# 3. 空函数:在定义阶段函数体代码,还没有思路进行如何编写或者直接里面不写任何代码时用pass或者...占位
# def index():
#     pass
"""
空函数感觉一点用都没有啊 但是非常有用
    前期能够通过空函数快速的罗列出程序中大致的功能
    让程序整体框架清晰  空函数大量的使用在项目前期的功能框架搭建
注意:编写一套程序
    功能也可以看成是函数 函数也可以看成是功能
"""

 

3. 函数的返回值

# 函数的返回值其实就是在调用函数之后返回的结果
# 如: 此代码表示的是调用len函数,并传入python cat,然后再将len函数的返回值赋值给res,最后输出res
#     s = 'python cat'
#     res = len(s)
#     print(res)

# 如何获取函数的返回值
# 变量名 = 函数名(参数)  # 此参数可以有,可以没有

# 如何操作返回值
# 1.当函数体代码没有return关键字的时候
# 返回值是None
def print_python_cat():
    print('python cat')


res = print_python_cat()
print(res)
# >>>None

# 2.当函数体代码写了return但是没有跟任何值得时候
# 返回值也是None
def print_python_cat():
    print('python cat')
    return


res = print_python_cat()
print(res)
# >>>None

# 3.当函数体代码写了return并且跟了数据
# 那么写什么就返回什么
# 如果写的是值那么直接返回值(任意数据类型)
# 如果写的是变量名那么返回变量名指向的值
def print_python_cat(name):
    print('python cat')
    return name


name = 'python_cat'
res = print_python_cat(name)
print(res)
# python_cat

# 4.return后面还可以跟多个值
# 逗号隔开
# 会自动组织成元组返回出去后
def print_python_cat():
    print('python cat')
    return 'python_cat', 'python cat'


res = print_python_cat()
print(res)
# python_cat', 'python cat'

# 5. 函数体代码遇到return会立刻结束函数运行
# 函数体代码里面写return相当于循环体代码里面写break
# 遇到了就立刻结束函数和循环的执行

 

4. 函数的参数

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

2.形参与实参的关系
    形参类似于是变量名、实参类似于是变量的值
        在调用函数的时候传入实参 会与形参临时绑定
        函数运行结束之后自动解除绑定
"""
def print_python_cat(cat, cat1):  # cat和cat1就是index函数的形参
    print(cat, cat1)
print_python_cat('python_cat', 'python cat')  # python_cat和python cat就是print_python_cat函数的实参
"""
python_cat会临时绑定给形参cat python cat会临时绑定给形参cat1
    函数体代码运行期间 可以通过形参直接使用到实参
    函数体代码运行完毕之后 解除绑定 
    形参ab处于没有绑定值得状态 等待下一次函数调用传入实参进行绑定
"""
# index('python_cat', 'python cat')  # python cat和python_cat就是print_python_cat函数的实参
"""
python_cat会临时绑定给形参cat python cat会临时绑定给形参cat1
    函数体代码运行期间 可以通过形参直接使用到实参
    函数体代码运行完毕之后 解除绑定 
    形参ab处于没有绑定值得状态 等待下一次函数调用传入实参进行绑定
"""
    # 1. 位置形参: 在函数定义阶段括号内从左往右依次填写的变量名
    def print_python_cat(cat, cat1):  # cat和cat1就是位置形参
        pass
    # 位置实参在函数调用阶段括号内从左往右依次传入的真实数据
    print_python_cat('python_cat', 'python cat')  # python_cat和python cat就是位置实参

    # 位置参数的特征
    # 1.位置形参与位置实参在绑定关系的时候就是按照从左往右的顺序依次绑定
    # 2.位置形参与位置实参的个数要一致   多一个不行少一个也不行
    def print_python_cat(cat, cat1):
        print(cat, cat1)  # 外界传入什么实参这里就打印什么


    # print_python_cat()  # 调用的时候不传实参不可以
    # print_python_cat(111)  # 传少了也不行
    print_python_cat(111, 222, 333)  # 传多了也不行

    # 2.关键字形参:出现在实参中  指名道姓的给形参传值 不需要遵循位置

    def print_python_cat(cat,cat1):
        print(cat, cat1)
    print_python_cat(cat=111, cat1=222)  # 指名道姓的说形参a接收数据222 b接收数据111
    print_python_cat(cat=333,222)  # 报错 关键字参数必须放在位置参数的后面
    print_python_cat(222,cat=111)  # 报错 形参只能指向一个实参
    print_python_cat(222,cat1=111)  # 可以 相当于位置参数
        """
        实参222会按照位置绑定给形参a 然后又通过关键字参数给形参a重复绑值
        这种情况是不被允许的!!!
        """

 

5. 默认参数

# 出现在形参中
    # 在函数定义阶段就已经给一些形参赋值了 
  #     后续如果不传值则使用默认的
  #   后续如果传值则使用传入的
    # 默认参数的出现也打破了形参与实参之间个数一致的情况
  # 默认参数必须定义在位置参数的后面  # 至于顺序问题 后面有口诀
"""
默认参数的实际案例
    eg:很多软件的注册页面 默认会帮助我们勾选一些选项
              默认头像
                如果男孩子喜欢使用的软件默认性别可能是男性
                如果女孩子喜欢使用的软件默认性别可能是女性
"""
def register(name, age, gender='猛男'):
    """
    函数的形参在命名的时候也应该见名知意
    """
    print("""
    学员姓名:%s
    学员年龄:%s
    学员性别:%s
    """ % (name, age, gender))
register('jason', 18)  # 不传就使用默认的
register('kevin', 28)
register('jerry',22,'美女')  # 传了就使用自己的

 

6. 可变长参数与可变长形参

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

print_python_cat(999)  
# 会报错  因为形参ab的存在 意味着index最少要给两个参数
print_python_cat(1, 2)  
# 1 2 ()
print_python_cat(1, 2, 3, 4, 5, 6, 7)  
# 1 2 (3, 4, 5, 6, 7)
print_python_cat(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)  
# 1 2 (3, 4, 5, 6, 7, 8, 9, 10)
# 结合print方法 理解*号的含义 暂时不要管self形参
"""
**在形参中
    用于接收多余的关键字参数 并且组织成字典的形式赋值给**后面的变量名
"""
def print_python_cat(a, b, **kwargs):
    print(a, b, kwargs)

print_python_cat(a=1, b=2)  # 1 2 {}
print_python_cat(a=1, b=2, c=3, name='python_cat')  
# 1 2 {'c': 3, 'name': 'python_cat'}
print_python_cat(1, 2, name='python_cat', age=18, pwd='python cat')  
# 1 2 {'name': 'python_cat', 'age': 18, 'pwd': 'python cat'}
'''需求:定义一个函数 无论传入多少关键字参数都可以正常执行'''
def print_python_cat(**kwargs):
    print(kwargs)

print_python_cat()  
# {}
print_python_cat(a=1, b=2)  
# {'a': 1, 'b': 2}
print_python_cat(a=1, b=2, c=3, d=4)  
# {'a': 1, 'b': 2, 'c': 3, 'd': 4}

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

 

7. 补充说明

# *和**不单单可以在形参中使用 还可以在实参中使用
def print_python_cat(*args, **kwargs):
    print(args, kwargs)


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

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

"""
**号在实参中
    可以将字典打散成关键字参数一一传入
def index(**{'name':'jason'})  等价于  index(name='jason')
"""
print_python_cat(**{'name': 'python_cat', 'age': 18, 'pwd': 'python cat'})
# () {'name': 'python_cat', 'age': 18, 'pwd': 'python cat'}
print_python_cat({'name': 'python_cat', 'age': 18, 'pwd': 'python cat'})
# ({'name': 'python_cat', 'age': 18, 'pwd': 'python cat'},) {}