一、函数进阶

    1.函数多返回值
    （1）def test_return():
            return 1,2
        x,y=test_return()
        print(x)
        print(y)
    （2）按照返回值的顺序，写对应顺序的多个变量接收即可
        变量之间用逗号隔开
        支持不同类型的数据return

# 函数多返回值
def return_test():
    return 1,2,3

x,y,z = return_test()
print(x,y,z)

    2.函数多种传参方式
    （1）位置参数：调用函数时根据函数定义的参数位置来传递参数
            传递的参数和定义的参数的顺序以及个数必须一致
    （2）关键字传参：
            可以让参数更加清晰、容易使用。同时也清除了参数的顺序需求（即可以不按照固定顺序传参）
                如： def user_info(name,age,gender):
                        ...函数体...
                    user_info(age=20,gender=...,name=...)
            函数调用时，如果有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序
                如： user_info("小明",gender="男",age=20)
    （3）缺省参数 ：
            缺省参数也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参数的值（所有位置参数必须出现在默认参数前，包括函数定义和调用）
            当调用函数时没有传递参数，就会使用默认是缺省参数对应的值
                def user_info(name,age,gender=“男”):
                        ...函数体...
    （4）不定长参数：也叫可变参数，用于不确定调用的时候会传递多少个参数（不传参也可以）的场景
            位置传递的不定长：        
                def user_info(*args):
                    print(args)
                传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组（tuple），args是元组类型

            关键字传递的不定长:
                def user_info(**kwargs):
                    print(kwargs)
            参数是“键=值”形式的形式的情况下，所有的“键=值”都会被kwargs接受，同时会根据“键=值”转成字典

# 函数的多种传参方式
# 1.位置传参 --按照顺序
def user_info(name,age,gender):
    print(name,age,gender)

user_info("小明",13,"男")

# 2.关键字传参
user_info(age=11,name="小明",gender="男")

# 3.关键字传参和位置传参混用
user_info("小张",gender="男",age=20)

# 4.不定长传参 --位置不定长 *args  --元组tuple
def user_info2(*args):
    print(args)

user_info2("小红","男",13)

# 4.不定长传参  --关键字不定长  **kwargs  -- key=value  -->转成字典  key:value
def user_info3(**kwargs):
    print(kwargs)

user_info3(name="小李",gender="女",age=20)

    3.匿名函数
    （1）函数作为参数传递
            def test_func(compute):
                resuit =compute(1， 2)
                print(result)
            def compute(x， y):
                return x+y
            test_func(compute)  -->3
        是一种计算逻辑的传递，而非数据的传递；任何逻辑都可以自行定义并作为函数传入    ----被计算的数据确定，而计算的逻辑不确定  ---逻辑传入
        而普通的传入数据的函数，是数据不确定，而计算逻辑写好了   --数据传入

# 函数作为参数传递，是一种计算逻辑的传递，而非数据的传递
def test_fun(compute):
    result=compute(5,6)
    print(result)

def compute(x,y):
    return x+y

# 调用，并传入函数
test_fun(compute)

# 使用lambda 定义匿名函数
test_fun(lambda x,y:y-x)

    （2）lambal匿名函数
            只能临时定义一次
            lambda 传入参数：函数体（一行代码）
                lambda是关键字，表示定义匿名函数
                传入参数表示匿名函数的形式参数  x,y表示接收2个形式参数
                函数体：函数的执行逻辑，只能谢一行，无法写多行代码
            

