Python基础：06.类、命名空间和作用域

类：面向对象编程

• 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
• 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
• 数据成员：类变量或者实例变量, 用于处理类及其实例对象的相关的数据。
• 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
• 局部变量：定义在方法中的变量，只作用于当前实例的类。
• 实例变量：在类的声明中，属性是用变量来表示的。这种变量就称为实例变量，是在类声明的内部但是在类的其他成员方法之外声明的。
• 继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟”是一个（is-a）”关系（例图，Dog是一个Animal）。
• 实例化：创建一个类的实例，类的具体对象。
• 方法：类中定义的函数。
• 对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

一、类的创建与使用

通过class name:来创建类，obj = classname()来实例化类，obj.name来调用属性

类定义的各个方法与普通的函数只有一个特别的区别：它们必须有一个额外的第一个参数名称,，按照惯例它的名称是 self ，换成其他的也可以

self经常忘写，self 代表的是类的实例，代表当前对象的地址，理解为C++的this指针

class people:
    name = 'python'
    def myname(self):
        print('my name is',self.name)
    def prt(self):
        print(self)
    def prt1(other):
        print(other)
a = people()
print(a.name)
b = people()
a.myname()
a.prt()
a.prt1()
b.prt()   # 能够看出a/b的地址是不同的

python
my name is python
<__main__.people object at 0x00000211984A00B8>
<__main__.people object at 0x00000211984A00B8>
<__main__.people object at 0x00000211984A0390>

类有一个名为 __init__() 的特殊方法（构造方法），该方法在类实例化时会自动调用，理解为C++的构造函数

__init()__方法可以有参数，类在实例化时，直接使用obj = class(arg1,arg2,arg3...)赋予实例化对象这些参数

class myclass():
    def __init__(self,name,height,weight):
        self.n = name
        self.h = height
        self.w = weight
    def speak(self):
        print('my name is %s, my height is %d cm, my weight is %.1fkg' % (self.n,self.h,self.w))
a = myclass('wanyu',175,70)       
a.speak()

my name is wanyu, my height is 175 cm, my weight is 70.0kg

二、继承

语法：class DerivedClassName(modname.BaseClassName):

继承本文件中的类，则模块名可省略，子类继承父类，父类也叫基类

有关父类中__init__的继承与否，又会分为三种形式：

1.子类需要自动调用父类的方法

子类不重写__init__()方法，实例化子类后，会自动调用父类的__init__()的方法

class people():
    name = ''    #规范
    height = 0
    weight = 0
    def __init__(self,n,h,w):
        self.name = n  # 对比上一段函数，详细的命名放在前面在调用时候更清晰的知道意思,上一段代码写的时候没考虑
        self.height = h
        self.weight = w
    def speak(self):
        print('my name is %s, my height is %d cm, my weight is %.1fkg' % (self.name,self.height,self.weight)) 
    
class student(people):
        pass  #调用父类的构造函数
a = student('wanyu',175,70)
a.speak()

my name is wanyu, my height is 175 cm, my weight is 70.0kg

2.子类不需要自动调用父类的方法

子类重写__init__()方法，实例化子类后，将不会自动调用父类的__init__()的方法

class people():
    name = ''    #规范
    height = 0
    weight = 0
    def __init__(self,n,h,w):
        self.name = n  
        self.height = h
        self.weight = w
    def speak(self):
        print('my name is %s, my height is %d cm, my weight is %.1fkg' % (self.name,self.height,self.weight)) 
    
class student(people):
    grade = ''
    def __init__(self,g):
        self.grade = g

    def speak_grade(self):           # 定义新函数
        print('i am in %d grade' % self.grade)
        
a = student(9)
a.speak_grade()

i am in 9 grade

3.子类重写init()方法又需要调用父类的方法

• 在子类定义__init__中加入：父类名称.__init__(self,arg1,arg2,...)
• 使用super关键词，在子类定义__init__中加入： super(student,self).__init__(arg1,arg2,...)

继承只能继承所有的父类init参数，不能继承部分

class people():
    name = ''    #规范
    height = 0
    weight = 0
    def __init__(self,n,h,w):
        self.name = n  
        self.height = h
        self.weight = w
    def speak(self):
        print('my name is %s, my height is %d cm, my weight is %.1fkg' % (self.name,self.height,self.weight)) 

