• 自然字符串
  如果你想要指示某些不需要如转义符那样的特别处理的字符串，那么你需要指定一个自
  然字符串。自然字符串通过给字符串加上前缀r或R来指定。例如r"Newlines are indicated
  by \n"。
• Unicode字符串
  Unicode是书写国际文本的标准方法。如果你想要用你的母语如北印度语或阿拉伯语写
  文本，那么你需要有一个支持Unicode的编辑器。类似地，Python允许你处理Unicode文
  本——你只需要在字符串前加上前缀u或U。例如，u"This is a Unicode string."。
• 使用变量时只需要给它们赋一个值。不需要声明或定义数据类型
• range返回一个序列的数。这个序列从第一个数开始到第二个数
  为止。例如，range(1,5)给出序列[1, 2, 3, 4]。默认地，range的步长为1。如果我们为range提供第三个数，那么它将成为步长。例如，range(1,5,2)给出[1,3]。记住，range 向上 延伸到第二个数，即它不包含第二个数。
• 函数通过def关键字定义。def关键字后跟一个函数的 标识符 名称，然后跟一对圆括号。圆括号之中可以包括一些变量名，该行以冒号结尾。接下来是一块语句，它们是函数体。下面这个例子将说明这事实上是十分简单的：
  例7.1 定义函数

#!/usr/bin/python
# Filename: function1.py
def sayHello():
  print 'Hello World!' # block belonging to the function
sayHello() # call the function

• 如果你想要为一个定义在函数外的变量赋值，那么你就得告诉Python这个变量名不是局部的，而是 全局 的。我们使用global语句完成这一功能。没有global语句，是不可能为定义在函数外的变量赋值的。
  你可以使用定义在函数外的变量的值（假设在函数内没有同名的变量）。然而，我并不鼓励你这样做，并且你应该尽量避免这样做，因为这使得程序的读者会不清楚这个变量是在哪里定义的。使用global语句可以清楚地表明变量是在外面的块定义的。

#!/usr/bin/python
# Filename: func_global.py
def func():
  global x
  print 'x is', x
  x = 2
  print 'Changed local x to', x
x = 50
func()
print 'Value of x is', x

global语句被用来声明x是全局的——因此，当我们在函数内把值赋给x的时候，这个变化也反映在我们在主块中使用x的值的时候。

• 默认参数
  默认参数值应该是一个参数。更加准确的说，默认参数值应该是不可变的

#!/usr/bin/python
# Filename: func_default.py
def say(message, times = 1):
  print message * times
say('Hello')
say('World', 5)

输出
$ python func_default.py
Hello
WorldWorldWorldWorldWorld

重要
只有在形参表末尾的那些参数可以有默认参数值，即你不能在声明函数形参的时候，先声明有默认值的形参而后声明没有默认值的形参。
这是因为赋给形参的值是根据位置而赋值的。例如，def func(a, b=5)是有效的，但是def func(a=5, b)是 无效 的。

• 关键参数
  如果你的某个函数有许多参数，而你只想指定其中的一部分，那么你可以通过命名来为这些参数赋值——这被称作 关键参数 ——我们使用名字（关键字）而不是位置来给函数指定实参。
  这样做有两个 优势 一，由于我们不必担心参数的顺序，使用函数变得更加简单了。二、假设其他参数都有默认值，我们可以只给我们想要的那些参数赋值。

#!/usr/bin/python
# Filename: func_key.py
def func(a, b=5, c=10):
  print 'a is', a, 'and b is', b, 'and c is', c
func(3, 7)
func(25, c=24)
func(c=50, a=100)

• 没有返回值的return语句等价于return None。None是Python中表示没有任何东西的特殊类型。
  例如，如果一个变量的值为None，可以表示它没有值。
  除非你提供你自己的return语句，每个函数都在结尾暗含有return None语句。通过运行printsomeFunction()，你可以明白这一点，函数someFunction没有使用return语句
  如同：
  def someFunction():
  pass
  pass语句在Python中表示一个空的语句块。
• DocStrings文档字符串
  Python有一个很奇妙的特性，称为 文档字符串 ，它通常被简称为 docstrings 。DocStrings是一个重要的工具，由于它帮助你的程序文档更加简单易懂，你应该尽量使用它。

#!/usr/bin/python
# Filename: func_doc.py
def printMax(x, y):
  '''Prints the maximum of two numbers.

  The two values must be integers.'''
  x = int(x) # convert to integers, if possible
  y = int(y)
  if x > y:
    print x, 'is maximum'
