8. Python3源码—Code对象与pyc文件

简介: # 8.1. Python程序的执行过程 Python解释器在执行任何一个Python程序文件时,首先进行的动作都是先对文件中的Python源代码进行编译,编译的主要结果是产生一组Python的byte code(字节码),然后将编译的结果交给Python的虚拟机(Virtual Machine),由虚拟机按照顺序一条一条地执行字节码,从而完成对Python程序的执行动作。 对于Pytho

8.1. Python程序的执行过程

Python解释器在执行任何一个Python程序文件时,首先进行的动作都是先对文件中的Python源代码进行编译,编译的主要结果是产生一组Python的byte code(字节码),然后将编译的结果交给Python的虚拟机(Virtual Machine),由虚拟机按照顺序一条一条地执行字节码,从而完成对Python程序的执行动作。

对于Python编译器来说,PyCodeObject对象才是其真正的编译结果,而pyc文件只是这个对象在硬盘上的表现形式,它们实际上是Python对源文件编译的结果的两种不同存在方式。

在程序运行期间,编译结果存在于内存的PyCodeObject对象中;而Python结束运行后,编译结果又被保存到了pyc文件中。当下一次运行相同的程序时,Python会根据pyc文件中记录的编译结果直接建立内存中的PyCodeObject对象,而不用再次对源文件进行编译了。

对整体流程认识清晰后完全可以写一个工具,将基于Python3.7生成的pyc文件解析出来,pyc文件的内容用json格式组织一下如下图:

写工具的目的只是为了更加理解整个流程。实际上使用Python的dis模块可以输出更为详细清晰的内容,如下图:

8.2. PyCodeObject源码

// code.h
typedef struct {
    PyObject_HEAD
    int co_argcount;
    int co_kwonlyargcount;
    int co_nlocals;
    int co_stacksize; 
    int co_flags; 
    int co_firstlineno;
    PyObject *co_code;
    PyObject *co_consts;
    PyObject *co_names;
    PyObject *co_varnames;
    PyObject *co_freevars;
    PyObject *co_cellvars;
    Py_ssize_t *co_cell2arg;
    PyObject *co_filename;      
    PyObject *co_name;          
    PyObject *co_lnotab;        
    void *co_zombieframe; 
    PyObject *co_weakreflist;
    void *co_extra;
} PyCodeObject;
  • Code Block:
    Python编译器在对Python源代码进行编译的时候,对于代码中的一个Code Block,会创建一个PyCodeObject对象与这段代码对应。当进入一个新的名字空间,或者说作用域时,就算是进入了一个新的Code Block了。比如下面的代码有三个code block:一个对应整个test.py文件,一个对应class A,一个对应def Fun。
# test.py
class A:
    pass

def Fun():
    pass

a = A()
Fun()
  • 名字空间:
    名字空间是符号的上下文环境,符号的含义取决于名字空间。更具体地说,一个变量名对应的变量值是什么,在Python中,这并不是确定的,而是需要通过名字空间来决定。一个Code Block,对应着一个名字空间,它会对应一个PyCodeObject对象。
  • Python中的code对象:
    在Python中,有与C语言下的PyCodeObject对象对应的对象——code对象,这个对象是对C语言下的PyCodeObject对象的一个简单包装,通过code对象,我们可以访问PyCodeObject对象中的各个域。

8.3. 生成pyc文件

# pyc_generator.py
import imp
import sys

def generate_pyc(name):
    fp, pathname, description = imp.find_module(name)
    try:
        imp.load_module(name, fp, pathname, description)
    finally:
        if fp:
            fp.close()

if __name__ == '__main__':
    generate_pyc(sys.argv[1])

命令行中输入如下命令会生成pyc文件:

>>> ./python3.7 pyc_generator.py test

8.3.1. 生成PyCodeObject对象和pyc文件的C流程

从上面的pyc_generator文件中的imp.load_module开始,函数调用顺序如下:

// imp.py
load_module
=>load_source

// _bootstrap.py[1]
=>_load
=>_load_unlocked

// _bootstrap_external.py
=> exec_module
=> get_code

get_code方法中调用source_to_code方法生成PyCodeObject对象,调用_code_to_timestamp_pyc将PyCodeObject转为二进制数据,调用_cache_bytecode方法将二进制数据写入文件。

