python实战：类，对象，init，del，str

概念

一、面向函数的编程方式

1. 把完成某 ⼀ 个需求的所有步骤从头到尾逐步实现；

2. 根据开发需求，将某些功能独 ⽴ 的代码封装成 ⼀ 个 ⼜⼀ 个函数；

3. 最后完成的代码，就是顺序地调 ⽤ 不同的函数。

二、⾯向对象的编程方式

相 ⽐ 较函数， ⾯ 向对象是更 ⼤ 的封装，根据职责在 ⼀ 个对象中封装多个 ⽅ 法

三、类和对象的概念

类和对象是 ⾯ 向对象编程的两个核 ⼼ 概念。

1. 类

类是对 ⼀ 群具有相同特征或者 ⾏ 为的事物的 ⼀个统称，是抽象的，不能直接使 ⽤ 。

特征被称为属性 ； ⾏ 为被称为 ⽅ 法 。

2. 对象

对象是由类创建出来的 ⼀ 个具体存在，可以直接使 ⽤ 。

由哪 ⼀ 个类创建出来的对象，就拥有在哪 ⼀个类中定义的： 属性 ；   ⽅ 法 。

3. 类和对象的关系

类是模板，对象是根据类这个模板创建出来的，应该先有类，再有对象 ；

类只有 ⼀ 个， ⽽ 对象可以有很多个 ；

不同的对象之间属性可能会各不相同 ；

类中定义了什么属性和 ⽅ 法，对象中就有什么属性和 ⽅法，不可能多，也不可能少

四、类的设计

在程序开发中，要设计 ⼀ 个类，通常需要满 ⾜⼀ 下三个要素：

1. 类名 这类事物的名字 ；

2. 属性 这类事物具有什么样的特征 ；

3. ⽅ 法 这类事物具有什么样的 ⾏ 为

1. 属性和⽅法的确定

对于对象的特征描述，通常可以定义成属性 ，属性的具体实现可以是一个

变量；

对象具有的 ⾏ 为（动词），通常可以定义成 ⽅ 法，方法的具体实现可以是一

个类里面的函数 ；

语法

一、class 关键字

class 关键字用于创建一个类，语法如下：

 class 类名: 
   def ⽅法 1(self, 参数列表): 
       pass
   def ⽅法 2(self, 参数列表): 
       pass

• ⽅法的定义格式和之前学习过的函数⼏乎⼀样 ;
• 区别在于第⼀个参数必须是 self ，⼤家暂时先记住，稍后介绍 self 。

二、类的代码实现

class cat:
   def eat(self):
       print("汤姆爱吃鱼")
   def drink(self):
       print("汤姆爱喝水")

三、 创建一个对象

名词解释

1. 实例 ------ 通过类创建出来的对象叫做类的实例；

2. 实例化 ------ 创建对象的动作叫做实例化 。

创建对象语法：

对象名 = 类名 ( 参数列表 )

类是静态的，只有创建为对象后，才能成为动态运行的程序。

class cat:
   def eat(self):
       print("汤姆爱吃鱼")
   def drink(self):
       print("汤姆爱喝水")
# 创建 lazy_cat 对象 
lazy_cat = cat() 
# 调用对象的 eat 方法 
lazy_cat.eat() 
# 调用对象的 drink 方法 
lazy_cat.drink()

四、⽅法中的 self 参数

  在类封装的 ⽅ 法内部， self 就表示调用方法的对象自己 ；

调 ⽤⽅ 法时，不需要传递 self 参数 ；

在方法内部可以通过 self. 访问对象的属性；

        通过在方法内部使用 self.属性名 = 值，为类添加属性

在方法内部可以通过 self. 调 ⽤ 对象的 ⽅ 法；

在类的外部，通过 对象名 . 访问对象的属性和 ⽅ 法 。

五、cat 类添加 name 属性，同时创建两个对象

# 定义 cat 类
class cat:
    def set_name(self, name):
# 给 cat 类添加一个属性 name
        self.name = name
    def eat(self):
        print("%s 爱吃鱼" % self.name)
    def drink(self):
        print("%s 爱喝水" % self.name)
# 创建 lazy_cat 对象
lazy_cat = cat() 
lazy_cat.set_name("懒猫") 
lazy_cat.eat() 
lazy_cat.drink() 
# 创建 tom_cat 对象 
tom_cat = cat() 
tom_cat.set_name("tom 猫") 
tom_cat.eat() 
tom_cat.drink()

# 有一个dog类,有属性name和age
# 提供设置,得到,显示name和age属性的方法
class dog:
    def __init__(self, name = '二哈', age = 2):
        self.name = name
        self.age = age

    def set_name(self, name):
        self.name = name

    def get_name(self):
        return self.name

    def show_name(self):
        print(self.name)

    def set_age(self, age):
        self.age = age

    def get_age(self):
        return self.age

    def show_age(self):
        print(self.age)

d = dog("比熊", 3)  # 实例化的时候设置属性的值
print(d.get_name())
d.set_name("黑背") # 实例化以后再设置属性值
print(d.get_name())
d.show_name()

__init__方法

一、 __init__ 初始化方法