else:
    print y, 'is maximum'
print Max(3, 5)
print printMax.__doc__

输出
$ python func_doc.py
5 is maximum
Prints the maximum of two numbers.

The two values must be integers.

注意：
在函数的第一个逻辑行的字符串是这个函数的 文档字符串 。注意，DocStrings也适用于模块和类。
文档字符串的惯例是一个多行字符串，它的首行以大写字母开始，句号结尾。第二行是空行，从第三行开始是详细的描述。 强烈建议 你在你的函数中使用文档字符串时遵循这个惯例。
你可以使用doc（注意双下划线）调用printMax函数的文档字符串属性（属于函数的名称）。请记住Python把 每一样东西 都作为对象，包括这个函数。
自动化工具也可以以同样的方式从你的程序中提取文档。因此，我 强烈建议 你对你所写的任何正式函数编写文档字符串。

• from..import语句
  如果你想要直接输入argv变量到你的程序中（避免在每次使用它时打sys.），那么你可以使用from sys import argv语句。如果你想要输入所有sys模块使用的名字，那么你可以使用from sys import *语句。这对于所有模块都适用。一般说来，应该避免使用from..import而使用import语句，因为这样可以使你的程序更加易读，也可以避免名称的冲突。
• 列表
  使用列表

#!/usr/bin/python
# Filename: using_list.py
# This is my shopping list
shoplist = ['apple', 'mango', 'carrot', 'banana']
print 'I have', len(shoplist),'items to purchase.'
print 'These items are:', # Notice the comma at end of the line
for item in shoplist:
  print item,
print '\nI also have to buy rice.'
shoplist.append('rice')
print 'My shopping list is now', shoplist
print 'I will sort my list now'
shoplist.sort()
print 'Sorted shopping list is', shoplist
print 'The first item I will buy is', shoplist[0]
olditem = shoplist[0]
del shoplist[0]
print 'I bought the', olditem
print 'My shopping list is now', shoplist

输出
$ python using_list.py
I have 4 items to purchase.
These items are: apple mango carrot banana
I also have to buy rice.
My shopping list is now ['apple', 'mango', 'carrot', 'banana', 'rice']
I will sort my list now
Sorted shopping list is ['apple', 'banana', 'carrot', 'mango', 'rice']
The first item I will buy is apple
I bought the apple
My shopping list is now ['banana', 'carrot', 'mango', 'rice']

注意:
我们在print语句的结尾使用了一个 逗号 来消除每个print语句自动打印的换行符。这样做有点难看，不过确实简单有效。接下来，我们使用append方法在列表中添加了一个项目，就如前面已经讨论过的一样。打印列表只需简单地把列表传递给print语句，我们可以得到一个整洁的输出。
再接下来，我们使用列表的sort方法来对列表排序。需要理解的是，这个方法影响列表本身，而不是返回一个修改后的列表——这与字符串工作的方法不同。这就是我们所说的列表是 可变的 而字符串是 不可变的 。

• 元组和列表十分类似，只不过元组和字符串一样是 不可变的 即你不能修改元组。元组通过圆括号中用逗号分割的项目定义。元组通常用在使语句或用户定义的函数能够安全地采用一组值的时候，即被使用的元组的值不会改变。

#!/usr/bin/python
# Filename: using_tuple.py
zoo = ('wolf', 'elephant', 'penguin')
print 'Number of animals in the zoo is', len(zoo)
new_zoo = ('monkey', 'dolphin', zoo)
print 'Number of animals in the new zoo is', len(new_zoo)
print 'All animals in new zoo are', new_zoo
print 'Animals brought from old zoo are', new_zoo[2]
print 'Last animal brought from old zoo is', new_zoo[2][2]

输出
$ python using_tuple.py
Number of animals in the zoo is 3
Number of animals in the new zoo is 3
All animals in new zoo are ('monkey', 'dolphin', ('wolf', 'elephant', 'penguin'))
Animals brought from old zoo are ('wolf', 'elephant', 'penguin')
Last animal brought from old zoo is penguin

含有0个或1个项目的元组：一个空的元组由一对空的圆括号组成，如myempty = ()。然而，含有单个元素的元组就不那么简单了。你必须在第一个（唯一一个）项目后跟一个逗号，这样Python才能区分元组和表达式中一个带圆括号的对象。即如果你想要的是一个包含项目2的元组的时候，你应该指明singleton = (2 , )。
给Perl程序员的注释：列表之中的列表不会失去它的身份，即列表不会像Perl中那样被打散。同样元组中的元组，或列表中的元组，或元组中的列表等等都是如此。只要是Python，它们就只是使用另一个对象存储的对象。

