私有化

python的私有化

python中在属性前面加两个下划线，就可以将属性或者方法私有化（只能两个下划线开头，不能结尾）
私有的属性和方法只能在类的内部使用，不能再类的外面使用

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.name,food)

    @classmethod
    def show_num(cls):
        print('人类数量为%d,%d'%(cls.num,cls.__num2))#人类数量为61,62

    @staticmethod
    def func1():
        print('保护大自然')

Person.show_num()

getter和setter

1.应用场景
getter：获取对象属性的值之前想要做点儿别的事情，就给这个属性添加getter
setter：给对象属性赋值之前想要做点儿别的事情，就给这个属性添加setter

2.添加getter
a.声明属性的时候在属性名前加一个下划线,
b.声明一个函数(函数没有除了self以外的参数，但是要有返回值，返回值就是获取属性拿到的值)，函数前面加@prooerty来修饰，函数名就是属性名去掉下划线
@property
def 去掉_的属性名（self）
做别的事情
返回属性的值
c.在类的外部通过对象.去掉下划线的属去获取相关的属性

3.添加setter -- 想要添加setter必须先要添加getter
a.声明属性的时候在属性名前加一个下划线,
b.声明函数（函数除了self以外还需要一个参数，没有返回值，这儿的参数代表给属性赋的值）
@属性名去掉下划线.setter
def 去掉的属性名(self,参数名)：
做别的事情
给属性赋值
c.在类的外面通过对象.去掉_的属性去给相关属性赋值

class Person:
    def __init__(self,name=' '):
        self.name=name
        self._age=0
        self._week=7 # 属性名前有_不要直接用
    @property
    def week(self):
        if self._week<7:
            return '星期%d'%self._week
        else:
            return '星期天'
    @property
    def age(self):
        return self._age

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

def main():
    p1=Person('小明')
    # 通过不带下划线的属性给属性赋值实质是调用setter对应的函数
    p1.age=10
    p1.name='asd'
    print(p1.week)
    print(p1.age)

继承

1.什么是继承
一个类继承另外一个类，其中会产生继承者和被继承者，继承者叫子类，被继承者叫做父类
继承就是直接让子类拥有父类的东西

2.怎么继承
class 类名（父类列表）：
类的类容

说明：
a.python中的类都是直接或者间接的继承于基类object
class 类名： ========> class 类名（object）：

b.python中的继承支持多继承，父类列表中可以有多个类，多个类之间用逗号隔开

3.能继承哪些东西：所有的方法属性
注意;sots的值不会继承
再类中给sots赋值后，当前类的对象不能使用dict，但是子类的对象可以使用，
只是dict中取不到从父类继承下来的对象属性，自由在子类中添加的对象属性

class Person(object):
    num=61

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

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

    @classmethod

    def show_num(cls):
        print('人类数量为%d'%cls.num)




class Student(Person):
    pass

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

    stu1=Student('张三')
    print(stu1.name) #张三
    stu1.eat('海底捞')#张三在吃海底捞
    Student.show_num() #人类数量为20

添加属性和方法

子类可以使用父类中的属性和方法，但是父类不能使用子类的属性和方法

1.添加方法
直接在子类中声明新的方法，
2.重写方法 -- 在子类中重新去实现父类中已有的方法，完全重写
3.部分重写 --

类中函数的声明过程：

===============================添加属性===============================================
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('人类的数量:%d' % cls.num)


class Student(Person):
    num2 = 100

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

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

    @staticmethod
    def func2():
        print('我是学生类的静态方法')

    @classmethod
    def show_num(cls):
        print('学生数量:%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)

添加对象属性

添加对象属性
对象属性其实是通过init方法继承下来了的

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

class Dog(Animal):
    def __init__(self,name,age):
        super().__init__(age)
        self.name=name








# 声明人类，属性：名字，年龄，性别
# 学生类，属性：名字，年龄，性别，学号，分数
# 人的对象名字必须赋值，性别可以赋值也可以不复制，年龄不能复制
# 创建学生们对象的时候，名字可以赋值也可以不赋值，学号必须赋值，分数和性别年龄不能赋值
class Person:
    def __init__(self,name,sex='w'):
        self.name=name
        self.sex=sex
        self.age=18

class Student(Person):
    def __init__(self,id,name='小花'):
        super().__init__(name)
        self.id=id
        self.score=88




p1=Person('小狗')
stu1=Student('stu001')
print(stu1.score,stu1.age)

def main():
    dog1=Dog('dahuang',2)
    print(dog1.name,dog1.color,dog1.age)

多继承

多继承：
class 类名（父类1，父类2，父类3......）

多继承的时候可以继承多个父类中的所有的字段和方法只是对象属性只能继承第一个父类的对象属性

class Animal:
   def __init__(self,name='小花花'):
       self.name=name
       self.age=0
       self.color='灰色'

   def func1(self):
       print('动物类的对象方法')

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

   def func2(self):
       print('飞行类的对象方法')

class Bird(Animal,Fly):
   pass

def main():
   pass
   b1=Bird()
   b1.func1()
   b1.func2()
   print(b1.name,b1.age)

运算符重载

1，什么是运算符重载，通过实现类中相应的魔法方法，来让当前类的对象支持相应的运算符

python中所有的数据类型都是类：所有的数据都是对象

注意大于小于运算符只需要重载一个就行

class Student:
    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]+'>'
    def __add__(self, other):
        return self.age+ other.age

    def __mul__(self, other):
        return self.name*other

    def __gt__(self, other):
        return self.age > self.age

def main():
    stu1=Student('小花',20,88)
    stu2=Student('小狗',21,90)
    stu3=Student('小黄',23,97)
    list1=[stu1,stu2,stu3]

    print(list1)
    list1.sort()
    print(list1)


    print(stu1+stu2)
    print(stu1*2)
    print(stu1>stu2)

内存管理机制

内存管理
1.数据的存储
内存分为栈区间和堆区间；从底层来看，栈区间的内存的开辟和释放是系统自动管理的，堆区间的内存是由程序员通过代码开辟(malloc)和释放的
从python语言角度，栈区间的内存的开辟和释放是系统自动管理的，堆区间的内存关键也已经封装好了,
程序员也不需要写代码来开辟空间和释放空间

a.python中变量本身是存在栈区间的，函数调用过程是在栈区间; 对象都是存在堆区间(python中所有数据都是对象)
b.变量赋值过程：先堆区间开辟空间将数据存起来， 然将数据对应的地址存到栈区间的变量中。
数字和字符串比较特殊，赋值的时候不会直接开辟空间，而是先检测之前有没有存储过这个数据，
如果有就用之前的数据的地址

2.内存释放(垃圾回收机制)原理：
python中的每个对象都有一个属性叫'引用计数',表示当前对象的引用的个数。判断一个对象是否销毁就看对象的引用计数是否为0；
为0的就销毁，不为0的就不销毁。

getrefcount函数：
getrefcount(对象) -> 获取对象的引用计数

from sys import getrefcount


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

    # 使用不同的变量存对象地址会增加引用计数
    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的引用计数

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

    bullets.pop(0)