python 学习笔记 -- 类与对象

2013年3月24日，python学习第七天。

耐心是一切聪明才智的基础 -- 柏拉图

类简介：

Python的类机制通过最小奥的新语法在语言中实现类。它是C++和Modula-3语言中类机制的混合。

1、类继承机制允许多重继承

2、派生类可以覆盖积累中的任何方法或类

3、可以使用相同的名称调用基类的方法

4、对象可以包含任意数量的私有数据

Python 作用域和命名空间：

1、global 语句用以指明某个特定的变量为全局作用域

2、nonlocal语句用以指明某个变量为封闭变量

代码：

def scope_test():
    def do_local():
        spam = "local spam"
    def do_nonlocal():
        nonlocal spam
        spam = "nonlocal spam"
    def do_global():
        global spam
        spam = "global spam"

    spam = "test spam"
    do_local()
    print("After local assignment:", spam)
    do_nonlocal()
    print("After nonlocal assignment:", spam)
    do_global()
    print("After global assignment:", spam)

scope_test()
print("In global scope:", spam)

类定义：

class ClassName:
    <statement-1>
    .
    .
    .
    <statement-N>

类对象：

类对象支持两种操作：属性引用和实例化

说明：类的实例化操作创建对象使用了特殊的函数__init__()，类的实例化操作会自动为新建的类实例调用__init__()方法。

类继承：

python类继承的基本语法：

class DerivedClassName(BaseClassName):
    <statement-1>
    .
    .
    .
    <statement-N>

当两个类不再同一个作用域时：

class DerivedClassName(modname.BaseClassName):
    <statement-1>
    .
    .
    .
    <statement-N>

1、派生类定义的执行和基类是一样的。构造派生类对象时，就记住了基类。这在解析属性引用的时候非常重要：如果在类中找不到请求调用的属性，就是搜索类。如
果基类是由别的类派生而来的，这个规则会递归到应用上。

2、搜索对应类的属性，必要时沿基类链逐级搜索，如果找到了函数对象的这个方法引用就是合法的。

3、派生类可能会覆盖其基类的方法

4、调用基类的方法：BaseClassName.methodname(self, arguments).

5、Python有两个用于继承的函数：1）函数isinstance()用于检查实例类型；2）函数issubclass()用于检查类继承。

多继承：

class DerivedClassName(Base1, Base2, Base3):
    <statement-1>
    .
    .
    .
    <statement-N>

1、Python有限的支持多继承形式。详情见www.python.org/download/releases/2.3/mro/

2、在大多数情况下，你能想到的搜索属性从父类继承的深度优先，从左到右，而不是搜索两次在同一个类层次结构中，其中一个重叠。因此，如果在本类中没有找到某个属
性，就会搜索base1，然后递归搜索基类，如果最终没有找到，就是搜索base2，以此类推。

私有变量：

像java等编程语言中在类中定义一个私有变量，不过在python中是不存在这样的语法的。然而，也有一个变通的访问用于大多数Python代码：以一个下划线开头的命名会被处

理为API的非公开部分，它会被视为一个实现细节，无需公开。

迭代器：

迭代器及实现原理

在自己的类中使用迭代器：

class Reverse:
    """Iterator for looping over a sequence backwards."""
    def __init__(self, data):
        self.data = data
        self.index = len(data)
    def __iter__(self):
        return self
    def __next__(self):
        if self.index == 0:
            raise StopIteration
        self.index = self.index - 1
        return self.data[self.index]

生成器：
生成器是创建迭代器的简单而强大的工具。需要返回数据的时候使用yied语句。每次next（）被调用时，生成器回复它脱离的位置。

注意：生成器的一个关键功能在于两次执行之间，局部变量和执行状态都是自动的保存下来。

附：（类与对象的一个简单程序）

#!/etc/bin/env python3.1
class Fridge:
	
	def __init__(self, items={}):
		if type(items) != type({}):
			raise TypeError("fridge required a dictionary but was geven %s" % type(items))
		self.items = items
		return
	
	
	def __add_multi(self, food_name,quantity):
		if(not food_name in self.items):
			self.items[food_name] = 0
		self.items[food_name] = self.items[food_name] + quantity
	
	def add_one(self, food_name):
		if type(food_name) != type(""):
			raise TypeError, "add_one required a string, given a %s" % food_name
		else:
			self.__add_multi(food_name, 1)
		return True
	def add_many(self, food_dict):
		if type(food_dict) != type({}):
			raise TypeError("add_many required a dictionary, got a %" % 
food_dict)
		for item in food_dict.keys():
			self.__add_multi(item, food_dict[item])
		return

	def has(self, food_name, quantity=1):
		return self.has_various({food_name:quantity})
	def has_various(self, foods):
		try:
			for food in foods.keys():
				if self.items[food] < foods[food]:
					return False
			return True
		except KeyError:
			return False
	def __get_multi(self, food_name,quantity):
		try:
			if (self.items[food_name] is None):
				return False
			if (quantity > self.items[food_name]):
				return False
			self.items[food_name] = self.items[food_name] - quantity
		except keyError:
			return False
		return quantity
	
	def get_one(self, food_name):
		if type(food_name) != type(""):
			raise TypeError("get_one requires a string, given a %s" % type(food_name))
		else:
			result = self.__get_multi(food_name, 1)
		return result
	def get_many(self, food_dict):
		if self.has_various(food_dict):
			foods_removed = {}
			for item in food_dict.keys():
				foods_removed[item] = self.__get_multi(item, food_dict[item])
			return foods_removed
	def get_ingredients(self, food):
		try:
			ingredients = self.get_many(food.__ingredients__())
		except AttributeError:
			return False
		if ingredients != False:
			return ingredients