1.类和对象

  • 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
  • 对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。
    面向对象：是把数据和方法结合起来，进行了分装。

1.1 类

打个比方，类好似玩具的模子，对象就是模子刻画出的玩具。
类包含：

  • 类的名称：类名
  • 类的属性：一组数据
  • 类的方法：允许进行操作的方法。

1.2 对象

首先定义一个类：

class Cat:
    #属性

    #方法
    def eat(self):
        print("猫在吃鱼....")

    def drink(self):
        print("猫正在喝kele.....")

如果单纯执行一个类，会有反应吗？不会，所以要创建一个对象，怎么创建啊？：

class Cat:
    #属性

    #方法
    def eat(self):
        print("猫在吃鱼....")

    def drink(self):
        print("猫正在喝kele.....")

#创建一个对象
tom = Cat()

调用tom指向的对象中的 方法

tom.eat()
tom.drink()

添加属性：

tom.name = "汤姆"
tom.age = 40

获取对象的属性：

class Cat:
    #属性

    #方法
    def eat(self):
        print("猫在吃鱼....")

    def drink(self):
        print("猫正在喝kele.....")

    def introduce(self):
        print("%s的年龄是:%d"%(tom.name, tom.age))


#创建一个对象
tom = Cat()

#调用tom指向的对象中的 方法
tom.eat()
tom.drink()

#给tom指向的对象添加2个属性
tom.name = "汤姆"
tom.age = 40

#获取属性的第1种方式
#print("%s的年龄是:%d"%(tom.name, tom.age))

tom.introduce()

结果显示：

猫在吃鱼....
猫正在喝kele.....
汤姆的年龄是:40

###多个对象：
一个模板只能创建一个对象吗，难道 tom 创建一个，其他不可以吗？比如蓝猫：

class Cat:
    #属性

    #方法
    def eat(self):
        print("猫在吃鱼....")

    def drink(self):
        print("猫正在喝kele.....")

    def introduce(self):
        print("%s的年龄是:%d"%(tom.name, tom.age))


#创建一个对象
tom = Cat()

#调用tom指向的对象中的 方法
tom.eat()
tom.drink()

#给tom指向的对象添加2个属性
tom.name = "汤姆"
tom.age = 40

#获取属性的第1种方式
#print("%s的年龄是:%d"%(tom.name, tom.age))

tom.introduce()


lanmao = Cat()
lanmao.name = "蓝猫"
lanmao.age = 10
lanmao.introduce()

结果显示:

猫在吃鱼....
猫正在喝kele.....
汤姆的年龄是:40
汤姆的年龄是:40

让人惊奇，感觉不好啦，问题出现啦。执行方法中有 tom.
###self:
那个对象的调用这个方法，此时指向调回去的对象。
如果解决上述问题，只要把tom替换为self即可。

#print("%s的年龄是:%d"%(tom.name, tom.age))
print("%s的年龄是:%d"%(self.name, self.age))

不用传参数，理解即可。

tom.introduce()#相当于 tom.introduce(tom)

###init:
一遍两个下划线，初始化对象。
对象创建的流程：

  1. 创建一个对象
  2. Python 解释器会自动的调用这个方法（谁调用传谁）
  3. 返回创建对象的引用给 Tom
class Cat:
    """定义了一个Cat类"""

    #初始化对象
    def __init__(self, new_name, new_age):
        self.name = new_name
        self.age = new_age

    #方法
    def eat(self):
        print("猫在吃鱼....")

    def drink(self):
        print("猫正在喝kele.....")

    def introduce(self):
        print("%s的年龄是:%d"%(self.name, self.age))

#创建一个对象
tom = Cat("汤姆", 40)
tom.eat()
tom.drink()
#tom.name = "汤姆"
#tom.age = 40
tom.introduce()

lanmao = Cat("蓝猫", 10)
#lanmao.name = "蓝猫"
#lanmao.age = 10
lanmao.introduce()

###**str: **

也不许自已调用，需要的时候会自动调用。

没有这个方法的时候，会

python类与对象 python中的类和对象_数据


当你想取调用对象信息的时候，Python会自动调用这个方法。比如print（tom），

