"""author = drh"""
"""
類和對象

1.類的聲明
class 類名:
類的內(nèi)容

2.屬性 - 聲明在類中的變量
a.對象屬性 - 值會因為對象不同而不同
聲明在init方法中
self.屬性 = 值
對象.屬性

對象屬性的增刪改查
slots

b.類的字段 - 值不會因為對象不同而不同
直接聲明在類中
變量名 = 值
類.屬性

c.內(nèi)置屬性
name
class
dict
doc
module
base

3.方法 - 聲明在類中的函數(shù)
a.對象方法
直接聲明在類中
自帶self參數(shù)， 調(diào)用的時候不用傳參， 誰調(diào)用指向誰
對象.方法()
實現(xiàn)函數(shù)的功能需要對象屬性

1）init方法
創(chuàng)建對象的時候系統(tǒng)自動調(diào)用
需要通過構造方法來給init方法傳參

b.類方法
聲明前加@classmethod
自帶cls參數(shù)， 調(diào)用的時候不用傳參， 誰調(diào)用指向誰
類.方法()
實現(xiàn)函數(shù)的功能不需要對象屬性，需要類的字段

c.靜態(tài)方法
聲明前加@staticmethod
沒有自帶參數(shù)
類.方法()
實現(xiàn)函數(shù)的功能既不需要對象屬性，也不需要類的字段

"""

def main():
pass

if name == 'main':
main()

"""author = drh"""
"""
1.屬性和方法的訪問權限
私有的：在類的外部不可以使用，也不可以繼承
保護的：在類的外部不可以使用，可以繼承
公開的：在類的外部可以使用，也可以被繼承

2.python的私有化
python中屬性和方法的訪問權限只有公開，但是提供了另一種私有化的方式。

python中在屬性或者方法名前加，就可以將屬性或者方法變成私有的(注意：只能兩開頭，不能__結(jié)尾)
私有的屬性和方法只能在類的內(nèi)部使用，不能在類的外面使用

3.python私有化的原理
在名字前是_的屬性和方法前再加'類名'去保存屬性和方法
"""

class Person:
num = 61
__num2 = 62

def __init__(self, name='張三', age=0):
    self.name = name
    self.age = age
    self.__sex = '男'

def eat(self, food):
    print(self.__sex)
    print(self.name, food)
    self.__run()

def __run(self):
    print('%s在跑步' % self.name)

@classmethod
def show_num(cls):
    print('人類的數(shù)量:%d, %d' % (cls.num, cls.__num2))

@staticmethod
def func1():
    print('人類要保護大自然!')

def main():
p1 = Person()

print(Person.num)
# print(Person.__num2)


print(p1.name)
# print(p1.__sex)
print(p1._Person__sex)

p1.eat('面條')
# p1.run()

Person.show_num()
Person.func1()

print(p1.__dict__)

if name == 'main':
main()

"""author = drh"""
"""
1.應用場景
getter: 獲取對象屬性的值之前想要做點兒別的事情，就給這個屬性添加getter
setter: 給對象屬性賦值之前想要做點兒別的事情，就給這個屬性添加setter

2.getter
第一步：聲明屬性的時候在屬性名前加_
第二步: 聲明函數(shù)(函數(shù)沒有除了self以外的參數(shù)，但是要與返回值。返回值就是獲取屬性拿到的值)
@property
def 去掉的屬性名(self):
做點別的事情
返回屬性的值
第三步：在類的外部通過對象.去掉的屬性去獲取相關的屬性

3.setter - 想要添加setter必須先要有getter
第一步：聲明屬性的時候在屬性名前加_
第二步: 聲明函數(shù)(函數(shù)除了self以外還需要一個參數(shù)，沒有返回值。這兒的參數(shù)代表給屬性賦的值)
@屬性名去掉.setter
def 去掉的屬性名(self, 參數(shù)):
做點別的事情
給屬性賦值
第三步：在類的外部通過對象.去掉_的屬性去給相關屬性賦值

"""

class Person:
def init(self, name=''):
self.name = name
self._age = 0
self.week = 7 # 屬性名前有，使用屬性的時候不要直接用

@property
def age(self):
    return self._age

# 給age添加setter
@age.setter
def age(self, value):
    if not isinstance(value, int):
        raise ValueError
    if not (0 <= value <= 150):
        raise ValueError
    self._age = value

# 給week添加getter
@property
def week(self):
    if self._week < 7:
        return '星期%d' % self._week
    else:
        return '星期天'

@week.setter
def week(self, value):
    self._week = value

def main():
p1 = Person('小明')

# 通過不帶_的屬性給屬性賦值實質(zhì)是在調(diào)用setter對應的函數(shù)
p1.age = 45
p1.age = 3

# 這個操作實質(zhì)是在調(diào)用week函數(shù)
# 通過不帶_的屬性來獲取屬性的值實質(zhì)是在調(diào)用getter對應的函數(shù)
print(p1.week)
p1.week = 4

