Python新式类 单例模式与作用域(四)详解编程语言

#新式类 
class C(object): 
    pass 
#经典类 
class B: 
    pass

 
1. __new__，__init__方法 
这两个方法是用来创建object的子类对象，静态方法__new__()用来创建类的实例，然后再调用 
__init__()来初始化实例。 
  
2. __delattr__, __getattribute__, __setattr__方法 
对象使用这些方法来处理属性的访问 
  
3. __hash__, __repr__, __str__方法 
print(someobj)会调用someobj.__str__()， 如果__str__没有定义，则会调用someobj.__repr__()， 
  
__str__()和__repr__()的区别： 
默认的实现是没有任何作用的 
__repr__的目标是对象信息唯一性 
__str__的目标是对象信息的可读性 
容器对象的__str__一般使用的是对象元素的__repr__ 
如果重新定义了__repr__，而没有定义__str__，则默认调用__str__时，调用的是__repr__ 
也就是说好的编程习惯是每一个类都需要重写一个__repr__方法，用于提供对象的可读信息， 
而重写__str__方法是可选的。实现__str__方法，一般是需要更加好看的打印效果，比如你要制作 
一个报表的时候等。

也是可以通过类和它的实例进行调用，不过它是有默认第一个参数，叫做是类对象，一般被 
命名为cls，当然你也可以命名为其它名字，这样就你可以调用类对象的一些操作， 
代码如下，[email protected]：

c = C.__new__(C, 2) 
if isinstance(c, C): 
    C.__init__(c, 23)#__init__第一个参数要为实例对象 
     
class Singleton(object): 
    _singletons = {} 
    def __new__(cls): 
        if not cls._singletons.has_key(cls):            #若还没有任何实例 
            cls._singletons[cls] = object.__new__(cls)  #生成一个实例 
        return cls._singletons[cls]                     #返回这个实例 
    a = Singleton() 
    b = Singleton() 
    id(a)  #35966666 
    id(b)  #35966666        
 #注:单例模式 ,两个实例指向同一个内存地址 

class A(object): 
    def __init__(self): 
        self.x = 1 
        self.y = 2 
        __slots__ = ('x','y') 
a = A() 
a.z = 3 
a.u = 4  #都会报错,不能对实例新增属性,__dict__字典集没有任何改变 
 
class A(object): 
    def __init__(self): 
        self.x = 1 
        self.y = 2 
a = A() 
a.x = 3  #不会报错,在__dict__字典字典集会新增'x'属性

1.  当一个类的父类没有定义__slots__属性，父类中的__dict__属性总是可以访问到的，所以只在子 
类中定义__slots__属性，而不在父类中定义是没有意义的。  
2. 如果定义了__slots__属性，还是想在之后添加新的变量，就需要把'__dict__'字符串添加到__slots__的 
元组里。 
3. 定义了__slots__属性，还会消失的一个属性是__weakref__，这样就不支持实例的weak reference， 
如果还是想用这个功能，同样，可以把'__weakref__'字符串添加到元组里。 
4. __slots__功能是通过descriptor实现的，会为每一个变量创建一个descriptor。 
5. __slots__的功能只影响定义它的类，因此，子类需要重新定义__slots__才能有它的功能。

class Singleton(object): 
    def __new__(cls, *args, **kw): 
        if not hasattr(cls, '_instance'): #如果该类是否含有实例 
            orig = super(Singleton, cls) 
            cls._instance = orig.__new__(cls, *args, **kw) 
        return cls._instance 
 
class MyClass(Singleton): 
    a = 1 
 
#如果 cls._instance 为 None 则创建实例，否则直接返回 cls._instance。

class Borg(object): 
    _state = {} 
    def __new__(cls, *args, **kw): 
        ob = super(Borg, cls).__new__(cls, *args, **kw) 
        ob.__dict__ = cls._state 
        return ob 
 
class MyClass2(Borg): 
    a = 1

def singleton(cls): 
    instances = {} 
    def getinstance(*args, **kw): 
        if cls not in instances: 
            instances[cls] = cls(*args, **kw) 
        return instances[cls] 
    return getinstance 
 
@singleton 
class MyClass: 
  ...

# mysingleton.py 
class My_Singleton(object): 
    def foo(self): 
        pass 
my_singleton = My_Singleton() 
 
# to use 
from mysingleton import my_singleton #将类进行导入使用 
my_singleton.foo()

#块级作用域 
if 1 == 1: 
    name = "lol" 
print(name)  
 
for i in range(10): 
    age = i 
print(age) 
 
#输出: 
C:/Users/L/PycharmProjects/s14/preview/Day8/作用域/test.py 
lol 
9

#局部作用域 
def  func(): 
    name = "lol" 
func()  #调用函数 
print(name) 
#输出 
Traceback (most recent call last): 
  File "C:/Users/L/PycharmProjects/s14/preview/Day8/作用域/test.py", line 23, in <module> 
    print(name) 
NameError: name 'name' is not defined

#作用域链 
name = "张三" 
def func1(): 
    name = "李四" 
    def func2(): 
        name = "王五" 
        print(name) 
    func2() 
func1() 
#输出 
"王五"

x = int(2.9)  # 内建作用域 
num = 0  # 全局作用域 
def outer(): 
    num2 = 1  # 闭包函数外的函数中 
    def inner(): 
        num3 = 2  # 局部作用域

a = 100 
 
def demo(): 
    global a 
    a = 123 
    print(a) 
demo() 
print(a) 
 
#运行结果是 
123 
123