类的概念

类（class）抽象的概念，比如说人类、鸟类、水果、是一个总的称呼，没有具体到某个物体；

对象（object，指具体实例，instance）；

类定义的语法：

class 类名：
　　执行语句
　　类变量
　　类方法

类最重要的两部分就是类变量和类方法，类成员之间的可以相互调用。

程序可以在类中给新变量赋值就是增加类变量，可以通过del语句删除已有类的变量。

在__init__构造函数（构造函数后面会说到）里面的是实例变量，程序可以任何位置（类里面或者类外面）增加实例变量，删除则用del语句。

在实例方法中有一个特别的方法 ：__init__ ，这个方法被称为构造方法 。 构造方法用于构造该类的对象， Python 通过调用构造方法返回该类的对象 。 python提供一个功能就是：若开发者没有定义构造函数，python会自动提供一个只包含self参数默认的构造方法。

class Bird:
    ‘这是学习python的第一个类‘
    eyes = "two"
    def __init__(self, color,feet):
        ‘为python对象增                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 ‘
        self.color = color
        self.feet = feet
    def call(self,cd):
        print("This bird:",cd)

上面的 Bird类定义了 一个构造方法，该构造方法只是方法名比较特殊：__init__ ，该方法的第一个参数同样是 self，被绑定到构造方法初始化的对象 。和函数定义文档类似，类文档用字符串即可。该文档同样被放在类声明之后、类体之前。

下面是调用类的构造方法创建对象。第二行是调用实例方法。

xique = Bird("green","two")
xique.call("gezhi")

#打印实例变量
print(xique.color,xique.feet)
#访问实例变量，对实例变量赋值
xique.color = "brown"
#增加实例变量
xique.skin = ‘yellow‘
#打印编辑后的实例变量
print(xique.color,xique.feet,xique.skin)
#调用实例方法call()，第一个参数仍是self,self代表实例本身，
#是自动绑定的，不需要再次输入，因此调用实例方法，只需再输入一个参数即可
xique.call("zhizhizhizhi")

同一个类的多个对象具有相同的特征，类用定义多个对象的相同特征。类不是一个具体的实体，对象才是一个具体的实体

class Person:
    ‘这是学习python的第二个类‘
    hair = ‘black‘
    def __init__(self,name = "Will",age = 8):
        ‘下面对Person对象增加两个实例变量‘
        self.name = name
        self.age = age
    ‘定义一个say()方法‘
    def say(self,content):
        print(content)

给对象增加一个实例变量

# 增加一个skills实例变量
p.skills = [‘programming‘,‘writing‘]
print(p.skills)
#删除p对象的name实例变量，而不是删除类中变量，新建一个对象，name实例变量还是构造函数默认的。
del p.name
# print(p.name) 会报错

给对象增加类方法

 1 #动态增加方法
 2 def info(self):
 3     print("-----info函数-----",self)
 4     print("动态增加方法")
 5     return None
 6 p.foo = info  # foo实例方法名，info是我们在外面定义的方法，当然二者名字可以相同
 7
 8 ‘‘‘方法增加，只用了变量名，后面并没有加括号方法动态增加，第一个参数并没有绑定给调
 9 用类的对象，所以我们需要手动把第一个参数输入，第一个参数是实例本身，可用实例名代表‘‘‘
10 print(p.foo(p))
11
12 #如果想自动绑定，调用方法时，不想输入self参数，可以用type模块包装
13 #重新写一个函数
14 def message(self,comment):
15     print("我的个人信息是 %s " % comment)
16     return None
17
18 p2 = Person()
19 p2.message = message
20
21 from types import MethodType
22 p2.message = MethodType(p2.message,per)
23
24 #综上，整队某个对象动态增加的类变量和类方法，只能应用此对象，其他对象需重新增加

实例方法调用另一个实例方法

 1 class Dog:
 2     skin = "white"
 3     def __init__(self,name = ‘Aled‘):
 4         self.name = name
 5     def jump(self):
 6         print("执行jump方法")
 7     def run(self):
 8         self.jump()  #此处不能写成jump()必须有self,通过调用实例对象的方法
 9         print("调用run方法")
10
11 g = Dog()
12 g.run() #通过run()方法，调用了jump()方法

类中self参数就是实例本身，可以自动绑定。

 1 #在构造方法中，self参数（第一个参数）表示该构造函数正在初始化的对象
 2 class InConstructor:
 3     def __init__(self):
 4         #在构造方法中定义一个foo变量（局部变量）,临时的
 5         foo = 1 #这是一个局部变量，不是实例变量，外界无法访问
 6         print(type(foo))
 7         print(foo)
 8         #把构造方法正在初始化的foo变量编程实例变量，并且重新复制
 9         self.foo = 5
