python相关知识点的记录

1.python中__new__和__init__的区别

__new__() 是在新式类中新出现的方法，它作用在构造方法建造实例之前，可以这么理解，在 Python 中存在于类里面的构造方法 __init__() 负责将类的实例化，而在 __init__() 启动之前，__new__() 决定是否要使用该 __init__() 方法，因为__new__() 可以调用其他类的构造方法或者直接返回别的对象来作为本类的实例。

如果将类比喻为工厂，那么__init__()方法则是该工厂的生产工人，__init__()方法接受的初始化参数则是生产所需原料，__init__()方法会按照方法中的语句负责将原料加工成实例以供工厂出货。而__new__()则是生产部经理，__new__()方法可以决定是否将原料提供给该生产部工人，同时它还决定着出货产品是否为该生产部的产品，因为这名经理可以借该工厂的名义向客户出售完全不是该工厂的产品。

__new__() 方法的特性：

• __new__() 方法是在类准备将自身实例化时调用。
• __new__() 方法始终都是类的静态方法，即使没有被加上静态方法装饰器。
• 类的实例化和它的构造方法通常都是这个样子

class MyClass(object):
    def __init__(self, *args, **kwargs):
        ...

# 实例化
myclass = MyClass(*args, **kwargs)

正如以上所示，一个类可以有多个位置参数和多个命名参数，而在实例化开始之后，在调用 __init__() 方法之前，Python 首先调用 __new__() 方法：

def __new__(cls, *args, **kwargs):
    ...

第一个参数cls是当前正在实例化的类。

• 如果要得到当前类的实例，应当在当前类中的 __new__() 方法语句中调用当前类的父类的 __new__() 方法。

　　例如，如果当前类是直接继承自 object，那当前类的 __new__() 方法返回的对象应该为：

def __new__(cls, *args, **kwargs):
    ...
    return object.__new__(cls)

注意：

　　事实上如果（新式）类中没有重写__new__()方法，即在定义新式类时没有重新定义__new__()时，Python默认是调用该类的直接父类的__new__()方法来构造该类的实例，如果该类的父类也没有重写__new__()，那么将一直按此规矩追溯至object的__new__()方法，因为object是所有新式类的基类。

　　而如果新式类中重写了__new__()方法，那么你可以自由选择任意一个的其他的新式类（必定要是新式类，只有新式类必定都有__new__()，因为所有新式类都是object的后代，而经典类则没有__new__()方法）的__new__()方法来制造实例，包括这个新式类的所有前代类和后代类，只要它们不会造成递归死循环。具体看以下代码解释：

class Foo(object):
    def __init__(self, *args, **kwargs):
        ...
    def __new__(cls, *args, **kwargs):
        return object.__new__(cls, *args, **kwargs)    

# 以上return等同于 
# return object.__new__(Foo, *args, **kwargs)
# return Stranger.__new__(cls, *args, **kwargs)
# return Child.__new__(cls, *args, **kwargs)

class Child(Foo):
    def __new__(cls, *args, **kwargs):
        return object.__new__(cls, *args, **kwargs)
# 如果Child中没有定义__new__()方法，那么会自动调用其父类的__new__()方法来制造实例，即 Foo.__new__(cls, *args, **kwargs)。
# 在任何新式类的__new__()方法，不能调用自身的__new__()来制造实例，因为这会造成死循环。因此必须避免类似以下的写法：
# 在Foo中避免：return Foo.__new__(cls, *args, **kwargs)或return cls.__new__(cls, *args, **kwargs)。Child同理。
# 使用object或者没有血缘关系的新式类的__new__()是安全的，但是如果是在有继承关系的两个类之间，应避免互调造成死循环，
#例如:(Foo)return Child.__new__(cls), (Child)return Foo.__new__(cls)。
class Stranger(object):
    ...
# 在制造Stranger实例时，会自动调用 object.__new__(cls)

通常来说，新式类开始实例化时，__new__()方法会返回cls（cls指代当前类）的实例，然后该类的__init__()方法作为构造方法会接收这个实例（即self）作为自己的第一个参数，然后依次传入__new__()方法中接收的位置参数和命名参数。

