Python3常用函数、方法总结（持续更新…）

梦里梦外; 2022-01-09 07:59 374阅读 0赞

最近刷LeetCode，自己自娱自乐完之后去discussion看大佬们的各种巧妙解法，总是止不住的双击666……加上最近Python3用的比较多（虽然Python实在不推荐跑算法题目，一是运行效率太低，二是Pythonic模式感觉是在作弊，只有在不考虑效率的情况下使用Python实现非Pythonic的算法设计还可以说的过去，且当作熟悉Python了），总结了一下常用的函数及方法，与大家分享也可以自己温故，与C++ STL还是有很多重叠的。

## 函数 ##

*  **next() 函数**
    
    > 返回迭代器的下一个项目。  
    > next(iterator\[, default\])  
    > iterator -- 可迭代对象  
    > default -- 可选，用于设置在没有下一个元素时返回该默认值，如果不设置，又没有下一个元素则会触发 StopIteration 异常。

#case 1
    # 首先获得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
    
    #case 2
    it = iter([1, 2, 3, 4, 5])
    while True:
        x = next(it, 'a')
        print(x)
        if x == 'a':
            break
    输出：
    1
    2
    3
    4
    5
    a

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

filter(function, iterable)
    def is_odd(n):
        return n % 2 == 1 
    newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
    输出：[1, 3, 5, 7, 9]
    
    a = list(filter(lambda x: x % 2 == 0, range(10)))
    print(a)
    输出：[0, 2, 4, 6, 8]

*  **zip()函数**
    
    > 用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。  
    > 如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 \* 号操作符，可以将元组解压为列表。

zip([iterable, ...])
    
    >>>a = [1,2,3]
    >>> b = [4,5,6]
    >>> c = [4,5,6,7,8]
    >>> zipped = zip(a,b)     # 打包为元组的列表
    [(1, 4), (2, 5), (3, 6)]
    >>> zip(a,c)              # 元素个数与最短的列表一致
    [(1, 4), (2, 5), (3, 6)]
    >>> zip(*zipped)          # 与 zip 相反，*zipped 可理解为解压，返回二维矩阵式
    [(1, 2, 3), (4, 5, 6)]

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

any(iterable)
    
    >>> any(['a', 'b', '', 'd'])   # 列表list，存在一个为空的元素
    True
    >>> any([0, '', False])        # 列表list,元素全为0,'',false
    False

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

all(iterable)
    
    >>> all(['a', 'b', 'c', 'd'])  # 列表list，元素都不为空或0
    True
    >>> all(['a', 'b', '', 'd'])   # 列表list，存在一个为空的元素
    False

*  **int()函数**
    
    > 用于将一个字符串或数字转换为整型。  
    > class int(x, base=10)  
    > x -- 字符串或数字。  
    > base -- 进制数，默认十进制。

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

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

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

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

enumerate(sequence, [start=0])
    
    >>>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')]

*  **eval()函数**
    
    > 用来执行一个字符串表达式，并返回表达式的值。  
    > eval(expression\[, globals\[, locals\]\])  
    > expression -- 表达式。  
    > globals -- 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。  
    > locals -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。

>>>x = 7
    >>> eval( '3 * x' )
    21
    
    >>> a = "123"
    >>> type(a)
    <class 'str'>
    >>> b = eval(a)
    >>> b
    123
    >>> type(b)
    <class 'int'>

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

reduce(function, iterable[, initializer])
    
    >>>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

## 方法 ##

*  **字典get()方法**
    
    > 返回指定键的值，如果值不在字典中返回默认值。  
    > dict.get(key, default=None)

dict = {'Name': 'Zara', 'Age': 27}
    print "Value : %s" %  dict.get('Sex', "Never")
    输出：Value : Never

*  **isalnum()方法**
    
    > 检测字符串是否由字母和数字组成。如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False。  
    > str.isalnum()

str = "this2009";  # 字符中没有空格
    print str.isalnum();
    输出：
    True 
    
    str = "this is string example....wow!!!";
    print str.isalnum();
    输出：
    False

*  **strip()方法**
    
    > 用于移除字符串头尾指定的字符（默认为空格或换行符）或字符序列。  
    > 注意：该方法只能删除开头或是结尾的字符，不能删除中间部分的字符。  
    > str.strip(\[chars\])

str = "00000003210abc1230000000"; 
    print(str.strip( '0' ))  # 去除首尾字符 0
    输出：
    3210abc0123
    
    str2 = "   abc      ";   # 去除首尾空格
    print(str2.strip())
    输出：
    abc

*  **join()方法**
    
    > 用于将序列中的元素以指定的字符连接生成一个新的字符串。  
    > str.join(sequence)

str = "-";
    seq = ("a", "b", "c"); # 字符串序列
    print str.join( seq );
    输出：
    a-b-c

*  **rjust()方法**
    
    > 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串。如果指定的长度小于字符串的长度则返回原字符串。  
    > str.rjust(width\[, fillchar\])

str = "this is string example....wow!!!";
    print str.rjust(50, '0');
    输出：
    000000000000000000this is string example....wow!!!

ljust()方法同理

## 位运算符 ##

与(&)和或(|)运算符就不说了，主要来看看下面几个位运算符：  
a = 0011 1100  
b = 0000 1101

> ^ 按位异或运算符：当两对应的二进位相异时，结果为1  
> (a ^ b) 输出结果 49 ，二进制解释： 0011 0001

> ~ 按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1 。~x 类似于 -x-1  
> (~a ) 输出结果 -61 ，二进制解释： 1100 0011，在一个有符号二进制数的补码形式。

> << 左移动运算符：运算数的各二进位全部左移若干位，由 << 右边的数字指定了移动的位数，高位丢弃，低位补0。  
> a << 2 输出结果 240 ，二进制解释： 1111 0000

> >> 右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，>> 右边的数字指定了移动的位数  
> a >> 2 输出结果 15 ，二进制解释： 0000 1111

转载于:https://www.cnblogs.com/intoxication/p/10661848.html