Python：类

概述：类的特点
作用域和命名空间。
类的详解：（python官方教程摘录）

概述特性

Python在oop方面思想和Ruby一样。同样包括数据封装，继承和多态三大特点。

类

Python的类提供了面向对象编程的所有标准特性：

类继承机制允许多个基类， ⚠️这点和Ruby不一样，Ruby要求继承的关系是只能有一个父类。
派生类可以覆盖它基类的任何方法，一个方法可以调用基类中相同名称的的方法。
对象可以包含任意数量和类型的数据。
在运行时创建，也可以在创建后修改。

例子：

class Student(object):

    """docstring for Student."""

    def __init__(self, name, score):

        super(Student, self).__init__()

        self.name = name

        self.score = score

    def print_score(self):

        print('%s %s' % (self.name, self.score))

bart = Student('Bart Simpson', 59)

lisa = Student('Lisa Simpson', 87)

bart.print_score()

lisa.print_score()

第一行 class Student(object)表示类Student从object继承过来。用的是括号。object类是一切类的父类。
实例一个Student对象的代码类似调用一个函数。⚠️这点和Ruby的写法不一样。(Ruby用到了new关键字)

上面的例子实例对象有两个变量name,score：

>>> bart.name = 'Bart Simpson'

>>> bart.name

'Bart Simpson'

⚠️又和Ruby不同, ruby必须提供name的读方法和写方法。Python不用。

__int__方法是类定义的初始化方法，第一个参数self代表类的实例。

类中定义的实例方法，第一个参数永远是self。调用时，无需传递该参数。

数据封装

类内部定义的方法可以访问类实例的数据，无需类的外部调用一个方法来读取数据，这就是数据封装。这些封装数据的函数就是类的方法。

上面的print_score就是类的方法，调用时无需传递参数。

⚠️Python的类的实例对象可以绑定任何外部数据：

>>> bart = Student('Bart Simpson', 59)

>>> lisa = Student('Lisa Simpson', 87)

>>> bart.age = 8     #age并不是类中定义的属性。

>>> bart.age

8

>>> lisa.age

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

AttributeError: 'Student' object has no attribute 'age'

访问限制

用__作为变量前缀的变量，不能被外部直接读取。会报告错误❌。⚠️是两个下划线。

⚠️__xx__这是特殊变量没有访问限制

例子：实例变量.__name

只能通过类内定义一个读取变量的方法来实现。

原理：

python会自动把__xxx这类私有变量，的名字转化为_类名__xxx.所有直接访问是不行的。

⚠️不要在外部直接修改私有变量！！！

实例的方法/函数

内置函数，用于操作实例对象。

hasattr(object, name) 参数有2个。如果对象的属性中有name这个字符串, 则返回True。
getattr()
setattr()

类属性

>>> class Student(object):

...     name = 'Student'

>>> s = Student() # 创建实例s

>>> print(s.name) # 打印name属性，因为实例并没有name属性，所以会继续查找class的name属性

Student

⚠️Ruby中定义类属性用@@，例子：@@name。实例变量用@, 例子@xxx。

Python的作用域和命名空间

标签：scope rules，高级Python程序员。

定义

A namespace is a mapping from names to objects.

命名空间是一个从名字到对象的映射（指向，明确的路径）。

Most namespaces are currently implemented as Python dictionaries。

大部分都是由字典dict（其他语言也称为hash）实现。

命名空间namespace例子：

内置函数名字和内置表达式名字的集合。
模块中的global names
一次函数调用内的local names
一个对象的属性集合也是一种namespace

注意：不同namespace内的名称之间没有任何关系。

创建命名空间和lifetimes生命周期

在不同的情况下，命名空间被创建并有了各不相同的生命周期。例子；

包括内建函数的命名空间会在Python interpreter启动时创建，并且永远不被删除。
一个模块的全局命名空间在这个模块定义被读入的时候创建。一般会持续到解释器退出。
一个函数的local namespace在函数被调用时创建，在函数返回或抛出一个不在函数内处理的错误时被删除。

作用域

A scope is a textual region of a Python program where a namespace is directly accessible.

一个作用域是一个Python程序的文本区域，这个区域的namespace是可以直接访问的。

在执行中，有几种内嵌作领域的命名空间可以被直接访问：

最内部的作用于，它被首先搜索，它包括了local names
任何闭包函数的作用领域，它会被从最近的封闭作用领域开始搜索，包括non-local,也包括non-global names.
the next-to-last scope, 包括当前模块的全局名称
最外面的作用领域，被最后搜索，这个命名空间包括内建函数。

命名空间的查找顺序：

　Local：首先搜索，包含局部名字的最内层（innermost）作用域，如函数/方法/类的内部局部作用域；

　Enclosing：根据嵌套层次从内到外搜索，包含非局部（nonlocal）非全局（nonglobal）名字的任意封闭函数的作用域。如两个嵌套的函数，内层函数的作用域是局部作用域，外层函数作用域就是内层函数的 Enclosing作用域；

　Global：倒数第二次被搜索，包含当前模块全局名字的作用域；

　Built-in：最后被搜索，包含内建名字的最外层作用域。

Python按照以上LEGB的顺序依次在四个作用域搜索名字，没有搜索到时，Python抛出NameError异常。

用一个类比来理解命名空间与作用域：

　　四种作用域相当于我们生活中的国家（Built-in）、省（Global）、市（Enclosing）、县（Local），命名空间相当于公务员花名册，记录着哪个职位是哪个人。国家级公务员服务于全国

民众（全国老百姓都可以喊他办事），省级公务员只服务于本身民众（国家层面的人或者其他省的人我不管），市（Enclosing）、县（Local）也是一个道理。当我们要找某一类领导（例如想找

