Python——property属性、with语句、生成器、浅拷贝、深拷贝 学习笔记

property属性

class Person(object):
    def __init__(self):
        self.__age = 0

    def get_age(self):
        return self.__age

    def set_age(self, new_age):
        if new_age > 0 and new_age < 130:
            self.__age = new_age
            print("执行了")
        else:
            print("成精了！")
    # 类属性的方式的property
    age = property(get_age, set_age)


p = Person()

print(p.age)

with语句

with open("test.txt", "r") as file:
    read = file.read()
    print("系统 open：%s" % read)


# 定义文件管理类
class File(object):
    # 初始化方法
    def __init__(self, file_name, file_model):
        # 定义变量保存文件名和打开模式
        self.file_name = file_name
        self.file_model = file_model

    # 上文方法
    def __enter__(self):
        print("进入上文方法")
        # 返回文件资源
        self.file = open(self.file_name,self.file_model)
        return self.file

    # 下文方法
    def __exit__(self, exc_type, exc_val, exc_tb):
        print("进入下文方法")
        self.file.close()


if __name__ == '__main__':

    # 使用with管理文件
    with File("test.txt", "r") as file:
        file_data = file.read()
        print("方法一：%s" % file_data)

生成器

# 创建生成器
my_generator = (i * 2 for i in range(5))
print(my_generator)

# next获取生成器下一个值
# value = next(my_generator)
# print(value)

# 遍历生成器
for value in my_generator:
    print(value)


def fibonacci(num):
    """
    生成器使用场景
    :param num:
    :return:
    """
    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)

浅拷贝

import copy
# 浅拷贝: 只会对可变类型的第一层对象进行拷贝，不会对子对象进行拷贝，
# 拷贝成功后会开辟一个新的内存空间存储拷贝这个对象

# 不可变类型：　数字、字符串、元组

num1 = 1
# copy() 表示是一个浅拷贝函数
# 浅拷贝
num2 = copy.copy(num1)
# 查看后内存地址没有发生变化，说明没有对对象进行拷贝，也就说没有开辟新的内存空间
print("num1:", id(num1), "num2:", id(num2))
# 对于不可变类型进行浅拷贝实际上是对引用的一个拷贝，两个变量指定的是一个内存地址

my_tuple1 = (3, 5)
my_tuple2 = copy.copy(my_tuple1)
print("my_tuple1:", id(my_tuple1), "my_tuple2:", id(my_tuple2))

# 得知结论: 浅拷贝不会对不可变类型进行拷贝，也就说不会开辟内存内存空间，
# 对于不可变类型进行浅拷贝实际上是对引用的一个拷贝，两个变量指定的是一个内存地址

# 可变类型: 列表、字典、集合
my_list1 = [1, 3, [4, 6]]

my_list2 = copy.copy(my_list1)

print("my_list1:", id(my_list1), "my_list2:", id(my_list2))

my_list1.append(5)
print(my_list1, my_list2)

print("my_list1[2]:", id(my_list1[2]), "my_list2[2]:", id(my_list2[2]))
my_list1[2].append(3)
print(my_list1, my_list2)

print("*"*10, "我是分割线", "*"*10)

深拷贝

import copy
# 深拷贝: 只要发现对象有可变类型那么就是对该对象到最后一个可变类型的每一层对象进行拷贝，拷贝成功后会开辟新的内存空间

# 不可变类型： 数字、字符串、元组

num1 = 1
num2 = copy.deepcopy(num1)

print("num1:", id(num1), "num2:", id(num2))

str1 = 'hello'
str2 = copy.deepcopy(str1)

print("str1:", id(str1), "str2:", id(str2))

my_tuple1 = (1, [1,2])
my_tuple2 = copy.deepcopy(my_tuple1)

print("my_tuple1:", id(my_tuple1), "my_tuple2:", id(my_tuple2))
print("my_tuple1[1]:", id(my_tuple1[1]), "my_tuple2[1]:", id(my_tuple2[1]))

my_tuple2[1].append(4)

print(my_tuple1, my_tuple2)

print("my_tuple1[0]:", id(my_tuple1[0]), "my_tuple2[0]:", id(my_tuple2[0]))

# 如果发现元组里面有可变类型那么，会对元组进行拷贝和子元素列表进行拷贝，拷贝后都会产生一个新的内存空间
# 但是不可变类型不会进行拷贝，因为不可变类型不允许在原有内存空间的基础修改数据，
# 所以拷贝没有意义，因为每次修改数据内存地址都会发生变化

# 可变类型： 列表，字典，结合 ， 对应深拷贝来说也会进行拷贝如果发现子对象也是可变类型也会进行拷贝，
# 拷贝后会开辟新的内存空间存储拷贝后的对象

my_list1 = [1,[2, 3]]
my_list2 = copy.deepcopy(my_list1)
print("my_list1:", id(my_list1), "my_list2:", id(my_list2))

print("my_list1[1]:", id(my_list1[1]), "my_list2[1]:", id(my_list2[1]))

# 无论是浅拷贝还是深拷贝都是针对的可变类型