初识面向对象

初识类和对象    

python中一切皆为对象，类型的本质就是类。

类是抽象的，通俗来说就是我知道有什么属性，有什么技能，但不知道具体的值。

对象是具体的，属性和技能都是根据类规范的。

在python中，用变量表示特征，用函数表示技能，因而具有相同特征和技能的一类事物就是“类”，对象则是这一类事物中具体的一个。

1、类有两种作用：属性引用和实例化

1.1、属性引用（类名、属性）

class Person:   #定义一个人类
    role = 'person'  #人的角色属性都是人
    def walk(self):  #人都可以走路，也就是有一个走路方法
        print("person is walking...")


print(Person.role)  #查看人的role属性
print(Person.walk)  #引用人的走路方法，注意，这里不是在调用

1.2、实例化

类名加括号就是实例化，会自动触发__init__函数的运行，可以用它来为每个实例订制自己的特征

class Person:   #定义一个人类
    role = 'person'  #人的角色属性都是人
    def __init__(self,name):
        self.name = name  # 每一个角色都有自己的昵称;
        
    def walk(self):  #人都可以走路，也就是有一个走路方法
        print("person is walking...")


print(Person.role)  #查看人的role属性
print(Person.walk)  #引用人的走路方法，注意，这里不是在调用

实例化的过程就是类——>对象的过程

原本我们只有一个Person类，在这个过程中，产生了一个egg对象，有自己具体的名字、攻击力和生命值。

语法：对象名 = 类名(参数)

注：参数是init方法的。

egg = Person('egon')  #类名()就等于在执行Person.__init__()
#执行完__init__()就会返回一个对象。这个对象类似一个字典，存着属于这个人本身的一些属性和方法。
#你可以偷偷的理解：egg = {'name':'egon','walk':walk}

类名能做的事：

        1）实例化

        2）调用方法：只不过要自己传递self参数

        3）调用类中的属性，也就是调用静态属性

        4）__dict__对于类中的名字只能看，不能操作。

        5）但是可以直接修改。

补充：

类关键字：class

__init__方法：初始化方法，python帮我们创建了一个对象self,每当我们调用类的时候就会触发这个方法，默认传self,在这个方法里可以对self进行赋值。

self是什么？

self拥有的属性都属于对象，是一个空对象，以字典形式存在。

实例跟对象完全没有区别。 

2、对象之间的交互

对象是关于类而实际存在的一个例子，即实例。

对象/实例只有一种作用：属性引用。

对象查看属性：对象.属性名

对象调用方法：对象.方法名（参数）

                          类名.方法名（对象名，参数）

对象能做的事：

         1）查看属性

         2）调用方法

         3）__dict__对于对象的增删改查操作都可以通过字典的语法进行。

class Dog:
    def __init__(self,name,blood,aggr,kind):
        self.name=name
        self.blood=blood
        self.aggr=aggr
        self.kind=kind
    def bite(self,person):
        person.blood-=self.aggr
        print("%s咬了%s，%s掉了%s血"%(self.name,person.name,person.name,self.aggr))
        if person.blood<=0:
            print("%s咬了%s，%s死掉了"%(self.name,person.name,person.name))

class Person:
    def __init__(self,name,blood,aggr,sex):
        self.name = name
        self.blood = blood
        self.aggr = aggr
        self.sex = sex
    def attack(self,dog):
        dog.blood-=self.aggr
        if dog.blood <= 0:
            print("%s打了%s，%s死掉了" % (self.name,dog.name,dog.name))
        else:
            print("%s打了%s，%s掉了%s血" % (self.name, dog.name,dog.name, self.aggr))

alex=Person("二哥",1000,100,"男")
jin=Dog("阿花",30,100,"Teddy")
jin.bite(alex)
alex.attack(jin)
print(jin.blood)
print(alex.blood)

 3、类和对象命名空间

创建一个类就会创建一个类的名称空间，用来存储类中定义的所有名字，这些名字称为类的属性

而类有两种属性：静态属性和动态属性

• 静态属性就是直接在类中定义的变量
• 动态属性就是定义在类中的方法

对象找名字 ： 先找自己的 找类的 再找不到就报错

对象修改静态属性的值
对于不可变数据类型来说，类变量最好用类名操作
对于可变数据类型来说，对象名的修改是共享的，重新赋值是独立的

类的数据属性是共享给所有对象的

>>>id(egg.role)
4341594072
>>>id(Person.role)
4341594072

类的动态属性是绑定到所有对象的

>>>egg.attack
<bound method Person.attack of <__main__.Person object at 0x101285860>>
>>>Person.attack
<function Person.attack at 0x10127abf8> 

创建一个对象/实例就会创建一个对象/实例的名称空间，存放对象/实例的名字，称为对象/实例的属性

