2019-01-14

Day16-面向对象2

一、 私有化

1、 属性和方法的访问权限

私有的：在类的外部不可以使用，也不可以继承
保护的：在类的外部不可以继承，可以继承
公开的：在类的外部可以使用，也可以被继承

2、 python的私有化

python中属性和方法的访问权限只有公开，但是提供了另一种私有化的方式
python中在属性或者方法名前加''，就可以将属性或者方法变成私有的（注意：不能''结尾）
私有的属性和方法只能在类的内部使用，不能再类的外面使用

3、 python私有化的原理

在名字前是'_'的属性和方法前在加'类名'去保存属性和方法


class Person:
    num = 61
    __num2 = 62

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

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

    @classmethod
    def show_num(cls):
        print('人类的数量：%d' % cls.num)

    @staticmethod
    def func1():
        print('人类要保护大自然！')



def main():
    p1 =Person()

    print(Person.num)
    print(p1.name)
    p1.eat('面条')
    Person.func1()
    print(p1._Person__sex)


if __name__ == '__main__':
    main()

二、getter和setter

1、 应用场景。

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

2 、 getter

第一步： 声明属性的时候，在属性名前加''
第二步： 声明函数（函数没有除了self以外的参数，但是要有返回值。返回值就是获取属性拿到的值）
@property
def 去掉下划线的属性名（self）：
做点别的事情
返回属性的值
第三步：在类的外部通过 对象.取消的属性去获取相关的属性

3、 setter - 想要添加setter必须先要有getter

第一步：声明属性的时候在属性名前加_
第二步：声明函数（函数除了self以外还需要一个参数，没有返回值。这儿的参数代表属性赋的值）
@属性名去掉.setter
def 去掉的属性名(self,参数):
做点别的事情
给属性赋值
第三步：在类的外部通过对象.去掉_的属性去给相关属性赋值

class Person:
    def __init__(self, name=''):
        self.name = name
        self._age = 0
        self._week = 1         # 前面有_的不能直接调用

    # 添加getter
    @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



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

def main():
    p1 = Person('小明')
    p1.age = 100
    print(p1.age)
    p1.age = 2333
    p1.age = 'sjd'
    # 这个操作实质是在调用week函数
    # 通过不带_的属性来获取属性的值实质是在调用getter对应的函数
    print(p1.week)






if __name__ == '__main__':
    main()

三、继承

1、 什么是继承

一个类继承另外一个类，其中会产生继承者和被继承者。这儿的继承者叫子类，被继承者叫父类或者超类
继承就是让子类直接拥有父类的方法和属性

2、 怎么继承

class 类名(父类列表):
类的内容
说明：
a. python中所有的类都是直接或间接继承自基类object
class 类名: ====> class 类名(object):
b. python中的继承支持多继承，父类列表中可以有多个类，多个类之间有逗号隔开

3、 能继承哪些东西：所有的属性和方法都能够继承

