智慧的屁

2021-04-04 16:19 已编辑中国科学院电工研究所 Java

关注

Python自带函数归档

Python 字典(Dictionary) items()方法

描述

Python 字典(Dictionary) items() 函数以列表返回可遍历的(键, 值) 元组数组。

语法

items()方法语法：

dict.items()

参数

NA。
#返回值
返回可遍历的(键, 值) 元组数组。

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

实例(Python 2.0+)

#!/usr/bin/python
# coding=utf-8

dict = {'Google': 'www.google.com', 'Runoob': 'www.runoob.com', 'taobao': 'www.taobao.com'}

print "字典值 : %s" %  dict.items()

# 遍历字典列表
for key,values in  dict.items():
    print key,values
以上实例输出结果为：

字典值 : [('Google', 'www.google.com'), ('taobao', 'www.taobao.com'), ('Runoob', 'www.runoob.com')]
Google www.google.com
taobao www.taobao.com
Runoob www.runoob.com

collections.Counter(s)函数

描述

一个 Counter 是一个 dict 的子类，用于计数可哈希对象。它是一个集合，元素像字典键(key)一样存储，它们的计数存储为值。计数可以是任何整数值，包括0和负数。 Counter 类有点像其他语言中的 bags或multisets。

元素从一个 iterable 被计数或从其他的 mapping (or counter)初始化：

c = Counter()                           # a new, empty counter
c = print(Counter('gallahad'))                 # a new counter from an iterable
#Counter({'a': 3, 'l': 2, 'g': 1, 'h': 1, 'd': 1})
c = Counter({'red': 4, 'blue': 2})      # a new counter from a mapping
c = Counter(cats=4, dogs=8)             # a new counter from keyword args
#Counter对象有一个字典接口，如果引用的键没有任何记录，就返回一个0，而不是弹出一个 KeyError :
c = Counter(['eggs', 'ham'])
c['bacon']                              # count of a missing element is zero
0
设置一个计数为0不会从计数器中移去一个元素。使用 del 来删除它:
c['sausage'] = 0                        # counter entry with a zero count
del c['sausage']                        # del actually removes the entry

eg:

class Solution:
    def firstUniqChar(self, s: str) -> int:
    #Counter对象（记住，是dict的子类）的key是待计数元素，value是对应的计数；也可以动态的使用循环对序列进行计数
        frequency=collections.Counter(s)
    #enumerate对象，输出索引和其值的映射（索引，值）
        for i ,ch in enumerate(s):
            if frequency[ch]==1:
                return i
        return -1

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

keys() 方法

描述

Python3 字典 keys() 方法返回一个可迭代对象，可以使用 list() 来转换为列表。
注意：Python2.x 是直接返回列表

语法

keys()方法语法：

dict.keys()

参数

NA。

返回值

返回一个迭代器。

实例

以下实例展示了 keys() 方法的使用方法：

>>> dict = {'Name': 'Runoob', 'Age': 7}
>>> dict.keys()
dict_keys(['Name', 'Age'])
>>> list(dict.keys())             # 转换为列表
['Name', 'Age']
>>> 
以上实例输出结果为：

字典所有的键为 : dict_keys(['Age', 'Name'])

fromkeys() 方法

描述

Python 字典 fromkeys() 函数用于创建一个新字典，以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值。

语法

fromkeys() 方法语法：

dict.fromkeys(seq[, value])

参数

seq -- 字典键值列表。
value -- 可选参数, 设置键序列（seq）对应的值，默认为 None。

返回值

该方法返回一个新字典。

实例

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

实例

#!/usr/bin/python3

seq = ('name', 'age', 'sex')

dict = dict.fromkeys(seq)
print ("新的字典为 : %s" %  str(dict))

dict = dict.fromkeys(seq, 10)
print ("新的字典为 : %s" %  str(dict))
以上实例输出结果为：

新的字典为 : {'age': None, 'name': None, 'sex': None}
新的字典为 : {'age': 10, 'name': 10, 'sex': 10}

不指定值：

#!/usr/bin/python3

x = ('key1', 'key2', 'key3')

thisdict = dict.fromkeys(x)

print(thisdict)
以上实例输出结果为：

{'key1': None, 'key2': None, 'key3': None}

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'])
>>>

reversed 函数

描述

reversed 函数返回一个反转的迭代器。

语法

以下是 reversed 的语法:

reversed(seq)

参数

seq -- 要转换的序列，可以是 tuple, string, list 或 range。

返回值

返回一个反转的迭代器。

实例

以下展示了使用 tuple 的实例：

#!/usr/bin/env python3

# 字符串
seqString = 'Runoob'
print(list(reversed(seqString)))

#元组

seqTuple = ('R', 'u', 'n', 'o', 'o', 'b')
print(list(reversed(seqTuple)))

# range

seqRange = range(5, 9)
print(list(reversed(seqRange)))

#列表

seqList = [1, 2, 4, 3, 5]
print(list(reversed(seqList)))
以上实例输出结果为：

['b', 'o', 'o', 'n', 'u', 'R']
['b', 'o', 'o', 'n', 'u', 'R']
[8, 7, 6, 5]
[5, 3, 4, 2, 1]

map()函数

描述