注意：如果__new__()没有返回cls（即当前类）的实例，那么当前类的__init__()方法是不会被调用的。如果__new__()返回其他类（新式类或经典类均可）的实例，那么只会调用被返回的那个类的构造方法。

class Foo(object):
    def __init__(self, *args, **kwargs):
        ...
    def __new__(cls, *args, **kwargs):
        return object.__new__(Stranger, *args, **kwargs)  

class Stranger(object):
    ...

foo = Foo()
print type(foo)    

# 打印的结果显示foo其实是Stranger类的实例。

# 因此可以这么描述__new__()和__init__()的区别，在新式类中__new__()才是真正的实例化方法，
#为类提供外壳制造出实例框架，然后调用该框架内的构造方法__init__()使其丰满。
# 如果以建房子做比喻，__new__()方法负责开发地皮，打下地基，并将原料存放在工地。
#而__init__()方法负责从工地取材料建造出地皮开发招标书中规定的大楼，
#__init__()负责大楼的细节设计，建造，装修使其可交付给客户。

面向对象编程中，实例化基本遵循创建实例对象、初始化实例对象、最后返回实例对象这么一个过程。

Python 中的 __new__ 方法负责创建一个实例对象，__init__ 方法负责将该实例对象进行初始化。

2.python是怎样进行内存操作的,还有C和C++呢

python话说会自己管理内存，实际上，对于占用很大内存的对象，并不会马上释放。举例，a=range(10000*10000)，会发现内存飙升一个多G，del a 或者a=[]都不能将内存降下来。

del 可以删除多个变量，del a,b,c,d
办法：
import gc （garbage collector）
del a
gc.collect()

马上内存就释放了。

在IPython中用run运行程序时，都是在独立的运行环境中运行，结束之后才将程序运行环境中的结果复制到IPython环境中，因此不会有变量被重复调用的问题。

如果你是指在自己的程序中想删除所有全局变量的话，可以自己编写一个clear函数，通过globals()获取全局变量然后将其中不需要的内容删除，例如下面的程序保留函数，类，模块，删除所有其它全局变量：

def clear():

    for key, value in globals().items():

        if callable(value) or value.__class__.__name__ == "module":

            continue

        del globals()[key]

不过程序中应该避免这种对全局变量的依赖。你也可以在IPython下用此函数清空全局变量。

内存管理机制

先从较浅的层面来说，Python的内存管理机制可以从三个方面来讲

（1）垃圾回收

（2）引用计数

（3）内存池机制

一、垃圾回收：

python不像C++，Java等语言一样，他们可以不用事先声明变量类型而直接对变量进行赋值。对Python语言来讲，对象的类型和内存都是在运行时确定的。这也是为什么我们称Python语言为动态类型的原因（这里我们把动态类型可以简单的归结为对变量内存地址的分配是在运行时自动判断变量类型并对变量进行赋值）。

1、当内存中有不再使用的部分时，垃圾收集器就会把他们清理掉。它会去检查那些引用计数为0的对象，然后清除其在内存的空间。当然除了引用计数为0的会被清除，还有一种情况也会被垃圾收集器清掉：当两个对象相互引用时，他们本身其他的引用已经为0了。

2、垃圾回收机制还有一个循环垃圾回收器, 确保释放循环引用对象(a引用b, b引用a, 导致其引用计数永远不为0)。

在Python中，许多时候申请的内存都是小块的内存，这些小块内存在申请后，很快又会被释放，由于这些内存的申请并不是为了创建对象，所以并没有对象一级的内存池机制。这就意味着Python在运行期间会大量地执行malloc和free的操作，频繁地在用户态和核心态之间进行切换，这将严重影响Python的执行效率。为了加速Python的执行效率，Python引入了一个内存池机制，用于管理对小块内存的申请和释放。

垃圾回收

1、当内存中有不再使用的部分时，垃圾收集器就会把他们清理掉。它会去检查那些引用计数为0的对象，然后清除其在内存的空间。当然除了引用计数为0的会被清除，还有一种情况也会被垃圾收集器清掉：当两个对象相互引用时，他们本身其他的引用已经为0了。

