python笔记(面向对象)

一、面向对象
1.所谓模子就是类抽象的
2.对象 = 类名()
3.过程：
（1）类名():首先会创造出一个对象，创建了一个self变量
（2）调用init方法，类名括号里的参数会被这里接收
（3）执行init方法
（4）返回self: self就是一个能够存储很多属性的一个大字典

在这里插入图片描述

class Person:
    country = 'china'         #创造了一个只要是这个类就一定有的属性
    # self就是一个能够存储很多属性的一个大字典
    def __init__(self,*arg):   #初始化方法，self是对象
        self.name = arg[0]
        self.hp = arg[1]
        self.aggr = arg[2]
        self.sex = arg[3]
    def walk(self,n):           #方法，一般情况下必须传self,且必须写第一个，也可以传其它参数
        print('%s走了%s步'%(self.name,n))

alex = Person('耿娃',10,1,'不详')#类的实例化
print(alex.__dict__)#查看所有属性
print(Person.__dict__)#查看创造类的属性
print(alex.name)#查看实例化类的属性
alex.age = 8#可添加属性
alex.walk(3)#调用方法 ： 类名.方法名（对象名）
print(Person.__dict__['country'])#直接操作字典
print(alex.country) #调用类的属性，不需要实例化





 class Person:
  country = 'china'         #创造了一个只要是这个类就一定有的属性
    # self就是一个能够存储很多属性的一个大字典
    def __init__(self,*arg):   #初始化方法，self是对象
        self.name = arg[0]
        self.hp = arg[1]
        self.aggr = arg[2]
        self.sex = arg[3]
    def attack(self,dog):           #方法，一般情况下必须传self,且必须写第一个，也可以传其它参数
        dog.hp -= self.aggr
        print(self.name+'打了%s%血',(dog.name,self.aggr))

class Dog:
    country = 'china'         #创造了一个只要是这个类就一定有的属性
    # self就是一个能够存储很多属性的一个大字典
    def __init__(self,*arg):   #初始化方法，self是对象
        self.name = arg[0]
        self.hp = arg[1]
        self.aggr = arg[2]
        self.sex = arg[3]
    def bite(self,person):           #方法，一般情况下必须传self,且必须写第一个，也可以传其它参数
        person.hp -= self.aggr
        print(self.name+'咬了%s%s血'%(person.name,self.aggr))


gengwa = Dog('耿娃',100,10,'teddy')
aoteman = Person('迪迦',100,11,'男')
gengwa.bite(aoteman)
print(aoteman.hp)

4.类中的静态变量可以被对象和类调用对于不可变数据类型，类变量最好用类名操作
对于可变数据类型来说，对象名修改是共享的，重新赋值是独立的

class Person:
    country = ['china']         #创造了一个只要是这个类就一定有的属性
    # self就是一个能够存储很多属性的一个大字典
    def __init__(self,*arg):   #初始化方法，self是对象
        self.name = arg[0]
        self.hp = arg[1]
        self.aggr = arg[2]
        self.sex = arg[3]
    def walk(self,n):           #方法，一般情况下必须传self,且必须写第一个，也可以传其它参数
        print('%s走了%s步'%(self.name,n))

man = Person('haha',12,2,'nv')
men = Person('xia',1,2,'uy')
man.country[0] = 'hu'
print(man.__dict__)
print(men.country)
print(Person.country)

输出结果：

{‘name’: ‘haha’, ‘hp’: 12, ‘aggr’: 2, ‘sex’: ‘nv’}
[‘hu’]
[‘hu’]

class foo:
    count = 0
    def __init__(self):
        foo.count += 1
f1 = foo()
f2 = foo()
print(f1.count)
print(f2.count)

输出结果：

2
2

5.一个类的定义不一定要__init__
6.面向对象的三大特性：继承，多态，封装
7.组合：一个对象的属性值是另外一个类的对象

人狗大战：

class Person:
    country = 'china'         #创造了一个只要是这个类就一定有的属性
    # self就是一个能够存储很多属性的一个大字典
    def __init__(self,*arg):   #初始化方法，self是对象
        self.name = arg[0]
        self.hp = arg[1]
        self.aggr = arg[2]
        self.sex = arg[3]
        self.money = 0
    def attack(self,dog):           #方法，一般情况下必须传self,且必须写第一个，也可以传其它参数
        dog.hp -= self.aggr
        print(self.name+'打了%s%s血还剩%s血'%(dog.name,self.aggr,dog.hp))
    def get_weapon(self,weapon):
        if self.money >= weapon.price:
            self.weapon = weapon
            self.aggr += weapon.aggr
            self.money -= weapon.price
        else:
            print('余额不足')


class Dog:
    country = 'china'         #创造了一个只要是这个类就一定有的属性
    # self就是一个能够存储很多属性的一个大字典
    def __init__(self,*arg):   #初始化方法，self是对象
        self.name = arg[0]
        self.hp = arg[1]
        self.aggr = arg[2]
        self.sex = arg[3]
    def bite(self,person):           #方法，一般情况下必须传self,且必须写第一个，也可以传其它参数
        person.hp -= self.aggr
        print(self.name+'咬了%s%s血'%(person.name,self.aggr))


class Weapon:
    def __init__(self,name,aggr,njd,price):
        self.name = name
        self.aggr = aggr
        self.njd = njd
        self.price = price
    def hand18(self,dog):
        if self.njd > 0:
            dog.hp -= self.aggr*2
            self.njd  -= 1

geng = Dog('gengwa',100,0.5,'no')
long = Person('xiaolong',300,1,'nan')
w = Weapon('打狗棒',3,3,30)
long.money += 1000
long.get_weapon(w)
print(long.weapon)
long.attack(geng)
long.weapon.hand18(geng) #long.weapon是weapon类的对象（组合）
print(geng.hp)

组合练习

  from math import pi
    class Ring:
        def __init

__(self,R):
        self.R = R
    def area(self):
        return self.R**2 * pi
class Huan:
    def __init__(self,out_R,in_R):
        self.out_area = Ring(out_R)
        self.in_area = Ring(in_R)
    def area(self):
        return self.out_area.area() - self.in_area.area()#使用了组合
huan = Huan(4,2)
print(huan.area())

输出结果：

37.69911184307752

创建一个老师类
老师有生日
生日也可以是一个类
组合
1.一个类的对象是另一个类对象的属性（至少两个类）
2.

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


class Teacher:
    def __init__(self,name,age,sex,birthday):
        self.name = name
        self.age = age
        self.sex = sex
        self.birthday = birthday

date = Birthday(2018,1,16)
man = Teacher('long',18,'男',date)
print(man.birthday.year)
print(man.birthday.month)
print(man.birthday.day)

输出结果：

2018
1
16

python笔记(面向对象)

猜你喜欢