python面向对象
类class关键字
class 类名:
def 方法名(self,参数1，参数2，...):
passclass Cat:
def eat(self):
print("猫吃饭")
def drink(self):
print("猫喝水")对象
实例：通过类创建出来的对象叫做类的实例
实例化：创建对象的动作叫做实例化
class Cat:
def eat(self):
print("猫吃饭")
def drink(self):
print("猫喝水")
c = Cat() # 根据类创建对象c
c.eat()
c.drink()
self参数和属性
class Cat:
def set_name(self):
self.name = "tom"
def eat(self):
print("%s吃饭" % self.name)
def drink(self):
print("%s喝水" % self.name)
c = Cat() # 根据类创建对象c
c.set_name()
c.eat()
c.drink()
c.name = "张三"
c.eat()
c.drink()
init方法
class Cat:
def __init__(self):
print("cat被创建了")
c = Cat() # 实例化对象的时候，init方法会被自动调用
class Cat:
def __init__(self,name="tom"):
self.name = name
def eat(self):
print("%s吃饭" % self.name)
def drink(self):
print("%s喝水" % self.name)
c = Cat("jessica") # 根据类创建对象c
c.eat()
c.drink()为了避免实例化的时候必须提供实参，init的形参总是有缺省值
del方法
当对象在内存中销毁的时候，自动调用del方法
del方法只有一个参数self
不要理解成调用del是把对象从内存中删除了
对象即使没有del，同样会被销毁
当对象从内存中销毁的时候，有机会能执行一些代码
class Cat:
def __init__(self, name="tom"):
self.name = name
def show_name(self):
print(self.name)
def __del__(self):
print("%s销毁了" % self.name)
c = Cat()
c.show_name()
如果对象是局部的，那么函数执行完毕，自动调用del方法
如果对象是全局的，那么程序执行完毕，自动调用del方法
设计
class Dog:
def __init__(self, name, age):
self.name = name
self.age = age
def get_name(self):
return self.name
def set_name(self, name):
self.name = name
def get_age(self):
return self.age
def set_age(self, age):
self.age = age
def show_name(self):
print(self.name)
def show_age(self):
print(self.age)
d = Dog("汤姆", 18) # 实例化的时候设置属性的值
d.show_name() # 汤姆
d.set_name("加菲猫") # 实例化以后设置属性的值
d.show_name() # 加菲猫
str方法
class demo:
def __init__(self,name="demo"):
self.name=name
def __str__(self):
return self.name
d=demo()
print(d)继承
封装：将属性和方法封装到类内部，只能在内部使用，不能在类的外部使用
继承：实现代码的重用，相同的代码不需要重复编写
多态：不同对象调用父类相同的方法，产生不同的执行结果，增加灵活度
class Animal:
def sleep(self):
print("睡")
def eat(self):
print("吃")
class Dog(Animal):
def run(self):
print("跑")
d = Dog()
d.sleep()
d.eat()
d.run()
扩展父类方法（super()）
class Animal:
def sleep(self):
print("睡")
def eat(self):
print("吃")
class Dog(Animal):
def run(self):
print("跑")
def eat(self):
super().eat()
print("吃肉")
d = Dog()
d.sleep()
d.eat()
d.run()
封装
把属性和方法前面加上两个下划线__，这个属性和方法就成为了类的内部属性和方法
多态
类属性（定义在类里面，方法外面）
class dog:
name = "二哈"
def __init__(self):
pass
print(dog.name)
dog.name = "狼狗"
print(dog.name)
类方法
class dog:
name = "二哈"
@classmethod
def set_name(cls, name):
cls.name = name # 通过类方法的形参修改类属性name值
def __init__(self):
self.age=20 #类方法无法访问普通属性age
def demo(self):
print("普通方法")# 类方法无法访问普通方法demo
print(dog.name)
dog.name="比熊"
print(dog.name)
dog.set_name("涛涛")
print(dog.name)
普通方法使用类属性和类方法
class dog:
name = "小白"
@classmethod
def get_name(cls):
return cls.name
def demo(self):
dog.name = "小小白"
print(dog.get_name())
d = dog()
d.demo()
统计实例化的次数
class dog:
index = 0;
@classmethod
def count(cls):
return cls.index
def __init__(self):
dog.index += 1;
d1 = dog()
d2 = dog()
d3 = dog()
d4 = dog()
print(dog.count()) # 4
静态方法（跟类没有关系）
静态方法不能访问类中其他成员
class dog:
@staticmethod
def help():
print("帮助")
dog.help()