二、文件操作

    1.文件编码
    （1）编码技术：翻译的规则，如何将内容翻译成二进制，以及如何将二进制翻译回可识别内容
    （2）编码是一种规则集合，记录了内容和二进制间进行相互转换的逻辑
    2.文件的读取
    （1）操作系统以文件为单位管理磁盘
    （2）文件可以分为文本文件、视频文件、音频文件、可执行文件
    （3）文件的操作： 打开文件、读写文件、关闭文件
    （4）打开文件：
            open（name,mode,encoding）
                name：要打开的目标文件名的字符串（可以包含文件所在的具体路径）
                mode:设置打开文件的模式(访问模式):只读[r]、写入[w]、追加[a]等。
                encoding:编码格式(推荐使用UTF-8)
            示例代码:
                f= open('python.txt','r',encoding=” UTF-8)
                #encoding的顺序不是第三位，所以不能用位置参数，用关键字参数直接指定
            注意事项
                注意:此时的`'f是`open'函数的文件对象，对象是Python中一种特殊的数据类型，拥有属性和方法，可以使用对象.属性或对象.方法对其进行访问
                对象：类被实例化之后得到的
    （5）mode三种访问模式：
            r:只读；文件的指针将会放在文件的开头；默认
            w：写入。如果该文件已存在则打开文件，并从开头开始编辑，原有内容会被删除；如果该文件不存在，创建新文件。
            a：追加。如果该文件已存在，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入
    （6）read()方法
            文件对象.read(num)
                num表示要从文件中读取的数据的长度（单位是字节）；不传num：读取文件中所有的数据
            如果连续两次调用read()  第二次读取从第一次读取的结尾开始
    （7）readlines()方法
                按照整行的方式把整个文件中的内容进行一次性读取，并且返回一个列表其中每一行的数据为一个元素，
                如果之前调用了read()方法，也会从上一次读取的结尾开始
    （8）readline():一次读取一行
    （9）with open :可以在操作完成后自动关闭close文件，
            with open("...","r",...) as f ：
                for line in f:
                    print(...)
        
    ！！！文件读取，使用指针！！！

# 对文件进行操作
# 1.打开文件
f=open(r"D:\test_file\python_open.txt","r",encoding="utf-8")
print(type(f))

# 2.读取文件 如果连续两次调用read()/readlines()等  第二次读取从第一次读取的结尾开始  文件读取：指针
# 2.1 read()
# print(f.read(3))
# 2.2 从上次读取结尾开始到整个文件结束
# print(f.read())
# 2.3 readlines() 读取文件的全部行，封装到列表中
# lines=f.readlines()
# print(type(lines))
# print(lines)

# 2.4readline() 一次读取一行
line1=f.readline()
print(line1)
line2=f.readline()
print(line2)
# line3=f.readline()
# print(line3)

# 2.5 for循环
for line in f:
    print(line)

# 3.close()关闭文件对象
f.close()

    3.文件的写入
    （1）#1.打开文件
        f= open('python.txt','w')
        # 2.文件写入
        f.write('hello world')
        #3.内容刷新
        f.flush()
    （2）直接调用write，内容并未真正写入文件，而是会积攒在程序的内存中，称之为缓冲区
        调用flush的时候，内容会真正写入文件
        这样做是避免频繁的操作硬盘，导致效率下降(这个凡是相当于:一次性写入磁盘)
        close.()内置了flush()功能

# 文件写入  w模式：文件不存在创建；文件存在 覆盖
f=open(r"D:\test_file\python_write.txt","w",encoding="utf-8")
f.write("123456yyy")
f.close()  # close()内置了flush()的功能

# 文件追加 a模式：文件不存在 创建文件；文件存在，在最追加写入文件
f2=open(r"D:\test_file\python_write.txt","a",encoding="utf-8")
f2.write("\nadd222....")
f2.write("\n bbbb")
f2.close()

    4.文件的追加 a
    （1）文件不存在 创建文件；文件存在，在最后追加写入文件

    3.关闭文件对象：close()
    （1）关闭对文件的占用

Python 异常、模块、包