10 p = InConstructor()
11 print(p.foo)
12
13 #自动绑定的self参数不依赖具体的调用方式，不管是以方法调用还是函数调用，self参数用一样可以自动绑定
14 class User:
15     def test(self):
16         print("self参数：",self)
17 u = User()
18 u.test() #self参数： <__main__.User object at 0x013ADCF0> User对象在内存...
19
20 #将User对象的test方法赋值给foo变量
21 foo = u.test #只需将名字赋值，不要加括号
22 #通过foo变量调用test()方法
23 foo() #效果 一样，因为foo也是指向u.test
24 #self参数可以作为实例方法返回值

self可以作为变量来访问，或者作为实例方法的返回值

当 self 参数作为对象的默认引用时，程序可以像访问普通变量一样来访 问这个self 参数，甚至可以把 self 参数当成实例方法的返回值 。 看下面程序 。

 1 class ReturnSelf:
 2     def grow(self):
 3         if hasattr(self,‘age‘):
 4             self.age += 1
 5             print("有age变量")
 6         else:
 7             self.age = 22
 8             print("无age变量")
 9         return self #返回调用该方法的实例对象
10     def isnotexist(self):
11         ‘实例变量不一定非要在构造方法中定义，也可以在类外，或者类里的实例方法中定义‘
12         print(self.age)
13
14 rs = ReturnSelf()
15 print(rs.grow().age) # 22
16 rs.isnotexist() #22
17 rs.grow().grow().isnotexist() #返回值是self实例本身，然后可以多次调用实例方法或变量

类也能调用实例方法

类名.method(参数)

类名.变量名

 1 #类调用实例方法 类名.method
 2
 3 #前面都是通过创建对象，通过对象调用实例方法
 4 #类很大程度上类似命名空间和定义变量和定义函数没有什么不同
 5
 6 #定义全局空间的foo函数
 7 def foo():
 8     print("全局空间的foo方法")
 9 #定义全局空间bar变量
10 bar = 20
11 class Bird:
12     #定义Bird空间的foo函数
13     def foo(self):
14         print("Bird空间的foo方法")
15     #定义Bird空间的bar变量
16     bar = 200
17 #调用全局空间的函数和变量
18 foo()
19 print(bar)
20 #调用Bird空间的函数和变量
21 # Bird.foo() 这样会报错。缺少self参数
22 print(Bird.bar)

直接类名+方法会报错，方法里面必须手动添加参数

1 class User:
2     def walk(self):
3         print(self,‘正在慢慢走‘)
4 #通过类调用实例方法
5 # User.walk() 这样报错 TypeError

u = User() 

User.walk(u)  #显式方法的第一个参数绑定参数值

这样的调用效果等同于u.walk()

实际上，当通过 User 类调用 walk()实例方法时， Python只要求手动为第一个参数绑定参数值，并不要求必须绑定 User 对象，因此也可使用如下代码进行调用 。

1 User.walk("任意输入都有可以，不一定非得是self参数")

如果传入两个参数呢

1 class Peaple:
2     def walk(self,name = "Will"):
3         print(name,"坐着",self)
4 #和普通函数调用没啥区别，就当self是一个变量名，参数随便输入
5 Peaple.walk("吃饭")
6 Peaple.walk("吃饭","Alex")

类方法和静态方法

Python其实可以支持类方法定义，区别前面的实例方法，同时只是静态方法定义，类方法和静态方法类似，都可以通过类调用（同时也支持对象调用）区别在于类方法第一个参数为cls，会自动绑定到类，而静态方法不会自动绑定到类

class Bird:
    #使用classmethod是类方法
    @classmethod
    def fly(cls):
        print(‘类方法fly:‘,cls)
    #使用staticmethod修饰的是静态方法
    @staticmethod
    def info(p):
        print(‘静态方法info:‘,p)
#调用类方法，类会自动绑定到第一个参数cls
Bird.fly()
#调用静态方法，不会自动绑定，意思是第一个参数必须手动输入
Bird.info("真麻烦")
#创建Bird对象
b = Bird()
#使用对象调用fly类方法，其实还是使用类调用
#因此第一个参数 依然自动绑定到Bird类
b.fly()
#使用对象调用info静态方法，其实还是使用类调用
b.info(‘fkit‘)

