2024年python源码解读_python代码解释，2024年最新Python面试题及答案2024

2301_76190672

于 2024-05-04 08:25:10 发布

阅读量707

点赞数 23

分类专栏：程序员文章标签： python 开发语言

本文链接：https://blog.csdn.net/2301_76190672/article/details/138434214

版权

程序员专栏收录该内容

142 篇文章 0 订阅

订阅专栏

（1）Python所有方向的学习路线（新版）

这是我花了几天的时间去把Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。

最近我才对这些路线做了一下新的更新，知识体系更全面了。

在这里插入图片描述

（2）Python学习视频

包含了Python入门、爬虫、数据分析和web开发的学习视频，总共100多个，虽然没有那么全面，但是对于入门来说是没问题的，学完这些之后，你可以按照我上面的学习路线去网上找其他的知识资源进行进阶。

在这里插入图片描述

（3）100多个练手项目

我们在看视频学习的时候，不能光动眼动脑不动手，比较科学的学习方法是在理解之后运用它们，这时候练手项目就很适合了，只是里面的项目比较多，水平也是参差不齐，大家可以挑自己能做的项目去练练。

在这里插入图片描述

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

PyObject_HEAD

} PyObject;


每一个python对象除了`PyObject`之外还需要额外的内存，`PyObject`定义了必须要的数据比如`PyIntObject`

// intobject.h
typedef struct _object{
PyObject_HEAD
long ob_ival;
w} PyIntObject;


对于变长对象python有新的抽象

// object.h
#define PyObject_VAR_HEAD
PyObject_HEAD
long ob_size; /一般指容器内元素数量
typedef struct _object{
PyObject_VAR_HEAD
} PyVarObject;


### 类型对象


PyObject占用内存大小是对象的元信息，元信息和对象所属类型密切相关

// object.h
typedef struct _typeobject{
PyObject_VAR_HEAD
char *tp_name; //print 信息"."
int tp_basicsize, item_size; //为了分配内存大小
destructor tp_dealloc;
printfunc tp_print;
hashfunc tp_hash;
ternaryfunc tp_call;
…
} PyTypeObject;


#### 对象的创建



> 
> python对象的创建主要有两种方式
> 
> 
> * C API(对于python的内建对象, 直接分配内存)
> 	+ 泛型API AOL
> 	+ 类型相关API COL
> * 类型对象创建(用户自定义对象，因为不可能事先提供这类C方法)，大致流程如下  
>  会调用`ob_type` 所指定的`PyTyoeObject`类的`tp_new`方法，如果`tp_new`是NULL会追溯`tp_base`所指向的`ob_type`的`tp_new`方法，最终定位的`tp_new`（因为所有类继承object会有保底的tp\_new方法）负责内存的申请(类似c++的new)  
>  之后通过`tp_init`初始化(类似c++的构造函数)
> 
> 
> 


#### 类型的类型


PyTypeObect 实际也是有ob\_type属性的，其为PyType\_Type(即type, 负责PyTypeObect的创建，即metaclass)  
 下图以int 为例说明了这些关系，也就是所知的python里面class,object,type的关系  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/20210322094914489.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NTgxOTYx,size_16,color_FFFFFF,t_70)


## Python中的整数对象


在Python的所有对象中，整数对象最简单且使用最频繁，故我们首先学习整数对象。关于整数对象的源码在`Objects.intobjects.c`中，整数对象是通过`PyIntObject`对象来完成的，在创建一个`PyIntObject`对象之后，就再也不能改变该对象的值了。定义为:

typedef struct {
prObject_HEAD;
long ob_ival;
}PyIntObject;


主要是`PyIntObject`和`PyInt_Type`，其他和普遍的PyObject, PyTyoeObject没什么，值得关注的有


* python2中稍小一点的数直接用C语言中的long去存储，稍大一点的数（超过long的承受范围）会使用python的long对象去存储，而python3不会作区分，统一用longObect去存储，实现用到了`柔性数组`，感兴趣可以查一下
* 小整形数组的内存池和大整形对象的内存链的维护,避免频繁malloc


在Python中，整数的使用是很广泛的，对应的，它的创建和释放也将会很频繁，那么如何设计一个高效的机制，使得整数对象的使用不会成为Python的瓶颈？在Python中是使用整数对象的缓冲池机制来解决此问题。使用缓冲池机制，那意味着运行时的整数对象并不是一个个独立的，而是相关联结成一个庞大的整数对象系统了。


### 小整形对象

// [intobject.c]
#ifndef NSMALLPOSINTS
#define NSMALLPOSINTS 257
#endif
#ifndef NSMALLNEGINTS
#define NSMALLNEGINTS 5
#endif
#if NSMALLNEGINTS + NSMALLPOSINTS > 0
/* References to small integers are saved in this array so that they
can be shared.
The integers that are saved are those in the range
-NSMALLNEGINTS (inclusive) to NSMALLPOSINTS (not inclusive).
*/
static PyIntObject *small_ints[NSMALLNEGINTS + NSMALLPOSINTS];
#endif


