Python学习笔记Day06~07 - 类

目录

• • • 类
• 普通类的创建方法
• class Foo(object):
• def init(self, name):
• self.name = name
• null
• null
• f = Foo("alex")
• print(type(f))
• print(type(Foo))
• 类的特殊创建方法
  • • 1.构造函数：在实例化时做一些类的初始化工作
    • 2.析构函数：在实例释放、销毁的时候自动执行的，通常用于做一些收尾工作，
    • 3.实例变量与类变量，类变量是大家共用的属性，能节省内存开销
    • 4.静态属性与动态属性，分别表示变量和方法
    • 5.私有方法，私有属性，加__，在外部无法调用
    • 6.封装
    • 7.继承 作用就是减少代码量，子类可以重构父类的方法，可以继承多个父类
    • 8.多态 一种接口，多种形态
• def animal_talk(obj):
• obj.talk()
  • • 类方法、静态方法和属性方法
      • 9.静态方法@staticmethod：不能访问类变量和实例变量，就相当于一个普通函数，与类的其他属性无关
• http://www.cnblogs.com/alex3714/articles/5213184.html
• @classmethod # 类方法：只能访问类变量，不能访问实例变量
• @staticmethod # 静态方法：不能访问类变量和实例变量，就相当于一个普通函数，与类的其他属性无关
• @property # 属性方法：调用不需要加括号，也不能传参数
• 类的特殊成员方法
  • • • 10.类方法@classmethod：只能访问类变量，不能访问实例变量
      • 11.属性方法@property：把一个方法变成一个静态属性，调用不需要加括号，也不能传参数
    • 12.类的特殊成员用法：doc,module,class,dict,call,str,getitem,setitem,delitem
• hasattr(obj,name_str) , 判断一个对象obj里是否有对应的name_str字符串的方法
• getattr(obj,name_str), 根据字符串去获取obj对象里的对应的方法的内存地址
• setattr(obj,'y',z), is equivalent to ``obj.y = z''
• delattr(obj,z)
  • • 13.所有类的数据类型就是type，通过__metaclass__可自定义
• 第一阶段：解释器从上到下执行代码创建Foo类，执行MyType的__init__方法
• 第二阶段：通过Foo类创建obj对象 call,new,init

类

普通类的创建方法

class Foo(object):

def init(self, name):

self.name = name

f = Foo("alex")

print(type(f))

print(type(Foo))

类的特殊创建方法

def func(self):
print('hello %s' %self.name)
def init(self,name,age):
self.name = name
self.age = age

Foo = type('Foo', (object,), {'func': func,
'init':init}) # 所有类都是type的实例化
f = Foo("Chrn",22)
f.func()
print(type(Foo))

1.构造函数：在实例化时做一些类的初始化工作

2.析构函数：在实例释放、销毁的时候自动执行的，通常用于做一些收尾工作，

如关闭一些数据库连接，关闭打开的临时文件

3.实例变量与类变量，类变量是大家共用的属性，能节省内存开销

4.静态属性与动态属性，分别表示变量和方法

5.私有方法，私有属性，加__，在外部无法调用

6.封装

7.继承 作用就是减少代码量，子类可以重构父类的方法，可以继承多个父类

py2 经典类是按深度优先来继承的，新式类是按广度优先来继承的
py3 经典类和新式类都是统一按广度优先来继承的

8.多态 一种接口，多种形态

class Animal:
def init(self, name): # Constructor of the class
self.name = name

def talk(self): # Abstract method, defined by convention only
pass #raise NotImplementedError("Subclass must implement abstract method")

@staticmethod
def animal_talk(obj):
obj.talk()

class Cat(Animal):
def talk(self):
print('Meow!')

class Dog(Animal):
def talk(self):
print('Woof! Woof!')

d = Dog("陈荣华")
#d.talk()

c = Cat("徐良伟")
#c.talk()

def animal_talk(obj):

obj.talk()

Animal.animal_talk(c) # 通过一个接口，按不同的子类实现不同的效果
Animal.animal_talk(d)

类方法、静态方法和属性方法

9.静态方法@staticmethod：不能访问类变量和实例变量，就相当于一个普通函数，与类的其他属性无关

http://www.cnblogs.com/alex3714/articles/5213184.html

class Dog(object):
# metaclass = MyType #指定该类由谁实例化
# def new(cls, *args, **kwargs):
# 类的生成、调用、顺序依次是：new --> init --> call
n = 123 # 类变量，可被实例变量覆盖