一、异常

    1.异常 bug
    2.异常的捕获
    （1）异常处理（捕获异常）
    （2）程序遇到BUG，两种情况：
            整个程序因为一个BUG停止运行
            对BUG进行提醒，整个程序继续运行  --捕获异常
    （3）捕获异常的作用：提前假设某处会出现异常，做提前准备
    3.捕获常规异常：
    （1）基本语法：
            try:
                可能发生错误的代码
            except：
                如果出现异常执行的代码
    （2）捕获指定异常
            try:
                可能发生错误的代码
            except 特定异常名（如NameError）as e：
                如果出现异常执行的代码
        e是异常的对象；发生的异常需要与except 捕获的异常名相同

    （3）捕获多个异常  --except后通过元组（）接收
            try:
                可能发生错误的代码
            except （特定异常名1，特定异常名2）（如NameError）as e：
                如果出现异常执行的代码
    （4）捕获所有异常：
            可以使用语法1 ，或者： Exception
                try:
                    ...
                except Exception as e:
                    ...

    4.异常else finally:
    （1）else表示的是如果没有异常要执行的代码
                try:
                    ...
                except Exception as e:
                    ...
                else:
                    ...
                finally:
                    f.close()
    （2）finally表示的是无论是否异常都要执行的代码，如关闭文件

    5.异常的传递
    （1）异常具有传递性
            当函数func01中发生异常，并且没有捕获处理这个异常的时候，异常会传递到函数func02，当func02也没有捕获处理这个异常的时候main函数会捕获这个异常，这就是异常的传递性
    （2）当所有函数都没有捕获异常的时候，程序就会报错

    6.Python的模块

    （1）Python 模块(Module)，是一个 Python 文件，以.py 结尾.模块能定义函数，类和变量，模块里也能包含可执行的代码
    （2）模块的作用: python中有很多各种不同的模块，每一个模块都可以帮助我们快速的实现一些功能，比如实现和时间相关的功能就可以使用time模块我们可以认为一个模块就是一个工具包，每一个工具包中都有各种不同的工具供我们使用进而实现各种不同的功能
        模块就是一个Python文件，包含类、函数、变量
    （3）模块的导入方式
            [from 模块名] import [模块 | 类 | 变量 | 函数 | *][as 别名]
    （4）常用的组合形式
            import 块名
                import time
                time.sleep(5)
            from 模块名 import 类、变量、方法等
                        from time  import sleep 
                sleep(5)
            from模块名 import *
                from time import *
                sleep(5)
            import 模块名 as 别名
            from模块名 import 功能名 as别名

# 模块的导入
# 1.import 块名
# import time
#
# print("111")
# time.sleep(5)  # 休眠5秒
# print("222")

# 2.from 模块名 import 类、变量、方法等
# from time  import sleep
# print("aaa")
# sleep(5)
# print("bbb")

# 3.from模块名 import *
from time import *
print("mmm")
sleep(5)
print("nnn")

    7.Python模块--自定义模块
    （1）当导入多个模块，且模块内有同名功能，当调用这个同名功能室，调用的是后面导入的模块的功能

# 自定义模块的使用
import my_model_test1 as m1

num= m1.test(2,3)
print(num)

# 自定义模块
def test(x,y):
    return x+y

    （2）在实际开发中，当一个开发人员编写完一个模块后，为了让模块能够在项目中达到想要的效果，这个开发人员会自行在py文件中添加一些测试信息，例如，在my_module1.py文件中添加测试代码test(1,1)
        问题:
            此时，无论是当前文件，还是其他已经导入了该模块的文件，在运行的时候都会自动执行`test 函数的调用
        解决方案：_ _main_ _
    （3）_ _main_ _
            if _ _name_ _='_ _main_ _'
                test(1,2)      ---则导入这个模块的另一个模块不会执行这个方法
    （4）_ _all_ _
            如果一个模块文件中有‘__all__’变量，当时用'from xxx import *'导入时，只能导入这个列表中的元素
            _ _all_ _=['test_A']

    8.Python包

    （1）Python包：是一个文件夹，包含一个__init__.py文件，该文件夹可用于包含多个模块文件；从逻辑上看，包的本质仍然是模块
    （2）Python包的作用：当模块文件多时，使用包管理这些模块
    （3）导入包：
            导入：  import 包名.模块名
            使用：  包名.模块名.目标
        ---或者：
            导入：from my_package[包名] import my_module[模块名]
            使用：模块名.目标（函数名等）

    9.第三方Python包
    （1）包时同类型功能的集合体
    （2）安装第三方包： -pip  pip install  默认链接国外网站
    （3）连接国内的网站进行包安装：
            pip install -i https://pypi.tuna.tsinghua.edu.cn/simple 包名称
    （4）通过PyCharm安装