Python 语言简单明了,往往其他语言很多行的代码,在python中可能一样代码就能搞定。

list, tuple, dict, set 这四种内置数据类型使用频度算是最高的了,介绍一下对应的内置函数以及相应的用法。

 

list

列表是根据元素的添加先后顺序有序存储的,元素可以是任意类型的。

声明list使用 []

例如:

list1 = [1]

list1 = [1, 2]

list1 = [index for index in range(5)]

append – 添加元素

# 声明并初始化一个列表
list1 = [1, 2, 3, 4, 5, 6, 7, 8]
print list1

# 添加一个数字到列表
list1.append(9)
print list1

# 添加一个字符串到列表
list1.append("11")
print list1

# 添加一个列表list到列表
list1.append([1, 2])
print list1

# 添加一个元组tuple到列表
list1.append((1, 2))
print list1

# 添加一个字典dict到列表
list1.append({"a": 1, "b": 2})
print list1

运行结果: 
[1, 2, 3, 4, 5, 6, 7, 8] 
[1, 2, 3, 4, 5, 6, 7, 8, 9] 
[1, 2, 3, 4, 5, 6, 7, 8, 9, '11'] 
[1, 2, 3, 4, 5, 6, 7, 8, 9, '11', [1, 2]] 
[1, 2, 3, 4, 5, 6, 7, 8, 9, '11', [1, 2], (1, 2)] 
[1, 2, 3, 4, 5, 6, 7, 8, 9, '11', [1, 2], (1, 2), {'a': 1, 'b': 2}]

count – 返回元素在列表中出现的次数

list1.count("11")

extend – 将一个可迭代对象iterable添加到现有的列表

list1 = [1]
print list1

# 添加一个列表
list1.extend([2, 3])
print list1

# 添加一个集合
list1.extend(set([2, 3]))
print list1

# 添加一个元组
list1.extend((2, 3))
print list1

运行结果:
[1]
[1, 2, 3]
[1, 2, 3, 2, 3]
[1, 2, 3, 2, 3, 2, 3]

index – 返回元素在列表中的下标

函数可以传入三个参数,
第一个参数是要查找的元素,
第二个参数是起始下标,
第三个参数是终止坐标,
第二三个参数默认值为None,第二三个参数相当于是对列表的一个切片。

list1 = [1, 2, 3, 2, 3, 3, 3, 2, 3]

# 返回找到的第一个2的下标 返回结果是1
print list1.index(2)

# 从下标4开始查找元素2 返回结果是7
print list1.index(2, 4)

# 从下标4到下标6之间查找,查不到抛出异常 ValueError: 2 is not in list
print list1.index(2, 4, 7)

insert – 在指定位置插入元素

list1 = [1, 2]
print list1

# 在第一个位置插入元素
list1.insert(0, 22)
print list1

# 在倒数第二个位置插入元素
list1.insert(-1, 22)
print list1

# 在第一个位置插入元素
list1.insert(-100, 222)
print list1

# 在最后一个位置插入元素
list1.insert(100, 222)
print list1

运行结果:
[1, 2]
[22, 1, 2]
[22, 1, 22, 2]
[222, 22, 1, 22, 2]
[222, 22, 1, 22, 2, 222]

pop – 移除指定位置的元素,并返回该元素的value

list1 = [1, 2]
print list1
print list1.pop(1)
print list1

运行结果:
[1, 2]
2
[1]

如果指定位置不在列表范围,将抛出异常 IndexError: pop index out of range

remove – 将制定元素移出列表

如果指定元素不存在,将抛出异常 ValueError: list.remove(x): x not in list

reverse – 将列表进行反转

list1 = [1, 2, 3, 4, 5]
print list1
list1.reverse()
print list1

运行结果:
[1, 2, 3, 4, 5]
[5, 4, 3, 2, 1]

sort – 对列表进行排序

list1 = [1, 2, 3, 1, 1, -1, -2]
print list1

# 默认进行升序排列
list1.sort()
print list1

# 进行降序排列
list1.sort(reverse=True)
print list1

运行结果:
[1, 2, 3, 1, 1, -1, -2]
[-2, -1, 1, 1, 1, 2, 3]
[3, 2, 1, 1, 1, -1, -2]

tuple

Python的元组与列表类似,不同之处在于元组的元素不能修改,元组使用小括号(),列表使用方括号,元组创建很简单,只需要在括号中添加元素,并使用逗号隔开即可。

tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
tup3 = "a", "b", "c", "d"
tup4 = (1,)
tup5 = 1,

count – 返回指定元素出现的次数
index – 返回指定元素出现的位置

tuple1 = (1, 2, 2, 3, 3, 3)
print tuple1

# 计算元素3出现的次数
print tuple1.count(3)

# 返回元素3第一次出现的位置下标
print tuple1.index(3)

运行结果:
(1, 2, 2, 3, 3, 3)
3
3

dict

字典,键值对的一个集合,字典没有顺序,
如果需要按照顺序存储的列表可以用OrderedDict

声明一个字典
dict1 = dict()
dict2 = {}
dict3 = {"a": "apple", "b": {"g": "grape", "o": "orange"}}

clear – 清空字典

copy – 返回字典的一个浅拷贝

fromkeys – fromkeys()方法从序列键和值设置为value来创建一个新的字典。

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

dict1 = dict.fromkeys(seq)
print "New Dictionary : %s" % str(dict1)

dict1 = dict.fromkeys(seq, 10)
print "New Dictionary : %s" % str(dict1)

运行结果:
New Dictionary: {'age': None, 'name': None, 'sex': None}
New Dictionary: {'age': 10, 'name': 10, 'sex': 10}

get – 通过键值获取对应的值,如果键值不存在返回None或者指定value

dict1 = {'age': 10, 'name': 10, 'sex': 10}
print dict1.get('age')  # 运行结果 10
print dict1.get('age1')  # 运行结果 None
print dict1.get("age1", "222")  # 222
print dict1["age"]  # 运行结果 10
print dict1["age1"]  # 运行结果 异常 KeyError: 'age1'
可以根据情况进行使用,不确定key是否存在的情况下用get可以减少异常捕获。

has_key – 判断字典是否包含某个键值

PEP 8: has_key() 已经不推荐使用了 推荐用 in
dict1 = {'age': 10, 'name': 10, 'sex': 10}
print dict1.has_key('age')
print 'age' in dict1

运行结果:
True
True

items – 返回一个键值对的列表 [(key, value), (key, value), …]

dict1 = {'age': 10, 'name': 10, 'sex': 10}
print dict1.items()

运行结果:
[('age', 10), ('name', 10), ('sex', 10)]

iteritems – 返回一个键值对的迭代对象

dict1 = {'age': 10, 'name': 10, 'sex': 10}
for key, value in dict1.iteritems():
    print key, value

运行结果:
age 10
name 10
sex 10

iterkeys – 返回字典键的可迭代对象

itervalues – 返回字典值得可迭代对象

keys – 返回字典键的列表

values – 返回字典值的列表

dict1 = {'age': 10, 'name': 10, 'sex': 10}
print dict1.iterkeys()
print dict1.keys()
print dict1.itervalues()
print dict1.values()

运行结果:
< dictionary - keyiterator object at 0x00000000022E3EF8 >
['age', 'name', 'sex']
< dictionary - valueiterator object at 0x00000000022E3EF8 >
[10, 10, 10]

pop – 移除对应的键值对并返回对应的value

dict1 = {'age': 10, 'name': 10, 'sex': 10}
print dict1.pop('age')  # 删除键值age并返回10
print dict1.pop('age1', 'default')  # age1不存在 返回default
print dict1.pop('age1')  # age1不存在 抛异常KeyError: 'age1'

popitem – 移除键值对,并返回 (key, value)

dict1 = {'age': 10, 'name': 10, 'sex': 10}
print dict1.popitem()
print dict1

执行结果:
('age', 10)
{'name': 10, 'sex': 10}

setdefault –  函数和get()方法类似, 如果键不已经存在于字典中,将会添加键并将值设为默认值。

dict1 = {'age': 10, 'name': 10, 'sex': 10}
print dict1.setdefault("age11", 15)
print dict1
print dict1.setdefault("age", 15)
print dict1

执行结果:
15
{'age11': 15, 'age': 10, 'name': 10, 'sex': 10}
10
{'age11': 15, 'age': 10, 'name': 10, 'sex': 10}

update – 使用更新字典更新内容,添加新的键值对,更改已有的键值对

dict1 = {'age': 10, 'name': 10, 'sex': 10}
print dict1
dict1.update({"age": 15, "age11": 15})
print dict1