class Cat:
    """定义了一个Cat类"""

    #初始化对象
    def __init__(self, new_name, new_age):
        self.name = new_name
        self.age = new_age

    def __str__(self):
        return "%s的年龄是:%d"%(self.name, self.age)

    #方法
    def eat(self):
        print("猫在吃鱼....")

    def drink(self):
        print("猫正在喝kele.....")

    def introduce(self):
        print("%s的年龄是:%d"%(self.name, self.age))

#创建一个对象
tom = Cat("汤姆", 40)

lanmao = Cat("蓝猫", 10)


print(tom)
print(lanmao)

###烤地瓜

class SweetPotato:
    """定义了一个地瓜类"""
    def __init__(self):
        self.cookedString = "生的"
        self.cookedLevel = 0
        self.condiments = []#为了能够存储多个数据,往往在开发中让一个属性是列表

    def __str__(self):
        return "地瓜 状态:%s(%d),添加的作料有:%s"%(self.cookedString, self.cookedLevel, str(self.condiments))

    def cook(self, cooked_time):

        #因为这个方法被调用了多次,为了能够在一次调用这个方法的时候 能够 获取到上一次调用这个方法时的cooked_time
        #所以 需要在此,把cooked_time保存到这个对象的属性中,因为属性不会随着方法的调用而结束(一个方法被调用的时候
        #是可以用局部变量来保存数据的,但是当这个方法定义结束之后这个方法中的所有数据就没有了)
        self.cookedLevel += cooked_time

        if self.cookedLevel >=0 and self.cookedLevel<3:
            self.cookedString = "生的"
        elif self.cookedLevel >=3 and self.cookedLevel<5:
            self.cookedString = "半生不熟"
        elif self.cookedLevel >=5 and self.cookedLevel<8:
            self.cookedString = "熟了"
        elif self.cookedLevel>8:
            self.cookedString = "烤糊了"

    def addCondiments(self, item):
        #因为item这个变量指向了一个 作料,所以 接下来需要将item放到append里面
        self.condiments.append(item)


#创建了一个地瓜对象
di_gua = SweetPotato()
print(di_gua)

#开始烤地瓜
print('开始烤地瓜')
di_gua.cook(1)
print(di_gua)
di_gua.cook(1)
print(di_gua)
di_gua.addCondiments("大蒜")
di_gua.cook(1)
print(di_gua)
di_gua.cook(1)
di_gua.addCondiments("番茄酱")
print(di_gua)
print('上面加入番茄酱')
di_gua.cook(1)
print(di_gua)
di_gua.cook(1)
di_gua.addCondiments("孜然")
print(di_gua)
di_gua.cook(1)
print(di_gua)
di_gua.addCondiments("芥末")
di_gua.cook(1)
print(di_gua)
di_gua.cook(1)
print(di_gua)
di_gua.cook(1)
print(di_gua)
di_gua.cook(1)
print(di_gua)

###存放家具
把一个对象放入另一个对象属性中。

class Home:
    def __init__(self, new_area, new_info, new_addr):
        self.area = new_area
        self.info = new_info
        self.addr = new_addr
        self.left_area = new_area
        self.contain_items = []

    def __str__(self):
        msg = "房子的总面积是:%d,可用面积是:%d,户型是:%s,地址是:%s"%(self.area, self.left_area, self.info, self.addr)
        msg += " 当前房子里的物品有%s"%(str(self.contain_items))
        return msg

    def add_item(self, item):
        #self.left_area -= item.area
        #self.contain_items.append(item.name)

        self.left_area -= item.get_area()
        self.contain_items.append(item.get_name())

class Bed:
    def __init__(self, new_name, new_area):
        self.name = new_name
        self.area = new_area

    def __str__(self):
        return "%s占用的面积是:%d"%(self.name, self.area)

    def get_area(self):
        return self.area

    def get_name(self):
        return self.name

fangzi = Home(129, "三室一厅", "北京市 朝阳区 长安街 666号")
print(fangzi)


bed1 = Bed("席梦思", 4)
print(bed1)

fangzi.add_item(bed1)
print(fangzi)

bed2 = Bed("三人床",3)
fangzi.add_item(bed2)
print(fangzi)

没改属性之前

python类与对象 python中的类和对象_初始化_02


改成方法，防止以后我不想让你看啊。