值得注意的是真正的Python不会调用_bootstrap.py的_load方法(上面函数调用顺序中的[1]),在Lib/importlib/__init__.py中:

# __init__.py
try:
    import _frozen_importlib as _bootstrap
except ImportError:
    from . import _bootstrap
    _bootstrap._setup(sys, _imp)
else:
    # do sth

try:
    import _frozen_importlib_external as _bootstrap_external
except ImportError:
    from . import _bootstrap_external
    _bootstrap_external._setup(_bootstrap)
    _bootstrap._bootstrap_external = _bootstrap_external
else:
   # do sth

可以看到实际上调用的是_frozen_importlib中的_load方法,而不是_bootstrap中的_load方法,此lib的内容在Python/importlib.h中被定义:

不太明白为什么要这么处理,但是分析整体流程时将此处换成了_bootstrap,便于阅读源码。

下面会详细分析生成PyCodeObject对象,将PyCodeObject转为二进制数据和将二进制数据写入文件的流程。

8.3.2. 生成PyCodeObject对象源码

// _bootstrap_external.py
source_to_code

// _bootstrap.py
=>_call_with_frames_removed

// bltinmodule.c
=> builtin_compile_impl

builtin_compile_impl的C源码如下:

// bltinmodule.c
static PyObject *
builtin_compile_impl(PyObject *module, PyObject *source, PyObject *filename, const char *mode, int flags, int dont_inherit, int optimize)
{
    PyObject *source_copy;
    const char *str;
    int compile_mode = -1;
    int is_ast;
    PyCompilerFlags cf;
    int start[] = {Py_file_input, Py_eval_input, Py_single_input};
    PyObject *result;

    cf.cf_flags = flags | PyCF_SOURCE_IS_UTF8;

    if (flags &
        ~(PyCF_MASK | PyCF_MASK_OBSOLETE | PyCF_DONT_IMPLY_DEDENT | PyCF_ONLY_AST))
    {
        PyErr_SetString(PyExc_ValueError,
                        "compile(): unrecognised flags");
        goto error;
    }
    /* XXX Warn if (supplied_flags & PyCF_MASK_OBSOLETE) != 0? */

    if (optimize < -1 || optimize > 2) {
        PyErr_SetString(PyExc_ValueError,
                        "compile(): invalid optimize value");
        goto error;
    }

    if (!dont_inherit) {
        PyEval_MergeCompilerFlags(&cf);
    }

    if (strcmp(mode, "exec") == 0)
        compile_mode = 0;
    else if (strcmp(mode, "eval") == 0)
        compile_mode = 1;
    else if (strcmp(mode, "single") == 0)
        compile_mode = 2;
    else {
        PyErr_SetString(PyExc_ValueError,
                        "compile() mode must be 'exec', 'eval' or 'single'");
        goto error;
    }

    is_ast = PyAST_Check(source);
    if (is_ast == -1)
        goto error;
    if (is_ast) {
        // do sth.
    }

    str = source_as_string(source, "compile", "string, bytes or AST", &cf, &source_copy);
    if (str == NULL)
        goto error;

    result = Py_CompileStringObject(str, filename, start[compile_mode], &cf, optimize);
    Py_XDECREF(source_copy);
    goto finally;

error:
    result = NULL;
finally:
    Py_DECREF(filename);
    return result;
}

其中:

  • 调用source_as_string方法将上面的test.py源码加载进内存:
  • 调用Py_CompileStringObject方法生成PyCodeObject对象:
// pythonrun.c
PyObject *
Py_CompileStringObject(const char *str, PyObject *filename, int start,
                       PyCompilerFlags *flags, int optimize)
{
    PyCodeObject *co;
    mod_ty mod;
    PyArena *arena = PyArena_New();
    if (arena == NULL)
        return NULL;

    mod = PyParser_ASTFromStringObject(str, filename, start, flags, arena);
    if (mod == NULL) {
        PyArena_Free(arena);
        return NULL;
    }
    if (flags && (flags->cf_flags & PyCF_ONLY_AST)) {
        PyObject *result = PyAST_mod2obj(mod);
        PyArena_Free(arena);
        return result;
    }
    co = PyAST_CompileObject(mod, filename, flags, optimize, arena);
    PyArena_Free(arena);
    return (PyObject *)co;
}