class student(people):
    grade = ''
    
    def __init__(self,n,h,w,g):
        # super(student,self).__init__(n,h,w)
        people.__init__(self,n,h,w)  # 调用父类的init函数  这里必须传入people类的所有init参数
        self.grade = g
    def speak_grade(self):           # 定义新函数
        print('i am in %d grade' % self.grade)

a = student('wanyu',175,70,9)
a.speak()
a.speak_grade()

my name is wanyu, my height is 175 cm, my weight is 70.0kg
i am in 9 grade

如果只继承部分init参数，会报错

class people():
    name = ''    #规范
    height = 0
    weight = 0
    def __init__(self,n,h,w):
        self.name = n  
        self.height = h
        self.weight = w
    def speak(self):
        print('my name is %s, my height is %d cm, my weight is %.1fkg' % (self.name,self.height,self.weight)) 

class student(people):
    grade = ''
    
    def __init__(self,n,h,g):
        # super(student,self).__init__(n,h,w)
        people.__init__(self,n,h)  # 这里只传入people类的所部分init参数，少传入参数w，报错
        self.grade = g
    def speak_grade(self):           # 定义新函数
        print('i am in %d grade' % self.grade)

a = student('wanyu',175,9)

TypeError: init() missing 1 required positional argument: ‘w’

4.方法重写

如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写

class people():
    name = ''    #规范
    height = 0
    weight = 0
    def __init__(self,n,h,w):
        self.name = n
        self.height = h
        self.weight = w
    def speak(self):
        print('my name is %s, my height is %d cm, my weight is %.1fkg' % (self.name,self.height,self.weight)) 

class student(people):
    grade = ''
    def __init__(self,n,h,w,g):
        people.__init__(self,n,h,w)  # 调用父类的init函数
        self.grade = g
    def speak(self):  # 方法重写
        print('my name is %s, my height is %d cm, my weight is %.1fkg. And i am in %d grade' % (self.name,self.height,self.weight,self.grade))

a = student('wanyu',175,70,9)
a.speak()

my name is wanyu, my height is 175 cm, my weight is 70.0kg. And i am in 9 grade

5.多继承

子类可以继承多个父类，语法为class DerivedClassName(Base1, Base2, Base3):

需要注意圆括号中父类的顺序，若是父类中有相同的方法名，而在子类使用时未指定，python从左至右搜索 即方法在子类中未找到时，从左到右查找父类中是否包含方法

class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
               
class speaker():  # 另一个类，多重继承之前的准备
    topic = ''
    name = ''
    def __init__(self,n,t):
        self.name = n
        self.topic = t
    def speak(self):
        print("我叫 %s，我是一个演说家，我演讲的主题是 %s"%(self.name,self.topic))
        
class sample(speaker,people): #多重继承
    a =''
    def __init__(self,n,a,w,t):
        people.__init__(self,n,a,w)
        speaker.__init__(self,n,t)
 
test = sample("Tim",25,80,"Python")
test.speak()   #方法名同，默认调用的是在括号中排前地父类的方法

我叫 Tim，我是一个演说家，我演讲的主题是 Python

三、私有属性与私有方法

__private_attrs：私有变量，两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问

__private_method：两个下划线开头，声明该方法为私有方法，只能在类的内部调用 ，不能在类的外部调用

可以在间接使用，比如类的公用方法调用了私有属性，那么在外部调用公共方法时，就能调用私有属性

class JustCounter:
    __secretCount = 0  # 私有变量，两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问
    publicCount = 0    # 公开变量
 
    def count(self):
        self.__secretCount += 1  # 在类内部的方法中使用时 self.__private
        self.publicCount += 1
        print (self.__secretCount)

counter = JustCounter()
counter.count()  # print (self.__secretCount)执行，打印1
counter.count()  # print (self.__secretCount)执行，打印2
try:
    print (counter.publicCount)    # publicCount=2 ,打印2 
    print (counter.__secretCount)  # 报错，实例不能访问私有变量
except AttributeError:
    print('实例不能访问私有变量')

1
2
2
实例不能访问私有变量

class Site:
    def __init__(self, name, url):
        self.name = name       # public
        self.__url = url       # private
 
    def who(self):
        print('name  : ', self.name)
        print('url : ', self.__url)
 
    def __foo(self):          # 私有方法，两个下划线开头，声明该方法为私有方法，只能在类的内部调用 ，不能在类的外部调用
        print('这是私有方法')
 
    def foo(self):            # 公共方法
        print('这是公共方法')
        self.__foo()          # 内部调用私有方法 