装饰器

 1 #装饰器
 2 #funA装饰funB，funB作为参数引入到funA中，同时funA返回值就是修饰后的返回值
 3 def funA(funB):
 4     print("A")
 5     funB()
 6     return "最终修饰结果"
 7 def funB():
 8     print("B")
 9 funB()
10
11 @funA
12 def funB():
13     print("B")
14 print(type(funB)) #这里是函数名，不是函数调用
15 print(funB) #装饰函数修饰后，通过被修饰函数名查看返回值

这个函数装饰器导致被修饰的函数变成了字符串，那么函数装饰器有什么用？别忘记了，被修饰的函数总是被替换成＠符号所引用的函数的返回值，因此被修饰的函数会变成什么，完全由于＠符号所引用的函数的返回值决定一一如果＠符号所引用的函数的返回值是函数，那么被修饰的函数在替换之后还是函数 。

 1 def foo(fn):
 2     #定义一个嵌套函数
 3     def bar(*args):
 4         print("===1===",args)
 5         n = args[0]
 6         print("===2===",n * (n -1))
 7         #查看传递给foo函数的fn函数
 8         print(fn.__name__)
 9         fn(n * (n -1))
10         print("*" * 15)
11         return fn(n * (n -1))
12     return bar
13
14 @foo
15 def my_test(a):
16     print("===my_test函数===",a)
17 print(my_test)  #返回值是bar函数<function foo.<locals>.bar at 0x032C3D20>
18 my_test(10)  #意思就是my_test函数被bar函数替换，调用my_test函数就是调用bar函数
19 my_test(6,5)

上面装饰结果相当于foo(my_test)，my_test函数会被替换（装饰）成foo（my_test）的返回值，他的返回值是bar函数，因此funB（my_test函数）就是bar函数

通过修饰函数，也可以在修饰函数中添加权限检查，逻辑验证，异常处理

下面将示范通过函数修饰器给函数添加权限检查的功能：

 1 def auth(fn):
 2     def auth_fn(*args):
 3         print("----模拟执行权限检查-----")
 4         #回调被修饰的目标函数
 5         fn(*args) #作为函数参数时前面必须有*，如果在函数里面的参数则为args
 6     return auth_fn
 7 @auth
 8 def bedecorated(a,b):
 9     print("执行bedecotated函数，参数a:%s,参数b:%s" % (a, b))
10
11 #调用bedecorated函数，其实就是调用修饰后返回的auth_fn函数
12
13 bedecorated(4,5)    

类命名空间

1 #类命名空间
2 global_fn = lambda p: print("执行lambda表达式，P参数：",p)
3 class Category:
4     cate_fn = lambda p:print("执行lambda表达式，p参数",p)
5 #调用全局的global_fn，为参数p传入参数值
6 global_fn(‘fkit‘)
7 c = Category()
8 c.cate_fn()

综上，在全局命名空间调用，类命名空间的lambda函数也可以调用，通过类对象调用lambda函数相当于调用类方法，python同样会自动为该刚方法绑定第一个参数值（self），也就是实例对象本身

成员变量

 1 class Address:
 2     detail = ‘广州‘
 3     post_code = ‘2019723‘
 4     def info(self):
 5         #尝试直接访问类变量
 6         #print(detail) 报错
 7         print(Address.detail)
 8         print(Address.post_code)
 9 Address.info(32) #通过类调用方法，需要手动输入第一个参数
10 #通过类来访问Address类的类变量
11 print(Address.detail)
12 addr = Address()
13 addr.info()
14 #修改Address的类变量
15 Address.detail = "佛山"
16 Address.post_code = ‘2018723‘
17 addr.info()

在类命名空间内定义的变量就属于类变量 ， Python 可以使用类来读取、修改类变量。 对于类变量而言，它们就是属于在类命名空间内定义的变量 ，因此程序不能直接访问这些变量，程序必须使用类名来调用类变量。不管是在全局范围内还是函数内访问这些类变量，都必须使用类名进行访问。

 1 #python也可以使用对象访问类变量，建议使用类访问类变量
 2 class Record:
 3     #定义两个类变量
 4     item = ‘鼠标‘
 5     date = ‘2019-07-23‘
 6     def info(self):
 7         print(‘info方法：‘,self.item)
 8         print(‘info方法：‘,self.date)
 9 rc = Record()
10 print(rc.item)
11 print(rc.date)
12 rc.info()
13
14 #修改Record类的两个类变量
15 Record.item = "键盘"
16 Record.date = ‘2020-01-01‘
17 rc.info()

