007、面向对象基础

面向对象

类和对象

• 先有类后有对象

类

• 是对一群具有相同特征或者行为的事物的一个统称，是抽象的，不能直接使用。
  • 特征被称为属性
  • 行为被称为方法
• 类就相当于制造飞机的图纸，是一个模板，是负责创建对象的。

对象

• 对象是由类创建出来的一个具体存在，可以直接使用。
• 由哪一类创建出来的对象，就拥有哪一个类中定义的：
  • 属性
  • 方法
• 对象就相当于用图纸制造的飞机。

在程序开发中，应该先有类，再有对象。

类和对象的关系

• 类是模板，对象是根据类这个模板创建出来的，应该先有类，后有对象。
• 类只有一个，二对象可以有很多个
  • 不同的对象之间竖向可能会各不相同
• 类中定义了什么属性和方法，对象中就有什么属性和方法，不可能多，也不可能少。

类的设计

• 在使用面对对象开发前，应该首先分析需求，确定一下，程序中需要包含的类。
• 设计一个类，通常需要满足的三要素：
  • 类名：这类事物的名字，满足大驼峰命名
  • 属性：这类事物具有什么样的特征
  • 方法：这类事物具有的行为

大驼峰命名方法

• CapWords
• 每一个单词首字母大写
• 单词与单词之间没有下划线

类名的确定

• 名词提炼法，分析整个业务流程，出现的名词，通常就是找到的类

属性和方法的确定

• 对对象的特征描述，通常可以定义成属性
• 对象具有的行为，通常可以定义成方法

提示：需求中没有涉及的属性或者方法在设计类时，不需要考虑。

面对对象基础语法

dir 内置函数

• 快速查看一个对象的内置属性和方法
  • 使用内置函数dir，传入 标识符/数据，可以查看对象内所有的属性和方法。

提示：__方法名__格式的方法是Python提供的内置方法/属性，下划线下划线方法名下划线下划线。

def run():
    print("nihao")

dir(run)

['__annotations__',
 '__call__',
 '__class__',
 '__closure__',
 '__code__',
 '__defaults__',
 '__delattr__',
 '__dict__',
 '__dir__',
 '__doc__',
 '__eq__',
 '__format__',
 '__ge__',
 '__get__',
 '__getattribute__',
 '__globals__',
 '__gt__',
 '__hash__',
 '__init__',
 '__init_subclass__',
 '__kwdefaults__',
 '__le__',
 '__lt__',
 '__module__',
 '__name__',
 '__ne__',
 '__new__',
 '__qualname__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__setattr__',
 '__sizeof__',
 '__str__',
 '__subclasshook__']

定义简单的类（只包含方法）

• 面向对象是更大的封装，在一个类中封装多个方法，这样通过这个类创建的对象，就可以直接调用这些方法了。

定义只包含方法的类

# 语法格式：
class 类名 :
    
    def 方法1(self, 参数列表):
        pass
    def 方法2(self, 参数列表):
        pass

• 方法的定一个是和之前的函数一致
• 区别再有第一个参数必须是self。

注意：类名的命名规则要符合大驼峰名法

创建对象

• 当一个类定义完成之后，要使用这个类来创建对象

# 语法格式如下
对象变量 = 类名()

# 面向对象案例1

class Cat():
    
    def eat(self):
        print("小猫爱吃鱼")
    
    def drink(self):
        print("小猫爱喝水")
        
        
# 创建猫对象
tom = Cat()

tom.eat()
tom.drink()

# 使用print可以输出一个变量是由哪个类创建的，并且输出变量的内存地址
print(tom)

addr = id(tom)
print("%x" %addr)
print("{}".format(addr))
print("%d" %addr)

小猫爱吃鱼
小猫爱喝水
<main.Cat object at 0x03309CD0>
3309cd0
53517520
53517520

# 面向对象案例2

class Cat():
    
    def eat(self):
        print("小猫爱吃鱼")
    
    def drink(self):
        print("小猫爱喝水")
        
        