调用PyParser_ASTFromStringObject方法生成语法树,调用PyAST_CompileObject方法生成PyCodeObject对象。此处不对语法解析和编译做深入分析。

8.3.3. 将PyCodeObject对象转为二进制数据

_code_to_timestamp_pyc方法负责将PyCodeObject对象转为二进制数据,源码如下:

// _bootstrap_external.py
def _code_to_timestamp_pyc(code, mtime=0, source_size=0):
    "Produce the data for a timestamp-based pyc."
    data = bytearray(MAGIC_NUMBER)
    data.extend(_w_long(0))
    data.extend(_w_long(mtime))
    data.extend(_w_long(source_size))
    data.extend(marshal.dumps(code))
    return data

可以看出一个pyc文件包含几部分内容:

  • MAGIC_NUMBER:不同版本的Python实现都会定义不同的MAGIC_NUMBER,比如Python 3.7a0 3392,Python 3.6a0 3360,防止加载不兼容的pyc文件;
  • 0:不清楚是用作什么;
  • mtime:py文件创建或最近一次修改的时间信息,如果修改时间没有改变则不需要转为二进制保存,即不需要修改pyc文件;
  • source_size:源码大小;
  • marshal.dumps(code):PyCodeObject对象的二进制流;

marshal.dumps调用marshal_dumps_impl方法:

// marshal.c
static PyObject *
marshal_dumps_impl(PyObject *module, PyObject *value, int version)
/*[clinic end generated code: output=9c200f98d7256cad input=a2139ea8608e9b27]*/
{
    return PyMarshal_WriteObjectToString(value, version);
}

PyMarshal_WriteObjectToString源码为:

