Python小白学习进行时---面向对象编程（三）（2018-6

一、属性私有化

二、

三、

四、

一、属性私有化

属性的访问权限：公开、保护、私有。其中属性私有化指属性只能在定义的类中使用。
私有属性格式：__属性名

class Person:
"""人"""
def __init__(self, name='', age=0):
    # name属性是公开的属性
    self.name = name

    # __age属性是私有的属性
    self.__age = age

def show(self):
    print(self.name)
    # 私有属性可以类的内部使用
    print(self.__age)


p1 = Person('小明')
print(p1.name)

# 私有属性不能在类的外部去使用，否则报错
# print(p1.__age)  # AttributeError: 'Person' object has no attribute '__age'

 p1.show()

二、假的私有属性

实际开发中，声明类的属性，很少会使用真正的私有属性和公开属性(前面加两个下滑线的)。
实际对属性的要求：
1.可以通过点语法方便的来给属性赋值或者拿到它的值（不能是私有的）

2. 给属性赋值的时候，需要对赋过来的值进行规范，不能直接就让值赋给属性(不能是直接的公开属性)
   满足要求: 就使用假的私有属性 + getter和setter
3. 声明属性，属性名前加一个下划线（这个是规范，不是语法：带一个下划线的属性，不要直接通过一个下划线对应的属性名去访问这个属性）
4. 通过给属性添加getter和setter来限制赋值和获取值的过程

a. 添加getter: --> 限制获取属性值的操作
getter的作用：返回属性的值

@property
def 属性名去掉下划线(self):
   其他任何操作
    return self.带下划线的属性名

 @属性名去掉下划线.setter
 def 属性名去掉下划线(self, 参数):
    其他任何操作
    self.带下划线的属性名 = 参数

3. 在类的外部通过不带下划线的属性去获取属性的值，或者给属性赋值
   示例一：getter和setter的写法

class Person:

def __init__(self, name='', age=0):
    # 声明属性的时候，在属性名前加_,是为了告诉别人，
    # 这个属性不要直接访问，要通过getter或者setter去访问
    self._name = name
    self._age = age

# 给_name属性添加getter
@property
def name(self):
    if len(self._name) == 0:
        return '无名氏'
    return self._name

# 给_name属性添加setter
@name.setter
def name(self, name1):
    # 可以在给属性赋值前做其他操作
    if isinstance(name1, str):
        self._name = name1
    else:
        self._name = ''

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


p1 = Person('小明')
print(p1._name)  # 是不会报错的，但是不推荐使用
p1._name = '路飞'

print(p1.name)
p1.name = '娜美'
print(p1.name)

1.getter一般要添加， setter可以不用写
2.如果要添加setter必须添加getter

示例二：getter和setter的使用以及关系

class Cat:
"""猫"""

def __init__(self, name='', color=''):
    self._name = name
    self._color = color

@property
def name(self):
    if isinstance(self._name, str):
        return self._name
    else:
        return ''

@name.setter
def name(self, name):
    self._name = name

cat1 = Cat('小花', 'yeloow')
cat1._name = '喵喵'  # 推荐
print(cat1._name)  # 不推荐

练习：写一个学生类，有名字、成绩两个属性。要求成绩是数字、名字是字符串

class Student:

def __init__(self, name='', score=0):
    self._name = name
    self._score = score

#   在getter中限制类型
@property
def name(self):
    # if isinstance(self._name, str):
    #     return self._name
    return str(self._name)

# 通过setter去限制
@property
def score(self):
    return self._score

@score.setter
def score(self, score):
    if isinstance(score, int) or isinstance(score, float):
        print('---')
        self._score = score
    else:
        self._score = 0


stu1 = Student('张胜男', 100)
stu1._name = 123
print(stu1.name)

stu1.score = 'abc'
print(stu1.score)

三、类字段和类方法

1.类字段就是类属性：通过类去获取
类字段是声明在类里面，函数外面的变量

2.类方法：通过类去调用
开发中怎么确定声明方法是对象方法还是类方法：看实现的功能是否需要对象属性来支持，如果需要就必须声明称对象方法

class Person:
"""人类"""
    # 这个person_num就是一个类字段
    person_num = 0

# @classmethod来说明下面的函数是一个类方法 --> 函数修饰符
# 所有的类方法都有一个默认参数cls,这个参数不需要传参，系统会自动将调用方法的类传给它(谁调用指向谁)
    @classmethod
    def hurt_earth(cls):
        print(cls)
        print('人类伤害破坏环境，伤害地球', Person.person_num, cls.person_num)


# 类字段要用类去使用
print(Person.person_num)

# 通过Person类调用类方法
Person.hurt_earth()
print(Person)

练习：写一个数学类，提供数据的加、减、乘、除的功能

class Math:
    @classmethod
    def add(cls, *num):
        sum1 = 0
        for x in num:
            sum1 += x
        return sum1


