01-privatization of attributes 属性的私有化
02-False private attribute getter and setter 假的私有属性
03-class fields and method 类字段和类方法
04-static method 静态方法
05-inheritance of class 类的继承
06-class inheritance override 类的继承重写（掌握）
01-privatization of attributes 属性的私有化
属性的访问权限：公开、保护(python中没有)、私有
公开：指的是在类的外部可以直接使用(默认)
公开属性：属性名是普通单词
私有：只能在类的内部直接使用
私有属性：属性名以两个下划线开头'__'（不以两个下划线结束）
class Person:
"""人"""
def __init__(self, name='', age=0):
# name属性是公开的属性
self.name = name
# __age属性是私有的属性
self.__age = age
def show(self):
# 私有属性可以在类的内部去使用
print(self.__age)
p1 = Person('小明')
print(p1.name)
# 私有属性不能在类的外部去使用
# print(p1.age) # value:AttributeError: 'Person' object has no attribute 'age'
p1.show()
02-False private attribute getter and setter 假的私有属性
实际开发中，声明类的属性，很少会使用真正的私有属性和公开属性（前面加两个下划线的）
实际对属性的要求：
1.可以通过 对象.属性 语法方便的来给属性赋值或者拿到它的值（不能是私有的）
2.给属性赋值的时候，需要对赋过来的值进行规范，不能直接就让值赋给属性（不能是直接的公开属性）
满足要求：就是假的私有属性+getter和setter
1.声明属性，属性名前加一个下划线（这个是规范，不是语法：带一个下划线的属性，不要直接使用）
2.通过给属性添加getter和setter来限制赋值和获取值的过程
a.添加getter:-->限制获取属性值的操作
getter的作用：返回属性的值
@property
def 属性名去掉下划线(self):
其他任何操作
return self.带下滑线的属性名
b.setter-->限制添加属性值的操作
setter的作用：修改属性的值
@属性名去掉下滑线.setter
def 属性名去掉下划线(self, 参数)：
其他任何操作
self.带下划线的属性名 = 参数
3.在类的外部通过不带下划线的属性去获取属性的值，或者给属性赋值
示例一：
class Person:
def __init__(self, name, age):
# 声明属性的时候，在属性名前加_,是为了告诉别人，这属性不要直接访问，要通过getter或者setter
self._name = name
self._age = age
@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
@age.setter
def age(self, age1):
if isinstance(age1, int):
self._age = age1
else:
print('请重新赋值')
p1 = Person('xi_ao_ming', 9)
# print(p1._name) # 是不会报错，但不推荐使用
# p1._name = '路飞'
p1.name = '娜美'
print(p1.name)
print(p1.age)
p1.age = 0
print(p1.age)
getter一般要添加， setter可以不用写
如果要添加setter必须添加getter
示例二：getter 和 setter的使用以及关系
class Cat:
"""猫"""
def __init__(self, name='', color=''):
self._name = name
self._color = color
@property
def name(self):
return self._name
cat1 = Cat('小花', 'yellow')
cat1._name = '喵喵' # 推荐
print(cat1._name) #显示波浪线-->不推荐
getter 与 setter限制类型的使用
练习
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 'sdg'
# 在setter中限制类型
@property
def score(self):
return self._score
@score.setter
def score(self, score1):
if isinstance(score1, int) or isinstance(score1, float):
self._score = score1
else:
print('please input number')
s1 = Student()
s1._name = 'st'
print(s1.name)
s1.score = 3.9
print(s1.name,s1.score)
03-class fields and method 类字段和类方法
3.1.类字段就是类属性：通过类去获取
类字段是声明在类里面，函数外面的变量
3.2.类方法：通过类去调用
格式：
@classmethod -->函数修饰符
def 函数名(cls): -->默认参数cls，系统会自动将调用方法的类传给它
语句块
注意：声明成对象方法还是类方法：看实现的功能是否需要对象属性来支持，如果需要，必须声明成对象方法
class Person:
"""
人类
"""
# 这个person_num就是一个类字段
person_num = 60e8
# @classmethod来说明下面的函数是一个类方法 -->函数修饰符
# 所有的类方法都有一个默认参数cls，这个参数不需要传参，系统会自动将调用方法的类传个它
@classmethod
def hurt_earth(cls):
print(cls)
print('human damages the environment ,hurt earth',Person.person_num,cls.person_num)
# 类字段要用类去使用
print(Person.person_num)
# 通过Person类调用类方法
Person.hurt_earth()
print(Person)
# 类字段要用类去使用
print(Person.person_num)
练习：写一个数学类，提供数据的加、减、乘、除的功能
class Math:
@classmethod
def add(cls,*num):
sum1 = 0
for x in num:
sum1 += x
return sum1
@classmethod
def divide(cls, num1, num2):
return num1/num2
re = Math.add(10, 2, 4)
print(re)
04-static method 静态方法
静态函数：在类中声明，由类来调用的方法
示例一：静态方法
class Math:
"""数学类"""
# multiply就是一个静态方法
@staticmethod
def multiply(num1, num2):
return num1*num2
# 静态方法需要使用类来调用
print(Math.multiply(2, 4))
示例二：静态方法和类方法的区别
共同点：都需要用类名去调用
区别：
1.类方法都有一个默认参数cls指向调用方法的类，但静态方法没有
2.类型不一样，静态方法的类型是function，类方法的类型是method
class Download:
"""下载类"""
# 静态方法
@staticmethod
def download_image(image_file):
print('download picture in %s ' % image_file)
# 类方法
@classmethod
def download_movie(cls, movie_file):
print('download movie in %s' % movie_file)
# 类中的普通函数，也是同过类来调用
def down(num):
print('aaa', num)
Download.download_image('aa/123.png')
print(Download.download_image) # <function Download.download_image at 0x0038B8A0>
Download.download_movie('aa/safa.avi')
print(Download.download_movie) #<bound method Download.download_movie of <class '__main__.Download'>>
Download.down(234)
print(Download.down) # <function Download.down at 0x0038B810>
print(Download.__dict__)
05-inheritance of class 类的继承
继承：继承就是让子类去拥有父类的属性和方法
子类：继承者
父类(超类)：被继承者
什么时候用继承：
在写一个类的时候，发现这个类中的部分属性和方法另一个类都拥有,
这个时候就不用去声明这些属性和方法，直接从另外一个类中继承下来就可以了
5.1：怎么继承
class 子类(父类)：
子类的类容
class Person:
"""人"""
def __init__(self, name='aaa', age=55):
self.name = name
self.age = age
class Student(Person):
pass
stu1 = Student()
print(stu1.name)
5.2：可以继承哪些东西？
1.公开属性可以继承;私有属性不能继承
2.公开的对象方法可以继承；私有的不行
3.类字段可以
4.类的方法和静态方法可以
总结：属性和方法除了私有的都可以继承;slots不能继承
class Animal:
# 1.对象的属性
__slots__ = ('name', '__age')
def __init__(self, name='abc', age=55):
self.name = name
self.__age = age
def run(self):
print(self.__age)
# 2.对象方法
def eat(self):
print('eat food')
# 私有的对象方法，只能在类的内部调用
def __shout(self):
print('shout')
# 3.类字段
count = 100
# 4.类方法
@classmethod
def class_func(cls):
print('class_func')
# 5.静态方法
@staticmethod
def static_func():
print('static_func')
pass
class Dog(Animal):
# def eat_bone(self):
# print('eat bone'. self.__age)
pass
a = Animal()
a.run()
dog1 = Dog()
# dog1.eat_bone()
print(dog1.name)
# print(dog1.age)
print(Dog.count)
Dog.class_func()
Dog.static_func()
dog1.color = 'red'
print(dog1.color)
06-class inheritance override 类的继承重写（掌握）
声明一个类，如果不声明其父类，那么这个类默认继承自object这个类；
object类是python中所有类直接或者间接的父类
6.1示例一：什么是重写
1.重新实现从父类继承下来的方法-->重写
2.super().方法名()
class Animal(object):
def __init__(self, name):
self.name = name
def shout(self):
print('%s： auf!auf!auf!' % self.name)
def be_beat(self):
print(self.name,'is running')
print('auf!auf!auf!when running')
class Dog(Animal):
# 重写父类的shout方法，然后通过Dog对象调用shout执行的是子类的方法
def shout(self):
print('%s: alf!alf!alf!' % self.name)
# 重写父类的be_beat，保留了父类的功能，并且添加新的功能
# super()-->父类
def be_beat(self):
super().be_beat()
print('angry and bite person')
pass
dog1 = Dog('da_huang')
dog1.shout()
dog1.be_beat()
6.2：init方法的继承和重写
重写init方法要注意：
1.如果需要继承父类的对象属性，就需要通过supr().init()
去保留父类的对象属性，然后再添加新的属性;
2.父类的参数必须写在init后的括号里
class Person:
"""人"""
def __init__(self, name='', age=0):
self.name = name
self.age = age
class Student(Person):
"""
重写init方法要注意：
1.如果需要继承父类的对象属性，就需要通过supr().__init__()去保留父类的对象属性，然后再添加新的属性
"""
def __init__(self, name='aas', age=0, study_id = ''):
super().__init__(name, age)
self.study_id = study_id
pass
stu1 = Student()
print(stu1.study_id)
print(stu1.name)
stu2 = Student('ada', 23, '002')
print(stu2.name)
stu3 = Student(study_id= '003')
print(stu3.study_id)
练习：
写一个正方形类，拥有方法：求面积、求周长；拥有属性边长
写一个长方形类，拥有方法：求面积、求周长；拥有属性长和宽
重点：用getter和setter方法将正方形的边长付给引用的父类（长和宽）
class Rectangle:
"""长方形"""
def __init__(self, length=0, width=0):
self.length = length
self.width = width
def area(self):
return self.length*self.width
def circumference(self):
return (self.length + self.width)*2
class Square(Rectangle):
"""
正方形
"""
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.length = side
self.width = side
self._side = side
rec1 = Rectangle(3, 5)
print('>>',rec1.area(), rec1.circumference())
squ1 = Square()
squ1.side = 10
print('>>',squ1.area(), squ1.circumference())