if name == 'main':
main()

"""author = drh"""
"""
1.什么是繼承
一個類繼承另外一個類，其中會產(chǎn)生繼承者和被繼承者。這兒的繼承者叫子類，被繼承者叫父類/超類
繼承就是讓子類直接擁有父類的方法和屬性

2.怎么繼承
語法：
class 類名(父類列表):
類的內(nèi)容

說明：
a.python中所有的類都是直接或者間接繼承自基類object
class 類名: ===> class 類名(object):
b.python中的繼承支持多繼承， 父類列表中可以有多個類，多個類之間用逗號隔開

3.能繼承哪些東西: 所有的屬性和方法都能夠繼承
注意：a.slots的值繼承后沒有效果
b.在類中給slots賦值后，當前類的對象不能使用dict;但是這個類的子類對象可以使用dict,
只是dict中沒有從父類繼承下來的對象屬性，只有在子類中添加的對象屬性
c.如果父類沒有給slots賦值，直接給子類的slots，無效！
"""

class Person(object):
num = 61
# slots = ('name', 'age', 'sex', '__face')

def __init__(self,name='zhangsan', age=0, sex='男'):
    self.name = name
    self.age = age
    self.sex = sex
    self.__face = 60

def eat(self, food):
    print('%s在吃%s' % (self.name, food))

@classmethod
def show_num(cls):
    print('人類的數(shù)量:%d' % cls.num)

class Student(Person):
# slots = ('name', 'age', 'sex', '__face')
pass

def main():
# Student.num = 20
print(Student.num)

stu = Student()
print(stu.name)
# print(stu.__dict__)
# print(stu.__face)

stu.eat('海底撈')

Student.show_num()

p1 = Person()
# print(p1.__dict__)
# p1.score = 100

stu.score = 100
print(stu.score)
print(stu.__dict__)

if name == 'main':
main()

"""author = drh"""
"""
======================添加方法====================
1.添加方法
直接在子類中聲明新的方法

2.重寫方法
在子類中重新實現(xiàn)父類的方法 - 完全重寫
保留父類的功能在子類中添加新的功能 - 部分重寫（在子類方法中通過'super().'的方式調(diào)用父類方法）

3.類中函數(shù)的調(diào)用過程
回到函數(shù)聲明的位置：先看當前類中是否有方法，如果有就直接調(diào)用當前類中的方法；沒有就去看父類中有沒有這個方法；
如果父類中也沒有就看父類的父類中有沒有....直到找到object類，如果object中也沒有就報錯！

=====================添加屬性======================
1.類的字段
直接在子類中聲明新的字段
"""

class Person(object):
num = 61

def __init__(self,name='zhangsan', age=0, sex='男'):
    self.name = name
    self.age = age
    self.sex = sex
    self.__face = 60

def eat(self, food):
    print('%s在吃%s' % (self.name, food))

@classmethod
def show_num(cls):
    print('人類的數(shù)量:%d' % cls.num)

class Student(Person):
num2 = 100

# 添加方法
def study(self):
    print('%s在寫代碼' % self.name)

@classmethod
def func1(cls):
    print('我是學生類的類方法')

@staticmethod
def func2():
    print('我是學生類的靜態(tài)方法')

@classmethod
def show_num(cls):
    print('學生數(shù)量:%d' % cls.num)

def eat(self, food):
    super().eat(food)
    print('吃飽了')

def main():
p1 = Person('張三')
stu1 = Student('李四')
stu1.study()

Student.func1()
# 子類可以使用父類的屬性和方法，但是父類不能使用子類中添加的屬性和方法
# Person.func2()

Person.show_num()
Student.show_num()

stu1.eat('包子')

print(Student.num2)

if name == 'main':
main()

"""author = drh"""
"""
添加對象屬性:
對象屬性其實是通過繼承init方法繼承下來的
"""

class Animal:

def __init__(self, age):
    self.age = age
    self.color = '灰色'

class Dog(Animal):
def init(self, name, age):
# 調(diào)用父類的init方法來繼承父類的對象屬性
super().init(age)
self.name = name

class Cat(Animal):
pass

練習：

聲明人類有屬性：名字、年齡、性別

聲明學生類有屬性：名字、年齡、性別、學號、分數(shù)

要求：創(chuàng)建人的對象的時候名字必須賦值，性別可以賦值也可以不賦值，年齡不能賦值；

創(chuàng)建學生對象的時候名字可以賦值可以不賦值，學號必須賦值，分數(shù)和性別、年齡不能賦值

class Person:
def init(self, name, sex='男'):
self.name = name
self.age = 0
self.sex = sex

class Student(Person):
def init(self, id, name='張三'):
super().init(name, '女')
self.id = id
self.score = 0

def main():
# 情景一：直接繼承，不添加
# dog1 = Dog()
# print(dog1.age)