sum1 = Math.add(10, 2, 3)
print(sum1)

四、静态方法

静态函数：在类中声明，由类来调用的方法

示例一： 静态方法

class Math:
"""数学类"""

# multiply就是一个静态方法
@staticmethod
def multiply(num1, num2):
    return num1 * num2


# 静态方法需要使用类来调用
print(Math.multiply(10, 4))

示例二：静态方法和类方法的区别

静态方法和类方法都是通过类去调用

区别：

1. 类方法都有一个默认参数cls指向调用方法的类，但是静态方法没有
2. 类型不一样，静态方法的类型是function，类方法的类型是method

class Download:
"""下载类"""
@staticmethod
def download_image(image_file):
    print('下载%s下的图片' % (image_file))

@classmethod
def dowload_movie(cls, movie_file):
    print('下载电影:%s' % (movie_file))

# 类中的普通函数也是通过类来调用(就是一个静态方法)
def download(num):
    print('aaa', num)


Download.download_image('aa/123.png')
print(Download.download_image)

Download.dowload_movie('aa/abc.mp4')
print(Download.dowload_movie)

print(Download.__dict__)

Download.download(100)
print(Download.download)

五、类的继承

继承：继承就是让子类去拥有父类的属性和方法
子类：继承者
父类(超类)：被继承者

实例一：怎么继承

class 子类(父类):
    子类的内容

class Person:
    """人"""
    def __init__(self, name='aaa', age=0):
        self.name = name
        self.age = age


class Student(Person):
    pass

stu1 = Student()
print(stu1.name)

实例二：继承范围
1.公开属性可以继承
2.私有的属性不可以继承
3.公开的对象方法可以继承（私有的不行）
4.类字段可以继承
5.类的方法和静态方法可以

总结：属性和方法除了私有的都可以继承; slots不能继承的

class Animal:
#1.对象的属性
__slots__ = ('name', '__age')
def __init__(self, name='bb'):
    self.name = name
    self.__age = 18

def run(self):
    print(self.__age)

#2.对象方法
def eat(self):
    print('吃东西')

# 私有的对象方法，只能类的内部调用
def __shout(self):
    print('叫')

#3.类字段
count = 100

#4.类方法
@classmethod
def class_func(cls):
    print('class_func')

#5.静态方法
@staticmethod
def static_func():
    print('static_func')


  class Dog(Animal):
  pass
  # def eat_bone(self):
  #     print('吃骨头',self.__age)



dog1 = Dog()
print(dog1.name)
dog1.eat()
print(Dog.count)
Dog.class_func()
Dog.static_func()

dog1.color = 'red'
print(dog1.color)

六、类的继承重写

声明一个类，如果不声明其父类，那么这个类默认继承自object这个类。
object类是python中所有类直接或者间接的父类

示例一：什么是重写

重新实现从父类继承下来的方法 ---> 重写

class Aniaml(object):

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

def shout(self):
    print('%s:嗷嗷叫' % (self.name))

def be_beat(self):
    print(self.name,'在跑')
    print('跑的时候嗷嗷叫')

class Dog(Aniaml):

# 重写父类的shout方法。然后通过Dog对象调用shout执行的是子类的方法
def shout(self):
    print('%s:汪汪汪！'% (self.name))

# 重写父类的be_beat，保留了父类实现的功能，并且添加了新的功能
def be_beat(self):
    # super()指的就是父类对象
    super().be_beat()
    print('奋起反抗')


dog1 = Dog('大黄')
dog1.shout()
dog1.be_beat()

示例2：init方法的继承和重写

 class Person:
"""人"""
def __init__(self, name='', age=0):
    self.name = name
    self.age = age


class Student(Person):
"""学生类"""
"""
重写init方法要注意：
1.如果需要继承父类的对象属性，就需要通过super().__init__()去保留父类的对象属性。然后再添加新的属性
"""
def __init__(self, name='', age=0, study_id=''):
    super().__init__(name, age)
    self.study_id = study_id


stu1 = Student()
print(stu1.name)
print(stu1.study_id)

stu2 = Student('name1', 18, '001')
print(stu2.name)

stu3 = Student(study_id='002')

练习：

设计两个类：
一个正方形类，拥有方法：求面积、求周长 拥有的属性是边长
一个长方形类，拥有方法：求面积、求周长 拥有的属性是长和宽

提示：正方形就是特殊的长方形

class Rect:
def __init__(self, length=0, width=0):
    self.length = length
    self.width = width

def area(self):
    return self.width * self.length

def perimeter(self):
    return (self.width + self.length)*2


class Square(Rect):
    def __init__(self, length=0, width=0):
        super().__init__(length, width)
        self._side = 0

  @property
   def side(self):
        return self._side

@side.setter
def side(self, side):
    self.width = side
    self.length = side
    self._side = side


s1 = Square()
s1.side = 10
print(s1.area())
print(s1.perimeter())