Python基础知识3

函数

先定义后调用
定义函数：
    def 函数名(参数):
        代码块

函数的说明文档--help(函数名)：
    def sum(a,b):
        """求和函数"""
        return a+b
    help(sum)
    结果显示：
        sum(a, b)
            求和函数

    高级使用：
        def sum(a,b):
            """(点击回车)
            求和函数
            :param a:参数1
            :param b: 参数2
            :return: 返回值
            """
            return a+b
        help(sum)
        结果显示：
            sum(a, b)
                (点击回车)
                求和函数
                :param a:参数1
                :param b: 参数2
                :return: 返回值
局部变量的作用：在函数体内部，临时保存数据，即当函数调用完成后，就立即销毁
全局变量：在函数体内外都能用的变量
关键字global：
    global a    #声明a为全局变量
返回值：return 后面可以写多个函数值、元组、列表、字典
    def method(a,b):
        return a,b
    num_1,num_2=method(1,2)
参数：
    位置参数：调用参数时根据函数定义的参数位置来传递参数，传递和定义参数的顺序及个数必须一致

    关键字参数：通过“键=值”形式加以指定。可以让函数更加星系、容易使用，同时也清除了参数的顺序需求
        def user(name,age,gender):
            print(f'您的名字是{name}，年龄是{age},性别是{gender}')
        user('Rose',age=20,gender='女')      *您的名字是Rose，年龄是20,性别是女*
        user('Tom',gender='男',age=18)     *您的名字是Tom，年龄是18,性别是男*
        user(gender='男',age=18,'Tom')     *报错*
        #位置参数必须写在关键字参数前面，，关键字参数之间不存在顺序

    缺省参数（默认参数）：             所有位置参数必须出现在默认参数前面
        def user(name,age,gender='男'):
            print(f'您的名字是{name}，年龄是{age},性别是{gender}')
        user('Rose',20,'女')      *您的名字是Rose，年龄是20,性别是女*
        user('Tom',18)              *您的名字是Tom，年龄是18,性别是男*
        #函数调用时，如果为缺省参数传值则修改默认参数值，否则使用默认参数

    不定长参数（可变参数）：
        用于不确定调用的时候会传递多少个参数（不传参也可以）的场景。
        此时，可以用包裹(packing)位置参数,或者包裹关键字参数，来进行参数传递
        无论是包裹位置传递还是包裹关键字传递，都是一个组包的过程
        包裹位置传递：
            def user(*args):
                print(args)
            user('Tom')         *('Tom',)*
            user('Tom',18)      *('Tom', 18)*
            # 传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组，args是元组类型
        包裹关键字传递：
            def user(**kwargs):
                print(kwargs)
            user(name='Tom')             *{'name': 'Tom'}*
            user(name='Tom',age=18)      *{'name': 'Tom', 'age': 18}*
            # 合并为一个字典
拆包：
    元组：
        def method():
            return 100,200
        result=method()      #result为元组类型
        num1,num2=method()      #拆包，注意个数问题
    字典：
        dict = {'name':'Tom','age':20}
        a,b = dict
        #对字典拆包，取出来的是字典的key
        print(a)            *name*
        print(b)            *age*
        print(dict[a])      *Tom*
        print(dict[b])      *18*
交换变量：
    方法一：利用第三变量存储数据
    方法二：
        a = 1
        b = 2
        a,b = b,a
引用：
    id()：检测变量的id值（内存的十进制值）
    a = 1
    b = a
    print(b)        *1*
    print(id(a))    *1420648672*
    print(id(b))    *1420648672*
    a = 2           *1*     #因为修改了a的数据，所以要开辟另一份内存空间存储2，id检测到a与b的内存地址不同
    print(id(a))    *1420648704*
    print(id(b))    *1420648672*
    print(b)
    # int型数据是不可变类型，列表是可变

可变类型：列表、字典、集合
不可变类型：整数、浮点型、字符串、元组
# 数据能够直接进行修改，那么就是可变，否则就是不可变

匿名函数(lambda)：满足简单的函数场景，仅仅能封装有限的逻辑；lambda只能是单个表达式，不是一个代码块
    语法：
        lambda 参数列表:表达式
        sum=lambda a,b,c:a+b+c
        print(sum(1,2,3))
    与三元运算符：
        a,b=1,2
        c = a if a>b else b

        max = (lambda x,y:x if x>y else y)
        c = max(1,2)
递归函数：自己调用自己
    优点：逻辑简单，定义简单
    缺点：容易导致栈溢出，内存资源紧张，甚至内存泄漏
    递归案例：模拟实现树形结构的遍历
        import os  #引入文件操作模块
        def findFile(file_Path):
            listRs = os.listdir(file_Path)  #得到该路径下所有文件夹
            for fileItem in listRs:
                full_path = os.path.join(file_Path,fileItem)    #获取完整的文件路径
                #判断是文件还是文件夹
                if os.path.isdir(full_path):
                    findFile(full_path)
                else:
                    print(fileItem)
                    pass
                pass
            else:
                return
            pass
        findFile('D:\Google下载')

