创建 Class

class Car:
    '''DocString.'''
    def __init__(self, brand, color):
        self.brand = brand
        self.color = color

    def get_brand(self):
        return self.brand

    def get_color(self):
        return self.color

实例化 Class

In [3]: bmw = Car('bmw', 'black')

In [4]: bmw.get_brand()
Out[4]: 'bmw'

In [5]: bmw.get_color()
Out[5]: 'black'

传递

实例化后的 Class，比如 bmw ，叫做对象；传递对象（及其他可变类型的序列，比如列表，字典）时，是传递它的引用（指针），因此，效率极高，并且函数可以直接修改传递对象的值（在函数外依然可以看到效果）

命名空间

global
nonlocal

每次新定义一个函数，都会创建一个新的命名空间；在函数内直接使用和全局变量名相同的变量名时，分为两种情况：

引用变量名：此时引用在函数内未定义的变量名，会直接得到全局变量名同名的值
对变量名赋值：对变量名赋值，会在函数的命名空间 local 内创建新的变量名，而不会影响到全局变量名（因此不同函数可以拥有相同的变量名，而互不影响）

如果在函数内要修改全局变量的值，需要先使用 global 声明
如果函数有两层，内层要修改外层的变量名，需要先使用 nonlocal 声明

global

In [6]: t = 'test spam'

In [7]: def func():
   ...:     t = 'func spam'   # 在 local 创建新变量名 t , 不会影响到 global 的 t
   ...:     print(t)
   ...:

In [8]: func()
func spam

In [9]: t
Out[9]: 'test spam'

在函数内直接对全局变量（global）进行赋值时，实际上只会创建新的本地变量，并不会修改到全局变量；若要在函数内修改全局变量，需要先使用关键字 global 声明变量

In [12]: t = 'test spam'

In [13]: def func():
    ...:     global t
    ...:     t = 'func span'  # 会修改到全局变量 t
    ...:     print(t)
    ...:

In [14]: func()
func span

In [15]: t
Out[15]: 'func span'

nonlocal

如果一个函数有两层，内部函数要修改外部函数的值，则需要先使用 nonlocal 声明变量

In [21]: def func1():
    ...:     t = 'func1 spam'
    ...:     print('before func2 called -->', t)
    ...:     print(t)
    ...:     def func2():
    ...:         nonlocal t  
    ...:         t = 'func2 span'  # 内层函数修改外层函数的变量 t
    ...:     func2()
    ...:     print('after func2 called -->',t)
    ...:

In [22]: func1()
before func2 called --> func1 spam
func1 spam
after func2 called --> func2 span

编码风格

类名使用首字母大写，驼峰状：MyClass

类之间，方法之间使用空白行隔开

方法的第一个参数总是 self
方法名使用小写，用下划线代替空格：get_color(self)

DocString

初始化方法

__init__(self) 是一个特殊的方法，在函数被实例化时自动调用，用于初始化对象

特性

self

self 代表的是实例对象本身；
定义类时，每个方法的第一个参数都是 self
调用实例对象的方法时，实例对象本身被隐含地传给 self

属性

类定义的属性默认都是公共的，实例化对象后可以随意地增删属性，所有同类型的对象共享这些属性；若要定义属于每个对象独立的属性，应使用 self.属性名

class Dog:

    kind = 'canine'         # class variable shared by all instances

    def __init__(self, name):
        self.name = name    # instance variable unique to each instance

>>> d = Dog('Fido')
>>> e = Dog('Buddy')
>>> d.kind                  # shared by all dogs
'canine'
>>> e.kind                  # shared by all dogs
'canine'
>>> d.name                  # unique to d
'Fido'
>>> e.name                  # unique to e
'Buddy'

As discussed in A Word About Names and Objects, shared data can have possibly surprising effects with involving mutable objects such as lists and dictionaries. For example, the tricks list in the following code should not be used as a class variable because just a single list would be shared by all Dog instances:

class Dog:

    tricks = []             # mistaken use of a class variable

    def __init__(self, name):
        self.name = name

    def add_trick(self, trick):
        self.tricks.append(trick)

>>> d = Dog('Fido')
>>> e = Dog('Buddy')
>>> d.add_trick('roll over')
>>> e.add_trick('play dead')
>>> d.tricks                # unexpectedly shared by all dogs
['roll over', 'play dead']

Correct design of the class should use an instance variable instead:

class Dog:

    def __init__(self, name):
        self.name = name
        self.tricks = []    # creates a new empty list for each dog

    def add_trick(self, trick):
        self.tricks.append(trick)

>>> d = Dog('Fido')
>>> e = Dog('Buddy')
>>> d.add_trick('roll over')
>>> e.add_trick('play dead')
>>> d.tricks
['roll over']
>>> e.tricks
['play dead']

Python -- Class