map() 会根据提供的函数对指定序列做映射。

第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。

语法

map() 函数语法：

map(function, iterable, ...)

参数

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

返回值

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

实例

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

Python2.x 实例:
>>> 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]
Python3.x 实例
>>> def square(x) :         # 计算平方数
...     return x ** 2
...
>>> map(square, [1,2,3,4,5])    # 计算列表各个元素的平方
<map object at 0x100d3d550>     # 返回迭代器
>>> list(map(square, [1,2,3,4,5]))   # 使用 list() 转换为列表
[1, 4, 9, 16, 25]
>>> list(map(lambda x: x ** 2, [1, 2, 3, 4, 5]))   # 使用 lambda 匿名函数
[1, 4, 9, 16, 25]
>>>

sorted() 函数

描述

sorted() 函数对所有可迭代的对象进行排序操作。

sort 与 sorted 区别：

sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。

list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

语法

sorted 语法：

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

参数说明：

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)]
>>>

bin() 函数

描述

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

语法

以下是 bin() 方法的语法:
bin(x)

参数

x -- int 或者 long int 数字

返回值

字符串。

实例

以下展示了使用 bin 函数的实例：

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

count()方法

描述

Python count() 方法用于统计字符串里某个字符出现的次数。可选参数为在字符串搜索的开始与结束位置。

语法

count()方法语法：
str.count(sub, start= 0,end=len(string))

参数

sub -- 搜索的子字符串
start -- 字符串开始搜索的位置。默认为第一个字符,第一个字符索引值为0。
end -- 字符串中结束搜索的位置。字符中第一个字符的索引为 0。默认为字符串的最后一个位置。

返回值

该方法返回子字符串在字符串中出现的次数。

实例

以下实例展示了count()方法的实例：

实例(Python 2.0+)
#!/usr/bin/python

str = "this is string example....wow!!!";

sub = "i";
print "str.count(sub, 4, 40) : ", str.count(sub, 4, 40)
sub = "wow";
print "str.count(sub) : ", str.count(sub)
以上实例输出结果如下：

str.count(sub, 4, 40) :  2
str.count(sub) :  1

replace()方法

描述

Python replace() 方法把字符串中的 old（旧字符串）替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次。

语法

replace()方法语法：

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

参数

old -- 将被替换的子字符串。
new -- 新字符串，用于替换old子字符串。
max -- 可选字符串, 替换不超过 max 次

返回值

返回字符串中的 old（旧字符串）替换成 new(新字符串)后生成的新字符串，如果指定第三个参数max，则替换不超过 max 次。

实例

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

实例
#!/usr/bin/python

str = "this is string example....wow!!! this is really string";
print str.replace("is", "was");
print str.replace("is", "was", 3);

#以上实例输出结果如下：

thwas was string example....wow!!! thwas was really string
thwas was string example....wow!!! thwas is really string

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 split()方法

描述

Python split() 通过指定分隔符对字符串进行切片，如果参数 num 有指定值，则分隔 num+1 个子字符串

语法

split() 方法语法：
str.split(str="", num=string.count(str)).

参数

str -- 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。
num -- 分割次数。默认为 -1, 即分隔所有。

返回值

返回分割后的字符串列表。

实例

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

实例(Python 2.0+)
#!/usr/bin/python
# -*- coding: UTF-8 -*-

str = "Line1-abcdef \nLine2-abc \nLine4-abcd";
print str.split( );       # 以空格为分隔符，包含 \n
print str.split(' ', 1 ); # 以空格为分隔符，分隔成两个
以上实例输出结果如下：

['Line1-abcdef', 'Line2-abc', 'Line4-abcd']
['Line1-abcdef', '\nLine2-abc \nLine4-abcd']
以下实例以 # 号为分隔符，指定第二个参数为 1，返回两个参数列表。

实例(Python 2.0+)
#!/usr/bin/python
# -*- coding: UTF-8 -*-

txt = "Google#Runoob#Taobao#Facebook"

# 第二个参数为 1，返回两个参数列表
x = txt.split("#", 1)

print x
以上实例输出结果如下：

['Google', 'Runoob#Taobao#Facebook']

Python strip()方法

描述

Python strip() 方法用于移除字符串头尾指定的字符（默认为空格或换行符）或字符序列。

注意：该方法只能删除开头或是结尾的字符，不能删除中间部分的字符。

语法

strip()方法语法：

str.strip([chars]);

参数

chars -- 移除字符串头尾指定的字符序列。

返回值

返回移除字符串头尾指定的字符生成的新字符串。

实例

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

实例(Python 2.0+)
#!/usr/bin/python
# -*- coding: UTF-8 -*-
str = "00000003210Runoob01230000000"; 
print str.strip( '0' );  # 去除首尾字符 0


str2 = "   Runoob      ";   # 去除首尾空格
print str2.strip();
以上实例输出结果如下：

3210Runoob0123
Runoob
从结果上看，可以注意到中间部分的字符并未删除。

以上下例演示了只要头尾包含有指定字符序列中的字符就删除：

实例
#!/usr/bin/python
# -*- coding: UTF-8 -*-

str = "123abcrunoob321"
print (str.strip( '12' ))  # 字符序列为 12
以上实例输出结果如下：

3abcrunoob3