1.类属性
类中的属性:对象属性、类属性(类的字段)
1)类属性
直接定义在类中的变量就是类属性
类属性的值不会因为对象不同而不一样
2)对象属性
通过 self.属性名 = 值 定义在init函数中的属性
对象属性的值会因为对象不同而不一样
class Person:
num = 61
x = 100
print(Person.num)
Person.num = 60
2.对象属性的增删改查
python中类的对象的属性支持增删改查
class Student:
def __init__(self, name, age=0, gender='男', score=0): # 赋默认值
self.name = name
self.age = age
self.gender = gender
self.score = score
def __repr__(self):
return f'<{str(self.__dict__)[1:-1]}>'
stu1 = Student('小明')
stu2 = Student('小花', gender='女')
2.1 查(获取属性的值)
对象.属性 - 获取对象指定属性对应的值;属性不存在会报错
getattr(对象, 属性名) - 获取对象指定属性对应的值;属性不存在会报错
getattr(对象, 属性名, 默认值) - 获取对象指定属性对应的值; 属性不存在不会报错,并且返回默认值
print(stu1.name)
\# print(stu1.name1) # AttributeError: 'Student' object has no attribute 'name1'
print(getattr(stu1, 'name')) # 小明
print(getattr(stu1, 'age')) # 0
\# print(getattr(stu1, 'name1')) # AttributeError: 'Student' object has no attribute 'name1'
print(getattr(stu1, 'name', '无名氏')) # 小明
print(getattr(stu1, 'name1', '无名氏')) # 无名氏
根据输入的内容获取对象属性的值
name -> 小明
age -> 0
value = input('请选择(name,age,gender,score):')
print(getattr(stu1, value))
2.2 改、增
对象.属性 = 值 - 当属性不存在就给对象添加属性,属性存在的时候就修改指定属性的值
setattr(对象, 属性名, 值) - 当属性不存在就给对象添加属性,属性存在的时候就修改指定属性的值
属性存在是修改
stu1.name = 'xiaoming'
print(stu1)
stu1.height = 180
print(stu1) # <'name': 'xiaoming', 'age': 0, 'gender': '男', 'score': 0, 'height': 180>
print(stu1.height)
setattr(stu1, 'age', 18)
print(stu1) # <'name': 'xiaoming', 'age': 18, 'gender': '男', 'score': 0, 'height': 180>
setattr(stu1, 'weight', 80)
print(stu1) # <'name': 'xiaoming', 'age': 18, 'gender': '男', 'score': 0, 'height': 180, 'weight': 80>
print(stu2) # <'name': '小花', 'age': 0, 'gender': '女', 'score': 0>
2.3 删
del 对象.属性 - 删除对象中指定的属性
delattr(对象, 属性名) - 删除对象中指定的属性
del stu2.age # <'name': '小花', 'gender': '女', 'score': 0>
print(stu2)
delattr(stu2, 'gender')
print(stu2) # <'name': '小花', 'score': 0>
3.内置属性
python在定义类的时候系统自动添加的属性(从基类中继承下来的属性)就是内置属性
class Student:
def __init__(self, name, age=18, score=0):
self.name = name
self.age = age
self.score = score
class Dog:
# 类属性
num = 100
# 对象属性
def __init__(self, name, age=1, color='白色'):
self.name = name
self.age = age
self.color = color
# 方法
def eat(self, food):
print(f'{self.name}在吃{food}')
@classmethod
def show_num(cls):
print(f'狗的数量:{cls.num}')
@staticmethod
def bark():
print('狗嗷嗷叫~')
def __repr__(self):
c = self.__class__
m = c.__module__
return f'<{m}模块.{c.__name__}类的对象: name={self.name},age={self.age},color={self.color}>'
dog1 = Dog('大黄')
3.1 __module__
类属性;
类.module - 获取定义的模块的模块名
print(Dog.__module__) # __main__
print(int.__module__) # builtins
3.2 __class__
对象.class - 获取对象对应的类
c = dog1.__class__
print(c) # <class '__main__.Dog'>
print(type(dog1)) # <class '__main__.Dog'>
print(Dog) # <class '__main__.Dog'>
3.3 __name__
类.__name__ - 获取类名,是字符串
print(Dog.__name__) # 'Dog'
重写 repr 方法, 要求以: <xxx模块.xxx类的对象: 属性1=值1,属性2=值2>
3.4 __dict__
类.__dict__ - 将类转换成字典(类的类属性名作为key,类属性的值作为值)
对象.__dict__ - 将对象转换成字典(对象属性名作为key,属性的值作为值)
print(Dog.__dict__) #{'__module__': '__main__', 'num': 100, '__init__': <function Dog.__init__ at 0x00000000021AF1F8>, 'eat': <function Dog.eat at 0x00000000021AF288>, 'show_num': <classmethod object at 0x00000000021AD208>, 'bark': <staticmethod object at 0x00000000021ADF08>, '__repr__': <function Dog.__repr__ at 0x00000000021AF438>, '__dict__': <attribute '__dict__' of 'Dog' objects>, '__weakref__': <attribute '__weakref__' of 'Dog' objects>, '__doc__': None}
print(dog1.__dict__) # {'name': '大黄', 'age': 1, 'color': '白色'}
3.5 __doc__
类.__doc__ - 获取类的说明文档
print(list.__doc__)
3.6 __base__、__bases__
类.__base__ - 获取当前类的父类
类.__bases__ - 获取当前类所有的父类
print(Dog.__base__) # <class 'object'>
print(Dog.__bases__) # (<class 'object'>,)
3.7 slots
class Person:
# __slots__可以约束当前类的对象能够拥有哪些对象属性
__slots__ = ('name', 'age', 'height')
def __init__(self, name, age=10):
self.name = name
self.age = age
p1 = Person('小明')
\# p1.name1 = 'xiaoming'
p1.height = 180
注意: 如果给类属性__slots__赋值了,那么这个类的对象不能再使用__dict__属性
print(p1.__dict__)
4.私有属性和方法
-
在实际开发中,对象的某些属性或者方法可能只希望在对象的内部别使用,而不希望在外部被访问到,这时就可以定义私有属性和私有方法
-
定义方法:
在定义属性或方法时,在属性名或者方法名前增加两个下划线__,定义的就是私有属性或方法 -
访问私有属性和方法:
私有属性不能直接使用,私有方法不能直接调用。但是,通过一些代码,我们也可以在外部访问一个对象的私有属性和方法
- 访问权限(针对属性和方法)
公开的:在类的内部和外部都可以使用,也能被继承
保护的:在类的内部可以使用,类的外部不能使用,但可以被继承
私有的:只能在类的内部使用,不能被继承
严格来说,python中所有的属性和方法都是公开的,这里的私有化其实是假的私有化
class Person:
num = 100
__num2 = 61
def __init__(self):
self.name = '小明'
self.age = 10
self.__gender = '男'
def eat(self):
print(f'{self.name}在吃饭')
print(self.__gender)
def get_gender(self):
return self.__gender
def __demo(self):
print('我是Person里面的私有方法')
p1 = Person()
print(Person.num) # 100
print(p1.name, p1.age) # 小明 10
p1.eat() # 小明在吃饭
print(p1.get_gender()) # 男,可以通过调用非私有方法来间接获得
# print(p1.__gender) # 无法访问
# print(Person.__num2) # 无法访问
私有化的原理:
print(p1.__dict__) # {'name': '小明', 'age': 10, '_Person__gender': '男'}
print(p1._Person__gender) # # 使用 对象名._类名__私有属性名
p1._Person__demo() # 通过使用 对象名._类名__私有属性名来访问
5.getter和setter
getter和setter相当于监视器,当一个对象属性需要随着另一个属性的值改变而改变时,并且当前需要获取该属性的值时,这是getter就可以让该属性先更新再返回,而setter主要是不让用户重新赋值来修改某些属性,修改时给响应警告,并抛出异常,实例如下。
5.1 getter和setter的作用
getter作用:在**获取某个属性值之前想要做别的事情,就给这个属性添加getter
setter作用:在给属性**赋值之前想要做别的事情,就给这个属性添加setter
5.2 怎么添加getter和setter
-
getter
第一步:在需要添加getter的属性名前加_
第二步:定义getter对应的函数(1.需要@property装饰器 2.函数名就是不带_的属性名 3.函数需要一个返回值)
第三步:获取属性值的通过: 对象.不带_属性名 (本质就是在调用getter对应的函数,取到属性值就是函数的返回值) -
setter
如果想要给属性添加setter必须先给属性添加getter
第一步:添加getter
第二步:定义setter对应的函数 (1.需要 @getter函数名.setter 装饰器 2.函数名就是不带_的属性名 3.需要一个参数不需要返回值,这个参数就是尝试给属性赋的值)
第三步:给属性赋值:对象.不带_属性名 = 值 (本质就是在调用setter对应的函数)
class Rect:
def __init__(self, length=0, width=0):
self.length = length
self.width = width
self._area = length*width
@property
def area(self):
print('area属性值被获取')
self._area = self.width * self.length
return self._area
@area.setter
def area(self, value):
# print(f'value:{value}')
# self._area = value
raise ValueError
r1 = Rect(4, 5)
print('==========')
print(r1.area)
print('++++++++')
不能让矩形直接修改面积属性值
\# r1.area = 100
\# print(r1.__dict__)
\#
r1.width = 10
print(r1.area)
r1.length = 10
print(r1.area)
r1.area = 80