模块

python有很多内置函数，只会自动导入一些常用函数
把函数定义在单独的文件中，成为一个模块，文件名就是模块名
    import xxx      #默认从当前目录下去寻找模块，不能加后缀.py
    xxx.def()       #调用
    
    from xxx import *
    
    from xxx import def     #从xxx模块中导入def方法
    def()
    
    from xxx import def as def2     #从xxx模块中导入def方法并命名为def2；防止重名或者方法名特别长
    def2()
    
    import xxx as xxx1      #给模块名起别名
    xxx1.def()

类（面向对象）

类的私有属性：
    两个下划线开头，说明该属性为私有，不能在类的外部被使用或直接访问
    class student():
        __name='小明'                            # 私有属性
        def shangke(self):
            print(f'{self.__name}在上课')
        def __doHomework(self):                 # 私有方法
            print(f'{self.__name}在写作业')
构造方法：   在类实例化时会自动调用
    def __init__(self): 
self：
    代表类的实例，而非类，self 不是 python 关键字
cls：代表这个类
类的方法：
    在类的内部，使用 def 关键字来定义一个方法，
    与一般函数定义不同，类方法必须包含参数 self, 且为第一个参数
继承： 可以多继承
    class fu():
        父类代码
    class zi(fu):
        子类代码
    class zi(fu1,fu2,fu3):  注意圆括号中父类的顺序，若是父类中有相同的方法名，而在子类使用时未指定，python从左至右搜索 
                            即方法在子类中未找到时，从左到右查找父类中是否包含方法。
重载：
    可以对类的专有方法进行重载
覆盖：
    super():    调用父类(超类)的一个方法。
通过模块导入类：
    class fu:   （文件名为父）
        def __init__(self,name,age): 
            self.name=name
            self.age=age
        def pri(self):
            print('父类的方法')
    import 父
    from 父 import fu 
    class zi():
        def __init__(self,name,age): 
            self.fu=父.fu(name,age)       #书写格式，父类.属性或父类.方法

文件操作

import os                   #导包
print(os.getcwd())          #输出当前的工作目录
os.chdir("C:\\Windows")     #修改工作目录，由文件夹组成
文件操作：
    1、读取文件内容
    open(file, mode='r',    buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
        (文件名,文件打开模式, 设置缓冲,      编码方式,        报错级别,     区分换行符,   传入的file参数类型)
        文件打开模式：
            r: 以只读方式打开文件;文件的指针将会放在文件的开头,这是默认模式
            w: 打开一个文件只用于写入
               如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除
               如果该文件不存在，创建新文件
            a: 打开一个文件用于追加
               如果该文件已存在，文件指针将会放在文件的结尾,也就是说，新的内容将会被写入到已有内容之后,追加在新一行在前面加个'\n'
               如果该文件不存在，创建新文件进行写入
            a+:打开一个文件用于读写;
               如果该文件已存在，文件指针将会放在文件的结尾,文件打开时会是追加模式
               如果该文件不存在，创建新文件用于读写
        with open(r'文件.txt',  encoding='utf8') as file:     #以防文件乱码
            content = file.read()
            print(content)
            file.close()
        *姓名、年龄、性别、电话*
    按行读取
        with open(r'文件.txt',  encoding='utf8') as file:
            for line in file:
                print(line)
    读取所有行并返回列表  
        with open(r'文件.txt',  encoding='utf8') as file: 
            l = file.readlines()        # 读取所有行并返回列表 
        for line in l:
            print(line)
    从文件中读取单独的一行    str = file.readline() 
    2、修改文件内容        与mode有关
        先打开，后写入：
            with open('文件.txt','w',  encoding='utf8') as file:
                file.write('写入的数据')         # 会把之前文件里的内容覆盖掉，把之前的内容清空，添加新的内容
文件夹操作：
    1、创建文件夹,默认在当前文件夹路径下
        相对路径
        os.makedirs("文件名1/文件名2")     *E:\Pythonworkspace\文件名1\文件名2*
        绝对路径
        os.makedirs("E:\\Pythonworkspace\\文件名")
        os.makedirs("E:/Pythonworkspace/文件名")

异常

异常捕捉可以使用 try/except 语句
    异常处理：
        try:
            执行代码
        except:
            发生异常时执行的代码
        else:
            没有异常时执行的代码

raise 语句抛出一个指定的异常
    抛出异常:
        x = -1
        if x < 0:
            raise Exception(f'x 不能小于0。x 的值为: {x}')

自定义异常: 通过创建一个新的异常类来拥有自己的异常,异常类继承自Exception类，可以直接继承或间接继承

断言：assert 用于判断一个表达式，在表达式条件为 false 的时候触发异常
    断言可以在条件不满足程序运行的情况下直接返回错误，而不必等待程序运行后出现崩溃的情况
    assert 1==2