dog2 = Dog('才才', 3)
print(dog2.name)
print(dog2.age, dog2.color)

if name == 'main':
main()

"""author = drh"""

"""
多繼承:
class 類名(父類1, 父類2,....):
類的內(nèi)容

多繼承的時候，多個父類中的所有方法和字段都可以繼承，只是對象屬性只能繼承第一個父類的
"""

class Animal:
def init(self, name=''):
self.name = name
self.age = 0
self.color = '黑色'

def fun1(self):
    print('動物中的對象方法')

class Fly:
def init(self):
self.height = 1000

def func2(self):
    print('飛行類的對象方法')

class Bird(Animal, Fly):
pass

def main():
b1 = Bird()
b1.fun1()
b1.func2()
print(b1.name, b1.age)
# print(b1.height) # 'Bird' object has no attribute 'height'

if name == 'main':
main()

"""author = drh"""

"""
1.什么是運算符重載
通過實現(xiàn)類中相應的魔法方法來讓當前類的對象支持相應的運算符

注意：python中所有的數(shù)據(jù)類型都是類; 所有的數(shù)據(jù)都是對象
"""

class Student(object):
def init(self, name='', age=0, score=0):
self.name = name
self.age = age
self.score = score

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

# 實現(xiàn)'+'對應的魔法方法，讓兩個學生對象能夠進行+操作
# self和other的關系： self+other    ==> self.__add__(other)
# 返回值就是運算結(jié)果
def __add__(self, other):
    # a.支持Student+Student:
    return self.age + other.age
    # b.支持Student+數(shù)字
    # return self.age + other

# self * other
# 將other當成數(shù)字
def __mul__(self, other):
    return self.name * other

# self和other都是學生對象
# 注意：大于和小于運算符是需要重載一個就行
def __gt__(self, other):
    return self.score > other.score

def main():
stu1 = Student('小花', 18, 90)
stu2 = Student('夏明', 20, 78)
stu3 = Student('小紅', 17, 99)

# 所有類的對象都支持'=='和'!='運算
print(stu1 == stu2)

print(stu1 + stu2)     # print(stu1.__add__(stu2))

# print(stu1 > stu2)
# print(stu1 < stu2)

print(stu1 * 2)   # print(stu1.__mul__(2))

students = [stu1, stu2, stu3]
print(students)
students.sort()
print(students)

if name == 'main':
main()

"""author = drh"""

"""
內(nèi)存管理
1.數(shù)據(jù)的存儲
內(nèi)存分為棧區(qū)間和堆區(qū)間；從底層來看，棧區(qū)間的內(nèi)存的開辟和釋放是系統(tǒng)自動管理的，堆區(qū)間的內(nèi)存是由程序員通過代碼開辟(malloc)和釋放的
從python語言角度，棧區(qū)間的內(nèi)存的開辟和釋放是系統(tǒng)自動管理的，堆區(qū)間的內(nèi)存關鍵也已經(jīng)封裝好了,
程序員也不需要寫代碼來開辟空間和釋放空間

a.python中變量本身是存在棧區(qū)間的，函數(shù)調(diào)用過程是在棧區(qū)間; 對象都是存在堆區(qū)間(python中所有數(shù)據(jù)都是對象)
b.變量賦值過程：先堆區(qū)間開辟空間將數(shù)據(jù)存起來， 然將數(shù)據(jù)對應的地址存到棧區(qū)間的變量中。
數(shù)字和字符串比較特殊，賦值的時候不會直接開辟空間，而是先檢測之前有沒有存儲過這個數(shù)據(jù)，
如果有就用之前的數(shù)據(jù)的地址

2.內(nèi)存釋放(垃圾回收機制)原理：
python中的每個對象都有一個屬性叫'引用計數(shù)',表示當前對象的引用的個數(shù)。判斷一個對象是否銷毀就看對象的引用計數(shù)是否為0；
為0的就銷毀，不為0的就不銷毀。

getrefcount函數(shù)：
getrefcount(對象) -> 獲取對象的引用計數(shù)
"""
from sys import getrefcount

def main():
list1 = [1, 2]
print(getrefcount(list1)) # 2

# 使用不同的變量存對象地址會增加引用計數(shù)
list2 = list1
print(getrefcount(list1))     # 3

[1, list1]
print(getrefcount(list1))    # 3

# def func1(obj):
#     print(getrefcount(list1))
#
# func1(list1)

print(getrefcount(list1))

list1 = []
print(getrefcount(list2))   # 2

del list2
# print(getrefcount(list2))   # UnboundLocalError


# def getrefcount(obj):
#     obj = list1
#     獲取obj的引用計數(shù)

bullets = [{'x': 10, 'y': 20}, {'x': 30, 'y': 10}, {'x': 100, 'y': 200}]
del bullets[2]

bullets.pop(0)

if name == 'main':
main()