x = Site('菜鸟教程', 'www.runoob.com')
try:
    x.who()        # 正常输出，因为这是公有方法，虽然其中调用了私有属性，但这是在类的内部调用的私有属性
    x.foo()        # 正常输出，因为其在类的内部调用的私有方法
    x.__foo()      # 报错
except AttributeError:
    print('AttributeError：类的外部不能调用类的私有方法')

name : 菜鸟教程
url : www.runoob.com
这是公共方法
这是私有方法
AttributeError：类的外部不能调用类的私有方法

四、类的专有方法

类一般有如下专有方法：

• __init__ ( self [,args...] ) 构造函数
• __del__( self ) 析构方法， 删除一个对象，简单的调用方法 : del obj
• __repr__( self ) 转化为供解释器读取的形式 简单的调用方法 : repr(obj)
• __str__( self ) 用于将值转化为适于人阅读的形式 简单的调用方法 : str(obj)
• __cmp__ ( self, x ) 对象比较 简单的调用方法 : cmp(obj, x)

所有专有方法中，__init__()要求无返回值，或者返回 None。而其他方法，如__str__()等，一般都是要返回值的。见运算符重载部分

class myclass():
    '这是帮助信息'
    def __init__(self):
        self.name = 'wanyu'

print(myclass.__doc__)

这是帮助信息

五、运算符重载

运算符重载是指通过使用类的专有方法对类的运算符进行重新的定义，这样在实例化时就会调用新的运算

class people:
    def __init__(self,name,age):
        self.name=name
        self.age=age
        
class god:
    def __init__(self,name,age):
        self.name=name
        self.age=age
        
    def __str__(self):   # 重载类的专有方法__str__()
        return '这个人的名字是%s,已经有%d岁了！'%(self.name,self.age)     # 原本此类实例化为a时，a只是一个people对象，现在可以打印字符了

a=people('孙悟空',999)
b=god('孙悟空',999)
print(a)  # 不重载
print(b)  # 重载

<__main__.people object at 0x000002119852BDD8>
这个人的名字是孙悟空,已经有999岁了！

类的专有方法中，也是存在默认优先级的，多个方法都有返回值，但一般优先取__str__()的返回值

class Vector:
    def __init__(self, a, b):
        self.a = a
        self.b = b
    def __repr__(self):
        return 'Vector (%d, %d)' % (self.b, self.a)
    def __str__(self):
        return 'Vector (%d, %d)' % (self.a, self.b)

v1 = Vector(2,10)
print (v1)  # 结果是 Vector(2,10)，说明是按照__str__的return语句
print (v1.__repr__())

Vector (2, 10)
Vector (10, 2)

更详细的说明举例：当解释器碰到 a+b 时，会做以下事情：
从 a 类中找__add__若返回值不是 NotImplemented, 则调用 a.__add__(b)
那么在下面的例子中，解释器碰到v1+v2，先去v1类中查找__add__，找到了之后，按照它的语句去执行。+这个运算执行完了，还得去优先级最高的__str__中找最终的返回形式

class Vector:
    def __init__(self, a, b):
        self.a = a
        self.b = b
 
    def __str__(self):  # 重新定义str属性
        return '想加这两个数：%d, %d' % (self.a, self.b)   
   
    def __add__(self,other): # 重新定义加运算
        return Vector(self.a + other.a, self.b + other.b)

v1 = Vector(2,10)
v2 = Vector(5,-2)
print(v1)
print(v2)
print (v1 + v2)

想加这两个数：2, 10
想加这两个数：5, -2
想加这两个数：7, 8

前面讲的是运算符重载的正向方法，还有反向方法。上面的例子中，若 a 类中没有__add__方法，则检查 b 有没有__radd__，这个就是反向方法。如果有，则调用 b.__radd__(a)，若没有，则返回 NotImplemented。

每个正规的运算符都有正向方法重载，反向方法重载。有一些有就地方法（即不返回新的对象，而是修改原本对象）

下面的例子中，重新定义radd，让字符实现”新的加法”

class Vector1:
    def __init__(self, a, b):
        self.a = a
        self.b = b 

