一、本章的内容

• 1.1、dir 内置函数
• 1.2、定义简单的类，(只包含方法)
• 1.3、方法中的 self 参数
• 1.4、初始化方法
• 1.5、内置方法和属性

二、dir 内置函数

• 2.1、在python中对象几乎是无处不在的，我们之前学习的变量、数据、函数 都是对象

  • python 中可以使用以下两个方法验证：

    • 1、在 标识符/数据 后输入一个 .,然后按下 tab 键， ipython 会提示该对象能够调用的 方法列表
      

      ipython查看方法
      
      扩展：Mac电脑安装 ipython 的方法如下：

      • mac 自带Python ，可以通过pip 安装iphthon

        1、终端运行 sudo easy_install pip 安装pip
           sudo easy_install pip
        2、通过pip安装ipython
           sudo pip install ipython
        

      • 终端输入 python3可以进入 python3编辑的状态，退出的话直接：control + D

      • 进入 python3状态后，写一个变量，再利用变量.就可以打印变量可以调用的方法

    • 2、使用内置函数 dir 传入 标识符/数据，可以查看对象内的 所有属性以及方法
      

      内置函数 `dir` 查看对象的方法和属性

  • 提示： __方法名__ 格式的方法是 Python 提供的 *内置方法/属性

  序号	方法名	类型	作用
  1	__new__	方法	创建对象时，会被 自动 调用
  2	__init__	方法	对象初始化时，会被 自动调用
  3	__del__	方法	对象被从内存中销毁前，会被 自动 调用
  4	__str__	方法	返回对象的描述信息，print函数输出使用

三、定义简单的类，(只包含方法)

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

• 3.1、定义只包含方法的类，格式如下：

  class 类名：
  
        def 方法1(self，参数列表)：
             pass
        def 方法2(self，参数列表)：
             pass
  

  方法 的定义格式和之前学习过的函数几乎一样，区别是在于第一个参数必须是 self，后面再一起探讨

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

• 3.2、创建对象

  • 当一个类定义完成之后，要使用这个类来创建对象，语法格式如下：

    对象变量 = 类名()
    

• 3.3、写一个简单的面向对象的程序

  需求： 小孩(baby) 爱笑，小孩(baby) 爱玩，代码如下

  class Baby:
         """这是一个孩子对象"""
  
         def smile(self):
               print("小孩(baby) 爱笑")
         def play(self):
               print("小孩(baby) 爱玩")
  smallBaby = Baby()
  smallBaby.smile()
  smallBaby.play()
  

  • 3.4、引用概念的强调

    • 在 Python 中使用类 创建对象之后，tom 变量中 仍然记录的是 对象在内存中的地址
    • 也就是 tom 变量 引用 了 新建的猫对象
    • 使用 print 输出 对象变量，默认情况下，是能够输出这个变量 引用的对象 是 由哪一个类创建的对象，以及 在内存中的地址（十六进制表示）

    提示：在计算机中，通常使用 十六进制 表示 内存地址

    • 十进制 和 十六进制 都是用来表达数字的，只是表示的方式不一样
    • 十进制 和 十六进制 的数字之间可以来回转换
    • %d 可以以 10 进制 输出数字
    • %x 可以以 16 进制 输出数字

    lass Baby:
       """这是一个孩子对象"""
    smallBaby = Baby()
    print(smallBaby)
    打印结果如下：
    <__main__.Baby object at 0x1081dfac8>
    

    从上面的代码可以看出 smallBaby的对象的类是：Baby，object代表对象类型，0x1081dfac8代表其 16进制的内存地址

    • 提示：相同的类可以创建多个不同的对象

四、方法中的 self 参数

• 4.1、使用 self 在方法内部输出对象的属性

  由 哪一个对象 调用的方法，方法内的 self 就是 哪一个对象的引用

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

  • 调用方法时，程序员不需要传递 self 参数

  • 在方法内部

    • 可以通过 self. 访问对象的属性
    • 也可以通过 self. 调用其他的对象方法

  • 代码示例如下：(下面的smallBaby.name = "jack"不推荐使用，类的属性应该封装在类的内部才是合理的)

    class Baby:
         """这是一个孩子对象"""
         print("我的名字叫 %s"% self.name)
    smallBaby = Baby()
    smallBaby.name = "jack"
    打印结果是：
    我的名字叫 jack
    

    • 在 类的外部，通过 变量名. 访问对象的 属性和方法
    • 在 类封装的方法中，通过 self. 访问对象的 属性和方法

