黑马程序员---property属性---上下文管理器---生成器

朱雀 2022-11-29 12:17 101阅读 0赞

一：property属性：  
1：作用：把一个方法当做属性进行使用。  
2：定义property属性的两种方式：装饰器方式，类属性方式。  
3：装饰器方式：在get方法上面增加`@property`,在setter方法上面写`@方法名.setter`

#目的：让实例方法跟属性一样可以使用。
    
    class Person(object):
        def __init__(self):
            self.__age = 0
    
        @property
        def age(self):
            return self.__age
        @age.setter
        def age(self, new_age):
            self.__age = new_age
    
    if __name__ == '__main__':
        zs = Person()
        # print(zs.age())
        print("访问时的age: ", zs.age)
        zs.age = 23
        print("需改后的age: ", zs.age)

4:类属性的方式：格式:`类变量 = proper(get方法名，set方法名)`

class Person(object):
        def __init__(self):
            self.__age = 0
    
        def get_age(self):
            return self.__age
    
        def set_age(self, new_age):
            self.__age = new_age
    
        #增加一个类属性age
        age = property(get_age, set_age)
    
    p = Person()
    print(p.age)
    
    p.age = 100
    print(p.age)

二:上下文管理器：（掌握定义上下文管理器的方式）  
1：一个类只要实现了\*\***enter**()和\_\_exit\_\_()\*\*这个两个方法，通过该类创建的对象我们就称之为上下文管理器。  
2：上下文管理器管理文件：

# with一开始就执行enter方法，一结束就执行exit函数。
    
    class File(object):
        def __init__(self, file_name, file_mode):
            self.file_name = file_name
            self.file_mode = file_mode
    
        def __enter__(self):
            print("进入上文函数，负责获取资源")
            self.file = open(self.file_name, self.file_mode)
            return self.file
    
        def __exit__(self, exc_type, exc_val, exc_tb):
            print("进入下文函数，负责关闭资源")
            self.file.close()
    
    
    if __name__ == '__main__':
    
        with File("1.txt", "r") as f:
            file_data = f.read()
            print(file_data)
    
    
    # 运行结果：
    # 进入上文函数，负责获取资源
    # hello
    # 进入下文函数，负责关闭资源
    
    
        # with open("1.txt", "w") as file:
        #   file.write("hello")
    
        # 创建上下文管理器
        # f = open("1.txt", "r")
        # with f as file:
        #     file_data = file.read()
        #     print(file_data)

3：上下文管理器管理数据库：

import pymysql
    
    class Sql(object):
        def __init__(self,target_db,username,password):
            self.target_db= target_db
            self.username = username
            self.password = password
        def __enter__(self):
            print("进入上下文函数")
            self.conn = pymysql.connect(host="127.0.0.1" ,port=3306,user=self.username,password=self.password,database=self.target_db,charset="utf8")
            self.cs = self.conn.cursor()
            return self.cs
    
        def __exit__(self, exc_type, exc_val, exc_tb):
            print("进入下文函数")
            # 如果出现异常：
            if exc_type:
                self.conn.rollback()
                print(exc_type,exc_val)
            else:
                self.conn.commit()
            self.cs.close()
            self.conn.close()
            
            # True：下文函数已经处理了异常，异常无需传递回主程序
            #return Ture
    
    
    if __name__ == '__main__':
        try:
            with Sql("jing_dong","root","123456") as cs:
                # row_num = cs.execute("select * from goods;")
                # print("查询到的行数：",row_num)
                #
                # rows = cs.fetchall()
                # for i in rows:
                #     print(i)
    
                # row_num = cs.execute("update goods set price = price+100")
                # 错的sql语句
                row_num = cs.execute("updata goods set price = price+100")
                print(row_num)
        except Exception as e:
            print(e)

注意：exc\_type, exc\_val分别是出现异常时异常的类型和异常单的信息值。  
思路：在上文函数获取数据库的连接，创建游标并且返回游标对象。在with语句中执行sql语句执行sql语句。在with语句结束的之后会调用下文函数，所以下文函数负责关闭游标和连接，并且出现异常下文也可以捕获，如果出现异常我们让事务回滚，如果没有出现异常则提交。  
注意：下文函数也可以处理异常，如果下文函数处理了异常，那么下文函数需要返回True，这样主程序任然可以在出现异常的sql语句向下继续执行。如果下文函数不处理异常，需要在主程序中用try except 捕获异常。  
注意： row\_num = cs.execute(“updata goods set price = price+100”)这个一旦出现错误，主函数不会直接捕获异常，而是先执行下文函数，如果下文函数不处理异常（不写return Ture）则异常传递回主函数，由try except 捕获异常。

三：生成器：  
1：数据不是一次性全部生成出来，而是使用一个，再生成一个，可以节约大量的内存。  
2：创建生成器的两种方式：**生成器推导式** 和 **yield关键字**。  
3：生成器推导式创建生成器：

# 生成器的作用：节约内存空间
    if __name__ == '__main__':
        # 列表推导式：一次性生成多个空间来存储
        my_list = [i*2 for i in range(5)]
        print(my_list)
    
        g1 = (i*2 for i in range(5))
        print(g1)
    
        #for循环取值
        for i in g1:
            print(i)
    
        # 使用while循环去取值
        # while True:
        #     try:
        #         d1 = next(g1)
        #         print(d1)
        #     except Exception as e:
        #         break

注意：生成器对象g1，会利用一块空间，一个一个的生成，用完就释放空间。而列表推导式是一下子创建一堆空间，存储所有的。  
4：yield关键字创建生成器：

# 代码执行到 yield 会暂停，然后把结果返回出去，下次启动生成器会在暂停的位置继续往下执行
    def test(n):
        for i in range(n):
            print("开始生成.....")
            yield i*2
            print("完成一次生成器")
    
    if __name__ == '__main__':
    
        # g就是生成器
        g = test(5)
        for i in g:
            print(i)

5：利用生成器创建菲波那切数列：（后面数字是前面两个的和）  
思路一：使用列表，一个一个的向后存储，这样无疑是占用大量的空间。  
思路二：使用生成器：第三个的值存储第二个的值，第四个 存储前两个的和，这样只用两块空间就可以了。

def fibonacci(num):
        a = 0
        b = 1
    
        # 记录生成fibonacci数字的下标
        current_index = 0
    
        while current_index < num:
            result = a
            a, b = b, a + b
            current_index += 1
            # 代码执行到yield会暂停，然后把结果返回出去，下次启动生成器会在暂停的位置继续往下执行
            yield result
    
    
    fib = fibonacci(5)
    # 遍历生成的数据
    for value in fib:
        print(value)

注意：执行过程：程序向下执行：fib = fibonacci(5)此处只是定义生成器对象，并没有执行非彼那切数列的函数，当程序执行到for循环的时候，会边进入函数边执行。当运行到 yield result的时候，退出函数，将返回值返回给for循环的value，然后执行打印，然后再回到yield result的位置继续执行while循环。