注意：slots的值不会继承
在类中给slots赋值后，当前类的对象不能使用dict；但是这个类的子类对象可以使用dict，
只是dice中没有从父类继承下来的属性，只有在子类中添加的对象属性
如果父类没有给slots赋值，直接给子类slots无效



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

    def __init__(self, name='', 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 shw_num(cls):
        print('人类的数量：%d' % cls.num)


class Student(Person):
    pass


def main():
    print(Student.num)

    stu = Student()
    print(stu.name)

    stu.eat('串串')


if __name__ == '__main__':
    main()

四、添加属性和方法

=====================添加方法======================

1、 添加方法

直接在子类中声明新的方法

2、 重写方法

在子类中重新实现父类的方法 - 完全重写
保留父类的功能在子类中添加新的功能 - 部分重写（在子类方法中通过'super().'的方式调用父类方法）

3、 类中函数的调用过程

回到函数声明的位置：先看当前类中是否有方法，如果有就直接调用当前类中的方法；没有就去看父类有没有这个方法；
如果父类中也没有就看父类的父类中有没有……直到找到object类，如果object中也没有就报错。
=====================添加属性======================

1、 类的字段

直接在子类中只能声明新的字段




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

    def __init__(self, name='', 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 shw_num(cls):
        print('人类的数量：%d' % cls.num)

class Student(Person):
    # 添加方法
    def study(self):
        print('%s在写代码' % self.name)
    @classmethod
    def func1(cls):
        print('子类的类方法')
    @classmethod
    def shw_num(cls):
        print('学生的数量：%d' % cls.num)




def main():
    p1 =Person('张三')
    stu1 = Student('李四')
    # 子类可以使用父类的属性和方法，但是父类不能使用子类中添加的属性和方法
    Student.func1()
    Person.shw_num()
    Student.shw_num()



if __name__ == '__main__':
    main()

添加对象属性

对象属性其实是通过继承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


def main():
    dog1 = Dog('123', 3)
    print(dog1.age)
    dog2 = Dog('旺财', 3)
    print(dog2.name)


if __name__ == '__main__':
    main()


# 练习
# 声明人类，有属性，年龄，性别
# 声明学生类，有属性，年龄，性别，学号，分数
# 要求：创建人的对象的时候名字必须赋值，性别可以赋值也可以不赋值，年龄可以不赋值
# 创建学生对象的时候名字可以赋值可以不赋值，学号必须赋值，分数和性别、年龄不能赋值

class Person:
    def __init__(self, name, sex='无'):
        self.name = name
        self.age = 20
        self.ex = sex


class Student(Person):
    def __init__(self, id, name='暂无'):
        super().__init__(name)
        self.id = id
        self.score = 99

s1 = Student(1)
print(s1.id)

五、运算符重载

1、 什么是运算符重载

通过实现类中相应的魔法方法让当前类的对象支持相应的运算符
注意：python中所有的数据类型都是类，所有的数据都是对象



class Student:
    def __init__(self, name, age, score):
        self.name = name
        self.age = age
        self.score = score

    # 实现‘+’对应的魔法方法，让两个学生对象能够进行‘+’操作
    # self和other的关系：self + other ====>   self.__add__(other)
    # 返回值就是运算结果
    def __add__(self, other):
        return self.age + other.age

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

    # 注意：大于和小于运算符只重载一个方法

def main():
    stu1 = Student('小花', 18, 90)
    stu2 = Student('小花', 18, 90)
    print(stu1 == stu2)
    print(stu1 + stu2)
    print(stu1 * 3)


if __name__ == '__main__':
    main()

六、内存管理

内存管理

1、 数据的存储

内存分为栈区间和堆区间；栈区间内存的开辟和释放是系统自动管理的，堆区间的内存是由程序员通过代码开辟（malloc）和释放的
从python语言较低，栈区间内存的开辟和释放是系统自动管理的，堆区间的内存关键也已经封装好了，
程序员也不需要写代码来开辟空间和释放空间。
a. python中变量本身是存在栈区间的，函数调用过程是在栈区间；对象（python中所有的数据都是对象）都是存在堆区间。
b. 变量赋值过程：先堆区间开辟空间将数据存起来，然后后将数据对应的地址存到栈区间的变量中。
数字和字符串比较特殊，赋值的时候不会直接开辟空间，而是先检测之前有没有存储过这个数据，如果有就用之前的数据地址。

2、 内存释放(垃圾回收机制)原理：

python中的每个对象都有一个属性叫‘引用计数’，表示当前对象引用的个数，判断一个对象是否销毁，就看对象的引用计数是否为0.
为0的就销毁，不为0的就不销毁。

# getrefcount(对象)  - > 获取对象的引用计数
from sys import getrefcount


def main():
    list1 = [1, 2]
    print(getrefcount(list1))
    # 使用不同的变量存对象地址会增加引用计数
    list2 = list1
    print(getrefcount(list2))


if __name__ == '__main__':
    main()
©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

推荐阅读更多精彩内容

  • 面试题
    Swift1> Swift和OC的区别1.1> Swift没有地址/指针的概念1.2> 泛型1.3> 类型严谨 对...
    cosWriter阅读 11,136评论 1赞 32
  • 极迅云课（服务端教案）
    一、Python简介和环境搭建以及pip的安装 4课时实验课主要内容 【Python简介】： Python 是一个...
    _小老虎_阅读 5,804评论 0赞 10
  • 忧伤也可以很温暖
    一个人的忧伤分很多种，他们的忧伤都是在生活，在岁月中埋藏了一段时间，或许很久，忧伤不同于悲伤，痛苦，忧伤就好像...
    时光尚浅等下你阅读 163评论 0赞 2
  • 绿萝花开
    （20160824，上海睛） 写下这个题目的时候觉得自己很白痴，赶忙在网上搜索看看绿萝的习性。 绿萝（学名：E...
    南宁唐方阅读 1,012评论 1赞 3
  • 月亮代表我吻你
    我不知道你去了哪里 记忆里只剩下你微笑着转身而去 过去的日子是一杯羞涩的美丽 我不曾抓紧就已随风飘离 这么多年它绿...
    守海入梦阅读 864评论 12赞 11