// marshal.c
PyObject *
PyMarshal_WriteObjectToString(PyObject *x, int version)
{
    WFILE wf;

    memset(&wf, 0, sizeof(wf));
    wf.str = PyBytes_FromStringAndSize((char *)NULL, 50);
    if (wf.str == NULL)
        return NULL;
    wf.ptr = wf.buf = PyBytes_AS_STRING((PyBytesObject *)wf.str);
    wf.end = wf.ptr + PyBytes_Size(wf.str);
    wf.error = WFERR_OK;
    wf.version = version;
    if (w_init_refs(&wf, version)) {
        Py_DECREF(wf.str);
        return NULL;
    }
    w_object(x, &wf);
    w_clear_refs(&wf);
    if (wf.str != NULL) {
        char *base = PyBytes_AS_STRING((PyBytesObject *)wf.str);
        if (wf.ptr - base > PY_SSIZE_T_MAX) {
            Py_DECREF(wf.str);
            PyErr_SetString(PyExc_OverflowError,
                            "too much marshal data for a bytes object");
            return NULL;
        }
        if (_PyBytes_Resize(&wf.str, (Py_ssize_t)(wf.ptr - base)) < 0)
            return NULL;
    }
    if (wf.error != WFERR_OK) {
        Py_XDECREF(wf.str);
        if (wf.error == WFERR_NOMEMORY)
            PyErr_NoMemory();
        else
            PyErr_SetString(PyExc_ValueError,
              (wf.error==WFERR_UNMARSHALLABLE)?"unmarshallable object"
               :"object too deeply nested to marshal");
        return NULL;
    }
    return wf.str;

此处最关键的方法为w_object,该方法会调用w_complex_object,真正将PyCodeObject对象转为二进制数据就在w_complex_object方法中:

// marshal.c
static void
w_complex_object(PyObject *v, char flag, WFILE *p)
{
    // do sth.
    else if (PyCode_Check(v)) {
        PyCodeObject *co = (PyCodeObject *)v;
        W_TYPE(TYPE_CODE, p);
        w_long(co->co_argcount, p);
        w_long(co->co_kwonlyargcount, p);
        w_long(co->co_nlocals, p);
        w_long(co->co_stacksize, p);
        w_long(co->co_flags, p);
        w_object(co->co_code, p);
        w_object(co->co_consts, p);
        w_object(co->co_names, p);
        w_object(co->co_varnames, p);
        w_object(co->co_freevars, p);
        w_object(co->co_cellvars, p);
        w_object(co->co_filename, p);
        w_object(co->co_name, p);
        w_long(co->co_firstlineno, p);
        w_object(co->co_lnotab, p);
    }
    // do sth.
}

可以看出:

  • PyCodeObject对象的类型是TYPE_CODE,8.2节中的test.py文件会生成三个PyCodeObject对象,它们之间的关系为一个PyCodeObject对象嵌套两个PyCodeObject对象;
  • co_argcount、co_kwonlyargcount等字段是通过调用w_long(调用w_byte方法写入四个字节),co_code、co_consts 等字段是通过调用w_object(实际上是调用w_long、w_string等方法),最终转为二进制数据的。这些字段的具体含义之后再进行深入分析;
  • 需要注意的是有一个特殊的类型:TYPE_REF,可以通过该类型节约存储空间。以co_filename为例,这个字段的含义为py文件的完整路径,下面为test.py生成的pyc文件中co_filename字段的值:
// class A
"co_filename": {
    "type": "unicode",
    "size": 49,
    "value": "/Users/l.wang/Documents/pythonindepth/bin/test.py"
}

// def Fun
"co_filename": {
    "type": "ref",
    "ref": 6
}

// test.py
"co_filename": {
    "type": "ref",
    "ref": 6
}

这是通过w_ref方法实现的,w_ref的源码如下。其中有一个hash表,该表的key为对象的地址,value为index,如果表中存在相同地址的对象,则写入TYPE_REF类型和index,从而节省空间。

// marshal.c
static int
w_ref(PyObject *v, char *flag, WFILE *p)
{
    _Py_hashtable_entry_t *entry;
    int w;

    if (p->version < 3 || p->hashtable == NULL) {
        return 0; /* not writing object references */
    }

    /* if it has only one reference, it definitely isn't shared */
    if (Py_REFCNT(v) == 1) {
        return 0;
    }

    entry = _Py_HASHTABLE_GET_ENTRY(p->hashtable, v);
    if (entry != NULL) {
        /* write the reference index to the stream */
        _Py_HASHTABLE_ENTRY_READ_DATA(p->hashtable, entry, w);
        /* we don't store "long" indices in the dict */
        assert(0 <= w && w <= 0x7fffffff);
        w_byte(TYPE_REF, p);
        w_long(w, p);
        return 1;
    } else {
        size_t s = p->hashtable->entries;
        /* we don't support long indices */
        if (s >= 0x7fffffff) {
            PyErr_SetString(PyExc_ValueError, "too many objects");
            goto err;
        }
        w = (int)s;
        Py_INCREF(v);
        if (_Py_HASHTABLE_SET(p->hashtable, v, w) < 0) {
            Py_DECREF(v);
            goto err;
        }
        *flag |= FLAG_REF;
        return 0;
    }
err:
    p->error = WFERR_UNMARSHALLABLE;
    return 1;
}

这个过程的逆序实现过程如下。如果flag不为0,则向list表中增加实际的值。如果类型为TYPE_REF,则根据读取的index从list表中获取真实的值。

static PyObject *
r_object(RFILE *p)
{
    PyObject *v, *v2;
    Py_ssize_t idx = 0;
    long i, n;
    int type, code = r_byte(p);
    int flag, is_interned = 0;
    PyObject *retval = NULL;

    if (code == EOF) {
        PyErr_SetString(PyExc_EOFError,
                        "EOF read where object expected");
        return NULL;
    }

    p->depth++;

    if (p->depth > MAX_MARSHAL_STACK_DEPTH) {
        p->depth--;
        PyErr_SetString(PyExc_ValueError, "recursion limit exceeded");
        return NULL;
    }

    flag = code & FLAG_REF;
    type = code & ~FLAG_REF;

#define R_REF(O) do{\
    if (flag) \
        O = r_ref(O, flag, p);\
} while (0)

    switch (type) {
      // do sth.
      case TYPE_REF:
        n = r_long(p);
        if (n < 0 || n >= PyList_GET_SIZE(p->refs)) {
            if (n == -1 && PyErr_Occurred())
                break;
            PyErr_SetString(PyExc_ValueError, "bad marshal data (invalid reference)");
            break;
        }
        v = PyList_GET_ITEM(p->refs, n);
        if (v == Py_None) {
            PyErr_SetString(PyExc_ValueError, "bad marshal data (invalid reference)");
            break;
        }
        Py_INCREF(v);
        retval = v;
        break;
      // do sth.
      }
}

