python之路 -- 面向对象基础

类和对象的相关知识

1.类的声明

'''
class 类名:
    类体
'''
#创建一个简单的people类
class People:            #类名的首字母一般大写
    people = "chinese"   #类的静态属性
    def walk(self):      #类的方法的定义
        print("people can walk.")

print(People.people)    #查看People类的静态属性people
print(People.walk)      #引用人的走路方法，注意，这里不是在调用walk方法
print(People.walk())　　# 会报错

# chinese
# <function People.walk at 0x000001F0FC924D08>

2.实例化

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

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

 

class People:
    people = "chinese"      #类的静态属性
    def __init__(self,name,age,sex):    #必须有一个self参数，且在第一个位置
        self.name = name
        self.age = age
        self.sex = sex

    def walk(self):         #类的方法的定义
        print('%s正在走路。'%self.name)

yl = People('yangl',18,"女")     #这就是一个实例化的过程，得到一个yl的对象  类名()就等于在执行Person.__init__()
                                #注意：实例化是传入的参数是__init__方法中的参数，且必须传
print(yl.name)              #查看此对象的属性
#>>>yangl
yl.walk()               #调用此对象中的方法，<==>People.walk(yl),得到相同的结果
                        #调用方法，对象名.方法名()
#>>>yangl正在走路。

 

3.整理的过程如下：

# 1.定义类
# 2.写__init__方法，此前可以定义静态属性
# 3.定义方法，方法都必须有一个self参数
# 4.实例化
#     对象=类（参数是__init__方法中的）
#     实例和对象没有区别
# 5.对象查看属性
#   调用对象的属性 对象.属性名
#   调用对象方法  对象.方法名（参数）《==》类名.方法名（对象名，参数）

4.类属性的补充

 

一：我们定义的类的属性到底存到哪里了？有两种方式查看
dir(类名)：查出的是一个名字列表
类名.__dict__:查出的是一个字典，key为属性名，value为属性值

二：特殊的类属性
类名.__name__# 类的名字(字符串)
类名.__doc__# 类的文档字符串
类名.__base__# 类的第一个父类
类名.__bases__# 类所有父类构成的元组
类名.__dict__# 类的字典属性
类名.__module__# 类定义所在的模块
类名.__class__# 实例对应的类(仅新式类中)

5.类的小练习

#在终端输出如下信息，用面向对象的方式
#小明，20岁，男，上山去砍柴
#小明，20岁，男，开车去东北
#小明，20岁，男，最爱happy
#老李，60岁，男，上山去砍柴
#老李，60岁，男，开车去东北
#老李，60岁，男，最爱happy

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

    def shangshan(self):
        print("%s,%s岁，%s,上山去砍柴"%(self.name,self.age,self.sex))

    def drive(self):
        print("%s,%s岁，%s,开车去东北" % (self.name, self.age, self.sex))

    def hobby(self):
        print("%s,%s岁，%s,最爱happy" % (self.name, self.age, self.sex))

xiaoming = People('小明',20,'男')
xiaoming.shangshan()
xiaoming.drive()
xiaoming.hobby()
laoli = People('老李',60,'男')
laoli.shangshan()
laoli.drive()
laoli.hobby()

#一个圆circle    属性:半径，两个方法：求周长和面积

from math import pi    #导入π
class Circle:
    def __init__(self,r):
        self.r = r

#定义一个计算圆的周长的方法
    def zhouchang(self):        
        return 2*pi*self.r

#定义一个计算圆的面积的方法
    def area(self):
        print(pi*(self.r**2))

yuan1 = Circle(5)        #实例化一个圆，传入半径为5
print(yuan1.zhouchang())        #计算圆的周长
yuan1.area()            #计算圆面积

#人狗大战游戏
class People:
    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扑街~~"%(dog.name,self.name,dog.name))
        else:
            print("%s剩余的血量为：%s"%(dog.name,dog.blood))

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

    def bite(self,people):
        people.blood -= self.aggr
        if people.blood <= 0:
            print("%s已经被%s打败,%s扑街~~"%(people.name,self.name,people.name))
        else:
            print("%s剩余的血量为：%s"%(people.name,people.blood))

people = People("alex",100,10,"man")
dog = Dog("金老板",200,20,"dog")

#人攻击狗的操作
people.attack(dog)
#狗咬人的操作
dog.bite(people)
people.attack(dog)
dog.bite(people)

 

6.面向对象小结——定义及调用的固定模式

class 类名:
    def __init__(self,参数1,参数2):
        self.对象的属性1 = 参数1
        self.对象的属性2 = 参数2

    def 方法名(self):pass

    def 方法名2(self):pass

对象名 = 类名(1,2)  #对象就是实例，代表一个具体的东西
                  #类名() : 类名+括号就是实例化一个类，相当于调用了__init__方法
                  #括号里传参数，参数不需要传self，其他与init中的形参一一对应
                  #结果返回一个对象
对象名.对象的属性1   #查看对象的属性，直接用 对象名.属性名 即可
对象名.方法名()     #调用类中的方法，直接用 对象名.方法名() 即可

---

类命名空间与对象、实例的命名空间

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

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

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

　　动态属性就是定义在类中的方法

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

>>>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> 

 

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

在obj.name会先从obj对象自己的名称空间里找name，找不到则去类中找，类也找不到就找父类...最后都找不到就抛出异常

---

面向对象的组合用法

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

组合指的是，在一个类中以另外一个类的对象作为数据属性，称为类的组合

class Teacher:    #创建一个Teacher类
    def __init__(self,name,age,classes):
        self.name = name
        self.age = age
        self.classes = classes

class Classes:    #创建一个Classees类
    def __init__(self,name,stu_num,price):
        self.name = name
        self.stu_num = stu_num
        self.price = price

classes1 = Classes("python全栈",30,19980)
teacher1 = Teacher("yl",18,classes1)    
#teacher的classes属性调用了对象classes1
print(teacher1.classes.name)

#运行结果：python全栈

　　圆环是由两个圆组成的，圆环的面积是外面圆的面积减去内部圆的面积。圆环的周长是内部圆的周长加上外部圆的周长。

这个时候，我们就首先实现一个圆形类，计算一个圆的周长和面积。然后在"环形类"中组合圆形的实例作为自己的属性来用。

from math import pi
class Circle:
    def __init__(self,r):
        self.r = r

    def zhouchang(self):
        return 2*pi*self.r

    def area(self):
        return pi*(self.r**2)

class Yuanhuan:
    def __init__(self,c1,c2):
        self.c1 = c1
        self.c2 = c2

    def huanzc(self):
        print(self.c1.zhouchang() + self.c2.zhouchang())

    def huanmj(self):
        return abs(self.c1.area() - self.c2.area())

C1 = Circle(10)        #实例化一个半径为10的圆
C2 = Circle(5)        #实例化一个半径为5的圆
huan1 = Yuanhuan(C1,C2)    #实例化一个圆环
print(huan1.huanmj())    #输出圆环的面积
huan1.huanzc()        #输出圆环的周长