函数

函数的介绍

# python中的函数
# 函数的定义
# 打印一个佛祖镇楼 -> 一个功能点的解释
def print_info():
    print("测试")
    print("                            _ooOoo_  ")
    print("                           o8888888o  ")
    print("                           88  .  88  ")
    print("                           (| -_- |)  ")
    print("                            O\\ = /O  ")
    print("                        ____/`---'\\____  ")
    print("                      .   ' \\| |// `.  ")
    print("                       / \\||| : |||// \\  ")
    print("                     / _||||| -:- |||||- \\  ")
    print("                       | | \\\\\\ - /// | |  ")
    print("                     | \\_| ''\\---/'' | |  ")
    print("                      \\ .-\\__ `-` ___/-. /  ")
    print("                   ___`. .' /--.--\\ `. . __  ")
    print("                ."" '< `.___\\_<|>_/___.' >'"".  ")
    print("               | | : `- \\`.;`\\ _ /`;.`/ - ` : | |  ")
    print("                 \\ \\ `-. \\_ __\\ /__ _/ .-` / /  ")
    print("         ======`-.____`-.___\\_____/___.-`____.-'======  ")
    print("                            `=---='  ")
    print("  ")
    print("         .............................................  ")
    print("                  佛祖镇楼                  BUG辟易  ")
    print("          佛曰:  ")
    print("                  写字楼里写字间，写字间里程序员；  ")
    print("                  程序人员写程序，又拿程序换酒钱。  ")
    print("                  酒醒只在网上坐，酒醉还来网下眠；  ")
    print("                  酒醉酒醒日复日，网上网下年复年。  ")
    print("                  但愿老死电脑间，不愿鞠躬老板前；  ")
    print("                  奔驰宝马贵者趣，公交自行程序员。  ")
    print("                  别人笑我忒疯癫，我笑自己命太贱；  ")
    print("                  不见满街漂亮妹，哪个归得程序员？")
a = 10
if a == 10:
    # print_info()
    pass  # 占位符，防止语法错误

# num = 1
# if num == 1:
    # print_info()

# my_str = "hello"
# if my_str == "hello":
    # print_info()

# 函数 - > python

函数的定义和调用

# 使用函数分为两步
'''第一步：定义函数'''
# def -> define 定义
# 格式：def 函数名():
#           执行的代码01
#           执行的代码02
#           执行的代码03...
def my_func():
    print("hello python")
'''第二步：函数的调用(执行)'''
# 格式：函数名()
my_func()

函数的参数(一)

# 利用函数来完成
# 函数的定义
def my_func1():
    num1 = 1
    num2 = 2    # 定义两个变量
    ret = num1 +num2
    print(ret)  # 打印
my_func1()      # 函数调用

def my_func2():
    num1 = 90
    num2 = 9    # 定义两个变量
    ret = num1 +num2
    print(ret)  # 打印
my_func2()

# 合二为一
# 定义一个有参数的函数
# 形参：形式参数
# 格式：def 函数名(形参1,形参2,...)
def my_func3(a, b):
    ret = a + b  # 求和
    print(ret)   # 打印

# 执行一个有参数的函数
# 实参：实际参数
# 格式： 函数名(实参1,实参2,...)
my_func3(15, 6)  # 执行一个有参数的函数
num1 = 15
num2 = 6
# 在执行函数的时候就好比是a=num1,b=num2
my_func3(num1, num2)

# 通过一个函数 打印一句话 无论输入什么字符串，最终格式：你好xx
def my_func(name):
    print("你好%s" % name)
    print("你好%s" % name)
    print("你好%s" % name)

my_func("小红")

函数的返回值

# 等号右侧的值返回给了a
# 叫a 记录这个20的值
# a = 10 + 10
# print(a)

# python中学习了一个内置函数len(object)
# 内含子函数如何实现

my_str = "hello"    # 定义一个字符串
def my_len(object):
    ret = 0
    for i in object:  # 猜测
        ret += 1

    # 如果有一个return数值，成为这个函数的返回值
    return ret

my_1 = my_len(my_str)
print("自定义的:", my_1)  # 输出：None  ->返回值 空值类型

# my_len(my_str)  # 输出：5

l = len(my_str)
print(l)  # 输出：1

# 定义一个函数
def add2num(a,b):
    ret = a + b
    return ret
num = add2num(10,11)
print(num)

# 定义一个变量，记录圆周率
pi = 3.1415926
# 我想在执行一个函数的时候,给我圆周率
def my_pi():
    return 3.1415926
ret =my_pi()
print(ret)

函数的类型(4种)

'''
函数根据有没有参数，有没有返回值，可以相互组合，一共有4种
1、无参数，无返回值
2、无参数，有返回值
3、有参数，无返回值
4、有参数，有返回值'''

