面向对象典型的语言就是Java
一.基本概念
__init__（cls）:是对将来具体实例的初始化方法，一般是不需要写的，Python会自动执行 __new__(self): 对__init__生成并返回的具体对象进行初始化 ---- 术语：构造函数 __del__(self):Python解释器自动执行的，在程序执行完后，Python解释器会自动执行，回收，释放内存的时候才会调用;一般情况下也是不需要写的，Python会自动执行 ---术语：析构函数 __super__： @classmethod ---修饰器 @staticmethod --- 修饰器 在类外面定义的变量就叫变量；在类里面定义的变量就叫属性 在类外面定义的函数就叫函数；在类里面定义的函数就叫方法
二.类的定义和调用
1. 基础语法
class LeiMing(): def __init__(self, canshu): self.canshu = canshu def fangfa(self): pass # 对象的使用 # 1. 初始化对象 a = LeiMing(1) # 2. 调用类中的方法 a.fangfa()
示例1：人类
# 定义了一个类,类型，不区分具体的对象个体 class Person(): # 在类里可以定义变量 age = 10 # 初始化对象（初始化函数） def __init__(self,age = None): if age is not None: self.age = age # self代表的是将来具体的person1 、person2 这样一个个具体的个体对象 # 在类里也可以定义函数 def speak(self): print("Hello") # 类的使用，person1 和 person2 就是对象，是一个个具体的人，每个人（对象）都有自己特有的特征 person1 = Person() print(person1.age) # 10 person1.speak() # Hello person1.age = 20 # 修改了person1的age print(person1.age) # 20 person2 = Person(30) print(person2.age) # 30 print(Person.age) # 10
示例2：猫
class Cat(): def __init__(self,age = 0, sex = "male"): self.age = age self.sex = sex def sleep(self): pass def eat(self): pass big_cat = Cat(6, 'male') er_cat = Cat(7, 'female') san_cat = Cat(7) print(big_cat.age, big_cat.sex) # 6 male print(er_cat.age,er_cat.sex) # 7 female print(san_cat.age,san_cat.sex) # 7 male
2.变量和类的属性
在类外面定义的变量就叫变量；在类里面定义的变量就叫属性
变量的查找顺序：变量-->类->基类
class Cat(): def __init__(self,age = 0, sex = "male"): self.age = age self.sex = sex def sleep(self): pass def eat(self): pass big_cat = Cat(6, 'male') er_cat = Cat(7, 'female') san_cat = Cat(7) big_cat.color = 'white' print(big_cat.color) # white # 是从big_cat的变量里取的值 print(er_cat.color) # AttributeError: 'Cat' object has no attribute 'color' # 因为er_cat没有定义它自己的变量color，类里也没有定义color，基类里也没有color，所以会报属性错误 # 变量的查找顺序：变量-->类->基类
class Cat(): color = 'BlACK' def __init__(self,age = 0, sex = "male"): self.age = age self.sex = sex def sleep(self): pass def eat(self): pass big_cat = Cat(6, 'male') er_cat = Cat(7, 'female') san_cat = Cat(7) big_cat.color = 'white' print(big_cat.color) # white # 是从big_cat的变量里取的值 print(er_cat.color) # BlACK # er_cat没有定义自己的color，就从类里找属性，找到了BLACK
3. 类的方法
在类外面定义的函数就叫函数；在类里面定义的函数就叫方法
函数和方法的使用没有任何区别，只是方法的第一个参数是self
class Cat(): # 类的属性， color， self.age 都是类里的变量，但是术语叫做属性 color = 'BlACK' def __init__(self,name,age = 0, sex = "male"): self.age = age self.sex = sex self.name = name # 类的方法 def sleep(self): print("{} sleep".format(self.name)) # self.name:就是将来那个对象个体的名字，比如可以是damao,ermao,sanmao的名字 def eat(self): print("{} eat".format(self.name)) big_cat = Cat('damao',6, 'male') er_cat = Cat('ermao',7, 'female') san_cat = Cat('sanmao',7) # 类方法的调用 big_cat.sleep() # damao sleep er_cat.eat() # ermao eat
三.面向对象中的内置方法
1. 构造方法 与 析构方法
class Dog(object): # __init__的作用：是给具体对象dog进行初始化的 def __init__(self): # self代表的是将来的具体的对象个体 print("__init__") # __new__方法的作用：就是用类型（Dog）生成具体对象（dog）的，通常是不需要写的
# 构造方法
def __new__(cls): # cls代表的是当前的这个类，这里就是Dog这个类 print("__new__") # 作用：回收 # 是Python解释器自己调用执行的
# 析构方法
def __del__(self): print("__del__") def speak(self): print("我啥都不想说") dog = Dog() dog.speak() # 报错 ''' AttributeError: 'NoneType' object has no attribute 'speak' 在上面的Person和Cat类里，没有__new__方法，就可以正常执行，而这里有 __new__ 方法，就报错了，为什么？ '''
class Dog(object): # __init__的作用：是给具体对象dog进行初始化的 def __init__(self): # self代表的是将来的具体的对象个体 print("__init__") # __new__方法的作用：就是用类型（Dog）生成具体对象（dog）的，通常是不需要写的 def __new__(cls): # cls代表的是当前的这个类，这里就是Dog这个类 print("__new__") return object.__new__(cls) # 这里是通用写法，而且写了一定要返回 # 作用：回收 # 是Python解释器自己调用执行的，一般也是不需要写的 def __del__(self): print("__del__") def speak(self): print("我啥都不想说") dog = Dog() dog.speak() # 输出 __new__ __init__ 我啥都不想说 __del__ ''' 看上面输出的代码的执行顺序 1. 先执行__new__ 2. 再执行__init__ 3. 接着执行函数方法 4. 等所有逻辑执行完成后，最后执行__del__，回收，释放内存 '''
四. 继承与super函数
class Fish(object): # Fish继承了Python的基类 def __init__(self,name): self.name = name def bubble(self): print("我叫{}： 我吐一串泡泡".format(self.name)) def swam(self): print("我是{}我游得很快".format(self.name)) # 定义一个多宝鱼，继承鱼类 class Turbot(Fish): def __init__(self,name): super(Turbot,self).__init__(name) # 固定写法： # 1. super()函数的第一个参数是类型（类名），第二个参数是对象 # 2 super()函数写在哪个类里面，第一个参数就是哪个类的类名，第二个参数是对象，对象是self； # 3. super()后面调用的是父类的方法，此处是父类（Fish类）的初始化方法__init__(name) # super()函数的本质：是调用它继承的那个类（即父类）里的方法或者属性 # super()函数的作用：可以一次性调用所有父类 def run(self): # 多宝鱼没有跑方法，但是可以通过super调用父类的swam方法，那多宝鱼也有了游的方法 super(Turbot,self).swam() fish = Turbot("多宝鱼") fish.swam() fish.bubble() fish.run()
五. 类的修饰器 @classmethod 和 @staticmethod
class Fish(object): # Fish继承了Python的基类 def __init__(self,name): self.name = name def bubble(self): print("我叫{}： 我吐一串泡泡".format(self.name)) def swam(self): print("我是{}我游得很快".format(self.name)) # 定义一个多宝鱼，继承鱼类 class Turbot(Fish): def __init__(self,name): super(Turbot,self).__init__(name) # 固定写法： # 1. super()函数的第一个参数是类型（类名），第二个参数是对象 # 2 super()函数写在哪个类里面，第一个参数就是哪个类的类名，第二个参数是对象，对象是self； # 3. super()后面调用的是父类的方法，此处是父类（Fish类）的初始化方法__init__(name) # super()函数的本质：是调用它继承的那个类（即父类）里的方法或者属性 # super()函数的作用：可以一次性调用所有父类 # 类方法里面的self参数代表具体对象本身 def run(self): # 多宝鱼没有跑方法，但是可以通过super调用父类的swam方法，那多宝鱼也有了游的方法 super(Turbot,self).swam() # 类方法里面的cls参数，代表的是类(这里是Trubot这个类)本身 # 想代表类本身的时候，它就是个类方法，类方法可以用@classmethod去修饰，而用@classmethod修饰的类方法，可以直接用 # 类名.方法名调用 或者 对象.方法名 @classmethod def balabala(cls): print("balabala") # 静态方法：可以认为与外面的函数是等价的，是一个普通函数，因为完全不需要用self或者cls去修饰 # 静态方法：可以在任何时候调用 # 调用方法：类名.方法名() # 用静态方法修饰后，可以理解为既不属于这个类，也不属于self那个对象，只是把这个方法写在了类里面而已 # 静态方法是独立于各种类以外的 @staticmethod def kalakala(): # 静态方法，可以没有cls参数 print("kalakala") fish = Turbot("多宝鱼") Turbot.balabala() # 类可以直接调用被@classmethod修饰过的类方法 Turbot.kalakala() # 类可以直接调用被@staticmethod修改过的方法 fish.balabala() # 对象可以调用被@classmethod修饰过的类方法 fish.kalakala() # 对象可以调用被@staticmethod修改过的方法
练习：实现水果类，并通过继承方法实现苹果，梨，香蕉和西瓜类
class Fruit(object): def __init__(self,name,price): self.name = name self.price = price class Apple(Fruit): def __init__(self,name,price): super(Apple,self).__init__(name,price) class Peer(Fruit): def __init__(self,name,price): super(Peer,self).__init__(name,price) class Banana(Fruit): def __init__(self,name,price): super(Banana, self).__init__(name,price) class Watermelon(Fruit): def __init__(self,name,price): super(Watermelon, self).__init__(name,price)
六. 总结
一. 类中__new__() 和 __init__()的区别是什么？
1.__new__()方法是把类型创建为具体的对象；__init__()是给具体的对象进行初始化的
2. __init__（）要想初始化具体的对象，必须通过__new__先创建一个对象，并且要在__new__返回这个对象后，__init__（）才能知道该去初始化谁。
通过new生成对象，然后要返回对象，这是通用写法；
object也是类，object是Python的最根本的类型，生成一个新的对象都是根据object来生成 的；
所以上面示例中dog这个具体的对象是__new__生成的，而不是__init__生成的；
通常情况下,__new__是不需要写的，Python会自动给每个来加一个__new__方法；
3. 执行顺序一定是先执行__new__，后执行__init__