1.内置类属性
-创建类的时候,系统默认为我们添加的类的属性
class Person:
"""人类"""
#类的字段
num = 1
#对象属性
def __init__(self,name):
self.name = name
#对象方法
def object_func(self):
print('对象方法',self.name)
#类方法
@classmethod
def class_func(cls):
print('类方法',cls.num)
#静态方法
@staticmethod
def static_func():
print('静态方法')
#系统自带的魔法方法,可以定制当前类的对象的打印内容.实现这个函数的时候要求有一个字符串类型的返回值
#单独打印对象的效果(记住)
def __str__(self):
return str(self.__dict__)[1:-1]
#对象作为元素的时候的打印效果(重点记住)
def __repr__(self):
return str(self.__dict__)[1:-1]
p1 = Person('小明') #
print([p1,Person('小红')])
1. name 字段
类.__name__ --获取类的名字
print(Person.__name__,type(Person.__name__)) #Person <class 'str'>
2. doc 字段
类.__doc__ --获取类的说明文档
print(Person.__doc__) #人类
3. class 对象属性
对象.__class__ -- 获取对象对应的类(对象是哪个类的对象)
print(p1.__class__) #<class '__main__.Person'>
4. dict 字段/对象属性 (常用,记住)
类.__dict__ -- 获取类中所有的字段和对应的值,以字典形式返回
对象.__dict__ -- 获取对象中所有的属性和对应的值,以字典形式返回
print(Person.__dict__) #{'__module__': '__main__', '__doc__': '人类', 'num': 1, '__init__': <function Person.__init__ at 0x01E65300>, 'object_func': <function Person.object_func at 0x01E652B8>, 'class_func': <classmethod object at 0x01E63110>, 'static_func': <staticmethod object at 0x01E630B0>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>}
print(p1.__dict__) #{'name': '小明'}
5. module 字段
类.__module__ -- 获取指定的类声明在哪个模块中,返回模块名(获取类所在的模块的__name__属性的值)
print(Person.__module__) #__main__(当前模块)
###6. __bases__ 字段
类.__bases__ -- 返回当前类的所有父类(一个类可继承多个父类)
print(Person.__bases__) #(<class 'object'>,) 默认基础object,返回元祖
2.slots魔法:
- 通过给slots字段赋值来 约束当前类的对象拥有的属性
- 当在类中给slots赋值后,当前类的dict属性无效
class Dog:
__slots__ = ('name','age')
def __init__(self,name,age=0):
self.name = name
self.age = age
dog1 = Dog('大黄')
# dog1.age1 = 's'
1高级语音
- 在很多高级面向对象语音中,会将属性和方法分为公开的(在类的外部可以使用)、
- 私有的(只能在类的内部使用,不能被继承)、受保护的三类(只能在类的内部使用,可以继承)。
2python
- python中类的内容本质上全部都是公开的. 私有和公开都只是约定
1私有化 - a.内容只能在类的内部使用,不能在外部使用。(效果)
b.在类中的方法名、属性名前加 '__' ;那么对应的方法和类就会私有化
c.当声明类的时候,在名字前加'__',内部会在这个基础前加 '_类名'
2属性保护 - a.可通过在对象属性名前加'_',把这个属性标记成受保护类型,为了告诉别人这个属性在使用时不要直接用,而是通过getter和setter使用
getter - 获取对象属性值之前,相要干点别的事情,那么就给这个属性添加getter
第一步: 在对应属性名前加'_'
第二步: 声明函数前加@property,这个函数没有参数,有一个返回值,函数名是属性名(不带下划线),这个函数就是getter
第三步: 获取属性值的时候,通过 对象.属性名(不带下划线) 获取属性值
setter - 给属性赋值之前干别的事情,就给这个属性添加setter,必须先添加getter
第一步: 在对应属性名前加'_'
第二步: 声明函数前加 @属性名.setter ;函数名是属性名,这个函数要一个参数,没有返回值
第三步: 给属性赋值的时候 通过 对象.属性名(不带下划线) 获取属性的值
'''
============保护==============
class Person1:
def __init__(self,name,age):
self.name = name
self.age = 0
self._week = 1
@property
def week(self):
weeks =['周一','周二','周三','周四','周五','周六','周日']
return weeks[self._week-1]
@week.setter
def week(self,x):
if not isinstance(x,int):
raise ValueError
elif not 1 <= x <= 7:
raise ValueError
self._week = x
p1 = Person1('qq',8)
p1.week = 7
print(p1.week)
============私有化============
class Person:
def __init__(self,name,age):
self.name = name
self.__age = age
def message(self):
return self.__age
p = Person('小明',10)
print(p.name)
# print(p.__age)
print(p.message())
print(p.__dict__) #{'name': '小明', '_Person__age': 10}
print(p._Person__age)
3.抛出异常
raise 异常类型
:raise - 关键字
异常类型 - 可以是系统提供的异常类型,也可以是自定义异常类型(必须继承exception)
4.自定义异常类型:写一个类继承exception,然后重写str方法来自定义错误信息.
class WeekError(Exception):
def __str__(self):
return '星期的值只能是1-7的整数'
- 练习:给age属性添加getter 和setter,获取年龄时,拿到年龄值和这个年龄对应的阶段
- 给age赋值的时候,必须是整数,并且范围在0-150 如果不满足要求,自定义AgeError
class Person3:
def __init__(self,name):
self.name = name
self._age = 0
@property
def age(self):
if self._age>=18:
return '成年'
else:
return '未成年'
@age.setter
def age(self,x):
if not isinstance(x,int) or not 0<=x<=150:
raise AgeError
else:
self._age = x
class AgeError(Exception):
def __str__(self):
return '年龄的值必须是整数,并且范围在0-150之前'
p3 = Person3('小明')
p3.age = 22
print(p3.age)
1.什么继承: 让子类直接拥有父类所有的属性和方法
父类 - 被继承者, 子类 - 继承者
- python中所有的类都是直接或者间接的继承object
- 2.怎么继承
class 子类名(父类1,父类2,...):
类的内容
3. 子类中添加内容
1)添加字段和方法,直接添加
class Person(object):
number = 61
def __init__(self, name, age=0, gender='男'):
# name = '小花'
self.name = name
self.age = age
self.gender = gender
self.__num = '0001'
def fun1(self):
print('Person对象方法:', self.name)
@classmethod
def func2(cls):
print(cls.number)
@staticmethod
def func3():
print('func3')
class Student(Person):
flag = '学生!'
def __init__(self, name):
# name = '小花'
# 在子类的方法中去调用父类的方法
super().__init__(name) # super().__init__('小花')
self.study_id = 'stu001'
def fun1(self):
super().fun1()
print('子类的,func1')
def study(self):
print('%s在学习' % self.name)
stu = Student('小花')
print(stu.__dict__)
# 使用父类继承下来的属性和方法
print(Student.number)
print(stu.name)
stu.fun1()
Student.func2()
Student.func3()
使用自己的属性和方法
print(Student.flag)
stu.study()
print(Person.__bases__)