• 元组与打印语句
  元组最通常的用法是用在打印语句中，下面是一个例子：

#!/usr/bin/python
# Filename: print_tuple.py
age = 22
name = 'Swaroop'
print '%s is %d years old' % (name, age)
print 'Why is %s playing with that python?' % name

输出
$ python print_tuple.py
Swaroop is 22 years old
Why is Swaroop playing with that python?

print语句可以使用跟着%符号的项目元组的字符串。这些字符串具备定制的功能。定制让输出满足某种特定的格式。定制可以是%s表示字符或%d表示整数。元组必须按照相同的顺序来对应这些定制。
print的这个用法使得编写输出变得极其简单，它避免了许多字符串操作。它也避免了我们一直以来使用的逗号。
在第二个print语句中，我们使用了一个定制，后面跟着%符号后的单个项目没有圆括号。这只在字符串中只有一个定制的时候有效。

• 字典
  你只能使用不可变的对象（比如字符串）来作为字典的键，但是你可以把不可变或可变的对象作为字典的值。基本说来就是，你应该只使用简单的对象作为键。
  键值对在字典中以这样的方式标记：d = {key1 : value1, key2 : value2 }。注意它们的键/值对用冒号分割，而各个对用逗号分割，所有这些都包括在花括号中。

#!/usr/bin/python
# Filename: using_dict.py
# 'ab' is short for 'a'ddress'b'ook
ab = { 'Swaroop' : 'swaroopch@byteofpython.info',
          'Larry' : 'larry@wall.org',
          'Matsumoto' : 'matz@ruby-lang.org',
          'Spammer' : 'spammer@hotmail.com'
}
print "Swaroop's address is %s" % ab['Swaroop']
# Adding a key/value pair
ab['Guido'] = 'guido@python.org'
# Deleting a key/value pair
del ab['Spammer']
print '\nThere are %d contacts in the address-book\n' % len(ab)
for name, address in ab.items():
print 'Contact %s at %s' % (name, address)
if 'Guido' in ab: # OR ab.has_key('Guido')
print "\nGuido's address is %s" % ab['Guido']

输出
$ python using_dict.py
Swaroop's address is swaroopch@byteofpython.info
There are 4 contacts in the address-book
Contact Swaroop at swaroopch@byteofpython.info
Contact Matsumoto at matz@ruby-lang.org
Contact Larry at larry@wall.org
Contact Guido at guido@python.org
Guido's address is guido@python.org

• 序列
  列表、元组和字符串都是序列，但是序列是什么，它们为什么如此特别呢？序列的两个主要特点是索引操作符和切片操作符。索引操作符让我们可以从序列中抓取一个特定项目。切片操作符让我们能够获取序列的一个切片，即一部分序列。

#!/usr/bin/python
# Filename: seq.py
shoplist = ['apple', 'mango', 'carrot', 'banana']
# Indexing or 'Subscription' operation
print 'Item 0 is', shoplist[0]
print 'Item 1 is', shoplist[1]
print 'Item 2 is', shoplist[2]
print 'Item 3 is', shoplist[3]
print 'Item -1 is', shoplist[-1]
print 'Item -2 is', shoplist[-2]
# Slicing on a list
print 'Item 1 to 3 is', shoplist[1:3]
print 'Item 2 to end is', shoplist[2:]
print 'Item 1 to -1 is', shoplist[1:-1]
print 'Item start to end is', shoplist[:]
# Slicing on a string
name = 'swaroop'
print 'characters 1 to 3 is', name[1:3]
print 'characters 2 to end is', name[2:]
print 'characters 1 to -1 is', name[1:-1]
print 'characters start to end is', name[:]

输出
$ python seq.py
Item 0 is apple
Item 1 is mango
Item 2 is carrot
Item 3 is banana
Item -1 is banana
Item -2 is carrot
Item 1 to 3 is ['mango', 'carrot']
Item 2 to end is ['carrot', 'banana']
Item 1 to -1 is ['mango', 'carrot']
Item start to end is ['apple', 'mango', 'carrot', 'banana']
characters 1 to 3 is wa
characters 2 to end is aroop
characters 1 to -1 is waroo
characters start to end is swaroop

• 引用
  当你创建一个对象并给它赋一个变量的时候，这个变量仅仅 引用 那个对象，而不是表示这个对象本身！也就是说，变量名指向你计算机中存储那个对象的内存。这被称作名称到对象的绑定。。
  对象与引用:

