2019-05-08day16总结

class Lyric:
def init(self, word):
self._time = 0
self.word = word

@property
def time(self):
    return self._time
@time.setter
def time(self, value):
    # value = '[00:22:34]'
    fen = float(value[1:3])
    miao = float(value[4:])
    self._time = fen * 60 + miao

def __repr__(self):
    return str(self.__dict__)

class LyricAnalysis:

def __init__(self, name):
    self.name = name
    self.all_lyric = []
# def analysis_file(self):

# 需要: 歌名
def get_world(self, time):
    if not self.all_lyric:

    # 1.解析歌词文件中的内容
        with open('files/%s.txt' % self.name, 'r', encoding='utf-8') as f:
            while True:
                # 读一行内容
                line = f.readline()
                # 切字符串
                lines = line.split(']')
                # 遍历时间创建歌词对象
                for time_str in lines[:-1]:
                    lyric_obj = Lyric(lines[-1])
                    lyric_obj.time = time_str
                    # print(lyric_obj.__dict__)
                    self.all_lyric.append(lyric_obj)

                if not line:
                    break
    # 2.当前歌的歌词按时间排序
    self.all_lyric.sort(reverse=True, key=lambda item: item.time)
    # print(self.all_lyric)
    # 3.根据时间找对应的歌词
    for item in self.all_lyric:
        if item.time < time:
            return item.word
    return self.name

l1 = LyricAnalysis('蓝莲花')

print(l1.get_world(10))

"""
python中所有数据类型都是类,数据都是对象。

所有的运算符对应的操作本质都是在调用数据类型对应的魔法方法。(没个运算符都对应一个魔法方法)
"""
class Student:
def init(self, name, age=0, score=0):
self.name = name
self.age = age
self.score = score

# 重载加法运算符
# self + other = return 返回值
def __add__(self, other):
    return self.age + other.age

# 重载乘法运算符
def __mul__(self, other: int):
    return self.score * other


# def __gt__(self, other):
#     return self.score > other.score

# def __repr__(self):
#     return str(all_student.__dict__)

def __lt__(self, other):
    return self.score < other.score

# 注意: >和<只需要重载一个

stu1 = Student('小明', 19, 22)
stu2 = Student('小米', 44, 45)
print(stu1 + stu2)
print(stu1 * 10)
print(stu1 < stu2)

all_student = [stu1, stu2, Student('小号', 34, 43), Student('小米', 11, 22)]
print(all_student)

练习: 让Student的对象支持乘法运算,运算规则是:

* 3 = [, , ]

class Student:
def init(self, name='张三', age=10, score=0):
self.name = name
self.age = age
self.score = score
def mul(self, other):
return self.name * 3, self.age * 3, self.score * 3

import copy

class Dog:
def init(self, name, color='黄色'):
self.name = name
self.color = color

class Student:
def init(self, name, age=0, score=0):
self.name = name
self.age = age
self.score = score
self.dog = None

def __repr__(self):
    return '<' + str(self.__dict__)[1:-1] + '>'

def __mul__(self, other):
    result = []
    for _ in range(other):
        result.append(self)
    return result

stu1 = Student('张三', 18, 90)
print(stu1)

result = stu1 * 2
print(result)

print('===================深拷贝和浅拷贝=================')
print("直接赋值")

1.一个变量直接给另外一个变量赋值:直接将地址赋值,赋完后两个变量指向同一块内存区域,并且相互影响

stu2 = Student('Lisa', 18, 69)
stu3 = stu2
print(id(stu2), id(stu3))

stu2.age = 28
print(stu3.dict)

2.浅拷贝和深拷贝(面试点!!)

"""
拷贝原理:将被拷贝的对象复制一份,产生一个新的数据,然后将新的数据的地址返回

a.浅拷贝
1)列表或字典的copy方法是浅拷贝、切片也是浅拷贝
2)copy.copy(对象) - 复制指定的对象,产生一个新的对象(不会复制子对象)

b.深拷贝
copy.deepcopy(对象) - 复制指定的对象,产生一个新的对象。如果这个对象中有其他的对象,子对象也会被复制
"""
print('======浅拷贝=======')
stu2 = Student('Lisa', 18, 69)

stu3 = stu2

print("======深拷贝=======")
stu2 = Student('Lisa', 18, 69)
stu4 = copy.copy(stu2)

1.数据的存储(内存开辟)

"""
python的变量都存储在栈区间,对象都在堆区间。

声明变量或者给变量赋值,是先在内存中(堆)中开辟存储数据,然后将数据地址保存在变量中。
但是数字和字符串特殊,如果是用数字或者字符串给变量赋值,他不会直接开辟空间保存数据,
而是先在内存中检查这个数据之前是否已经存储过,如果已经存储,直接用上次保存的数据,没有存储才会开辟新的空间保存数据
"""

list1 = [1, 2]
list2 = [1, 2]
print(id(list1), id(list2))
num1 = {}
num2 = {}
print(id(num1), id(num2))
num3 = 99999999999999999999999999999999999999
num4 = 99999999999999999999999999999999999999
print(id(num3), id(num4))

2.内存的释放

"""
1)引用计数
python中每个对象都有一个属性叫引用计数,用来保存当前对象的引用的个数。

python中的垃圾回收机制来判断一个对象是否销毁,就看这个对象的引用技术是否为零,如果为零就被销毁
"""
from sys import getrefcount
print('=========引用计数========')
list1 = [1, 2]
print(getrefcount(list1))

让引用计数增加

list2 = list1
print(getrefcount(list1))
dict1 = {'a': list2}
print(getrefcount(list1))

num = 100

print(getrefcount(num))

num1 = 100

print(getrefcount(num1))

让引用计数减少

print(getrefcount(list1))
list2 = 100
print(getrefcount(list1))
del dict1['a']
print(getrefcount(list1))

你可能感兴趣的:(2019-05-08day16总结)