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.comcollections.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 entryeg:
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 stringeval() 函数
描述
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