个警察帮我打架）时（要访问某个名称），如果我是在县（Local）里头，优先在县里的领导花名册中找（优先在自己作用域的命名空间中找），县里花名册中没警察没有就去市里的花名册找（往

上一层作用域命名空间找），知道找到国家级都还没找到，那就会报错。如果省级民众想找个警察帮忙大家，不会找市里或者县里的，只会找自己省里的（其它省都不行），或者找国家级的。国家、

省、市、县肯定一直都在那里，可不会移动（作用域是静态的）；领导可以换届，任期移到就换人（命名空间是动态的，每次调用函数都会新的命名空间，函数执行

Python的特殊之处

如果不存在生效的 global 语句 -- 对名称的赋值总是进入最内层作用域。

赋值不会复制数据 --- 它们只是将名称绑定到对象。删除也一样，del x会从局部命名空间的引用中删除对x的绑定。

所有引入的新名称的操作都使用局部作用领域。import声明和函数定义，会在local scope中绑定module或函数名称。

#gloal 用于表示变量生存在全局作用域，并且应当被重新绑定。顶层的绑定。

#nonlocal 表示变量生存在当前作用域的外部，并且应当在其中被重新绑定。

glocal与nonlocal的区别

第一，两者的功能不同。

global关键字修饰变量后标识该变量是全局变量，对该变量进行修改就是修改全局变量，而nonlocal关键字修饰变量后标识该变量是上一级函数中的局部变量，如果上一级函数中不存在该局部变量，nonlocal位置会发生错误。

def f1():

    # i = 1

    def f2():

        nonlocal i

        print(i)

        i = 2

    f2()

    print(i)

f1()

# SyntaxError: no binding for nonlocal 'i' found

第二，两者使用的范围不同。

global关键字可以用在任何地方，包括最上层函数中和嵌套函数中，即使之前未定义该变量，global修饰后也可以直接使用。
nonlocal关键字只能用于嵌套函数中，并且外层函数中定义了相应的局部变量，否则会发生错误。

i = 0

def f1():

    i = 1

    def f2():

        global i     #重新绑定

        print("global", i)

        i = 2

    f2()

    print("local",i)

f1()

# 输出：

# global 0

# local 1

作用域是按字面文本来确定的：

在一个模块内定义的函数的全局作用域就是该模块的命名空间，无论该函数从什么地方或以什么别名被调用。
即在函数定义时，就已经确认作用域了。和函数调用时的位置无关！

几个例子：

i = 1

def f1():

    print(i)

def f2():

    i = 2

    f1()

f2()

print(i)

#输出

#1

#1

解释：这个例子，说明了函数的外部作用域，是函数定义时的外部代码。

if True:

  i = 1

print(i) # 可以正常输出i的值1，不会报错

解释：这说明了if语句不产生新的作用域，只有函数/类才会产生新作用域。

for i in range(10):

  pass

print(i) #输出结果是9，而不是NameError

解释：无关作用域，i被声明，并被赋值。

def test():

    print(i)

　　i= 2

i = 0

test()

解释：会报告错误，UnboundLocalError: local variable 'i' referenced before assignment。i已经被占用了。所以不能再被重新声明。

class A(object):

    a = 2

    def fun(self):

        print(a)

new_class = A()

new_class.fun()

#NameError: name 'a' is not defined

解释：还不理解。fun函数的外部作用域中，没有a。

类的详解

类定义

当进入类定义，创建一个命名空间，作为局部变量和函数的局部作用域。
离开类定义，会创建一个类对象。a class object。
类名称和这个类对象绑定在一起。

Class Object

类对象有2种操作，属性引用和实例化。类变量和函数都是属性。

Instance Object

可以对实例对象进行实例属性引用，有2种：

data attributes: 在其他语言叫做实例变量instance variables(Ruby, Smalltalk)/ data members（C++）
methods：就是从属于一个对象的函数。

例子：

class MyClass:

    i = 12345

    def f(self):

        return 'hello world'

x = MyClass()

x是类的实例对象，x.f是一个method object。具体来说是一个绑定：

而MyClass.f是一个function object。<function Myclass.f at 0x10c759c10>

Python的类的实例对象调用方法，会把自身作为第一个参数传入。

解释一下什么是方法对象method object

比如本例子

x.f()

首先，实例x的类会在自身作用域搜索Myclass.f，如果f是一个函数对象，则
创建一个method object：它是通过把实例对象x和函数对象f打包到一起后产生的一个抽象的对象。
当x.f()被调用，会产生一个新的参数list，这个list会提供给Myclass.f。

私有变量和名称改写name mangling

Any identifier of the form __spam (at least two leading underscores, at most one trailing underscore) is textually replaced with _classname__spam, where classname is the current class name with leading underscore(s) stripped.

任何形式为 __spam 的标识符（至少带有两个前缀下划线，至多一个后缀下划线）的文本将被替换为 _classname__spam，其中 classname 为去除了前缀下划线的当前类名称。

请注意，改写规则的设计主要是为了避免意外冲突；

再谈迭代器

for element in [1, 2, 3]:

    print(element)

解释：

实际上for语句把[1,2,3]作为参数，传入iter()方法。返回一个定义了__next__()方法的对象，叫做iterator object。

每次使用next()，会返回一个容器中的元素。知道元素用尽，引发StopIteration异常。

类可以通过定义__iter__和__next__函数，就可以对类的实例对象进行定制化了。例子：

class Reverse:

    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]

rev = Reverse('spam')

for char in iter(rev):

    print(char)

巴特西