python-日志-day15-2019-08-9

day15-面向对象

一.内置类属性

1.什么是内置类属性

声明类的时候系统自动添加的属性(可能是字段也可能是对象属性)

import json


class Person:
    """
    说明文档: 人类
    num - 人类的数量
    name - 人的名字
    """
    num = 61

    # 注意: 如果设置了__slots__的值,那么当前类的对象就不能使用__dict__属性
    # __slots__ = ('name', 'gender', 'age')

    def __init__(self, name, gender, age):
        self.name = name
        self.gender = gender
        self.age = age

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

    # 定制当前类的对象的打印
    # 1) 重写__str__方法, 这个方法的返回值就是对应的打印结果(类型必须是字符串)
    # def __str__(self):
    #     # return '姓名:{}, 年龄:{}, 性别:{}'.format(self.name, self.age, self.gender)
    #     return '<'+str(self.__dict__)[1:-1]+'>'

    # 2)重写 __repr__方法,这个方法的返回值就是对应的打印结果(类型必须是字符串)
    def __repr__(self):
        # return '姓名:{}, 年龄:{}, 性别:{}'.format(self.name, self.age, self.gender)
        # <'name': '小明', 'gender': '男', 'age': 18>
        return '<' + str(self.__dict__)[1:-1] + '>'
        # return 'abc'


p1 = Person('小明', '男', 18)
# 1.__name__
"""
类的字段; 类.__name__  - 获取类的名字(字符串)
"""
print(type(Person), Person)
print(type(int))
print(Person.__name__)

# 2.__doc__
"""
类的字段; 类.__doc__   - 获取类的说明文档
"""
print(Person.__doc__)
print(int.__doc__)

# 3.__class__
"""
对象属性; 对象.__class__   -  获取对象对应的类,返回的是类
         (和type(对象)功能一样)
"""
print(p1.__class__)
print(type(p1))
# type1 = p1.__class__
type1 = type(p1)
print(type1.__name__)
p2 = type1('小花', '女', 17)
print(p2.name, p2.gender, p2.age)


# 4.__dict__ (将对象转换成字典)
"""
对象属性; 对象.__dict__  - 将对象所有的属性和对应的值转换成一个字典中的键值对(一个对象对应一个字典)
类的字段; 类.__dict__  - 将类转换成一个字典,字典中的元素是类中所有的字段和对应的值
"""
print(p1.__dict__)
print(Person.__dict__)
print('p1:', p1)
print('p2:', p2)

persons = [p1, p2]
print(persons)


# 5. __module__
"""
类的字段; 类.__module__  -  获取当前类是在哪个模块中声明的(返回的是模块的名字)
"""
print(Person.__module__)
print(bool.__module__)

# 6.__bases__
"""
类的字段; 类.__bases__  -  获取当前类的父类(返回的是一个元祖)
"""
print(Person.__bases__)


# 练习: 将字典转换成对象
with open('data', 'r', encoding='utf-8') as f:
    content = json.loads(f.read())
    datas = content['data']


class Data:
    def __init__(self, dict1: dict):
        for key in dict1:
            setattr(self, key, dict1[key])

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


for item in datas:
    data = Data(item)
    print(data.name, type(data))
    # print(data)

二.私有化

1.访问权限

公开,保护,私有
公开 - 公开的属性和方法在类的内部,外部以及子类能够使用,也能被继承
保护 - 保护的属性和方法在类的内部能够使用,外部不能使用,可以被继承
私有 - 私有的属性和方法只能在类的内部使用,外部不能使用,也不能被继承

2.python中属性和方法的访问权限

python类中所有的属性和方法本质都是公开的;
私有化是假私有化,只是提供程序员这个属性或者方法在外部不能要使用,也不要去继承
怎么私有化:
在需要私有化的属性名或者方法名前加''(注意,不能以结尾)

