2018-09-07 Day15 类和对象2
01.内置类属性
1.内置类属性就是魔法属性
a.魔法属性:属性名的前后都有两个下划线
b.魔法方法:方法的前后都有两个下划线
class Person:
"""人类"""
# 类的字段
number = 99
def __init__(self, name, age, height):
#对象的属性
self.name = name
self.age = age
self.height = height
# 对象方法
def run(self):
print('%s在跑步'%self.name)
@classmethod
def show_number(cls):
print('人类的数量为:%d亿'%cls.number)
# 静态方法
@staticmethod
def destroy():
print('人类在破坏环境!')
p1 = Person('张三',28,170)
1.name 属性 ---类的名字(是个字符串)
name = Person.__name__
print(name,type(name),type(Person))
2.class属性 ---获取对象对应类(是一个类)
对象的属性
my_class是一个类,之前类能做到的事他都能做
my_class = p1.__class__
p2 = my_class('小明',17,999)
print(p2.name,my_class.__name__)
3.dict属性
---可以将对象或类的属性及其对应的值转换成键值对存到字典中
# print(Person.__dict__)
print(p1.__dict__)#{'name': '张三', 'age': 28, 'height': 170}
print(p2.__dict__)#{'name': '小明', 'age': 17, 'height': 999}
4.module属性 ---获取类所在的模块对应的名字
print(Person.__module__)
5.doc属性 ---获取类的说明文档
# 类的属性
doc = Person.__doc__
print(doc)
6.bases属性 ---获取当前类的父类
# 类的属性
print(Person.__bases__)
02.slots魔法
class Person:
# 通过__slots__中存的元素的属性的值来约束当前这个类的对象的属性,
# 对象的属性只能比元祖中的元素少,不能多!
__slots__ = ('name','age','face')
def __init__(self):
self.name = '白胡子'
self.age = 18
self.face = 70
# self.sex = 'boy' #__slots__中并没有sex
p1=Person()
# p1.sex = 'girl'
# print(p1.sex)
#
# p1.neme = 'onepice'
print(p1.name)
注意:一旦在类中给slots属性赋了值,那么这个类的对象的dict属性就不能使用
1.slot属于类属性,是一个列表 , 只有列表内的变量名可以成为实例属性
2.dict属性为字典型
print(p1.dict)
03.属性的私有化:
a.python中并没有真正的私有化!!
b.python的类中默认的属性和方法都是公开的
1.私有化
a.类中的属性和方法都可以通过在属性名和方法名前加两个下划线,来让实行和方法变成私有的。
b.私有的属性和方法只能在当前的类中使用
2.python中私有化的原理:
在前面有两个下划线的属性名和方法名前添加了‘_类名’来阻止外部通过直接访问属性名来使用属性
class Dog:
# 字段
number = 100
__count = 200
def __init__(self):
self.color = '黑白色'
self.age = 3
self.name = '哈士奇'
self.__sex = 'gong'
# 对象方法
def __eat(self):
print('%s在食~'%self.name)
def eat(self):
# 在类中可以使用私有的属性和方法
self.__eat()
print('%s在食屎~'%self.name)
@classmethod
def shout(cls):
print('count:',cls.__count,Dog.__count)
print('wangwangwang~~~')
@staticmethod
def function():
print('kanjjjjjjj~~~')
# python的类中默认的属性和方法都是公开的
dog1 = Dog()
print(Dog.number)
print(dog1.name,dog1.color,dog1.age)
dog1.eat()
Dog.shout()
Dog.function()
# 在类的外面不能直接使用私有的属性
#print(Dog.__count) #AttributeError: type object 'Dog' has no attribute '__count'
print(dog1._Dog__sex)
print(dog1.__dict__)
04.属性的getter和setter
1.保护类型的属性:
a.就是在声明属性的时候,在属性名前加一个下划线来代表这个属性是受保护的属性,那么以后再访问该属性的时候就不要直接访问,要通过getter获取属性值和setter来给属性赋值
b.如果一个属性已经声明成保护类型的属性,那么我们就需要给这个属性添加getter.也可以添加setter
2.添加getter:
添加getter其实就是声明一个没有参数有一个返回值的函数。作用是获取属性值
a.格式:
@property
def 去掉下划线的属性名(self):
函数体
将属性相关的值返回
b.使用场景
场景1:如果想要获取对象的某个属性的值之前,想在干点别的事情(额外处理),就可以给这个属性添加getter
场景2:想要拿到某个属性被使用的时刻
3.添加setter
添加setter就是声明一个有一个参数但是没有返回值的函数。作用是给属性赋值。
a.格式:@属性名.setter
b.使用场景:
在给属性赋值之前想干点别的事,就给属性添加setter
class Car:
def __init__(self):
self.color = '黑色'
self.type = 'MSDS_BC'
# _price属性是保护类型
self._price = 2000000
# 给_price属性添加getter
@property
def price(self):
print('在使用_price属性')
return self._price / 1000
# 想要给一个属性添加setter,必须先给这个属性添加getter
@price.setter
def price(self, price):
if isinstance(price, int) or isinstance(price, float):
self._price = price
else:
self._price = 0
car1 = Car()
print(car1.color, car1._price)
# 添加完getter后就通过getter去获取属性的值
# price就是属性_price的getter
# 实质是在调用getter对应的方法
print(car1.price,'k')
print(car1.price)
# 通过setter给属性赋值。实质是在调用setter对应的方法
car1.price = 1000
print(car1.price)
car1.price = 'abc'
print(car1.price)
练习:声明一个员工类,有一个属性为是否已婚(bool),在获取值之前,根据存的值返回'已婚'/'未婚'
class Staff:
def __init__(self, name, age, sex):
self.name = name
self.age = age
self.sex = sex
self._marrieds = ''
@property
def marrieds(self):
return self._marrieds
@marrieds.setter
def marrieds(self, marrieds):
if marrieds == '是':
self._marrieds = '已婚'
if marrieds == '否':
self._marrieds = '未婚'
sta = Staff('ftr', '21', '男')
print(sta.name, sta.age, sta.sex)
sta.marrieds = input('是否结婚(是/否): ')
print(sta.marrieds)
05.继承
a.python中的类可以继承,并且支持多继承。
b.程序中的继承:就是让子类直接拥有父类的属性和方法(集成后父类中的内容不会因为被继承而减少)
1.继承的语法
class 子类(父类):
类的内容
注意:如果声明类的时候没有写继承,那么这个类会自动继承python的基类,object.相当于class.类名(object)
python中所有类都是直接或间接的继承自object
2.能继承哪些东西?
a.所有的属性和方法都能继承
b.slots的值不会继承,但是会影响子类对象dict属性。不能获取到父类继承下来的属性。
class Person:
# class Person(object):
"""人类"""
# 字段
number = 99
__slots__ = ('name','age')
# 对象的属性
def __init__(self,name='ftr',age=18):
self.name=name
self.age=age
# self.__height = 50
# 对象方法
def show_message(self):
print('姓名:%s 年龄:%d'%(self.name,self.age))
# 类方法
@classmethod
def show_number(cls):
print('人类的数量:%d'%cls.number)
# 静态方法
@staticmethod
def complaint():
print('人类攻打小动物~~~')
class Student(Person):
"""学生类"""
pass
# 创建Person类的对象
p=Person()
# p.sex='boy'
# 创建Student类的对象
stu1 = Student()
# 类的字段继承
print(Student.number)
stu1.name='cctv'
print(stu1.name)
stu1.show_message()
Student.show_number()
Student.complaint()
print(stu1.__dict__)
06.方法的重写
子类继承父类,拥有父类的属性和方法以后,还可以再添加自己的属性和方法。
1.添加方法和类的字段:
直接在子类中声明相应的方法和字段
2.添加对象属性:
对象的属性是通过继承父类的init方法而继承下来
如果需要在保留父类对象的同时,添加自己的对象属性,需要在子类的init方法中,通过super()去调用父类的方法
3.方法的重写
在子类中从新实现父类的方法,就是重写
方式1:直接覆盖父类的实现
方式2:保留父类的功能再添加其他的功能
4.类中方法调用的过程(终点)
先在当前这个类中去找,没有就去父类中找,找不到再去父类中找,依次类推,如在基类中都没有找到才崩溃。
在第一次找到的位置,去调用
注意:使用super的时候必须是通过super()来代替父类或者是父类对象
class Animal:
def __init__(self):
self.age = 0
self.sex = '雌'
def shout(self):
print('aoaoao~~~')
class Cat(Animal):
def __init__(self):
# 调用父类的init方法
super().__init__()
self.name = 'xxx'
food = '鱼'
# @staticmethod
# # 没用到属性和类
# def Shout():
# print('mmmmm~~~')
class Dog(Animal):
def shout(self):
# 通过super()调用父类的方法,保留父类的功能
super().shout()
print('wawawa~~~')
cat1=Cat()
print(cat1.__dict__)
print(cat1.name)
5.init方法的重写
练习:写一个Person类,拥有属性name、age、sex。要求创建Person对象的时候必须给age和name赋值,sex可赋可不赋。
在写一个Staff类继承自Person类,要求保留Person中所有的属性,并且添加新的属性salary。
要求创建Staff类的对象的时候,只能给name赋值(必须赋)
class Person:
def __init__(self,name,age,sex='boy'):
self.name=name
self.age=age
self.sex=sex
class Staff (Person):
def __init__(self,name):
super().__init__(name,18)
self.name=name
self.salary=0
per=Person('FTR',20,'boy')
per1=Person('FT',18)
sta = Staff('cctv')
print(sta.__dict__)
07.运算符的重写
如果希望类的对象支持相应的运算符操作(例如:+、-、*、/、>、<等),就必须实现相应的魔法方法。这个过程就叫做运算符的重载。
一般情况需要对>或者<进行重载,重载后可以通过sort方法直接对对象的列表进行排序
class Student:
def __init__(self,name='',age=18,score=0):
self.name=name
self.age=age
self.score=score
# self:+号前面的对象
# other:+号后面的对象
def __add__(self,other):
return self.name + other.name
# 重载 > 符号
# 注意:重载>和<可以只重载一个,另外一个对应的功能自动取反
def __gt__(self, other):
return self.age>other.age
# 重写魔法方法__str__,用来定制对象的打印样式
def __str__(self):
# return ('%s %s %s '%(self.name,self.age,self.score))
return str(self.__dict__)[1:-1][1:-1]
stu1 = Student('FTR',18,99)
stu2 = Student('FT',19,89)
stu3 = Student('F',29,79)
print(stu1)
all_students = [stu1,stu2,stu3]
all_students.sort(reverse=True)
for stu in all_students:
print(stu.name,stu.age,stu.score)
print(stu1>stu2)
print(stu1<stu2)
print(stu1+stu2)