• 4.2、上面代码存在的问题 —— 在类的外部给对象增加属性
  我们调整下上面代码执行的顺序，下面的代码运行就会发生错误，因为在执行smallBaby.smile()的时候还没有 name 这个属性

  class Baby:
        """这是一个孩子对象"""
        
        def smile(self):
            print("我的名字叫 %s"% self.name)
  smallBaby = Baby()
  smallBaby.smile()
  smallBaby.name = "jack"
  打印结果如下：
  AttributeError: 'Baby' object has no attribute 'name'
  

五、初始化方法

• 5.1、当使用 类名() 创建对象时，会 自动 执行以下操作：

  • 为对象在内存中 分配空间 —— 创建对象
  • 为对象的属性 设置初始值 —— 初始化方法(init)

• 5.2、这个 初始化方法 就是 __init__ 方法，__init__ 是对象的内置方法

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

  在 Baby 中增加 __init__ 方法，验证该方法在创建对象时会被自动调用，如下代码

  class Baby:
  
       def __init__(self):
           print("初始化方法")
  smallBaby = Baby()
  打印结果如下：
  初始化方法
  

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

  • 在 __init__方法内部使用 self.属性名 = 属性的初始值 就可以 定义属性

  • 定义属性之后，再使用 Cat 类创建的对象，都会拥有该属性

    class Baby:
    
        def __init__(self):
             print("初始化方法")
             self.name = "Jack"
        def smile(self):
             print("我的名字叫 %s"% self.name)
       
    smallBaby = Baby()
    # 下面我们打印一下，刚创建的smallBaby的名字
    print("%s" % smallbaby.name )
    打印结果是：
    Jack
    

    上面的代码，smallBaby. smile ()不管什么时候执行都不会报name不存在的错误了，因为name在smallBaby = Baby()就被创建了

• 5.4、改造初始化方法 —— 初始化的同时设置初始值(初始值是传递进去的),这样相比5.3、name的值更加灵活

  • 把希望设置的属性值，定义成 __init__方法的参数

  • 在方法内部使用 self.属性 = 形参 接收外部传递的参数

  • 在创建对象时，使用 类名(属性1, 属性2...) 调用

    class Baby:
    
    def __init__(self,new_name):
    
            print("初始化方法")
            self.name = new_name
    
    smallBaby = Baby("Jack")
    print(smallBaby.name)
    

六、内置方法和属性

• 6.1、__del__ 方法

  • 在 Python 中
    • 当使用 类名() 创建对象时，为对象 分配完空间后，自动 调用 __init__ 方法
    • 当一个 对象被从内存中销毁 前，会 自动 调用 __del__ 方法
  • 应用场景
    • __init__ 改造初始化方法，可以让创建对象更加灵活
    • __del__ 如果希望在对象被销毁前，再做一些事情，可以考虑一下 __del__ 方法
  • 生命周期

    • 一个对象从调用 类名() 创建，生命周期开始

    • 一个对象的 del 方法一旦被调用，生命周期结束

    • 在对象的生命周期内，可以访问对象属性，或者让对象调用方法

      class Baby:
      
          def __init__(self,new_name):
                 print("初始化方法")
          del __del__(self):
                 print("对象销毁的方法")
      
      smallBaby = Baby("Jack")
      

• 6.2、__str__ 方法

  • 在 Python 中，使用 print 输出 对象变量，默认情况下，会输出这个变量 引用的对象 是 由哪一个类创建的对象，以及 在内存中的地址（十六进制表示）

  • 如果在开发中，希望使用 print 输出 对象变量 时，能够打印 自定义的内容，就可以利用 str 这个内置方法了

    class Baby:
    
         def __init__(self, new_name):
               print("初始化方f法")
    
         def __del__(self):
               print("对象销毁的方法")
    
         def __str__(self):
               return "打印对象变量"
    
    smallBaby = Baby("Jack")
    print(smallBaby)
    

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

    提示：如果上面的代码不写 __str__，就会打印如下的信息

    <__main__.Baby object at 0x103ee8358> 
    Baby:类名，object:对象类型，0x103ee8358:对象的内存空间地址