2、垃圾回收机制还有一个循环垃圾回收器, 确保释放循环引用对象(a引用b, b引用a, 导致其引用计数永远不为0)。

 

二.引用计数

Python采用了类似Windows内核对象一样的方式来对内存进行管理。每一个对象，都维护这一个对指向该对对象的引用的计数。如图所示（图片来自Python核心编程）

我们首先创建了一个对象3.14， 然后将这个浮点数对象的引用赋值给x，因为x是第一个引用，因此，这个浮点数对象的引用计数为1. 语句y = x创建了一个指向同一个对象的引用别名y，我们发现，并没有为Y创建一个新的对象，而是将Y也指向了x指向的浮点数对象，使其引用计数为2.

我们可以很容易就证明上述的观点：

变量a 和 变量b的id一致(我们可以将id值想象为C中变量的指针).

我们援引另一个网址的图片来说明问题：对于C语言来讲，我们创建一个变量A时就会为为该变量申请一个内存空间，并将变量值 放入该空间中,当将该变量赋给另一变量B时会为B申请一个新的内存空间，并将变量值放入到B的内存空间中，这也是为什么A和B的指针不一致的原因。如图：

我们援引另一个网址的图片来说明问题：对于C语言来讲，我们创建一个变量A时就会为为该变量申请一个内存空间，并将变量值 放入该空间中,当将该变量赋给另一变量B时会为B申请一个新的内存空间，并将变量值放入到B的内存空间中，这也是为什么A和B的指针不一致的原因。如图：

而Python的情况却不一样，实际上，Python的处理方式和Javascript有点类似，如图所示，变量更像是附在对象上的标签(和引用的定义类似)。当变量被绑定在一个对象上的时候，该变量的引用计数就是1，(还有另外一些情况也会导致变量引用计数的增加),系统会自动维护这些标签，并定时扫描，当某标签的引用计数变为0的时候，该对就会被回收。

引用计数增加

1.对象被创建：x=4

2.另外的别人被创建：y=x

3.被作为参数传递给函数：foo(x)

4.作为容器对象的一个元素：a=[1,x,'33']

引用计数减少

1.一个本地引用离开了它的作用域。比如上面的foo(x)函数结束时，x指向的对象引用减1。

2.对象的别名被显式的销毁：del x ；或者del y

3.对象的一个别名被赋值给其他对象：x=789

4.对象从一个窗口对象中移除：myList.remove(x)

5.窗口对象本身被销毁：del myList，或者窗口对象本身离开了作用域。

 

三.内存池机制

Python的内存机制以金字塔行，-1，-2层主要有操作系统进行操作，

　　第0层是C中的malloc，free等内存分配和释放函数进行操作；

　　第1层和第2层是内存池，有Python的接口函数PyMem_Malloc函数实现，当对象小于256K时有该层直接分配内存；

　　第3层是最上层，也就是我们对Python对象的直接操作；

在 C 中如果频繁的调用 malloc 与 free 时,是会产生性能问题的.再加上频繁的分配与释放小块的内存会产生内存碎片. Python 在这里主要干的工作有:

　　如果请求分配的内存在1~256字节之间就使用自己的内存管理系统,否则直接使用 malloc.

　　这里还是会调用 malloc 分配内存,但每次会分配一块大小为256k的大块内存.

经由内存池登记的内存到最后还是会回收到内存池,并不会调用 C 的 free 释放掉.以便下次使用.对于简单的Python对象，例如数值、字符串，元组（tuple不允许被更改)采用的是复制的方式(深拷贝?)，也就是说当将另一个变量B赋值给变量A时，虽然A和B的内存空间仍然相同，但当A的值发生变化时，会重新给A分配空间，A和B的地址变得不再相同

而对于像字典(dict)，列表(List)等，改变一个就会引起另一个的改变，也称之为浅拷贝

Python深入06 Python的内存管理

C++内存管理学习笔记

3.python中的协程，进程和线程

python（40）- 进程、线程、协程及IO模型

python进程、线程、协程

协程

4.C/C++的内存使用的区别

C++内存管理学习笔记

5.引用和指针的区别

为什么C/C++语言使用指针？

答案：

①一方面，每一种编程语言都使用指针。不止C/C++使用指针。

