Python 函数基础详解

将一段具有功能性的代码进行封装，封装到函数中，在哪里实现代码，只需调用当前函数即可。
优点：1.降低代码的冗余量  
   2.提高代码的可读性  
   3.增加代码的重用性

1. 内置函数：python解释器封装好的，直接进行使用函数
  print()   input()  max()   len()   del()  min()   sum()
2. 自定义函数：程序员根据自己程序的需求编写的函数

# 定义函数
# 语法格式：
# def 函数名(参数):
#     代码块
# 注意：参数可有可无，根据程序的需求决定是否传参
def func():
  # 函数的声明文档在函数名下以三引号包裹的形式定义
    '''打印 hello wrold '''
    print("hello world")
# 调用func函数
# 语法：函数名(参数)
# 注意：参数可有无可，根据程序的需求决定是否传参
func()
# 获取函数的声明文档   help(函数名)
help(func)

# 在全局和局部定义相同名字的变量，不产生任何冲突，也不会实现值的覆盖
# 全局变量：定义在函数外，在函数外和函数内都能使用
a = 1
def func():
    # 局部变量：定义在函数内，只能在函数内使用，不能在函数外使用
    # 实现修改全局变量  global 变量名   换行实现对变量进行重新复制
    global a
    a = 2
    print(a)
print(a)
func()
print(a)

# 定义函数，函数的功能实现任意两个数字进行求和
# 函数参数分类：
# 形参：形式上的参数，在定义函数时传递形参(变量名)
# 实参：实际上的参数，在调用函数时传递实参(变量值)
def func1(a,b):
    # 函数会对形参进行操作，不会直接使用实参
    print(f"求和的结果为：{a+b}")
func1(5,6)

# 位置参数：形参与实参数量和位置一一对应
def func(a,b):
    print(a+b)
func(5,6)

# 关键字参数：在传递实参时以键=值的形式传递,多个关键字参数之间可以互相打乱顺序
def func(height,weight):
    print(f"我的身高{height}，我的体重{weight}")
    
func(weight=180,height=175)

# 既有位置参数又有关键字参数，位置参数一定要放在关键字参数之前，否则报错
def func(name,age,gender,height,weight):
    print(f"我的名字叫{name}，我的年龄{age}，我的性别{gender}，我的身高{height}，我的体重{weight}")
    
func("张三",18,"男",weight=180,height=175)

# 缺省参数：在传递形参时以键=值的形式传递
# 如果给当前缺省参数传递了实参，直接使用实参的值；如果没有指定实参则使用默认指定的值
def func(name,age,height,weight,gender="男"):
    print(f"我的名字叫{name}，我的年龄{age}，我的性别{gender}，我的身高{height}，我的体重{weight}")
    
func("张三",18,180,175,"女")

# 不定长位置参数:*args,*接收所有的位置参数，存放在args这个元组里
def func(*args):
    print(sum(args))
    
func(1,4,5,9,6,3,2,8,7,10)

# 不定长关键字参数：**kwargs,**接收所有的关键字参数，存放kwargs这个字典里
def func(**kwargs):
    print(kwargs)
    
func(name="张三",age=18,gender="保密",height=190,weight=150,phone=110,address="北京警局")

# 既有位置参数又有关键字参数，位置参数要放在关键字参数之前
def func(*args,**kwargs):
    print(args)
    print(kwargs)
    
func("张三",18,"男",height=190,weight=150,phone=110,address="北京警局")

# 函数的返回值
# 语法：return 值
# 如果想要获取函数的返回值    print(调用函数)
# 定义一个函数，函数实现对任意两个数字进行求和
def func(a,b):
    c = a+b
    # print(f"求和的结果为：{c}")
    return c
# 想要获取函数的返回值   print(调用函数)
print(func(5,6))

# 函数返回值
# 1.函数返回一个值   return 值
def func1(a):
    return a**2
print(func1(10))
# 2.函数返回多个值   return 值1,值2,值3……    多个返回值会被存放在元组中展示
def func2(a):
    return a**2,a**3,a*2,a*3
print(func2(10))
# 3.函数返回None  1>.return None   2>.return    3>.不写return
def func3():
    pass
print(func3())
# 4.函数返回函数--->此处涉及到闭包知识点
def outer():
    def inner():
        pass
    return inner

# return关键字作用
# 1.将值返回
# 2.结束函数
# 函数功能实现返回数字1-10
def func():
    for i in range(1,11):
        return i
print(func())

# 1.无参数无返回值的函数
def func():
    print("无参数无返回值的函数")
func()
-------------------------------
# 2.无参数有返回值的函数
def func2():
    return "无参数有返回值的函数"
print(func2())
--------------------------------
# 3.有参数无返回值的函数
def func3(a):
    print(f"有参数无返回值的函数，参数为：{a}")
func3(10)
-----------------------------------------
# 4.有参数有返回值的函数
def func4(x):
    return f"有参数有返回值的函数，参数为：{x}"
print(func4(6))

# 对字符串类型的数据进行拆包
a,b,c,d,e = "hello"
print(a)    # h
# 对列表类型的数据进行拆包
list1,list2 = [1,2]
print(list2)   # 1
# 对元组类型的数据进行拆包
tuple1,tuple2 = ("hello","world")
print(tuple2)   # "hello"
# 对字典类型的数据进行拆包-->字典拆包的结果是键
dict1,dict2 = {"name":"张三","age":18}
print(dict2)   # "age"

dict3 = {"name":"李四","age":16,"gender":"女"}
# 获取字典的键值对--->多个临时变量接收数据就是在执行拆包操作
for i,j in dict3.items():
    print(i)
# 定义一个函数，任意传递一个整数，函数返回值  平方、立方、2倍数、3倍数
def func(x):
    return x**2,x**3,x*2,x*3
a,b,c,d = func(10)

a = 10
b = 20
# 第一种方式：借助第三个变量
c = a   # c=10
a = b   # a=20
b = c   # b=10
print(a,b)
# 第二种方式：一次性定义多个变量
a,b = b,a
print(a,b)

1 1 2 3 5 8 13 21 34 55 ……
规律：前两个数的和是下一个数的值
定义斐波那契注意：1.必须要有两个初始值  2.满足a,b=b,a+b
一开始    a = 1    b = 1    a+b=2
第一次    a=b=1    b = 2    a+b=3
第二次    a = 2    b = 3     5
综上所述:
斐波那契的规则：a,b = b,a+b
-------------------------------------------
# 输出10个斐波那契数
x = 0
y = 1
for i in range(10):
    x,y = y,x+y
    print(x)

# 枚举函数
# enumerate()
# 语法：enumerate(可迭代对象,start)
# 作用：获取可迭代对象中的每一个数据及对应的序号；序号不指定默认从0开始，可以充当下标；序号通过start参数进行修改
str1 = "hello"
ret = enumerate(str1,start=100)
for i,j in ret:
    # 如果只有一个临时变量，临时变量i接受一个元组  (序号,数据)
    # 如果有两个临时变量，i接收所有的序号，j接收所有的数据(涉及到拆包)
    print(i,j)

# for……else
# for循环正常执行结束则执行else中的代码
for i in range(5):
    if i == 4:
        break
    else:
        print(i)
else:
    print("哈哈哈哈哈")