#!/usr/bin/python
# Filename: reference.py
print 'Simple Assignment'
shoplist = ['apple', 'mango', 'carrot', 'banana']
mylist = shoplist # mylist is just another name pointing to the same object!
del shoplist[0]
print 'shoplist is', shoplist
print 'mylist is', mylist
# notice that both shoplist and mylist both print the same list without
# the 'apple' confirming that they point to the same object
print 'Copy by making a full slice'
mylist = shoplist[:] # make a copy by doing a full slice
del mylist[0] # remove first item
print 'shoplist is', shoplist
print 'mylist is', mylist
# notice that now the two lists are different

输出
$ python reference.py
Simple Assignment
shoplist is ['mango', 'carrot', 'banana']
mylist is ['mango', 'carrot', 'banana']
Copy by making a full slice
shoplist is ['mango', 'carrot', 'banana']
mylist is ['carrot', 'banana']

需要记住的只是如果你想要复制一个列表或者类似的序列或者其他复杂的对象（不是如整数那样的简单 对象 ），那么你必须使用切片操作符来取得拷贝。如果你只是想要使用另一个变量名，两个名称都 引用 同一个对象，那么如果你不小心的话，可能会引来各种麻烦。

• 字符串的方法

#!/usr/bin/python
# Filename: str_methods.py
name = 'Swaroop' # This is a string object
if name.startswith('Swa'):
print 'Yes, the string starts with "Swa"'
if 'a' in name:
print 'Yes, it contains the string "a"'
if name.find('war') != -1:
print 'Yes, it contains the string "war"'
delimiter = '_*_'
mylist = ['Brazil', 'Russia', 'India', 'China']
print delimiter.join(mylist)

输出
$ python str_methods.py
Yes, the string starts with "Swa"
Yes, it contains the string "a"
Yes, it contains the string "war"
Brazil_*_Russia_*_India_*_China

• 对象
  对象可以使用普通的 属于 对象的变量存储数据。属于一个对象或类的变量被称为域。对象也可以使用 属于 类的函数来具有功能。这样的函数被称为类的方法。这些术语帮助我们把它们与孤立的函数和变量区分开来。域和方法可以合称为类的属性。域有两种类型——属于每个实例/类的对象或属于类本身。它们分别被称为实例变量和类变量。
• self
  你一定很奇怪Python如何给self赋值以及为何你不需要给它赋值。举一个例子会使此变得清晰。假如你有一个类称为MyClass和这个类的一个实例MyObject。当你调用这个对象的方法MyObject.method(arg1, arg2)的时候，这会由Python自动转为MyClass.method(MyObject, arg1,arg2)——这就是self的原理了。
• 对象的方法

#!/usr/bin/python
# Filename: method.py
class Person:
  def sayHi(self):
    print 'Hello, how are you?'

p = Person()
p.sayHi()
# This short example can also be written as Person().sayHi()

输出
$ python method.py
Hello, how are you?

这里我们看到了self的用法。注意sayHi方法没有任何参数，但仍然在函数定义时有self。

• 对象的方法

#!/usr/bin/python
# Filename: method.py
class Person:
  def sayHi(self):
    print 'Hello, how are you?'

p = Person()
p.sayHi()
# This short example can also be written as Person().sayHi()

输出
$ python method.py
Hello, how are you?

• init方法
  init方法在类的一个对象被建立时，马上运行。这个方法可以用来对你的对象做一些你希望的 初始化 。注意，这个名称的开始和结尾都是双下划线。

#!/usr/bin/python
# Filename: class_init.py
class Person:
  def __init__(self, name):
    self.name = name
  def sayHi(self):
    print 'Hello, my name is', self.name

p = Person('Swaroop')
p.sayHi()
# This short example can also be written as Person('Swaroop').sayHi()

输出
$ python class_init.py
Hello, my name is Swaroop

这里，我们把init方法定义为取一个参数name（以及普通的参数self）。在这个init里，我们只是创建一个新的域，也称为name。注意它们是两个不同的变量，尽管它们有相同的名字。点号使我们能够区分它们。
最重要的是，我们没有专门调用init方法，只是在创建一个类的新实例的时候，把参数包括在圆括号内跟在类名后面，从而传递给init方法。这是这种方法的重要之处。

• 类与对象的变量

#!/usr/bin/python
# Filename: objvar.py
class Person:
  '''Represents a person.'''
  population = 0
  def __init__(self, name):
    '''Initializes the person's data.'''
    self.name = name
    print '(Initializing %s)' % self.name
    # When this person is created, he/she
    # adds to the population
    Person.population += 1