# 1、无参数，无返回值
def my_print():
    print("你好")
    print("python")
# 执行函数
my_print()

# 2、无参数，有返回值
def my_pi():
    return 3.1415926
print(my_pi())

# 3、有参数，无返回值
def print_info(name):
    print("你好%s" % name)
print_info("马老师")       # 输出：你好马老师

def print_info(name):
    print("你好%s" % name)
name_list = ['高老师','小明','小红','张三']
for new_name in name_list:
    # print(new_name)
    print_info(new_name)

# 4、有参数，有返回值
def my_finc(a,b):
    # ret = a + b
    # return ret
    return a + b  # 优化简写
result = my_finc(10,5)
print(result)

函数的嵌套和使用

# def my_func1():
#     print("my_func1开始")
#     print("my_func1结束")
# print("开始测试")
# my_func1()
# print("测试")
'''  《输出》
开始测试
my_func1开始
my_func1结束
测试'''

def my_func1():
    print("my_func1开始")
    print("my_func1结束")
def my_func2():
    print("my_func2开始")
    my_func1()
    print("my_func2结束")
my_func2()
print("测试")
'''《输出》
my_func2开始
my_func1开始
my_func1结束
my_func2结束
测试
'''

函数的应用：打印图形和数字计算

# 1、写一个函数打印一条横线
def print_one_line():
    print("-"*10)
# print_one_line()          # 调用函数

# 2、打印自定义行数的横线
def print_lines(num):
    for i in range(num):     # for 循环
        print_one_line()      # 执行函数pring_one_line
print_lines(5)                  # 最终执行print_lines

# 3、写一个函数求三个数的和
def add3num(a, b, c):
    return a + b + c
# ret = add3num(10, 20, 30)
# print(ret)

# 4、写一个函数求三个数的平均值
def average3num(num1, num2, num3):
    # 求num1+num2+num3
    # ret = num1 + num2 + num3
    # 通过求和函数完成
    ret = add3num(num1, num2, num3)
    # 把和除以3
    return ret / 3
result = average3num(10, 20, 30)
print(result)

调用函数：位置参数

# 定义一个函数
def my_func(a, b):
    print(a + b)

# 函数调用  -> 位置参数调用函数
# 使用当前位置参数调用函数需要注意当前实参的位置
# 实参的位置和当前形参的位置要一一对应
# 如果实参传入的少一个，会报错
# TypeError: my_func() missing 1 required positional argument: 'b'
my_func(10, 11)

调用函数：关键字函数

# 定义一个函数
# python是一个弱类型
def my_print(name, age):
    print("我的名字:%s" % name)
    print("我的年龄:%d" % age)
# 调用 ->位置参数
my_print("小明", 20)

# 关键字参数
# 调用函数的时候使用的是函数的形参名
my_print(name="老王", age=32)
# my_print(age=32, name="老王")  #不在乎顺序

# 调用函数的时候使用了位置和关键字参数混合
my_print("小马", age=30)
# 如果混合使用，需要让位置参数在前，关键字参数在后面
# my_print(age=30, "小马" )  # 会报错
# 如果某个参数使用了关键字参数，后面的都需要使用关键字参数

函数参数(二)：缺省参数

# 定义一个函数 （名字 学号 年龄）
def my_print(name, no, age):
    print("名字:%s" % name)
    print("学号:%s" % no)
    print("年龄:%d" % age)
    print("="*10)
# 小明 001 20
# 小红 002 20
# 小张 003 20
my_print("小明", "001", 20)
my_print("小红", "002", 20)
my_print("小张", "003", 20)

# 或者下面写法
# 定义一个有缺省参数的函数
#缺省函数：给形参设置了一个默认值
def my_print(name, no, age=20):
    print("名字:%s" % name)
    print("学号:%s" % no)
    print("年龄:%d" % age)
    print("="*10)
# 在调用函数的时候，如果有默认值，可以根据业务需求不传递
my_print("小明", "001")
my_print("小红", "002")
my_print("小张", "003")

# 假如这个my_print的函数打印全班人的信息，有80%是20岁，但是20%年龄是25-30岁之间
# 如果执行函数时提供实参那么函数的形参使用实参
# 如果执行函数的时候没有提供实参那么形参讲使用默认值(缺省参数)
my_print("老王", "010" ,30)

# 在定义函数的时候，某个形参使用了缺省参数，那么后面的形参都需要用缺省参数
def my_print(name, age=20, no="001"):
    print("名字:%s" % name)
    print("学号:%s" % no)
    print("年龄:%d" % age)
    print("="*10)

函数的返回值：多个return