class Person:
    __num = 61

    def __init__(self, name, age):
        self.name = name
        self.__age = age

    def eat(self,food='米饭'):
        print('%s在吃%s' % (self.name, food))
        print('内部:', Person.__num)
        self.func1()

    def func1(self):
        print('函数')
        print(self.__age)
        self.__func2()

    def __func2(self):
        print('私有函数')


p1 = Person('xiaoming', 20)
# print(Person.num, p1.name, p1.age)
# p1.eat()
# p1.func1()
# print(Person.__num)    # AttributeError: type object 'Person' has no attribute '__num'
# p1.eat()

# print(p1.__age)   # AttributeError: 'Person' object has no attribute '__age'
p1.func1()
# p1.__func2()   # AttributeError: 'Person' object has no attribute '__func2'


print(p1.__dict__)
print(p1._Person__age)
p1._Person__func2()

三.属性的getter和setter

1.什么是getter和setter

当我们需要在获取属性值之前做点别的事情就需要给这个属性添加getter;
当需要给属性赋值之前做别的事情,就需要给这个属性添加setter

2.给属性添加getter

  1. 属性命名的时候前面加'_'
  2. 在@property装饰器的后面声明一个对象方法
    a.将属性去掉下划线作为方法名
    b.方法除了self以外不需要其他参数
    c.函数的返回值就是获取这个属性的时候得到的值
  3. 在外部使用属性的时候,通过'对象.不带下滑的属性'去使用

注意: 获取属性值的时候,就会自动去调用getter对应的函数

3.给属性添加setter

属性添加setter之前必须先添加getter
1)保证属性名前有'',后面不能有''
2)在@getter名.setter后面声明对象方法
a.将属性去掉下划线作为方法名
b.需要一个self以外的参数
c.不需要返回值

  1. 在外部使用属性的时候,通过'对象.不带下滑的属性'去使用

注意: 当给属性赋值的时候,实质是调用setter对应的方法


class Person:
    count = 0

    def __init__(self, name, age, gender):
        self.name = name
        self._age = age
        self._gender = 1
        self._week = 3

    # 添加getter
    @property
    def week(self):
        if self._week == 0:
            return '星期天'
        elif self._week == 1:
            return '星期一'
        elif self._week == 2:
            return '星期二'
        elif self._week == 3:
            return '星期三'
        elif self._week == 4:
            return '星期四'
        elif self._week == 5:
            return '星期五'
        elif self._week == 6:
            return '星期六'

    @property
    def age(self):
        Person.count += 1
        print('年龄值被访问!!!!')
        return self._age

    @age.setter
    def age(self, value):
        print('年龄值被修改!')
        if not isinstance(value, int):
            raise ValueError
        if not 0 <= value <= 200:
            raise ValueError
        self._age = value

    @property
    def gender(self):
        if self._gender == 1:
            return '女'
        return '男'

    @gender.setter
    def gender(self, value):
        raise ValueError


p1 = Person('xiaoming', 18, '男')
# p1.age = 1908
# print(p1.age)
# print(p1.name, p1.age, p1.gender, p1.week)
print(p1.week)    # 这儿实质是在调用week方法获取返回值


p2 = Person('小花', 20, '女')
p2._week = 5
print(p2.week)

print(p1.age)        # p1.age()
age1 = p1.age
print(p2.age)     # p2.age()

p1.age = 67      # p1.age(200)

print(p1.gender)
# p1.gender = '男'


# 练习: 写一个矩形类
# 有属性: 长、宽、面积、周长
# 要求从生活的角度看这个矩形
class WriteError(Exception):
    def __str__(self):
        return '修改只读属性!'


class Rect:
    def __init__(self, length, width):
        if isinstance(length, int) or isinstance(length, float):
            self._length = length
        else:
            raise ValueError
            # self._length = 0

        self._width = width
        self._area = 0
        self.perimeter = 0

    @property
    def length(self):
        return self._length

    @length.setter
    def length(self, value):
        if not (isinstance(value, int) or isinstance(value, float)):
            raise ValueError

        if value < 0:
            raise ValueError

        self._length = value

    @property
    def area(self):
        self._area = self._length * self._width
        return self._area

    @area.setter
    def area(self, value):
        raise WriteError