这里存在一个问题,为什么w_ref没有像r_object中根据flag的值决定哪个字段写入hash表中,目前没有想明白。

8.3.4. 将二进制数据写入文件

_cache_bytecode方法负责将将二进制数据写入文件,源码如下:

# _bootstrap_external.py    
def _cache_bytecode(self, source_path, bytecode_path, data):
    # Adapt between the two APIs
    mode = _calc_mode(source_path)
    return self.set_data(bytecode_path, data, _mode=mode)

set_data方法源码如下:

    def set_data(self, path, data, *, _mode=0o666):
        """Write bytes data to a file."""
        parent, filename = _path_split(path)
        path_parts = []
        # Figure out what directories are missing.
        while parent and not _path_isdir(parent):
            parent, part = _path_split(parent)
            path_parts.append(part)
        # Create needed directories.
        for part in reversed(path_parts):
            parent = _path_join(parent, part)
            try:
                _os.mkdir(parent)
            except FileExistsError:
                # Probably another Python process already created the dir.
                continue
            except OSError as exc:
                # Could be a permission error, read-only filesystem: just forget
                # about writing the data.
                _bootstrap._verbose_message('could not create {!r}: {!r}',
                                            parent, exc)
                return
        try:
            _write_atomic(path, data, _mode)
            _bootstrap._verbose_message('created {!r}', path)
        except OSError as exc:
            # Same as above: just don't write the bytecode.
            _bootstrap._verbose_message('could not create {!r}: {!r}', path,
                                        exc)

写入文件的关键方法为_write_atomic,源码如下。该方法采用写入临时文件,而后重命名的方式,用于保证要么有异常从而不会生成文件,要么无异常生成指定名称的文件。

def _write_atomic(path, data, mode=0o666):
    """Best-effort function to write data to a path atomically.
    Be prepared to handle a FileExistsError if concurrent writing of the
    temporary file is attempted."""
    # id() is used to generate a pseudo-random filename.
    path_tmp = '{}.{}'.format(path, id(path))
    fd = _os.open(path_tmp,
                  _os.O_EXCL | _os.O_CREAT | _os.O_WRONLY, mode & 0o666)
    try:
        # We first write data to a temporary file, and then use os.replace() to
        # perform an atomic rename.
        with _io.FileIO(fd, 'wb') as file:
            file.write(data)
        _os.replace(path_tmp, path)
    except OSError:
        try:
            _os.unlink(path_tmp)
        except OSError:
            pass
        raise

8.4. 参考

  • Python源码剖析

8.5. 附录

分析清楚pyc文件生成的流程后,就可以实现8.1节中提到的工具,工具源码如下:

# -*- coding:utf-8 -*-
import json
import datetime
import sys

FLAG_REF = ord('\x80')
TYPE_CODE = ord('c')
TYPE_STRING = ord('s')
TYPE_SMALL_TUPLE = ord(')')
TYPE_INT = ord('i')
TYPE_SHORT_ASCII = ord('z')
TYPE_SHORT_ASCII_INTERNED = ord('Z')
TYPE_REF = ord('r')
TYPE_NONE = ord('N')

REFS_HASH = {}