# 定义一个函数，当执行函数的时候，传入一个分数，可以返回一个字符串(优 良 中 差)
# 包含多个return
def my_func(score):
    # 对分数进行判断
    if score >= 90:
        return "优"
    elif score >= 80:
        return "良"
    elif score >= 60:
        return "中"
    elif score >= 0:
        return "差"
    print("测试")  # 它不会执行，因为在第11行已经执行了return
ret = my_func(89)
print(ret)        # 输出：良

def my_func1():
    print("开始")
    # 只要函数中执行了return就提前结束函数的执行，而且return后面的代码将不再执行
    return "3.14"
    print("开始1")
    return  "20"
    print("结束")
# my_func1()
ret = my_func1()
print(ret)
print("测试")
'''《输出》
开始
3.14
测试
'''

python中return使用总结

# return总结

# <1>作为函数的返回值
# <2>执行的额函数提前结束(为了提高性能)
# 包含多个return
def my_func(score):
    if score < 0:
        print("您传入的分数有误!!!")
        return   # 函数的执行提前结束
    print("测试")
    # 对分数进行判断
    if score >= 90:
        return "优"
    elif score >= 80:
        return "良"
    elif score >= 60:
        return "中"
    elif score >= 0:
        return "差"

# 需求：如果调用函数的人传入的分数为0，那么就认为传入的错误，告知函数的调用着
my_func(-10)  # 您传入的分数有误!!!

函数的返回值：函数返回多个数据

# 需求：传入一个名字 年龄
# 例如 小明 22
# 通过调用函数后，得到两个字符串 姓名：小明 年龄：22
def deal_name_age(name, age):
    # 处理后 姓名:小明 年龄:22
    new_name = "姓名:%s" % name
    new_age = "年龄:%d" % age
    print(new_name)
    print(new_age)
    return
deal_name_age("小明", 22)

# 假如是列表
def deal_name_age(name, age):
    # 处理后 姓名:小红 年龄:23
    new_name = "姓名:%s" % name
    new_age = "年龄:%d" % age
    # print(new_name)
    # print(new_age)
    return[new_name, new_age]
# 变量为列表
ret = deal_name_age("小红", 23)
print(type(ret))
print(ret[0])
print(ret[1])

# 假如字典
def deal_name_age(name, age):
    # 处理后 姓名:小章 年龄:24
    new_name = "姓名:%s" % name
    new_age = "年龄:%d" % age
    return{"name": new_name, "age": new_age}
my_dict = deal_name_age("小章",24)
print(my_dict["name"])
print(my_dict["age"])

# 假如元祖
def deal_name_age(name, age):
    # 处理后 姓名:小章 年龄:24
    new_name = "姓名:%s" % name
    new_age = "年龄:%d" % age
    # 如果在函数内部使用return，返回值1 返回值2，...默认就是元祖类型
    return new_name, new_age
my_tuple = deal_name_age("小李",25)
print(type(my_tuple))
print(my_tuple[0])
print(my_tuple[1])

拆包

# 拆包
# 定义一个列表
# my_list = [1, 3.14, "hello", True]
# 可以获取列表中元素的值，但是读性不强
# print(my_list[1])
# print(my_list[2])

# 拆包
# num, pi, my_str, my_bool = my_list
# print(pi)
# print(my_bool)
# num, pi, my_str, my_bool = [1, 3.14, "hello", True]

# 定义一个元祖
my_tuple = (1, 3.14, "hello", True)
# um, pi, my_str, my_bool = my_tuple
# print(pi)

# 定义一个字典
my_dict = {"name":"老王","age":19}
ret1, ret2 = my_dict
# 得到的是key 字典是无序的
print(ret1, ret2)

# 一次定义多个变量
num1 = 10
num2 = 20
num3 = 30
num4 = 40
# 称之为比较python自夸
# 变量名和值是一一对应的
num1, num2, num3, num4 = 10, 20, 30, 40
print(num1)

# 思考：下面这个可以拆包吗？
def deal_name_age(name, age):
    # 处理后 姓名:小章 年龄:24
    new_name = "姓名:%s" % name
    new_age = "年龄:%d" % age
    # 如果在函数内部使用return，返回值1 返回值2，...默认就是元祖类型
    return new_name, new_age
# 拆包：
my_name, my_age = deal_name_age("小明",20)
print(my_name, my_age)

交换变量的值

# 第1种方式
a = 4
b = 5
c = 0
c = a  # c = 4
a = b  # a = 5
b = c  # b = 4
# 结果
print(a)
print(b)

# 第2种方式
a = 4
b = 5
a = a+b  # a=9, b=5
b = a-b  # a=9, b=4
a = a-b  # a=5, b=4
print(a)
print(b)

# # 第3种方式
a, b = 4, 5  # a = 4,b = 5
# 在执行27行时，看的是滴22行的代码
# a = b
# b = a
# 不是等价的
a, b = b, a  # a = 5,b = 4
print(a)
print(b)