def __del__(self):
  '''I am dying.'''
  print '%s says bye.' % self.name
  Person.population -= 1
  if Person.population == 0:
    print 'I am the last one.'
  else:
    print 'There are still %d people left.' % Person.population

def sayHi(self):
  '''Greeting by the person.
  Really, that's all it does.'''
  print 'Hi, my name is %s.' % self.name

def howMany(self):
  '''Prints the current population.'''
  if Person.population == 1:
    print 'I am the only person here.'
  else:
    print 'We have %d persons here.' % Person.population

swaroop = Person('Swaroop')
swaroop.sayHi()
swaroop.howMany()
kalam = Person('Abdul Kalam')
kalam.sayHi()
kalam.howMany()
swaroop.sayHi()
swaroop.howMany()

输出
$ python objvar.py
(Initializing Swaroop)
Hi, my name is Swaroop.
I am the only person here.
(Initializing Abdul Kalam)
Hi, my name is Abdul Kalam.
We have 2 persons here.
Hi, my name is Swaroop.
We have 2 persons here.
Abdul Kalam says bye.
There are still 1 people left.
Swaroop says bye.
I am the last one.

这是一个很长的例子，但是它有助于说明类与对象的变量的本质。这里，population属于Person类，因此是一个类的变量。name变量属于对象（它使用self赋值）因此是对象的变量。
观察可以发现init方法用一个名字来初始化Person实例。在这个方法中，我们让population增加1，这是因为我们增加了一个人。同样可以发现，self.name的值根据每个对象指定，这表明了它作为对象的变量的本质。
记住，你只能使用self变量来参考同一个对象的变量和方法。这被称为 属性参考 。
在这个程序中，我们还看到docstring对于类和方法同样有用。我们可以在运行时使用Person.doc和Person.sayHi.doc来分别访问类与方法的文档字符串。
就如同init方法一样，还有一个特殊的方法del，它在对象消逝的时候被调用。对象消逝即对象不再被使用，它所占用的内存将返回给系统作它用。在这个方法里面，我们只是简单地把Person.population减1。
给C++/Java/C#程序员的注释
Python中所有的类成员（包括数据成员）都是 公共的 ，所有的方法都是 有效的 。
只有一个例外：如果你使用的数据成员名称以 双下划线前缀 比如__privatevar，Python的名称管理体系会有效地把它作为私有变量。

• 继承

#!/usr/bin/python
# Filename: inherit.py
class SchoolMember:
  '''Represents any school member.'''
  def __init__(self, name, age):
    self.name = name
    self.age = age
    print '(Initialized SchoolMember: %s)' % self.name

  def tell(self):
    '''Tell my details.'''
    print 'Name:"%s" Age:"%s"' % (self.name, self.age),

class Teacher(SchoolMember):
  '''Represents a teacher.'''
  def __init__(self, name, age, salary):
    SchoolMember.__init__(self, name, age)
    self.salary = salary
    print '(Initialized Teacher: %s)' % self.name

  def tell(self):
    SchoolMember.tell(self)
    print 'Salary: "%d"' % self.salary

class Student(SchoolMember):
  '''Represents a student.'''
  def __init__(self, name, age, marks):
    SchoolMember.__init__(self, name, age)
    self.marks = marks
    print '(Initialized Student: %s)' % self.name

def tell(self):
  SchoolMember.tell(self)
   print 'Marks: "%d"' % self.marks
    
t = Teacher('Mrs. Shrividya', 40, 30000)
s = Student('Swaroop', 22, 75)
print # prints a blank line
members = [t, s]
for member in members:
  member.tell() # works for both Teachers and Students

输出
$ python inherit.py
(Initialized SchoolMember: Mrs. Shrividya)
(Initialized Teacher: Mrs. Shrividya)
(Initialized SchoolMember: Swaroop)
(Initialized Student: Swaroop)
Name:"Mrs. Shrividya" Age:"40" Salary: "30000"
Name:"Swaroop" Age:"22" Marks: "75"\

为了使用继承，我们把基本类的名称作为一个元组跟在定义类时的类名称之后。然后，我们注意到基本类的init方法专门使用self变量调用，这样我们就可以初始化对象的基本类部分。这一点十分重要——Python不会自动调用基本类的constructor，你得亲自专门调用它。

• 文件操作

