精华内容
下载资源
问答
  • 主要介绍了Python内置函数 next的具体使用方法,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • python next()函数

    万次阅读 多人点赞 2017-11-08 15:36:04
    最近在看python编程:从入门到实践里面读文件有用函数next(),对此函数不是很理解,看的代码如下:import csv filename='E:\python学习\pcc-master\chapter_16\sitka_weather_07-2014.csv' with open(filename) as f...

    最近在看python编程:从入门到实践里面读文件有用函数next(),对此函数不是很理解,看的代码如下:

    import csv
    filename='E:\python学习\pcc-master\chapter_16\sitka_weather_07-2014.csv'
    with open(filename) as  f:
        reader=csv.reader(f)
        header_row=next(reader)
        for index,column_header in enumerate(header_row):
            print(index,column_header)

    然后查了一下python的文档,里面的解释是The next() function returns the next item from the iterator.
    这个函数的参数是迭代器(iterator)和一个default
    next(iterator, default)
    default是迭代器已经到了最末端,再调用next()函数的输出值。不填这个参数的话,到了最末端还用next()的话会报错。

    random = [5, 9, 'cat']
    
    # converting list to iterator
    randomIterator = iter(random)
    print(randomIterator)
    
    # Output: 5
    print(next(randomIterator))
    
    # Output: 9
    print(next(randomIterator))
    
    # Output: 'cat'
    print(next(randomIterator))
    
    # This will raise Error
    # iterator is exhausted
    print(next(randomIterator))

    这里的输出为

    5
    9
    cat
    Traceback (most recent call last):
    File “python”, line 18, in
    StopIteration
    而添加了default之后的例子如下:

    random = [5, 9]
    
    # converting list to iterator
    randomIterator = iter(random)
    
    # Output: 5
    print(next(randomIterator, '-1'))
    
    # Output: 9
    print(next(randomIterator, '-1'))
    
    # randomIterator is exhausted
    # Output: '-1'
    print(next(randomIterator, '-1'))
    print(next(randomIterator, '-1'))
    print(next(randomIterator, '-1'))

    输出如下:
    5
    9
    -1
    -1
    -1

    因此在python编程:从入门到实践里面的代码输入的是scv文件的迭代器,其指向文件的第一行,用了next之后,此迭代器指向文件的第二行,进行读取。

    展开全文
  • 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
    

    其余参考原文
    菜鸟教程

    展开全文
  • python常用函数总结

    万次阅读 多人点赞 2018-04-23 11:40:49
    普通函数 一、输入输出函数 1、print()函数 输出函数 向屏幕输出指定的汉字 print(&quot;hello world&quot;) print()函数可以同时输出多个字符串,用逗号“,”隔开 print(&quot;hello&...

    普通函数

    关注公众号“轻松学编程”了解更多。
    pdf下载【点我下载】

    一、输入输出函数

    1、print()函数

    输出函数

    向屏幕输出指定的汉字

    print("hello world")
    

    print()函数可以同时输出多个字符串,用逗号“,”隔开

    print("hello","how","are","you")
    

    print()会依次打印每个字符串,遇到逗号“,”会输出空格,输出的内容是这样的:

    hello how are you
    

    print()可以打印整数,或者计算结果

    >>>print(300)
    300
    >>>print(100 + 200)
    300
    

    我们也可以把打印的结果显示的再漂亮一些

    >>>print("100 + 200 =", 100 + 200)
    100 + 200 = 300
    

    注意:对于字符串"100 + 200 ="它会原样输出,但是对于100+200,python解释器自动计算出结果为300,因此会打印出上述的结果。

    字符串相加,进行字符串的连接,且不产生空格

    print("hello","你好")
    # 使用”,“进行连接
    
    print("he" + "llo")
    # 字符串相加,进行字符串的连接,且不产生空格
    
    print(10+30)
    # 没有使用引号括起来,默认为数值,若是使用引号括起来,就是字符串
    # 若是数值使用加号连接,默认是表达式进行计算,返回计算的结果
    
    print("hello"+1) #会报错
    # 不同类型的数据不能使用加号连接
    # 不同类型的数据能够使用”,“进行连接
    print("1 2 3",2+3)
    # 输入
    # input()
    # 带有提示信息的输入
    # name = input("请输入您的姓名:")
    # print(name)
    
    

    python中print之后是默认换行的

    要实现不换行要加end参数表明

    n = 0
    while n <= 100:
        print("n =",n,end=' ')
        if n == 20:
            break
        n += 1
    输出:
    n = 0 n = 1 n = 2 n = 3 n = 4 n = 5 n = 6 n = 7 n = 8 n = 9 n = 10 n = 11 n = 12 n = 13 n = 14 n = 15 n = 16 n = 17 n = 18 n = 19 n = 20 
    
    

    多个数值进行比较

    print('c'>'b'>'a')
    print(5>1>2)
    输出:
    True
    False
    

    2、input()函数

    输入函数

    Python提供了一个input()函数,可以让用户输入字符串,并且存放在变量中,比如输入用户名

    >>> name = input()
    jean
    

    如何查看输入的内容:

    >>> name
    'jean'
    

    或者使用:

    >>> print(name)
    jean
    

    当然,有时候需要友好的提示一下,我们也可以这样做:

    >>> name = input("place enter your name")
    place input your name jean
    >>> print("hello,", name)
    hello, jean
    

    二、进制转换函数

    1、bin(),oct(),hex()进制转换函数(带前缀)

    使用bin(),oct(),hex()进行转换的时候的返回值均为字符串,且带有0b, 0o, 0x前缀.

    十进制转换为二进制

    >>> bin(10)
    '0b1010'
    

    十进制转为八进制

    >>> oct(12)
    '014'
    

    十进制转为十六进制

    >>> hex(12)
    '0xc'
    

    2、’{0:b/o/x}’.format()进制转换函数(不带前缀)

    十进制转换为二进制

    >>>'{0:b}'.format(10)
    '1010'
    

    十进制转为八进制

    >>> '{0:o}'.format(12)
    '14'
    

    十进制转为十六进制

    >>> '{0:x}'.format(12)
    'c'
    
    注意:hex函数比格式化字符串函数format慢,不推荐使用.

    3、int(’’,2/8/16)转化为十进制函数(不带前缀)

    二进制转为十进制

    >>> int('1010',2)
    10
    

    八进制转为十进制

    >>> int('014', 8)
    12
    

    十六进制转十进制

    >>> int('0xc',16)
    12
    

    4、’{0:d}’.format()进制转换为十进制函数

    二进制转十进制

    >>> '{0:d}'.format(0b11)
    '3'
    

    八进制转十进制

    >>> '{0:d}'.format(0o14)
    '12'
    

    十六进制转十进制

    >>> '{0:d}'.format(0x1f)
    '31'
    

    5、eval()进制转为十进制函数

    二进制转十进制

    >>> eval('0b11')
    '3'
    

    八进制转十进制

    >>> eval('0o14')
    '12'
    

    十六进制转十进制

    >>> eval('0x1f')
    '31'
    
    注意:eval函数比int函数慢,不推荐使用
    二进制, 十六进制以及八进制之间的转换,可以借助十进制这个中间值,即先转十进制再转其他的进制,也可以直接使用函数进制转换.
    #借助十进制
    >>> bin(int('fc',16))
    '0b11111100'
    #利用函数直接转
    >>> bin(0xa)
    '0b1010'
    >>> oct(0xa)
    '012'
    >>> hex(10)
    '0xa'
    

    三、求数据类型函数

    1、type()

    n = "hello world"
    n = type(n)
    print(n)
    输出:
    <class 'str'>
    

    2、使用type()判断变量的类型

    # int float str bool tuple list dict set
    str1 = 'ss'
    if type(num) == str:
        print('yes')
    输出:
    yes
    
    str1 = 'ss'
    print(isinstance(str1,str))
    输出:
    True
    

    推荐使用isinstance()

    3、isinstance()

    功能:判断变量是否属于某一数据类型,可以判断子类是否属于父类。

    class A():
        pass
    
    class B(A):
        def __init__(self):
            super(B, self).__init__()
        pass
    
    class C(A):
        def __init__(self):
            A.__init__(self)
    n = 0.1
    print(isinstance(n,(int,float,str)))
    print(isinstance(n,int))
    print(isinstance(A,object))
    b = B()
    print(isinstance(b,A))
    c =C()
    print(isinstance(c,B))
    输出:
    True
    False
    True
    True
    False
    

    四、关键字函数

    1、keyword.kwlist()函数

    查看关键字 :

    import keyword
    print(keyword.kwlist)
    输出:
    ['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
    
    

    五、删除变量/对象函数

    1、del() 函数

    变量一旦删除,就不能引用,否则会报错

    用法1

    n = "hello world"
    print(n)
    del n
    

    用法2

    n = "hello world"
    print(n)
    del(n)
    print(n)
    输出:
    hello world
    NameError: name 'n' is not defined
    

    六、数学函数

    1、abs(num) 返回num的绝对值

    print(abs(-3))
    输出:
     3
    

    2、max(num1,num2,…,numn) 返回给定参数的最大值

    num1 = 10
    num2 = 20
    print(num1 > num2)
    print(max(num1,num2,56))
    输出:
     False
     56
    
    

    3、min(num1,num2,…,numn) :返回给定参数的最小值

    print(min(12,3,34,0))
    输出:
     0
    

    4、pow(x,y) : 求x的y次方,x^y

    print(pow(2,3))
    输出:
     8
    

    5、round(num,n) : 四舍五入,

    ​ 参数一:需要进行四舍五入的数据;
    参数二:保留小数的位数。若n不写,默认为0

    print(round(123.486,2))
    输出:
     123.49
    
    

    6、range()函数

    range([start,] stop [,step])
    实质:创建了一个可迭代对象;一般情况下与for循环一起连用
    1、start 可以不写,默认值是0,若给定则从start开始
    2、stop 必须给定;
    3、取值范围[start,stop)
    4、step:步长,若不给则默认为1

    '''
    需求:使用for循环计算1*2*3...*20的值
    '''
    accou = 1
    for i in range(1,21):
        accou *= i
    print(accou)
    输出:
    2432902008176640000
    

    七、字符串函数

    1、eval(str)函数

    功能:将字符串转成有效的表达式来求值或者计算结果

    可以将字符串转化成列表list,元组tuple,字典dict,集合set

    注意:生成了一个新的字符串,没有改变原本的字符串

    # 12-3 --> 9
    str1 = "12-3"
    print(eval(str1))
    print(str1)
    print(eval("[1,2,3,4]"))
    print(type(eval("[1,2,3,4]")))
    print(eval("(1,2,3,4)"))
    print(eval('{1:1,2:2,3:3}'))
    print(eval('{2,3,5,3}'))
    输出:
    9
    12-3
    [1, 2, 3, 4]
    <class 'list'>
    (1, 2, 3, 4)
    {1: 1, 2: 2, 3: 3}
    {2, 3, 5}
    

    2、len(str)函数

    功能:获取字符串长度

    str1 = "you are good man"
    print(len(str1))
    输出:
    16
    

    3、str.lower()函数

    功能:返回一个字符串中大写字母转化成小写字母的字符串

    注意:生成了一个新的字符串,没有改变原本的字符串

    str1 = "You are good Man"
    print(str1.lower())
    print(str1)
    输出:
    you are good man
    You are good Man
    

    4、str.upper()函数

    功能:返回一个字符串中小写字母转化成大写字母的字符串

    注意:生成了一个新的字符串,没有改变原本的字符串

    str1 = "You are good man"
    print(str1.upper())
    print(str1)
    输出:
    YOU ARE GOOD MAN
    You are good man
    

    5、str.swapcase()函数

    功能:返回字符串中的大写字母转小写,小写字母转大写的字符串

    注意:生成了一个新的字符串,没有改变原本的字符串

    str1 = "You are Good man"
    print(str1.swapcase())
    print(str1)
    输出:
    yOU ARE gOOD MAN
    You are Good man
    

    6、str.capitalize()函数

    功能:返回字符串中的首字母大写,其余小写的字符串

    注意:生成了一个新的字符串,没有改变原本的字符串

    tr1 = "you Are good man"
    print(str1.capitalize())
    print(str1)
    str2 = "You are a good Man"
    print(str2.capitalize())
    输出:
    You are good man
    you Are good man
    

    7、str.title()函数

    功能:返回一个每个单词首字母都大写的字符串

    注意:生成了一个新的字符串,没有改变原本的字符串

    str1 = "you Are good man"
    print(str1.title())
    print(str1)
    str2 = "You are a good Man"
    print(str2.title())
    输出:
    You Are Good Man
    you Are good man
    You Are A Good Man
    

    8、str.center(width[,fillchar])函数

    功能:返回一个指定宽度的居中字符串

    参数一:指定的参数【必须有】

    参数二:fillchar填充的字符,若未指定,则默认使用空格

    注意:生成了一个新的字符串,没有改变原本的字符串

    str1 = "you Are good man"
    print(str1.center(20,"*"))
    print(str1)
    输出:
         you Are good man    
    **you Are good man**
    you Are good man
    

    9、str.ljust(width[,fillchar])函数

    功能:返回一个指定宽度左对齐的字符串

    参数一:指定字符串的宽度【必须有】

    参数二:填充的字符,若不写则默认为空格

    注意:生成了一个新的字符串,没有改变原本的字符串

    str1 = "you Are good man"
    print(str1.ljust(20,"*"))
    print(str1)
    输出:
    you Are good man****
    you Are good man
    

    10、str.rjust(width[,fillchar])函数

    功能:返回一个指定宽度右对齐的字符串

    参数一:指定字符串的宽度【必须有】

    参数二:填充的字符,若不写则默认为空格

    注意:生成了一个新的字符串,没有改变原本的字符串

    str1 = "you Are good man"
    print(str1.rjust(20,"*"))
    print(str1)
    输出:
    ****you Are good man
    you Are good man
    

    11、str.zfill(width)函数

    功能:返回一个长度为width的字符串,原字符右对齐,前面补0

    注意:生成了一个新的字符串,没有改变原本的字符串

    str1 = "you Are good man"
    print(str1.zfill(20))
    print(str1)
    输出:
    0000you Are good man
    

    12、str2.count(str1,start,end])函数

    功能:返回str1在str2中出现的次数,可以指定一个范围,若不指定则默认查找整个字符串

    区分大小写

    注意:生成了一个新的字符串,没有改变原本的字符串

    str1 = "hello"
    str2 = "Hello hello1 Hello2 hi haha helloa Are good man"
    print(str2.count(str1,0,20))
    输出:
    1
    

    13、str2.find(str1,start,end)函数

    功能:从左往右检测str2,返回str1第一次出现在str2中的下标

    若找不到则返回-1,可以指定查询的范围,若不指定则默认查询整个字符串

    注意:生成了一个新的字符串,没有改变原本的字符串

    str1 = "hello"
    str2 = "Hello hello1 Hello2 hi haha helloa Are good man"
    print(str2.find(str1,5,20))
    输出:
    6
    

    14、str2.rfind(str1,start,end)函数

    功能:从右往左检测str2,返回str1第一次出现在str2中的小标,若找不到则返回-1,可以指定查询的范围,若不指定则默认查询整个字符串

    注意:生成了一个新的字符串,没有改变原本的字符串

    str1 = "hello"
    str2 = "Hello hello1 Hello2 hi haha helloa Are good man"
    print(str2.rfind(str1,10,35))
    输出;
    28
    

    15、str2.index(str1,start,end)函数

    功能:和find()一样,不同的是若找不到str1,则会报异常

    ValueError:substring not found

    注意:生成了一个新的字符串,没有改变原本的字符串

    str1 = "hello"
    str2 = "Hello hello1 Hello2 hi haha helloa Are good man"
    print(str2.index(str1,2,25))
    print(str2.index(str1,24,25))
    输出:
    6
    ValueError: substring not found
    

    16、str.lstrip(char)函数

    功能:返回一个截掉字符串左侧指定的字符,若不给参数则默认截掉空字符: \n \r \t 空格

    注意:生成了一个新的字符串,没有改变原本的字符串

    str3 = "  \n\r \t ni hao ma"
    print(str3)
    print(str3.lstrip())
    str4 = "****ni hao ma****"
    print(str4.lstrip('*'))
    输出;
    	 ni hao ma
    ni hao ma
    ni hao ma****
    

    17、str.rstrip()函数

    功能:返回一个截掉字符串右侧指定的字符,若不给参数则默认截掉空字符: \n \r \t 空格

    注意:生成了一个新的字符串,没有改变原本的字符串

    str3 = "  ni hao ma \n\r \t"
    print(str3.rstrip())
    str4 = "****ni hao ma****"
    print(str4.rstrip('*'))
    输出:
     ni hao ma
    ****ni hao ma
    

    18、str2.split(str1,num) 分离字符串

    功能:返回一个列表,列表的元素是以str1作为分隔符对str2进行切片,
    若num有指定值,则切num次,列表元素个数为num+1
    若不指定则全部进行切片
    若str1不指定,则默认为空字符(空格、换行\n、回车\r、制表\t)

    注意:生成了一个新的字符串,没有改变原本的字符串

    str2 = "22hello nihao hi hello haha ello2 hello3 hello"
    print(str2.split(' ',3))
    str3 = "1257309054@qq.com"
    print(str3.split('@'))
    list1 = str3.split('@')
    print(list1[1].split('.'))
    输出:
    ['22hello', 'nihao', 'hi', 'hello haha ello2 hello3 hello']
    ['1257309054', 'qq.com']
    ['qq', 'com']
    

    19、str2.splitlines()

    功能:返回一个列表,列表的元素是以换行为分隔符,对str2进行切片

    注意:生成了一个新的字符串,没有改变原本的字符串

    str2 = '''
    22
      23
       hello
    '''
    print(str2.splitlines())
    输出:
    ['', '22', '  23', '   hello']
    

    20、str1.join(seq)函数 字符串连接

    功能:以指定字符串作为分隔符,将seq中的所有元素合并成为一个新的字符串

    seq:list、tuple、string

    list1 = ["hello","nihao"]
    print(" ".join(list1))
    输出:
    hello nihao
    
    str1 = "how are you , i am fine thank you"
    str3 = "*".join(str1)
    print(str3)
    输出:
    h*o*w* *a*r*e* *y*o*u* *,* *i* *a*m* *f*i*n*e* *t*h*a*n*k* *y*o*u
    

    21、ord() 求字符的ASCLL码值函数

    print(ord("a"))
    输出:
    97
    

    22、chr() 数字转为对应的ASCLL码函数

    print(chr(97))
    输出:
    a
    

    23、 max(str) min(str)获取最大最小字符

    **max(str) **功能: 返回字符串str中最大的字母

    str1 = "how are you , i am fine thank you"
    print(max(str1))
    输出:
    y
    

    min(str) 功能:返回字符串str中最小字母

    str1 = "how are you , i am fine thank you"
    print(min(str1))
    输出:
    ' '
    

    24、str.replace(old , new [, count]) 字符串的替换

    str.replace(old , new [, count])

    功能:使用新字符串替换旧字符串,若不指定count,则默认全部替换,
    若指定count,则替换前count个

    str1 = "you are a good man"
    print(str1.replace("good","nice"))
    输出:
    you are a nice man
    

    25、字符串映射替换

    参数一:要转换的字符 参数二:目标字符

    dic = str.maketrans(oldstr, newstr)

    str2.translate(dic)

    str1 = "you are a good man"
    dic = str1.maketrans("ya","32")
    print(str1.translate(dic))
    结果:
    3ou 2re 2 good m2n
    

    26、str.startswith(str1,start.end) 判断字符串的开头

    str.startswith(str1,start.end)
    功能:判断在指定的范围内字符串str是否以str1开头,若是就返回True,否则返回False
    若不指定start,则start默认从开始,
    若不指定end,则默认到字符串结尾

    str1 = "hello man"
    print(str1.startswith("h",0,6))
    输出:
    True
    

    27、str.endswith(str1,start.end) 判断字符串的结尾

    str.endswith(str1,start.end)
    功能:判断在指定的范围内字符串str是否以str结束,若是就返回True,否则返回False
    若不指定start,则start默认从开始,
    若不指定end,则默认到字符串结尾

    str1 = "hello man"
    print(str1.endswith("man"))
    输出:
    True
    

    28、str.encode(编码格式)

    对字符串进行编码 默认是utf-8
    编码:str.encode()
    解码:str.encode().decode()
    注意:encode()的编码格式与decode()的编码格式必须保持一致

    str4 = "你好吗"
    print(str4.encode())
    print(str4.encode().decode())
    print(str4.encode("gbk"))
    print(str4.encode("gbk").decode("gbk"))
    输出:
    b'\xe4\xbd\xa0\xe5\xa5\xbd\xe5\x90\x97'
    你好吗
    b'\xc4\xe3\xba\xc3\xc2\xf0'
    你好吗
    

    29、str1.isalpha() 字符串为字母

    功能:判断字符串【至少含有一个字符】中的所有的字符是否都是字母【a~z A~Z 汉字】
    若符合条件则返回True,否则返回False

    str5 = "hello你二"
    print(str5.isalpha())
    str5 = "hello "
    print(str5.isalpha())
    输出:
    True
    False
    

    30、str5.isalnum()

    功能:判断字符串【至少含有一个字符】中的所有字符都是字母或者数字【09,Az,中文】

    str5 = "helloA标红"
    print(str5.isalnum())
    print("12aaa".isalnum())
    print("aaa".isalnum())
    print("  111".isalnum())
    print("111".isalnum())
    print("$$%%qwqw11".isalnum())
    print("你好".isalnum())
    print( "IV".isalnum())
    print('Ⅳ'.isalnum())
    输出;
    True
    True
    True
    False
    True
    False
    True
    True
    True
    

    31、str.isupper()

    功能:判断字符串中所有字符是不是大写字符

    print("WWW".isupper())
    print("wWW".isupper())
    print("123".isupper())
    print("一二三".isupper())
    输出;
    True
    False
    False
    False
    

    31、str.islower()

    功能:判断字符串中所有字符是不是小写字符

    print("WWW".islower())
    print("wWW".islower())
    print("123".islower())
    print("一二三".islower())
    print("qwww".islower())
    输出:
    False
    False
    False
    False
    True
    

    32、str.istitle()

    功能:判断字符串是否是标题化字符串【每个首字母大写】

    print("U Wss".istitle())
    print("wWW ".istitle())
    print("123 ".istitle())
    print("一二三".istitle())
    print("qwww".istitle())
    输出:
    True
    False
    False
    False
    False
    

    33、 str.isdigit()

    isdigit()
    True: Unicode数字,byte数字(单字节),全角数字(双字节)
    False: 汉字数字, ,罗马数字
    Error: 无

    print("123".isdigit())
    print("123".isdigit())
    print(b"1".isdigit())
    print("Ⅳ".isdigit())
    print("123.34".isdigit())
    print("一".isdigit())
    输出;
    True
    True
    True
    False
    False
    False
    

    34、str.isspace()

    功能:判断字符串中是否只含有空格

    print("ddd".isspace())
    print("".isspace())
    print("a  ddd".isspace())
    print(" aaa".isspace())
    print("  ".isspace())
    输出;
    False
    False
    False
    False
    True
    

    35、str.isnumeric()

    功能:若字符串中只包含数字字符,则返回True,否则返回False

    isnumeric()
    True: Unicode数字,全角数字(双字节),汉字数字
    False: 罗马数字,
    Error: byte数字(单字节)
    

    36、str.isdecimal()

    功能:检查字符串是否只包含十进制字符【0,9】,如果是返回True,否则返回False

    isdecimal()
    True: Unicode数字,,全角数字(双字节),
    False: 罗马数字,汉字数字
    Error: byte数字(单字节)
    
    print("123".isdecimal())
    print("123z".isdecimal())
    #结果
    True
    False
    

    八、list列表函数

    1、list.append(元素)

    功能:在列表末尾添加新的元素,只要是python中的数据类型都可以添加,如列表,元组、字典等

    list1 = [1,2,3,4]
    list2 = ["good","nice","beautiful"]
    list1.append("hello")
    print(list1)
    list1.append(list2)
    print(list1)
    输出:
    [1, 2, 3, 4, 'hello', ['good', 'nice', 'beautiful']]
    
    
    2、list1.extend()
    功能:在列表的末尾一次性追加另一个列表中的多个值
    注意:extend()中的值,只能是列表、元组、字符串、字典(可迭代的对象)
    

    2、list1.extend()

    功能:在列表的末尾一次性追加另一个列表中的多个值
    注意:extend()中的值,只能是列表、元组、字符串、字典(可迭代的对象)

    list1 = [1,2,3,4]
    list2 = ["good","nice","beautiful"]
    list1.extend(list2)
    print(list1)
    list1.extend({'h':2,'e':3})
    print(list1)
    输出:
    [1, 2, 3, 4, 'good', 'nice', 'beautiful']
    [1, 2, 3, 4, 'good', 'nice', 'beautiful', 'h', 'e']
    
    
    什么时候使用append,什么时候用extend?
    当我们需要在原本的列表中追加像number类型后者Boolean类型的时候,
    可以使用append,
    或者是我们需要把另外一个列表当成一个元素追加到原本的列表中去的时候,
    这时候也可以使用append
    
    当我们需要在原本的列表中插入一个新的列表中的所有的元素的时候,
    这时候我们需要使用extend
    

    3、str.insert(下标值,object)

    功能:在下标处插入元素,不覆盖原本的数据,原数据向后顺延
    它与append非常类似,不同之处:append默认把新的元素添加在列表的末尾
    而insert可以指定位置进行添加【插入】

    list1 = [1,2,3,4]
    list2 = ["good","nice","beautiful"]
    list1.insert(0,list2)
    print(list1)
    输出:
    [['good', 'nice', 'beautiful'], 1, 2, 3, 4]
    
    

    4、list.pop()

    功能:移除列表最后一个元素,并且返回移除元素的值
    list.pop(index)
    index:下标值
    功能:移除指定下标处的元素,并且返回移除元素的值
    注意:pop一次,list元素个数减1,index的取值为[0,len(list)),若超出取值范围则会报错
    IndexError: pop index out of range

    list2 = ["good","nice","beautiful"]
    list2.pop()
    print(list2)
    list1 = [1,2,3,4]
    list2.pop(0)
    print(list2)
    list2.extend(list1)
    print(list2)
    输出:
    ['good', 'nice']
    ['nice']
    ['nice', 1, 2, 3, 4]
    
    

    5、list.remove(元素)

    功能:移除列表中指定元素的第一个匹配成功的结果
    没有返回值

    list2 = [2,"good","nice","beautiful",2]
    list2.remove(2)
    print(list2.remove(2))
    print(list2)
    输出:
    None
    ['good', 'nice', 'beautiful']
    
    

    6、list.clear()

    功能:清除列表中的所有元素,但不删除列表,没有返回值

    list2 = [2,"good","nice","beautiful",2]
    list2.clear()
    print(list2.clear())
    print(list2)
    输出:
    None
    []
    
    

    7、del list

    功能:删除列表

    list2 = [2,"good","nice","beautiful",2]
    del list2
    print(list2)
    输出:
    NameError: name 'list2' is not defined
    因为列表已经删除了,所以不能再访问,否则会出错
    

    8、list.index(元素,start,end)

    功能:返回从指定的范围内[start,end)的列表中查找到第一个与元素匹配的元素的下标
    若不指定范围,则默认为整个列表。
    注意:若在列表中查不到指定的元素,则会报错

    ValueError: 4 is not in list

    list1 = ['h','e','l','l','o']
    print(list1.index('e'))
    输出:
    1
    

    9、list.count(元素)

    功能:返回元素在列表中出现的次数

    list1 = [1,2,3,4,5,1]
    print(list1.count(1))
    输出:
    2
    

    10、len(list)

    功能:返回列表元素的个数

    list1 = [1,2,3,4,5,[1,3,4]]
    print(len(list1))
    输出:
    6
    

    11、max(list)、min(list)

    功能;返回列表中的最大值,若是字符串比较ASCII码
    注意:数据类型不同的不能进行比较
    min(list)
    功能: 返回列表中的最小值,若是字符串则比较ASCII码

    list1 = [1,2,3,4,5]
    print(max(list1))
    print(min(list1))
    list2 = ['hello','he','hl','hl','ho']
    print(max(list2))
    print(min(list2))
    输出:
    5
    1
    ho
    he
    

    12、list.reverse()

    功能:列表倒叙
    注意:操作的是原本的列表

    list3 = [2,1.22,3,6,33]
    list4 = ['hello','nihao','how are you']
    list3.reverse()
    list4.reverse()
    print(list3)
    print(list4)
    输出:
    [33, 6, 3, 1.22, 2]
    ['how are you', 'nihao', 'hello']
    
    

    13、list.sort()

    功能:列表排序,默认升序
    注意:操作的是原本的列表

    list4 = ['hello','nihao','how are you']
    list4.sort()
    print(list4)
    list4 = [2,3,1,2,4]
    list4.sort()
    print(list4)
    输出:
    ['hello', 'how are you', 'nihao']
    [1, 2, 2, 3, 4]
    
    

    降序:list.sort(reverse=True)

    list1 = [1,3,2,4,5,6]
    list1.sort(reverse=True)
    print(list1)
    输出:
    [6, 5, 4, 3, 2, 1]
    
    
    list1 = [1,3,2,4,5,6]
    y = list1.copy()
    x = list1[:]
    print(sorted(list1,reverse=True))
    print(list1)
    print(y)
    print(id(list1))
    print(id(y))
    print(x)
    print(id(x))
    输出:
    [6, 5, 4, 3, 2, 1]
    [1, 3, 2, 4, 5, 6]
    [1, 3, 2, 4, 5, 6]
    3232179914952
    3232179037832
    [1, 3, 2, 4, 5, 6]
    3232179914824
    
    

    14、浅拷贝、深拷贝

    list1 = list2
    注意:浅拷贝是引用拷贝,类似于快捷方式
    深拷贝【内存拷贝】
    list3 = list1.copy()
    注意:重新开辟了一个新的内存空间,存储的数据于list1相同

    list1 = ['hello','nihao','how are you']
    list2 = list1
    print(id(list1))
    print(id(list2))
    list3 = list1.copy()
    print(id(list3))
    输出;
    1670426304008
    1670426304008
    1670426233032
    
    

    15、list(元组)

    功能:将元组转为列表。

    list1 = list((1,2,3))
    print(list1)
    输出:
    [1, 2, 3]
    
    

    九、元组函数

    1、len(tuple)

    获取元组的长度

    2、max(tuple)

    获取元组的最大值

    3、min(tuple)

    获取元组的最小值

    注意:使用max和min的时候,元组中的元素若是不同类型的数据则不能进行比较

    4、tuple(列表)

    将列表转为元组

    tuple4 =(1,3,2,4,5,3)
    print(len(tuple4))
    print(max(tuple4))
    print(min(tuple4))
    print(tuple([1, 2, 3, 4, 6]))
    输出:
    6
    5
    1
    (1, 2, 3, 4, 6)
    

    十、dict字典函数

    1、value= 字典名.get(key)

    获取字典中关键字对应的值,如果key不存在,返回None

    dict1 = {"key1":1,"key2":2}
    print(dict1.get("key1"))
    输出:
    1
    

    2、dict.pop(key) 删除元素

    通过key删除元素,返回被删除元素的值,pop一次,dict长度减1

    dict1 = {"key1":1,"key2":2}
    print(dict1.pop("key1"))
    print(dict1.pop("key2"))
    print(dict1)
    输出:
    1
    2
    {}    
    

    十一、set集合函数

    1、set1.add(元素) 添加元素

    可以添加重复的元素但是没有效果
    不能添加的元素【字典,列表,元组【带有可变元素的】】

    set1 = {'key1','key2'}
    set1.add('key1')
    set1.add('key3')
    print(set1)
    输出;
    {'key1', 'key2', 'key3'}
    

    2、set.update() 添加seq元素

    功能:插入整个list【一维】,tuple,字符串打碎插入

    set1 = {'key1','key2'}
    set1.update(['key3','key4'])
    set1.update(('hello',True))
    set1.update('key5')
    print(set1)
    输出;
    {'key3', True, '5', 'key1', 'y', 'key4', 'key2', 'k', 'hello', 'e'}
    
    

    3、set.remove(元素)删除元素

    功能:删除集合中的元素,若元素不存在则会报错,删除一次,set长度减1

    set1 = {'key1','key2'}
    set1.remove('key1')
    print(set1)
    set1.remove('key3')
    输出;
    {'key2'}
    报错:KeyError: 'key3'
    

    十二、栈和队列

    1、 栈 stack

    特点:先进先出[可以抽象成竹筒中的豆子,先进去的后出来] 后来者居上

    mystack = []
    #压栈[向栈中存数据]
    mystack.append(1)
    print(mystack)
    mystack.append(2)
    print(mystack)
    mystack.append(3)
    print(mystack)
    
    #出栈[从栈中取数据]
    mystack.pop()
    print(mystack)
    mystack.pop()
    print(mystack)
    

    2、 队列 queue

    特点: 先进先出[可以抽象成一个平放的水管]

    #导入数据结构的集合
    import collections
    queue = collections.deque([1, 2, 3, 4, 5])
    print(queue)
    
    #入队[存数据]
    queue.append(8)
    print(queue)
    queue.append(9)
    print(queue)
    
    #取数据
    print(queue.popleft())
    print(queue)
    

    模块函数

    一、math模块

    在使用math模块时要先导入

    # 导入模块
    import math
    
    

    1、math.ceil(num):对num进行向上取整

    number1 = 12.045
    num1 = math.ceil(number1)
    print(num1)
    输出:
     13
    

    2、math.floor(num) :对num进行向下取整

    number2 = 12.823
    num2 = math.floor(number2)
    print(num2)
    输出:
     12
    

    3、math.modf(num) :返回一个元组类型的数据,数据包含小数部分和整数部分

    # python默认处理的数据长度是无限大,但由于计算机的数据长度有限,所以处理浮点数会出现误差值
    number1 = 12.045
    number2 = 12.823
    print(math.modf(number1))
    print(math.modf(number2))
    输出:
     (0.04499999999999993, 12.0)
     (0.8230000000000004, 12.0)
    
    

    4、math.sqrt(num) : 返回num的开平方根,返回一个浮点数

    开方

    print(math.sqrt(4))
    输出:
     2.0
    

    二、随机函数

    # 导入模块
    import random
    
    

    1、random.choice(列表/元组/字符串) ,在列表或者元组中随机挑选一个元素,若是字符串则随机挑选一个字符

    num1 = random.choice(['hello',True,1,[1,4,5]])
    print(num1)
    输出(每次输出的结果不一定一样):
     1
    

    2、random.randrange([start,end),step) : 返回一个从[start,end)并且步长为step的一个随机数

    若start不写,默认为0
    多step不写,默认为1
    但是end一定要有num2 =

    random.randrange(100)
    print(num2)# 去头去尾
    num3 = random.randrange(80,100,2)
    print(num3)# 取一个1~6的随机数
    print(random.randrange(1,7))
    输出(每次输出的结果不一定一样):
    83
    84
    6
    

    3、random.random(): 返回一个[0,1)的随机数,结果是一个浮点数

    num4 = random.random()
    print(num4)
    输出(每次输出的结果不一定一样):
    0.8073295394931393
    

    4、random.shuffle(列表) :将序列中所有的元素进行随机排序,直接操作序列【序列发生变化】,没有返回值

    list1 = [1,2,3,5,6,7]
    random.shuffle(list1)
    print(random.shuffle(list1)) # 返回结果为None
    print(list1)
    输出(每次输出的结果不一定一样):
    None
    [1, 7, 5, 6, 3, 2]
    

    5、random.uniform(m,n) : 随机产生一个[m,n]的浮点数

    print(random.uniform(5,4))
    输出(每次输出的结果不一定一样):
    4.697767338612918
    

    6、random.randint(m,n)

    随机产生一个[m,n]的整数

    print(random.randint(-1,4))
    输出(每次输出的结果不一定一样):
    0
    

    三、OS模块

    在自动化测试中,经常需要查找操作文件,比如查找配置文件(从而读取配置文件的信息),查找测试报告等等,经常会对大量文件和路径进行操作,这就需要依赖os模块。

    1. os.getcwd()

    功能:查看当前所在路径

    import os
    print(os.getcwd())
    

    2. os.listdir()

    列举目录下所有的文件,返回的是列表类型

    import os
    print(os.listdir("c:\file"))
    

    3. os.path.abspath(path)

    功能:返回path的绝对路径

    绝对路径:【路径具体的写法】“D:\Learn\python\qianfeng\day15”
    相对路径:【路径的简写】 :"."

    import os
    print(os.path.abspath("."))
    

    4. os.path.split(path)

    功能: 将路径分解为(文件夹,文件名),返回的是元组类型

    注意:若路径字符串最后一个字符是,则只有文件夹部分有值,若路径字符串中均无,则只有文件名部分有值,若路径字符串有\且不在最后,则文件夹和文件名都有值,且返回的结果不包括\

    import os
    print(os.path.split(r"D:\python\file\hello.py"))
    #结果
    ('D:\python\file','hello.py')
    
    print(os.path.split("."))
    #结果
    ('','.')
    
    os.path.split('D:\\pythontest\\ostest\\')
    #结果
    ('D:\\pythontest\\ostest', '')
    
    os.path.split('D:\\pythontest\\ostest')
    ('D:\\pythontest', 'ostest')
    

    5. os.path.join(path1,path2,…)

    将path进行组合,若其中有绝对路径,则之前的path将会被删除.

    >>> import os
    >>> os.path.join(r"d:\python\test",'hello.py')
    'd:\pyhton\test\hello.py'
    >>> os.path.join(r"d:\pyhton\test\hello.py",r"d:\pyhton\test\hello2.py")
    'd:\pyhton\test\hello2.py'
    
    

    6. os.path.dirname(path)

    返回path中文件夹部分,不包括""

    >>> import os
    >>> os.path.dirname(r"d:\pyhton\test\hello.py")
    'd:\pyhton\test'
    >>> os.path.dirname(".")
    ''
    >>> os.path.dirname(r"d:\pyhton\test\")
    'd:\pyhton\test'
    >>> os.path.dirname(r"d:\pyhton\test")
    test
    

    7. os.path.basename(path)

    功能:返回path中文件名

    >>> import os
    >>> os.path.basename(r"d:\pyhton\test\hello.py")
    'hello.py'
    >>> os.path.basename(".")
    '.'
    >>> os.path.basename(r"d:\pyhton\test\")
    ''
    >>> os.path.basename(r"d:\pyhton\test")
    'test'
    

    8. os.path.getsize(path)

    功能: 获取文件的大小,若是文件夹则返回0

    >>> import os
    >>> os.path.getsize(r"d:\pyhton\test\hello.py")
    38L
    >>> os.path.getsize(r"d:\pyhton\test")
    0L
    

    9. os.path.exists(path)

    功能:判断文件是否存在,若存在返回True,否则返回False

    >>> import os
    >>> os.listdir(os.getcwd())
    ['hello.py','test.txt']
    >>> os.path.exists(r"d:\python\test\hello.py")
    True
    >>> os.path.exists(r"d:\python\test\hello1.py")
    False
    

    10.os.path.isdir(path)

    功能:判断该路径是否为目录

    >>> import os
    >>>os.path.isdir(r"C:\Users\zhangjiao\PycharmProjects\day01")
    True
    >>>os.path.isdir(r"C:\Users\zhangjiao\PycharmProjects\day01\hello.py")
    False
    

    11.os.path.isfile(path)

    功能:判断该路径是否为文件

    import os
    print(os.path.isfile(r'C:\360用户文件'))
    print(os.path.isfile(r'C:\core.dmp'))
    输出:
    False
    True
    

    四、sys模块

    1 sys模块

    sys 主要是针对于黑屏终端的库

    1.1 sys.argv

    sys.argv 获取当前正在执行的命令行参数的参数列表

    sys.argv:实现程序外部向程序内部传递参数,返回一个列表
    argv[0]:当前的完整路径
    argv[1]:传入的第一个参数

    import sys
    #实现从程序外部向程序传递参数
    print(sys.argv)
    #当前程序名
    sys.argv[0]
    #第一个参数
    sys.argv[1]
    

    1.2 sys.platform

    获取当前执行环境的平台

    #mac
    >>> import sys
    >>> sys.platform
    'darwin'
    

    1.3 sys.path

    path是一个目录列表,供python从中查找第三方扩展模块,在python启动时,sys.path根据内建规则,PATHPATH变量进行初始化

    >>> import sys
    >>> sys.path
    ['', '/Library/Frameworks/Python.framework/Versions/3.6/lib/python36.zip', '/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6', '/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/lib-dynload', '/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages']
    

    五、Image模块

    1、使用Image模块

    有了PIL,处理图片易如反掌,随便找个图片生成缩略图

    # 引入了第三方库
    from PIL import Image
    #打开图片,路径需要注意
    im = Image.open("test.png")
    #查看图片的信息
    print(im.format, im.size, im.mode)
    # 设置图片的大小,注意:图片的大小给定的是个元组
    im.thumbnail((200, 100))
    #保存成新的图片
    im.save("thum.jpg","JPEG")
    输出:
    PEG (497, 325) RGB
    

    六、time模块

    时间格式

    '''
    %a 本地(local) 简化星期名称
    %A 本地完整星期名称
    %b 本地简化月份名称
    %B 本地完整月份名称
    %c 本地相应的日期和时间表示
    %d 一个月中的第几天(01-31)
    %H 一天中的第几个小时(24小时制00-23)
    %I 第几个小时(12小时制01-12)
    %j 一年中的第几天(001-366)
    %m 月份(01-12)
    %M 分钟数(00-59)
    %p 本地am或pm的相应符
    %S 秒(01-60)
    %U 一年中的星期数。(00-53 星期天是一个星期的开始)第一个星期天之前的所有天数都放在第0周
    %w 一个星期中的第几天(0-6 0是星期天)
    %W 和%U基本相同,不同的是%W以星期一为一个星期的开始
    %x 本地相应日期
    %X 本地相应时间
    %y 去掉世纪的年份(00-99)
    %Y 完整的年份
    %z 时区的名字
    %% '%'字符
    '''
    import time
    time1 = time.time()
    lt = time.localtime(time1)
    st = time.strftime('''a: %a |A: %A |b: %b |B: %B |c: %c |d: %d 
    H: %H |I: %I |j: %j |m: %m |M: %M |p: %p 
    S: %S |U: %U |w: %w |W: %W |x: %x |X: %X 
    y: %y |Y: %Y |z: %z |%% ''',lt)
    print(st)
    输出:
    a: Thu |A: Thursday |b: Apr |B: April |c: Thu Apr 12 17:15:19 2018 |d: 12 
    H: 17 |I: 05 |j: 102 |m: 04 |M: 15 |p: PM 
    S: 19 |U: 14 |w: 4 |W: 15 |x: 04/12/18 |X: 17:15:19 
    y: 18 |Y: 2018 |Z: +0800 |% 
    

    1.1 名词解释

    UTC :格林威治天文时间,世界标准时间,在中国为UTC+8

    DST:夏令时是一种节约能源而人为规定的时间制度,在夏季调快一小时.

    1.2 时间的表示形式

    1.时间戳

    以整数或浮点型表示的是一个秒为单位的时间间隔,这个时间的基础值1970.1.1的零点开始算起

    2.元组格式

    采用python的数据结构表示,这个元组有9个整型内容,分别表示不同含义

    year month day hours minutes seconds weekday Julia days flag[1 夏令时 -1 根据当前时间判断 0 正常表示]

    3.格式化字符串

    导入时间模块

    import time
    

    1、time.clock()

    以浮点数计算秒数,返回程序运行的时间。

    print(time.clock())
    time.sleep(2)
    print(time.clock())
    输出:
    0.0
    2.0007889054974255
    
    print(time.clock())
    输出:
    4.665319322446344e-07
    

    用处:可用来计算一段程序运行的时间

    import time
    start = time.clock()
    for cock in range(5,101,5):   # 公鸡
        for hen in range(3,101 - cock,3):  #母鸡
            for chick in range(1,101 - cock - hen): #小鸡
                if cock // 5 + hen // 3 + chick * 3 == 100 and cock + hen + chick == 100:
                   pass
    
    end = time.clock()
    time2 = end - start
    print("方案二所花时间",time2)
    输出:
    方案二所花时间 0.0041665966868768296
    

    2、time.sleep(seconds)

    程序休眠seconds再执行下面的语句。单位s

    3、time.time() 时间戳

    返回一个浮点型数据

    格林威治时间1970年01月01日00时00分00秒(北京时间1970年01月01日08时00分00秒)起至现在的总秒数。通俗的讲, 时间戳是一份能够表示一份数据在一个特定时间点已经存在的完整的可验证的数据。 它的提出主要是为用户提供一份电子证据, 以证明用户的某些数据的产生时间。

    time1 = time.time()
    print(time1)
    输出:
    1523427779.9672592
    

    4、time.gmtime(时间戳)

    把时间戳转成格林尼治时间,返回一个时间元组

    time1 = time.time()
    gm = time.gmtime(time1)
    print(gm)
    输出:
    time.struct_time(tm_year=2018, tm_mon=4, tm_mday=11, tm_hour=6, tm_min=22, tm_sec=59, tm_wday=2, tm_yday=101, tm_isdst=0)
    
    

    5、time.localtime(时间戳)

    把时间戳转成本地时间,返回一个时间元组。(如中国时区,加上8个小时)

    time1 = time.time()
    lm = time.localtime(time1)
    print(lm)
    输出:
    time.struct_time(tm_year=2018, tm_mon=4, tm_mday=11, tm_hour=14, tm_min=22, tm_sec=59, tm_wday=2, tm_yday=101, tm_isdst=0)
    
    

    6、time.mktime(时间元组)

    把时间元组转成时间戳,返回一个浮点数。

    lm2 = time.localtime(1523328000)
    time2 = time.mktime(lm2)
    print(time2)
    输出:
    1523328000.0
    

    7、time.asctime(时间元组)

    将时间元组转成一个字符串。

    lm2 = time.localtime(1523328000)
    st = time.asctime(lm2)
    print(st)
    输出:
    Tue Apr 10 10:40:00 2018
    

    8、time.ctime(时间戳)

    将时间戳转成一个字符串。

    time1 = time.time()
    ct = time.ctime(time1)
    print(ct)
    输出:
    Wed Apr 11 15:18:35 2018
    

    9、time.strftime(format,时间元组)

    将时间元组转成指定格式的字符串。

    time1 = time.time()
    lm = time.localtime(time1)
    sct = time.strftime("%Y-%m-%d %X",lm)
    print(sct)
    输出:
    2018-04-11 15:18:35
    

    10、time.strptime(字符串,format)

    将指定格式的字符串转成时间元组。

    strp = time.strptime('2018-04-10 11:12:57',"%Y-%m-%d %X")
    print(strp)
    输出:
    time.struct_time(tm_year=2018, tm_mon=4, tm_mday=10, tm_hour=11, tm_min=12, tm_sec=57, tm_wday=1, tm_yday=100, tm_isdst=-1)
    
    

    七、datetime模块

    1.1 概述

    datetime比time高级了不少,可以理解为datetime基于time进行了封装,提供了更多的实用的函数,datetime的接口更加的直观,更容易调用

    1.2 模块中的类

    datetime:同时有时间与日期

    timedelta:表示时间间隔,即两个时间点的间隔:主要用于计算时间的跨度

    tzinfo: 时区相关的信息

    date : 只关注日期

    2、获取系统当前时间

    datetime.datetime.now()

    先导入模块:

    import datetime
    
    
    t1 = datetime.datetime.now()
    print(t1)
    输出:
    2018-04-11 19:52:06.180339
    

    3、获取指定时间

    datetime.datetime(参数列表)

    time2 = datetime.datetime(2018, 3, 28, 21, 59, 7, 95015)
    print(time2)
    print(type(time2))
    输出:
    2018-03-28 21:59:07.095015
    <class 'datetime.datetime'>
    

    4、将时间转为字符串

    time1 = datetime.datetime.now()
    time3 = time1.strftime("%Y-%m-%d")
    print(time3)
    输出:
    2018-04-11
    

    5、时间相减,返回一个时间间隔的对象

    import datetime
    import time
    time1 = datetime.datetime.now()
    time.sleep(3)
    time2 = datetime.datetime.now()
    time3 = time2 -time1
    print(time1)
    print(time2)
    print(time3)
    print(type(time3))
    #间隔天数
    print(time3.days)
    # 间隔天数之外的时间转为秒
    print(time3.seconds)
    输出:
    2018-04-11 20:06:11.439085
    2018-04-11 20:06:14.440052
    0:00:03.000967
    <class 'datetime.timedelta'>
    0
    3
    

    八、calendar模块

    1、calendar模块有很广泛的方法用来处理年历和月历

    导入模块

    import calendar
    

    2、calendar.month(year.month)

    返回指定年月的日历【字符串类型】

    print(calendar.month(2018,4))
    print(type(calendar.month(2018,4)))
    
    输出:
         April 2018
    Mo Tu We Th Fr Sa Su
                       1
     2  3  4  5  6  7  8
     9 10 11 12 13 14 15
    16 17 18 19 20 21 22
    23 24 25 26 27 28 29
    30
    
    <class 'str'>
    

    3、calendar.calendar(year)

    返回指定年的日历【字符串类型】

    4、calendar.firstweekday()

    返回当前每周起始日期的设置

    print(calendar.firstweekday())
    输出:
    0
    

    5、calendar.isleap(year)

    返回指定的年份是否为闰年,若是返回True,否则返回False

    print(calendar.isleap(2016))
    输出:
    True
    

    6、calendar.leapdays(year1,year2)

    返回[year1,year2)之间闰年的总和。

    print(calendar.leapdays(2000,2020))
    输出:
    5
    

    7、calendar.monthrange(year,month)

    返回一个元组(参数一,参数二)
    参数一:当月的天数
    参数二:当月第一天的日期码[0,6][周一,周日]
    
    
    print(calendar.monthrange(2018,1))
    print(calendar.monthrange(2018,2))
    print(calendar.monthrange(2018,3))
    print(calendar.monthrange(2018,4))
    输出:
    (0, 31)
    (3, 28)
    (3, 31)
    (6, 30)
    

    8、calendar.monthlendar(year,month)

    返回指定月份以每一周为元素的一个二维列表。

    print(calendar.monthcalendar(2018,4))
    输出:
    [[0, 0, 0, 0, 0, 0, 1], [2, 3, 4, 5, 6, 7, 8], [9, 10, 11, 12, 13, 14, 15], [16, 17, 18, 19, 20, 21, 22], [23, 24, 25, 26, 27, 28, 29], [30, 0, 0, 0, 0, 0, 0]]
    
    

    9、calendar.weekday(year,month,day)

    返回指定日期的日期码。

    print(calendar.weekday(2018,4,1))
    输出:
    6
    

    九、IO模块

    1、open()读/写文件

    f = open(r"文件地址",“读取方式”,encoding=“utf-8”,errors=“ignore”)

    str1 = f.read() #一次性读取文件全部内容
    f.close()#关闭流

    “r”:以只读文本方式读取文件

    “rb”:以只读二进制方式读取文件

    “w”:以文本方式覆盖文件

    “wb”:以二进制方式覆盖文件

    “a”:以文本方式追加写进文件

    “ab”:以二进制方式追加写进文件

    encoding:读取的编码格式

    errors=“ignore”:遇到编码错误跳过,继续读取文件

    r"文件地址":不让转义字符“\”起作用

    with open(r"文件地址",“读取方式”,encoding=“utf-8”) as f:

    str1 = f.read()

    f.read(size) 按字节size大小读取

    f.readline() 读取一行

    f.readlines() 以行的方式全部读取文件

    print(f.readline())
    for line in f.readlines():
       print(line.strip() #去掉换行符
    

    2、StringIO读写内存字符串

    stirngIO顾名思义就是在内存中读写str

    from io import StringIO
    f = StringIO()
    f.write("hello")
    f.write("	")
    f.write('world')
    #获取写入后的str
    print(f.getvalue())
    输出:
    hello	world
    

    要读取StringIO,可以用一个str初始化StringIO,然后,像读文件一样读取:

    from io import StringIO
    f = StringIO("Hello\nHi\nGoodBye!")
    while True:
        s = f.readline()
        if s == '':
            break
        # 去掉换行符
        print(s.strip())
    输出:
    Hello
    Hi
    GoodBye!
    

    3、BytesIO读写内存二进制

    BytesIO实现了在内存中读写bytes,我们创建一个BytesIO,然后写入一些bytes:

    from io import BytesIO
    f = BytesIO()
    f.write("中文".encode('utf-8'))
    print(f.getvalue())
    输出:
    b'\xe4\xb8\xad\xe6\x96\x87'
    

    注意:写入的不是str,而是经过UTF-8编码的bytes

    和StringIO类似,可以用一个bytes初始化BytesIO,然后,像读文件一样读取:

    from io import BytesIO
    f = BytesIO(b'\xe4\xb8\xad\xe6\x96\x87')
    d = f.read()
    print(d)
    print(d.decode())
    输出:
    b'\xe4\xb8\xad\xe6\x96\x87'
    中文
    

    StringIO和BytesIO是在内存中操作str和bytes的方法,使得读写文件具有一致的接口.

    4、序列化

    在这里我们把变量从内存中变成可存储或者传输的过程称之为序列化,在python中叫picking,序列化之后,我们就可以把序列化后的内容写入磁盘,或是通过网络传输到别的机器上。反之,把变量内容从序列化的对象重新读取到内存里称之为反序列化,即unpicking。

    python提供了pickle模块来实现序列化。

    import pickle
    d = dict({"name":"lili","age":18})
    #pickle.dumps()方法把任意对象序列化成一个bytes,然后就可以把bytes写入文件
    print(pickle.dumps(d))
    
    #把序列化后的对象写入文件
    f = open("t1.txt",'wb')
    #参数一:要写入的对象, 参数二:写入文件的对象
    pickle.dump(d,f)
    f.close()
    
    #从文件中读取序列化后的对象
    f2 = open("t1.txt","rb")
    #pickle.load()反序列化对象
    d = pickle.load(f2)
    f2.close()
    print(d)
    print(type(d))
    输出:
    {'name': 'lili', 'age': 18}
    <class 'dict'>
    
    

    注意:pickle只能用于python,并且不同版本的python彼此都不兼容,因此,只能用pickle保存一些不重要的数据,这样即使不能成功的反序列化也没什么关系。

    5、Json

    如果我们需要在不同的编程语言之间传递对象,那么我们必须把对象序列化成标准化格式,比如xml,但是更好的方法是json,因为json表现出来就是一个字符串,可以被所有的语言读取,也方便存储到磁盘或者网络传输,json不仅是标准模式,并且速度也比xml更快,还可以在web中读取,非常方便。把python的dict对象变成一个json

    import json
    
    dict1 = {"name":"lili","age":18}
    ji = json.dumps(dict1)
    print(type(ji))
    with open("dd.txt","w") as f:
        json.dump(dict1,f)
    
    with open("dd.txt","r",encoding="utf-8") as f:
        du = json.load(f)
        print(du)
        print(type(du))
    输出:
    <class 'str'>
    {'name': 'lili', 'age': 18}
    <class 'dict'>
    

    将一个class对象序列化为json

    import json
    
    class Student(object):
        def __init__(self, name, age, score):
            self.name = name
            self.age = age
            self.score = score
    
    # 将student对象转换为dict
    def student2dict(std):
        return {
            'name': std.name,
            'age': std.age,
            'score': std.score
        }
    
    s = Student('Bob', 20, 88)
    # 参数一:要传入的对象  参数二:将对象转为dict的函数
    d = json.dumps(s, default=student2dict)
    
    # 将dict转为对象
    def dict2student(d):
        return Student(d['name'], d['age'], d['score'])
    
    jsonStr = '{"age": 20, "score": 88, "name": "Bob"}'
    # json反序列化为一个对象
    # 参数一:json字符串,参数二:dict转为对象的函数
    print(json.loads(jsonStr, object_hook=dict2student))
    
    # 写入文件
    with open("t1.txt","w") as f:
        f.write(d)
    
    # 读取文件
    with open("t1.txt","r",encoding="utf-8") as f:
        du = json.load(f,object_hook=dict2student)
    print(du)
    输出:
    <__main__.Student object at 0x000002CA795AA0F0>
    <__main__.Student object at 0x000002CA7975B0F0>
    

    6、读写csv文件

    6.1、读csv文件

    csv文件本身就是个纯文本文件,这种文件格式经常用来作为不同程序之间的数据交互的格式.

    演示:

    需求:读取001.scv文件

    说明:可以直接打印,然后定义list

    import csv
    
    def readCsv(path):
        #列表
        infoList = []
        #以只读的形式打开文件
        with open(path, 'r')  as f:
            #读取文件的内容
            allFileInfo = csv.reader(f)
            #将获取到的内容逐行追加到列表中
            for row in allFileInfo:
                infoList.append(row)
        return infoList
    path = r"C:\Users\xlg\Desktop\001.csv"
    info = readCsv(path)
    
    6.2、写csv文件

    演示:

    需求:向002.csv文件中写入内容

    import csv
    
    #以写的方式打开文件
    def writeCsv(path,data)
    	with open(path,'w',newline='')  as f:
            writer = csv.writer(f)
            for rowData in data:
                print("rowData =", rowData)
                #按行写入
                writer.writerow(rowData)
    path = r"C:\Users\xlg\Desktop\002.csv"
    writeCsv(path,[[1,2,3],[4,5,6],[7,8,9]])        
    

    7、读取pdf文件

    pip是一个安装和管理python包的工具

    在进行代码演示之前,首先进行安装和pdf相关的工具

    a.在cmd中输入以下命令: pip list [作用:列出pip下安装的所有的工具]

    b.安装pdfminer3k,继续输入以下命令:pip install pdfminer3k

    c.代码演示

    import sys
    import importlib
    
    importlib.reload(sys)
    
    from pdfminer.pdfparser import PDFParser, PDFDocument
    from pdfminer.pdfinterp import PDFResourceManager, PDFPageInterpreter #解释器
    from pdfminer.converter import PDFPageAggregator #转换器
    from pdfminer.layout import LTTextBoxHorizontal, LAParams #布局
    from pdfminer.pdfinterp import PDFTextExtractionNotAllowed #是否允许pdf和text转换
    
    def readPDF(path, toPath):
        #以二进制形式打开pdf文件
        f = open(path, "rb")
    
        #创建一个pdf文档分析器
        parser = PDFParser(f)
        #创建pdf文档
        pdfFile = PDFDocument()
        #链接分析器与文档对象
        parser.set_document(pdfFile)
        pdfFile.set_parser(parser)
        #提供初始化密码
        pdfFile.initialize()
        #检测文档是否提供txt转换
        if not pdfFile.is_extractable:
            raise PDFTextExtractionNotAllowed
        else:
            #解析数据
            #数据管理器
            manager = PDFResourceManager()
            #创建一个PDF设备对象
            laparams = LAParams()
            device = PDFPageAggregator(manager, laparams=laparams)
            #解释器对象
            interpreter = PDFPageInterpreter(manager, device)
            #开始循环处理,每次处理一页
            for page in pdfFile.get_pages():
                interpreter.process_page(page)
                layout = device.get_result()
                for x in layout:
                    if (isinstance(x, LTTextBoxHorizontal)):
                        with open(toPath, "a") as f:
                            str = x.get_text()
                            #print(str)
                            f.write(str+"\n")
    
    path = r"0319开始.pdf"
    toPath = r"n.txt"
    readPDF(path, toPath)
    

    十、高阶函数

    1.MapReduce

    MapReduce主要应用于分布式中。

    大数据实际上是在15年下半年开始火起来的。

    分布式思想:将一个连续的字符串转为列表,元素类型为字符串类型,将其都变成数字类型,使用分布式思想【类似于一件事一个人干起来慢,但是如果人多呢?效率则可以相应的提高】,同理,一台电脑处理数据比较慢,但是如果有100台电脑同时处理,则效率则会快很多,最终将每台电脑上处理的数据进行整合。

    python的优点:内置了map()和reduce()函数,可以直接使用。

    #python内置了map()和reduce()函数
    '''
    def myMap(func,li):
    	resList = []
    	for paser in li:
    		res = func(paser)
    		resList.append(res)
    '''       
    

    2、map()函数

    功能:将传入的函数依次作用于序列中的每一个元素,并把结果作为新的Iterator(可迭代对象)返回

    语法:

    map(func, lsd)

    参数1是函数,参数2是序列

    #一、map()
    #原型 map(func, lsd)
    #将单个字符转成对应的字面量整数
    def chrToint(chr):
        return {"0":0,"1":1,"2":2,"3":3,"4":4,"5":5,"6":6,"7":7,"8":8,"9":9}[chr]
    
    list1 = ["2","1","4","5"]
    res = map(chrToint, list1)
    #[chr2int("2"),chr2int("1"),chr2int("4"),chr2int("5")]
    print(res)
    print(list(res))
    
    #将整数元素的序列,转为字符串型
    #[1,2,3,4] --》[“1”,“2”,“3”,“4”]
    l = map(str,[1,2,3,4])
    print(list(l))
    输出:
    <map object at 0x0000028288E76780>
    [2, 1, 4, 5]
    ['1', '2', '3', '4']
    

    练习:使用map函数,求n的序列[1,4,9,…,n^2]

    num = int(input("请输入一个数:"))
    map1 = map(lambda n: n*n,range(1,num+1))
    print(list(map1))
    输出:
    请输入一个数:4
    [1, 4, 9, 16]
    

    3、reduce()函数

    功能:一个函数作用在序列上,这个函数必须接受两个参数,reduce把结果继续和序列的下一个元素累计运算

    语法:reduce(func,lsd)

    参数1为函数,参数2为列表

    reduce(f,[1,2,3,4])等价于f(f(f(1,2),3),4),类似于递归

    from functools import reduce
    #需求,求一个序列的和
    list2 = [1, 2, 3, 4]
    def mySum(x,y)
    	return x+y
    r = reduce(mySum,list2)
    print("r=",r)
    输出:
    r= 10
    

    练习1,将字符串转成对应字面量数字

    from functools import reduce
    #将字符串转成对应字面量数字
    def strToint(str1)
    	def fc(x, y):
            return x*10 + y
        def fs(chr):
       		return {"0":0,"1":1,"2":2,"3":3,"4":4,"5":5,"6":6,"7":7,"8":8,"9":9}[chr]
        return reduce(fc,map(fs,list(str1)))
    a = strToint("12345")
    print(a)
    print(type(a))
    
    #模拟map()函数
    def myMap(func,li):
        resList = []
        for n in li:
            res = func(n)
            resList.append(res)
     输出:
    12345
    <class 'int'>
    

    练习2,求1!+2!+3!+…+n!之和。【使用map与reduce函数】

    from functools import reduce
    '''
    求1!+2!+3!+...+n!之和
    '''
    num = int(input("请输入一个正数:"))
    def jiecheng(n):
        ji = 1
        for i in range(1,n+1):
            ji *= i
        return ji
    
    list1 = reduce(lambda x,y: x + y ,map(jiecheng,range(1,num+1)))
    print(list1)
    输出:
    请输入一个正数:5
    153
    

    4、filter()函数

    作用:把传入的函数依次作用于每个元素,然后根据返回值是True还是False决定保留该元素还是丢弃该元素【通过一定的条件过滤列表中的元素】

    '''
    语法:
    filter(func,lsd)
    参数一:函数名
    参数二:序列
    功能:用于过滤序列
    简单理解:把传入的函数依次作用于序列的每一个元素,根据返回的True还是False,决定是否保留该元素。
    '''
    #需求:将列表中的偶数筛选出来。
    list1 = [1,2,3,4,5,6,7,8]
    #筛选条件
    def func(num):
        #保留偶数元素
        if num%2 == 0:
            return True
        #剔除奇数元素
        return False
    list2 = filter(func,list1)
    print(list2)
    print(list(list2))
    print(list1)
    输出:
    <filter object at 0x0000026E74106B38>
    [2, 4, 6, 8]
    [1, 2, 3, 4, 5, 6, 7, 8]
    

    注意:使用filter()这个高阶函数,关键在正确实现一个“筛选”函数,filter()函数返回的是一个Iterator,也就是一个惰性序列,所以要强迫filter完成计算结果,需要使用list()函数获取所有的结果并且返回list.

    练习

    需求;将爱好为“无”的数据剔除掉

    data= [["姓名","年龄","爱好"],["tom", 25, "无"],["hanmeimei", 26, "金钱"]]
    
    data= [["姓名","年龄","爱好"],["tom", 25, "无"],["hanmeimei", 26, "金钱"]]
    
    def filterWu(list1):
        for i in list1:
            if i == "无":
                return False
        return True
    
    dataFilter = list(filter(filterWu,data))
    print(dataFilter)
    输出:
    [['姓名', '年龄', '爱好'], ['hanmeimei', 26, '金钱']]
    

    练习2,需求:打印2000到2020之内的闰年[使用filter函数]

    import calendar
    print(list(filter(calendar.isleap,range(2000,2020))))
    输出:
    [2000, 2004, 2008, 2012, 2016]
    

    5、sorted()函数

    sorted(iterable,key,reverse)作用:实现对列表的排序。
    

    iterable:是可迭代类型;
    cmp:用于比较的函数,比较什么由key决定;
    key:用列表元素的某个属性或函数作为关键字,有默认值,迭代集合中的一项;
    reverse:排序规则. reverse = True 降序 或者 reverse = False 升序,默认值为False。
    返回值:是一个经过排序的可迭代类型,与iterable一样。

    #排序
    #第一类:冒泡 选择
    #第二类:快速,插入,计数器
    #注意:如果数据量小的情况下,上述两类用法的效率基本相同,但是,如果数据量大的情况下,第一类的效率很低
    
    #1.普通排序
    list1 = [4,3,5,6,1]
    #默认为升序排序
    list2 = sorted(list1)
    print(list2)
    
    #2.按绝对值大小排序
    list3 = [4-352-9]
    #key接受函数来实现自定义排序规则
    #abs表示通过绝对值进行排序
    list4 = sorted(list3, key=abs)
    #利用map可以实现取绝对值之后的排序
    list5 = sorted(map(abs,list3))
    print(list3)
    print(list4)
    print(list5)
    
    #3.降序排序
    list5 = [2,1,4,5,6,7]
    #通过设置reverse=True来表示反转
    list6 = sorted(list5,reverse=True)
    print(list5)
    print(list6)
    
    list7 = ['a','b','c','d']
    list8 = sorted(list7)
    print(list7)
    #同样也可以实现升序排列,结果为abcd,排序依据为ASCII值
    print(list8)
    
    #自定义函数:按照字符串的长短来进行排序
    def myLen(str1)return len(str1)
    list7 = ['sddd','dded','et54y5','6576986oy','sa','sda']
    #使用自定义函数,进行排序,key=函数名
    list8 = sorted(list7, key = myLen)
    print(list7)
    print(list8)
    输出:
    [1, 3, 4, 5, 6]
    [4, -3, 5, 2, -9]
    [2, -3, 4, 5, -9]
    [2, 3, 4, 5, 9]
    [2, 1, 4, 5, 6, 7]
    [7, 6, 5, 4, 2, 1]
    ['a', 'b', 'c', 'd']
    ['a', 'b', 'c', 'd']
    ['sddd', 'dded', 'et54y5', '6576986oy', 'sa', 'sda']
    ['sa', 'sda', 'sddd', 'dded', 'et54y5', '6576986oy']
    
    class Student(object):
        def __init__(self,name,age):
            self.name = name
            self.age = age
    
        def __str__(self):
            return self.name +" "+ str(self.age)
    
    stu1 = Student('lili1',18)
    stu2 = Student('lili2',19)
    stu3 = Student('lili3',17)
    stu4 = Student('lili4',20)
    stu5 = Student('lili5',20)
    list2 = [stu1,stu2,stu3,stu4,stu5]
    def com(Student):
        return Student.age
    list3 = sorted(list2,key=lambda Student: Student.age)
    for i in list3:
        print(i)
    输出:
    lili3 17
    lili1 18
    lili2 19
    lili4 20
    lili5 20
    

    十一、排列组合(破解密码)

    1.排列

    itertools.permutations(iterable,n)
    参数一:要排列的序列,
    参数二:要选取的个数
    返回的是一个迭代对象,迭代器中的每一个元素都是一个元组

    import itertools
    #概念:从n个不同元素中取出m(m≤n)个元素,按照一定的顺序排成一列,叫做从n个元素中取出m个元素的一个排列(Arrangement)。特别地,当m=n时,这个排列被称作全排列(Permutation)
    '''
    1 2 3 4
    假设从中取出3个数字
    123
    132
    213
    231
    321
    312
    '''
    #需求:从[1,2,3,4]4个数中随机取出3个数进行排列
    mylist = list(itertools.permutations([1,2,3,4], 3))
    print(mylist)
    print(len(mylist))
    
    '''
    规律总结:
    
    4 - 3   24
    4 - 2   12
    4 - 1   4
    
    排列的可能性次数:n! / (n-m)!
    
    '''
    

    2.组合

    itertools.combinations(iterable,n)
    参数一:可迭代对象
    参数二:要选取的个数
    返回值:返回一二迭代器,迭代器中的每一个元素都是一个元组

    import itertools
    
    #概念:从m个不同的元素中,任取n(n≤m)个元素为一组,叫作从m个不同元素中取出n个元素的进行组合
    '''
    1 2 3 4 5 中选4个数的组合方式有几种?
    '''
    mylist = list(itertools.combinations([1,2,3,4,5], 4))
    print(mylist)
    print(len(mylist))
    
    '''
    规律总结:
    
    m   n
    5 - 5   1
    5 - 4   5
    5 - 3   10
    5 - 2   10
    
    5!
    120/120(m-n)!
    120/24(m-n)!
    120/6(m-n)!
    m!/(n!x(m-n)!)
    '''
    

    3.排列组合

    itertools.product(iterable,repeat=1)
    参数一:可迭代对象,参数二:重复的次数,默认为1

    import itertools
    
    '''
    _ _ _ _ _
    '''
    
    mylist = list(itertools.product("0123456789QWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbnm", repeat=6))
    #可以尝试10,有可能电脑会卡住
    #多线程也不行,电脑内存不够,咋处理都白搭
    #print(mylist)
    print(len(mylist))
    

    扩展:现在但凡涉及到密码,一般都会进行加密处理,常用的加密方式有MD5,RSA,DES等

    4.疯狂破解密码

    伤敌一千自损一万的破解方式

    import time
    import itertools
    #mylist = list(itertools.product("0123456789", repeat=10))
    passwd = ("".join(x) for x in itertools.product("0123456789QWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbnm", repeat=6))
    #print(mylist)
    #print(len(mylist))
    while True:
        #先直接实现,然后再添加异常
        try:
            str = next(passwd)
            time.sleep(0.5)
            print(str)
        except StopIteration as e:
            break
    

    十二、正则表达式

    1.常用需求

    1.1判断qq号

    需求:设计一个方法,传入一个qq号,判断这个qq号是否合法

    """
    分析
    1.全数字
    2.位数:5~12
    3.第一位不能为0
    """
    def checkQQ(str):
        #不管传入的str是否合法,我们假设合法
        result = True
    
        #寻找条件推翻最初的假设
        try:
            #判断是否是全数字
            num = int(str)
    
            #判断位数
            if len(str) >= 4 and len(str) <= 11:
                #判断是否以数字0开头
                if str[0] == '0':
                    result = False
            else:
                result = False
    
        except BaseException:
            result = False
    
        return result
    
    print(checkQQ("1490980463434"))
    
    考虑:如果要用正则表达式实现上述需求,该怎么做?
    
    
    1.2判断手机号码

    需求:设计一个方法,传入一个手机号码,判断这个手机号码是否合法

    """
    分析:
    1.全数字
    2.位数:11位
    3.开头只能是1
    4.第二位可以为3,4,5,6,7,8
    """
    def checkPhone(str):
        result = True
    
        try:
            #判断是否是全数字
            int(str)
            #判断位数
            if len(str) == 11:
                #判断开头是否为1
                if str[0] == '1':
                    #判断第二位的数字
                    if str[1] != '3' and str[1] != '4' and str[1] != '5' and str[1] != '6' and str[1] != '7' and str[1] != '8':
                        result = False
                else:
                    result = False
            else:
                result = False
    
        except BaseException:
            result = False
    
        return  result
    
    print(checkPhone("18501970795"))
    
    考虑:如果要用正则表达式实现上述需求,该怎么做?
    
    

    2.正则概述

    ​ 正则表达式(英语:Regular Expression,在代码中常简写为regex、regexp或RE)使用单个字符串来描述、匹配一系列符合某个句法规则的字符串搜索模式。

    ​ 搜索模式可用于文本搜索文本替换

    ​ 正则表达式是由一个字符序列形成的搜索模式。

    ​ 当你在文本中搜索数据时,你可以用搜索模式来描述你要查询的内容。

    ​ 正则表达式可以是一个简单的字符,或一个更复杂的模式。

    ​ 正则表达式可用于所有文本搜索和文本替换的操作

    ​ 而在python中,通过内嵌集成re模块,程序媛们可以直接调用来实现正则匹配。正则表达式模式被编译成一系列的字节码,然后由用C编写的匹配引擎执行

    3.re模块简介

    Python 自1.5版本起增加了re 模块,它提供 Perl 风格的正则表达式模式。

    re 模块使 Python 语言拥有全部的正则表达式功能

    re 模块也提供了与这些方法功能完全一致的函数,这些函数使用一个模式字符串做为它们的第一个参数

    4.正则表达式的元字符

    4.1 匹配单个字符与数字
    .                匹配除换行符以外的任意字符
    [0123456789]     []是字符集合,表示匹配方括号中所包含的任意一个字符
    [good]           匹配good中任意一个字符
    [a-z]            匹配任意小写字母
    [A-Z]            匹配任意大写字母
    [0-9]            匹配任意数字,类似[0123456789]
    [0-9a-zA-Z]      匹配任意的数字和字母
    [0-9a-zA-Z_]     匹配任意的数字、字母和下划线
    [^good]          匹配除了good这几个字母以外的所有字符,中括号里的^称为脱字符,表示不匹配集合中的字符
    [^0-9]           匹配所有的非数字字符
    \d               匹配数字,效果同[0-9]
    \D               匹配非数字字符,效果同[^0-9]
    \w               匹配数字,字母和下划线,效果同[0-9a-zA-Z_]
    \W               匹配非数字,字母和下划线,效果同[^0-9a-zA-Z_]
    \s               匹配任意的空白符(空格,回车,换行,制表,换页),效果同[ \r\n\t\f]
    \S               匹配任意的非空白符,效果同[^ \f\n\r\t]
    
    print(re.findall("\d", "_sunck is 66a go8od man 3"))
    print(re.findall("[A-Z]","_sunck is 66a go8oD man 3"))
    print(re.findall("[a-z]","_sunck is 66a go8od man 3"))
    print(re.findall("[\S]","_sunck is 66a go8od man 3"))
    print(re.findall("[\W]","_sunck is 66a go8od man 3"))
    
    输出:
    ['6', '6', '8', '3']
    ['D']
    ['s', 'u', 'n', 'c', 'k', 'i', 's', 'a', 'g', 'o', 'o', 'd', 'm', 'a', 'n']
    ['_', 's', 'u', 'n', 'c', 'k', 'i', 's', '6', '6', 'a', 'g', 'o', '8', 'o', 'd', 'm', 'a', 'n', '3']
    [' ', ' ', ' ', ' ', ' ']
    
    
    4.2 锚字符(边界字符)
    ^     行首匹配,和在[]里的^不是一个意思,"^"要写到字符串的前面
    $     行尾匹配,"$"要写到匹配的字符串后面
    
    \A    匹配字符串的开始,它和^的区别是,\A只匹配整个字符串的开头,即使在re.M模式下也不会匹配其它行的行首
    \Z    匹配字符串的结束,它和$的区别是,\Z只匹配整个字符串的结束,即使在re.M模式下也不会匹配它行的行尾
    
    \b    匹配一个单词的边界,也就是值单词和空格间的位置
          'er\b'可以匹配never,不能匹配nerve
    \B    匹配非单词边界
    

    这里写图片描述

    print(re.search("^sunck", "sunck is a good man"))
    print(re.search("man$", "sunck is a good man"))
    
    print(re.findall("^sunck", "sunck is a good man\nsunck is a nice man", re.M))
    print(re.findall("\Asunck", "sunck is a good man\nsunck is a nice man", re.M))
    print(re.findall("man$", "sunck is a good man\nsunck is a nice man", re.M))
    print(re.findall("man\Z", "sunck is a good man\nsunck is a nice man", re.M))
    
    print(re.search(r"er\b", "never"))
    print(re.search(r"er\b", "nerve"))
    print(re.search(r"er\B", "never"))
    print(re.search(r"er\B", "nerve"))
    输出:
    <_sre.SRE_Match object; span=(0, 5), match='sunck'>
    <_sre.SRE_Match object; span=(16, 19), match='man'>
    ['sunck', 'sunck']
    ['sunck']
    ['man', 'man']
    ['man']
    <_sre.SRE_Match object; span=(3, 5), match='er'>
    None
    None
    <_sre.SRE_Match object; span=(1, 3), match='er'>
    
    #匹配qq邮箱,5~12位,第一位不为0
    import re
    
    print(re.findall(r"^[1-9]\d{4,11}@qq\.com$","123456@qq.com"))
    print(re.findall(r"^[1-9]\d{4,11}@qq\.com$","0123456@qq.com"))
    print(re.findall(r"^[1-9]\d{4,11}@qq\.com$","123456@qq.co"))
    
    4.3匹配多个字符
    说明:下方的x、y、z均为假设的普通字符,n、m(非负整数),不是正则表达式的元字符
    (xyz)    匹配小括号内的xyz(作为一个整体去匹配)
    x?       匹配0个或者1个x(非贪婪匹配【尽可能少的匹配】)
    x*       匹配0个或者任意多个x(.* 表示匹配0个或者任意多个字符(换行符除外))(贪婪匹配【尽可能多的匹配】)
    x+       匹配至少一个x(贪婪匹配)
    x{n}     匹配确定的n个x(n是一个非负整数)
    x{n,}    匹配至少n个x
    x{n,m}   匹配至少n个最多m个x。注意:n <= m
    x|y      |表示或,匹配的是x或y
    
    import re
    
    print(re.findall(r"a?", "aaa"))#非贪婪匹配(尽可能少的匹配)
    print(re.findall(r"a*", "aaabaa"))#贪婪匹配(尽可能多的匹配)
    print(re.findall(r"a+", "aaabaaaaaa"))#贪婪匹配(尽可能多的匹配)
    print(re.findall(r"a{3}", "aaabaa"))
    print(re.findall(r"a{3,}", "aaaaabaaa"))#贪婪匹配(尽可能多的匹配)
    print(re.findall(r"a{3,6}", "aaaabaaa"))
    print(re.findall(r"((s|S)unck)", "sunck--SuNck--Sunck"))
    
    
    #需求,提取sunck……man,
    str = "sunck is a good man!sunck is a nice man!sunck is a very handsome man"
    print(re.findall(r"sunck.*?man", str))
    输出:
    ['a', 'a', 'a', '']
    ['aaa', '', 'aa', '']
    ['aaa', 'aaaaaa']
    ['aaa']
    ['aaaaa', 'aaa']
    ['aaaa', 'aaa']
    [('sunck', 's'), ('Sunck', 'S')]
    ['sunck is a good man', 'sunck is a nice man', 'sunck is a very handsome man']
    
    
    4.4特殊
    *?   +?   x?  最小匹配,通常都是尽可能多的匹配,可以使用这种解决贪婪匹配(?:x)    类似(xyz),但不表示一个组
    
    # /*  part1  */   /*   part2  */
    print(re.findall(r"/\*.*?\*/","/*  part1  */   /*   part2  */"))
    输出:
    ['/*  part1  */', '/*   part2  */']
    

    十三.re模块中常用功能函数

    1 compile()

    编译正则表达式模式,返回一个对象的模式。(可以把那些常用的正则表达式编译成正则表达式对象,这样做的目的是为了可以提高一点效率

    格式:

    re.compile(pattern,flags=0)

    pattern: 编译时用的表达式字符串。

    flags 编译标志位,用于修改正则表达式的匹配方式,如:是否区分大小写,多行匹配等

    flags定义包括:
    re.I:使匹配对大小写不敏感
    re.L:表示特殊字符集 \w, \W, \b, \B, \s, \S 依赖于当前环境
    re.M:多行模式
    re.S:’ . ’并且包括换行符在内的任意字符(注意:’ . ’不包括换行符)
    re.U: 表示特殊字符集 \w, \W, \b, \B, \d, \D, \s, \S 依赖于 Unicode 字符属性数据库

    re.X VERBOSE 详细模式。该模式下正则表达式可以是多行,忽略空白字符,并可以加入注释。

    代码演示:

    import re
    tt = "Tina is a good girl, she is cool, clever, and so on..."
    rr = re.compile(r'\w*oo\w*')
    print(rr.findall(tt))   #查找所有包含'oo'的单词
    
    #执行结果如下:
    #['good', 'cool']
    

    2 match()

    决定RE是否在字符串刚开始的位置匹配。//注:这个方法并不是完全匹配。当pattern结束时若string还有剩余字符,仍然视为成功。想要完全匹配,可以在表达式末尾加上边界匹配符’$’。检测不成功则返回None。

    格式:

    re.match(pattern, string, flags=0)

    代码演示:

    import re
    print(re.match('com','comwww.runcomoob').group())
    print(re.match('com','Comwww.runcomoob',re.I).group())
    print(re.match("com$","com122@qq.com"))
    print(re.match(r"^[1-9]\d{4,11}@qq\.com$","23344555@qq.com"))
    输出:
    com
    Com
    None
    <_sre.SRE_Match object; span=(0, 15), match='23344555@qq.com'>
    

    3 search()

    格式:

    re.search(pattern, string, flags=0)

    re.search函数会在字符串内查找模式匹配,只要找到第一个匹配然后返回一个可迭代对象,如果字符串没有匹配,则返回None

    代码演示:

    import re
    print(re.search('\dcom','www.4comrunoob.5com').group())
    print(re.search("a+","aabaaaa"))
    print(re.findall("a+","aabaaaa"))
    输出:
    4com
    <_sre.SRE_Match object; span=(0, 2), match='aa'>
    ['aa', 'aaaa']
    

    4 findall()

    re.findall遍历匹配,可以获取字符串中所有匹配的字符串,返回一个列表

    格式:

    re.findall(pattern, string, flags=0)

    代码演示:

    import re
    p = re.compile(r'\d+')
    print(p.findall('o1n2m3k4'))
    输出:
    ['1', '2', '3', '4']
    
    
    import re
    tt = "Tina is a good girl, she is cool, clever, and so on..."
    rr = re.compile(r'\w*oo\w*')
    print(rr.findall(tt))
    输出:
    ['good', 'cool']
    
    

    5 finditer()

    搜索string,返回一个顺序访问每一个匹配结果(Match对象)的迭代器。找到 RE 匹配的所有子串,并把它们作为一个迭代器返回。

    格式:

    re.finditer(pattern, string, flags=0)

    代码分配:

    import re
    iter = re.finditer(r'\d+','12 drumm44ers drumming, 11 ... 10 ...')
    for i in iter:
        print(i)
        print(i.group())
        print(i.span())
    输出:
    <_sre.SRE_Match object; span=(0, 2), match='12'>
    12
    (0, 2)
    <_sre.SRE_Match object; span=(8, 10), match='44'>
    44
    (8, 10)
    <_sre.SRE_Match object; span=(24, 26), match='11'>
    11
    (24, 26)
    <_sre.SRE_Match object; span=(31, 33), match='10'>
    10
    (31, 33)
    

    6 split()

    按照能够匹配的子串将string分割后返回列表。

    可以使用re.split来分割字符串,如:re.split(r’\s+’, text);将字符串按空格分割成一个单词列表。

    格式:

    re.split(pattern, string[, maxsplit])

    maxsplit用于指定最大分割次数,不指定将全部分割

    代码演示:

    import re
    print(re.split('\d+','one1two2three3four4five5'))
    输出:
    ['one', 'two', 'three', 'four', 'five', '']
    
    import re
    string3 = '[12:23:90][12:90:87][23233][dsnernrev]'
    print(re.split(r"\[|\]",string3))
    输出:
    ['', '12:23:90', '', '12:90:87', '', '23233', '', 'dsnernrev', '']
    

    7 sub()

    使用re替换string中每一个匹配的子串后返回替换后的字符串。

    格式:

    re.sub(pattern, repl, string, count)

    代码演示:

    import re
    text = "Bob is a handsome boy, he is cool, clever, and so on..."
    print(re.sub(r'\s+', '-', text))
    输出:
    Bob-is-a-handsome-boy,-he-is-cool,-clever,-and-so-on...
    
    #其中第二个参数是替换后的字符串;本例中为'-'
    
    #第四个参数指替换个数。默认为0,表示每个匹配项都替换。
    

    re.sub还允许使用函数对匹配项的替换进行复杂的处理。

    如:re.sub(r’\s’, lambda m: ‘[’ + m.group(0) + ‘]’, text, 0);将字符串中的空格’ ‘替换为’[ ]’。

    代码演示:

    import re
    text = "JGood is a handsome boy, he is cool, clever, and so on..."
    print(re.sub(r'\s+', lambda m:'['+m.group(0)+']', text,0))
    输出:
    JGood[ ]is[ ]a[ ]handsome[ ]boy,[ ]he[ ]is[ ]cool,[ ]clever,[ ]and[ ]so[ ]on...
    

    8 subn()

    返回替换次数

    格式:

    subn(pattern, repl, string, count=0, flags=0)

    代码演示:

    import re
    print(re.subn('[1-2]','A','123456abcdef'))
    print(re.sub("g.t","have",'I get A,  I got B ,I gut C'))
    print(re.subn("g.t","have",'I get A,  I got B ,I gut C'))
    输出:
    ('AA3456abcdef', 2)
    I have A,  I have B ,I have C
    ('I have A,  I have B ,I have C', 3)
    

    9. 一些注意点

    1、re.match与re.search与re.findall的区别:

    re.match只匹配字符串的开始,如果字符串开始不符合正则表达式,则匹配失败,函数返回None;而re.search匹配整个字符串,直到找到一个匹配

    代码演示:

    import re
    a=re.search('[\d]',"abc3").group()
    print(a)
    p=re.match('[\d]',"abc3")
    print(p)
    b=re.findall('[\d]',"abc3")
    print(b)
    #执行结果:
    #3
    #None
    #['3', '3']
    

    2、贪婪匹配与非贪婪匹配**

    ?,+?,??,{m,n}? 前面的,+,?等都是贪婪匹配,也就是尽可能匹配,后面加?号使其变成惰性匹配

    代码演示:

    import re
    a = re.findall(r"a(\d+?)",'a23b')
    print(a)
    b = re.findall(r"a(\d+)",'a23b')
    print(b)
    #执行结果:
    #['2']
    #['23']
    
    #这里需要注意的是如果前后均有限定条件的时候,就不存在什么贪婪模式了,非匹配模式失效。
    
    a = re.findall(r"a(\d+)b",'a3333b')
    print(a)
    b = re.findall(r"a(\d+?)b",'a3333b')
    print(b)
    #执行结果如下:
    #['3333']
    #['3333']
    

    3、用flags时遇到的小坑

    print(re.split('a','1A1a2A3',re.I))#输出结果并未能区分大小写
    #这是因为re.split(pattern,string,maxsplit,flags)默认是四个参数,当我们传入的三个参数的时候,系统会默认re.I是第三个参数,所以就没起作用。如果想让这里的re.I起作用,写成flags=re.I即可
    

    10.使用练习

    #1、匹配电话号码[座机]
    p = re.compile(r'\d{3}-\d{6}')
    print(p.findall('010-628888'))
    
    #2、匹配IP
    b = re.search(r"\b(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\b", '192.168.11.244')
    print(b)
    

    后记

    【后记】为了让大家能够轻松学编程,我创建了一个公众号【轻松学编程】,里面有让你快速学会编程的文章,当然也有一些干货提高你的编程水平,也有一些编程项目适合做一些课程设计等课题。

    也可加我微信【1257309054】,拉你进群,大家一起交流学习。
    如果文章对您有帮助,请我喝杯咖啡吧!

    公众号

    公众号

    赞赏码

    关注我,我们一起成长~~

    展开全文
  • 主要介绍了python next()和iter()函数原理解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 文章目录next() 函数描述语法参数返回值实例 next() 函数 描述 next() 返回迭代器的下一个项目。 next() 函数要和生成迭代器的iter() 函数一起使用。 语法 next 语法: next(iterator[, default]) 参数 iterator ...


    next() 函数

    描述

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

    next() 函数要和生成迭代器的iter() 函数一起使用。

    语法

    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内置函数——next

    2017-09-15 09:35:49
    函数格式:next(iterator[, default])说明1:iterator函数必须接收一个可迭代对象参数,每次调用的时候,返回可迭代对象的下一个元素。如果所有元素均已经返回过,则抛出StopIteration 异常。>>> a = iter('abcd') >...
  • Python内置函数作用及解析

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

    万次阅读 多人点赞 2019-11-13 17:21:35
    Python 的内置函数数量众多,功能强大,如果能够灵活运用,必将极大地提高编程效率。不过,在大家公认的所谓内置函数里面,有很多并不是真的函数,而是内置类,只是因为使用起来和真正的函数没有什么不同,所以也就...
  • 今天小编就为大家分享一篇对Python 3.2 迭代器的next函数实例讲解,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 内置函数 Built-in Functions abs() dict() help() min() setattr() all()  dir() hex() next() slice() any() divmod() id() object() sorted() ascii() enumerate() input() oct() staticmethod() ...
  • Python 内置函数 Python builtins 模块

    千次阅读 2020-05-06 17:09:16
     Python常用的内置函数 下面列举一些常用的Python内置函数 abs() divmod() input() open() enumerate() int() ord() str() eval() ...
  • python: iter、next函数

    千次阅读 2017-11-17 20:39:46
    iter(object[, sentinel]) next(iterator[, default]) 实验代码# -*- coding: utf-8 -*-# 首先获得Iterator对象: it = iter([1, 2, 'Hello', 'Nanjing', [10, 20]]) print type(it) print it # 循环: while True: ...
  • python 类 构造函数 Python构造函数创建类对象 (Python Constructors to create a Class Object) In the last tutorial, we learned how to create a class, its instance and how to access class members...
  • 内置函数就是Python给你提供的, 拿来直接用的函数比如printinput等 截止到python版本3.6.2 一共提供了68个内置函数具体如下? abs?dict?help?min?setattr) all?dir?hex?next?slice? any?divmod?id?object?sorted? ...
  • Python reduce 函数

    千次阅读 2020-04-19 14:44:33
    学习Python语言 要改为 学习 Python 语言 # 实现 参考 https://github.com/hjiang/scripts/blob/master/add-space-between-latin-and-cjk 进行修改如下: add-space-between-latin-and-cjk.py #!/usr/bin/env ...
  • python 卷积函数What is a convolution? OK, that’s not such a simple question. Instead, I am will give you a very basic example and then I will show you how to do this in Python with actual functions. ...
  • Python内置函数大全

    千次阅读 2017-04-08 22:07:00
    学习Python不可避免的首先要了解python的内置函数,熟悉了这些以后可以给编程带来很大的方便。 1、数学运算类 函数函数功能 备注 abs(x) 求绝对值 1、参数可以是整型,也可以...
  • Python学习笔记3.2-python内置函数大全

    万次阅读 2016-11-22 22:28:09
    学习python不可避免的首先要了解python的内置函数,熟悉了这些以后可以给编程带来很大的方便。
  • python lambda函数

    千次阅读 2019-06-14 10:04:28
    lambda定义的是单行函数,如果需要复杂的函数,应该定义普通函数 lambda参数列表可以包含多个参数,如 lambda x, y: x + y lambda中的表达式不能含有命令,而且只限一条表达式 默认返回表达式中的计算结果 可变类型...
  • shell脚本中调用python脚本的函数并获取python脚本函数的return值 例子1: 废话少说,直接上代码: python脚本:merge_report.py # coding=utf-8 import sys def main(param): return param def find_...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 112,469
精华内容 44,987
关键字:

pythonnext函数

python 订阅