Python 允许通过对象访问类变量 ，但如果程序通过对象尝试对类变量赋值，此时性质就变了一Python 是动态语言，赋值语句往往意味着定义新变量。因此，如果程序通过对象对类变量赋值，其实不是对“类变量赋值”，而是定义新的实例变量 。例如如下程序 。

 1 class Inventory:
 2     #定义两个变量
 3     quantity = 2000
 4     item = ‘鼠标‘
 5     #定义实例方法
 6     def change(self,item,quantity):
 7         self.item = item
 8         self.quantity = quantity
 9 #创建Inventory对象
10 iv = Inventory()
11 iv.change(‘显示器‘,500)
12 #访问iv的item和quantity实例变量
13 print(iv.item) #显示器
14 print(iv.quantity) #500
15
16 #访问Inventotry的item和quantity类变量
17 print(Inventory.item) #鼠标
18 print(Inventory.quantity) #2000

通过类修改类变量的值，实例变量不会受到影响

1 Inventory.item = ‘类变量item‘
2 Inventory.quantity = ‘类变量quantity‘
3 #访问iv对象的实例变量item和quantity
4 print(iv.item) #显示器
5 print(iv.quantity) #500

同样修改实例变量的值，这种修改也不影响类变量或者其他对象的实例变量。

1 iv.item = ‘iv实例变量item‘
2 iv.quantity = ‘iv实例变量quantity‘
3 print(Inventory.item)
4 print(Inventory.quantity)
5 iv2 = Inventory()
6 print(iv2.item) #类变量item,前面修改了类变量，此处没有调用change方法创建新的实例变量，所以这样调用的是类变量
7 #新对象创建实例变量item ,quantity
8 iv2.change(‘音响‘,600)
9 print(iv2.item) #音响，这次就不是类变量了，因为创建的实例变量，python内在机制，实例可以调用类变量，其实还是通过类访问的类变量

使用property函数定义属性

 1 class Retangle:
 2     def __init__(self,width,height):
 3         self.width = width
 4         self.height = height
 5     def setsize(self,size_):
 6         self.width,self.height = size_
 7     def getsize(self):
 8         return self.width,self.height
 9     def delsize(self):
10         self.width,self.height = 0,0
11     size = property(getsize,setsize,delsize,‘描述事物的属性‘)
12 #访问size的说明文档
13 print(Retangle.size.__doc__)
14 #通过内置的help函数查看说明文档
15 help(Retangle.size)
16 rect = Retangle(4,3)
17 print(rect.size)
18 rect.setsize((7,9))
19 print(rect.size)
20 rect.size = 9,7
21 print(rect.width,rect.height)
22 del rect.size
23 print(rect.width,rect.height)
24
25 class Retangle:
26     def __init__(self,width,height,length):
27         self.width = width
28         self.height = height
29         self.length = length
30     def getsize(self):
31         return self.width,self.height,self.length
32     def setsize(self,size):
33         self.width,self.height,self.length = size
34     def delsize(self):
35         self.width,self.height,self.length = 0,0,0
36     size = property(getsize,setsize,delsize,‘描述事物的属性‘)
37 rec = Retangle(88,56,72)
38 print(rec.size)
39 rec.size = 85,45,23
40 print(rec.size)
41 print(rec.width,rec.length,rec.height)
42 del rec.size
43 print(rec.size)
44
45
46 class User:
47     def __init__(self,first,last):
48         self.first = first
49         self.last = last
50     def getfullname(self):
51         return self.first + ‘,‘ + self.last
52     def setfullname(self,fullname):
53         name = fullname.split(‘,‘)
54         self.first = name[0]
55         self.last = name[1]
56     fullname = property(getfullname,setfullname)
57 u = User(‘孙‘,‘悟空‘)
58 print(u.fullname)
59 print(u.first,u.last)
60 u.fullname = ‘smith,jackey‘
61 print(u.fullname)
62 print(u.first,u.last)

隐藏和封装

 1 class User:
 2     def __hide(self):
 3         print("示范隐藏的方法")
 4     def getname(self):
 5         return self.__name
 6
 7     def setname(self,name):
 8         if len(name) < 3 or len(name) > 8:
 9             raise ValueError("输入长度在3-8之间的")
10         self.__name = name
11     name = property(getname,setname) #参数必须先
12
13     def getage(self):
14         return self.__age #可以和property的属性区分开来
15     def setage(self,age):
16         if age < 11 or age > 70:
17             raise ValueError("年龄在11到70岁之间")
18         self.__age = age
19     age = property(getage,setage)
20
21 u = User()
22 u.name = "fuck"
23 print(u.name)
24 print(u.getname())
25 u.age = 56
26 print(u.getage())

