一、属性私有化
二、
三、
四、
一、属性私有化
属性的访问权限：公开、保护、私有。其中属性私有化指属性只能在定义的类中使用。
私有属性格式：__属性名
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.可以通过点语法方便的来给属性赋值或者拿到它的值（不能是私有的）
- 给属性赋值的时候，需要对赋过来的值进行规范，不能直接就让值赋给属性(不能是直接的公开属性)
满足要求: 就使用假的私有属性 + getter和setter - 声明属性，属性名前加一个下划线（这个是规范，不是语法：带一个下划线的属性，不要直接通过一个下划线对应的属性名去访问这个属性）
- 通过给属性添加getter和setter来限制赋值和获取值的过程
a. 添加getter: --> 限制获取属性值的操作
getter的作用：返回属性的值
@property
def 属性名去掉下划线(self):
其他任何操作
return self.带下划线的属性名
@属性名去掉下划线.setter
def 属性名去掉下划线(self, 参数):
其他任何操作
self.带下划线的属性名 = 参数
- 在类的外部通过不带下划线的属性去获取属性的值，或者给属性赋值
示例一：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))
示例二：静态方法和类方法的区别
静态方法和类方法都是通过类去调用
区别：
- 类方法都有一个默认参数cls指向调用方法的类，但是静态方法没有
- 类型不一样，静态方法的类型是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())