r1 = Rect(100, 300)
print(r1.area)

r1.length = 20
print(r1.area)
# r1.area = 100

r2 = Rect('abc', 'ui')

四.类方法和静态方法

1.类中的函数

类中的方法分为:对象方法,类方法和静态方法
1)对象方法
a.怎么声明: 直接声明
b.怎么调用: 用对象来调用
c.特点: 有指向当前对象的self
d.什么时候用:如果实现函数的功能需要用到对象属性,就使用对象方法

2)类方法
a.怎么声明: 声明在@classmethod后面
b.怎么调用: 用类来调用, '类.类方法()'
c.特点: 有自带的参数cls,表示当前类; 这个参数在调用的时候不用传参,系统会自动将当前类传给它;
cls:谁调用就指向谁(如果是对象指向的是对象对应的类)
d.什么时候用: 如果实现函数的功能不需要对象属性,但是需要类的字段, 就使用类方法

3)静态方法
a.怎么声明: 声明在@staticmethod后面
b.怎么调用: 通过类来调用, '类.静态方法()'
c.特点: 没有默认参数
d.什么时候用: 实现函数的功能既不需要类也不需要对象,就使用静态方法


class Person:
    num = 61

    def __init__(self, name: str, age: int, gender: str):
        self.name = name
        self.age = age
        self.gender = gender

    def eat(self, food: str):
        # 对象能做的事情,self都能做
        print(self.name+'在吃'+food)

    @classmethod
    def func1(cls):
        # 类能做的事情,cls都能做
        print(cls)
        t = cls('a', 10, 'b')
        print('t:',t)
        print(cls.num)
        print('这是一个类方法!')

    @staticmethod
    def func2():
        print('这是一个静态方法!')
        print(Person.num)

    def func3(self):
        print('这是一个函数!', self.name)

    def func4(self):
        print(self.age, Person.num)


Person.func1()
print(Person)

# p1 = Person('夏明', 90, '男')
# p1.func1()

Person.func2()


p1 = Person('夏明', 90, '男')
p1.func4()


class Student(Person):
    num = 10

    @staticmethod
    def func2():
        print('这是一个静态方法!')
        print(Student.num)


print('============1=============')
Student.func1()
Person.func1()

print('=============2============')
Student.func2()
Person.func2()

五.继承

1.什么是继承

继承就是让子类直接拥有父类的属性和方法
子类 - 继承者
父类/超类 - 被继承者

2.怎么继承

1)语法
class 类名(父类1,父类2,..):
说明文档
类的内容
2)说明:
() - 固定写法,如果省略相当于(object)
声明类的时候如果没有写父类,默认继承object(object又叫基类)
父类 - 一个类的父类可以有多个,但是一般情况下只有一个(支持多继承)


class Person:
    num = 61

    def __init__(self):
        print('Person中init')
        self.name = '小明'
        self.age = 18
        self.gender = '男'
        self.__a = 10

    def eat(self, food='米饭'):
        print('{}在吃{}'.format(self.name, food))

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

    @staticmethod
    def func1():
        print('人类')

    def func2(self):
        print('我是'+self.name)


class Student(Person):
    num = 10

    def __init__(self):
        # 在子类中添加对象属性,需要先通过super()去调用父类的__init__来继承父类的对象属性
        super().__init__()
        print('Student中init')
        self.study_id = '001'
        self.class1 = 'py1904'

    # 添加功能
    def study(self):
        print(self.name+'在好好学习!')


    @staticmethod
    def func1():
        print('学生')

    def func2(self):
        print('我是学生!')
        # 在子类中可以通过super()可以去调用父类的方法
        # 注意: super()只能在对象方法和类方法中使用
        super().func2()


stu1 = Student()
print(Student.num)
print(stu1.name, stu1.age, stu1.gender)
stu1.eat()
Student.show()
print(stu1.__dict__)
Student.func1()

stu1.func2()

你可能感兴趣的:(python-日志-day15-2019-08-9)