class Course:
    language="Chinese"    #静态属性
    def __init__(self,teacher,course_name,period,price):
        self.teacher=teacher
        self.course_name=course_name
        self.period=period
        self.price=price
    def func(self):
        pass

python = Course('egon','python','6 months',20000)
linux = Course('oldboy','linux','6 months',20000)

Course.language="Endlish"           #可直接修改
# Course.__dict__["language"]="English"     #__dict__对于类中的名字只能看，不能直接修改
print(Course.language)  #Endlish

python.language="Chinese"
print(python.language)    #Chinese  python独有属性
print(Course.language)  #Endlish
print(python.__dict__)
print(linux.__dict__)  #{'teacher': 'egon', 'period': '6 months', 'price': 20000, 'course_name': 'python', 'language': 'Chinese'}
print(Course.__dict__)  #{'teacher': 'oldboy', 'period': '6 months', 'price': 20000, 'course_name': 'linux'}

class Person:
    money=0
    def  work(self):
        Person.money+=1000
mother=Person()    #实例化mother
father=Person()   #实例化father
mother.work()    #+1000
father.work()    #+1000
print(Person.money)   #2000

例：创建一个类，每实例化一个对象就计数最终所有的对象共享这个数据

class Foo:
    count=0
    def __init__(self):
        Foo.count+=1
f1=Foo()   #实例化对象
f2=Foo()   #实例化对象
print(f1.count) #2
print(f2.count)  #2
f3=Foo()  #实例化对象
print(f3.count)  #3
print(f1.count)  #3

4、面向对象的组合

软件重用的重要方式除了继承之外还有另外一种方式，即：组合

组合指的是，在一个类中以另外一个类的对象作为数据属性，称为类的组合。（什么有什么的关系）

class Dog:
    def __init__(self,name,aggr,hp,kind):
        self.name = name
        self.aggr = aggr
        self.hp = hp
        self.kind = kind

    def bite(self,person):
        person.hp -= self.aggr

class Person:
    def __init__(self,name,aggr,hp,sex):
        self.name = name
        self.aggr = aggr
        self.hp = hp
        self.sex = sex
        self.money = 0

    def attack(self,dog):
        dog.hp -= self.aggr

    def get_weapon(self,weapon):
        if self.money >= weapon.price:
            self.money -= weapon.price
            self.weapon = weapon
            self.aggr += weapon.aggr
        else:
            print("余额不足，请先充值")

class Weapon:
    def __init__(self,name,aggr,njd,price):
        self.name = name
        self.aggr = aggr
        self.njd = njd
        self.price = price

    def hand18(self,person):
        if self.njd > 0:
            person.hp -= self.aggr * 2
            self.njd -= 1

alex = Person('alex',0.5,100,'不详')
jin = Dog('金老板',100,500,'teddy')
w = Weapon('打狗棒',100,3,998)
# alex装备打狗棒
alex.money += 1000
alex.get_weapon(w)
print(alex.weapon)
print(alex.aggr)
alex.attack(jin)
print(jin.hp)
alex.weapon.hand18(jin)
print(jin.hp)

下面看一下计算圆环面积和周长的例子，了解一下面向对象的组合。

from math import pi
class Circle:   #定义了一个圆形类
    def __init__(self,r):
        self.r = r
    def area(self):  #计算圆面积方法
        return self.r**2 * pi
    def perimeter(self):   #计算圆周长方法
        return 2*pi*self.r

class Ring:   #定义了一个圆环类
    def __init__(self,outside_r,inside_r):
        self.outside_c=Circle(outside_r)
        self.inside_c=Circle(inside_r)
    def area(self): #计算圆环面积方法
        return self.outside_c.area()-self.inside_c.area()
    def perimeter(self):  #计算圆环周长方法
        return self.outside_c.perimeter()+self.inside_c.perimeter()

ring=Ring(10,2) #实例化一个圆环
print(ring.area())  #计算圆环的面积
print(ring.perimeter())  #计算圆环的周长

用组合的方式建立了类与组合的类之间的关系

关于老师所教课程和生日

class Birthday:
    def __init__(self,year,month,day):
        self.year=year
        self.month=month
        self.day=day

class Course:
    def __init__(self,course_name,period,price):
        self.course_name=course_name
        self.period=period
        self.price=price

class Teacher:
    def __init__(self,name,age,sex,birthday):
        self.name=name
        self.age=age
        self.sex=sex
        self.birthday=birthday
        self.course=Course("python","6 months",19800)


ya=Birthday(2018,1,16)
yaya=Teacher("egon",18,"女",ya)
print(yaya.birthday.year)   #2018
print(yaya.birthday.month)  #1
print(yaya.course.price)   #19800

当类之间有显著不同，并且较小的类是较大的类所需要的组件时，用组合比较好。