类的定义
python类主要包含类变量、类方法、实例变量，定义格式如下：
class demo:  # 定义一个demo类
    name = 'default_name'  # name为类变量

    def print_name(self):  # 类方法
    print(self.name)

    def set_age(self, age):  # 类方法
        self.age = age  # age为实例变量

    def print_age(self):  # 类方法
        print(self.age)

类变量：在类中定义好的变量，例如上面的name

类方法：在类中定义的方法，例如上面的print_name()、set_age()、print_age()

实例变量：对实例对象的变量赋值就会创建一个新的实例变量，例如上面的age
注意示例代码中的self，类似于C++的类的this指针，类中的函数称为实例方法，所有实例方法的第一个参数都会被绑定到方法的调用者（该类的实例对象），因此所有实例方法第一个参数必须有self，当然，第一个参数不一定要是self，可以改成任何你想要的变量名，不过self是约定俗成的习惯。
self指向实例对象本身，如果不用self.name的形式，只会新建一个name变量。
构造方法

特殊的一种方法，类似于C++的构造函数，init（init前后分别两个下划线），用于初始化新创建的类实例。
私有变量和方法
私有变量（方法）只需要在类名（方法名）前面加上双下划线即可。但是，python中的私有变量并非一定不可在外部访问，只需要用对象名._类名私有变量名的形式访问即可。
class demo:  # 定义一个demo类
    __name = 'default_name'  # name为私有变量


temp = demo()
# print(temp.__name)  # 此处打印报错
print(temp._demo__name)  # 此处可以打印

参考资料

Python class定义类，Python类的定义（入门必读）
Python：为什么类中的私有属性可以在外部赋值并访问？

Python 类
类的定义
class ClassName():
	def __init__(self,parameter1,parameter2,[parameter...]):
		self.parameter1 = parameter1
		##省略##

类的继承
class Car():
	##省略##

class ElectricCar(Car):
	def __init__(self,parameter1,parameter2,[parameter...]):
		super().__init__(parameter1,parameter2,[parameter...])

重写父类的方法
在子类中把代码重写一遍就行
在一个模块中导入另一个模块

object类：所有Python类的基类

python类的实例方法、静态方法和类方法区别及其应用场景

一、先看语法，python 类语法中有三种方法，实例方法，静态方法，类方法。

 

ps.python中self，cls的区别

普通实例方法，第一个参数需要是self，它表示一个具体的实例本身。

如果用了staticmethod，那么就可以无视这个self，而将这个方法当成一个普通的函数使用。

而对于classmethod，它的第一个参数不是self，是cls，它表示这个类本身。

# coding:utf-8
class Foo(object):
    """类三种方法语法形式"""

    def instance_method(self):
        print("是类{}的实例方法，只能被实例对象调用".format(Foo))

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

    @classmethod
    def class_method(cls):
        print("是类方法")

foo = Foo()
foo.instance_method()
foo.static_method()
foo.class_method()
print('----------------')
Foo.static_method()
Foo.class_method()

运行结果如下

是类<class '__main__.Foo'>的实例方法，只能被实例对象调用
是静态方法
是类方法
----------------
是静态方法
是类方法

说明：

实例方法只能被实例对象调用，静态方法(由@staticmethod装饰的方法)、类方法(由@classmethod装饰的方法)，可以被类或类的实例对象调用。

实例方法，第一个参数必须要默认传实例对象，一般习惯用self。

静态方法，参数没有要求。

类方法，第一个参数必须要默认传类，一般习惯用cls。

二、静态方法、类方法使用区别或者说使用场景

 

1、类方法用在模拟java定义多个构造函数的情况。

 由于python类中只能有一个初始化方法，不能按照不同的情况初始化类。

参考django https://docs.djangoproject.com/en/1.9/ref/models/instances/ 请看下面的代码。

# coding:utf-8
class Book(object):

    def __init__(self, title):
        self.title = title

    @classmethod
    def class_method_create(cls, title):
        book = cls(title=title)
        return book

    @staticmethod
    def static_method_create(title):
        book= Book(title)
        return book

book1 = Book("use instance_method_create book instance")
book2 = Book.class_method_create("use class_method_create book instance")
book3 = Book.static_method_create("use static_method_create book instance")
print(book1.title)
print(book2.title)
print(book3.title)

结果：

use instance_method_create book instance
use class_method_create book instance
use static_method_create book instance

Process finished with exit code 0

特别说明，静态方法也可以实现上面功能，当静态方法每次都要写上类的名字，不方便。

2、类中静态方法方法调用静态方法和类方法调用静态方法例子。

下面的代码，静态方法调用另一个静态方法，如果改用类方法调用静态方法，可以让cls代替类，

让代码看起来精简一些。也防止类名修改了，不用在类定义中修改原来的类名。

# coding:utf-8
class Foo(object):
    X = 1
    Y = 2

    @staticmethod
    def averag(*mixes):
        return sum(mixes) / len(mixes)

    @staticmethod
    def static_method():  # 在静态方法中调用静态方法
        print "在静态方法中调用静态方法"
        return Foo.averag(Foo.X, Foo.Y)

    @classmethod
    def class_method(cls):  # 在类方法中使用静态方法
        print "在类方法中使用静态方法"
        return cls.averag(cls.X, cls.Y)

foo = Foo()
print(foo.static_method())
print(foo.class_method())

结果：


在静态方法中调用静态方法

1

在类方法中使用静态方法

1


3、继承类中的区别 

从下面代码可以看出，如果子类继承父类的方法，子类覆盖了父类的静态方法，

子类的实例继承了父类的static_method静态方法，调用该方法，还是调用的父类的方法和类属性。

子类的实例继承了父类的class_method类方法，调用该方法，调用的是子类的方法和子类的类属性。

# coding:utf-8
class Foo(object):
    X = 1
    Y = 14

    @staticmethod
    def averag(*mixes):  # "父类中的静态方法"
        return sum(mixes) / len(mixes)

    @staticmethod
    def static_method():  # "父类中的静态方法"
        print "父类中的静态方法"
        return Foo.averag(Foo.X, Foo.Y)

    @classmethod
    def class_method(cls):  # 父类中的类方法
        print "父类中的类方法"
        return cls.averag(cls.X, cls.Y)


class Son(Foo):
    X = 3
    Y = 5

    @staticmethod
    def averag(*mixes):  # "子类中重载了父类的静态方法"
        print "子类中重载了父类的静态方法"
        print "666 ",mixes
        return sum(mixes) / 3

p = Son()
print "result of p.averag(1,5)"
print (p.averag(1,5))
print "result of p.static_method()"
print(p.static_method())
print "result of p.class_method()"
print(p.class_method())

结果如下：


result of p.averag(1,5)

子类中重载了父类的静态方法

666  (1, 5)

2

result of p.static_method()

父类中的静态方法

7

result of p.class_method()

父类中的类方法

子类中重载了父类的静态方法

666  (3, 5)

2

Process finished with exit code 0


参考网址：https://zhuanlan.zhihu.com/p/21101992