class Vector2:
    def __init__(self, a, b):
        self.a = a
        self.b = b
    
    def __radd__(self,other): # 重新定义加运算
        return '想加这两组字符：（%s+%s）（%s+%s）' % (self.a,other.a,self.b,other.b)

v1 = Vector1('a','b')   # Vector1未定义add
v2 = Vector2('x','y')   # Vector1定义radd
print (v1 + v2)

想加这两组字符：（x+a）（y+b）

命名空间和作用域

一、命名空间

命名空间提供了在项目中避免名字冲突的一种方法。各个命名空间是独立的，没有任何关系的，所以一个命名空间中不能有重名，但不同的命名空间是可以重名而没有任何影响。

一般有三种命名空间：

• 内置名称（built-in names）， Python 语言内置的名称，比如函数名 abs、char 和异常名称 BaseException、Exception 等等。

• 全局名称（global names），模块中定义的名称，记录了模块的变量，包括函数、类、其它导入的模块、模块级的变量和常量。

• 局部名称（local names），函数中定义的名称，记录了函数的变量，包括函数的参数和局部定义的变量。（类中定义的也是）

  

Python 的命名空间查找顺序为：局部的命名空间去 -> 全局命名空间 -> 内置命名空间

二、作用域

在一个 python 程序中，直接访问一个变量，会从内到外依次访问所有的作用域直到找到，否则会报未定义的错误

变量的作用域决定了在哪一部分程序可以访问哪个特定的变量名称。

Python的作用域一共有4种：

• L（Local）：最内层，包含局部变量，比如一个函数/方法内部。
• E（Enclosing）：包含了非局部(non-local)也非全局(non-global)的变量。比如两个嵌套函数，一个函数（或类） A 里面又包含了一个函数 B ，那么对于 B 中的名称来说 A 中的作用域就为 nonlocal。
• G（Global）：当前脚本的最外层，比如当前模块的全局变量。
• B（Built-in）： 包含了内建的变量/关键字等。，最后被搜索

在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，再者去内置中找

g_count = 0  # 全局作用域
def outer():
    o_count = 1  # 闭包函数外的函数中
    def inner():
        i_count = 2  # 局部作用域

内置作用域是通过一个名为builtin的标准模块来实现的，但是这个变量名自身并没有放入内置作用域内，所以必须导入这个文件才能够使用它。在Python3.0中，可以使用以下的代码来查看到底预定义了哪些变量

import builtins
dir(builtins)

Python 中只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域，其它的代码块（如 if/elif/else/、try/except、for/while等）是不会引入新的作用域的，也就是说这些语句内定义的变量，外部也可以访问

if True:
    msg = 'I am from Runoob'
def test():
    msg_inner = 'I am from Runoob'
print(msg) # 外部能访问
print(msg_inner) # 外部不能访问

I am from Runoob

NameError: name ‘msg_inner’ is not defined

1. 全局变量和局部变量

定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。

局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。

total = 0 # 这是一个全局变量

def sum( arg1, arg2 ):
    #返回2个参数的和
    total = arg1 + arg2 # total在这里是局部变量.
    print ("函数内是局部变量 : ", total)
    return total
 
#调用sum函数
sum( 10, 20 )
print ("函数外是全局变量 : ", total)

函数内是局部变量 : 30
函数外是全局变量 : 0

2. global 和 nonlocal 关键字

global 可声明该变量为全局变量

total = 0 # 这是一个全局变量

def sum( arg1, arg2 ):
    global total  # 声明全局变量
    total = arg1 + arg2 
    print ("全局变量函数内部运算后为 : ", total)
    return total
 
#调用sum函数
sum( 10, 20 )
print ("函数外全局变量也随之改变 : ", total)

全局变量函数内部运算后为 : 30
函数外全局变量也随之改变 : 30

nonlocal声明该变量非局部变量（局部作用域），而是外层非全局作用域

num = 1     
def outer():
    num = 10
    def inner(): 
        num = 100      
        print(num)      # 打印100
    inner()
    print(num)          # 外层非全局的变量不会被修改
outer()
print(num) # 全局变量不会被修改

100
10
1

num = 1     
def outer():
    num = 10
    def inner():
        nonlocal num   # nonlocal关键字，声明这个num是外层非全局的变量，从这里看就是指这个num是上面的10，现在要把你赋值为100
        num = 100       
        print(num)      
    inner()
    print(num)          # 外层非全局的num会被修改
outer()
print(num) # 全局变量不会被修改

100
100
1