标签：log eth blog 信息 写法 子类 广度 __call__ 创建
1、面向对象
2、类，实例
把一个抽象的类的变成一个具体的对象的过程叫实例化，实例化时，python把实例本身传入类的函数中， 类中__init__函数时初始化函数(方法)，实例化时，__init__方法自动执行
类本身也是一个内存对象
class student(obect): school = "middle school" # 类变量，在类的内存中 def __init__(self,name,age,sex,major): #初始化 self.name = name # 成员属性或者成员变量，实例化后，在实例的内存空间中 self.age = age self.sex = sex self.major = major
def print_score(self,score): # 类的方法
self.core = score
print (self.core)
st1 = student("px",19,"男"，"计算机") st2 = student("pz",18,"女"，"英语")
print (student.school)
print (st1.school)
print (st2.school)
结果为：
middle school
middle school
middle school
实例可以访问类变量，如果实例有和类相同名的变量，实例访问该变量时，该变量的值为实例变量的值，如果实例没有该变量，则为类变量的值。实例变量不能被类访问调用。
类变量，类属性
成员变量，实例变量
3、类的三大特性：
封装：
封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，
对不可信的进行信息隐藏。
多态：
封装和继承都实现了代码重用
多态实现了接口重用，接口统一，
但python没有多态的语法，可以通过一些技巧实现多态的效果：
class Animal(object): def run(self): print ‘Animal is running...‘ class Dog(Animal): def run(self): print ‘Dog is running...‘ class Cat(Animal): def run(self): print ‘Cat is running...‘ def run_twice(animal): animal.run() animal.run()
这样调用run_twice函数时，只要传入的实例是Animal类或Animal子类，都会自动调用实际类型的run方
法
调用方只管调用，不管细节，而当我们新增一种Animal的子类时，只要确保run()方法编写正确，不用管
原来的代码是如何调用的。这就是著名的“开闭”原则：
对扩展开放：允许新增Animal子类；
对修改封闭：不需要修改依赖Animal类型的run_twice()等函数。
继承：
class SchoolMember(object): members = 0 #初始学校人数为0 def __init__(self,name,age): self.name = name self.age = age def tell(self): pass def enroll(self): ‘‘‘注册‘‘‘ SchoolMember.members +=1 print("\033[32;1mnew member [%s] is enrolled,now there are [%s] members.\033[0m " %(self.name,SchoolMember.members)) def __del__(self): ‘‘‘析构方法‘‘‘ print("\033[31;1mmember [%s] is dead!\033[0m" %self.name) class Teacher(SchoolMember): def __init__(self,name,age,course,salary): super(Teacher,self).__init__(name,age) self.course = course self.salary = salary self.enroll() def teaching(self): ‘‘‘讲课方法‘‘‘ print("Teacher [%s] is teaching [%s] for class [%s]" %(self.name,self.course,‘s12‘)) def tell(self): ‘‘‘自我介绍方法‘‘‘ msg = ‘‘‘Hi, my name is [%s], works for [%s] as a [%s] teacher !‘‘‘ %(self.name,‘Oldboy‘, self.course) print(msg) class Student(SchoolMember): def __init__(self, name,age,grade,sid): #重写父类的__init__方法 super(Student,self).__init__(name,age) # 同时也继承了父类的_init__方法 self.grade = grade self.sid = sid self.enroll() def tell(self): ‘‘‘自我介绍方法‘‘‘ msg = ‘‘‘Hi, my name is [%s], I‘m studying [%s] in [%s]!‘‘‘ %(self.name, self.grade,‘Oldboy‘) print(msg) if __name__ == ‘__main__‘: t1 = Teacher("Alex",22,‘Python‘,20000) t2 = Teacher("TengLan",29,‘Linux‘,3000) s1 = Student("Qinghua", 24,"Python S12",1483) s2 = Student("SanJiang", 26,"Python S12",1484) t1.teaching() t2.teaching() t1.tell()
python面向对象的高级语法：
在类中可以用装饰器：
1.在类的某个方法之前加了@classmethod后
该方法将会变成类方法，在该方法内部不能访问实例变量
2.在类的某个方法之前加了@staticmethod后
该方法将会变成类静态方法，在该方法内部不能访问实例和类变量
大多数情况没有用，可以使用该类型方法作为类的工具箱
3.在类的某个方法之前加了@property后
该方法将会变成类静态属性，实例只能通过访问属性(变量)的方式访问调用该方法
私有属性：隐藏变量，
不容许在类的外部访问属性（变量）,只容许在类内部访问
self.__name = name （加2个下划线就可以变成私有属性）
但是还是有方法可以在外部访问到私有变量的。
d = Animal("Sanjiang")
print (d._Animal__num)
类的特殊成员方法：
1、__doc__
表示类的描述信息
class Foo:
""" 描述类信息"""
def func(self):
pass
print Foo.__doc__
#输出：描述类信息
2、__module__ 和__class__
分别表示
表示当前操作的对象在哪个模块
表示当前操作的对象属于哪个类
from lib.aa import C
obj = C()
print obj.__module__ # 输出 lib.aa，即：输出模块
print obj.__class__ # 输出 lib.aa.C，即：输出类
3 __init__
构造方法，通过类创建对象时，自动触发执行。
4、__del__
对象在内存中销毁后，自动执行程序该方法
5 __call__
class role(object):
def __init__(self):
print (‘__init__‘)
def __call__(self):
print (‘__call__‘)
a = role()
a() # 执行__call__ 方法
6 __new__
是它调用执行__init__
7、__dict__
查看类或对象中的所有成员
8、__str__
class Foo: def __str__(self): return ‘pengxuan‘ obj = Foo() print obj # 输出：pengxuan
新式类与经典类：
1、区别一：写法不同
经典类就是老写法
比如以前类的定义类的写法是这样的
class person: def __init__(self,name): self.name = name
而新式类是这样写的
class person(object): def __init__(self,name): self.name = name
区别二：
多继承有区别
class A: def f1(self): print (‘a‘) class B(A): pass class C(A): def f1(self): print (‘C‘) class D(B,C): n = 3 obj = D() obj.f1()
这个例子中如果是广度优先，执行obj.f1()时，从父类查找是否有f1方法的顺序是B->C-A；如果是深度优
先，查找f1方法的顺序是B->A->C。最先在哪个类中找到f1方法，则继承那个类中的f1方法
在低于python3.0的版本
经典类是深度优先
新式类是广度优先
到python3.X版本
新式类和经典类都是广度优先
反射：
hasattr
getattr
setattr
delattr
import sys class WebServer(object): def __init__(self,host,port): # Constructor of the class self.host = host self.port = port def start(self): print("Server is starting...") def stop(self): print("Server is stopping...") def restart(self): self.stop() self.start() def test_run(self,name): print("running...",name,self.host) if __name__ == "__main__": server = WebServer(‘localhost‘,333) server2 = WebServer(‘localhost‘,333) #print(sys.argv[1]) if hasattr(server,sys.argv[1]): func = getattr(server,sys.argv[1]) #获取server.start 内存地址 func() #server.start() #setattr(server,‘run‘,test_run) #server.run(server,‘alex‘) delattr(WebServer,‘start‘) print(server.restart()) #server2.run(server,‘alex‘) ‘‘‘cmd_dic = { ‘start‘:server.start, ‘stop‘:server.stop, }‘‘‘ #if sys.argv[1] == ‘start‘: #if sys.argv[1] in cmd_dic: # cmd_dic[sys.argv[1]]()
标签：log eth blog 信息 写法 子类 广度 __call__ 创建
原文地址：http://www.cnblogs.com/pengxuann/p/6017954.html
