#7 class,OOP, 类型判断

python中类的声明和js中基本相似，传统OOP的3大特征：封装，继承，多态，python也支持。

一.类的声明

看python类声明之前，先看看js中类的声明(ES6特性，js中的类的实质是函数),我们对比着看

# extends Object可以省略,则super()同时也省去
class Student extends Object {
  constructor(name, age) {
    super();
    this.name = name;
    this.age = age;
  }
  info() {
    console.log(`your name: ${this.name}, your age: ${this.age}`)
  }
}
# 使用
var james = new Student('James', 26)
james.info()
your name: James, your age: 26

在python中类的声明,同样使用关键词 class:

class Student(object):
  def __init__(self, name, age):
    self.name = name
    self.age = age
  def info(self):
    print('your name: %s, your age: %s' % (self.name, self.age))
# 使用
james = Student('James', 26)
james.info()
your name: James, your age: 26    

类比起来看，可以看出两者的语法基本类似，不同之处在于：

• python中的 __init__ 相当于js中的构造器函数constructor
• python中类的后面括号直接添加父类： Student(object), 默认父类是object，可以省略
• python中的关键词 self 相当于 this, 表示context; 但是python中的self需要显式的写出来，并且后面的函数也需要写出来，比如info(self)
• python中实例化一个对象不需要使用 'new' 关键词来调用构造器

二.类属性的声明规范

python的命名形式一般有以下几种方式：

• __xxx: 表示私有的，不能直接访问
• __xxx__: 特殊变量，可以直接访问，但是python很多内部属性以这种形式，命名的时候应避免冲突
• _xxx: 实例变量名，可以直接访问，但是约定俗成的这是私有的，不要随便访问
• xxx: 普通的命名，可以随意访问

__xxx

如果想要类的属性不被访问到，可以使用属性前面添加 __ 的方式,这样属性就变为了私有属性

class Student(object):
  def __init__(self, name, age):
    self.__name = name
    self.__age = age
  def info(self):
    print('your name: %s, your age: %s' % (self.__name, self.__age))

>>> s = Student('James', 28)
>>> s.__name
# 报错
AttributeError: 'Student' object has no attribute '__name'

这种方式看起来将属性隐藏了，其实python内部将属性名变为了 _className__propertyName 的形式，所以如果要获取上面的 __name 属性，可以这样做:

>>> s._Student__name
James
>>> s._Student__age
28

如果想要修改这些私有的属性，一般通过的是 set, get 方法(python需要自定义，所以名字可以随意)，在这2个方法中可以添加自己的一些逻辑：

class Student(object):
  ...
  def get_name(self):
    return self.__name
  def set_age(self, age):
    if self.__age < 0:
      print('age invalid')
      raise ValueError('age invalid')
    self.__age = age  

三.继承和多态

上面的一些函数对数据的处理，实际上就是封装的一种表现形式。下面来谈谈继承和多态。

继承

在最上面已经谈到了python继承的基本形式，继承是为了实现代码的重用和抽象的提取，下面来看个具体的示例

# 省份
class Province(object):
  def __init__(self, proname):
    self.proname = proname

  def proInfo(self):
    print('我来自 %s' % self.proname)

# 城市
class City(Province):
  def __init__(self, proname, cityname):
    # 调用父类的构造器
    # 等同于 self.proname = proname
    Province.__init__(self.proname) 
    self.cityname = cityname
  def cityInfo(self):
    print('我来自%s省 - %s市' % (self.proname, self.cityname))

>>> wuhan = City('湖北', '武汉')
# 调用父类的方法
>>> wuhan.proInfo()
我来自湖北

# 调用自身的方法
>>> wuhan.cityInfo()
我来自湖北省 - 武汉市

多态

多态的本质就是当一个函数能够传入父类对象，则也可以传入其子类对象，实现方法的重用

比如在上面继承的例子后面再定义一个函数：

def f(x):
  f.proInfo()

# 父类Province中有proInfo方法，此处传入一个Province的实例毫无问题
# 又因为City继承自Province对象，所以传入一个City的实例也是可以的
>>> p = Province('hubei')
>>> f(p)

>>> c = City('hubei', 'wuhan')
f(c)

四.静态属性

静态属性就是由类直接调用的属性，因为python的动态特性，使用时需要注意一些问题，下面会讲到

首先，声明静态属性的方式，直接将属性写在类中，这一点和js一致：

class Student(object):
  ...

  name = 'james' # 静态属性
  def sayHi():   # 静态方法，不使用self
    print('Hi')

# 使用
>>> Student.name
'james'  
>>> Student.sayHi()
'Hi'

但是对于实例来说，如果使用静态属性，实例会向上查找

>>> s = Student()
# 使用
>>> s.hello()
# 报错

>>> s.name
'james'

# 但是 如果尝试删除该属性会报错
# 这是因为name属性是属于类本身的
>>> del s.name

# 再比如可以给实例s也添加一个name的属性
>>> s.name = 'kobe'
>>> s.name
kobe
>>> Student.name
james

五.获取对象信息

主要使用以下几种方式来获取一个对象的信息:

• type(): 查看一个对象的类型
• is | not: 判断一个对象是不是什么
• isinstance(obj, DataType): 判断是不是某个对象的实例
• types: 对象属性(需要 import types)
• hasattr() | getattr() | setattr(): 获取对象的属性
• dir(DataType): 获取该类型的所有方法,例如获取所有字符串方法，dir('abc')

type()

直接返回是什么类型

>>> type('123') == str
True

>>> type(123)


>>> type(12) is int
True

isinstance

是不是某个类的实例

>>> isinstance('abc', str)
True

# 上面的Province 和 City
>>> isinstance(city, Province)
True
>>> isinstance(city, City)
True

types

一个对象具体是什么类型，可以使用 types 来判断

import types # 需要引入该模块

def f():
  pass

>>> type(f) == types.FunctionType
True

>>> type(lambda x: x) == types.LambdaType

>>> type(abs) == types.BuiltinFunctionType

>>> type((x for x in range(10))) == type.GeneratorType

这个 'types' 有很多中类型， types种类

另外判断一个对象是不是函数，还可以使用 callable 来判断

def fn():
  pass

>>> callable(fn)  
True

# 以前版本可以使用 'hasattr' 判断对象是否存在内部属性 '__call__'
>>> hasattr(fn, '__call__')
True

hasattr getattr setattr

分别相当于js中的'hasOwnProperty()', 'getOwnPropertyDescriptor()', 'defineProperty()' (类似)

示例：

class MyObject(object):
  def __init__(self):
    self.x = 9
  def power(self):
    return self.x * self.x

>>> obj = MyObject()

>>> hasattr(obj, 'x')    
True

>>> hasattr(obj, 'y')
False

>>> setattr(obj, 'y', 18)
>>> getattr(obj, 'y')
18

如果使用getattr尝试获取一个不存在的属性，会报错， 可以传入一个默认的返回值

>>> getattr(obj, 'z')
AttributeError: 'MyObject' object has no attribute 'z'

# 如果不存在返回一个默认值,避免报错
>>> getattr(obj, 'z'， -1)
-1

总结

本章主要谈python面向对象的基本理论，包括：

• 如何声明一个类
• OOP的3大特性：封装，继承，多态
• python的命名规范，如何声明一个私有变量， 静态属性等
• 类型判断比较全的总结
• 使用 hasattr getattr setattr 来获取一个对象的信息

2017年3月7日 15:12:52