类的概念
类（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) 会报错
给对象增加类方法
扫描二维码关注公众号，回复：
6898677 查看本文章
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)