Python类的概念

类

类的技术名词解释

● 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
● 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
● 数据成员：类变量或者实例变量, 用于处理类及其实例对象的相关的数据。
● 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
● 局部变量：定义在方法中的变量，只作用于当前实例的类。
● 实例变量：在类的声明中，属性是用变量来表示的。这种变量就称为实例变量，是在类声明的内部但是在类的其他成员方法之外声明的。
● 继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
● 实例化：创建一个类的实例，类的具体对象。
● 方法：类中定义的函数。
● 对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

初识类

类有三大特性：继承、封装、多态
类是面向对象的编程思想，具体什么意思呢？举例来说，人有姓名、年龄、职业、工资等属性，以及人可以工作，健身，吃饭，睡觉等，我们可以把这些抽象出一个类，这个类下面有属性（姓名、年龄、职业、工资），有方法（工作，健身，吃饭，睡觉），我们所有人基本上都有这些属性，那么具体到某个人就是说是这个类的实例化对象。

创建一个类

class Person(object):
    # 类变量，类变量定义在类中且在函数体之外，可以直接用“类名.属性”调用
    sex = "男"

    def __init__(self, name, age):
        # _init__()方法称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法
        self.name = name
        self.age = age

    def work(self):
        print("人会工作")


print(Person.sex)
p = Person("张三", 12)
p.work()

1. init()方法称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法
2. sex变量属于类方法，可以直接被类名调用
3. p = Person(“张三”, 12)，这句属于实例化对象

类的属性

类属性

class Animal():
    url = "www.baidu.com"  # 类属性

实例属性

class Animal():
    url = "www.baidu.com"  # 类属性
    def __init__(self,age,name):  # 实例属性
        self.age = age
        self.name = name

私有属性

私有属性不能被子类调用，也不能被实例对象调用，两个下划线

__sex = "男"

类的方法

实例方法

不能用类名直接访问，可以被实例化对象访问

class Person(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def work(self):
        print("人会工作")

print(Person.work())  #会报错，不能直接调用，需要先实例化对象，再调用

私有方法

不能用类名直接访问，也不能被类的实例化对象访问，只能在类里面可以访问

    def __eat(self):
        print("真会吃")

静态方法

用 @staticmethod 装饰的不带 self 参数的方法叫做静态方法，类的静态方法可以没有参数，方法后面的括号不需要加self,可以直接用类名访问，也可以被类的实例化对象访问。

class Person(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age

    @staticmethod
    def staticFunction():
        print("静态方法")

print(Person.staticFunction())

类方法

默认有个 cls 参数，需要加上 @classmethod 装饰器。
可以用类名直接访问，也可以被实例化对象访问，类方法可以访问静态方法，类方法可以访问类属性，类方法不能调用调用其它类方法的实例方法

class Animal():
    sex = "男"
    @classmethod
    def eat(cls):
        print("这是一个类方法")
        cls.run()  # 类方法可以访问静态方法
        print(cls.sex)  # 类方法可以访问类属性
        cls.speak(cls)  #类方法不能调用调用其它类方法的实例方法
    @staticmethod
    def run():
        print("这是一个静态方法")

    def speak(self):  # 实例方法
        print("这是一个实例方法")
        self.__rich()  # 私有方法在类里面可以访问

    def __rich(self):
        print("这是一个私有方法")

类的继承

主要好处之一是代码的重用，实现这种重用的方法之一是通过继承机制。通过继承创建的新类称为子类或派生类，被继承的类称为基类、父类或超类
比如有个基类叫Animal，那么我们还需要造一个Person类以及Cat类，人和猫是不是都属于动物，那我们可以通过继承动物的方法，可以使用父类里面的方法和属性，可以少些很多方法，这就是代码的重用思想。

# 类的继承
# 父类也叫基类或超类
class Animal(object):
    def __init__(self,name,age):
        print("父类的初始化方法")
        self.name = name
        self.age = age

    def speak(self):
        print("%s会说"%self.name)

    def eat(self):
        print("%s会吃"%self.name)


class Person(Animal):
    # 子类里面__init__方法没有，使用的是父类里面的初始化方法
    def speak(self):
        print("%s 会说人话"%self.name)

class Cat(Animal):
    # 子类把父类里面的方法重写了，没有用super是不会走到父类里面的初始化方法
    def __init__(self,name,skill):
        self.name = name
        self.skill = skill

    def speak(self):
        print("%s 会喵喵叫"%self.name)

class Dog(Animal):
    # 子类重写父类的init方法，并且需要走到父类的init方法，需要用到super方法
    def __init__(self,name,age,skill):
        super(Dog,self).__init__(name,age)
        self.skill = skill

d = Dog("旺财",2,"会招财")
d.speak()
p = Person("李四",20)
p.speak()
c = Cat("小花猫","抓老鼠")
c.speak()

类的多态

其实多态也叫方法重写，比如有个基类叫Animal，里面有个方法叫speak，还有Person类以及Cat类继承Animal类，人和猫都会叫，但是人是啊啊啊的叫，猫是喵喵喵地叫，我们看看以下的例子：

class Animal(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def speak(self):
        print("会动")


class Person(Animal):
    def speak(self):
        print(self.name, "啊啊啊~")


class Cat(Animal):
    def speak(self):
        print(self.name, "喵喵喵~")


p = Person("小明",10)
p.speak()
c = Cat("花猫", 20)
c.speak()

Python内置类属性

__name__方法

类名
在当前文件执行代码，__name__的值为"main", 如果为了调试代码，可以在当前文件下面加判断，在里面写上调试代码，其它文件引用该文件的时候不会执行判断里面的代码

class Animal(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age

print(Animal.__name__)
print(__name__)
if __name__ == "__main__":
    print("此处写调试代码")

导入其它文件夹里面的类

比如我想从main.py文件里面导入test文件夹下面的animal.py里面的Animal类：
animal.py文件里面的代码：

class Animal(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age


print(__name__)

即使我们把实例化animal注释了，会执行animal.py里面的print(name)，结果是test.animal，打印的是文件夹下面的某个文件，所以我们定义类的文件如果本身执行或者调试的话，做个判断，加上以下这句话：

if __name__ == "__main__":
    启动本文件执行的代码，别的地方引用的时候不会执行