执行结果:
{'age': 10, 'name': 10, 'sex': 10}
{'age11': 15, 'age': 15, 'name': 10, 'sex': 10}

viewitems – 显示键值对

viewkeys – 显示键值

viewvalues – 显示值

dict1 = {'age': 10, 'name': 10, 'sex': 10}
print dict1.viewitems()
print dict1.viewkeys()
print dict1.viewvalues()

执行结果:
dict_items([('age', 10), ('name', 10), ('sex', 10)])
dict_keys(['age', 'name', 'sex'])
dict_values([10, 10, 10])

set

 

a = t | s          # t 和 s的并集  

b = t & s          # t 和 s的交集  

c = t – s          # 求差集(项在t中,但不在s中)  

d = t ^ s          # 对称差集(项在t或s中,但不会同时出现在二者中)

 

 

集合,一个集合中不可有重复的元素,可以很好利用这点进行列表的去重。

list1 = [1, 1, 2, 2, 3, 4, 5]
print list1
print set(list1)

执行结果:
[1, 1, 2, 2, 3, 4, 5]
set([1, 2, 3, 4, 5]

add – 向集合中添加元素

clear – 清空集合

set1 = set()
print set1
set1.add(2)
print set1
set1.clear()
print set1

执行结果:
set([])
set([2])
set([])

copy – 返回集合的拷贝

difference – 返回与另一个set中不同的部分 (差集)

set1 = set(['a', 'b', 'c'])
set2 = set(['c', 'd', 'e'])

print set1.difference(set2)
print set1 - set2

执行结果:
set(['a', 'b'])
set(['a', 'b']

difference_update – 只保留和其他set中不同的值

set1 = set(['a', 'b', 'c'])
set2 = set(['c', 'd', 'e'])

set1.difference_update(set2)
print set1

执行结果:
set(['a', 'b'])

discard – 从集合中移除一个元素

set1 = set(['a', 'b', 'c'])

set1.discard('a')
print set1

执行结果:
set(['c', 'b'])

intersection – 返回与另一个set的 (交集)

set1 = set(['a', 'b', 'c'])
set2 = set(['c', 'd', 'e'])

print set1.intersection(set2)
print set1 & set2

执行结果:
set(['c'])
set(['c'])

intersection_update – 只保留和其他set中相同的值

set1 = set(['a', 'b', 'c'])
set2 = set(['c', 'd', 'e'])

print set1.intersection_update(set2)
print set1

执行结果:
set(['c'])

isdisjoint – 如果两个set没有交集 返回True

set1 = set(['a', 'b', 'c'])
set2 = set(['d', 'e'])

print set1.isdisjoint(set2)

# 执行结果:
True

issubset – 如果当前set是另一个set的子集 返回True

set1 = set(['a', 'b', 'c'])
set2 = set(['b', 'c'])

print set2.issubset(set1)

# 执行结果:
True

issuperset – 如果当前set是另一个set的超集返回True

set1 = set(['a', 'b', 'c'])
set2 = set(['b', 'c'])

print set1.issuperset(set2)

# 执行结果:
True

pop – 任意删除一个元素并返回,空set将报异常

remove – 从列表中删除指定元素,不存在将报异常

symmetric_difference – 对称差集(项在t或s中,但不会同时出现在二者中)

set1 = set(['a', 'b', 'c'])
set2 = set(['b', 'c', 'd'])

print set1.symmetric_difference(set2)
print set1.difference(set2)
print set1 ^ set2

执行结果:
set(['a', 'd'])
set(['a'])
set(['a', 'd'])

symmetric_difference_update – 将集合赋值为二者的对称差集

set1 = set(['a', 'b', 'c'])
set2 = set(['b', 'c', 'd'])

set1.symmetric_difference_update(set2)
print set1

# 执行结果:
set(['a', 'd'])

union – 返回两个集合的并集

set1 = set(['a', 'b', 'c'])
set2 = set(['b', 'c', 'd'])

print set1.union(set2)
print set1 | set2

# 执行结果:
set(['a', 'c', 'b', 'd'])
set(['a', 'c', 'b', 'd'])

update – 将两个set的并集赋值给当前set

set1 = set(['a', 'b', 'c'])
set2 = set(['b', 'c', 'd'])

print set1 | set2
print set1
set1.update(set2)
print set1

执行结果:
set(['a', 'c', 'b', 'd'])
set(['a', 'c', 'b'])
set(['a', 'c', 'b', 'd'])