Python——面向对象

Python——面向对象

参考博文 https://www.cnblogs.com/linhaifeng/articles/6182264.html

一、类

类是用来描述一类事物，类的对象指的是这一类事物中的个体

1、Python的经典类与新式类

2、如何声明类？

class 类名：
类的文档字符串
类体

例如：

class Chinese:
    "这是一个中国人的类"
    pass

3、类的实例化

p1 = Chinese()  // 类名+（）就是一个实例化。由Chinese类产生的对象，实例化会返回一个结果，相当于函数的return

4、属性

事物均有属性，属性分为：
1、数据属性：就是变量
2、函数属性：在面向对象方法里通常称为方法

类和对象均用 点 来访问自己的属性。例如：

class Chinese:
   "这是一个中国人的类"
   man = "中国男人"
print(Chinese.man)

类的函数属性调用（又称为方法）

class Chinese:
    "这是一个中国人的类"
    man = "中国男人"
    def history():
        print("中国拥有上下五千年的历史")

    def people(self):
        print("%s 是一个中国人"%self)
        
Chinese.history()
people_obj = 'alex'
Chinese.people(people_obj) #带参函数，所以调用时需要传入参数，讲'alex'传给self

4（1）、查看类的属性

定义的类存到了哪里？有两种方式查看

dir(类名)：查出的是一个名字列表
类名.__dict __:查出的是一个字典，key为属性名，value为属性值

4（2）、特殊的类属性

5、构造函数（初始化）

如何为实例定制数据属性？可以使用类的一个内置方法 __init() __ ，该方法，在类()实例化时会自动执行

class Chinese:
    "这是一个中国人的类"
    man = "中国男人"
    def __init__(self,name,age):
        self.name = name
        self.age = age
        # 切记这里不需要写return，此内置方法会自动帮你返回
    
    def history():
        print("中国拥有上下五千年的历史")
    def people(self):
        print("%s 是一个中国人"%self)


person1 = Chinese('alex',18)
person2 = Chinese('Bob',28)

疑问：为什么传参的名字，年龄可以自动对应name，age？为什么__init __里面的self 不用对应？

这两个问题实际是一个问题，这是类的内置方法帮我们做了对应的操作
实际是：

person1 = Chinese.__init__(p1,name,age)

person1 对应了 self，类里面的 name 实际也是 person1.name = name ，以此类推。

疑问：person1这个实例是由Chinese这个类产生的，那，可以调用到 man 这个属性吗
可以，类像函数，__init __ 里面没有 man 这个属性，于是就去到上一层找。

注意：由于实例调用类方法时，类会自动把实例传给类方法，所以类里面每个方法后面都要加（self）

6、类属性的增删改查

类属性又称为静态变量，或者静态数据。这些数据与它们所属的类对象是绑定的，不依赖于任何类实例。在JAVA或C++语言中，相当于在变量声明前加上 static 关键字。

查看类属性
print(Chinese.man)

修改类属性
Chinese.man = '女人'

删除类属性
del Chinese.man

增加类属性
Chinese.woman = "女人"
Chinese.location = "Asia"

7、实例属性的增删改查

注意：实例没有函数属性

查看实例属性
print(person1.name)

增加实例属性
person1.number = 123456

修改实例属性
person1.name = 'aaa'

删除实例属性
del person1.name

切记：不要修改底层的属性字典

8、静态属性

class Room:
    def __init__(self,width,len,heigh):
        self.width = width
        self.len = len
        self.heigh = heigh

    def area(self):
        print('面积为：%s'%(self.width*self.len))

r1 = Room(5,3,6)
r1.area()

上面代码中，我们想要计算面积的时候，需要写 r1.area() ，一看就知道area是函数属性，如果想要隐藏起来，可以加个装饰器 @property

class Room:
    def __init__(self,width,len,heigh):
        self.width = width
        self.len = len
        self.heigh = heigh

    @property
    def area(self):
        return self.width * self.len

r1 = Room(5,3,6)
print(r1.area)

这样，在调用的时候，不需要再加括号，调用者就分不清是数据属性还是函数属性。

9、类方法

class Room:
    lenb = 123
    def __init__(self,width,len,heigh):
        self.width = width
        self.len = len
        self.heigh = heigh

    @classmethod
    def cla(cls):
        print(cls.lenb)
        
Room.cla()

在函数前加个装饰器 @classmethod ，就能直接通过类来调用，且不用传参。

10、静态方法

在函数前加一个装饰器 @staticmethod,静态方法只是名义上归属类管理，不能使用类变量和实例变量，是类的工具包

class Room:
    lenb = 123
    def __init__(self,width,len,heigh):
        self.width = width
        self.len = len
        self.heigh = heigh
        
    @staticmethod
   	def qwe(a,b):
        print("第一个：%s,第二个 ：%s" %(a,b))

Room.qwe(1,2)

此函数括号里没有 self ，如果不加这个装饰器，在实例调用此函数时调用不了，会把实例本身传进去。加了此装饰器，实例就能调用，函数也不需要加 self 。

二、组合

1、定义一个类，比如人；人里面也有其他分类，比如人种，性别等等。这几个属性又是可以通过一个类实例化的对象，这就是组合。比如：

class School:
    #学校
    def __init__(self,name,addr):
        self.name = name
        self.addr = addr

class Teacher:
    #老师
    def __init__(self,name,age,School):
        self.name = name
        self.age = age
        self.school = School

class cour:
    #课程
    def __init__(self,name,Teacher,School):
        self.name = name
        self.teacher = Teacher
        self.school = School

比如上述代码，老师中有分哪个校区的老师，课程有分哪个老师教，哪个校区的课程。

未完待续…