set和get函数方法顺序无关，但是property函数内参数，必须是先读取后写入的顺序。

继承

#继承
class Fruit:
    def info(self,weight): #如果后面有参数，函数内就必须初始化，如果没参数，后面初始化不同写
        self.weight = weight
        print("this fruit weigh %s" % (self.weight))
class Food:
    def taste(self):
        print("不同食物，口味不同")
class Apple(Fruit,Food):
    pass
a = Apple()
a.info(25)
a.taste()

 1 #当父类方法名字重合，选择第一个
 2 class Item:
 3     def info(self):
 4         print("这是一个商品")
 5 class Product:
 6     def info(self):
 7         print(‘这是一个工艺‘)
 8
 9 class Mouse(Product,Item): #父类顺序，如果有相同的方法，先调用一个参数
10     pass
11
12 m = Mouse()
13 m.info()

父类方法重写

 1 class Bird:
 2     def fly(self):
 3         print("我在天空里自由自在地飞翔")
 4 class Ostrich(Bird):
 5     #重写Bird类的fly()方法
 6     def fly(self):
 7         print("我只能在地上奔跑")
 8 #创建Ostrich对象
 9 os = Ostrich()
10 #执行Ostrich对象的fly(),将输出“我只能在地上奔跑”
11 os.fly()

子类重写父类方法，那如何调用父类被重写的方法。

 1 class BaseClass:
 2     def foo(self):
 3         print("父类中定义的foo方法")
 4 class SubClass(BaseClass):
 5     def foo(self):
 6         print("子类中定义的foo方法")
 7     def bar(self):
 8         print("执行bar方法")
 9         self.foo()
10         #通过类名调用父类被重写的方法
11         BaseClass.foo(self)
12 sc = SubClass()
13 sc.bar()

使用super函数调用父类构造方法

 1 class  Employee:
 2     def __init__(self,salary):
 3         self.salary = salary
 4     def work(self):
 5         print("普通员工正在写代码，工资是：",self.salary)
 6 class Customer:
 7     def __init__(self,favorite,address):
 8         self.favorite = favorite
 9         self.address = address
10     def info(self):
11         print("我是一个顾客，我的爱好是：%s,地址是%s" % (self.favorite,self.address))
12         #manager 继承了Employee,Customer
13 class Manager(Customer):
14     def __init__(self,favorite,address):
15         print("manager的构造方法")
16         #通过super函数调用父类的构造方法
17         super(Manager,self).__init__(favorite,address)
18
19
20
21 m = Manager("IT","beijing")
22
23 m.info()
24
25 class Fooparent:
26     def __init__(self):
27         self.parents = ‘I\‘m the parent‘ # 5
28         print("Parent11") # 1
29     def bar(self,message):
30         print("%s from Parent"% message) # 3
31 class FooChild(Fooparent):
32     def __init__(self):
33         super(FooChild,self).__init__()
34         print("child22") # 2
35     def bar(self,message):
36         super(FooChild,self).bar(message)
37         print("Child bar function") #4
38         print(self.parents)
39 if __name__ == "__main__":
40     foochild = FooChild() #创建一个子类对象
41     foochild.bar("helloworld")
42
43 #从上面可见先执行父类构造函数的打印函数，在执行子类打印函数，然后根据调用执行父类函数

python动态属性与slots

class Cat:
    def __init__(self,name):
        self.name = name

def walk_func(self):
    print("%s慢慢走过每一片草地"% self.name)
d1 = Cat(‘Marry‘)
d2 = Cat(‘Kitty‘)
Cat.walk = walk_func
d1.walk()
d2.walk()

#__slot__限制动态添加的属性和方法
class Dog:
    __slots__ = (‘walk‘,‘age‘,‘name‘)
    def __init__(self,name):
        self.name = name
    def test():
        print("预先定义好的test方法")
d = Dog(‘Snoogy‘)
d.age = 5
print(d.age)
# d.weight = 24报错
Dog.walk = walk_func
d.walk()
Dog.bar = lambda self:print("abc")
d.bar()

type函数定义类

def fn(self):
    print("fn函数")
#使用type函数定义Dog类
Dog = type(‘Dog‘,(object,),dict(walk = fn,age = 6))
#创建dog对象
d = Dog()
#分别查看d.dog的类型
print(type(d))
print(type(Dog))
print(type(Dog()))
print(type(d.walk))
d.walk()
print(d.age)

原文地址：https://www.cnblogs.com/chxb/p/11220366.html