精华内容
下载资源
问答
  • ARM NEON 查找手册,可以查找neon内建函数的功能以及入参和返回值类型; RVCT 提供在 ARM 和 Thumb 状态下为 Cortex-A8 处理器生成 NEON 代码的内在 函数。 NEON 内在函数在头文件 arm_neon.h 中定义。头文件既...
  • Python针对众多的类型,提供了众多的内建函数来处理,这些内建函数功用在于其往往可对多种类型对象进行类似的操作,即多种类型对象的共有的操作,下面话不多说了,来一看看详细的介绍吧。 map() map()函数接受两个...
  • Python提供了一些内建函数用于基本对象类型:cmp(),repr(),str(),type()和等同于repr()的(' ')操作符,本文给大家分享Python随手笔记之标准类型内建函数,对python内建函数相关知识感兴趣的朋友一起学习...
  • MultiCharts内建PowerLanguage语言和Easy Language的函数中文说明,excel版,查找函数非常方便。 MultiCharts 是一款专为期货,证券和外汇交易所设计的专业图表绘制和自动化交易的软件。 (官网没有)
  • opencl中文手册,方便查看opencl的相应API,整数函数,公共函数,几何函数。关系函数,加载矢量数据图像数据等,详细介绍各种数据类型,函数的精度等
  • 主要介绍了Python列表list常用内建函数,结合实例形式总结分析了Python列表list常见内建函数的功能、使用方法及相关操作注意事项,需要的朋友可以参考下
  • 11.1 什么是内建函数 内建函数,顾名思义,就是编译器内部实现的函数。这些函数跟关键字一样,可以直接使用,无须像标准库函数那样,要 #include 对应的头文件才能使用。 内建函数的函数命名,通常以 __builtin ...

     

    11.1 什么是内建函数

    内建函数,顾名思义,就是编译器内部实现的函数。这些函数跟关键字一样,可以直接使用,无须像标准库函数那样,要 #include 对应的头文件才能使用。

    内建函数的函数命名,通常以 __builtin 开头。这些函数主要在编译器内部使用,主要是为编译器服务的。内建函数的主要用途如下。

    • 用来处理变长参数列表;
    • 用来处理程序运行异常;
    • 程序的编译优化、性能优化;
    • 查看函数运行中的底层信息、堆栈信息等;
    • C 标准库函数的内建版本。

    因为内建函数是编译器内部定义,主要由编译器相关的工具和程序调用,所以这些函数并没有文档说明,而且变动而频繁。对于程序开发者来说,不建议使用这些函数。

    但有些函数,对于我们了解程序运行的底层信息、编译优化很有帮助,而且在 Linux 内核中也经常使用这些函数,所以还是很有必要去了解 Linux 内核中常用的一些内建函数。

     

    11.2 常用内建函数

    __builtin_return_address(LEVEL)

    这个函数用来返回当前函数或调用者的返回地址。函数的参数 LEVEl 表示函数调用链中的不同层次的函数,各个值代表的意义如下。

    • 0:返回当前函数的返回地址;
    • 1:返回当前函数调用者的返回地址;
    • 2:返回当前函数调用者的调用者的返回地址;
    • ……

    我们接下来写一个测试程序。

    void f(void)
        {
            int *p;
            p = __builtin_return_address(0);
            printf("f    return address: %p\n",p);
            p = __builtin_return_address(1);;
            printf("func return address: %p\n",p);
            p = __builtin_return_address(2);;
            printf("main return address: %p\n",p);
            printf("\n");
        }
        void func(void)
        {
            int *p;
            p = __builtin_return_address(0);
            printf("func return address: %p\n",p);
            p = __builtin_return_address(1);;
            printf("main return address: %p\n",p);
            printf("\n");
            f();
        }
    ​
        int main(void)
        {
            int *p;
            p = __builtin_return_address(0);
            printf("main return address: %p\n",p);
            printf("\n"); 
            func();
            printf("goodbye!\n");
            return 0;
        }

    C 语言函数在调用过程中,会将当前函数的返回地址、寄存器等现场信息保存在堆栈中,然后才会跳到被调用函数中去执行。当被调用函数执行结束后,根据保存在堆栈中的返回地址,就可以直接返回到原来的函数中继续执行。

    在这个程序中,main() 函数调用 func() 函数,在 main() 函数跳转到 func() 函数执行之前,会将程序正在运行的当前语句的下一条语句(如下代码所示)的地址保存到堆栈中,然后才去执行 func(); 这条语句,跳到 func() 函数去执行。func() 执行完毕后,如何返回到 main() 函数呢?很简单,将保存到堆栈中的返回地址赋值给 PC 指针,就可以直接返回到 main() 函数,继续往下执行了。

    printf("goodbye!\n");

    每一层函数调用,都会将当前函数的下一条指令地址,即返回地址压入堆栈保存。各层函数调用就构成 了一个函数调用链。在各层函数内部,我们使用内建函数就可以打印这个调用链上各个函数的返回地址。程序的运行结果如下。

    main return address:0040124B
    ​
    func return address:004013C3
    main return address:0040124B
    ​
    f    return address:00401385
    func return address:004013C3
    main return address:0040124B

    __builtin_frame_address(LEVEL)

    在函数调用过程中,还有一个“栈帧”的概念。函数每调用一次,都会将当前函数的现场(返回地址、寄存器等)保存在栈中,每一层函数调用都会将各自的现场信息都保存在各自的栈中。这个栈也就是当前函数的栈帧,每一个栈帧有起始地址和结束地址,表示当前函数的堆栈信息。多层函数调用就会有多个栈帧,每个栈帧里会保存上一层栈帧的起始地址,这样各个栈帧就形成了一个调用链。很多调试器、GDB、包括我们的这个内建函数,其实都是通过回溯函数栈帧调用链来获取函数底层的各种信息的。比如,返回地址 i、调用关系等。在 ARM 系统中,使用 FP 和 SP 这两个寄存器,分别指向当前函数栈帧的起始地址和结束地址。当函数继续调用或者返回,这两个寄存器的值也会发生变化,总是指向当前函数栈帧的起始地址和结束地址。

    我们可以通过内建函数 __builtinframeaddress(LEVEL),查看函数的栈帧地址。

    • 0:查看当前函数的栈帧地址
    • 1:查看当前函数调用者的栈帧地址
    • ……

    写一个程序,打印当前函数的栈帧地址。

    void func(void)
    {
        int *p;
        p = __builtin_frame_address(0);
        printf("func frame:%p\n",p);
        p = __builtin_frame_address(1);
        printf("main frame:%p\n",p);
    }
    ​
    int main(void)
    {
        int *p;
        p = __builtin_frame_address(0);
        printf("main frame:%p\n",p);
        printf("\n");
        func();
        return 0;
    }

    程序运行结果如下。

    main frame:0028FF48
    ​
    func frame:0028FF28
    main frame:0028FF48

     

    11.3 C 标准库的内建函数

    在 GNU C 编译器内部,实现了一些和 C 标准库函数类似的内建函数。这些函数跟 C 标准库函数功能相似,函数名也相同,只是在前面加了一个前缀 __builtin。如果你不想使用 C 库函数,也可以加个前缀,直接使用对应的内建函数。

    常见的标准库函数如下:

    • 内存相关的函数:memcpy 、memset、memcmp
    • 数学函数:log、cos、abs、exp
    • 字符串处理函数:strcat、strcmp、strcpy、strlen
    • 打印函数:printf、scanf、putchar、puts

    接下来我们写个小程序,使用与 C 标准库对应的内建函数。

    int main(void)
    {    
        char a[100];
        __builtin_memcpy(a,"hello world!",20);
        __builtin_puts(a);
    ​
        return 0;
    }

    程序运行结果如下。

    hello world!

    通过运行结果我们看到,使用与 C 标准库对应的内建函数,同样也能实现字符串的复制和打印,实现 C 标准库函数的功能。

     

    11.4 内建函数:__builtinconstantp(n)

    编译器内部还有一些内建函数,主要用来编译优化、性能优化,如 __builtinconstantp(n) 函数。该函数主要用来判断参数 n 在编译时是否为常量,是常量的话,函数返回1;否则函数返回0。该函数常用于宏定义中,用于编译优化。一个宏定义,根据宏的参数是常量还是变量,可能实现的方法不一样。在内核中经常看到这样的宏。

    #define _dma_cache_sync(addr, sz, dir)        \
    do {                            \
        if (__builtin_constant_p(dir))          \
            __inline_dma_cache_sync(addr, sz, dir); \
        else                        \
            __arc_dma_cache_sync(addr, sz, dir);    \
    }                            \
    while (0);

    很多计算或者操作在参数为常数时可能有更优化的实现,在这个宏定义中,我们实现了两个版本。根据参数是否为常数,我们可以灵活选用不同的版本。

     

    11.5 内建函数:__builtin_expect(exp,c)

    内建函数 __builtin_expect 也常常用来编译优化。这个函数有两个参数,返回值就是其中一个参数,仍是 exp。这个函数的意义主要就是告诉编译器:参数 exp 的值为 c 的可能性很大。然后编译器可能就会根据这个提示信息,做一些分支预测上的代码优化。

    参数 c 跟这个函数的返回值无关,无论 c 为何值,函数的返回值都是 exp。

    int main(void)
    {    
        int a;
        a = __builtin_expect(3,1);
        printf("a = %d\n",a);
    ​
        a = __builtin_expect(3,10);
        printf("a = %d\n",a);
    ​
        a = __builtin_expect(3,100);
        printf("a = %d\n",a);
        return 0;
    }

    程序运行结果如下。

    a = 3
    a = 3
    a = 3

    这个函数的主要用途就是编译器的分支预测优化。现代 CPU 内部,都有 cache 这个缓存器件。CPU 的运行速度很高,而外部 RAM 的速度相对来说就低了不少,所以当 CPU 从内存 RAM 读写数据时就会有一定的性能瓶颈。为了提高程序执行效率,CPU 都会通过 cache 这个 CPU 内部缓冲区来缓存一定的指令或数据。CPU 读写内存 RAM 中的数据时,会先到 cache 里面去看看能不能找到。找到的话就直接进行读写;找不到的话,cache 会重新缓存一部分内存数据进来。CPU 读写 cache 的速度远远大于内存 RAM,所以通过这种方式,可以提高系统的性能。

    那 cache 如何缓存内存数据呢?简单来说,就是依据空间相近原则。比如 CPU 正在执行一条指令,那么下一个指令周期,CPU 就会大概率执行当前指令的下一条指令。如果此时 cache 将下面几条指令都缓存到 cache 里面,下一个指令周期 CPU 就可以直接到 cache 里取指、翻译、执行,从而使运算效率大大提高。

    但有时候也会出现意外。比如程序在执行过程中遇到函数调用、if 分支、goto 跳转等程序结构,会跳到其它地址执行,那么缓存到 cache 中的指令就不是 CPU 要获取的指令。此时,我们就说 cache 没有命中,cache 会重新缓存正确的指令代码给 CPU 读取,这就是 cache 工作的基本流程。

    有了这个理论基础,我们在编写程序时,遇到 if/switch 这种选择分支的程序结构,可以将大概率发生的分支写在前面,这样程序运行时,因为大概率发生,所以大部分时间就不需要跳转,程序就相当于一个顺序结构,从而提高 cache 的命中率。内核中已经实现一些相关的宏,如 likely 和 unlikely,用来提醒程序员优化程序。

     

    11.6 内核中的 likely 和 unlikely

    Linux 内核中,使用 __builtin_expect 内建函数,定义了两个宏。

    #define likely(x) __builtin_expect(!!(x),1)
    #define unlikely(x) __builtin_expect(!!(x),0)

    这两个宏的主要作用,就是告诉编译器:某一个分支发生的概率很高,或者说很低,基本不可能发生。编译器就根据这个提示信息,就会去做一些分值预测的编译优化。在这两个宏定义有一个细节,就是对宏的参数 x 做两次取非操作,这是为了将参数 x 转换为布尔类型,然后与 1 和 0 作比较,告诉编译器 x 为真或为假的可能性很高。

    我们接下来举个例子,让大家感受下,使用这两个宏后,编译器在分支预测上的一些编译变化。

    //expect.c
    int main(void)
    {
        int a;
        scanf("%d",&a);
        if( a==0)
        {
            printf("%d",1);
            printf("%d",2);
            printf("\n");
        }
        else
        {
            printf("%d",5);
            printf("%d",6);
            printf("\n");
        }
        return 0;
    }

    在这个程序中,根据我们输入变量 a 的值,程序会执行不同的分支代码。我们接着对这个程序反汇编,生成对应的汇编代码。

    $ arm-linux-gnueabi-gcc  expect.c
    $ arm-linux-gnueabi-objdump -D a.out
     00010558 <main>:
       10558:    e92d4800    push    {fp, lr}
       1055c:    e28db004    add fp, sp, #4
       10560:    e24dd008    sub sp, sp, #8
       10564:    e59f308c    ldr r3, [pc, #140]  
       10568:    e5933000    ldr r3, [r3]
       1056c:    e50b3008    str r3, [fp, #-8]
       10570:    e24b300c    sub r3, fp, #12
       10574:    e1a01003    mov r1, r3
       10578:    e59f007c    ldr r0, [pc, #124]  
       1057c:    ebffffa5    bl  10418 <__isoc99_scanf@plt>
       10580:    e51b300c    ldr r3, [fp, #-12]
       10584:    e3530000    cmp r3, #0
       10588:    1a000008    bne 105b0 <main+0x58>
       1058c:    e3a01001    mov r1, #1
       10590:    e59f0068    ldr r0, [pc, #104]  
       10594:    ebffff90    bl  103dc <printf@plt>
       10598:    e3a01002    mov r1, #2
       1059c:    e59f005c    ldr r0, [pc, #92]
       105a0:    ebffff8d    bl  103dc <printf@plt>
       105a4:    e3a0000a    mov r0, #10
       105a8:    ebffff97    bl  1040c <putchar@plt>
       105ac:    ea000007    b   105d0 <main+0x78>
       105b0:    e3a01005    mov r1, #5
       105b4:    e59f0044    ldr r0, [pc, #68]
       105b8:    ebffff87    bl  103dc <printf@plt>
       105bc:    e3a01006    mov r1, #6
       105c0:    e59f0038    ldr r0, [pc, #56]
       105c4:    ebffff84    bl  103dc <printf@plt>

    观察 main 函数的反汇编代码,我们看到:汇编代码的结构就是基于我们的 if/else 分支先后顺序,依次生成对应的汇编代码(看 10588:bne 105b0 跳转)。我们接着改一下代码,使用 unlikely 修饰 if 分支,告诉编译器,这个 if 分支小概率发生,或者说不可能发生。

    //expect.c
    int main(void)
    {
        int a;
        scanf("%d",&a);
        if( unlikely(a==0) )
        {
            printf("%d",1);
            printf("%d",2);
            printf("\n");
        }
        else
        {
            printf("%d",5);
            printf("%d",6);
            printf("\n");
        }
        return 0;
    }

    对这个程序添加 -O2 优化参数编译,并对生成的可执行文件 a.out 反汇编。

    $ arm-linux-gnueabi-gcc -O2 expect.c
     $ arm-linux-gnueabi-objdump -D a.out
    00010438 <main>:
       10438:    e92d4010    push    {r4, lr}
       1043c:    e59f4080    ldr r4, [pc, #128]  
       10440:    e24dd008    sub sp, sp, #8
       10444:    e5943000    ldr r3, [r4]
       10448:    e1a0100d    mov r1, sp
       1044c:    e59f0074    ldr r0, [pc, #116]
       10450:    e58d3004    str r3, [sp, #4]
       10454:    ebfffff1    bl  10420 <__isoc99_scanf@plt>
       10458:    e59d3000    ldr r3, [sp]
       1045c:    e3530000    cmp r3, #0
       10460:    0a000010    beq 104a8 <main+0x70>
       10464:    e3a02005    mov r2, #5
       10468:    e59f105c    ldr r1, [pc, #92]
       1046c:    e3a00001    mov r0, #1
       10470:    ebffffe7    bl  10414 <__printf_chk@plt>
       10474:    e3a02006    mov r2, #6
       10478:    e59f104c    ldr r1, [pc, #76]
       1047c:    e3a00001    mov r0, #1
       10480:    ebffffe3    bl  10414 <__printf_chk@plt>
       10484:    e3a0000a    mov r0, #10
       10488:    ebffffde    bl  10408 <putchar@plt>
       1048c:    e59d2004    ldr r2, [sp, #4]
       10490:    e5943000    ldr r3, [r4]
       10494:    e3a00000    mov r0, #0
       10498:    e1520003    cmp r2, r3
       1049c:    1a000007    bne 104c0 <main+0x88>
       104a0:    e28dd008    add sp, sp, #8
       104a4:    e8bd8010    pop {r4, pc}
       104a8:    e3a02001    mov r2, #1
       104ac:    e59f1018    ldr r1, [pc, #24]
       104b0:    e1a00002    mov r0, r2
       104b4:    ebffffd6    bl  10414 <__printf_chk@plt>
       104b8:    e3a02002    mov r2, #2
       104bc:    eaffffed    b   10478 <main+0x40>

    我们对 if 分支条件表达式使用 unlikely 修饰,告诉编译器这个分支小概率发生。在编译器开启优化编译条件下,通过生成的反汇编代码(10460:beq 104a8),我们可以看到,编译器将小概率发生的 if 分支汇编代码放在了后面,将 else 分支的汇编代码放在了前面,这样就确保了程序在执行时,大部分时间都不需要跳转,直接按顺序执行下面大概率发生的分支代码。

    在 Linux 内核中,你会发现很多地方使用 likely 和 unlikely 宏修饰,此时你应该知道它们的用途了吧。

     

    本文根据《C语言嵌入式Linux高级编程》部分章节改编,视频学习可访问CSDN学院:https://edu.csdn.net/combo/detail/1038

    微信公众号:宅学部落(armlinuxfun)

    QQ群:475504428

    更多嵌入式视频教程:https://wanglitao.taobao.com

    电子书籍下载地址:https://pan.baidu.com/s/1a6L0cyIQKKLlmIfRw7U6Dg

    展开全文
  • 本篇主要介绍了集合、字典、解析式、生成器和一些简单的内建函数
  • 主要介绍了smarty模板引擎之内建函数用法,实例分析了smarty中foreach函数、if...else...、if...elseif...elseif...else...等内建函数的使用方法,具有一定参考借鉴价值,需要的朋友可以参考下
  • 主要介绍了python元组和字典的内建函数,结合实例形式详细分析了Python元组和字典的各种常见内建函数功能与相关使用技巧,需要的朋友可以参考下
  • 主要介绍了Python常见字典内建函数用法,结合具体实例形式分析了Python字典内建函数实现针对字典的长度、hash运算、键值对遍历、获取、计算等相关操作技巧,需要的朋友可以参考下
  • 主要介绍了PHP模板引擎Smarty内建函数用法,结合实例形式分析了smarty中常见的内建函数功能,定义与使用方法,需要的朋友可以参考下
  • 主要介绍了Java 8新特性 内建函数式接口详解的相关资料,这里主要介绍4个基本函数式接口,需要的朋友可以参考下
  • 主要介绍了Python中内建函数的简单用法说明,包括apply()、filter()、reduce()、map()四个函数的用法讲解,需要的朋友可以参考下
  • 隐式声明与GCC内建函数

    千次阅读 2017-10-13 11:43:28
    C语言隐式声明与GCC内建函数C语言隐式声明与GCC内建函数 什么是C语言的隐式声明 GCC内建函数 隐式声明带来的灾难什么是C语言的隐式声明 在C语言中,函数在调用前不一定非要声明。如果没有声明,那么编译器会自动...

    C语言隐式声明与GCC内建函数

    什么是C语言的隐式声明

      在C语言中,函数在调用前不一定非要声明。如果没有声明,那么编译器会自动按照一种隐式声明的规则,为调用函数的C代码产生汇编代码。下面是一个例子:

    #include <stdio.h>
    
    int main() {
        double x = no_declare_func();
        return 0;
    }
    $ gcc -c implicitDeclare2.c 
    $ gcc implicitDeclare2.o -o implicitDeclare2
    implicitDeclare2.o: In function `main':
    implicitDeclare2.c:(.text+0xe): undefined reference to `no_declare_func'
    collect2: error: ld returned 1 exit status

      可以看到上面的代码没有定义no_declare_func,但是gcc在编译的时候并不会报错,因为C语言规定,对于没有声明的函数,自动使用隐式声明,也就变成如下代码(函数的隐式声明默认为int型):

    #include <stdio.h>
    
    int no_declare_func();
    int main() {
        double x = no_declare_func();
        return 0;
    }

      在链接的时候会报错,因为链接过程中没有找到函数no_declare_func的定义。
      目前C++是没有隐式声明这一说,遇到这种没有函数声明的情况,会直接报error。

    GCC内建函数

      内建函数(built-in),即一个系统或者工具提供的默认就能用的函数,我的理解是默认情况下,gcc在链接的时候如果没有找到定义,就会自动去链接库中对应名称的函数,gcc的内建函数大多是为了对代码进行优化。
      gcc内建函数相关的选项如下:

    • -fbuiltin:
      gcc编译默认选项,默认通过名字来识别内建函数

    • -fno-builtin:
      禁用GCC编译器内建函数。如果在gcc编译时用了-fno-builtin选项,则除非利用前缀__builtin_进行引用,否则不识别所有内建函数。例如,为了获得内建strcpy函数,应该调用__builtin_strcpy()而不是名为 strcpy() 的函数。

    • -fno-builtin-xxx:
      gcc编译时想特定的不使用某些函数的内建函数,例如,想使用除sqrt()之外的所有内建函数,则可以添加此选项-fno-builtin-sqrt

    隐式声明带来的灾难

      不要用隐式声明!!!不要用隐式声明!!!不要用隐式声明!!!

    1. 首先,隐式声明是默认int型,如果没有对应同名的内建函数,编译不报错,链接报错,这种情况上面已经介绍
    2. 有同名的内建函数,且类型相同,gcc编译链接没问题
    3. 有同名的内建函数,类型不同,链接报warning“隐式声明与内建函数不兼容”,但是以内建函数的函数原型为准。gcc编译器在编译时能够自动在常用库头文件(内建函数)中查找与隐式声明同名的函数,如果发现两者并不相同,则会按照内建函数的声明原型去生成调用代码。

    case 2:

    #include <stdio.h>
    
    int main(){
        int x = abs(-1,2,3,4,5);
        printf("%d \n", x);
        return 0;
    }

      其中,abs的隐式声明函数原型为:

    int abs(int);

      abs()内建函数原型为:

    int abs(int);

      gcc编译链接均没有报错,执行结果如下:

    $ gcc -c implicitDeclare.c
    $ gcc implicitDeclare.o -o implicitDeclare
    $ ./implicitDeclare 
    1 

      可见,gcc的内建函数机制并不关心函数的参数,只是关心函数的返回值。虽然这个例子的运行结果都是正确的,但是这种正确是“碰巧”的,因为额外的函数参数并没有影响到结果。这种偶然正确是程序中要避免的。

    case 3:

    #include <stdio.h>
    
    int main(){
        double x = sqrt(1);
        printf("%lf \n", x);
        return 0;
    }

      其中,sqrt()的隐式声明函数原型为:

    int sqrt(int);

      sqrt()的内建函数原型为:

    double sqrt(double);

    编译报警告,链接按照内建函数原型链接:

    $ gcc -c implicitDeclare.c
    implicitDeclare.c: In function ‘main’:
    implicitDeclare.c:4:16: warning: incompatible implicit declaration of built-in function ‘sqrt’ [enabled by default]
         double x = sqrt(1);
                    ^
    $ gcc implicitDeclare.o -o implicitDeclare

    但是仍然可以执行,结果如下:

    $ ./implicitDeclare 
    1.000000 
    展开全文
  • 主要介绍了Python中集合的内建函数建方法学习教程,包括工厂函数和仅用于可变集合的方法等知识点,需要的朋友可以参考下
  • Python内置函数/内建函数,魔法方法、特殊方法 built-in functions、special method、magic method区别与联系 Python的内置函数与特殊方法、魔法方法概念既相关,又容易混淆,本文试图厘清其中关系。 内置函数/内建...

    Python内置函数/内建函数,魔法方法、特殊方法 built-in functions、special method、magic method区别与联系

    Python的内置函数与特殊方法、魔法方法概念既相关,又容易混淆,本文试图厘清其中关系。

    内置函数/内建函数 built-in functions

    内建函数(内建是相对于导入import来说的)是指python内部自带的函数,不需要导入外部包即可实现的函数,比如 len(),abs()等,Python针对众多的类型,提供了众多的内建函数来处理,这些内建函数功用在于其往往可对多种类型对象进行类似的操作,即多种类型对象的共有的操作;如果某种操作只对特殊的某一类对象可行,Python常将其设置为该种类型的方法(method)。

    Python内置函数列表可参考:
    https://docs.python.org/3.6/library/functions.html#import

    特殊方法 special method

    special method 就是一类有特殊名字 special names的方法,此特殊名字就是前后有双下划线,此类方法实质就是内建函数的底层函数,也即 len()函数调用的是__len()函数,abs()调用的是__abs(),特殊方法的列表
    http://www.cnblogs.com/liao-sir/p/8416081.html

    python 手册中关于特殊函数的部分:

    3.3. Special method names
    A class can implement certain operations that are invoked by special syntax (such as arithmetic operations or subscripting and slicing) by defining methods with special names. This is Python’s approach to operator overloading, allowing classes to define their own behavior with respect to language operators. For instance, if a class defines a method named getitem(), and x is an instance of this class, then x[i] is roughly equivalent to type(x).getitem(x, i). Except where mentioned, attempts to execute an operation raise an exception when no appropriate method is defined (typically AttributeError or TypeError).、

    全文链接:https://docs.python.org/3.6/reference/datamodel.html#specialnames

    魔法函数

    由于内置函数调用特殊函数是由解释器自动调用,比如 > 操作直接调用 gt() 特殊函数,看起来比较魔法,故也称特殊函数也为魔法函数。
    特殊函数可以在类定义内重载,而且重载后相应的内置函数也会发生变化,但不能自己创造一个不存在的特殊函数名称。

    由于特殊函数的可以重载,则可以给内置函数带来更多的功能和性质,可参考:

    http://www.cnblogs.com/jhao/p/6022928.html

    Special (magic) methods in Python

    参考

    1、python内置函数和魔法函数 https://www.cnblogs.com/ranjiewen/p/9219110.html

    展开全文
  • 通过具体的实例,讲解了Python基础中的内建函数。 包括abs函数 bool函数dir函数float函数、int函数len函数max与min函数range函数sum函数使用文件中read函数与write函数
  • 主要介绍了详解Python中映射类型的内建函数和工厂函数,目前Python的建映射类型只有字典一种,需要的朋友可以参考下
  • Python如何查看内建函数

    千次阅读 2019-02-17 15:21:03
    dir(__builtins__)

    dir(__builtins__)

    展开全文
  • python: index 内建函数

    千次阅读 2018-01-01 10:56:11
    Syntax list.index(obj) 从列表中找出某个值 第一个 匹配项 的 索引 。Args: obj: 查找的对象。 Testlst = [10, 20, "Hello", 20, "Nanjing"]idx = lst.index(20) print(idx) # 1idx = lst.index("Hi") ...
  • 标准类型内建函数 len() 集合类型工厂函数 set()和 frozenset() 集合类型建方法 方法(所有集合的方法) 方法(仅适用于可变集合) 集合内建函数应用举例 集合的介绍 set 对象是由具有
  • python字符串内建函数详解

    千次阅读 2016-09-10 20:50:41
    这些方法实现了string模块的大部分方法,如下表所示列出了目前字符串内建支持的方法,所有的方法都包含了对Unicode的支持,有一些甚至是专门用于Unicode的。Python capitalize()方法描述 Python capitalize()将字符...
  • wserver.c:27:2: 警告:隐式声明与内建函数‘memset’不兼容 [默认启用]  memset( &amp;servaddr, '\0', sizeof(servaddr)); 这种情况多半是缺少某些头文件。那么如何确定缺少那些文件呢? Linux下查...
  • 警告:隐式声明与内建函数‘exit’不兼容
  • 34.笔记go语言——内建函数

    千次阅读 2017-10-06 20:23:25
    34.笔记go语言——内建函数 预定义了少数函数,这意味着无需引用任何包就可以使用它们。 close new paniccomplex delete make recover real len append print imag cap copy println close 用于channel通讯。使用...
  • GCC 内建函数

    千次阅读 2016-04-13 23:52:02
    __builtin_*形式的gcc内建函数一般是基于不同硬件平台采用专门的硬件指令实现的,因此性能较高。如 int __builtin_popcount (unsigned int x) Returns the number of 1-bits in x. int __builtin_popcountl ...
  • 在linux下编译C语言时,出现“隐式声明与内建函数‘printf’不兼容 [默认启用]”这个错误 解决方法是:添加头文件stdio.h 类似问题:出现“隐式声明与内建函数‘exit’不兼容 [默认启用]”这个错误 解决方法:添加...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 341,350
精华内容 136,540
关键字:

内建函数