# 创建猫对象
tom = Cat()

tom.eat()
tom.drink()
print(tom)

#在创建一个猫对象
lazy_cat = Cat()

lazy_cat.eat()
lazy_cat.drink()
print(lazy_cat)

lazy_cat2 = lazy_cat
print(lazy_cat2)

小猫爱吃鱼
小猫爱喝水
<main.Cat object at 0x03309DF0>
小猫爱吃鱼
小猫爱喝水
<main.Cat object at 0x03309C70>
<main.Cat object at 0x03309C70>

self

• 由哪一个对象调用的方法，方法内的self就是哪一个对象的引用
• 在类封装的方法内部，self就表示当前调用方法的对象自己
• 调用方法时，程序员不需要传递self参数
• 在方法内部：
  • 可以通过self访问对象的属性
  • 也可以通过self. 调用其他对象方法

# 给类中增加属性
# 面向对象案例

class Cat():
    
    def eat(self):
        # 哪一个对象调用了方法，self就是哪个对象的引用。
        print("%s爱吃鱼" %self.name)
    
    def drink(self):
        print("%s爱喝水" %self.name)
        
        
# 创建猫对象
tom = Cat()

# 使用 . 属性名  利用赋值语句就可以了
# 此种增加属性的方法，只能在对象中增加不能再类中增加
tom.name = "Tom"

tom.eat()
tom.drink()
print(tom)

#在创建一个猫对象
lazy_cat = Cat()

lazy_cat.name = "大懒猫"

lazy_cat.eat()
lazy_cat.drink()
print(lazy_cat)

Tom爱吃鱼
Tom爱喝水
<main.Cat object at 0x0354F2B0>
大懒猫爱吃鱼
大懒猫爱喝水
<main.Cat object at 0x0354F3D0>

初始化方法

之前代码存在的问题——在类的外部给对象增加属性

提示：

• 在开发中，不推荐在类的外部给对象增加属性
  • 如果在运行时，没有找到属性，程序会报错。
• 对象应该包含有哪些属性，应该封装在类的内部

# 给类中增加属性
# 面向对象案例

class Cat():
    
    def eat(self):
        # 哪一个对象调用了方法，self就是哪个对象的引用。
        print("%s爱吃鱼" %self.name)
    
    def drink(self):
        print("%s爱喝水" %self.name)
        
        
# 创建猫对象
tom = Cat()

# 使用 . 属性名  利用赋值语句就可以了
# 此种增加属性的方法，只能在对象中增加不能再类中增加
# tom.name = "Tom"
# 给类中增加属性
# 面向对象案例

class Cat():
    
    def eat(self):
        # 哪一个对象调用了方法，self就是哪个对象的引用。
        print("%s爱吃鱼" %self.name)
    
    def drink(self):
        print("%s爱喝水" %self.name)
        
        
# 创建猫对象
tom = Cat()

# 使用 . 属性名  利用赋值语句就可以了
# 此种增加属性的方法，只能在对象中增加不能再类中增加
# tom.name = "Tom"
# 给类中增加属性
# 面向对象案例
​
class Cat():
    
    def eat(self):
        # 哪一个对象调用了方法，self就是哪个对象的引用。
        print("%s爱吃鱼" %self.name)
    
    def drink(self):
        print("%s爱喝水" %self.name)
        
        
# 创建猫对象
tom = Cat()
​
# 使用 . 属性名  利用赋值语句就可以了
# 此种增加属性的方法，只能在对象中增加不能再类中增加
# tom.name = "Tom"
​
tom.eat()
tom.drink()
tom.name = "Tom"
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-35-122a5e00f45e> in <module>()
     19 # tom.name = "Tom"
     20 
---> 21 tom.eat()
     22 tom.drink()
     23 tom.name = "Tom"

<ipython-input-35-122a5e00f45e> in eat(self)
      6     def eat(self):
      7         # 哪一个对象调用了方法，self就是哪个对象的引用。