#!/usr/bin/python
# Filename: using_file.py
poem = '''\
Programming is fun
When the work is done
if you wanna make your work also fun:
  use Python!
'''
f = file('poem.txt', 'w') # open for 'w'riting
f.write(poem) # write text to file
f.close() # close the file
f = file('poem.txt')
# if no mode is specified, 'r'ead mode is assumed by default
while True:
  line = f.readline()
  if len(line) == 0: # Zero length indicates EOF
    break
  print line,
# Notice comma to avoid automatic newline added by Python
f.close() # close the file

输出
$ python using_file.py
Programming is fun
When the work is done
if you wanna make your work also fun:
  use Python!

我们通过指明我们希望打开的文件和模式来创建一个file类的实例。模式可以为读模式
（'r'）、写模式（'w'）或追加模式（'a'）。
接下来，我们再一次打开同一个文件来读文件。如果我们没有指定模式，读模式会作为默认的模式。在一个循环中，我们使用readline方法读文件的每一行。这个方法返回包括行末换行符的一个完整行。所以，当一个 空的 字符串被返回的时候，即表示文件末已经到达了，于是我们停止循环。

• 存储器持久化

#!/usr/bin/python
# Filename: pickling.py
import cPickle as p
#import pickle as p
shoplistfile = 'shoplist.data'
# the name of the file where we will store the object
shoplist = ['apple', 'mango', 'carrot']
# Write to the file
f = file(shoplistfile, 'w')
p.dump(shoplist, f) # dump the object to a file
f.close()
del shoplist # remove the shoplist
# Read back from the storage
f = file(shoplistfile)
storedlist = p.load(f)
print storedlist

输出
$ python pickling.py
['apple', 'mango', 'carrot']

• 新式类和旧式类
  python2有经典类和新式类并存，具体写法分为：
  class A(object)：新式类
  class A():旧式类
  class A:旧式类
  python3默认是新式类
  有无object是判断旧式类和新式类的最大区别，新式类继承了object类。

新式类的MRO(method resolution order 基类搜索顺序)算法采用C3算法广度优先搜索，而旧式类的MRO算法是采用深度优先搜索。

在python2和python3定义类，测试他的类型时是这样：

#Python2
 
class A:
 
    pass
 
print(type(A))
 
output:
<type 'classobj'>
 
 
 
#Python3
 
class A(object):
 
    pass
 
print(type(A))
 
output:
 
<type 'type'>

另外旧式类的深度优先示例：

class A():
 
    def foo1(self):
 
          print("A")
 
class B(A):
 
    def foo2(self):
          pass
 
class C(A):
     def foo1(self):
 
          print("C")
 
class D(B, C):
 
    pass
 
d =D()
 
d.foo1()
 
output:
 
A

按照经典类的查找顺序从左到右深度优先的规则，在访问d.foo1()的时候,D这个类是没有的..那么往上查找,先找到B,里面没有,深度优先,访问A,找到了foo1(),所以这时候调用的是A的foo1()，从而导致C重写的foo1()被绕过

新式类是广度优先:

class A(object):
 
    def foo1(self):
 
          print("A")
 
class B(object):
 
    def foo2(self):
 
          pass
 
class C(object):     #或者是class C(A):只要A是新式类的定义，那么继承类都是新式类
 
    def foo1(self):
 
          print("C")
 
class D(B, C):
 
    pass
 
d = D()
 
d.foo1()
 
output:
 
C

新式类和旧式类的不同还包括：

#举例
class A(object):
    pass
 
class B():
    pass
 
print(dir(A))
print(dir(B))
#查看旧式类和新式类都有哪些魔术方法
 
output:
新式类有：
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__']
旧式类有：
['__doc__', '__module__']

Python:super函数

这是个高大上的函数,在python装13手册里面介绍过多使用可显得自己是高手. 但其实他还是很重要的. 简单说, super函数是调用下一个父类(超类)并返回该父类实例的方法. 这里的下一个的概念参考后面的MRO表介绍.

help介绍如下:

super(type, obj) -> bound super object; requires isinstance(obj, type)
super(type) -> unbound super object
super(type, type2) -> bound super object; requires issubclass(type2, type)
Typical use to call a cooperative superclass method:
class C(B):
    def meth(self, arg):
        super(C, self).meth(arg)

由此可知, super有三种用法, 第一参数总是召唤父类的那个类, 第二参数可缺(返回非绑定父类对象),也可以是实例对象或该类的子类. 最终返回的都是父类的实例(绑定或非绑定). 在Python3中,super函数多了一种用法是直接super(),相当于super(type,首参), 这个首参就是一般的传入的self实例本身啦. 因为在py2里面常用也是这种写法.

