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)
<class 'int'>
>>> 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
