python中的class(类)

 

编码注释:
在源文件的第一行或第二行写入如下内容：
  # -*- coding:gbk -*-
  # 设置源文件编码格式为:gbk
或
  # -*- coding:utf-8 -*-
  # 设置源文件编码格式为:UTF-8

 

面向对象编程:
  什么是对象:
     一切皆对象(实例)

类型   对象(实例)
车   --> 车牌号(京P88888) 实例
画   --> 蒙娜丽莎(实例), ....

面向对象是指用类来描述一个对象(实例)，用类来建立实例与实例的关联关系
对象 : object
实例 : instance

类 : class

作用：
  用来描述对象
  用来创建对象

类的创建语法:
  class 类名(继承列表):
     "类文档字符串"
     实例方法(类内的函数methed)定义
     类变量定义
     类方法(@classmethod)定义
     静态方法(@staticmethod)定义

最简单类的定义的示例：
  # 定义一个类
  class Dog:
      pass
  # 创建一个Dog实例
  dog1 = Dog()
  dog2 = Dog()
  # 同list
  L = list()  # L是list类的一个对象(实例)
  L2 = list()
  L3 = list(range(10))

类的创建语法说明：
  类名必须是标识符
  类名实质上是变量，它绑定一个类
  类的定义的前后要加两个空行以告诉解释执行器，类的定义已经开始和结束

实例创建表达式:
  类名([创建传参列表])
作用：
  创建一个类的实例对象并返回此实例的引用关系

实例说明：
  实例有自己的作用域和名字空间,可以为该实例添加变量(实例变量/属性)
  实例可以调用类中的方法
  实例可以访问类中的类变量

实例变量:
  在python程序中，每个实例可以有自己的变量，每个实例变量有自己独立的作用域

实例变量的调用语法:
  实例.变量名

实例变量的赋值规则:
  首次为实例变量赋值则创建此实例变量
  再次为实例变量赋值则改变变量的绑定关系

示例见:

# dog.py


class Dog:
    """这是一个小狗的类

    此类用来创建小狗的实例
    """
    pass


dog1 = Dog()
dog1.kinds = "京巴"  # 为实例添加 kinds 属性
dog1.color = "白色"

dog2 = Dog()
dog2.kinds = "藏獒"
dog2.color = "棕色"

print("dog1的属性:", dog1.kinds, dog1.color)
print("dog2的属性:", dog2.kinds, dog2.color)

 

实例方法:
语法:
  class 类名(继承列表):
      def 实例方法名(self, 参数1, 参数2, ...):
          "实例方法的文档字符串"
          语句块

实例方法说明：
　　实例方法的实质就是函数，是定义在类内的函数
  实例方法属于类的属性
  实例方法的第一个参数代表调用这个方法的实例，一般命名为: "self"
  实例方法如果没有return 语句则返回None

调用语法:
  实例.实例方法名(调用参数)
  或
  类名.实例方法名(实例，　调用参数)

示例见:

  

# instance_method.py
class Dog:
    def say(self):
        """这是小狗的沟通方法"""
        print("旺!")
        print("self.kinds=", self.kinds)


dog1 = Dog()

dog1.kinds = "京巴"
# 调用方法1
dog1.say()

dog2 = Dog()
# 下一行出错，因为 第8行 self绑定的
# 对象没有kinds实例变量
dog2.say()

 

  和
  

# instance_method.py
class Dog:
    def say(self):
        """这是小狗的沟通方法"""
        print("旺!")

    def eat(self, that):
        "为狗进食，同时在狗的food属性里记住吃的是什么"
        print("小狗正在吃", that, "旺!...")
        self.food = that

    def food_info(self):
        "显示狗的进食信息"
        print("小狗刚吃过的是:", self.food)

dog1 = Dog()
# 调用方法1
dog1.say()
# 调用方法2
Dog.say(dog1)


dog2 = Dog()

dog1.eat("骨头")
dog2.eat("窝头")

# print("小狗1吃的是", dog1.food)
# print("小狗2吃的是", dog2.food)

dog1.food_info()
r = dog1.food_info()
print(r)

class MyList:
    def append(obj):
        # 把obj放在某个容器的尾部
        return None

 

 

构造方法(也叫初始化方法)
作用：
  创建对象，初始化实例变量

构造方法的语法格式:
  class 类名(继承列表):
      def __init__(self [, 参数列表]):
          语句块
  [] 代表可省略
说明：
  1. 构造 方法名必须是: __init__ 不可改变
  2. 在一个类内只能有一个__init__构造方法起作用
  3. 构造方法会在实例生成时自动调用,且将实例自身通过第一个参数self传入__init__方法
  4. 构造方法内如果需要return语句返回，则只能返回None