另外, 在py2中, super只支持新类( new-style class, 就是继承自object的).

为什么要调用父类?

在类继承时, 要是重定义某个方法, 这个方法就会覆盖掉父类的相应同名方法. 通过调用父类实例, 可以在子类中同时实现父类的功能.例如:

# Should be new-class based on object in python2.
class A(object):
    def __init__(self):
        print "enter A"
        print "leave A"

class B(A):
    def __init__(self):
        print "enter B"
        super(B, self).__init__()
        print "leave B"

>>> b = B()
enter B
enter A
leave A
leave B

通过调用super获得父类实例从而可以实现该实例的初始化函数. 这在实践中太常用了 (因为要继承父类的功能, 又要有新的功能).

直接使用父类来调用的差异

事实上, 上面的super函数方法还可以这么写:

class A(object):
    def __init__(self):
        print "enter A"
        print "leave A"

class B(A):
    def __init__(self):
        print "enter B"
        A.__init__(self)
        print "leave B"

通过直接使用父类类名来调用父类的方法, 实际也是可行的. 起码在上面的例子中效果上他们现在是一样的. 这种方法在老式类中也是唯一的调用父类的方法 (老式类没有super).

通过父类类名调用方法很常用, 比较直观. 但其效果和super还是有差异的. 例如:

class A(object):
    def __init__(self):
        print "enter A"
        print "leave A"

class B(A):
    def __init__(self):
        print "enter B"
        A.__init__(self)
        print "leave B"

class C(A):
    def __init__(self):
        print "enter C"
        A.__init__(self)
        print "leave C"

class D(B,C):
    def __init__(self):
        print "enter D"
        B.__init__(self)
        C.__init__(self)
        print "leave D"
>>> d=D()
enter D
enter B
enter A
leave A
leave B
enter C
enter A
leave A
leave C
leave D

可以发现, 这里面A的初始化函数被执行了两次. 因为我们同时要实现B和C的初始化函数, 所以分开调用两次, 这是必然的结果.

但如果改写成super呢?

class A(object):
    def __init__(self):
        print "enter A"
        print "leave A"

class B(A):
    def __init__(self):
        print "enter B"
        super(B,self).__init__()
        print "leave B"

class C(A):
    def __init__(self):
        print "enter C"
        super(C,self).__init__()
        print "leave C"

class D(B,C):
    def __init__(self):
        print "enter D"
        super(D,self).__init__()
        print "leave D"
>>> d=D()
enter D
enter B
enter C
enter A
leave A
leave C
leave B
leave D

会发现所有父类ABC只执行了一次, 并不像之前那样执行了两次A的初始化.

然后, 又发现一个很奇怪的: 父类的执行是 BCA 的顺序并且是全进入后再统一出去. 这是MRO表问题, 后面继续讨论.

如果没有多继承, super其实和通过父类来调用方法差不多. 但, super还有个好处: 当B继承自A, 写成了A.__init__, 如果根据需要进行重构全部要改成继承自 E,那么全部都得改一次! 这样很麻烦而且容易出错! 而使用super()就不用一个一个改了(只需类定义中改一改就好了)

Anyway, 可以发现, super并不是那么简单.

MRO 表

MRO是什么? 可以通过以下方式调出来:

>>> D.mro() # or d.__class__.mro()  or D.__class__.mro(D) 
[D, B, C, A, object]

>>> B.mro()
[B, A, object]

>>> help(D.mro)
#Docstring:
#mro() -> list
#return a type's method resolution order
#Type:      method_descriptor

MRO就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表 (类继承顺序表去理解也行) 啦.

这个表有啥用? 首先了解实际super做了啥:

def super(cls, inst):
    mro = inst.__class__.mro()
    return mro[mro.index(cls) + 1]

换而言之, super方法实际是调用了cls的在MRO表中的下一个类. 如果是简单一条线的单继承, 那就是父类->父类一个一个地下去罗. 但对于多继承, 就要遵循MRO表中的顺序了. 以上面的D的调用为例:

d的初始化
-> D (进入D) super(D,self) 
-> 父类B (进入B) super(B,self) 
-> 父类C (进入C) super(C,self) 
-> 父父类A (进入A)  (退出A) # 如有继续super(A,self)  -> object (停了)
-> (退出C)
-> (退出B)
-> (退出D)

所以, 在MRO表中的超类初始化函数只执行了一次!