在实际的编程中，数值比较小的整数，比如1,2,等等，这些在程序中是频繁使用到的，而Python中，所有的对象都存活在系统堆上，也就是说，如果没有特殊的机制，对于小整数对象，Python将一次次的malloc在堆上申请空间，然后free，这样的操作将大大降低了运行效率。


那么如何解决呢？Python中，对小整数对象使用了对象池技术。  
 那么又有一个问题了，Python中的大对象和小对象如何区分呢？嗯，Python中确实有一种方法，用户可以调整大整数和小整数的分界点，从而动态的确定小整数的对象池中应该有多少个小整数对象，但是调整的方法只有自己修改源代码，然后重新编译。


### 大整数对象


对于小整数，小整数对象池中完全的缓存PyIntObject对象，对于其它对象，Python将提供一块内存空间，这些内存空间将由这些大整数轮流使用，也就是谁需要的时候谁使用。


比如，在Python中有一个PyIntBlock结构，维护了一块内存，其中保存了一些PyIntObject对象，维护对象的个数也可以做动态的调整。在Python运行的某个时刻，有一些内存已经被使用，而另一些内存则处于空闲状态，而这些空闲的内存必须组织起来，那样，当Python需要新的内存时，才能快速的获得所需的内存，在Python中使用一个单向链表(free\_list）来管理所有的空闲内存。

// [intobject.c]
#define BLOCK_SIZE 1000 /* 1K less typical malloc overhead */
#define BHEAD_SIZE 8 /* Enough for a 64-bit pointer */
#define N_INTOBJECTS ((BLOCK_SIZE - BHEAD_SIZE) / sizeof(PyIntObject))

struct _intblock {
struct _intblock *next;
PyIntObject objects[N_INTOBJECTS];
};

typedef struct _intblock PyIntBlock;

static PyIntBlock *block_list = NULL;
static PyIntObject *free_list = NULL;


**创建**  
 如果小整数对象池机制被激活，则尝试使用小整数对象池；如果不能使用小整数对象池，则使用通用整数对象池。  
 可以创建int的代码理解这两块的使用

// [intobject.c]
PyObject *
PyInt_FromLong(long ival)
{
register PyIntObject *v;
#if NSMALLNEGINTS + NSMALLPOSINTS > 0 /* 尝试使用小整数对象池 */
if (-NSMALLNEGINTS <= ival && ival < NSMALLPOSINTS) {
v = small_ints[ival + NSMALLNEGINTS];
Py_INCREF(v);
return (PyObject *) v;
}
#endif
if (free_list == NULL) {
if ((free_list = fill_free_list()) == NULL)
return NULL;
}
/* Inline PyObject_New */
v = free_list;
free_list = (PyIntObject *)v->ob_type; /* 有一个看似不合适但是比较方便的地方，freelist会通过 ob_type存放可用空间的pyObject的地址(类似链表的next)，而不是 PyTyoeObject */
(void)PyObject_INIT(v, &PyInt_Type);
v->ob_ival = ival;
return (PyObject *) v;
}


下面是关于freelist的申请，和freelist和block\_list的维护有关的代码

// [intobject.c]
static PyIntObject *
fill_free_list(void)
{
PyIntObject *p, *q;
/* 申请大小为sizeof（PyIntBlock）的内存空间，并链接到已有的block list中 */
p = (PyIntObject *) PyMem_MALLOC(sizeof(PyIntBlock));
((PyIntBlock *)p)->next = block_list;
block_list = (PyIntBlock *)p;
/* 将PyIntBlock中的PyIntObject数组——objects转变成单向链表*/
p = &((PyIntBlock *)p)->objects[0];
q = p + N_INTOBJECTS;
while (–q > p)
q->ob_type = (struct _typeobject *)(q-1); /* 上一段代码中所提到的不合适的地方
Py_TYPE(q) = NULL;
return p + N_INTOBJECTS - 1;
}


这样，freelist会指向可以分配内存的地址，但是如果由之前分配的PyIntObject被释放了，freelist需要将被释放的地址重新使用才可以，这个是通过PyIntObect的析构函数来实现的

// [intobject.c]
static void
int_dealloc(PyIntObject *v)
{
if (PyInt_CheckExact(v)) { // 如果不是派生类这么执行，保证freelist的完整性
v->ob_type = (struct _typeobject *)free_list;
free_list = v;
}
else // 如果是派生类，则执行正常的析构流程
v->ob_type->tp_free((PyObject *)v);
}


## Python中的字符串对象


### PyStringObject和PyString\_Type

//[stringobject.h]
typedef struct{
PyObject_VAR_HEAD
long ob_shash;
int ob_sstate;
char ob_sval[1];
} PyStringObject;
//[stringobject.c]
PyTypeObject PyString_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0,
“str”,
sizeof(PyStringObject), // basic size
sizeof(char), //itemsize
// …
}



> 
> * `ob_sval`指的是一段长度为ob\_size+1个字节的内存，必须满足ob\_sval[ob\_size] == ‘\0’
> * `ob_shash`是`缓存`的该对象的`hash`值
> * `ob_sstate`标记了该对象是否已经经过intern机制的处理
> 
> 
> 


### 创建PyStringObject对象

//[stringobject.c]
// 从原生字符串创建
PyObject* PyString_FromString(const char *str) {
register size_t size;
register PyStringObejct *op;

size = strlen(str);
if (size > PY_SSIZE_T_MAX) {
    return NULL;
}
if (size == 0 && (op = nullstring )!= NULL) {  // intern机制： 和下面的一个分支都是为了缓存特定的对象，一个是空字符串，一个是单个字符字符串，第一次使用后会存在，之后不必再次创建PyObject对象（这些对象之前都被初始化成了NULL）
    return (PyObject \*) op;
}
if (size == 1 && (op = characters[\*str & UCHAR_MAX]) != NULL) {
    return (PyObject \*) op;
}
op = (PyStringObject \*)PyObject\_MALLOC(sizeof(PyStringObject) + size); // 加上包含'\0'的额外内存
PyObject\_INIT\_VAR(ob, &PyString_Type, size);
op->ob_shash=-1;
op->ob_sstate=SSTATE_NOT_INTERNED;
memcpy(op->ob_sval, str, size+1);
if (size==0) {
    PyObject \*t = (PyObject \*) op;
    PyString\_InternInPlace(&t);
    op = (PyStringObject \*) t;
    nullstring = op;
} else if (size == 1) {
    PyObject \*t = (PyObject \*) op;
    PyString\_InternInPlace(&t);
    op = (PyStringObject \*) t;
    characters[\*str & UCHAR_MAX] = op;
}
return (PyObejct \*) op;

}


![在这里插入图片描述](https://img-blog.csdnimg.cn/20210323105537555.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NTgxOTYx,size_16,color_FFFFFF,t_70)


### 字符串对象的intern机制

//[stringobject.c]
void PyString_InternInPlace(PyObject **p) {
register PyStringObject *s = (PyStringObject *)(*p);
PyObject *t;
if (!PyString_CheckExact(s)) return;
if (PyString_CHECK_INTERNED(s)) return;
if (interned == NULL) {
interned = PyDict_New();
}
t = PyDict_GetItem(interned, (PyObject *) s);
if (t) {
Py_INCREF(t);
Py_DECREF(*p);
*p = t;
return;
}
PyDict_SetItem(interned, (PyObject *)s, (PyObject *)s);
s->ob_refcnt -= 2; // 减去key 和 value的引用
PyString_CHECK_INTERNED(s) = SSTATE_INTERNED_MORTAL; // 当析构时会根据这个属性，做出在interned中删除的操作
}



> 
> characters 是静态变量static PyStringObject \*characters[UCHAR\_MAX+1]; 开始都是NULL指针  
>  = join字符串效率比 + 好， 因为PyStringObject 是不可变对象（varObject只是因为是变长的），两者申请内存不同  
>  join 计算所有 PyStringObject 的size 得出需要分配的内存，一次分配  
>  = 而concat(+) 需要分配n-1次内存，并且伴有析构
> 
> 
> 


## python中的List对象

// [listobject.h]
typedef struct{
PyObject_VAR_HEAD
PyObject **ob_item; // list[0] 实际就是ob_item[0]
int allocated; // 类似cap, 而ob_size是当前的元素数量
} PyListObject;


实际的操作和c++ vector类似略。有一个比较特别的是free\_list的维护

// [listobject.c]
// list只有这一个创建入口

最后

不知道你们用的什么环境，我一般都是用的Python3.6环境和pycharm解释器，没有软件，或者没有资料，没人解答问题，都可以免费领取（包括今天的代码），过几天我还会做个视频教程出来，有需要也可以领取~

给大家准备的学习资料包括但不限于：

Python 环境、pycharm编辑器/永久激活/翻译插件

python 零基础视频教程

Python 界面开发实战教程

Python 爬虫实战教程

Python 数据分析实战教程

python 游戏开发实战教程

Python 电子书100本

Python 学习路线规划

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

2301_76190672

关注

23
点赞
踩
25

收藏

觉得还不错? 一键收藏
0
评论
2024年python源码解读_python代码解释，2024年最新Python面试题及答案2024

不知道你们用的什么环境，我一般都是用的Python3.6环境和pycharm解释器，没有软件，或者没有资料，没人解答问题，都可以免费领取（包括今天的代码），过几天我还会做个视频教程出来，有需要也可以领取~给大家准备的学习资料包括但不限于：Python 环境、pycharm编辑器/永久激活/翻译插件python 零基础视频教程Python 界面开发实战教程Python 爬虫实战教程Python 数据分析实战教程python 游戏开发实战教程Python 电子书100本。
复制链接

扫一扫