def parse_code(fp):
    code = int.from_bytes(fp.read(1), 'little')
    code_type = code & ~FLAG_REF
    code_flag = code & FLAG_REF

    idx = len(REFS_HASH)
    if code_flag:
        REFS_HASH[idx] = None

    code_dict = {}
    if code_type == TYPE_CODE:
        code_dict['type'] = 'code'
        code_dict['co_argcount'] = int.from_bytes(fp.read(4), 'little')
        code_dict['co_kwonlyargcount'] = int.from_bytes(fp.read(4), 'little')
        code_dict['co_nlocals'] = int.from_bytes(fp.read(4), 'little')
        code_dict['co_stacksize'] = int.from_bytes(fp.read(4), 'little')
        code_dict['co_flags'] = int.from_bytes(fp.read(4), 'little')
        code_dict['co_code'] = parse_code(fp)
        code_dict['co_consts'] = parse_code(fp)
        code_dict['co_names'] = parse_code(fp)
        code_dict['co_varnames'] = parse_code(fp)
        code_dict['co_freevars'] = parse_code(fp)
        code_dict['co_cellvars']  = parse_code(fp)
        code_dict['co_filename']  = parse_code(fp)
        code_dict['co_name']  = parse_code(fp)
        code_dict['co_firstlineno']  = int.from_bytes(fp.read(4), 'little')
        code_dict['co_lnotab']  = parse_code(fp)
    elif code_type == TYPE_STRING:
        code_dict['type'] = 'string'

        length = int.from_bytes(fp.read(4), 'little')
        code_dict['length'] = length

        # todo
        value = fp.read(length)
        code_dict['value'] = str(value)

        if code_flag:
            REFS_HASH[idx] = code_dict['value']
    elif code_type == TYPE_SMALL_TUPLE:
        code_dict['type'] = 'tuple'

        size = int.from_bytes(fp.read(1), 'little')
        code_dict['size'] = size

        items = []
        for _ in range(size):
            items.append(parse_code(fp))
        code_dict['items'] = items

        if code_flag:
            REFS_HASH[idx] = code_dict['items']
    elif code_type == TYPE_INT:
        code_dict['type'] = 'long'

        value = int.from_bytes(fp.read(4), 'little')
        code_dict['value'] = value

        if code_flag:
            REFS_HASH[idx] = code_dict['value']
    elif code_type == TYPE_SHORT_ASCII:
        code_dict['type'] = 'unicode'

        size = int.from_bytes(fp.read(1), 'little')
        code_dict['size'] = size

        code_dict['value'] = fp.read(size).decode()

        if code_flag:
            REFS_HASH[idx] = code_dict['value']
    elif code_type == TYPE_SHORT_ASCII_INTERNED:
        code_dict['type'] = 'unicode'

        size = int.from_bytes(fp.read(1), 'little')
        code_dict['size'] = size

        code_dict['value'] = fp.read(size).decode()

        if code_flag:
            REFS_HASH[idx] = code_dict['value']
    elif code_type == TYPE_REF:
        code_dict['type'] = 'ref'
        code_dict['ref'] = int.from_bytes(fp.read(4), 'little')
        code_dict['value'] = REFS_HASH[code_dict['ref']]
    elif code_type == TYPE_NONE:
        code_dict['type'] = 'none'
    else:
        print(code_type)

    return code_dict

def parse_pyc(file_name):
    pyc_dict = {}

    with open(file_name, 'rb') as fp:
        magic_number = int.from_bytes(fp.read(2), 'little')
        if magic_number >= 3390 and magic_number <= 3392:
            pyc_dict['version'] = 'Python 3.7'
        else:
            print('only support Python 3.7')
            exit(0)
        
        _ = fp.read(2)
        _ = fp.read(4)

        timestamp = int.from_bytes(fp.read(4), 'little')
        pyc_dict['modified'] = str(datetime.datetime.fromtimestamp(timestamp))

        source_size = int.from_bytes(fp.read(4), 'little')
        pyc_dict['size'] = source_size
        pyc_dict['code'] = parse_code(fp)

    return(pyc_dict)

if __name__ == '__main__':
    file_name = sys.argv[1]
    print(json.dumps(parse_pyc(file_name), indent=2))

分析test.py后结果为:

实现了对TYPE_REF的处理,下面的value值并不在真实的二进制中包含:

"co_filename": {
    "type": "ref",
    "ref": 6,
    "value": "/Users/l.wang/Documents/pythonindepth/bin/test.py"
}

目前没有对指令集做处理。