那么, MRO的顺序究竟是怎么定的呢? 这个可以参考官方说明The Python 2.3 Method Resolution Order. 基本就是, 计算出每个类(从父类到子类的顺序)的MRO, 再merge 成一条线. 遵循以下规则:

在 MRO 中，基类永远出现在派生类后面，如果有多个基类，基类的相对顺序保持不变。 这个原则包括两点:

1. 基类永远在派生类后面
2. 类定义时的继承顺序影响相对顺序.

如果有以下继承 (转自涡旋鸣人的python super()):

    object
     /   \
    /      A
   |     /   \
  B-1  C-2   D-2
    \   /    /
     E-1    /
        \  /
          F

那么MRO是: F －> E -> B -> C -> D -> A -> object

怎么解释呢?

根据官方的方法, 是:

L(O) = O
L(B) = B O
L(A) = A O
L(C) = C A O
L(D) = D A O
L(E) = E + merge(L(B),L(C))
     = E + merge(BO,CAO)
     = E + B + merge(O,CAO)
     = E + B + C + merge(O,AO)
     = E + B + C + A + merge(O,O)
     = E B C A O
L(F) = F + merge(L(E),L(D))
     = F + merge(EBCAO,DAO)
     = F + EBC + merge(AO,DAO)
     = F + EBC + D + merge(AO,AO)
     = F EBC D AO

看起来很复杂..但还是遵循在 MRO 中，基类永远出现在派生类后面，如果有多个基类，基类的相对顺序保持不变。所以, 我个人认为可以这么想:

• 先找出最长深度最深的继承路线F->E->C->A->object. (因为必然基类永远出现在派生类后面)
• 类似深度优先, 定出其余顺序: F->E->B->obj, F->D->A-object
• 如果有多个基类，基类的相对顺序保持不变, 类似于merge时优先提前面的项. 所以排好这些路线: (FEBO, FECAO, FDAO)
• F->E->B->obj且E(B,C)决定B在C前面.所以F->E->B->C->A->obj (相当于F+merge(EBO,ECAO)).
• F->D->A-object且F(E,D)决定了D在E后, 所以D在E后A前. 因为相对顺序, 相当于FE+merge(BCAO, DAO), 所以FE BC D AO

[Python杂谈: init.py的作用]

我们经常在python的模块目录中会看到 "init.py" 这个文件，那么它到底有什么作用呢？

标识该目录是一个python的模块包（module package）

如果你是使用python的相关IDE来进行开发，那么如果目录中存在该文件，该目录就会被识别为 module package 。

简化模块导入操作

假设我们的模块包的目录结构如下：

└── mypackage
    ├── subpackage_1
    │   ├── test11.py
    │   └── test12.py
    ├── subpackage_2
    │   ├── test21.py
    │   └── test22.py
    └── subpackage_3
        ├── test31.py
        └── test32.py</pre>

如果我们使用最直接的导入方式，将整个文件拷贝到工程目录下，然后直接导入：

from mypackage.subpackage_1 import test11
from mypackage.subpackage_1 import test12
from mypackage.subpackage_2 import test21
from mypackage.subpackage_2 import test22
from mypackage.subpackage_3 import test31
from mypackage.subpackage_3 import test32

当然这个例子里面文件比较少，如果模块比较大，目录比较深的话，可能自己都记不清该如何导入。（很有可能，哪怕只想导入一个模块都要在目录中找很久）
这种情况下，init.py 就很有作用了。我们先来看看该文件是如何工作的。

init.py 是怎么工作的？

实际上，如果目录中包含了 init.py 时，当用 import 导入该目录时，会执行 init.py 里面的代码。我们在mypackage目录下增加一个 init.py 文件来做一个实验：

└── mypackage
    ├── __init__.py
    ├── subpackage_1
    │   ├── test11.py
    │   └── test12.py
    ├── subpackage_2
    │   ├── test21.py
    │   └── test22.py
    └── subpackage_3
        ├── test31.py
        └── test32.py</pre>

mypackage/init.py 里面加一个print，如果执行了该文件就会输出：

print("You have imported mypackage")

下面直接用交互模式进行 import
import mypackage
You have imported mypackage

很显然，init.py 在包被导入时会被执行。

使用import mypackage将mypackage包导入到当前文件，具体可以将该包下什么模块或内容导入取决于该包下__init__.py中的内容（关注__init__.py初始化了什么内容和导入了什么模块）。
若mypackage包下的某个模块a没有被__init__.py导入，使用import mypackage导入包后将不能使用该模块a，即mypackage.a会报错。
可以使用方式from mypackage import a来导入该包下的具体模块a。