精华内容
下载资源
问答
  • builtins
    2021-11-19 10:04:02

    1./: 本身不是一个具体的参数,只是限制前面的参数必须以位置参数传入:positional_only

      *: 本身也不是一个具体的参数,只是限制后面的参数必须以关键字的形式传参 sort(/, *, key=None, reverse=False)

    def special_arg(arg1, arg2, /):
        print(arg1, arg2)
    # 【×】positional-only arguments passed as keyword arguments: 'arg2'
    
    special_arg(4, 5)
    
    
    def special_arg2(arg1 , arg2, *, arg3=None, arg4=None):
        print(arg1, arg2, arg3, arg4)
    # special_arg2() takes 2 positional arguments but 4 were given
    
    special_arg2(1, 2, arg3=3, arg4=4)

    2.嵌套函数

    def outer():  # outer = function obj
        def inner():  # inner = function obj1
            print("this is inner function")
        print("this is outer function")
        inner()
    #     return inner
    #
    # inner = outer()
    # inner()
    
    # test = outer
    # test()

    3.递归函数:自己调用自己

    # 1+2+3+4+5+6+7...100=5050
    # func(n) => n = 100
    # 1+2+3+4+5+6+7...100
    # func(n-1) =>
    # 1+2+3+4+5+6+7...+99
    # func(n) => func(n-1) + n
    
    # n * (n + 1) / 2 = 5050
    def func_sum(n):
        if n == 1:
            return 1
        else:
            return func_sum(n-1) + n
    print(func_sum(100))
    
    # 1 3 5 7 + 99
    # func(n-2)+n

    4.其他用法

    id()

    print()

    sum()

    open()

    ord()

    chr()

    len()

    都是函数,从哪里来的

    Python解释器带了一个自带模块:builtins.py(可以在里面找没见过的函数) Built-in functions, exceptions, and other objects.

    内建的函数,异常,其他对象

    no imports: 无需导入直接使用

    all() =>bool()

    any() 所有都为。。

    callable() 是否可调用的

    abs() absolute:绝对值

    dir() 展示一个对象中所有的属性(变量和函数)的名字

    divmod() 取商和取余

    更多相关内容
  • 例子获取当前Node.js版本的核心模块列表: var builtins = require ( 'builtins' ) ( )assert ( builtins . indexOf ( 'http' ) > - 1 ) 获取特定Node.js版本的核心模块列表: var builtins = require ( 'builtins' ...
  • compiler-builtins 将compiler-rt内在函数移植到Rust 参见 。 什么时候以及如何使用此板条箱? 如果您使用的目标没有通过rustup可用的std二进制发行版(这可能意味着您是在自己构建核心板条箱),并且需要编译器-...
  • python库。资源全名:dolmen.builtins-0.3.tar.gz
  • __builtins__ 是内建模块__builtin__中的对象,使用Python中的内建函数时会通过__builtins__引导,这里我们就来深入解析Python中的__builtins__内建对象,需要的朋友可以参考下
  • node-browser-builtins, 在 node.js 模块中,浏览器altenatives生成 浏览器 altenatives,内置 node.js-模块这是 browserify 模块所使用的。 最初这些文件在 node-browser-resolve 中,但在v1.0.1中消失了,这破坏了...
  • z-builtins 的插件,JavaScript promises的实用程序库。 z-builtins插件直接在Z Promise上公开所有本机JavaScript方法。安装最简单的入门方法是使用现成的Z包,例如 。 它包括这个插件。 如果您想自己进行设置,则有...
  • 文章目录1 名称空间(Namespace)2 内建函数3 内建名称空间与 \_\_builtins__4 \_\_builtins\_\_ 与 \_\_builtin\_\_ 的简单区别5 \_\_builtins\_\_ 与 \_\_builtin\_\_ 的深入区别5.1 在主模块 \_\_main\_\_ 中5.2 ...

    这里以 Python 2.7为例,探讨 __builtin__ 模块和 __builtins__ 模块的区别和联系。

    在 Python3 中,__builtin__ 模块被命名为 builtins

    1 名称空间(Namespace)

    名称空间指的是名称(标识符)到对象的映射,在一个正常的Python程序的执行过程中,至少存在两个名称空间:

    • 内建名称空间
    • 全局名称空间

    如果定义了函数,则还会有局部名称空间,全局名称空间一般由在程序的全局变量和它们对应的映射对象组成,而局部名称空间则在函数内部由函数局部变量和它们对应的映射对象组成,这里关键的是内建名称空间,它到底是怎么产生的?

    2 内建函数

    在启动 Python 解释器之后,即使没有创建任何的变量或者函数,还是会有许多函数可以使用,比如:

    >>> abs(-1)
    1
    >>> max(1,2)
    2
    >>> abs
    <built-in function abs>
    >>> max
    <built-in function max>
    

    这些函数是内建函数,因为它们不需要我们程序员作任何定义,在启动 Python 解释器的时候,就已经导入到内存当中供我们使用

    3 内建名称空间与 __builtins__

    那么内建函数也是函数,虽然我们没有人为导入这些,但是正如前面所说,在启动 Python 解释器的时候,会自动帮我们导入,那么内建函数存在于哪里呢?

    其实准确地来说,是 Python 解释器在启动的时候会首先加载内建名称空间,内建名称空间有许多名字到对象之间映射,而这些名字其实就是内建函数的名称,对象就是这些内建函数本身(注意区分函数名称和函数对象的区别)。这些名称空间由 __builtins__ 模块中的名字构成:

    >>>  dir ()
    [ '__builtins__' ,  '__doc__' ,  '__name__' ,  '__package__' ]
    

    可以看到有一个 __builtins__ 的模块名称,这个模块本身定义了一个名称空间,即内建名称空间,我们不妨 dir 一下:

    在这里插入图片描述

    会看到我们熟悉的内建函数的名称,如 list、dict 等,当然还有一些异常和其它属性。

    4 __builtins__ 与 __builtin__ 的简单区别

    既然内建名称空间由 __builtins__ 模块中的名称空间定义,那么是不是也意味着内建名称空间中所对应的这些函数也是在 __builtins__ 模块中实现的呢?

    显然不是的,我们可以在解释器中直接输入 __builtins__:

    >>> __builtins__
    <module '__builtin__' (built-in)>
    

    结果中可以看到,__builtins__ 其实还是引用了 __builtin__ 模块而已,这说明真正的模块是 __builtin__,也就是说,前面提到的内建函数其实是在内建模块 __builtin__ 中定义的,即 __builtins__ 模块包含内建名称空间中内建名字的集合(因为它引用或者说指向了 __builtin__ 模块),而真正的内建函数、异常和属性来自 __builtin__ 模块。也就是说,在Python中,其实真正是只有 __builtin__ 这个模块,并不存在 __builtins__ 这个模块:

    >>> import __builtin__
    >>> import __builtins__
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    ImportError: No module named __builtins__
    

    可以看到,导入 __builtin__ 模块并没有问题,但导入 __builtins__ 模块时就会提示不存在,这充分说明了前面的结论,现在再次总结如下:

    在 Python 中并没有 __builtins__这个模块,只有 __builtin__ 模块,__builtins__ 模块只是在启动 Python 解释器时,解释器为我们自动创建的一个到 __builtin__ 模块的引用

    至于这种引用到底是怎么样,可以看下面的深入区别。

    5 __builtins__ 与 __builtin__ 的深入区别

    上面只是大概说了下 __builtins__ 与 __builtin__ 两个模块的简单区分而已,其实深究下去,要分成下面所提及的两种情况。

    5.1 在主模块 __main__ 中

    其实我们在使用 Python 交互器的时候就是在主模块中进行操作,可以做如下验证:

    >>> print __name__
    __main__
    

    在这种情况,__builtins__ 与 __builtin__ 是完全一样的,它们指向的都是__builtin__ 这个内建模块

    >>> import __builtin__
    >>> __builtin__
    <module '__builtin__' (built-in)>
    >>> __builtins__
    <module '__builtin__' (built-in)>
    >>> __builtin__.__name__
    '__builtin__'
    >>> __builtins__.__name__
    '__builtin__'
    >>> __builtin__ == __builtins__
    True
    >>> __builtin__ is __builtins__
    True
    >>> id(__builtins__)
    139655361473296
    >>> id(__builtin__)
    139655361473296
    

    可以看到,这时候 __builtins__ 和 __builtin__ 是完全一样的,它们都指向了同一个模块对象,其实这也是 Python 中引用传递的概念。

    其实这种情况跟我们创建一个变量并对它做一次引用传递时的情况是一样的,可以做如下测试:

    >>> def func():
    ...     print "test"
    ... 
    >>> funcs = func
    >>> func
    <function func at 0x7f040c21ccd0>
    >>> funcs
    <function func at 0x7f040c21ccd0>
    >>> func.__name__
    'func'
    >>> funcs.__name__
    'func'
    >>> func == funcs
    True
    >>> func is funcs
    True
    >>> id(func)
    139655360138448
    >>> id(funcs)
    139655360138448
    

    显然,这完全验证了我们上面的结论。

    5.2 不是在主模块中

    如果不是在主模块中使用 __builtins__,这时候,__builtins__ 只是对__builtin__.__dict__ 的一个简单引用而已,可以通过下面的测试来验证说明。

    先创建一个 test.py 模块,后面我们需要在 Python 交互器中导入它,那么这时候对于 test 模块来说,它就不是主模块了。如下:

    import  __builtin__
    
    
    print  'Module name:' , __name__
    
    print  '*==test __builtin__ and __builtins__==*'
    print  '__builtin__ == __builtins__' , __builtin__  ==  __builtins__
    print  '__builtin__ is __builtins__' , __builtin__  is  __builtins__
    print  'id(__builtin__)' ,  id (__builtin__)
    print  'id(__builtins__)' ,  id (__builtins__)
    
    print  '=' * 50
    
    print  '*==test __builtin__.__dict__ and __builtins__==*'
    print  '__builtin__.__dict__ == __builtins__' , __builtin__.__dict__  ==  __builtins__
    print  '__builtin__ is __builtins__' , __builtin__.__dict__  is  __builtins__
    print  'id(__builtin__)' ,  id (__builtin__.__dict__)
    print  'id(__builtins__)' ,  id (__builtins__)
    

    在 Python 交互器中导入上面这个 test 模块,如下:

    >>> import test
    Module name: test
    *==test __builtin__ and __builtins__==*
    __builtin__ == __builtins__ False
    __builtin__ is __builtins__ False
    id(__builtin__) 140032283536144
    id(__builtins__) 140032283615600
    ==================================================
    *==test __builtin__.__dict__ and __builtins__==*
    __builtin__.__dict__ == __builtins__ True
    __builtin__ is __builtins__ True
    id(__builtin__) 140032283615600
    id(__builtins__) 140032283615600
    

    可以看到输出的结果跟我们想的是完全一样的,即这时候 __builtins__ 其实是对__builtin__.__dict__ 模块的引用

    6 总结

    不管怎么说,在启动 Python 解释器或运行一个 Python 程序时,内建名称空间都是从 __builtins__ 模块中加载的,只是 __builtins__ 本身是对 Python 内建模块 __builtin__ 的引用,而这种引用又分下面两种情况:

    • 如果是在主模块 __main__ 中,__builtins__ 直接引用 __builtin__ 模块,此时模块名 __builtins__ 与模块名 __builtin__ 指向的都是同一个模块,即<builtin>内建模块(这里要注意变量名和对象本身的区别)
    • 如果不是在主模块中,那么 __builtins__ 只是引用了__builtin__.__dict__
    展开全文
  • python的builtins模块

    2022-04-06 14:45:33
    python的builtins模块builtins模块详解1.介绍1.1 builtins: python内建模块1.2 builtins 与 __builtins__的区别.在__main__模块中.在非__main__模块中2.示例代码结果 builtins模块详解 1.介绍 1.1 builtins: python...

    builtins模块详解

    1.介绍

    1.1 builtins: python内建模块

    内建模块就是在使用的时候不需要进行import, 在python启动之后,在没有执行程序员编写的任何代码之前,python会加载内建模块中函数到内存(python的内建函数,例如:abs(),str(),type()等)。在python2.x中为builtins

    如果需要向内建模块中添加自己的函数,则必须import builtins__main__模块中可以直接通过__builtins__添加函数,不需要import builtins。

    1.2 builtins 与 __builtins__的区别

    .在__main__模块中

    __main__模块中,__builtins__与builtins是同一个东西,可以使用两个中的任意一个来导入自己的函数到内建模块中,而使用builtins的时候需要import builtins__builtins__不需要import。

    .在非__main__模块中

    __builtins__是对builtins的__dict__引用,而不是builtins本身

    2.示例

    代码

    1.
    #test.py
    import builtins
    
    def Test():
        print(__builtins__ is builtins)
        print(__builtins__ is builtins.__dict__)
        print(type(__builtins__))
       
    Test() 
    
    2.
    import builtins
    
    def Test():
        print(__builtins__ is builtins)
        print(__builtins__ is builtins.__dict__)
        print(type(__builtins__))
    
    # 
    if __name__ == '__main__':
        Test()
    
    3. --->2
    ## test2.py
    import test
    
    test.Test()
    
    
    4.--->1
    ## test2.py
    import test
    
    test.Test()
    

    结果

    1Alt
    2在这里插入图片描述
    3在这里插入图片描述
    4在这里插入图片描述

    展开全文
  • pickle File "C:\Users\86178\Python310\lib\site-packages\numpy\random_pickle.py", line 1, in from .mtrand import RandomState File "mtrand.pyx", line 1, in init numpy.random.mtrand ValueError: builtins....
  • Python源码builtins.py

    多人点赞 2021-05-12 11:05:02
    为何Python源码builtins.py中的函数体都是pass? 目录 为何Python源码builtins.py中的函数体都是pass? 1.突发奇想看看源代码 2.如何查看源代码? 为何Python源码builtins.py中的函数体都是pass? 1.突发奇想...

    为何Python源码builtins.py中的函数体都是pass?

    目录

    为何Python源码builtins.py中的函数体都是pass?

    1.突发奇想看看源代码

    2.如何查看源代码?


    为何Python源码builtins.py中的函数体都是pass?

    1.突发奇想看看源代码

    今天在敲代码的时候好奇强大的list是怎么定义的,其中的函数是如何优化的,想着学习一下,于是点进了它的源代码,没想到竟然是下面的内容:

    class list(object):
        """
        list() -> new empty list
        list(iterable) -> new list initialized from iterable's items
        """
        def append(self, p_object): # real signature unknown; restored from __doc__
            """ L.append(object) -> None -- append object to end """
            pass
    
        def clear(self): # real signature unknown; restored from __doc__
            """ L.clear() -> None -- remove all items from L """
            pass
    
        def copy(self): # real signature unknown; restored from __doc__
            """ L.copy() -> list -- a shallow copy of L """
            return []
    
        def count(self, value): # real signature unknown; restored from __doc__
            """ L.count(value) -> integer -- return number of occurrences of value """
            return 0
    
        def extend(self, iterable): # real signature unknown; restored from __doc__
            """ L.extend(iterable) -> None -- extend list by appending elements from the iterable """
            pass
    
        def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__
            """
            L.index(value, [start, [stop]]) -> integer -- return first index of value.
            Raises ValueError if the value is not present.
            """
            return 0
    
        def insert(self, index, p_object): # real signature unknown; restored from __doc__
            """ L.insert(index, object) -- insert object before index """
            pass
    
        def pop(self, index=None): # real signature unknown; restored from __doc__
            """
            L.pop([index]) -> item -- remove and return item at index (default last).
            Raises IndexError if list is empty or index is out of range.
            """
            pass
    
        def remove(self, value): # real signature unknown; restored from __doc__
            """
            L.remove(value) -> None -- remove first occurrence of value.
            Raises ValueError if the value is not present.
            """
            pass
    
        def reverse(self): # real signature unknown; restored from __doc__
            """ L.reverse() -- reverse *IN PLACE* """
            pass
    
        def sort(self, key=None, reverse=False): # real signature unknown; restored from __doc__
            """ L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE* """
            pass

    没想到源代码中只有函数功能的描述,函数体无一例外全是pass,WTF???

    于是我去百度了一下,哦,这是Pycharm在糊弄老子呢

    python是C语言实现的,尽管有很多标准库是由python代码实现,但是涉及到底层支撑架构的功能还是C代码。 一些IDE为了对这些进行友好代码提示,会弄和底层一样的访问接口,而其实现直接写 pass 略过。

    2.如何查看源代码?

    答:到github上查看Cpython项目,其地址为:https://github.com/python/cpython

    在这里可以看到所有python基类的定义,所有函数的内容,例如我感兴趣的List就在Objects/listobject.c目录下,总共有3409行代码........

    最后给大家看一下几个list中比较常用的函数在Cpython中的写法

    大佬append(),源码并不长...

    /*[clinic input]
    list.append
         object: object
         /
    Append object to the end of the list.
    [clinic start generated code]*/
    
    static PyObject *
    list_append(PyListObject *self, PyObject *object)
    /*[clinic end generated code: output=7c096003a29c0eae input=43a3fe48a7066e91]*/
    {
        if (app1(self, object) == 0)
            Py_RETURN_NONE;
        return NULL;
    }
    

    POP()

    /*[clinic input]
    list.pop
        index: Py_ssize_t = -1
        /
    Remove and return item at index (default last).
    Raises IndexError if list is empty or index is out of range.
    [clinic start generated code]*/
    
    static PyObject *
    list_pop_impl(PyListObject *self, Py_ssize_t index)
    /*[clinic end generated code: output=6bd69dcb3f17eca8 input=b83675976f329e6f]*/
    {
        PyObject *v;
        int status;
    
        if (Py_SIZE(self) == 0) {
            /* Special-case most common failure cause */
            PyErr_SetString(PyExc_IndexError, "pop from empty list");
            return NULL;
        }
        if (index < 0)
            index += Py_SIZE(self);
        if (!valid_index(index, Py_SIZE(self))) {
            PyErr_SetString(PyExc_IndexError, "pop index out of range");
            return NULL;
        }
        v = self->ob_item[index];
        if (index == Py_SIZE(self) - 1) {
            status = list_resize(self, Py_SIZE(self) - 1);
            if (status >= 0)
                return v; /* and v now owns the reference the list had */
            else
                return NULL;
        }
        Py_INCREF(v);
        status = list_ass_slice(self, index, index+1, (PyObject *)NULL);
        if (status < 0) {
            Py_DECREF(v);
            return NULL;
        }
        return v;
    }

    index()

    /*[clinic input]
    list.index
        value: object
        start: slice_index(accept={int}) = 0
        stop: slice_index(accept={int}, c_default="PY_SSIZE_T_MAX") = sys.maxsize
        /
    Return first index of value.
    Raises ValueError if the value is not present.
    [clinic start generated code]*/
    
    static PyObject *
    list_index_impl(PyListObject *self, PyObject *value, Py_ssize_t start,
                    Py_ssize_t stop)
    /*[clinic end generated code: output=ec51b88787e4e481 input=40ec5826303a0eb1]*/
    {
        Py_ssize_t i;
    
        if (start < 0) {
            start += Py_SIZE(self);
            if (start < 0)
                start = 0;
        }
        if (stop < 0) {
            stop += Py_SIZE(self);
            if (stop < 0)
                stop = 0;
        }
        for (i = start; i < stop && i < Py_SIZE(self); i++) {
            PyObject *obj = self->ob_item[i];
            Py_INCREF(obj);
            int cmp = PyObject_RichCompareBool(obj, value, Py_EQ);
            Py_DECREF(obj);
            if (cmp > 0)
                return PyLong_FromSsize_t(i);
            else if (cmp < 0)
                return NULL;
        }
        PyErr_Format(PyExc_ValueError, "%R is not in list", value);
        return NULL;
    }
    

    count()

    /*[clinic input]
    list.count
         value: object
         /
    Return number of occurrences of value.
    [clinic start generated code]*/
    
    static PyObject *
    list_count(PyListObject *self, PyObject *value)
    /*[clinic end generated code: output=b1f5d284205ae714 input=3bdc3a5e6f749565]*/
    {
        Py_ssize_t count = 0;
        Py_ssize_t i;
    
        for (i = 0; i < Py_SIZE(self); i++) {
            PyObject *obj = self->ob_item[i];
            if (obj == value) {
               count++;
               continue;
            }
            Py_INCREF(obj);
            int cmp = PyObject_RichCompareBool(obj, value, Py_EQ);
            Py_DECREF(obj);
            if (cmp > 0)
                count++;
            else if (cmp < 0)
                return NULL;
        }
        return PyLong_FromSsize_t(count);
    }
    

     

    展开全文
  • Python 内置函数 Python builtins 模块

    千次阅读 2020-05-06 17:09:16
    '__annotations__': {}, '__builtins__': , '__file__': 'E:/python_project/BasicCalculate01/py_dir/test01.py', '__cached__': None, 'sys': } map()函数 描述 map() 会根据提供的函数对指定序列做映射。...
  • 这里主要以Python 2.7为例来探讨Python 2.x中__builtin__模块和__builtins__模块的区别和联系! PS:在Python 3+中,__builtin__模块被命名为builtins 命名空间 名称空间(NameSpace)是Python中非常重要的一个概念...
  • 在学习Python时,很多人会问到__builtin__、__builtins__和builtins之间有什么关系。百度或Google一下,有很 多答案,但是这些答案要么不准确,要么只说了一点点,并不全面。本文将给大家一个较为全面的答案。以下...
  • anaconda
  • builtins常用操作

    2020-09-22 19:45:44
    a.rstrip():返回删除了结尾空格的字符串S的副本。如果给定了chars而不是None,则改为删除chars中的字符。 def rstrip(self, chars=None): """ S.rstrip([chars]) -> str Return a copy of the string S ...
  • builtins内建模块

    2019-10-04 18:41:10
    builtins模块 为啥我们没有导入任何模块就能使用len(),str(),print()...等这么多的函数? 其实在我们运行python解释器的时候,他会自动导入一些模块,这些函数就是从这些地方来的,这些函数被称为内建函数 首先查看...
  • Python学习笔记 - 内建模块builtins

    千次阅读 2019-07-02 02:56:29
    导入builtins模块后,其实自动加载的__builtins__模块和手动导入的builtins模块是同一个模块。 >>> dir() ['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec_...
  • Embedded builtins

    2019-11-28 20:16:15
    Published14 August 2018· tagged withinternals ...V8 built-in functions (builtins) consume memory in every instance of V8. The builtin count, average size, and the number of V8 instances per Chrome br...
  • 最开始遇到的时候,是在wing IDE的使用中: import numpy as np 结果报错: builtins.ImportError: IMPORTANT: PLEASE READ THIS FOR ADVICE ON HOW TO SOLVE THIS ISSUE!... 第一次解决,在Anaconda的终端里: pip list ...
  •  从结果中可以看到,__builtins__其实还是引用了__builtin__模块而已,这说明真正的模块是__builtin__,也就是说,前面提到的内建函数其实是在内建模块__builtin__中定义的,即__builtins__模块包含内建名称空间中...
  • 7查看模块:builtins内置方法

    千次阅读 2019-12-21 14:06:10
    7查看模块:builtins内置方法 builtins模块提供对Python的所有“内置”标识符的直接访问;例如,builtins.open 是内置函数的全名 open() 。 dir()获得对象的方法 import builtins fun = dir(builtins) print(len(fun...
  • python builtins模块

    2020-03-27 10:59:43
    这个模块提供了对于python内置标识符的直接访问,例如builtins.open是内置函数open()的全名,也是对于内置open()的直接访问。 在程序中,如果我们需要改写python内置的标识符(函数等),就可以通过访问builtins实现...
  • yarn add react-dream-web-builtins 然后是ReactDream本身的一些peerDependencies: yarn add react recompose 用法 import { Html , Svg } from 'react-dream-web-builtins' import { render } from 'react-dom' ...
  • python是简单的一门语言,是因为里面存在了很多的模块...用下面的命令查看>>> dir(__builtins__)>>> dir(__builtins__)[‘ArithmeticError‘, ‘AssertionError‘, ‘AttributeError‘, ‘BaseException‘, ‘Blo...
  • BASH_BUILTINS.txt

    2019-11-26 22:30:52
    本文件内容源自linux操作系统下的bash指导手册,由于在notepad++上排版后,复制到csdn上格式有些乱,随将此txt文件上传到csdn,以备日后查询。
  • python3 中的 builtins 和 __builtin__

    千次阅读 2020-11-04 00:15:51
    1 内建模块 在 Python 中,有一个内建模块,该模块中有一些常用函数;而该模块在 Python 启动后、且没有执行程序员所写的任何代码前,Python会 首先加载 该...python2 中有 __builtin__ 和 __builtins__,二者的区别详见
  • cargo-xbuild Cargo-xbuild是货物构建的包装,它交叉编译sysroot板条箱核心,compiler_builtins和alloc以用于自定义目标。 cargo-xbuild Cargo-xbuild是货物构建的包装,它交叉编译sysroot板条箱核心,compiler_...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 31,223
精华内容 12,489
关键字:

builtins

友情链接: PacNeat-master.zip