每一种编程语言都使用指针。C++将指针暴露给了用户(程序员)，而Java和C#等语言则将指针隐藏起来了。

“Everything uses pointers. C++ just exposes them rather than hiding them,”

It's easier to give someone an address to your home than to give a copy of your home to everyone.

②另一方面

使用指针的优点和必要性：

• 指针能够有效的表示数据结构；
• 能动态分配内存，实现内存的自由管理；
• 能较方便的使用字符串；
• 便捷高效地使用数组
• 指针直接与数据的储存地址有关，比如：值传递不如地址传递高效，因为值传递先从实参的地址中取出值，再赋值给形参代入函数计算；而指针则把形参的地址直接指向实参地址，使用时直接取出数据，效率提高，特别在频繁赋值等情况下（注意：形参的改变会影响实参的值！）

引用和指针有什么区别？

浅谈C/C++引用和指针的联系和区别

本质：引用是别名，指针是地址，具体的：

指针指向一块内存，它的内容是所指内存的地址；而引用则是某块内存的别名，引用不改变指向。

①从现象上看，指针在运行时可以改变其所指向的值，而引用一旦和某个对象绑定后就不再改变。这句话可以理解为：指针可以被重新赋值以指向另一个不同的对象。但是引用则总是指向在初始化时被指定的对象，以后不能改变，但是指定的对象其内容可以改变。
②从内存分配上看，程序为指针变量分配内存区域，而不为引用分配内存区域，因为引用声明时必须初始化，从而指向一个已经存在的对象。引用不能指向空值。

注：标准没有规定引用要不要占用内存，也没有规定引用具体要怎么实现，具体随编译器 http://bbs.youkuaiyun.com/topics/320095541

③ 从编译上看，程序在编译时分别将指针和引用添加到 符号表上，符号表上记录的是变量名及变量所对应地址。指针变量在符号表上对应的地址值为指针变量的地址值，而 引用在符号表上对应的地址值为 引用对象的地址值。符号表生成后就不会再改，因此指针可以改变指向的对象（指针变量中的值可以改），而引用对象不能改。这是使用指针不安全而使用引用安全的主要原因。从某种意义上来说 引用可以被认为是不能改变的指针。
④不存在指向空值的引用这个事实，意味着使用引用的代码效率比使用指针的要高。因为在使用引用之前不需要测试它的合法性。相反，指针则应该总是被测试，防止其为空。
⑤理论上，对于指针的级数没有限制，但是引用只能是一级。如下：
  int** p1;         // 合法。指向指针的指针
  int*& p2;         // 合法。指向指针的引用
  int&* p3;         // 非法。指向引用的指针是非法的
  int&& p4;         // 非法。指向引用的引用是非法的
  注意上述读法是 从左到右。 

看const和*谁在前谁在后

char* const pc(指针是一个常量)指针常量，必须得初始化,说明指针变量(pc)不允许修改。如同次指针指向一个地址该地址不能被修改，但是该地址里的内容可以被修改(*pc)

const char* pc(指向常量的指针变量)常量指针，是一个指针，指针pc可以修改，但是*pc不可以修改，所以不能进行左值操作，即不能进行修改

 常量指针定义"const int* pointer=&a"告诉编译器，*pointer是常量，不能将*pointer作为左值进行操作。

char const* pc(指向常量的指针)常量指针和上面第二个是等价的  

常量指针和指针常量的区别

6.c++中const关键字与static关键字

c++的const总结(转)

7.python中is和==区别

1.== 是比较两个对象的内容是否相等，即两个对象的“值“”是否相等，不管两者在内存中的引用地址是否一样。

2.is 比较的是两个实例对象是不是完全相同，它们是不是同一个对象，占用的内存地址是否相同。即is比较两个条件：1.内容相同。2.内存中地址相同

3.使用is注意python对于小整数使用对象池存储问题[-5,256]小整数部分会在内存中直接创建一份

4.使用is注意python关于字符串的intern机制存储 

8.python中的闭包问题

python中的闭包从表现形式上定义（解释）为：如果在一个内部函数里，对在外部作用域（但不是在全局作用域）的变量进行引用，那么内部函数就被认为是闭包(closure).