初识面向对象

一、类的相关知识

类：具有相同属性和方法的一类事物

class 类名：(类名首字母一般大写） ( 类属性：静态属性，可以被直接调用)

def __init__(self,参数1，参数2，......): （一般都用self，执行完一个__init__就返回一个对象）

self. 对象的属性1=参数1

self.对象的属性2=参数2

def 函数名（）： (方法函数）（动态属性）

( self.参数1)与(self.参数2)等的表达式

对象名=类名（给参数1参数2传值）

对象名.对象的属性1 （实例化）

print（对象名.函数名（）） (调用方法函数）

二、对象的相关知识

对象：具有具体属性的事物

对象/实例只有属性引用的作用

小明，10岁，男，上山去砍柴
小明，10岁，男，开车去东北
 小明，10岁，男，最爱大保健
 老李，90岁，男，上山去砍柴
 老李，90岁，男，开车去东北
 老李，90岁，男，最爱大保健

class Person:
    def   __init__(self,name,age):
        self.name=name
        self.age=age
        self.male='男'
    def  hiking(self):
        print('%s,%s岁,%s,上山去砍柴'%(self.name,self.age,self.male))
    def   diving(self):
        print('%s,%s岁,%s,开车去东北'%(self.name,self.age,self.male))
    def  hobby(self):
        print('%s,%s岁,%s,最爱大保健'%(self.name,self.age,self.male))
小明=Person('小明',10)
老李=Person('老李',90)
小明.hiking()
小明.diving()
小明.hobby()
老李.hiking()
老李.diving()
老李.hobby()

练习

三、对象之间的交互

对象之间的交互就是一种类与另一种类之间通过代码交流

人狗大战
class Person:
    def __init__(self,name,age,aggr):
        self.name=name
        self.age=age
        self.aggr=aggr
        self.blood=20000
    def attack(self,dog):
        print('%s attack %s'%(self.name,dog.name_1))
        dog.blood_1=dog.blood_1-self.aggr
david=Person('david',23,300)


class Dog:
    def __init__(self,name_2):
        self.name_1=name_2
        self.aggr_1=10000
        self.blood_1=2000
    def bit(self,person):
        print('%s bit %s'%(self.name_1,person.name))
        person.blood=person.blood-self.aggr_1

husky=Dog('husky')
david.attack(husky)
print(husky.blood_1)
husky.bit(david)
print(david.blood)

人狗大战

四、练习

class Rectangle:
    def __init__(self, a,b):
         self.a=a
         self.b=b
     def perimeter(self):
         return 2*(self.a+self.b)
    def area(self):
         return self.a*self.b
 l=Rectangle(23,42)
 print(l.perimeter())
 print(l.area())

长方形周长和面积

五、类的命名空间

1.对于类的静态属性

（1）如果类.属性就是调用类中的属性

（2）对象.属性先从自己的内存空间找，找到就用自己的，找不到用类的，类中找不到就报错

2.对于类的动态属性（方法）

（1）这个方法本身就存在类中，不会存到对象空间里

（2）对象调用类的方法时，需要一个地址簿去内存空间找

3.关于对象的属性

（1）对象的属性就存在对象的命名空间中

（2）只能被对象调用和修改

（3）不能被类调用

class A:
    country = '印度'
    def show_name(self):
        print(self.name)

a = A()                  #实例化对象
a.name = 'alex'      #给对象创建一个name属性
a.show_name()      #调用了showname方法

例1

class A:
    country = '印度'
    def show_name(self):
        print(self.name)

a = A()
a.name = 'alex'
a.show_name = 'egon'
a.show_name()     #报错

例2

class A:
    country = '印度'
    def show_name(self):
        print(self.name)

a = A()    #a对象
b = A()    #b对象
print(A.country)
print(a.country)   #先找a对象的内存 再找A的内存
print(b.country)
a.country = '中国'  #给a对象创建了一个属性
print(A.country)    #印度
print(a.country)    #中国
print(b.country)    #印度

例3

六、组合

组合表达了“什么有什么”的关系，增强了代码的重用性。

class Circle:
    def __init__(self,r):
        self.r = r

    def area(self):
        return self.r*self.r*3.14

    def perimeter(self):
        return self.r*2*3.14

class Ring:
    def __init__(self,r_out,r_in):  #10,5
        self.c_out = Circle(r_out)
        self.c_in = Circle(r_in)

    def area(self):
        return self.c_out.area() - self.c_in.area()

    def perimeter(self):
        return self.c_out.perimeter() + self.c_in.perimeter()

r1 = Ring(10,5)
print(r1.area())
print(r1.perimeter())

例1

class Birthday:
    def __init__(self,year,month,day):
        self.year=year
        self.month=month
        self.day=day
class Course:
    def __init__(self,name,period,teacher,price):
        self.name=name
        self.period=period
        self.teacher=teacher
        self.price=price
class Person:
    def __init__(self,name,birth):
        self.name=name
        self.birthday=birth
birth_1=Birthday(1888,2,4)
py=Course('python','six month','aa',20000)
bb=Person('bb',birth_1)
bb.kecheng=py
print(bb.birthday.year)
print(bb.kecheng.name)
print(bb.name)

例2

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

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

    def equip(self,weapon):
        self.money -= weapon.price
        self.weapon = weapon

    def use_weapon(self,dog):
        self.weapon.hurt(dog)
        self.blood += self.weapon.back_blood

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

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

class Weapon:
    def __init__(self,name,attack,price,back_blood):
        self.name = name
        self.attack = attack
        self.price = price
        self.back_blood = back_blood

    def hurt(self,dog):
        dog.blood -= self.attack


egon = Person()
alex = Person('alex','不详',20,40000)
dog = Dog('egg','藏獒',500,20000)
#加武器
毒包子 = Weapon('毒包子',10000,200,300)
egon.money = 200
if egon.money >= 毒包子.price:
    egon.equip(毒包子)
egon.use_weapon(dog)
print(egon.blood)
print(dog.blood)

例3

七、多态

python天生支持多态

class Foo:
    pass

def func(f_obj):
    print(f_obj)

f=Foo()
print(type(f))

多态实例1

class Banana:
    pass
class Apple:
    pass
def eat(fruit_obj):
    print(fruit_obj)
b=Banana()
eat(b)

多态实例2

posted @ 2017-10-30 14:36 星雨5213 阅读(93) 评论(0) 收藏举报

刷新页面返回顶部

星雨5213

初识面向对象

初识面向对象

公告