def init(self, name):
self.name = name # 实例变量（静态属性），作用域是实例本身

@classmethod # 类方法：只能访问类变量，不能访问实例变量

@staticmethod # 静态方法：不能访问类变量和实例变量，就相当于一个普通函数，与类的其他属性无关

@property # 属性方法：调用不需要加括号，也不能传参数

def eat(self): #类的方法（动态属性）
print('%s is eatting...' % self.name)

def call(self, *args, **kwargs):
print('实例对象后面加括号触发') # 用d()调用

def str(self):
return "打印实例对象时输出返回的值" # 用d 调用

def getitem(self, item):
print('索引获取，如字典')
# 实例：key_value
# result = obj['k1'] # 自动触发执行 getitem
# obj['k2'] = 'alex' # 自动触发执行 setitem
# del obj['k1'] # 自动触发执行 setitem

def setitem(self, key, value):
print('索引设置')

def delitem(self, key):
print('索引删除')

d = Dog('金毛') #实例化

d.bullet_prove = True #添加实例变量
del d.name #删除实例的变量
d.n = '改变类变量' #相当于添加一个实例变量，原本的类变量并没有改变

类的特殊成员方法

d.doc #输出类的描述信息
d.module #输出类所属模块lib
d.class #输出类所属类
d.dict #查看实例中的所有变量
Dog.dict #查看类中的所有成员

10.类方法@classmethod：只能访问类变量，不能访问实例变量

11.属性方法@property：把一个方法变成一个静态属性，调用不需要加括号，也不能传参数

要给属性方法传参数只能使用.setter再写一个同名方法
接口，对用户来讲，只需要属性的结果，不需要知道其中的过程

class Flight(object):
def init(self,name):
self.flight_name = name

def checking_status(self):
print("checking flight %s status " % self.flight_name)
return 0

@property
def flight_status(self):
status = self.checking_status()
if status == 0 :
print("flight got canceled...")
elif status == 1 :
print("flight is arrived...")
elif status == 2:
print("flight has departured already...")
else:
print("cannot confirm the flight status...,please check later")
@flight_status.setter
def flight_status(self,status):
print("flight %s has changed status to %s" %(self.flight_name,status))
f = Flight("CA980")
f.flight_status
f.flight_status = 2

12.类的特殊成员用法：doc,module,class,dict,call,str,getitem,setitem,delitem

hasattr(obj,name_str) , 判断一个对象obj里是否有对应的name_str字符串的方法

getattr(obj,name_str), 根据字符串去获取obj对象里的对应的方法的内存地址

setattr(obj,'y',z), is equivalent to ``obj.y = z''

delattr(obj,z)

def bulk(self):
print("%s is yelling...." % self.name)

class Dog(object):
def init(self, name):
self.name = name

def eat(self, food):
print("%s is eating..." % self.name, food)

d = Dog("NiuHanYang")
choice = input(">>:").strip()

if hasattr(d, choice): # 判断实例是否有这个方法
getattr(d, choice) # 获得实例中的方法
else:
setattr(d, choice, bulk) # d.talk = bulk 为实例添加方法
func = getattr(d, choice)
func(d)

13.所有类的数据类型就是type，通过__metaclass__可自定义

类的创建过程

class MyType(type):
def init(self, what, bases=None, dict=None): # 创建类时执行的第一阶段
print("--MyType init---")
super(MyType, self).init(what, bases, dict)

def call(self, *args, **kwargs): # 创建实例时执行的第二阶段第一步
print("--MyType call---")
obj = self.new(self, *args, **kwargs)
obj.data = {"name":111}
self.init(obj, *args, **kwargs)

class Foo(object):
metaclass = MyType # 定制类的创建过程，默认type

def init(self, name): # 创建实例时执行的第二阶段第三步
self.name = name
print("Foo ---init__")

def new(cls, *args, **kwargs): # 类自带，用来创建实例，先于__init__执行，第二阶段第二步
print("Foo --new--")
#print(object.new(cls))
return object.new(cls) # 继承父类的__new__方法 #cls相当于类的self

第一阶段：解释器从上到下执行代码创建Foo类，执行MyType的__init__方法

第二阶段：通过Foo类创建obj对象 call,new,init

obj = Foo("Alex")
print(obj.name)