基础知识
编程：语法+数据结构+算法
编程范式： 面向过程，step by step top-down language 面向对象oop，世界万物，皆可分类，皆为对象
特性 class –实例化–> object 实例化：把类变成具体对象的过程
封装：数据隐藏 把一些功能的实现细节不对外暴露
继承：代码复用 组合 单继承 多继承 py2 - 经典类：深度优先来继承的 - 新式类：广度优先来继承的 class Foo(object) py3 - 经典类和新式类都是按照广度优先来继承的
多态：接口重用 一个接口，多种实现
类： 1. 属性： 1. 类变量 大家共用属性，节省内存开销 2. 实例变量(静态属性)：作用域是实例本身 3. 私有属性 __开头
2.方法（动态属性） 1. 构造函数：init 实例化时做类的初始化工作 2. 析构函数：del 释放，销毁对象时执行，通常用于收尾工作，如关闭数据库连接，关闭临时文件 3. 私有方法 __开头 4. 静态方法：staticmethod与类没什么关系，只是名义上数据 5. 类方法：classmethod 只能访问类变量，不能访问实例变量 6. 属性方法：property 把一个方法变成一个静态属性
编程原则： 1、不写重复代码 2、代码会经常变更，做到易读，易改
对象实例化： 数据拷贝 方法不拷贝 object.method 相当于 class.method(object)
类属性class Dog(object):
count = 0 # 类变量
lst = []
def __init__(self, name): # 构造函数
self.name = name # 实例变量
self.__age = 0 # 私有属性
def bark(self): # 方法
print("%s bark" % self.name)
def __del__(self): # 析构函数
print("%s del" % self.name)
# 实例化对象，并赋予实例变量，相当于局部变量
d1 = Dog("Tom")
d2 = Dog("Alex")
d3 = Dog("Jack")
# 调用对象方法
d1.bark() # Tom bark
d2.bark() # Alex bark
d3.bark() # Jack bark
# 修改类变量，相当于全局变量
d1.count = 12
d2.count = 12
d3.count = 12
print(Dog.count) #0 #类变量 没有被修改
print(d1.count) #12
print(d1.count) #12
print(d1.count) #12
d1.lst.append("d1")
d2.lst.append("d2")
d3.lst.append("d3")
# 类变量 列表被修改了
print(Dog.lst) # ['d1', 'd2', 'd3']
print(d1.lst) # ['d1', 'd2', 'd3']
print(d2.lst) # ['d1', 'd2', 'd3']
print(d3.lst) # ['d1', 'd2', 'd3']class Animal(object):
count = 1
def __init__(self, name):
self.name = name
self.__color = None
def talk(self):
pass
@staticmethod # 静态方法
def animal_talk(animal):
animal.talk()
@classmethod # 类方法
def animal_sleep(cls):
print(cls,cls.count)
@property # 属性方法
def color(self):
return self.__color
@color.setter # 设置
def color(self, color):
self.__color = color
@color.deleter # 删除
def color(self):
del self.__color
class Cat(Animal):
def talk(self):
print("%s talking" % self.name)
class Dog(Animal):
def talk(self):
print("%s talking" % self.name)
cat = Cat("mimi")
dog = Dog("jiji")
Animal.animal_talk(cat)
Animal.animal_talk(dog)
Animal.animal_sleep()
print(dog.color)
dog.color = "red"
print(dog.color)
del dog.color
# class People: #经典类
class People(object): # 新式类
def __init__(self, name, age):
self.name = name
self.age = age
def sleep(self):
print("%s is sleeping" % self.name)
class Animal(object):
def drink(self):
print("%s drinking" % self.name)
class Man(People, Animal): # 多继承
def __init__(self, name, age, money):
People.__init__(self, name, age)
# 等价于：super(Man, self).__init__(name, age) 新式类写法
self.money = money
print("%s have money %s" % (name, money))
def work(self):
print("%s is working" % self.name)
def sleep(self): # 重载父类方法
People.sleep(self) # 调用父类方法
print("Man is sleeping")
class Woman(People):
def eat(self):
print("%s is eating" % self.name)
m = Man("Tom", 23, 2000)
w = Woman("Jack", 24)
m.sleep() # Tom is sleeping
m.work() # Tom is working
w.sleep() # Jack is sleeping
w.eat() # Jack is eating
m.drink() # Tom drinking
class A(object):
pass
# def __init__(self):
# print("init A")
class B(object):
def __init__(self):
print("init B")
class C(A):
pass
# def __init__(self):
# print("init C")
class D(B):
pass
# def __init__(self):
# print("init D")
class E(C, D):
pass
# def __init__(self):
# print("init E")
e = E()
# C -> A -> D -> B
class Dog(object):
"""类的描述信息"""
def __init__(self,name):
self.name = name
self.data = {}
def __call__(self):
print("call")
def __str__(self): #打印时触发
return self.name
def __getitem__(self, item): # 像字典一样访问对象
print("getitem")
return self.data.get(item)
def __setitem__(self, key, value): # 设置值
print("setitem")
self.data[key] = value
def __delitem__(self, key): # 删除值
print("delitem")
del self.data[key]
print(Dog.__doc__) # 输出类的描述信息
dog = Dog("Tom")
print(dog.__module__) # 输出模块 __main__
print(dog.__class__) # 输出类
dog() # 对象() 括号触发__call__ 方法
print(Dog.__dict__) #打印类所有属性，不包括实例属性
# {'__weakref__': ,
# '__dict__': ,
# '__init__': ,
# '__doc__': '类的描述信息',
# '__call__': ,
# '__module__': '__main__'}
print(dog.__dict__) # 打印实例所有属性，不包括类属性
# {'name': 'Tom'}
print(dog)
dog["dog1"] = "dogA"
dog["dog2"] = "dogB"
dog["dog3"] = "dogC"
print(dog["dog1"])
print(dog["dog2"])
print(dog["dog3"])
print(dog.data)
del dog["dog1"]
del dog["dog2"]
del dog["dog3"]
print(dog.data)
# python一切皆为对象，类类型也是对象 ，由type类实例化而来
# class Foo():
# def __init__(self, name, age):
# self.name = name
# self.age = age
#
# def talk(self):
# print("%s is talking" % self.name)
#
# f= Foo("Alex", 23)
# f.talk()
# 等价于：
def __init__(self, name, age):
self.name = name
self.age = age
def talk(self):
print("%s is talking" % self.name)
Foo = type("Foo", (object,), {"__init__": __init__, "talk": talk})
f= Foo("Alex", 23)
f.talk()
class Foo(object):
def __init__(self, name):
self.name = name
print("init")
def __new__(cls, *args, **kwargs):
print("new")
return object.__new__(cls) # 继承父类的 new 方法
f = Foo("Tom")
# new
# init
# 元类metaclass：就是类的类，所有类都源自type
print(f.__class__) #
print(Foo.__class__) #
a = 5
print(a.__class__) #
print(a.__class__.__class__) #
b = "name"
print(b.__class__) #
print(b.__class__.__class__) #
def foo(): pass
print(foo.__class__) #
print(foo.__class__.__class__) #
# 反射函数
"""
hasattr() 检查成员
getattr() 获取成员
setattr() 设置成员
delattr() 删除成员
"""
class Foo(object):
def __init__(self):
self.name = "Tom"
def eat(self):
print("eating")
def talk():
print("talking")
f= Foo()
choice = input("输入>>")
if hasattr(f, choice): # 判断对象是否有名称为choice 的属性
delattr(f, choice) # 删除对象属性
# func = getattr(f, choice) # 通过字符串获取对象函数地址
# func()
else:
setattr(f, "talk", talk) # 动态给对象增加新方法
f.talk()
setattr(f, "age", 23) #给对象增加静态属性
print(f.age)
print(f.name)参考文章：
- 全面深入理解 Python 面向对象