----> 8         print("%s爱吃鱼" %self.name)
      9 
     10     def drink(self):

AttributeError: 'Cat' object has no attribute 'name'

初始化方法

• 当时用 类名（），创建对象时，会自动执行以下操作：
  • 为对象在内存中分配空间——创建对象
  • 为对象的属性设置初始值——初始化方法（init）
• 这个初始化方法就是 init 方法，__init__是对象的内置方法。

init 方法是专门用来定义一个类具有哪些属性的方法！

#案例

class Cat():
    
    def __init__(self):
        
        print("这是一个初始化方法")

# 使用类名（）创建对象的时候，会自动调用初始化方法
tom = Cat()

这是一个初始化方法

在初始化方法内部定义属性

• 在__init__方法内部使用self.属性名 = 属性的初始值，就可以定义属性
• 定义属性之后，再使用Cat类创建的对象，都会拥有该属性

#案例

class Cat():
    
    def __init__(self):
        
        print("这是一个初始化方法")
        
        #self.属性名 = 属性的初始值
        self.name = "Tom"
        
    def eat(self):
        print("%s爱吃鱼" %self.name)
# 使用类名（）创建对象的时候，会自动调用初始化方法
tom = Cat()

tom.eat()
print(tom.name)

这是一个初始化方法
Tom爱吃鱼
Tom

改造初始化方法——初始化的同时设置初始值

• 开发中，希望创建对象的同时，就设置对象的属性，可以对__init__进行改造
  • 把希望设置的属性值，定义成__init__方法的参数
  • 在方法内部使用self.属性 = 形参 接收外部传递的参数
  • 在创建对象时，使用 类名（属性1,属性2…）调用

#案例

class Cat:
    
    def __init__(self, new_name):
        
        print("这是一个初始化方法")
        
        #self.属性名 = 属性的初始值
        # self.name = "Tom"
        self.name = new_name
        
    def eat(self):
        print("%s爱吃鱼" %self.name)
# 使用类名（）创建对象的时候，会自动调用初始化方法
tom = Cat("Tom")

tom.eat()
print(tom.name)

lazy_cat = Cat("大懒猫")
lazy_cat.eat()

这是一个初始化方法
Tom爱吃鱼
Tom
这是一个初始化方法
大懒猫爱吃鱼

内置方法

__del__方法

• 当时用 类名（） 创建对象时，为对象分配完空间后，自动调用 init 方法
• 当一个对象被从内存中销毁前，会自动调用 __del__方法

应用场景

• __init__改造初始化方法，可以使让创建对象更加灵活
• __del__希望对象被销毁前，再做一些事情，可以考虑使用__del__方法

生命周期

• 一个对象从调用类名()创建，生命周期开始
• 一个对象的__del__方法一旦被调用，生命周期结束
• 在对象的生命周期内，可以访问对象属性，或者让对象调用方法

#案例

class Cat:
    
    def __init__(self, new_name):
        
        self.name = new_name
        
        print("%s 来了" % self.name)
        
    def __del__(self):
        
        print("%s 我去了" % self.name)

        
# tom 是一个全局变量        
tom = Cat("Tom")
print(tom.name)

# del关键字可以删除一个对象
del tom
print("-" * 50)

__str__方法

• 在Python中，使用print输出对象变量，会输出这个变量的对象是由哪一个类创建的对象，以及在内存中的地址（十六进制表示）
• 如果在开发中，希望使用print输出对象变量时，能够打印自定义的内容，就可以利用__str__这个内置方法了

注意：__str__方法必须返回一个字符串

#案例
class Cat:
    def __init__(self, new_name):
        self.name = new_name
        print("%s来了" % self.name)
    def __del__(self):
        print("%s去了" % self.name)
    def __str__(self):
        return "我是小猫：%s" %self.name
    
tom = Cat("Tom")
print(tom)

Tom来了
我是小猫：Tom