__init__ 就是对象的初始化 ⽅ 法， __init__ 是对象的内置 ⽅ 法。

当使 ⽤ 类名 () 创建对象时，会自动执 ⾏ 以下操作：

1. 为对象在内存中分配空间 —— 创建对象 ;

2. 系统自动调用 ⽅ 法 (__ init__ ) .

二、 cat 类增加 __init__ 方法

三、在初始化方法内部为类添加属性

# 定义 cat 类
class cat:
# 初始化方法
  def __init__(self):
     self.name = "猫"
     print("%s 的初始化方法" % self.name)
  def eat(self):
     print("%s 爱吃鱼" % self.name)
  def drink(self):
     print("%s 爱喝水" % self.name)
# 创建对象的同时，初始化方法被自动调用
lazy_cat = cat()

四、带有参数的初始化方法

# 定义 cat 类
class cat:
# 初始化方法
  def __init__(self, name): 
      self.name = name
      print("%s 的带有参数的初始化方法" % self.name)
  def eat(self):
     print("%s 爱吃鱼" % self.name)
  def drink(self):
     print("%s 爱喝水" % self.name)
# 创建对象的同时，初始化方法被自动调用
lazy_cat = cat("tom")

五、初始化方法的缺省参数

# 定义 cat 类
class cat:
# 带有缺省参数初始化方法 
  def __init__(self, name = "猫"):
      self.name = name
      print("%s 的带有参数的初始化方法" % self.name)
  def eat(self):
     print("%s 爱吃鱼" % self.name)
  def drink(self):
     print("%s 爱喝水" % self.name)
# 创建对象的同时，初始化方法被自动调用
lazy_cat = cat()

__del__方法

一、__del__方法说明

• __del__方式只能有一个参数 self；
• 当对象在内存中被销毁的时候，__del__方法被系统自动调用；
• 当使⽤ 类名() 创建对象时，为对象分配完空间后，⾃动调⽤ __init__ ⽅
• 法 ；
• 当⼀个对象被从内存中销毁前，会⾃动调⽤ __del__ ⽅法 ；
• ⼀个对象的 __del__ ⽅法⼀旦被调⽤，对象的生命周期结束 。

• 在函数内定义的变量，函数执行完毕，变量就被销毁了；
• 在函数外部定义的变量，程序执行完毕，变量就被销毁了；
• 可以通过 del 关键字，显式的销毁一个变量。

# 定义 cat 类
class cat:
# 带有缺省参数初始化方法 
  def __init__(self, name = "猫"):
      self.name = name
      print("%s 的带有参数的初始化方法" % self.name)
  def __del__(self): 
      print("%s 被销毁了" % self.name)
  def eat(self):
      print("%s 爱吃鱼" % self.name)
  def drink(self):
      print("%s 爱喝水" % self.name)
# 创建对象的同时，初始化方法被自动调用
#案例一：调用 del 函数在程序完成前把对象销毁
lazy_cat = cat()
del lazy_cat 
print("程序终止")
#案例二：函数执行完成，对象销毁
def test_cat(): 
    lazy_cat = cat()
test_cat() 
print("程序终止")

__str__ 方法

在 Python 中，使 ⽤ print 输出 对象变量，默认情况下，会输出这个变量 引

⽤ 的对象是由哪 ⼀ 个类创建的对象，以及在内存中的地址（ ⼗ 六进制表示）

# 定义 cat 类
class cat:
# 带有缺省参数初始化方法 
  def __init__(self, name = "猫"):
      self.name = name
      print("%s 的带有参数的初始化方法" % self.name)
  def __del__(self): 
      print("%s 被销毁了" % self.name)
  def eat(self):
      print("%s 爱吃鱼" % self.name)
  def drink(self):
      print("%s 爱喝水" % self.name)


lazy_cat = cat() 
print(lazy_cat)

如果在开发中，希望使 ⽤ print 输出对象变量时，能够打印 ⾃ 定义的内容，

就可以利 ⽤ __str__ 这个内置 ⽅ 法了

注意： __str__

# 定义 cat 类
class cat:
# 带有缺省参数初始化方法 
  def __init__(self, name = "猫"):
      self.name = name
      print("%s 的带有参数的初始化方法" % self.name)
  def __del__(self): 
      print("%s 被销毁了" % self.name)
  def __str__(self): 
      return "我是一只%s" % self.name
  def eat(self):
      print("%s 爱吃鱼" % self.name)
  def drink(self):
      print("%s 爱喝水" % self.name)


lazy_cat = cat('www') 
# 这个时候 print 将显示__str__函数返回的字符串
print(lazy_cat)

类设计练习

class calc:
    def __init__(self, oper = "+"):
        self.oper = oper

    def calc(self, a, b):
        if self.oper == "+":
            return a + b
        elif self.oper == "-":
            return a - b
        elif self.oper == "*":
            return a * b
        elif self.oper == "/":
            if b != 0:
                return a / b
            else:
                return None
        else:
            return None

c = calc()
print(c.calc(3, 4))

d = calc("*")
print(d.calc(3, 4))

e = calc("/")
print(e.calc(3, 0))

f = calc("sdfsd")
print(f.calc(4, 5))