面向对象1

1.编程的3大方法

 面向过程：即一步一步往下执行，若有一步不成立则停止往下，重新回到第一步。

 函数式：编程语言定义的函数+数学意义的函数。

 面向对象：将某一东西所有相同的特征和动作整合在一起。

注意：def定义的就是函数式编程这种说话是绝对错误的。如下图，下图就是一种面向对象。定义了一个人

def people(name,age,gender)：
    def dicc(name,age,gender)：
        dic ={"name":name
                 "age":age
                 "gender":gender
                 "eat":eat 
                 "sport":sport}
         return  dic   
    def eat():
        print("%s正在吃东西" %(name))
    def sport():
        print("%s正在运动" %（name）)
    return  dicc

2.类：把一类事物的相同的特征和动作整合在一起就是一个类，类是抽象的概念。

3.对象：就是基于类而创建的一个具体的事物（具体存在的），也是特征和动作整合在一起。

 4.面向对象设计：将一类具体的事物的数据和动作整合起来

5.面向对象编程：即用面向对象语言如class等来定义

6.定义一个类的基本形式：

class  类名（首字母一般用大写，这是一种规范）
        “类的文档字符串”>>>>即描述这是什么类
        类体


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


类的实例化(即创建一个对象p1)
p1 = Chinese()

 7.类分为经典类和新式类，这两种在python2中是由区别的，不过在python3中都称为新式类。

经典类
class Chinese：
    "这是一个中国人的类"
    pass

新式类：
class Chinese（object）：
    "这是一个中国人的类"
    pass

 8.属性：

（1）属性分为数据属性（变量）和函数属性（方法）（在类和对象中可以用 .  来访问属性）

class Foo:
     x = 1           >>>>>>>数据属性
     def eat():       >>>>>>这个eat函数称为函数属性
        pass

（2）属性都会放在属性字典里，查看所有的属性>>>>>  类名实例.__dict__

class People:
    name="cwt"
    age = 20
    gender = "male"
    def eat():
       pass 


print(People.__dict__) 

>>>>>>

{'__module__': '__main__', 'name': 'cwt', 'age': 20, 'gender': 'male', 'eat': <function People.eat at 0x00469468>, '__dict__': <attribute '__dict__' of 'People' objects>, '__weakref__': <attribute '__weakref__' of 'People' objects>, '__doc__': None

由上可得：属性都放在了一个字典里，所以除了用   .   来访问属性外，也可以按字典的操作方法访问如People.__dict__["name"]

本质上，点的方法也是在属性字典里找。

提前透露：

当进行类的实例化时，虽然实例能调用到类的属性，但是，类的属性并不会被输入到实例的属性字典里。

如

class People:
     name="cwt"
     age = 20
     gender = "male"
     def eat():
       pass


p1 = People()
print(p1.__dict__)
print（p1.name）

》》》{}
>>>> cwt

 9.完整的类一般都有一个函数名为__init__的函数，这个函数是用来对实例进行设值

class People:
    def __init__(self,name,age,gender):
        self.name = name
        self.age = age
        self.gender = gender
　　def eat(self):
　　　　print("%s正在吃饭" %self.name)

p1 = People("cwt",20,"male")
print(p1.__dict__ )

>>>>{'name': 'cwt', 'age': 20, 'gender': 'male'} 
People.eat(p1)
p1.eat()

 解析上述代码：

（1）当你实例化时，类名（参数）时，就会自动触发__init__函数。

（2）上面的self参数表示的就是实例，即上述代码的p1，

（3）为什么__init__有四个参数，但第一个我们不需要传呢？原因是你在实例化时，系统会自动帮你进行   p1 = People(p1,"cwt",20,"male")

（4）且该函数不需要返回值，因为self本身就是我们要的实例。

（5）__init__函数是将属性添加到实例的属性字典中 。所以可以说一般情况下通过实例化得到的实例，其属性字典里一般只有数据属性。但其可以调用类里的函数属性，因为作用域，实例会先在自己的属性字典里找，找不到就到类的属性字典里找。若类里也没有则会报错。

(6)只有实例调用函数属性时，会自动将实例传给函数，类调用的话需要自己传参数。

如：上述最后两行代码

10.类的增删改查：

class People:
    age = 20
    gender = "male"
print(People.age)        查
People.name = "cwt"      增
del People.gender        删
People.age = 18          改

11.实例的增删改查

class People:
    age = 20
    gender = "male"

p1 = People()
print(p1.age)            查
p1.name = "cwt"          增
del p1.gender            删
p1.name = "chenweitao"   改

为实例增加属性也可以增加函数属性，不过当你在调用自己增加的函数属性时，需要增加传self参数。

class People:
    def __init__(self,name):
        self.name = name


def eat(self):
    print("%s正在吃东西" %self.name)



p1 = People("cwt")
p1.eat = eat   将eat函数加入实例p1中
p1.eat(p1)


》》》cwt正在吃东西

 11.注意：只有当用 . 或者字典的形式的时候才是在调用属性的值。

age = 20
class People:
    age = 18
    def __init__(self):
        print(age)


People()   >>>>20
print(People.age)  >>>>18

12.当属性值为一个列表时，有以下几点要注意。

class Foo:
    l = ["a","b"]

p1 = Foo()
p1.l = ["1","2"]   >>相当于为实例p1添加一个l属性
p1.l.append("c")>若一开始没有为实例添加 l 属性，则此操作可以为类的属性 l 添加元素“c“

13.静态属性（@property）：将函数属性变成类似于数据属性，当调用给属性时，只能得到一个值。

作用：能封装函数里的逻辑

class Room:
    def __init__(self, width, length, height):
        self.width = width
        self.length = length
        self.height = height
    @property
    def volume(self):
        return self.width * self.height * self.length

r1 = Room(20,20,20)
print(r1.volume)  
print(r1.width)
>>>>8000
>>>>20

14.类方法：当我们在用类调用函数属性时，由于函数属性有设置self值，所以我们需要先实例化得到一个实例，然后才能在类中调用该函数。不过我们可以用@classmethod 来解决。直接从类中调用函数属性。

class Room:
    def __init__(self, width, length, height):
        self.width = width
        self.length = length
        self.height = height
    @classmethod
    
def volume(cls):
        print(cls)

Room.volume()

15.静态方法：有些函数并不需要传实例，即没有self值，但我们在实例中调用该函数时，由于系统会自动把实例传给该函数，所以会报错。可以用@staticmethod解决。

class Room:
    def __init__(self, width, length):
        self.width = width
        self.length = length
    def volume():
        print("没有self值")

r1 = Room(20,20)
r1.volume()   >>系统会自动变为：r1.volume(r1) 

>>>报错

class Room:
    def __init__(self, width, length):
        self.width = width
        self.length = length
    @staticmethod
    def volume():
        print("没有self值")

r1 = Room(20,20)
r1.volume()

》》》没有self值

16.组合：即做类于类之间的关联。如当你建一个老师的类时，这个类中有个属性是学校，所以你就可以做老师类和学校类的关联。

class Teacher:
    def __init__(self,school):
        self.school = school

class School:
    def __init__(self,name):
        self.name = name
s1 = School("澄海中学")
t1 = Teacher(s1)

print(t1.__dict__)

》》{'school': <__main__.School object at 0x0364EDB0>}