class Car:
    def __init__(self, c, b, m):
        "这是构造方法"
        print("__init__被调用!")
        self.color, self.brand, self.model = c, b, m

    def run(self, speed):
        print(self.color, "的", self.brand,
              self.model, "正在以", speed,
              "公里/小时的速度驶")

    def change_color(self, c):
        "此方法用来改变颜色"
        self.color = c  # 换色


a4 = Car("红色", "奥迪", "A4")

a4.run(199)
a4.change_color("黑色")  # 推荐
# a4.color = "银色"  # 不推荐
a4.run(233)

ts = Car("蓝色", "Tesla", "S")
ts.run(300)

 

 

析构方法：
语法格式 ：
  class 类名(继承列表):
      def __del__(self):
          语句块
说明：
  析构方法在对象被销毁时被自动调用
注：
  python语言建议不要在对象销毁时做任何事情，因为销毁的时间难以确定

预置实例属性:
  __dict__属性:
    通常每个对象(实例)都有一个__dict__属性
    __dict__属性绑定一个存储此实例自身变量的字典

例：
  class Dog:
       pass
  dog1 = Dog()
  print(dog1.__dict__)

__doc__属性:
  记录文件字符串, 用于help帮助
  此文件字符串与类的文档字符串相同

__class__属性
  用于绑定创建此实例的类对象(类实例)

作用：
  可以借助此属性来创建同类对象
  可以借助此属性来访问类对象(类实例)
示例：
  class Dog:
     pass
  dog1 = Dog()
  dog2 = dog1.__class__()  # 创建dog2

类变量
  1. 是指在类class 内定义的变量,此变量属于类，不属于此类的实例
  2. 类变量可以通过该类直接访问
  3. 类变量可以通过类的实例直接访问
  4. 类变量可以通过此类的对象的__class__属性间接访问

语法:
  class 类名(继承列表):
      变量名 = 表达式
      ....

示例：
  class Human:  # 人类
      home = "地球"  # 类变量

  print(Human.home)  #  home 属于  Human类变量

 

类的 __slots__ 列表属性
作用：
  限定一个类创建的实例只能有固定的实例属性
  不允许对象添加列表以外的实例属性(变量)
  防止用户因错写属性的名称而发生程序错误!

说明：
   __slots__属性是一个列表，列表的值是字符串
   含有__slots__ 属性的类所创建的实例对象没有
     __dict__属性,即此实例不用字典来存储属性

示例：
  class Student:
     # __slots__ = ["name", "age", "score"]
     def __init__(self, n, a, s):
         self.name = n
         self.age = a
         self.score = s
         self.scros = s  # 错，因为scros不在列表里

  s1 = Student("李四", 21, 100)
  s1.name = "张三"
  s1.abcd = 10000  # 出错

对象的属性管理函数
  1. getattr(obj, name[, default])  从一个对象得到对象的属性; getattr(x, 'y') 等同于x.y,当属性不存在时，如果给出default参数，则返回default,如果没有给出default则生一个AttributeError错误
  2. hasattr(obj, name) 用给定的name返回对象obj是否有此属性，此种做法可以避免在getattr(obj, name)时引发错误
  3. setattr(obj, name, value) 给对象obj的名为name的属性设置相应的值value; set(x, 'y', v)  等同于 x.y = v
  4. delattr(obj, name) 删除 对象的obj中的name属性, delattr(x, 'y') 等同于 del x.y

用于类的函数:
  isinstance(obj, 类或元组) 返回这个对象obj是否是某个(或某些)类的对象，如果是则返回True, 否则返回False
  type(obj)  返回对象的类型

类方法 @classmethod
    类方法是只能访问类变量的方法
    类方法需要使用@classmethod装饰器定义
    类方法的第一个参数是类实例, 约定写为 cls
说明：
  类实例的对象实例都可以调用类方法
  类方法不能访问实例变量

示例:
  class Human:
      home = "地球"

      @classmethod
      def set_home(cls, h):
          cls.home = h
          print("欢迎来到", cls.home)

静态方法 @staticmethod
  静态方法是普通的函数
  静态方法定义在类的内部，只能凭借该类的实例访问
  静态方法需要使用@staticmethod装饰器定义
  静态方法与普通函数定义相同，不需要传入self和cls参数

说明：
  类实例和对象实例都可以调用静态方法
  静态方法不能访问类变量和实例变量

示例:
  

# 静态方法示例
class A:
    @staticmethod
    def myadd(a, b):
        return a + b

print(A.myadd(100, 200))
a = A()
print(a.myadd(3, 4))

 

实例方法、类方法、静态方法、函数 总结
  不想访问类变量和实例变量，可以用静态方法
  只想访问类内变量，不想访问实例变量用类方法
  即想访问类变量，也想访问实例变量用实例方法
  函数与静态方法相同，只是静态方法的作用域定义在类内