精华内容
下载资源
问答
  • 内置函数

    2014-02-26 17:02:34
    特征: 采用关键字是inline,不能包括复杂的控制语句,函数体不宜大于5行并且在函数中频繁调用时才考虑使用内置函数。  优点:提高运行效率。 因为它在编译阶段将函数体插入到主函数中取得,这样就避免了一次函数...

      特征: 采用关键字是inline,不能包括复杂的控制语句,函数体不宜大于5行并且在函数中频繁调用时才考虑使用内置函数。

      优点:提高运行效率。 因为它在编译阶段将函数体插入到主函数中取得,这样就避免了一次函数调用而节省时间。

      缺点:主函数体会变长。所以函数内容比较多的函数不建议使用内置函数。

    #include <iostream>
    using namespace std;
    inline int max(int,int, int); //声明函数,注意左端有inline
    int main( )
    {int i=10,j=20,k=30,m;
    m=max(i,j,k);
    cout<<″max=″<<m<<endl;
    return 0;
    }
    inline int max(int a,int b,int c) //定义max为内置函数
    {if(b>a) a=b; //求a,b,c中的最大者
    if(c>a) a=c;
    return a;
    }

    由于在定义函数时指定它为内置函数,因此编译系
    统在遇到函数调用“max(i,j,k)”时,就用max函数体
    的代码代替“max(i,j,k)”,同时将实参代替形参。这
    样,程序第6行 “m=max(i,j,k);”就被置换成
    if (j>i) i=j;
    if(k>i) i=k;
    m=i;
    注意: 可以在声明函数和定义函数时同时写
    inline,也可以只在其中一处声明inline,效果相
    同,都能按内置函数处理。

    展开全文
  • Python内置函数作用及解析

    万次阅读 多人点赞 2018-06-30 15:44:45
    为了方便记忆,已经有很多开发者将这些内置函数进行了如下分类: 数学运算(7个) 类型转换(24个) 序列操作(8个) 对象操作(7个) 反射操作(8个) 变量操作(2个) 交互操作(2个) 文件操作(1个) 编译执行(4个) 装饰器(3个)...

    Python内置的函数及其用法。为了方便记忆,已经有很多开发者将这些内置函数进行了如下分类:

    •  数学运算(7个)
    •  类型转换(24个)
    • 序列操作(8个)
    • 对象操作(7个)
    • 反射操作(8个)
    • 变量操作(2个)
    • 交互操作(2个)
    • 文件操作(1个)
    • 编译执行(4个)
    • 装饰器(3个)

    汇总如下:

    分类 函数 作用
    数学运算 abs 求数值的绝对值
    divmod 返回两个数值的商和余数
    max 返回可迭代对象中的元素中的最大值或者所有参数的最大值
    min 返回可迭代对象中的元素中的最小值或者所有参数的最小值
    pow 返回两个数值的幂运算值或其与指定整数的模值
    round 对浮点数进行四舍五入求值
    sum 对元素类型是数值的可迭代对象中的每个元素求和
    类型转换 bool 根据传入的参数逻辑值,创建一个新的布尔值
    int 根据传入的参数,创建一个新的整数
    float 根据传入的参数,创建一个新的浮点数
    complex 根据传入参数,创建一个新的复数
    str 返回一个对象的字符串表现形式(给用户)
    bytearray 根据传入的参数,创建一个新的字节数组
    bytes 根据传入的参数,创建一个新的不可变字节数组
    memoryview 根据传入的参数,创建一个新的内存查看对象
    ord 返回Unicode字符对应的整数
    chr 返回整数所对应的Unicode字符
    bin 将整数转换成2进制字符串
    oct 将整数转化成8进制数字符串
    hex 将整数转换成16进制字符串
    tuple 根据传入的参数,创建一个新的元组
    list 根据传入的参数,创建一个新的列表
    dict 根据传入的参数,创建一个新的字典
    set 根据传入的参数,创建一个新的集合
    frozenset 根据传入的参数,创建一个新的不可变集合
    enumerate 根据可迭代对象创建枚举对象
    range 根据传入的参数,创建一个新的range对象
    iter 根据传入的参数,创建一个新的可迭代对象
    slice 根据传入的参数,创建一个新的切片对象
    super 根据传入的参数,创建一个新的子类和父类关系的代理对象
    object 创建一个新的object对象
    序列操作 all 判断可迭代对象的每个元素是否都为True值
    any 判断可迭代对象的元素是否有为True值的元素
    filter 使用指定方法过滤可迭代对象的元素
    map 使用指定方法去作用传入的每个可迭代对象的元素,生成新的可迭代对象
    next 返回可迭代对象中的下一个元素值
    reversed 反转序列生成新的可迭代对象
    sorted 对可迭代对象进行排序,返回一个新的列表
    zip 聚合传入的每个迭代器中相同位置的元素,返回一个新的元组类型迭代器
    对象操作 help 返回对象的帮助信息
    dir 返回对象或者当前作用域内的属性列表
    id 返回对象的唯一标识符
    hash 获取对象的哈希值
    type 返回对象的类型,或者根据传入的参数,创建一个新的类型
    len 返回对象的长度
    ascii 返回对象的可打印表字符串表现方式
    format 格式化显示值
    反射操作 vars 返回当前作用域内的局部变量,和其值组成的字典,或者返回对象的属性列表
    isinstance 判断对象是否是类或者类型元组中任意类元素的实例
    issubclass 判断类是否是另外一个类或者类型元组中任意类元素的子类
    hasattr 检查对象是否含有属性
    getattr 获取对象的属性值
    setattr 设置对象的属性值
    delattr 删除对象的属性
    callable 检测对象是否可被调用
    变量操作 globals 返回当前作用域内的全局变量,和其值组成的字典
    locals 返回当前作用域内的局部变量,和其值组成的字典
    交互操作 print 向标准输出对象打印输出
    input 读取用户输入值
    文件操作 open 使用指定的模式和编码打开文件,返回文件读写对象
    编译执行 compile 将字符串编译为代码或者AST对象,使之能够通过exec语句来执行或者eval进行求值
    eval 执行动态表达式求值
    exec 执行动态语句块
    repr 返回一个对象的字符串表现形式(给解释器)
    装饰器 property 标示属性的装饰器
    classmethod 标示方法为类方法的装饰器
    staticmethod 标示方法为静态方法的装饰器

    具体每个函数的解析如下: 

      数学运算 

    • abs:求数值的绝对值
      >>> abs(-1)
      1
      >>> abs(1)
      1
    • divmod:返回两个数值的商和余数
      >>> divmod(5,2)
      (2, 1)
      >> divmod(5.5,2)
      (2.0, 1.5)
    • max:返回可迭代对象中的元素中的最大值或者所有参数的最大值
       
      >>> max(1,2) # 传入参数 取较大者
      2
      >>> max('123') # 传入1个可迭代对象,取其最大元素值
      '3'
      
      >>> max(-1,0) # 数值默认取数值较大者
      0
      >>> max(-1,0,key = abs) # 传入了求绝对值函数,则参数都会进行求绝对值后再取较大者
      -1
    • min:返回可迭代对象中的元素中的最小值或者所有参数的最小值
       
      >>> min(1,2) # 传入3个参数 取3个中较小者
      1
      >>> min('123') # 传入1个可迭代对象,取其最小元素值
      '1'
      
      >>> min(-1,-2) # 数值默认去数值较小者
      -2
      >>> min(-1,-2,key = abs)  # 传入了求绝对值函数,则参数都会进行求绝对值后再取较小者
      -1
    • pow:返回两个数值的幂运算值或其与指定整数的模值
      >>> pow(2,3)
      >>> 2**3
      
      >>> pow(2,3,4)
      >>> pow(2,3)%4
    • round:对浮点数进行四舍五入求值
      >>> round(1.16,1)
      1.1
    • sum:对元素类型是数值的可迭代对象中的每个元素求和
       
      # 传入可迭代对象,要求是数字
      >>> sum((1,2,3))
      6

     

     
    展开全文
  • Python-内置函数

    千人学习 2017-08-24 09:11:16
    介绍Python的内置函数time
  • Python 内置函数详解

    千次阅读 多人点赞 2019-11-13 17:21:35
    Python 的内置函数数量众多,功能强大,如果能够灵活运用,必将极大地提高编程效率。不过,在大家公认的所谓内置函数里面,有很多并不是真的函数,而是内置类,只是因为使用起来和真正的函数没有什么不同,所以也就...

    Python内置函数是Python解释器中预先定义好的函数,也被称为内嵌函数。所有的内置函数都被定义在标准模块 builtins 中。Python解释器启动的时候,自动以 form builtins import * 的方式导入全部内置函数,因此我们可以直接使用这些函数。例如,print()为常用的内置函数之一,在编程的时候既可以直接调用,也可以通过调用builtins类来使用:

    
    >>> print('Python') # 这是内置函数最典型的用法
    Python
    
    >>> import builtins
    >>> builtins.print('Python') # 这样使用,仅是为了验证内置函被定义在标准模块 builtins 中
    Python                     
    

    Python 的内置函数数量众多,功能强大,如果能够灵活运用,必将极大地提高编程效率。不过,在大家公认的所谓内置函数里面,有很多并不是真的函数,而是内置类,只是因为使用起来和真正的函数没有什么不同,所以也就约定俗成地统称为内置函数了。比如,我们常说的类型转换函数 int()、str()、float() 等,都是类,而 print()、sorted() 等才是真正地函数。

    >>> type(print) # 这是内置函数 
    <class 'builtin_function_or_method'>
    >>> type(sorted) # 这是内置函数 
    <class 'builtin_function_or_method'>
    >>> type(int), type(float), type(str) # 这是内置类 
    (<class 'type'>, <class 'type'>, <class 'type'>)
    

    本文整理了 Python 的全部内置函数和内置类,共计73个,按照功能的不同将它们分为16大类,编排成速查表并,根据它们在编码实践中使用的频次,给出一个主观的评价,共初学者参考。点击速查表中的函数名,即可快速跳转至使用详解。速查表中标红的函数,建议初学者首先要熟练应用。代码虽经反复测试验证,仍难免存在谬误。各位如有发现,敬请留言指正。

    Python内置函数(类)速查表
    No. 内置函数 功能 返回结果 使用频次
    (一)输入输出功能
    1 print() 在控制台或终端显示内容 ★★★★★
    2 input() 在控制台或终端输入内容 字符串 ★★★★★
    (二)数据类型功能
    3 int() - 生成整数对象(默认为 0 )
    - 或者将参数转为整数类型
    整数 ★★★★★
    4 float() - 生成浮点数对象(默认为 0.0 )
    - 或者将参数转为浮点数类型
    浮点数 ★★★★★
    5 bool() - 生成布尔类型对象(默认为 False )
    - 或者将参数转为布尔类型
    布尔值 ★★★★☆
    6 str() - 生成字符串对象(默认为空字符串)
    - 或者将参数转换为字符串类型
    字符串 ★★★★★
    7 list() - 生成列表对象(默认为空列表)
    - 或者将参数转换为列表类型
    列表 ★★★★★
    8 tuple() - 生成元组对象(默认为空元组)
    - 或者将参数转换为元组类型
    元组 ★★★★★
    9 dict() - 生成字典对象(默认为空字典)
    - 或者将参数转换为字典类型
    字典 ★★★★★
    10 set() - 生成集合对象(默认为空集合)
    - 或者将参数转换为集合类型
    集合 ★★★★☆
    11 frozenset() 将参数转换为不可变集合类型 不可变集合 ★★★☆☆
    12 bytes() - 生成字节串对象(默认为空字节)
    - 或者将数字转换为字节串类型
    字节串 ★★★★☆
    13 bytearray() - 生成字节数组对象(默认为空字节)
    - 或者将对象转换为字节数组类型
    字节数组(可迭代对象) ★★★☆☆
    14 memoryview() - 返回字节数组对象指定下标的内容
    - 或者返回截取片段的内存地址
    元素内容或地址 ★★☆☆☆
    (三)参数辅助功能
    15 type() 显示参数的类型 type类型 ★★★★★
    16 isinstance() 判断对象是否为某类型 布尔值 ★★★★★
    17 len() 显示参数(需为可迭代对象)的长度 整数 ★★★★★
    18 range() 规定整数区间并开始依次遍历数字 range类型 ★★★★★
    19 format() 将参数格式化为相应的字符串 字符串 ★★★★★
    (四)数学运算功能
    20 max() 多个参数中查找最大值 数字类型 ★★★★★
    21 min() 多个参数中查找最小值 数字类型 ★★★★★
    22 sum() 多个参数求和 数字类型 ★★★★★
    23 pow() 计算参数的多次方 数字类型 ★★★★★
    24 abs() 求参数绝对值 数字类型 ★★★★★
    25 round() 四舍五入参数值 数字类型 ★★★★★
    26 divmod() 返回两个数字参数的商和余数 元组 ★★★☆☆
    27 complex() 将数字与字符串转换为复数 complex类型 ★★★☆☆
    (五)条件判断功能
    28 all() 判断多个内容是否全部为真 布尔值 ★★★★☆
    29 any() 判断多个内容是否至少一个为真 布尔值 ★★★★☆
    (六)进制转义功能
    30 bin() 将十进制整数转换为 ‘0b’ 开头的二进制数字 字符串 ★★★☆☆
    31 oct() 将十进制整数转换为 ‘0o’ 开头的八进制数字 字符串 ★★★☆☆
    32 hex() 将十进制整数转换为 ‘0x’ 开头的十六进制数字 字符串 ★★★☆☆
    (七)编码转义功能
    33 chr() 输入Unicode码数返回对应的字符串 字符串 ★★★☆☆
    34 ord() 输入字符串返回对应的Unicode码数 整数 ★★★☆☆
    (八)字符串进阶功能
    35 repr() 将任意对象尝试修改为直观的字符串 字符串 ★★★☆☆
    36 ascii() 将任意对象尝试修改为直观的字符串
    超出ascii编码范围的字符使用转义
    字符串 ★★★☆☆
    37 eval() 将字符串视为代码语法并执行 执行后的相关参数 ★★★☆☆
    38 exec() 将字符串视为代码语法并执行 执行后的相关参数 ★★★☆☆
    39 compile() 将字符串转换为对应的执行命令: eval exec single 执行程序 ★★★☆☆
    (九)迭代相关功能
    40 enumerate() 同时生成序列号与元素结合的数据序列 数据序列 ★★★★★
    41 reversed() 返回一个反转顺序的数据序列 数据序列
    42 map() 处理多个参数在同一个函数中的结果 结果序列 ★★★★☆
    43 sorted() 对可迭代对象内元素排序 排序后的对象 ★★★★★
    44 filter() 根据函数条件过滤可迭代对象 过滤后的对象 ★★★☆☆
    45 iter() 生成元素组成的迭代器 元素迭代器 ★★★☆☆
    46 next() 返回元素迭代器内下一个未使用元素 对象的一个元素 ★★★☆☆
    47 slice() 设置切片函数,对迭代对象进行切片(筛选) 切片后的迭代对象 ★★★☆☆
    48 zip() 将多个迭代对象压缩为一个迭代对象 压缩后的迭代序列 ★★★★☆
    (十)系统相关功能
    49 open() 打开目标文件 待处理的文件内容 ★★★★★
    50 breakpoint() 制造程序断点,通常用于调试 Pdb调试状态 ★★★★☆
    (十一)终止程序功能
    51 quit() 终止程序 ★★★☆☆
    52 exit() 终止程序 ★★★☆☆
    (十二)属性相关功能
    53 hasattr() 判断当前对象是否存在某个属性 布尔值 ★★★★☆
    54 delattr() 删除一个对象的属性 ★★★☆☆
    55 getattr() 获取引用对象的属性值 属性值 ★★★☆☆
    56 setattr() 修改创建对象的属性值 属性值 ★★★☆☆
    57 dir() 当前或指定对象的全部有效属性名称 列表 ★★★☆☆
    58 locals() 当前或指定位置的全部变量与值的信息 字典 ★★★★☆
    59 vars() 当前或指定位置的全部变量与值的信息 字典 ★★★☆☆
    60 globals() 当前文件的全部变量与值的信息 字典 ★★★☆☆
    (十三)查看对象信息功能
    61 help() 获取对象的用途及说明 说明文本 ★★★☆☆
    62 id() 获取对象的内存地址 整数 ★★★★☆
    63 hash() 获取对象的哈希值 整数 ★★★☆☆
    (十四)类相关功能
    64 super() 调用父类/基类的方法 ★★★★☆
    65 object() 所有类的父类 class类型 ★★★★☆
    66 callable() 判断对象是否可被调用 布尔类型 ★★★☆☆
    67 issubclass() 判断一个类是否继承自某一个类 布尔类型 ★★★☆☆
    (十五)装饰器相关功能
    68 classmethod() 将一个方法封装为类方法 ★★★★☆
    69 staticmethod() 将一个方法封装为静态方法 ★★★★☆
    70 property() 将一个方法封装为只读属性 ★★★☆☆
    (十六)python声明
    71 copyright() 打印许可文本 贡献者列表 版权通知 字符串 ★★★☆☆
    72 credits() 打印许可文本 相关网址 字符串 ★★★☆☆
    73 license() 打印python历史 相关网址 字符串 ★★★☆☆

    1. print()

    print() 函数是Python中最常用的内置函数之一,通常用于终端的结果打印及程序调试。除了基本的打印功能之外,print() 函数还有四个参数值可供用户修改:

    print(*objects, sep=’ ‘, end=’\n’, file=sys.stdout, flush=False)

    • objects – 零个或多个输出对象。输出多个对象时,需要用半角逗号分隔
    • sep – 用来间隔多个对象,默认值是一个空格
    • end – 用来设定以什么结尾。默认值是换行符 \n,我们可以换成其他字符串
    • file – 要写入的文件对象
    • flush – 输出是否被缓存通常决定于 file,但如果 flush 关键字参数为 True,流会被强制刷新

    应用示例

    >>> print('A','B')  # 输出多个对象时,需要用半角逗号分隔;显示时两个参数之间默认使用一个空格分割
    A B
    >>> print('A','B', sep='-') # 可以改用其他字符做分割
    A-B
    >>> for i in range(2):
    >>> 	print('result')  # 默认为换行,即每次输出完自动换行
    result
    result
    
    >>> for i in range(2):
    >>> 	print('result', end='')  # 改为空字符,则每次输出结束不换行
    resultresult
    
    >>> for i in range(2):
    >>> 	print('result', end=' ')  # 改为空格,则每次输出以空格结束
    result result
    
    >>> with open('文件.txt', 'w') as f:
    >>> 	print('内容', file=f)  # 将'内容'写入到'文件.txt'中
    

    返回 Python内置函数(类)速查表


    2. input()

    input() 函数常用于程序执行过程中接收用户输入的参数,因其本身具备IO阻塞的功能,所以也可用于作为程序调试断点来使用。input() 函数没有默认参数,但接受一个字符串作为输入提示信息。

    input([prompt])

    应用示例

    >>> n = input('请输入一个正整数:')
    请输入一个正整数:5
    >>> print(n)
    5
    

    返回 Python内置函数(类)速查表


    3. int()

    int() 函数用于生成和转换整数类型,当int() 函数将浮点数转换为整数时,并不会四舍五入,而是直接忽视小数点之后的所有数字。

    class int([x])
    class int(x, base=10)

    应用示例

    >>> int()
    0
    >>> int(12.5)
    12
    >>> int('25', base=8)
    21
    >>> int('1100', base=2)
    12
    

    返回 Python内置函数(类)速查表


    4. float()

    float() 用于生成和转换浮点数类型。

    class float([x])

    应用示例

    >>> float()
    0.0
    >>> float(5)
    5.0
    >>> float(5.35)
    5.35
    >>> float('5.35')
    5.35
    

    返回 Python内置函数(类)速查表


    5. bool()

    bool() 用于生成和转换布尔类型。布尔类型只有两个值(True和False),所以不同的数据类型会根据不同的规则来转换。

    class bool([x])

    应用示例

    >>> bool()
    False
    >>> bool(0)
    False
    >>> bool(3)
    True
    >>> bool('')
    False
    >>> bool('False')
    True
    >>> bool(None)
    False
    >>> bool(list())
    False
    

    返回 Python内置函数(类)速查表


    6. str()

    str() 用于生成空字符串或者将其它对象转换成字符串类型,布尔类型直接转为“True”或者F“alse字”样的字符串。

    class str(object=’’)
    class str(object=b’’, encoding=‘utf-8’, errors=‘strict’)

    应用示例

    >>> str()
    ''
    >>> str([2,3,4])
    '[2, 3, 4]'
    >>> str({'a':1, 'b':2})
    "{'a': 1, 'b': 2}"
    >>> str(b'xyz012')
    "b'xyz012'"
    >>> str('中文')
    '中文'
    >>> str('中文'.encode('utf8'))
    "b'\\xe4\\xb8\\xad\\xe6\\x96\\x87'"
    >>> str(True)
    'True'
    

    返回 Python内置函数(类)速查表


    7. list()

    实例化 list 类。

    class list([iterable])

    应用示例

    >>> list()
    []
    >>> list((2,3,4))
    [2, 3, 4]
    >>> list({'x',3,False})
    [3, False, 'x']
    

    返回 Python内置函数(类)速查表


    8. tuple ()

    实例化 tuple 类。

    tuple([iterable])

    应用示例

    >>> tuple()
    ()
    >>> tuple([5])
    (5,)
    >>> tuple([5,6,'x'])
    (5, 6, 'x')
    

    返回 Python内置函数(类)速查表


    9. dict()

    实例化 dict 类。

    class dict(**kwarg)
    class dict(mapping, **kwarg)
    class dict(iterable, **kwarg)

    应用示例

    >>> dict()
    {}
    >>> dict(a=1,b=2)
    {'a': 1, 'b': 2}
    >>> dict([('a',1),('b',2)])
    {'a': 1, 'b': 2}
    >>> dict({'a': 1, 'b': 2})
    {'a': 1, 'b': 2}
    

    返回 Python内置函数(类)速查表


    10. set()

    实例化 set 类。

    class set([iterable])

    应用示例

    >>> set()
    set()
    >>> set([2,3,3,'x'])
    {2, 3, 'x'}
    >>> set((5,'5',6))
    {'5', 5, 6}
    >>> set('hello, world')
    {'d', 'l', ' ', 'h', 'w', 'o', ',', 'e', 'r'}
    

    返回 Python内置函数(类)速查表


    11. frozenset()

    frozenset() 将参数转换为不可变集合类型。

    class frozenset([iterable])

    应用示例

    >>> frozenset()
    frozenset()
    >>> frozenset([2,3,4])
    frozenset({2, 3, 4})
    >>> frozenset('hello, world')
    frozenset({'d', 'l', ' ', 'h', 'w', 'o', ',', 'e', 'r'})
    

    返回 Python内置函数(类)速查表


    12. bytes()

    bytes() 返回一个新的“bytes”对象,它是一个区间为 [0,255] 的不可变整数序列。

    class bytes([source[, encoding[, errors]]])

    • 如果没有输入任何参数,默认就是初始化数组为0个元素。
    • 如果 source 为整数,则返回一个长度为 source 的内容初始化的数组;
    • 如果 source 为字符串,则需指定 encoding 参数将字符串转换为字节序列;
    • 如果 source 为可迭代类型,则内部元素必须为[0 ,255] 中的整数;
    • 如果 source 为与buffer 接口一致的对象,则此对象也可以被用于初始化bytearray。

    应用示例

    >>> bytes()
    b''
    >>> bytes(3)
    b'\x00\x00\x00'
    >>> bytes('123', encoding='utf-8')
    b'123'
    >>> bytes('123', encoding='utf-8')
    b'123'
    >>> bytes([1,2,3,4])
    b'\x01\x02\x03\x04'
    

    返回 Python内置函数(类)速查表


    13. bytearray()

    bytearray() 函数返回一个新的字节数组。bytearray类是一个区间为 [0,255] 的可变整数序列。它拥有可变序列的大多数常用方法,。

    class bytearray([source[, encoding[, errors]]])

    • 如果没有参数,则创建大小为0的数组。
    • 如果 source 为整数,则返回一个长度为 source 的内容初始化的数组;
    • 如果 source 为字符串,则需指定 encoding 参数将字符串转换为字节序列;
    • 如果 source 为可迭代类型,则内部元素必须为[0 ,255] 中的整数;
    • 如果对象符合buffer接口,则使用对象的只读缓冲区来初始化bytes数组。

    应用示例

    >>> bytearray()
    bytearray(b'')
    >>> bytearray(3)
    bytearray(b'\x00\x00\x00')
    >>> bytearray('123', encoding='utf-8')
    bytearray(b'123')
    >>> bytearray([1,2,3,4])
    bytearray(b'\x01\x02\x03\x04)
    

    返回 Python内置函数(类)速查表


    14. memoryview()

    memoryview() 函数返回一个由给定字节参数创建的“内存视图”对象。

    memoryview(obj)

    应用示例

    >>> a = memoryview(b'123456')
    >>> a[0]
    49
    >>> a[1:4]
    <memory at 0x00000133C47161C8>
    

    返回 Python内置函数(类)速查表


    15.type ()

    type() 函数用于显示当前对象的类型或者通过参数创造新的类型。

    type(object)
    type(name, bases, dict)

    应用示例

    >>> type(1)
    <class 'int'>
    >>> type([1,2,3,4])
    <class 'list'>
    

    返回 Python内置函数(类)速查表


    16. isinstance()

    isinstance() 函数用于判断一个对象是否属于一个已知类型。

    isinstance(object, classinfo)

    应用示例

    >>> a = 1
    >>> isinstance(a, int) 
    True
    >>> isinstance(a, (float, str, list))  
    False
    

    返回 Python内置函数(类)速查表


    17.len ()

    len() 函数用于返回当前可迭代对象的长度(或称为元素数量)。

    len( s )

    应用示例

    >>> len(b'123456abcd')
    10
    >>> len(['a','b','c','d'])
    4
    >>> len({'a':1})
    1
    >>> len({'a','b','c'})
    3
    >>> len(range(10))
    10
    

    返回 Python内置函数(类)速查表


    18. range()

    range() 函数用于构建整数列表,通常与for循环搭配使用。

    range(start, stop[, step])

    应用示例

    >>> range(5)
    range(0, 5)
    >>> list(range(5))
    [0, 1, 2, 3, 4]
    >>> for i in range(3): 
    >>>    print(i, end=' ')
    0 1 2
    >>> for i in range(2, 6) 
    >>>    print(i, end=' ')
    2 3 4 5
    >>> for i in range(1, 10, 2) 
    >>>    print(i, end=' ')
    1 3 5 7 9
    >>> for i in range(1, 10, -2) 
    >>>    print(i, end=' ')
    9 7 5 3 1
    

    返回 Python内置函数(类)速查表


    19. format()

    format() 函数用于将值转换为“格式化”表示形式。

    format(value[, format_spec])

    常用格式化符号速查表

    格式化符号 功能 示例参数 示例结果
    {:.2f} 小数保留后两位,末置位四舍五入 .format(3.14159) ‘3.14’
    {:+.2f} 小数保留后两位,保留正负值 .format(-3.14159) ‘-3.14’
    {:0>2d} 整数左侧补零,总长度不小于2 .format(5) ‘05’
    {:X<4d} 整数右侧补‘X’,总长度不小于4 .format(5) ‘5XXX’
    {:,} 逗号分隔数字 100000000 100,000,000
    {:.2%} 百分比格式保留后两位 0.25 ‘25.00%’
    {:.2e} 指数记法 100000000 ‘1.00e+08’
    {:>10d} 长度10以内右对齐 10 ‘        10’
    {:<10d} 长度10以内左对齐 10 ‘10        ’
    {:^10d} 长度10以内居中对齐 10 ‘    10    ’
    {:b} 二进制转换整数 11 ‘1011’
    {:#b} 二进制加前缀 11 ‘0b1011’
    {:d} 十进制转换整数 11 ‘11’
    {:o} 八进制转换整数 11 ‘13’
    {:#o} 八进制加前缀 11 ‘0o13’
    {:x} 十六进制转换整数 11 ‘b’
    {:#x} 十六进制加前缀规定小写 11 ‘0xb’
    {:#X} 十六进制加前缀规定大写 11 ‘0XB’

    应用示例

    >>> '姓名:{}, 年龄:{}'.format('admin', 16)
    '姓名: admin, 年龄:16'
    >>> '苹果{0}{2}, 菠萝{1}{2}'.format(12, 14, '个')
    '苹果12个, 菠萝14个'
    >>> 'pie = {:.2f}'.format(3.14159)  # 小数点只保留后两位
    'pie = 3.14'
    

    返回 Python内置函数(类)速查表


    20.max ()

    max() 函数用于返回多个参数或者迭代参数内的最大值。

    max(iterable, *[, key, default])
    max(arg1, arg2, *args[, key])

    应用示例

    >>> max(1,2,3,4,5)
    5
    >>> max([1,2,3,4,5])
    5
    
    def X(v):
    	return abs(v)   # 对每个参数先做绝对值处理
    
    >>> max(1,-2,5,-6, key=X)  # 比较所有参数里绝对值最大的元素
    6
    

    返回 Python内置函数(类)速查表


    21.min ()

    min() 函数用于返回多个参数或者迭代参数内的最小值。

    min(iterable, *[, key, default])
    min(arg1, arg2, *args[, key])

    应用示例

    >>> min(1,2,3,4,5)
    1
    >>> min([1,2,3,4,5])
    1
    
    def X(v):
    	return abs(v)   # 对每个参数先做绝对值处理
    
    >>> max(-1,-2,-5,-6, key=X)  # 比较所有参数里绝对值最小的元素
    1
    

    返回 Python内置函数(类)速查表


    22.sum ()

    sum() 函数用于返回多个参数或者迭代参数的总和。

    sum(iterable)

    应用示例

    >>> sum([1,2,3,4])
    10
    

    返回 Python内置函数(类)速查表


    23. pow()

    pow() 函数用于计算参数1的参数2次方结果,如果有参数3,则开方结果再取余参数3。

    pow(base, exp[, mod])

    应用示例

    >>> pow(2, 3)
    8
    >>> pow(2, 3, 2)
    0
    >>> pow(2, 0.5)
    1.4142135623730951
    

    返回 Python内置函数(类)速查表


    24. abs()

    abs() 函数用于计算参数的绝对值。

    abs(x)

    应用示例

    >>> abs(-20)
    20
    >>> abs(-20.5)
    20.5
    

    返回 Python内置函数(类)速查表


    25. round()

    round() 函数用于计算参数四舍五入的结果。

    round(number[, ndigits])

    应用示例

    >>> round(4.5) 
    5
    >>> round(3.259, 2) # 其精确到小数点后两位
    3.26
    

    返回 Python内置函数(类)速查表


    26.divmod ()

    divmod() 函数用于计算两个参数的商和余数。

    divmod(a, b)

    应用示例

    >>> divmod(7, 3)
    (2, 1)
    

    返回 Python内置函数(类)速查表


    27.complex ()

    complex() 函数用于将参数转换为复数。

    class complex([real[, imag]])

    应用示例

    >>> complex(1)
    (1 + 0j)
    >>> complex(1, 2)
    (1 + 2j)
    >>> complex('1')
    (1 + 0j)
    >>> complex('1+2j')    # 字符串不能有空格
    (1 + 2j)
    

    返回 Python内置函数(类)速查表


    28. all()

    all() 函数用于对迭代参数内的所有元素做判断,若全部为True,则返回True,否则返回False。

    all(iterable)

    应用示例

    >>> all([]) # 没有内部元素返回True
    True
    >>> all([0,1,2])
    False
    >>> all(['0','1','2'])
    True
    >>> all(['0','1',''])
    False
    

    返回 Python内置函数(类)速查表


    29. any()

    any() 函数用于对迭代参数内的所有元素做判断,若存在True,则返回True,不存在则返回False。

    any(iterable)

    应用示例

    >>> any([])   # 没有内部元素返回False
    False
    >>> any(0, '')
    False
    >>> any(['0','1','2'])
    True
    

    返回 Python内置函数(类)速查表


    30. bin()

    bin() 函数用于将整数转为‘0b’开头的二进制数字。

    bin(x)

    应用示例

    >>> bin(7)
    '0b111'
    >>> format(14, '#b'), format(14, 'b')
    ('0b1110', '1110')
    >>> f'{14:#b}', f'{14:b}'
    ('0b1110', '1110')
    

    返回 Python内置函数(类)速查表


    31. oct()

    oct() 函数用于将整数转为‘0o’开头的八进制数字。

    oct(x)

    应用示例

    >>> oct(14)
    '0o16'
    >>> '%#o' % 10, '%o' % 10
    ('0o12', '12')
    >>> format(10, '#o'), format(10, 'o')
    ('0o12', '12')
    >>> f'{10:#o}', f'{10:o}'
    ('0o12', '12')
    

    返回 Python内置函数(类)速查表


    32. hex()

    hex() 函数用于将整数转为‘0x’开头的十六进制数字。

    hex(x)

    应用示例

    >>> hex(256)
    '0x100'
    >>> '%#x' % 255, '%x' % 255, '%X' % 255
    ('0xff', 'ff', 'FF')
    >>> format(255, '#x'), format(255, 'x'), format(255, 'X')
    ('0xff', 'ff', 'FF')
    >>> f'{255:#x}', f'{255:x}', f'{255:X}'
    ('0xff', 'ff', 'FF')
    

    返回 Python内置函数(类)速查表


    33.chr ()

    chr() 函数返回 ascii 码值对应的字符。

    chr(i)

    应用示例

    >>> chr(65)
    'A'
    

    返回 Python内置函数(类)速查表


    34. ord()

    ord() 函数返回字符对应的 ascii 码值。

    ord(i)

    应用示例

    >>> ord('A')
    65
    

    返回 Python内置函数(类)速查表


    35. repr()

    repr() 函数用于返回一个包含可打印的对象表示形式的字符串,以供解释器读取。

    repr(object)

    应用示例

    >>> repr('a')
    "'a'"
    >>> repr(5)
    '5'
    >>> repr('中文'.encode('utf8'))
    "b'\\xe4\\xb8\\xad\\xe6\\x96\\x87'"
    >>> repr([1,2,'a','人'])
    "[1, 2, 'a', '人']"
    

    返回 Python内置函数(类)速查表


    36. ascii()

    ascii() 函数用于返回一个包含可打印的对象表示形式的字符串,以供解释器读取。遇到非ascii字符将使用\x、\u或\U来转义。

    ascii(object)

    应用示例

    >>> ascii('a')
    "'a'"
    >>> ascii(5)
    '5'
    >>> ascii('中文'.encode('utf8'))
    "b'\\xe4\\xb8\\xad\\xe6\\x96\\x87'"
    >>> ascii([1,2,'a','人'])
    "[1, 2, 'a', '\u4eba']"
    

    返回 Python内置函数(类)速查表


    37. eval()

    eval() 参数为一个字符串格式的Python表达式,直接运行表达式,返回表达式的求值结果。

    eval(expression[, globals[, locals]])

    应用示例

    >>> eval('1+2')
    3
    

    返回 Python内置函数(类)速查表


    38. exec()

    exec() 参数为一个字符串格式的Python表达式,直接运行表达式,不返回表达式的求值结果。

    exec(object[, globals[, locals]])

    应用示例

    >>> exec('a = 3+2')
    >>> a
    5
    

    返回 Python内置函数(类)速查表


    39. compile()

    compile()函数将源代码编译成代码对象。代码对象可以由 exec( )或 eval() 执行。源可以是普通字符串、字节字符串。

    compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)

    应用示例

    >>> s = compile('print(1+2)', '<string>', 'exec')
    >>> s
    <code object <module> at 0x0000018D8AB6D150, file "<string>", line 1>
    >>> exec(s)
    3
    

    返回 Python内置函数(类)速查表


    40. enumerate()

    enumerate()参数必须是序列、迭代器或其他支持迭代的对象。返回一个tuple,其中包含一个count(从默认值为0开始)和通过迭代获得的值。

    enumerate(iterable, start=0)

    应用示例

    >>> a = ['a','b','c']
    >>> for index, value in enumerate(a):
    	print(index, value, sep=': ')
    	
    0: a
    1: b
    2: c
    

    返回 Python内置函数(类)速查表


    41. reversed()

    reversed() 函数用于生成并返回一个反向迭代器。

    reversed(seq)

    应用示例

    >>> a = [1,4,2,3]
    >>> reversed(a)
    <list_reverseiterator object at 0x0000022A3B3D20C8>
    >>> list(reversed(a))
    [3, 2, 4, 1]
    

    返回 Python内置函数(类)速查表


    42.map ()

    map() 函数返回一个迭代器,该迭代器将指定函数应用于iterable的每一项。

    map(function, iterable, …)

    应用示例

    def X(v):
    	return pow(v, 2)        
    
    >>> a = map(X, [1,2,3,4,5])
    >>> list(a)
    [1, 4, 9, 16, 25]
    

    返回 Python内置函数(类)速查表


    43.sorted ()

    sorted() 函数可以对输入的迭代对象元素排序后生成新的列表。

    sorted(iterable, *, key=None, reverse=False)

    应用示例

    >>> sorted([3,7,2,8,5])
    [2, 3, 5, 7, 8]
    >>> a = [[6, 5], [3, 7], [2, 8]]
    >>> sorted(a, key=lambda x:x[0]) # 根据每一行的首元素排序,默认reverse=False
    [[2, 8], [3, 7], [6, 5]]
    >>> sorted(a, key=lambda x:x[-1]) # 根据每一行的尾元素排序,设置reverse=True实现逆序
    [[6, 5], [3, 7], [2, 8]]
    

    返回 Python内置函数(类)速查表


    44. filter()

    filter() 函数用于将输入的迭代对象根据函数筛选出为True的结果,构造成一个迭代器。

    filter(function, iterable)

    应用示例

    >>> def K(v):
    	return v<=3
    
    >>> list(filter(K, [5,2,0,3,4,1]))
    [2, 0, 3, 1]
    
    >>> list(filter(None, [0,1,2,3,4])) # 函数位置若为None,默认筛选掉所有元素内结果等于False的值
    1,2,3,4
    

    返回 Python内置函数(类)速查表


    45. iter()

    iter() 函数用于生成一个迭代器对象。

    iter(object[, sentinel])

    sentinel 参数默认为 None,即不调用该参数。当 iter() 需要调用该参数时,必须保证 iter() 传入两个参数,而且严格规定了参数1必须为可调用对象,参数2即为sentinel,传参为整数,指迭代过程中的终止值。

    应用示例

    >>> a = iter([1, 2, 3, 4])
    >>> type(a)  
    <class list_iterator>
    

    返回 Python内置函数(类)速查表


    next() 函数会从迭代器中检索下一项,如果提供了默认值,则在迭代器耗尽时返回默认值,否则将引发StopIteration错误。

    next(iterator[, default])

    应用示例

    >>> a = iter([1, 2, 3, 4])       # 将一个列表使用iter()转换为迭代器
    >>> next(a)
    1
    >>> next(a)
    2
    >>> next(a)
    3
    # 默认值使用实例
    >>> a = iter([1,2])
    >>> next(a, 0)
    1
    >>> next(a, 0)
    2
    >>> next(a, 0)      
    0
    >>> next(a, 0)       
    0
    

    返回 Python内置函数(类)速查表


    47. slice()

    slice() 函数用于返回一个切片对象,由范围(start、stop、step)指定的一组索引。

    class slice(stop)
    class slice(start, stop[, step])

    应用示例

    li = ['a','b','c','d','e','f','g','h','i']
    
    >>> s = slice(3): 
    >>> print(li[s])
    ['a', 'b', 'c']
    >>> s = slice(2, 6)
    >>> print(li[s])
    ['c', 'd', 'e', 'f']
    >>> s = slice(1, 9, 2)
    >>> print(li[s])
    ['b', 'd', 'f', 'h']
    >>> s = slice(9, 1, -2) 
    >>> print(li[s])
    ['i', 'g', 'e', 'c']
    

    返回 Python内置函数(类)速查表


    48. zip()

    zip() 函数用于创建一个迭代器来聚合来自每个迭代对象的元素,元素按照相同下标聚合,长度不同则忽略大于最短迭代对象长度的元素。

    zip(*iterables)

    应用示例

    >>> a = [1, 2, 3, 4, 5]
    >>> b = ['a', 'b', 'c', 'd']                    
    >>> list(zip(a, b))    
    [(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')]
    
    >>> for i in zip(a, b):
    >>>      print(i)
    (1, 'a')
    (2, 'b')
    (3, 'c')
    (4, 'd')
    
    >>> x, y = zip(*zip(a,b)) # zip还可用来解压
    >>> x
    (1, 2, 3, 4)
    >>> y
    ('a', 'b', 'c', 'd')
    

    返回 Python内置函数(类)速查表


    49. open()

    open() 函数打开文件并返回相应的文件对象。

    open(file, mode=‘r’, buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

    • closefd-- 文件描述符开关,默认值为True,当参数为False时,如果关闭文件,文件底层的文件描述符会保持打开状态。文件描述符只在Linux下有意义。
    • opener-- 文件描述符参数,默认值为None,用于非负整数的传递文件描述符。

    文件打开模式速查表

    mode参数 参数概述 参数功能
    r / rt 只读模式(默认) 只能获取文本内容,不能写入
    rb 二进制只读模式 使用二进制获取文本内容,
    通常用于获取图片视频等非文本
    r+ 读写追加 用于读写,文件指针放在内容开头
    rb+ 二进制读写追加 用于二进制读写,文件指针放在内容开头
    w / wt 只写模式 用于写入内容,会将原本的内容覆盖
    w+ 只写追加 用于写入内容,会在原本的内容之后续写
    wb 二进制只写模式 用于写入二进制内容,会将原本的内容覆盖
    通常用于写入图片视频等非文本
    wb+ 二进制只写追加 用于写入二进制内容,会在原本的内容之后续写
    通常用于写入图片视频等非文本
    a / at 读写追加 用于读取或写入内容,写入会在原本的内容之后续写
    没有文本则创建文本
    ab 二进制读写追加 用于读取或写入二进制内容,写入会在原本内容之后续写
    没有文本则创建文本
    a+ 读写追加 用于读取或写入内容,写入会在原本的内容之后续写
    没有文本则创建文本
    ab+ 二进制读写追加 用于读取或写入二进制内容,写入会在原本内容之后续写
    没有文本则创建文本

    应用示例

    >>> with open(r'd:\csv_data.csv', 'w') as fp:
    	for line in [[0.468,0.975,0.446],[0.718,0.826,0.359]]:
    		ok = fp.write('%s\n'%','.join([str(item) for item in data[0]]))
    		
    >>> with open(r'd:\csv_data.csv', 'r') as fp:
    	print(fp.read())
    	
    0.468,0.975,0.446
    0.468,0.975,0.446
    
    >>> with open(r'd:\csv_data.csv', 'r') as fp:
    	for line in fp.readlines():
    		print('%s - %s - %s'%tuple(line.strip().split(',')))
    		
    0.468 - 0.975 - 0.446
    0.468 - 0.975 - 0.446
    

    返回 Python内置函数(类)速查表


    50. breakpoint()

    breakpoint() 此函数将会在程序运行过程中进入调用站点的调试器中。

    breakpoint(*args, **kws)

    进入Pdb调试模式时,可使用指令进行对应的操作:

    指令 功能
    h 显示全部指令
    p 变量名 查看当前对应变量名的值
    pp 变量名 查看当前对应变量名的值(美化版)
    w 显示当前断点所在位置
    s 前进一步(若有函数,执行函数第一句)
    n 前进一步(若有函数,执行函数下一句)
    b 添加断点
    cl 清除断点
    c 继续运行程序,直到遇到下一个断点
    q 退出断点,结束程序
    程序语言 在该断点处额外执行程序

    应用示例

    >>> def factorial(n):
    	result = 1
    	for i in range(n):
    		result *= i+1
    		breakpoint()
    	return result
    
    >>> factorial(3)
    > <pyshell#34>(3)factorial()
    (Pdb) pp i, result
    (0, 1)
    (Pdb) c
    > <pyshell#34>(3)factorial()
    (Pdb) pp i, result
    (1, 2)
    (Pdb) c
    > <pyshell#34>(3)factorial()
    (Pdb) pp i, result
    (2, 6)
    (Pdb) c
    6
    

    返回 Python内置函数(类)速查表


    51.quit ()

    quit() 函数用于终止当前运行程序。

    quit(*args, **kwargs)

    应用示例

    >>> def factorial(n):
    	if n > 5:
    		quit()
    	result = 1
    	for i in range(n):
    		result *= i+1
    	return result
    
    >>> factorial(3)
    6
    >>> factorial(10) # 此时弹出窗口提示关闭IDLE
    

    返回 Python内置函数(类)速查表


    52. exit()

    exit() 函数用于终止当前运行程序。

    exit(*args, **kwargs)

    应用示例

    >>> def factorial(n):
    	if n > 5:
    		exit()
    	result = 1
    	for i in range(n):
    		result *= i+1
    	return result
    
    >>> factorial(3)
    6
    >>> factorial(10) # 此时弹出窗口提示关闭IDLE
    

    返回 Python内置函数(类)速查表


    53.hasattr ()

    hasattr() 函数用于判断当前对象。

    hasattr(object, name)

    应用示例

    >>> hasattr(list, 'append')
    True
    >>> hasattr(dict, 'update')
    True
    >>> class Demo:
     	def A(self):
    		pass
    
    >>> d = Demo()
    >>> hasattr(d, 'A')  # 判断对象d是否存在名称为A的属性 
    True
    >>> hasattr(d, 'B')  # 判断对象d是否存在名称为B的属性
    False
    

    返回 Python内置函数(类)速查表


    54. delattr()

    delattr() 函数用于将删除指定对象的属性。

    delattr(object, name)

    应用示例

    >>> class Demo:
    	def A(self):
    		pass
    	def B(self):
    		pass
    	
    >>> hasattr(Demo, 'B')
    True
    >>> delattr(Demo, 'B')
    >>> hasattr(Demo, 'B')
    False
    

    返回 Python内置函数(类)速查表


    55. getattr()

    getattr() 函数用于获取对象的指定属性值。

    getattr(object, name[, default])

    应用示例

    >>> class Demo:
     	A = 5
     	
    >>> d = Demo()
    >>> getattr(d, 'A')
    5
    >>> getattr(Demo, 'A')
    5
    

    返回 Python内置函数(类)速查表


    56.setattr ()

    setattr() 函数用于给对象的指定属性赋值。

    setattr(object, name, value)

    应用示例

    >>> class Demo:
    	A = 5
    	def __init__(self):
    		self.B = 1
    		
    >>> d = Demo()
    >>> setattr(d, 'B', 10)
    >>> getattr(d, 'B')
    10
    >>> setattr(d, 'A', 15)
    >>> getattr(d, 'A')
    15
    >>> getattr(Demo, 'A')
    5
    

    返回 Python内置函数(类)速查表


    57.dir ()

    dir() 函数如果没有参数,则返回当前局部范围内的名称列表。使用参数,尝试返回该对象的有效属性列表。

    dir([object])

    应用示例

    >>> class Demo:
    	A = 5
    	def __init__(self):
    		self.B = 1
    	def hello(self):
    		pass
    	
    d = Demo()
    >>> dir(Demo)
    ['A', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'hello']
    >>> dir(d)
    ['A', 'B', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'hello']
    

    返回 Python内置函数(类)速查表


    58. locals()

    locals() 函数返回一个表示当前本地有效参数的字典。

    locals()

    应用示例

    >>> def factorial(n):
    	result = 1
    	for i in range(n):
    		result *= i+1
    	return result, locals()
    
    >>> factorial(3)
    (6, {'n': 3, 'result': 6, 'i': 2})
    

    返回 Python内置函数(类)速查表


    59. vars()

    vars() 函数用于返回模块、类、实例或任何其他具有属性的对象的属性字典。

    vars([object])

    应用示例

    >>> class Demo:
    	A = 5
    	def __init__(self):
    		self.B = 1
    	def hello(self):
    		pass
    	
    >>> vars(Demo)
    mappingproxy({'__module__': '__main__', 'A': 5, '__init__': <function Demo.__init__ at 0x000001F08F543E58>, 'hello': <function Demo.hello at 0x000001F08F543EE8>, '__dict__': <attribute '__dict__' of 'Demo' objects>, '__weakref__': <attribute '__weakref__' of 'Demo' objects>, '__doc__': None})
    

    返回 Python内置函数(类)速查表


    60. globals()

    globals() 函数用于返回表示当前全局有效参数的字典——通常指当前模块的字典(在函数或方法中,不是调用它的模块,而是定义它的模块)。

    globals()

    应用示例

    >>> def factorial(n):
    	result = 1
    	for i in range(n):
    		result *= i+1
    	return result, globals()
    
    >>> factorial(3)
    (6, {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 'd': <__main__.Demo object at 0x000001F08F54B088>, 'Demo': <class '__main__.Demo'>, 'factorial': <function factorial at 0x000001F08F543F78>})
    

    返回 Python内置函数(类)速查表


    61. help()

    help() 函数用于调用内置的帮助系统。如果没有给出参数,交互式帮助系统将在解释器控制台启动。如果参数是字符串,那么该字符串将作为模块、函数、类、方法、关键字或文档主题的名称进行查找,并在控制台上打印帮助页面。如果参数是任何其他类型的对象,则生成该对象的帮助页。

    help([object])

    应用示例

    >>> class Demo:
    	A = 5
    	def __init__(self):
    		self.B = 1
    	def hello(self):
    		pass
    
    	
    >>> help(Demo)
    Help on class Demo in module __main__:
    
    class Demo(builtins.object)
     |  Methods defined here:
     |  
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |  
     |  hello(self)
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |  
     |  __dict__
     |      dictionary for instance variables (if defined)
     |  
     |  __weakref__
     |      list of weak references to the object (if defined)
     |  
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |  
     |  A = 5
    

    返回 Python内置函数(类)速查表


    62. id()

    id() 函数用于获取对象的内存地址。

    id(object)

    应用示例

    >>> a = [3,4,5]
    >>> b = a
    >>> c = [3,4,5]
    >>> id(a), id(b), id(c)
    (2132708704136, 2132708704136, 2132708704072)
    

    返回 Python内置函数(类)速查表


    63.hash ()

    hash() 函数用于获取对象的哈希值。

    hash(object)

    应用示例

    >>> hash('123xyzxufive')
    7482598040289208751
    

    返回 Python内置函数(类)速查表


    64. super()

    super() 函数返回一个代理对象,该对象将方法调用委托给类型的父类或兄弟类。这对于访问在类中被覆盖的继承方法非常有用。

    super([type[, object-or-type]])

    应用示例

    >>> class A:
    	def __init__(self, name):
    		self.name = name
    	def hello(self):
    		print('Name: %s'%self.name)
    		
    >>> class B(A):
    	def __init__(self, name, age):
    		super().__init__(name)
    		self.age = age
    	def hello(self):
    		super().hello()
    		print('Age: %d'%self.age)
    		
    >>> b = B('Youth', 18)
    >>> b.hello()
    Name: Youth
    Age: 18
    

    返回 Python内置函数(类)速查表


    65. object()

    返回一个没有特征的新对象。object 是所有类的基类。它具有所有 Python 类实例的通用方法。这个函数不接受任何实参。

    class object

    应用示例

    >>> a = object()
    >>> dir(a)
    ['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']
    

    返回 Python内置函数(类)速查表


    66. callable()

    如果对象参数看起来是可调用的,则返回True;如果不是,则返回False。

    callable(object)

    应用示例

    >>> a = ['x', print]
    >>> callable(a)
    False
    >>> callable(a.append)
    True
    >>> callable(a[0])
    False
    >>> callable(a[1])
    True
    

    返回 Python内置函数(类)速查表


    67. issubclass()

    issubclass() 用于判断class 是否是classinfo的子类。

    issubclass(class, classinfo)

    应用示例

    >>> class A:
    	pass
    
    >>> class B(A):
    	pass
    
    >>> class C:
    	pass
    
    >>> issubclass(B, A)
    True
    >>> issubclass(C, A)
    False
    

    返回 Python内置函数(类)速查表


    68. classmethod()

    装饰器函数,定义类的静态函数的方法之一。类的静态函数接收类 cls 作为隐式的第一个参数,就像实例方法接收实例一样。

    classmethod(function
    …@classmethod

    应用示例

    >>> class Demo:
    	@classmethod
    	def hello(cls):
    		print('我是静态函数')
    		
    >>> Demo.hello()
    我是静态函数
    

    返回 Python内置函数(类)速查表


    69. staticmethod()

    装饰器函数,定义类的静态函数的方法之一。静态方法不接收隐式的第一个参数。

    classmethod(function
    …@staticmethod

    应用示例

    >>> class Demo:
    	@staticmethod
    	def hello():
    		print('我是静态函数')
    
    		
    >>> Demo.hello()
    我是静态函数
    

    返回 Python内置函数(类)速查表


    70. property()

    返回一个属性。fget是一个获取属性值的函数,fset是设置属性值的函数,fdel是一个用于删除属性值的函数,doc为属性创建一个docstring。

    class property(fget=None, fset=None, fdel=None, doc=None)
    @property

    应用示例

    >>> class A:
    	def __init__(self, age):
    		self.age = age
    	def old(self):
    		return self.age
    
    	
    >>> a = A(18)
    >>> a.age
    18
    >>> a.old()
    18
    >>> class A:
    	def __init__(self, age):
    		self.age = age
    	@property
    	def old(self):
    		return self.age
    
    	
    >>> a = A(20)
    >>> a.age
    20
    >>> a.old
    20
    >>> a.old()
    Traceback (most recent call last):
      File "<pyshell#59>", line 1, in <module>
        a.old()
    TypeError: 'int' object is not callable
    

    返回 Python内置函数(类)速查表


    打印版权通知。

    copyright(*args, **kwargs)

    应用示例

    >>> copyright()
    Copyright (c) 2001-2019 Python Software Foundation.
    All Rights Reserved.
    
    Copyright (c) 2000 BeOpen.com.
    All Rights Reserved.
    
    Copyright (c) 1995-2001 Corporation for National Research Initiatives.
    All Rights Reserved.
    
    Copyright (c) 1991-1995 Stichting Mathematisch Centrum, Amsterdam.
    All Rights Reserved.
    

    返回 Python内置函数(类)速查表


    72. credits()

    打印感谢名单。

    credits(*args, **kwargs)

    应用示例

    >>> credits()
        Thanks to CWI, CNRI, BeOpen.com, Zope Corporation and a cast of thousands
        for supporting Python development.  See www.python.org for more information.
    

    返回 Python内置函数(类)速查表


    73. license()

    打印python历史 相关开发团队。

    license(*args, **kwargs)

    应用示例

    >>> license()
    A. HISTORY OF THE SOFTWARE
    ==========================
    
    Python was created in the early 1990s by Guido van Rossum at Stichting
    Mathematisch Centrum (CWI, see http://www.cwi.nl) in the Netherlands
    as a successor of a language called ABC.  Guido remains Python's
    principal author, although it includes many contributions from others.
    
    In 1995, Guido continued his work on Python at the Corporation for
    National Research Initiatives (CNRI, see http://www.cnri.reston.va.us)
    in Reston, Virginia where he released several versions of the
    software.
    
    In May 2000, Guido and the Python core development team moved to
    BeOpen.com to form the BeOpen PythonLabs team.  In October of the same
    year, the PythonLabs team moved to Digital Creations, which became
    Zope Corporation.  In 2001, the Python Software Foundation (PSF, see
    https://www.python.org/psf/) was formed, a non-profit organization
    created specifically to own Python-related Intellectual Property.
    Zope Corporation was a sponsoring member of the PSF.
    
    All Python releases are Open Source (see http://www.opensource.org for
    the Open Source Definition).  Historically, most, but not all, Python
    Hit Return for more, or q (and Return) to quit: 
    releases have also been GPL-compatible; the table below summarizes
    the various releases.
    
        Release         Derived     Year        Owner       GPL-
                        from                                compatible? (1)
    
        0.9.0 thru 1.2              1991-1995   CWI         yes
        1.3 thru 1.5.2  1.2         1995-1999   CNRI        yes
        1.6             1.5.2       2000        CNRI        no
        2.0             1.6         2000        BeOpen.com  no
        1.6.1           1.6         2001        CNRI        yes (2)
        2.1             2.0+1.6.1   2001        PSF         no
        2.0.1           2.0+1.6.1   2001        PSF         yes
        2.1.1           2.1+2.0.1   2001        PSF         yes
        2.1.2           2.1.1       2002        PSF         yes
        2.1.3           2.1.2       2002        PSF         yes
        2.2 and above   2.1.1       2001-now    PSF         yes
    
    Footnotes:
    
    (1) GPL-compatible doesn't mean that we're distributing Python under
        the GPL.  All Python licenses, unlike the GPL, let you distribute
        a modified version without making your changes open source.  The
    Hit Return for more, or q (and Return) to quit: 
    

    返回 Python内置函数(类)速查表


    后记

    近期有很多朋友通过私信咨询有关Python学习问题。为便于交流,我在CSDN的app上创建了“Python作业辅导”大本营,面向Python初学者,为大家提供咨询服务、辅导Python作业。欢迎有兴趣的同学使用微信扫码加入。

    在这里插入图片描述

    从博客到公众号,每一篇、每一题、每一句、每一行代码,都坚持原创,绝不复制抄袭,这是我坚守的原则。如果喜欢,请关注我的微信公众号“Python作业辅导员”。

    在这里插入图片描述

    展开全文
  • 轻松学习Python 69个内置函数

    千人学习 2020-10-16 16:41:22
    课程介绍 ---------- Python内置函数是非常重要的Python基础,本课程通过Python内置函数官网文档,以一个内置函数一节课的方式讲解Python内置函数。   ### 内置函数官网文档截图     ### 备注 课程...
  • Python内置函数

    千次阅读 多人点赞 2019-05-10 15:10:36
    Python内置函数Python abs()函数Python all() 函数Python any() 函数Python basestring() 函数Python bin() 函数Python bool() 函数Python bytearray() 函数Python callable() 函数Python chr() 函数Python ...

    Python内置函数

    Python abs()函数

    描述:
    abs() 函数返回数字的绝对值。

    abs() 方法的语法:
    abs( x )

    参数:

    x – 数值表达式。

    返回值:
    函数返回x(数字)的绝对值。

    实例:

    print "abs(-45) : ", abs(-45)
    print "abs(100.12) : ", abs(100.12)
    print "abs(119L) : ", abs(119L)
    

    输出结果:

    abs(-45) :  45
    abs(100.12) :  100.12
    abs(119L) :  119
    

    Python all() 函数

    描述:
    all() 函数用于判断给定的可迭代参数 iterable 中的所有元素是否都为 True,如果是返回 True,否则返回 False。
    元素除了是 0、空、None、False 外都算 True。

    以下是 all() 方法的语法:
    all(iterable)

    参数:

    iterable – 元组或列表。

    返回值:
    如果iterable的所有元素不为0、’’、False或者iterable为空,all(iterable)返回True,否则返回False;
    注意:空元组、空列表返回值为True,这里要特别注意。

    all(['a', 'b', 'c', 'd'])  # 列表list,元素都不为空或0
    
    True
    
    all(['a', 'b', '', 'd'])   # 列表list,存在一个为空的元素
    
    False
    
    all([0, 1,2, 3])          # 列表list,存在一个为0的元素
    
    False  
    
    all(('a', 'b', 'c', 'd'))  # 元组tuple,元素都不为空或0
    
    True
    
    all(('a', 'b', '', 'd'))   # 元组tuple,存在一个为空的元素
    
    False
    
    all((0, 1, 2, 3))          # 元组tuple,存在一个为0的元素
    
    False  
    
    all([])             # 空列表
    
    True
    
    all(())             # 空元组
    
    True
    

    Python any() 函数

    描述:
    any() 函数用于判断给定的可迭代参数 iterable 是否全部为 False,则返回 False,如果有一个为 True,则返回 True。
    元素除了是 0、空、False 外都算 True。

    any() 方法的语法:
    any(iterable)

    参数:

    iterable – 元组或列表。

    返回值:
    如果都为空、0、false,则返回false,如果不都为空、0、false,则返回true。

    实例:

    any(['a', 'b', 'c', 'd'])  # 列表list,元素都不为空或0
    True
     
    any(['a', 'b', '', 'd'])   # 列表list,存在一个为空的元素
    True
     
    any([0, '', False])        # 列表list,元素全为0,'',false
    False
     
    any(('a', 'b', 'c', 'd'))  # 元组tuple,元素都不为空或0
    True
     
    any(('a', 'b', '', 'd'))   # 元组tuple,存在一个为空的元素
    True
     
    any((0, '', False))        # 元组tuple,元素全为0,'',false
    False
      
    any([]) # 空列表
    False
     
    any(()) # 空元组
    False
    

    Python basestring() 函数

    描述:
    basestring() 方法是 str 和 unicode 的超类(父类),也是抽象类,因此不能被调用和实例化,但可以被用来判断一个对象是否为 str 或者 unicode 的实例,isinstance(obj, basestring) 等价于 isinstance(obj, (str, unicode))。

    basestring() 方法的语法:
    basestring()

    参数:

    返回值:

    实例:

    isinstance("Hello world", str)
    True
    
    isinstance("Hello world", basestring)
    True
    

    Python bin() 函数

    描述:
    bin() 返回一个整数 int 或者长整数 long int 的二进制表示。

    bin() 方法的语法:
    bin(x)

    参数:

    x – int 或者 long int 数字

    返回值:
    字符串

    实例:

    bin(10)
    '0b1010'
    bin(20)
    '0b10100'
    

    Python bool() 函数

    描述:

    bool() 函数用于将给定参数转换为布尔类型,如果没有参数,返回 False。
    bool 是 int 的子类。

    bool() 方法的语法:
    class bool([x])

    参数:

    x – 要进行转换的参数。

    返回值:
    返回 Ture 或 False。

    实例:

    bool()
    False
    
    bool(0)
    False
    
    bool(1)
    True
    
    bool(2)
    True
    
    issubclass(bool, int)  # bool 是 int 子类
    True
    

    Python bytearray() 函数

    描述:
    bytearray() 方法返回一个新字节数组。这个数组里的元素是可变的,并且每个元素的值范围: 0 <= x < 256。

    bytearray()方法语法:
    class bytearray([source[, encoding[, errors]]])

    参数:

    如果 source 为整数,则返回一个长度为 source 的初始化数组;
    如果 source 为字符串,则按照指定的 encoding 将字符串转换为字节序列;
    如果 source 为可迭代类型,则元素必须为[0 ,255] 中的整数;
    如果 source 为与 buffer 接口一致的对象,则此对象也可以被用于初始化 bytearray。
    如果没有输入任何参数,默认就是初始化数组为0个元素。

    返回值:
    返回新字节数组

    实例:

    >>>bytearray()
    bytearray(b'')
    >>> bytearray([1,2,3])
    bytearray(b'\x01\x02\x03')
    >>> bytearray('runoob', 'utf-8')
    bytearray(b'runoob')
    >>>
    

    Python callable() 函数

    描述:
    callable() 函数用于检查一个对象是否是可调用的。如果返回 True,object 仍然可能调用失败;但如果返回 False,调用对象 object 绝对不会成功。
    对于函数、方法、lambda 函式、 类以及实现了 call 方法的类实例, 它都返回 True。

    callable()方法语法:
    callable(object)

    参数:
    object – 对象

    返回值:
    可调用返回 True,否则返回 False。

    实例:

    >>>callable(0)
    False
    >>> callable("runoob")
    False
     
    >>> def add(a, b):
    ...     return a + b
    ... 
    >>> callable(add)             # 函数返回 True
    True
    >>> class A:                  # 类
    ...     def method(self):
    ...             return 0
    ... 
    >>> callable(A)               # 类返回 True
    True
    >>> a = A()
    >>> callable(a)               # 没有实现 __call__, 返回 False
    False
    >>> class B:
    ...     def __call__(self):
    ...             return 0
    ... 
    >>> callable(B)
    True
    >>> b = B()
    >>> callable(b)               # 实现 __call__, 返回 True
    True
    

    Python chr() 函数

    描述:
    chr() 用一个范围在 range(256)内的(就是0~255)整数作参数,返回一个对应的字符。

    chr() 方法的语法:
    chr(i)

    参数:

    i – 可以是10进制也可以是16进制的形式的数字。

    返回值:
    返回值是当前整数对应的 ASCII 字符。

    实例:

    >>>print chr(0x30), chr(0x31), chr(0x61)   # 十六进制
    0 1 a
    >>> print chr(48), chr(49), chr(97)         # 十进制
    0 1 a
    

    Python classmethod 修饰符

    描述:
    classmethod 修饰符对应的函数不需要实例化,不需要 self 参数,但第一个参数需要是表示自身类的 cls 参数,可以来调用类的属性,类的方法,实例化对象等。

    classmethod 语法:
    classmethod

    参数:
    无。

    返回值:
    返回函数的类方法。

    实例:
    class A(object):
    bar = 1
    def func1(self):
    print (‘foo’)
    @classmethod
    def func2(cls):
    print (‘func2’)
    print (cls.bar)
    cls().func1() # 调用 foo 方法

    A.func2()               # 不需要实例化
    

    输出结果为:

    func2
    1
    foo
    

    Python cmp() 函数

    描述:
    cmp(x,y) 函数用于比较2个对象,如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。

    cmp() 方法的语法:
    cmp( x, y )

    参数:

    x – 数值表达式。
    y – 数值表达式。

    返回值
    如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。

    以下展示了使用 cmp() 方法的实例:

    print "cmp(80, 100) : ", cmp(80, 100)
    print "cmp(180, 100) : ", cmp(180, 100)
    print "cmp(-80, 100) : ", cmp(-80, 100)
    print "cmp(80, -100) : ", cmp(80, -100)
    

    以上实例运行后输出结果为:

    cmp(80, 100) :  -1
    cmp(180, 100) :  1
    cmp(-80, 100) :  -1
    cmp(80, -100) :  1
    

    Python 3.X 的版本中已经没有 cmp 函数,如果你需要实现比较功能,需要引入 operator 模块,适合任何对象,包含的方法有:

    operator.lt(a, b)
    operator.le(a, b)
    operator.eq(a, b)
    operator.ne(a, b)
    operator.ge(a, b)
    operator.gt(a, b)
    operator.lt(a, b)
    operator.le(a, b)
    operator.eq(a, b)
    operator.ne(a, b)
    operator.ge(a, b)
    operator.gt(a, b)
    实例

    import operator
    operator.eq('hello', 'name');
    operator.eq('hello', 'hello');
    

    结果:

    False
    True
    

    Python compile() 函数

    描述:
    compile() 函数将一个字符串编译为字节代码。

    compile() 方法的语法:
    compile(source, filename, mode[, flags[, dont_inherit]])

    参数:

    source – 字符串或者AST(Abstract Syntax Trees)对象。。
    filename – 代码文件名称,如果不是从文件读取代码则传递一些可辨认的值。
    mode – 指定编译代码的种类。可以指定为 exec, eval, single。
    flags – 变量作用域,局部命名空间,如果被提供,可以是任何映射对象。。
    flags和dont_inherit是用来控制编译源码时的标志

    返回值
    返回表达式执行结果。

    以下展示了使用 compile 函数的实例:

    >>>str = "for i in range(0,10): print(i)" 
    >>> c = compile(str,'','exec')   # 编译为字节代码对象 
    >>> c
    <code object <module> at 0x10141e0b0, file "", line 1>
    >>> exec(c)
    0
    1
    2
    3
    4
    5
    6
    7
    8
    9
    >>> str = "3 * 4 + 5"
    >>> a = compile(str,'','eval')
    >>> eval(a)
    17
    

    Python complex() 函数

    描述

    complex() 函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串,则不需要指定第二个参数。。

    complex 语法:
    class complex([real[, imag]])

    参数说明:

    real – int, long, float或字符串;
    imag – int, long, float;

    返回值
    返回一个复数。

    以下实例展示了 complex 的使用方法:

    >>>complex(1, 2)
    (1 + 2j)
     
    >>> complex(1)    # 数字
    (1 + 0j)
     
    >>> complex("1")  # 当做字符串处理
    (1 + 0j)
     
    # 注意:这个地方在"+"号两边不能有空格,也就是不能写成"1 + 2j",应该是"1+2j",否则会报错
    >>> complex("1+2j")
    (1 + 2j)
    

    Python delattr() 函数

    描述:

    delattr 函数用于删除属性。
    delattr(x, ‘foobar’) 相等于 del x.foobar。

    delattr 语法:
    delattr(object, name)

    参数:

    object – 对象。
    name – 必须是对象的属性。

    返回值:
    无。

    以下实例展示了 delattr 的使用方法:

    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
     
    class Coordinate:
        x = 10
        y = -5
        z = 0
     
    point1 = Coordinate() 
     
    print('x = ',point1.x)
    print('y = ',point1.y)
    print('z = ',point1.z)
     
    delattr(Coordinate, 'z')
     
    print('--删除 z 属性后--')
    print('x = ',point1.x)
    print('y = ',point1.y)
     
    # 触发错误
    print('z = ',point1.z)
    
    输出结果:
    
    ('x = ', 10)
    ('y = ', -5)
    ('z = ', 0)
    --删除 z 属性后--
    ('x = ', 10)
    ('y = ', -5)
    Traceback (most recent call last):
      File "test.py", line 22, in <module>
        print('z = ',point1.z)
    AttributeError: Coordinate instance has no attribute 'z'
    

    Python dict() 函数

    描述:
    dict() 函数用于创建一个字典。

    dict 语法:
    class dict(**kwarg)
    class dict(mapping, **kwarg)
    class dict(iterable, **kwarg)

    参数说明:

    **kwargs – 关键字
    mapping – 元素的容器。
    iterable – 可迭代对象。

    返回值:
    返回一个字典。

    以下实例展示了 dict 的使用方法:

    >>>dict()                        # 创建空字典
    {}
    >>> dict(a='a', b='b', t='t')     # 传入关键字
    {'a': 'a', 'b': 'b', 't': 't'}
    >>> dict(zip(['one', 'two', 'three'], [1, 2, 3]))   # 映射函数方式来构造字典
    {'three': 3, 'two': 2, 'one': 1} 
    >>> dict([('one', 1), ('two', 2), ('three', 3)])    # 可迭代对象方式来构造字典
    {'three': 3, 'two': 2, 'one': 1}
    >>>
    

    Python dir() 函数

    描述:
    dir() 函数不带参数时,返回当前范围内的变量、方法和定义的类型列表;带参数时,返回参数的属性、方法列表。如果参数包含方法__dir__(),该方法将被调用。如果参数不包含__dir__(),该方法将最大限度地收集参数信息。

    dir 语法:
    dir([object])

    参数说明:

    object – 对象、变量、类型。

    返回值:
    返回模块的属性列表。

    以下实例展示了 dir 的使用方法:

    >>>dir()   #  获得当前模块的属性列表
    ['__builtins__', '__doc__', '__name__', '__package__', 'arr', 'myslice']
    >>> dir([ ])    # 查看列表的方法
    ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
    >>>
    

    Python divmod() 函数

    描述:
    python divmod() 函数把除数和余数运算结果结合起来,返回一个包含商和余数的元组(a // b, a % b)。

    函数语法:
    divmod(a, b)
    Python divmod() 函数

    Python 内置函数 Python 内置函数

    python divmod() 函数把除数和余数运算结果结合起来,返回一个包含商和余数的元组(a // b, a % b)。

    在 python 2.3 版本之前不允许处理复数。
    函数语法

    divmod(a, b)

    参数说明:

    a: 数字
    b: 数字

    实例

    >>>divmod(7, 2)
    (3, 1)
    >>> divmod(8, 2)
    (4, 0)
    >>> divmod(1+2j,1+0.5j)
    ((1+0j), 1.5j)
    

    Python enumerate() 函数

    描述:
    enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列,同时列出数据和数据下标,一般用在 for 循环当中。

    enumerate() 方法的语法:
    enumerate(sequence, [start=0])

    参数:

    sequence – 一个序列、迭代器或其他支持迭代对象。
    start – 下标起始位置。

    返回值:
    返回 enumerate(枚举) 对象。

    以下展示了使用 enumerate() 方法的实例:

    >>>seasons = ['Spring', 'Summer', 'Fall', 'Winter']
    >>> list(enumerate(seasons))
    [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
    >>> list(enumerate(seasons, start=1))       # 下标从 1 开始
    [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
    

    普通的 for 循环

    >>>i = 0
    >>> seq = ['one', 'two', 'three']
    >>> for element in seq:
    ...     print i, seq[i]
    ...     i +=1
    ... 
    0 one
    1 two
    2 three
    

    for 循环使用 enumerate

    >>>seq = ['one', 'two', 'three']
    >>> for i, element in enumerate(seq):
    ...     print i, element
    ... 
    0 one
    1 two
    2 three
    

    Python eval() 函数

    描述:
    eval() 函数用来执行一个字符串表达式,并返回表达式的值。

    eval() 方法的语法:
    eval(expression[, globals[, locals]])

    参数:

    expression – 表达式。
    globals – 变量作用域,全局命名空间,如果被提供,则必须是一个字典对象。
    locals – 变量作用域,局部命名空间,如果被提供,可以是任何映射对象。

    返回值:
    返回表达式计算结果。

    以下展示了使用 eval() 方法的实例:

    >>>x = 7
    >>> eval( '3 * x' )
    21
    >>> eval('pow(2,2)')
    4
    >>> eval('2 + 2')
    4
    >>> n=81
    >>> eval("n + 4")
    85
    

    Python execfile() 函数

    描述:

    execfile() 函数可以用来执行一个文件。

    execfile() 方法的语法:
    execfile(filename[, globals[, locals]])

    参数

    filename – 文件名。
    globals – 变量作用域,全局命名空间,如果被提供,则必须是一个字典对象。
    locals – 变量作用域,局部命名空间,如果被提供,可以是任何映射对象。

    返回值
    返回表达式执行结果。

    以下展示了使用 execfile 函数的实例:

    假设文件 hello.py,内容如下:

    print('runoob');
    

    execfile 调用该文件

    >>>execfile('hello.py')
    runoob
    

    Python file() 函数

    描述
    file() 函数用于创建一个 file 对象,它有一个别名叫 open(),更形象一些,它们是内置函数。参数是以字符串的形式传递的。
    更多文件操作可参考:Python 文件I/O。

    file() 方法的语法:
    file(name[, mode[, buffering]])

    参数

    name – 文件名
    mode – 打开模式
    buffering – 0 表示不缓冲,如果为 1 表示进行行缓冲,大于 1 为缓冲区大小。

    返回值
    文件对象。
    实例

    测试文件 test.txt,内容如下:

    RUNOOB1
    RUNOOB2
    
    >>>f = file('test.txt')
    >>> f.read()
    'RUNOOB1\nRUNOOB2\n'
    

    Python filter() 函数

    描述
    filter() 函数用于过滤序列,过滤掉不符合条件的元素,返回由符合条件元素组成的新列表。
    该接收两个参数,第一个为函数,第二个为序列,序列的每个元素作为参数传递给函数进行判,然后返回 True 或 False,最后将返回 True 的元素放到新列表中。

    注意: Pyhton2.7 返回列表,Python3.x 返回迭代器对象,具体内容可以查看:Python3 filter() 函数
    

    filter() 方法的语法:
    filter(function, iterable)

    参数

    function – 判断函数。
    iterable – 可迭代对象。

    返回值
    返回列表。

    以下展示了使用 filter 函数的实例:
    过滤出列表中的所有奇数:

    def is_odd(n):
        return n % 2 == 1
     
    newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
    print(newlist)
    

    输出结果 :

    [1, 3, 5, 7, 9]
    

    过滤出1~100中平方根是整数的数:

    import math
    def is_sqr(x):
        return math.sqrt(x) % 1 == 0
     
    newlist = filter(is_sqr, range(1, 101))
    print(newlist)
    

    输出结果 :

    [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
    

    Python float() 函数

    描述
    float() 函数用于将整数和字符串转换成浮点数。

    float()方法语法:
    class float([x])

    参数

    x – 整数或字符串

    返回值
    返回浮点数。

    以下实例展示了 float() 的使用方法:

    >>>float(1)
    1.0
    >>> float(112)
    112.0
    >>> float(-123.6)
    -123.6
    >>> float('123')     # 字符串
    123.0
    

    Python format 格式化函数

    以下实例展示了format()的使用方法:

    "{} {}".format("hello", "world")    # 不设置指定位置,按默认顺序
    "{0} {1}".format("hello", "world")  # 设置指定位置
    "{1} {0} {1}".format("hello", "world")  # 设置指定位置
    

    输出结果:

    'hello world'
    'hello world'
    'world hello world'
    

    Python frozenset() 函数

    描述

    frozenset() 返回一个冻结的集合,冻结后集合不能再添加或删除任何元素。

    frozenset() 函数语法:

    class frozenset([iterable])

    参数

    iterable – 可迭代的对象,比如列表、字典、元组等等。

    返回值

    返回新的 frozenset 对象,如果不提供任何参数,默认会生成空集合。

    以下实例展示了 frozenset() 的使用方法:

    >>>a = frozenset(range(10))     # 生成一个新的不可变集合
    >>> a
    frozenset([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
    >>> b = frozenset('runoob') 
    >>> b
    frozenset(['b', 'r', 'u', 'o', 'n'])   # 创建不可变集合
    >>>
    

    Python getattr() 函数

    描述
    getattr() 函数用于返回一个对象属性值。

    getattr 语法:

    getattr(object, name[, default])

    参数

    object – 对象。
    name – 字符串,对象属性。
    default – 默认返回值,如果不提供该参数,在没有对应属性时,将触发 AttributeError。
    返回值
    返回对象属性值。

    以下实例展示了 getattr 的使用方法:

    >>>class A(object):
    ...     bar = 1
    ... 
    >>> a = A()
    >>> getattr(a, 'bar')        # 获取属性 bar 值
    1
    >>> getattr(a, 'bar2')       # 属性 bar2 不存在,触发异常
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    AttributeError: 'A' object has no attribute 'bar2'
    >>> getattr(a, 'bar2', 3)    # 属性 bar2 不存在,但设置了默认值
    3
    >>>
    

    Python globals() 函数

    描述

    globals() 函数会以字典类型返回当前位置的全部全局变量。

    globals() 函数语法:

    globals()

    参数

    返回值

    返回全局变量的字典。

    以下实例展示了 globals() 的使用方法:

    >>>a='runoob'
    >>> print(globals()) # globals 函数返回一个全局变量的字典,包括所有导入的变量。
    {'__builtins__': <module '__builtin__' (built-in)>, '__name__': '__main__', '__doc__': None, 'a': 'runoob', '__package__': None}
    

    Python hasattr() 函数

    描述

    hasattr() 函数用于判断对象是否包含对应的属性。

    hasattr 语法:

    hasattr(object, name)

    参数

    object – 对象。
    name – 字符串,属性名。
    返回值
    如果对象有该属性返回 True,否则返回 False。

    以下实例展示了 hasattr 的使用方法:

    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
     
    class Coordinate:
        x = 10
        y = -5
        z = 0
     
    point1 = Coordinate() 
    print(hasattr(point1, 'x'))
    print(hasattr(point1, 'y'))
    print(hasattr(point1, 'z'))
    print(hasattr(point1, 'no'))  # 没有该属性
    

    输出结果:

    True
    True
    True
    False
    

    Python hash() 函数

    描述

    hash() 用于获取取一个对象(字符串或者数值等)的哈希值。

    hash 语法:

    hash(object)

    参数说明:

    object – 对象;
    返回值
    返回对象的哈希值。

    以下实例展示了 hash 的使用方法:

    >>>hash('test')            # 字符串
    2314058222102390712
    >>> hash(1)                 # 数字
    1
    >>> hash(str([1,2,3]))      # 集合
    1335416675971793195
    >>> hash(str(sorted({'1':1}))) # 字典
    7666464346782421378
    >>>
    

    Python hash() 函数

    描述
    hash() 用于获取取一个对象(字符串或者数值等)的哈希值。

    hash 语法:

    hash(object)

    参数说明:

    object – 对象;
    返回值
    返回对象的哈希值。

    以下实例展示了 hash 的使用方法:

    >>>hash('test')            # 字符串
    2314058222102390712
    >>> hash(1)                 # 数字
    1
    >>> hash(str([1,2,3]))      # 集合
    1335416675971793195
    >>> hash(str(sorted({'1':1}))) # 字典
    7666464346782421378
    >>>
    

    Python hex() 函数

    描述

    hex() 函数用于将10进制整数转换成16进制,以字符串形式表示。

    hex 语法:

    hex(x)

    参数说明:

    x – 10进制整数
    返回值
    返回16进制数,以字符串形式表示。

    以下实例展示了 hex 的使用方法:

    >>>hex(255)
    '0xff'
    >>> hex(-42)
    '-0x2a'
    >>> hex(1L)
    '0x1L'
    >>> hex(12)
    '0xc'
    >>> type(hex(12))
    <class 'str'>      # 字符串
    

    Python id() 函数

    描述

    id() 函数用于获取对象的内存地址。

    id 语法:

    id([object])

    参数说明:

    object – 对象。
    返回值
    返回对象的内存地址。

    以下实例展示了 id 的使用方法:

    >>>a = 'runoob'
    >>> id(a)
    4531887632
    >>> b = 1
    >>> id(b)
    140588731085608
    

    Python3 input() 函数

    Python3.x 中 input() 函数接受一个标准输入数据,返回为 string 类型。
    注意:在 Python3.x 中 raw_input() 和 input() 进行了整合,去除了 raw_input( ),仅保留了input( )函数,其接收任意任性输入,将所有输入默认为字符串处理,并返回字符串类型。

    函数语法

    input([prompt])

    参数说明:

    prompt: 提示信息

    input() 需要输入 python 表达式

    >>>a = input("input:")
    input:123                  # 输入整数
    >>> type(a)
    <class 'str'>              # 字符串
    >>> a = input("input:")    
    input:runoob              # 正确,字符串表达式
    >>> type(a)
    <class 'str'>             # 字符串
    

    Python int() 函数

    描述

    int() 函数用于将一个字符串或数字转换为整型。

    以下是 int() 方法的语法:

    class int(x, base=10)

    参数

    x – 字符串或数字。
    base – 进制数,默认十进制。
    返回值
    返回整型数据。

    以下展示了使用 int() 方法的实例:

    >>>int()               # 不传入参数时,得到结果0
    0
    >>> int(3)
    3
    >>> int(3.6)
    3
    >>> int('12',16)        # 如果是带参数base的话,12要以字符串的形式进行输入,12 为 16进制
    18
    >>> int('0xa',16)  
    10  
    >>> int('10',8)  
    8
    

    #Python isinstance() 函数

    描述
    isinstance() 函数来判断一个对象是否是一个已知的类型,类似 type()。
    isinstance() 与 type() 区别:
    type() 不会认为子类是一种父类类型,不考虑继承关系。
    isinstance() 会认为子类是一种父类类型,考虑继承关系。
    如果要判断两个类型是否相同推荐使用 isinstance()。

    以下是 isinstance() 方法的语法:

    isinstance(object, classinfo)

    参数

    object – 实例对象。
    classinfo – 可以是直接或间接类名、基本类型或者由它们组成的元组。
    返回值
    如果对象的类型与参数二的类型(classinfo)相同则返回 True,否则返回 False。。

    以下展示了使用 isinstance 函数的实例:

    >>>a = 2
    >>> isinstance (a,int)
    True
    >>> isinstance (a,str)
    False
    >>> isinstance (a,(str,int,list))    # 是元组中的一个返回 True
    True
    

    type() 与 isinstance()区别:

    class A:
        pass
     
    class B(A):
        pass
     
    isinstance(A(), A)    # returns True
    type(A()) == A        # returns True
    isinstance(B(), A)    # returns True
    type(B()) == A        # returns False
    

    Python issubclass() 函数

    描述

    issubclass() 方法用于判断参数 class 是否是类型参数 classinfo 的子类。

    以下是 issubclass() 方法的语法:

    issubclass(class, classinfo)

    参数

    class – 类。
    classinfo – 类。
    返回值
    如果 class 是 classinfo 的子类返回 True,否则返回 False。

    以下展示了使用 issubclass 函数的实例:

    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
     
    class A:
        pass
    class B(A):
        pass
        
    print(issubclass(B,A))    # 返回 True
    

    Python iter() 函数

    描述

    iter() 函数用来生成迭代器。

    以下是 iter() 方法的语法:

    iter(object[, sentinel])

    参数

    object – 支持迭代的集合对象。
    sentinel – 如果传递了第二个参数,则参数 object 必须是一个可调用的对象(如,函数),此时,iter 创建了一个迭代器对象,每次调用这个迭代器对象的__next__()方法时,都会调用 object。
    打开模式
    返回值
    迭代器对象。

    实例

    >>>lst = [1, 2, 3]
    >>> for i in iter(lst):
    ...     print(i)
    ... 
    1
    2
    3
    

    Python len()方法

    描述

    Python len() 方法返回对象(字符、列表、元组等)长度或项目个数。

    len()方法语法:

    len( s )

    参数

    s – 对象。
    返回值
    返回对象长度。

    以下实例展示了 len() 的使用方法:

    >>>str = "runoob"
    >>> len(str)             # 字符串长度
    6
    >>> l = [1,2,3,4,5]
    >>> len(l)               # 列表元素个数
    5
    

    Python List list()方法

    描述
    list() 方法用于将元组转换为列表。

    注:元组与列表是非常类似的,区别在于元组的元素值不能修改,元组是放在括号中,列表是放于方括号中。

    list()方法语法:

    list( tup )

    参数

    tup – 要转换为列表的元组。
    返回值
    返回列表。

    以下实例展示了 list()函数的使用方法:

    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
     
    aTuple = (123, 'xyz', 'zara', 'abc');
    aList = list(aTuple)
     
    print "列表元素 : ", aList
    以上实例输出结果如下:
    
    列表元素 :  [123, 'xyz', 'zara', 'abc']
    

    Python locals() 函数

    描述

    locals() 函数会以字典类型返回当前位置的全部局部变量。
    对于函数, 方法, lambda 函式, 类, 以及实现了 call 方法的类实例, 它都返回 True。

    locals() 函数语法:

    locals()

    参数

    返回值

    返回字典类型的局部变量。

    以下实例展示了 locals() 的使用方法:

    >>>def runoob(arg):    # 两个局部变量:arg、z
    ...     z = 1
    ...     print (locals())
    ... 
    >>> runoob(4)
    {'z': 1, 'arg': 4}      # 返回一个名字/值对的字典
    >>>
    

    Python long() 函数

    描述

    long() 函数将数字或字符串转换为一个长整型。

    long() 函数语法:

    class long(x, base=10)

    参数

    x – 字符串或数字。
    base – 可选,进制数,默认十进制。
    返回值
    返回长整型数。

    以下实例展示了 long() 的使用方法:

    >>>long()
    0L
    >>> long(1)
    1L
    >>> long('123')
    123L
    >>> 
    >>>
    

    Python map() 函数

    描述

    map() 会根据提供的函数对指定序列做映射。
    第一个参数 function 以参数序列中的每一个元素调用 function 函数,返回包含每次 function 函数返回值的新列表。

    map() 函数语法:

    map(function, iterable, …)

    参数

    function – 函数
    iterable – 一个或多个序列

    返回值

    Python 2.x 返回列表。
    Python 3.x 返回迭代器。

    以下实例展示了 map() 的使用方法:

    >>>def square(x) :            # 计算平方数
    ...     return x ** 2
    ... 
    >>> map(square, [1,2,3,4,5])   # 计算列表各个元素的平方
    [1, 4, 9, 16, 25]
    >>> map(lambda x: x ** 2, [1, 2, 3, 4, 5])  # 使用 lambda 匿名函数
    [1, 4, 9, 16, 25]
    
    # 提供了两个列表,对相同位置的列表数据进行相加
    >>> map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
    [3, 7, 11, 15, 19]
    

    Python max() 函数

    描述

    max() 方法返回给定参数的最大值,参数可以为序列。

    以下是 max() 方法的语法:

    max( x, y, z, … )

    参数

    x – 数值表达式。
    y – 数值表达式。
    z – 数值表达式。

    返回值

    返回给定参数的最大值。

    以下展示了使用 max() 方法的实例:

    实例(Python 2.0+)
    #!/usr/bin/python
     
    print "max(80, 100, 1000) : ", max(80, 100, 1000)
    print "max(-20, 100, 400) : ", max(-20, 100, 400)
    print "max(-80, -20, -10) : ", max(-80, -20, -10)
    print "max(0, 100, -400) : ", max(0, 100, -400)
    
    实例(Python 3.0+)
    print ("max(80, 100, 1000) : ", max(80, 100, 1000))
    print ("max(-20, 100, 400) : ", max(-20, 100, 400))
    print ("max(-80, -20, -10) : ", max(-80, -20, -10))
    print ("max(0, 100, -400) : ", max(0, 100, -400))
    

    以上实例运行后输出结果为:

    max(80, 100, 1000) :  1000
    max(-20, 100, 400) :  400
    max(-80, -20, -10) :  -10
    max(0, 100, -400) :  100
    

    # Python memoryview() 函数

    描述

    memoryview() 函数返回给定参数的内存查看对象(Momory view)。
    所谓内存查看对象,是指对支持缓冲区协议的数据进行包装,在不需要复制对象基础上允许Python代码访问。

    memoryview 语法:

    memoryview(obj)

    参数说明:

    obj – 对象
    返回值
    返回元组列表。

    以下实例展示了 memoryview 的使用方法:

    Python2.x 应用:

    >>>v = memoryview('abcefg')
    >>> v[1]
    'b'
    >>> v[-1]
    'g'
    >>> v[1:4]
    <memory at 0x77ab28>
    >>> v[1:4].tobytes()
    'bce'
    

    Python3.x 应用:

    >>>v = memoryview(bytearray("abcefg", 'utf-8'))
    >>> print(v[1])
    98
    >>> print(v[-1])
    103
    >>> print(v[1:4])
    <memory at 0x10f543a08>
    >>> print(v[1:4].tobytes())
    b'bce'
    >>>
    

    Python min() 函数

    描述

    min() 方法返回给定参数的最小值,参数可以为序列。

    以下是 min() 方法的语法:

    min( x, y, z, … )

    参数

    x – 数值表达式。
    y – 数值表达式。
    z – 数值表达式。

    返回值

    返回给定参数的最小值。

    以下展示了使用 min() 方法的实例:

    #!/usr/bin/python
    
    print "min(80, 100, 1000) : ", min(80, 100, 1000)
    print "min(-20, 100, 400) : ", min(-20, 100, 400)
    print "min(-80, -20, -10) : ", min(-80, -20, -10)
    print "min(0, 100, -400) : ", min(0, 100, -400)
    

    以上实例运行后输出结果为:

    min(80, 100, 1000) :  80
    min(-20, 100, 400) :  -20
    min(-80, -20, -10) :  -80
    min(0, 100, -400) :  -400
    

    Python next() 函数

    描述

    next() 返回迭代器的下一个项目。

    next 语法:

    next(iterator[, default])

    参数说明:

    iterator – 可迭代对象
    default – 可选,用于设置在没有下一个元素时返回该默认值,如果不设置,又没有下一个元素则会触发 StopIteration 异常。

    返回值

    返回对象帮助信息。

    以下实例展示了 next 的使用方法:

    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
     
    # 首先获得Iterator对象:
    it = iter([1, 2, 3, 4, 5])
    # 循环:
    while True:
        try:
            # 获得下一个值:
            x = next(it)
            print(x)
        except StopIteration:
            # 遇到StopIteration就退出循环
            break
    

    输出结果为:

    1
    2
    3
    4
    5
    

    Python object()函数

    Python object() 函数

    Python oct() 函数

    描述

    oct() 函数将一个整数转换成8进制字符串。

    oct 语法:

    oct(x)

    参数说明:

    x – 整数。
    返回值
    返回8进制字符串。

    以下实例展示了 oct 的使用方法:

    >>>oct(10)
    '012'
    >>> oct(20)
    '024'
    >>> oct(15)
    '017'
    >>>
    

    Python open() 函数

    python open() 函数用于打开一个文件,创建一个 file 对象,相关的方法才可以调用它进行读写。

    更多文件操作可参考:Python 文件I/O

    函数语法

    open(name[, mode[, buffering]])

    参数说明:

    name : 一个包含了你要访问的文件名称的字符串值。
    mode : mode 决定了打开文件的模式:只读,写入,追加等。所有可取值见如下的完全列表。这个参数是非强制的,默认文件访问模式为只读®。
    buffering : 如果 buffering 的值被设为 0,就不会有寄存。如果 buffering 的值取 1,访问文件时会寄存行。如果将 buffering 的值设为大于 1 的整数,表明了这就是的寄存区的缓冲大小。如果取负值,寄存区的缓冲大小则为系统默认。

    不同模式打开文件的完全列表:

    模式 描述
    r 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
    rb 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
    r+ 打开一个文件用于读写。文件指针将会放在文件的开头。
    rb+ 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
    w 打开一个文件只用于写入。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。
    wb 以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。
    w+ 打开一个文件用于读写。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。
    wb+ 以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。
    a 打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。也就是说,新的内容将会被写入到已有内容之后。如果该文件不存在,创建新文件进行写入。
    ab 以二进制格式打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。也就是说,新的内容将会被写入到已有内容之后。如果该文件不存在,创建新文件进行写入。
    a+ 打开一个文件用于读写。如果该文件已存在,文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在,创建新文件用于读写。
    ab+ 以二进制格式打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。如果该文件不存在,创建新文件用于读写。

    file 对象方法

    file.read([size]):size 未指定则返回整个文件,如果文件大小 >2 倍内存则有问题,f.read()读到文件尾时返回""(空字串)。

    file.readline():返回一行。

    file.readlines([size]) :返回包含size行的列表, size 未指定则返回全部行。

    for line in f: print line :通过迭代器访问。

    f.write(“hello\n”):如果要写入字符串以外的数据,先将他转换为字符串。

    f.tell():返回一个整数,表示当前文件指针的位置(就是到文件头的比特数)。

    f.seek(偏移量,[起始位置]):用来移动文件指针。

    偏移量: 单位为比特,可正可负
    起始位置: 0 - 文件头, 默认值; 1 - 当前位置; 2 - 文件尾
    f.close() 关闭文件

    Python ord() 函数

    描述

    ord() 函数是 chr() 函数(对于8位的ASCII字符串)或 unichr() 函数(对于Unicode对象)的配对函数,它以一个字符(长度为1的字符串)作为参数,返回对应的 ASCII 数值,或者 Unicode 数值,如果所给的 Unicode 字符超出了你的 Python 定义范围,则会引发一个 TypeError 的异常。

    以下是 ord() 方法的语法:

    ord©

    参数

    c – 字符。
    返回值
    返回值是对应的十进制整数。

    以下展示了使用 ord() 方法的实例:

    >>>ord('a')
    97
    >>> ord('b')
    98
    >>> ord('c')
    99
    

    Python pow() 函数

    描述

    pow() 方法返回 xy(x的y次方) 的值。

    以下是 math 模块 pow() 方法的语法:

    import math

    math.pow( x, y )

    内置的 pow() 方法

    pow(x, y[, z])

    函数是计算x的y次方,如果z在存在,则再对结果进行取模,其结果等效于pow(x,y) %z
    注意:pow() 通过内置的方法直接调用,内置方法会把参数作为整型,而 math 模块则会把参数转换为 float。

    参数

    x – 数值表达式。
    y – 数值表达式。
    z – 数值表达式。

    返回值

    返回 xy(x的y次方) 的值。

    以下展示了使用 pow() 方法的实例:

    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
     
    import math   # 导入 math 模块
     
    print "math.pow(100, 2) : ", math.pow(100, 2)
    # 使用内置,查看输出结果区别
    print "pow(100, 2) : ", pow(100, 2)
     
    print "math.pow(100, -2) : ", math.pow(100, -2)
    print "math.pow(2, 4) : ", math.pow(2, 4)
    print "math.pow(3, 0) : ", math.pow(3, 0)
    

    以上实例运行后输出结果为:

    math.pow(100, 2) :  10000.0
    pow(100, 2) :  10000
    math.pow(100, -2) :  0.0001
    math.pow(2, 4) :  16.0
    math.pow(3, 0) :  1.0
    

    Python print() 函数

    描述

    print() 方法用于打印输出,最常见的一个函数。
    print 在 Python3.x 是一个函数,但在 Python2.x 版本不是一个函数,只是一个关键字。

    以下是 print() 方法的语法:

    print(*objects, sep=’ ‘, end=’\n’, file=sys.stdout)

    参数

    objects – 复数,表示可以一次输出多个对象。输出多个对象时,需要用 , 分隔。
    sep – 用来间隔多个对象,默认值是一个空格。
    end – 用来设定以什么结尾。默认值是换行符 \n,我们可以换成其他字符串。
    file – 要写入的文件对象。

    返回值

    无。

    以下展示了使用 print 函数的实例:
    Python3 下测试

    >>>print(1)  
    1  
    >>> print("Hello World")  
    Hello World  
     
    >>> a = 1
    >>> b = 'runoob'
    >>> print(a,b)
    1 runoob
     
    >>> print("aaa""bbb")
    aaabbb
    >>> print("aaa","bbb")
    aaa bbb
    >>> 
     
    >>> print("I","Love","Python",sep=".")  # 设置间隔符
    I.Love.Python
    

    Python property() 函数

    描述

    property() 函数的作用是在新式类中返回属性值。

    以下是 property() 方法的语法:

    class property([fget[, fset[, fdel[, doc]]]])

    参数

    fget – 获取属性值的函数
    fset – 设置属性值的函数
    fdel – 删除属性值函数
    doc – 属性描述信息

    返回值

    返回新式类属性。

    实例

    定义一个可控属性值 x
    class C(object):
        def __init__(self):
            self._x = None
     
        def getx(self):
            return self._x
     
        def setx(self, value):
            self._x = value
     
        def delx(self):
            del self._x
     
        x = property(getx, setx, delx, "I'm the 'x' property.")
    

    如果 c 是 C 的实例化, c.x 将触发 getter,c.x = value 将触发 setter , del c.x 触发 deleter。
    如果给定 doc 参数,其将成为这个属性值的 docstring,否则 property 函数就会复制 fget 函数的 docstring(如果有的话)。
    将 property 函数用作装饰器可以很方便的创建只读属性:

    class Parrot(object):
        def __init__(self):
            self._voltage = 100000
     
        @property
        def voltage(self):
            """Get the current voltage."""
            return self._voltage
    

    上面的代码将 voltage() 方法转化成同名只读属性的 getter 方法。
    property 的 getter,setter 和 deleter 方法同样可以用作装饰器:

    class C(object):
        def __init__(self):
            self._x = None
     
        @property
        def x(self):
            """I'm the 'x' property."""
            return self._x
     
        @x.setter
        def x(self, value):
            self._x = value
     
        @x.deleter
        def x(self):
            del self._x
    

    这个代码和第一个例子完全相同,但要注意这些额外函数的名字和 property 下的一样,例如这里的 x。

    Python range() 函数用法

    描述
    python range() 函数可创建一个整数列表,一般用在 for 循环中。

    函数语法

    range(start, stop[, step])

    参数说明:

    start: 计数从 start 开始。默认是从 0 开始。例如range(5)等价于range(0, 5);
    stop: 计数到 stop 结束,但不包括 stop。例如:range(0, 5) 是[0, 1, 2, 3, 4]没有5
    step:步长,默认为1。例如:range(0, 5) 等价于 range(0, 5, 1)

    实例

    >>>range(10)        # 从 0 开始到 10
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    >>> range(1, 11)     # 从 1 开始到 11
    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    >>> range(0, 30, 5)  # 步长为 5
    [0, 5, 10, 15, 20, 25]
    >>> range(0, 10, 3)  # 步长为 3
    [0, 3, 6, 9]
    >>> range(0, -10, -1) # 负数
    [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
    >>> range(0)
    []
    >>> range(1, 0)
    []
    

    以下是 range 在 for 中的使用,循环出runoob 的每个字母:

    >>>x = 'runoob'
    >>> for i in range(len(x)) :
    ...     print(x[i])
    ... 
    r
    u
    n
    o
    o
    b
    >>>
    

    Python raw_input() 函数

    描述
    python raw_input() 用来获取控制台的输入。
    raw_input() 将所有输入作为字符串看待,返回字符串类型。

    注意: input() 和 raw_input() 这两个函数均能接收 字符串 ,但 raw_input() 直接读取控制台的输入(任何类型的输入它都可以接收)。而对于 input() ,它希望能够读取一个合法的 python 表达式,即你输入字符串的时候必须使用引号将它括起来,否则它会引发一个 SyntaxError 。
    除非对 input() 有特别需要,否则一般情况下我们都是推荐使用 raw_input() 来与用户交互。

    注意: python3 里 input() 默认接收到的是 str 类型。

    函数语法

    raw_input([prompt])

    参数说明:

    prompt: 可选,字符串,可作为一个提示语。

    实例
    raw_input() 将所有输入作为字符串看待

    >>>a = raw_input("input:")
    input:123
    >>> type(a)
    <type 'str'>              # 字符串
    >>> a = raw_input("input:")
    input:runoob
    >>> type(a)
    <type 'str'>              # 字符串
    >>>
    

    input() 需要输入 python 表达式

    >>>a = input("input:")
    input:123                  # 输入整数
    >>> type(a)
    <type 'int'>               # 整型
    >>> a = input("input:")    
    input:"runoob"           # 正确,字符串表达式
    >>> type(a)
    <type 'str'>             # 字符串
    >>> a = input("input:")
    input:runoob               # 报错,不是表达式
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
      File "<string>", line 1, in <module>
    NameError: name 'runoob' is not defined
    <type 'str'>
    

    Python reduce() 函数

    描述

    reduce() 函数会对参数序列中元素进行累积。
    函数将一个数据集合(链表,元组等)中的所有数据进行下列操作:用传给 reduce 中的函数 function(有两个参数)先对集合中的第 1、2 个元素进行操作,得到的结果再与第三个数据用 function 函数运算,最后得到一个结果。

    reduce() 函数语法:

    reduce(function, iterable[, initializer])

    参数

    function – 函数,有两个参数
    iterable – 可迭代对象
    initializer – 可选,初始参数

    返回值

    返回函数计算结果。

    以下实例展示了 reduce() 的使用方法:

    >>>def add(x, y) :            # 两数相加
    ...     return x + y
    ... 
    >>> reduce(add, [1,2,3,4,5])   # 计算列表和:1+2+3+4+5
    15
    >>> reduce(lambda x, y: x+y, [1,2,3,4,5])  # 使用 lambda 匿名函数
    15
    

    Python reload() 函数

    Python3.0+ 重要!!!

    说明:Python 3.0 把 reload 内置函数移到了 imp 标准库模块中。它仍然像以前一样重载文件,但是,必须导入它才能使用。

    方法一:

    from imp import reload
    reload(module)
    方法二:

    import imp
    imp.reload(module)

    描述

    reload() 用于重新载入之前载入的模块。

    reload() 函数语法:

    reload(module)

    参数

    module – 模块对象。

    返回值

    返回模块对象。

    以下实例展示了 reload() 的使用方法:

    重新载入 sys 模块,并设置默认编码为 utf8
    >>>import sys
    >>> sys.getdefaultencoding()            # 当前默认编码
    'ascii'
    >>> reload(sys)                         # 使用 reload
    <module 'sys' (built-in)>
    >>> sys.setdefaultencoding('utf8')      # 设置编码
    >>> sys.getdefaultencoding()
    'utf8'
    >>>
    

    Python repr() 函数

    描述

    repr() 函数将对象转化为供解释器读取的形式。

    以下是 repr() 方法的语法:

    repr(object)

    参数

    object – 对象。

    返回值

    返回一个对象的 string 格式。

    以下展示了使用 repr() 方法的实例:

    >>>s = 'RUNOOB'
    >>> repr(s)
    "'RUNOOB'"
    >>> dict = {'runoob': 'runoob.com', 'google': 'google.com'};
    >>> repr(dict)
    "{'google': 'google.com', 'runoob': 'runoob.com'}"
    >>>
    

    Python List reverse()方法

    描述

    reverse() 函数用于反向列表中元素。

    reverse()方法语法:

    list.reverse()

    参数

    NA。

    返回值

    该方法没有返回值,但是会对列表的元素进行反向排序。

    以下实例展示了 reverse()函数的使用方法:

    #!/usr/bin/python
    
    aList = [123, 'xyz', 'zara', 'abc', 'xyz']
    
    aList.reverse()
    print "List : ", aList
    以上实例输出结果如下:
    
    List :  ['xyz', 'abc', 'zara', 'xyz', 123]
    

    Python round() 函数

    描述

    round() 方法返回浮点数x的四舍五入值。

    以下是 round() 方法的语法:

    round( x [, n] )

    参数

    x – 数值表达式。
    n – 数值表达式。

    返回值
    返回浮点数x的四舍五入值。

    以下展示了使用 round() 方法的实例:

    #!/usr/bin/python
    
    print "round(80.23456, 2) : ", round(80.23456, 2)
    print "round(100.000056, 3) : ", round(100.000056, 3)
    print "round(-100.000056, 3) : ", round(-100.000056, 3)
    

    以上实例运行后输出结果为:

    round(80.23456, 2) :  80.23
    round(100.000056, 3) :  100.0
    round(-100.000056, 3) :  -100.0
    

    Python set() 函数

    描述

    set() 函数创建一个无序不重复元素集,可进行关系测试,删除重复数据,还可以计算交集、差集、并集等。

    set 语法:

    class set([iterable])

    参数说明:

    iterable – 可迭代对象对象;

    返回值

    返回新的集合对象。

    以下实例展示了 set 的使用方法:

    >>>x = set('runoob')
    >>> y = set('google')
    >>> x, y
    (set(['b', 'r', 'u', 'o', 'n']), set(['e', 'o', 'g', 'l']))   # 重复的被删除
    >>> x & y         # 交集
    set(['o'])
    >>> x | y         # 并集
    set(['b', 'e', 'g', 'l', 'o', 'n', 'r', 'u'])
    >>> x - y         # 差集
    set(['r', 'b', 'u', 'n'])
    >>>
    

    Python setattr() 函数

    描述
    setattr() 函数对应函数 getattr(),用于设置属性值,该属性不一定是存在的。

    setattr() 语法:

    setattr(object, name, value)

    参数

    object – 对象。
    name – 字符串,对象属性。
    value – 属性值。

    返回值
    无。

    以下实例展示了 setattr() 函数的使用方法:

    对已存在的属性进行赋值:

    >>>class A(object):
    ...     bar = 1
    ... 
    >>> a = A()
    >>> getattr(a, 'bar')          # 获取属性 bar 值
    1
    >>> setattr(a, 'bar', 5)       # 设置属性 bar 值
    >>> a.bar
    5
    

    如果属性不存在会创建一个新的对象属性,并对属性赋值:

    >>>class A():
    ...     name = "runoob"
    ... 
    >>> a = A()
    >>> setattr(a, "age", 28)
    >>> print(a.age)
    28
    >>>
    

    Python slice() 函数

    描述

    slice() 函数实现切片对象,主要用在切片操作函数里的参数传递。

    slice 语法:

    class slice(stop)
    class slice(start, stop[, step])

    参数说明:

    start – 起始位置
    stop – 结束位置
    step – 间距

    返回值

    返回一个切片对象。

    以下实例展示了 slice 的使用方法:

    >>>myslice = slice(5)    # 设置截取5个元素的切片
    >>> myslice
    slice(None, 5, None)
    >>> arr = range(10)
    >>> arr
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    >>> arr[myslice]         # 截取 5 个元素
    [0, 1, 2, 3, 4]
    >>>
    

    Python sorted() 函数

    描述

    sorted() 函数对所有可迭代的对象进行排序操作。
    sort 与 sorted 区别:
    sort 是应用在 list 上的方法,sorted 可以对所有可迭代的对象进行排序操作。
    list 的 sort 方法返回的是对已经存在的列表进行操作,无返回值,而内建函数 sorted 方法返回的是一个新的 list,而不是在原来的基础上进行的操作。

    sorted 语法:

    sorted(iterable[, cmp[, key[, reverse]]])

    参数说明:

    iterable – 可迭代对象。
    cmp – 比较的函数,这个具有两个参数,参数的值都是从可迭代对象中取出,此函数必须遵守的规则为,大于则返回1,小于则返回-1,等于则返回0。
    key – 主要是用来进行比较的元素,只有一个参数,具体的函数的参数就是取自于可迭代对象中,指定可迭代对象中的一个元素来进行排序。
    reverse – 排序规则,reverse = True 降序 , reverse = False 升序(默认)。

    返回值

    返回重新排序的列表。

    以下实例展示了 sorted 的使用方法:

    >>>a = [5,7,6,3,4,1,2]
    >>> b = sorted(a)       # 保留原列表
    >>> a 
    [5, 7, 6, 3, 4, 1, 2]
    >>> b
    [1, 2, 3, 4, 5, 6, 7]
     
    >>> L=[('b',2),('a',1),('c',3),('d',4)]
    >>> sorted(L, cmp=lambda x,y:cmp(x[1],y[1]))   # 利用cmp函数
    [('a', 1), ('b', 2), ('c', 3), ('d', 4)]
    >>> sorted(L, key=lambda x:x[1])               # 利用key
    [('a', 1), ('b', 2), ('c', 3), ('d', 4)]
     
     
    >>> students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
    >>> sorted(students, key=lambda s: s[2])            # 按年龄排序
    [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
     
    >>> sorted(students, key=lambda s: s[2], reverse=True)       # 按降序
    [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
    >>>
    

    Python staticmethod() 函数

    描述
    python staticmethod 返回函数的静态方法。
    该方法不强制要求传递参数,如下声明一个静态方法:

    class C(object):
        @staticmethod
        def f(arg1, arg2, ...):
            ...
    

    以上实例声明了静态方法 f,类可以不用实例化就可以调用该方法 C.f(),当然也可以实例化后调用 C().f()。

    函数语法
    staticmethod(function)

    参数说明:

    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
     
    class C(object):
        @staticmethod
        def f():
            print('Python');
     
    C.f();          # 静态方法无需实例化
    cobj = C()
    cobj.f()        # 也可以实例化后调用
    

    以上实例输出结果为:

    Python
    Python
    

    Python str() 函数

    描述

    str() 函数将对象转化为适于人阅读的形式。

    以下是 str() 方法的语法:

    class str(object=’’)

    参数

    object – 对象。
    返回值
    返回一个对象的string格式。

    以下展示了使用 str() 方法的实例:

    >>>s = 'RUNOOB'
    >>> str(s)
    'RUNOOB'
    >>> dict = {'runoob': 'runoob.com', 'google': 'google.com'};
    >>> str(dict)
    "{'google': 'google.com', 'runoob': 'runoob.com'}"
    >>>
    

    Python sum() 函数

    描述

    sum() 方法对系列进行求和计算。

    以下是 sum() 方法的语法:

    sum(iterable[, start])

    参数

    iterable – 可迭代对象,如:列表、元组、集合。
    start – 指定相加的参数,如果没有设置这个值,默认为0。

    返回值

    返回计算结果。

    以下展示了使用 sum 函数的实例:

    >>>sum([0,1,2])  
    3  
    >>> sum((2, 3, 4), 1)        # 元组计算总和后再加 1
    10
    >>> sum([0,1,2,3,4], 2)      # 列表计算总和后再加 2
    12
    

    Python super() 函数

    描述
    super() 函数是用于调用父类(超类)的一个方法。

    super 是用来解决多重继承问题的,直接用类名调用父类方法在使用单继承的时候没问题,但是如果使用多继承,会涉及到查找顺序(MRO)、重复调用(钻石继承)等种种问题。

    MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。

    以下是 super() 方法的语法:

    super(type[, object-or-type])

    参数

    type – 类。
    object-or-type – 类,一般是 self

    Python3.x 和 Python2.x 的一个区别是: Python 3 可以使用直接使用 super().xxx 代替 super(Class, self).xxx :

    Python3.x 实例:

    class A:
         def add(self, x):
             y = x+1
             print(y)
    class B(A):
        def add(self, x):
            super().add(x)
    b = B()
    b.add(2)  # 3
    

    Python2.x 实例:

    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
     
    class A(object):   # Python2.x 记得继承 object
        def add(self, x):
             y = x+1
             print(y)
    class B(A):
        def add(self, x):
            super(B, self).add(x)
    b = B()
    b.add(2)  # 3
    

    返回值

    无。

    以下展示了使用 super 函数的实例:

    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
     
    class FooParent(object):
        def __init__(self):
            self.parent = 'I\'m the parent.'
            print ('Parent')
        
        def bar(self,message):
            print ("%s from Parent" % message)
     
    class FooChild(FooParent):
        def __init__(self):
            # super(FooChild,self) 首先找到 FooChild 的父类(就是类 FooParent),然后把类B的对象 FooChild 转换为类 FooParent 的对象
            super(FooChild,self).__init__()    
            print ('Child')
            
        def bar(self,message):
            super(FooChild, self).bar(message)
            print ('Child bar fuction')
            print (self.parent)
     
    if __name__ == '__main__':
        fooChild = FooChild()
        fooChild.bar('HelloWorld')
    

    执行结果:

    Parent
    Child
    HelloWorld from Parent
    Child bar fuction
    I'm the parent.
    

    Python Tuple(元组) tuple()方法

    描述

    Python 元组 tuple() 函数将列表转换为元组。

    tuple()方法语法:

    tuple( seq )

    参数

    seq – 要转换为元组的序列。

    返回值

    返回元组。

    以下实例展示了 tuple()函数的使用方法:

    实例 1

    >>>tuple([1,2,3,4])
     
    (1, 2, 3, 4)
     
    >>> tuple({1:2,3:4})    #针对字典 会返回字典的key组成的tuple
     
    (1, 3)
     
    >>> tuple((1,2,3,4))    #元组会返回元组自身
     
    (1, 2, 3, 4)
    

    实例 2

    #!/usr/bin/python
     
    aList = [123, 'xyz', 'zara', 'abc'];
    aTuple = tuple(aList)
     
    print "Tuple elements : ", aTuple
    

    以上实例输出结果为:

    Tuple elements :  (123, 'xyz', 'zara', 'abc')
    

    Python type() 函数

    描述

    type() 函数如果你只有第一个参数则返回对象的类型,三个参数返回新的类型对象。
    isinstance() 与 type() 区别:
    type() 不会认为子类是一种父类类型,不考虑继承关系。
    isinstance() 会认为子类是一种父类类型,考虑继承关系。
    如果要判断两个类型是否相同推荐使用 isinstance()。

    以下是 type() 方法的语法:

    type(object)
    type(name, bases, dict)

    参数

    name – 类的名称。
    bases – 基类的元组。
    dict – 字典,类内定义的命名空间变量。

    返回值

    一个参数返回对象类型, 三个参数,返回新的类型对象。

    以下展示了使用 type 函数的实例:

    # 一个参数实例
    >>> type(1)
    <type 'int'>
    >>> type('runoob')
    <type 'str'>
    >>> type([2])
    <type 'list'>
    >>> type({0:'zero'})
    <type 'dict'>
    >>> x = 1          
    >>> type( x ) == int    # 判断类型是否相等
    True
     
    # 三个参数
    >>> class X(object):
    ...     a = 1
    ...
    >>> X = type('X', (object,), dict(a=1))  # 产生一个新的类型 X
    >>> X
    <class '__main__.X'>
    type() 与 isinstance()区别:
    class A:
        pass
     
    class B(A):
        pass
     
    isinstance(A(), A)    # returns True
    type(A()) == A        # returns True
    isinstance(B(), A)    # returns True
    type(B()) == A        # returns False
    

    type() 与 isinstance()区别:

    class A:
        pass
     
    class B(A):
        pass
     
    isinstance(A(), A)    # returns True
    type(A()) == A        # returns True
    isinstance(B(), A)    # returns True
    type(B()) == A        # returns False
    

    Python unichr() 函数

    描述

    unichr() 函数 和 chr()函数功能基本一样, 只不过是返回 unicode 的字符。

    以下是 unichr() 方法的语法:

    unichr(i)

    参数

    i – 可以是10进制也可以是16进制的形式的数字。

    返回值

    返回 unicode 的字符。

    以下展示了使用 unichr() 方法的实例:

    >>>unichr(97)
    u'a'
    >>> unichr(98)
    u'b'
    >>> unichr(99)
    u'c'
    

    Python unicode() 函数

    unicode()

    Python vars() 函数

    描述

    vars() 函数返回对象object的属性和属性值的字典对象。

    vars() 函数语法:

    vars([object])

    参数

    object – 对象

    返回值

    返回对象object的属性和属性值的字典对象,如果没有参数,就打印当前调用位置的属性和属性值 类似 locals()。

    以下实例展示了 vars() 的使用方法:

    >>>print(vars())
    {'__builtins__': <module '__builtin__' (built-in)>, '__name__': '__main__', '__doc__': None, '__package__': None}
    >>> class Runoob:
    ...     a = 1
    ... 
    >>> print(vars(Runoob))
    {'a': 1, '__module__': '__main__', '__doc__': None}
    >>> runoob = Runoob()
    >>> print(vars(runoob))
    {}
    

    Python xrange() 函数

    描述

    xrange() 函数用法与 range 完全相同,所不同的是生成的不是一个数组,而是一个生成器。

    xrange 语法:

    xrange(stop)
    xrange(start, stop[, step])

    参数说明:

    start: 计数从 start 开始。默认是从 0 开始。例如 xrange(5) 等价于 xrange(0, 5)
    stop: 计数到 stop 结束,但不包括 stop。例如:xrange(0, 5) 是 [0, 1, 2, 3, 4] 没有 5
    step:步长,默认为1。例如:xrange(0, 5) 等价于 xrange(0, 5, 1)

    返回值

    返回生成器。

    以下实例展示了 xrange 的使用方法:

    >>>xrange(8)
    xrange(8)
    >>> list(xrange(8))
    [0, 1, 2, 3, 4, 5, 6, 7]
    >>> range(8)                 # range 使用
    [0, 1, 2, 3, 4, 5, 6, 7]
    >>> xrange(3, 5)
    xrange(3, 5)
    >>> list(xrange(3,5))
    [3, 4]
    >>> range(3,5)               # 使用 range
    [3, 4]
    >>> xrange(0,6,2)
    xrange(0, 6, 2)              # 步长为 2
    >>> list(xrange(0,6,2))
    [0, 2, 4]
    >>>
    

    Python3 zip() 函数

    描述
    zip() 函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元组组成的对象,这样做的好处是节约了不少的内存。
    我们可以使用 list() 转换来输出列表。
    如果各个迭代器的元素个数不一致,则返回列表长度与最短的对象相同,利用 * 号操作符,可以将元组解压为列表。

    zip 语法:

    zip([iterable, …])

    参数说明:

    iterabl – 一个或多个迭代器;

    返回值

    返回一个对象。

    以下实例展示了 zip 的使用方法:

    >>>a = [1,2,3]
    >>> b = [4,5,6]
    >>> c = [4,5,6,7,8]
    >>> zipped = zip(a,b)     # 返回一个对象
    >>> zipped
    <zip object at 0x103abc288>
    >>> list(zipped)  # list() 转换为列表
    [(1, 4), (2, 5), (3, 6)]
    >>> list(zip(a,c))              # 元素个数与最短的列表一致
    [(1, 4), (2, 5), (3, 6)]
     
    >>> a1, a2 = zip(*zip(a,b))          # 与 zip 相反,zip(*) 可理解为解压,返回二维矩阵式
    >>> list(a1)
    [1, 2, 3]
    >>> list(a2)
    [4, 5, 6]
    >>>
    

    Python import() 函数

    描述

    import() 函数用于动态加载类和函数 。
    如果一个模块经常变化就可以使用 import() 来动态载入。

    import 语法:

    import(name[, globals[, locals[, fromlist[, level]]]])

    参数说明:

    name – 模块名

    返回值

    返回元组列表。

    以下实例展示了 import 的使用方法:

    a.py 文件代码:

    #!/usr/bin/env python    
    #encoding: utf-8  
     
    import os  
     
    print ('在 a.py 文件中 %s' % id(os))
    

    test.py 文件代码:

    #!/usr/bin/env python    
    #encoding: utf-8  
     
    import sys  
    __import__('a')        # 导入 a.py 模块
    

    执行 test.py 文件,输出结果为:

    在 a.py 文件中 4394716136
    

    Python exec 内置语句

    描述

    exec 执行储存在字符串或文件中的Python语句,相比于 eval,exec可以执行更复杂的 Python 代码。
    需要说明的是在 Python2 中exec不是函数,而是一个内置语句(statement),但是Python 2中有一个 execfile() 函数。可以理解为 Python 3 把 exec 这个 statement 和 execfile() 函数的功能够整合到一个新的 exec() 函数中去了。

    以下是 exec 的语法:

    exec obj

    参数

    obj – 要执行的表达式。

    返回值
    exec 返回值永远为 None。

    以下展示了使用 exec 的实例:

    实例 1

    >>>exec 'print "Hello World"'
    Hello World
    # 单行语句字符串
    >>> exec "print 'runoob.com'"
    runoob.com
     
    #  多行语句字符串
    >>> exec """for i in range(5):
    ...   print "iter time: %d" % i
    ... """
    iter time: 0
    iter time: 1
    iter time: 2
    iter time: 3
    iter time: 4
    

    实例 2

    x = 10
    expr = """
    z = 30
    sum = x + y + z
    print(sum)
    """
    def func():
        y = 20
        exec(expr)
        exec(expr, {'x': 1, 'y': 2})
        exec(expr, {'x': 1, 'y': 2}, {'y': 3, 'z': 4})
        
    func()
    

    输出结果:

    60
    33
    34
    

    其余参考原文
    菜鸟教程

    展开全文
  • MySQL 常用内置函数与所有内置函数

    千次阅读 2018-10-08 10:38:50
    MySQL 常用内置函数 【数值函数】 Abs(X) //绝对值abs(-10.9) = 10 Format(X,D) //格式化千分位数值format(1234567.456, 2) =1,234,567.46 Ceil(X) //向上取整ceil(10.1) = 11 Floor(X) //向下取整floor (10.1) = ...
  • MySQL 常用内置函数 数学函数 字符串函数 日期函数 条件函数 加密函数 数学函数 abs(n): 求一个数字的绝对值 sqrt(n): 求一个数字的 正的算术平方根 mod(n, m) : 求 n/m 的 余数 ceil(n) : 对一个数字 向上 取整 ...
  • SQL内置函数之系统函数
  • Hive 内置函数

    千次阅读 2018-10-10 18:29:27
    简介 以下介绍Hive中可用的内置函数内置函数 返回类型 函数名 描述 BIGINT round(double a) 返回double最近的BIGINT值。 ...
  • python内置函数详解

    千次阅读 多人点赞 2019-10-09 15:54:44
    将python 69个内置函数进行详细介绍,并且进行了分类。
  • hive内置函数

    千次阅读 2019-04-04 17:46:40
    1 Hive的内置函数 在Hive中给我们内置了很多函数官方地址 也可以在启动hive后输入命令查看函数: SHOW FUNCTIONS; DESCRIBE FUNCTION <function_name>; DESCRIBE FUNCTION EXTENDED <function_name>;123...
  • SparkSQL内置函数

    千次阅读 2018-09-12 18:02:36
    Spark SQL 内置函数 版本说明:spark-2.3.0 SparkSQL内置函数官网API:http://spark.apache.org/docs/latest/api/scala/index.html#org.apache.spark.sql.functions%24 CSDN博主整理的内置函数:...
  • Golang 内置函数

    千次阅读 2018-04-01 22:34:10
    Golang中内置了一些函数,在使用这些函数时,...下边来介绍一下Golang内置函数。 append append作用是在切片变量后边追加新的数据,然后返回新的切片变量。函数声明是: func append(slice []Type, elems ...
  • C++常用内置函数

    千次阅读 多人点赞 2019-03-07 19:18:21
    这些函数写在标准 C 和 C++ 库中,叫做内置函数。您可以在程序中引用这些函数。 数学函数 C++ 内置了丰富的数学函数,可对各种数字进行运算。下表列出了 C++ 中一些有用的内置的数学函数。 为了利用这些函数,您需要...
  • flink内置函数

    千次阅读 2019-09-19 10:10:05
    flink内置函数 flink支持的字符串函数: string1 || string2 : 两个字符串串联 CHAR_LENGTH(string) / CHARACTER_LENGTH(string) :返回字符串字符长度 UPPER(string) : 返回大写格式的字符串 LOWER(string) : ...
  • Hive 内置函数及自定义函数

    千次阅读 2017-09-02 18:16:08
    1.内置函数使用如下命令查看当前hive版本支持的所有内置函数show functions;部分截图:可以使用如下命令查看某个函数的使用方法及作用,比如查看 upper函数desc function upper;如果想要查看更为详细的信息加上...
  • hive 内置函数

    2018-04-28 16:55:38
    参考链接: Hive常用字符串函数 Hive中复合数据结构简介以及一些函数的用法说明 hive 内置函数
  • 一、hive内置函数 1、查看系统自带的函数 hive>show functions; 2、显示自带的函数的用法 hive> desc function upper; 3、详细显示自带的函数的用法 hive> desc function extendedupper; 二、hive...
  • golang 内置函数

    千次阅读 2018-05-04 09:46:30
    golang 内置函数 Golang有一些不需要进行导入操作即可使用的内置函数, 函数 功能 close 用于管道通信,关闭chanal len、cap len 用于返回某个类型的长度或数量(字符串、数组、切片、map 、...
  • 1. 函数(1) 内置函数 eval 函数: 用于计算字符串表达式的值isNaN 函数:用于验证参数是否为 NaN(非数字) (2) 自定义函数 定义一个函数 使用关键字function注: js中的函数 没有返回类型,但是可以有返回值...
  • mysql内置函数大全

    万次阅读 多人点赞 2018-09-16 11:23:13
    mysql中的内置函数 mysql内置函数列表可以从mysql官方文档查询,这里仅分类简单介绍一些可能会用到的函数。 1 数学函数 abs(x) pi() mod(x,y) sqrt(x) ceil(x)或者ceiling(x) rand(),rand(N):返回0-1间的浮点数,...
  • python函数: 内置函数

    千次阅读 2015-03-30 19:25:11
    python内置函数 Python内置(built-in)函数随着python解释器的运行而创建。在Python的程序中,你可以随时调用这些函数,不需要定义。 Built-in Functions abs() dict() help() m...
  • 数据库内置函数及自定义函数

    千次阅读 2019-08-05 10:09:37
    一、数据库内置函数 二、数据库自定义函数 1、自定义函数的作用: - 提高SQL语句的重用性,共享性和可移植性; - 减少重复代码的编写,提高程序的可读性; - 能够实现较快的执行速度,减少网络流量,提高程序...
  • Python内置函数

    千次阅读 2019-10-14 15:35:03
    Python内置函数! 今天博主跟大家聊一聊如何使用Python内置函数!不喜勿喷,如有建议欢迎补充、讨论! 关于安装和汉化可以观看博主的这篇文章《下载安装及汉化 》以及Python系列:windows10配置Python3.0开发环境!...
  • 内置函数的使用

    2018-09-16 15:54:49
    内置函数与一般函数的区别是内置函数在编译时将所调用函数的代码直接嵌入到主调函数中,而不是将流程转出去。 一般函数调用过程 1.执行函数中调用前的语句; 2.转移到被调用函数的入口处,同时进行参数传递; 3....
  • impala内置函数

    千次阅读 2019-01-24 11:07:52
    impala内置函数: 数值处理: select abs() 绝对值 select power(2,5) 求幂 select sin/cos/tan/asin/acos/atan/atan2() 三角函数 select bin() 十进制转换二进制 ceil() 返回大于参数的最小整数 floor() 返回小于...
  • gcc内置函数

    千次阅读 2017-06-23 18:58:25
    首先内置函数并不是c标准定义的,而是由编译器自定义的。gcc实现了一套自己的内置函数: https://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html#Other-Builtins 其中需要引起注意的一段话是: GCC built-in ...
  • 这种嵌入到主调函数中的函数称为内置函数(inline function),又称内嵌函数。在有些书中把它译成内联函数。 指定内置函数的方法很简单,只需在函数首行的左端加一个关键字inline即可。 【例4.4】函数指定为内置函数...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 73,372
精华内容 29,348
关键字:

内置函数