函数的文档说明

# 假设使用len函数
help(len)
# 函数文档说明->加的文档说明是python
# len(obj, /)
#     Return the number of items in a container.

# 很多的时候需要程序员自己创建

# 自定义一个函数
# def add2num(num1, num2):
#     return num1 + num2
# # 如果一个自定义函数没有我问的那个说明，默认是help会打印函数上面的注释
# help(add2num)   # 输出：    # 自定义一个函数

# 自定义一个函数
def add2num(num1, num2):
    """          # 6个双引号，按回车键，自动生成函数的文档说明
                 # 这个函数是用来计算两个数的和的
    :param num1: # 数字1
    :param num2: # 数字2
    :return:     # 返回值是两个数字相加
    """
    return num1 + num2
help(add2num)
# 错误的
# add2num([1, 2], (1, 3))
'''
01- 可以快速读懂自己的代码
02- 便于工作的交接
习惯和公司的要求
'''

局部变量

# 定义一个函数
def my_func1():
    # 定义一个局部变量
    # 局部变量：定义在函数内部的变量
    # 局部的作用域(使用范围)在函数的内部，函数的外部无法使用
    num = 10
    print(num)
# 调用函数
my_func1()

# 再定义一个函数
def my_func2():
    # 定义一个局部变量
    num = 10
    print(num)
# 在函数内部定义的局部变量名可以和其他函数的局部变量名相同，是不冲突的
my_func2()

全局变量

# 全局变量：定义在函数的外部的变量
# 全局变量 或者变量(作用域实在整个模块内使用)
# num1 = 10
# 分别在两个函数内部使用了全局变量
# def my_func1():
#     print("my_func1", num1)
#
# def my_func2():
#     print("my_func2", num1)
#
# print("函数外面", num1)
# my_func1()
# my_func2()

# 全局变量
# num2 = 10
# 分别在两个函数内部使用了全局变量
# def my_func3():
#     # 其实是定义了一个和全局变量名相同的局部变量
#     # 在函数内部如果使用变量，它先从函数内部找，如果有直接使用
#     # 如果函数内部没有找到，会到函数外面找(全局变量)
#     # 如果还是没有找到，就报错
#     num2 = 20
#     print("my_func3", num2)
#
# my_func3()
# print("外面", num2)

# 全局变量
num3 = 10
# 分别在两个函数内部使用了全局变量
def my_func3():
    # 标识这两个函数内部不是定义一个局部变量，其实是对全局变量的进行修改
    global num3
    # 对全局变量进行修改
    num3 = 20
    print("my_func3", num3)

my_func3()
print("外面", num3)

匿名函数

# 匿名函数(藏名字的函数)
# 对函数的简写
# 无参数无返回值的函数
# def my_print():
#     print("hello python")
# my_print()

# 表达式的定义
# f = lambda : print("hello python")
# 执行
# f()
# 等价于
# (lambda : print("hello python"))()

# 无参数有返回值的函数
# def my_pi():
#     return 3.14
# print(my_pi())
# f = lambda : 3.14
# print(f())

# 有参数的无返回值的函数
# def my_prnt(name):
#     print("你好%s" % name)
# print("姜子牙")
# f = lambda name:print("你好%s"%name)
# # 执行
# f("姜子牙")

# 有参数有返回值的函数
def add2num(a, b):
    return a + b
f = lambda a, b :a + b
ret = f(10, 20)
print(f(10, 20))

列表推导式

# 定义一个列表
# my_list = {1, 2, 3, 4, 5}
# 定义一而空列表
# my_list = []
# for i in range(1, 101):
#     my_list.append(i)
# print(my_list)

# 列表推导式
# 使用列表推导式快速创建一个列表
my_list = [i for i in range(1, 30)]
print(my_list)

# 思考：得到一个有30个哈哈的列表
my_list = ["哈哈" for i in range(30)]
print(my_list)

# 定义一个列表，保存数据[1,50]之间的偶数
my_list = []
for i in range(1,51):
    if i % 2 == 0:
        my_list.append(i)
print(my_list)
# 列表推导式
my_list = [i for i in range(1,51) if i % 2 == 0]
print(my_list)

 

# def my_func1():
#     print("my_func1开始")
#     print("my_func1结束")
# print("开始测试")
# my_func1()
# print("测试")
'''  《输出》
开始测试
my_func1开始
my_func1结束
测试'''

def my_func1():
    print("my_func1开始")
    print("my_func1结束")
def my_func2():
    print("my_func2开始")
    my_func1()
    print("my_func2结束")
my_func2()
print("测试")
'''《输出》
my_func2开始
my_func1开始
my_func1结束
my_func2结束
测试
'''