目录
相关文章
|
2月前
|
安全 Linux 数据安全/隐私保护
python知识点100篇系列(15)-加密python源代码为pyd文件
【10月更文挑战第5天】为了保护Python源码不被查看,可将其编译成二进制文件(Windows下为.pyd,Linux下为.so)。以Python3.8为例,通过Cython工具,先写好Python代码并加入`# cython: language_level=3`指令,安装easycython库后,使用`easycython *.py`命令编译源文件,最终生成.pyd文件供直接导入使用。
python知识点100篇系列(15)-加密python源代码为pyd文件
|
29天前
|
开发者 Python
Python中__init__.py文件的作用
`__init__.py`文件在Python包管理中扮演着重要角色,通过标识目录为包、初始化包、控制导入行为、支持递归包结构以及定义包的命名空间,`__init__.py`文件为组织和管理Python代码提供了强大支持。理解并正确使用 `__init__.py`文件,可以帮助开发者更好地组织代码,提高代码的可维护性和可读性。
29 2
|
2月前
|
Java Python
> python知识点100篇系列(19)-使用python下载文件的几种方式
【10月更文挑战第7天】本文介绍了使用Python下载文件的五种方法,包括使用requests、wget、线程池、urllib3和asyncio模块。每种方法适用于不同的场景,如单文件下载、多文件并发下载等,提供了丰富的选择。
|
2月前
|
数据安全/隐私保护 流计算 开发者
python知识点100篇系列(18)-解析m3u8文件的下载视频
【10月更文挑战第6天】m3u8是苹果公司推出的一种视频播放标准,采用UTF-8编码,主要用于记录视频的网络地址。HLS(Http Live Streaming)是苹果公司提出的一种基于HTTP的流媒体传输协议,通过m3u8索引文件按序访问ts文件,实现音视频播放。本文介绍了如何通过浏览器找到m3u8文件,解析m3u8文件获取ts文件地址,下载ts文件并解密(如有必要),最后使用ffmpeg合并ts文件为mp4文件。
|
2月前
|
JSON 数据格式 Python
Python实用记录(十四):python统计某个单词在TXT/JSON文件中出现的次数
这篇文章介绍了一个Python脚本,用于统计TXT或JSON文件中特定单词的出现次数。它包含两个函数,分别处理文本和JSON文件,并通过命令行参数接收文件路径、目标单词和文件格式。文章还提供了代码逻辑的解释和示例用法。
50 0
Python实用记录(十四):python统计某个单词在TXT/JSON文件中出现的次数
|
15天前
|
存储 数据挖掘 开发者
Python编程入门:从零到英雄
在这篇文章中,我们将一起踏上Python编程的奇幻之旅。无论你是编程新手,还是希望拓展技能的开发者,本教程都将为你提供一条清晰的道路,引导你从基础语法走向实际应用。通过精心设计的代码示例和练习,你将学会如何用Python解决实际问题,并准备好迎接更复杂的编程挑战。让我们一起探索这个强大的语言,开启你的编程生涯吧!
|
21天前
|
机器学习/深度学习 人工智能 TensorFlow
人工智能浪潮下的自我修养:从Python编程入门到深度学习实践
【10月更文挑战第39天】本文旨在为初学者提供一条清晰的道路,从Python基础语法的掌握到深度学习领域的探索。我们将通过简明扼要的语言和实际代码示例,引导读者逐步构建起对人工智能技术的理解和应用能力。文章不仅涵盖Python编程的基础,还将深入探讨深度学习的核心概念、工具和实战技巧,帮助读者在AI的浪潮中找到自己的位置。
|
21天前
|
机器学习/深度学习 数据挖掘 Python
Python编程入门——从零开始构建你的第一个程序
【10月更文挑战第39天】本文将带你走进Python的世界,通过简单易懂的语言和实际的代码示例,让你快速掌握Python的基础语法。无论你是编程新手还是想学习新语言的老手,这篇文章都能为你提供有价值的信息。我们将从变量、数据类型、控制结构等基本概念入手,逐步过渡到函数、模块等高级特性,最后通过一个综合示例来巩固所学知识。让我们一起开启Python编程之旅吧!
|
21天前
|
存储 Python
Python编程入门:打造你的第一个程序
【10月更文挑战第39天】在数字时代的浪潮中,掌握编程技能如同掌握了一门新时代的语言。本文将引导你步入Python编程的奇妙世界,从零基础出发,一步步构建你的第一个程序。我们将探索编程的基本概念,通过简单示例理解变量、数据类型和控制结构,最终实现一个简单的猜数字游戏。这不仅是一段代码的旅程,更是逻辑思维和问题解决能力的锻炼之旅。准备好了吗?让我们开始吧!
|
8天前
|
Python
Python编程入门:从零开始的代码旅程
本文是一篇针对Python编程初学者的入门指南,将介绍Python的基本语法、数据类型、控制结构以及函数等概念。文章旨在帮助读者快速掌握Python编程的基础知识,并能够编写简单的Python程序。通过本文的学习,读者将能够理解Python代码的基本结构和逻辑,为进一步深入学习打下坚实的基础。