本质上python中所有的属性和方法都是公开的,在类的外部可以使用也可以被继承。
1.私有化 - 让属性和方法只能在类的内部使用,不能在类的外部使用
"""
1)语法:
声明属性或者方法的时候,在属性名或者方法名前加"__"
2)python私有化的原理
python并不能像java一样从访问权限上去限制属性和方法,没有真正的私有和方法。
私有化只是在两个下划线开头的名字前加'_类名',导致不能直接通过原名进行访问
"""
class Person:
__num = 30
def __init__(self, name, age=10):
self.name = name
self.age = age
self.__gender = '男'
def eat(self, food='米饭'):
print(Person.__num)
print(self.__gender)
print('%s在吃%s' % (self.name, food))
p1 = Person('小米')
print(Person.num)
print(p1.name)
p1.eat('牛肉')
2.对象属性的保护: 不要直接访问或者修改对象属性的值,而是通过属性访问器(getter)和修改器(setter)去操作对象属性
"""
需要添加getter或者setter的对象属性,属性命名的时候需要在最前面加'_',
(添加下划线的目的是为了告诉使用者之歌属性我给他添加了getter或者setter)
1)getter - 获取属性(间接)
a.语法:
@property
def 函数名(self):
其他语句
reutrn 属性值
b.说明:
函数名 - 对应的属性名去掉下划线
属性值 - 对应的有下划线的属性有关联
c.什么时候用
如果希望在获取某个属性的值之前干点别的事情,就给这个属性添加getter
2)setter - 给属性赋值(间接)
想要添加setter必须先添加getter
a.语法:
@getter名.setter
def 函数名(self, 参数):
其他语句
self.属性 = 值
c.什么时候用
如果给属性赋值之前干点别的事情,就给这个属性添加setter
"""
print('=======getter和setter=======')
class Student:
def init(self, name1):
self._name = name1
self._week = 1
self._age = 0
self.is_adult = False
@property
def name(self):
return self._name
# @property
# def week(self):
# if self._week == 1:
# return "星期一"
# elif self._week == 2:
@property
def age(self):
return self._age
@age.setter
def age(self, value):
if isinstance(value, int):
if value < 0 or value > 200:
print('年龄范围只能在(0~200)')
self._age = 0
else:
self._age = value
else:
print("年龄只能是整数")
stu = Student('小明')
print(stu._name)
print(stu.name) # 通过不带下划线去获取属性的值的时候,其实本质是在调用属性对应的getter方法,结果是getter的返回值
class Circle:
def init(self, r):
self.r = r
self._area = None
@property
def area(self):
return self.r*2*3.1415926
c1 = Circle(2)
print(c1.area)
stu.age = 10
stu.age = 'abc'
print(stu.age)
练习: 声明矩形类,有长、宽、周长、面基面积。要求修改长和款的值的时候,周长和面积自动变化。
并且不能修改周长和面积的值(如果主动给周长和面积赋值,程序直接报错)
raise IndexError
class WriterError(Exception):
def __str__(self):
return '不能修改只读的属性!'
# class Rectangle:
# def __init__(self, long, wide):
# self.lenth = long
# self.width = wide
# self.__area = None
# self.__perimeter = None
# @property
# def area(self):
# return self.lenth * 2 + self.width * 2
# @property
# def perimeter(self):
# return self.lenth * self.width
#
#
class Rect:
def __init__(self, long, wide):
self._lenth = long
self._width = wide
self._area = long * wide
self._perimeter = (long + wide) * 2
# 1.lenth
@property
def lenth(self):
return self._lenth
@lenth.setter
def lenth(self, value):
self._lenth = value
self._perimeter = (self._lenth + self._width) * 2
self._area = self._lenth * self._width
# 2.width
@property
def width(self):
return self._width
@width.setter
def width(self, value):
self._width = value
self._perimeter = (self._lenth + self._width) * 2
self._area = self._lenth * self._width
# 3.perimeter
@property
def perimeter(self):
return self._perimeter
@perimeter.setter
def perimeter(self, value):
raise ValueError
# 4.area
@property
def area(self):
return self._area
@area.setter
def area(self, value):
raise ValueError
r1 = Rect(4, 6)
print(r1.perimeter, r1.area)
r1.perimeter = 300
1.类中的方法: 对象方法、类方法、静态方法
"""
1)对象方法
a.怎么声明:直接声明在类中
b.特点:有默认参数self;调用的时候不用传参,指向当前对象
c.怎么调用:通过对象来调用(对象.对象方法())
d.什么时候用:如果实现函数的功能,需要使用对象属性(需要对象),就用对象方法
2)类方法
a.怎么声明:声明函数前添加@classmethod装饰器
b.特点:有默认参数cls;调用的时候不用传参,系统将调用这个方法的类传给他,指向的是当前类
c.怎么调用:通过类来调用
d.什么时候用:在不需要独享属性的前提下,需要类的字段,就使用类方法
3)静态方法
a.怎么声明:声明前添加@staticmethod装饰器
b.特点:没有默认参数
c.怎么调用:通过类来调用
d.什么时候用:既不需要对象属性也不需要类的字段,就使用静态方法
"""
class Person:
num = 10
def __init__(self, name='', age=0):
self.name = name
self.age = age
# 对象方法
def eat(self, food):
print('%s在吃%s' % (self.name, food))
# 类方法
@classmethod
def show_count(cls):
# cls: 当前类,当前类能做的事情,cls都能做
print('类方法', cls.num) # 使用类的字段
p = cls() # 创建对象
print(p)
# 静态方法
@staticmethod
def static():
print('静态方法')
p1 = Person('xiaomi')
Person.show_count()
Person.static()
class Student(Person):
num = 30
Person.show_count()
Student.show_count()
1.继承
"""
继承者 - 子类
被继承撑者 - 父类
继承 - 让子类直接拥有父类的属性和方法
1)语法:
class 类名(父类):
类的内容
"""
2.在子类中添加内容
"""
- 在子类中添加字段和方法
直接在子类中声明新的字段和方法 - 添加对象属性
在子类中实现init方法,并且添加新属性。同时需要通过super().init()去调用父类的init方法
补充: 类中的函数的调用过程
先看当前类中是否有这个方法,如果有就直接调用自己的方法;没有就去看父类有没有这个方法,如果有就调用父类的方法;
如果父类也没有就找父类的父类,以此类推,如果找到object都没有找到这个方法才报错
python中所有类默认都是集成object,object是python中所有类的基类
"""
3.重写
"""
在子类中重新实现父类的函数;可以通过super()去调用父类的方法。
注意: super()不能在静态方法中使用,只能在对象方法和类方法中用
"""
class Person:
num = 61
def __init__(self):
self.name = '张三'
self.age = 0
self.gender = '男'
def eat(self, food):
print('%s在吃%s' % (self.name, food))
@staticmethod
def run():
print('人在跑步')
class Student(Person):
# 添加字段和方法
num = 100
id_pre = 'stu'
@staticmethod
def study():
print('好好学习,天天向上')
# 添加对象属性
def __init__(self):
# 调用当前类的父类的__init__方法
super().__init__()
self.stu_id = '001'
self.score = 0
# 3.重写方法
@classmethod
def run(cls):
print('===============')
# super().run()
cls.__bases__[0].run()
print('学生在跑步')
stu = Student()
print(stu.name)
print(Student.num)
print(Student.id_pre)
Student.study()
添加对象属性
print(stu.stu_id, stu.score)
print(stu.name)
Student.run()
Person.run()