**python中列表 元组 字典 集合

天大地大妈咪最大 提交于 2020-02-04 20:27:07

   列表 元组 字典 集合的区别是python面试中最常见的一个问题。这个问题虽然很基础,但确实能反映出面试者的基础水平。

1.列表 

  列表是以方括号“[]”包围的数据集合,不同成员以“,”分隔。

  列表的特点:有序,数据可变,数据可重复,数据类型可不同,可嵌套。

  创建一个列表:tl = [1, 'Hello', 1, "你好", [2, 'World']]

  初步可以看到它的语法、数据可重复、数据类型可不同、可嵌套等特点,如果用print函数多输出几次就会发现它是有序的,下面我们看一下列表的常用操作,同时也证明列表数据可变。

(1)list.append()追加成员,添加到末尾

tl = [1, 'Hello', 1, "你好", [2, 'World']]
print(tl)
tl.append('test')
print(tl)

  输出:

[1, 'Hello', 1, '你好', [2, 'World']]
[1, 'Hello', 1, '你好', [2, 'World'], 'test']

(2)list.pop(i)删除第i个成员,并可将删除的数据赋值给变量

tl = [1, 'Hello', 1, "你好", [2, 'World']]
print(tl)
a = tl.pop(3)
print(tl)
print(a)

  输出:

[1, 'Hello', 1, '你好', [2, 'World']]
[1, 'Hello', 1, [2, 'World']]
你好

(3)list.remove(s)直接删除值为s的成员,如果该值有多个只删除第一个,注意与pop的区别

tl = [1, 'Hello', 1, "你好", [2, 'World']]print(tl)tl.remove("你好")print(tl)

  输出:

[1, 'Hello', 1, '你好', [2, 'World']]
[1, 'Hello', 1, [2, 'World']]

(4)list.index(x)获得参数x在列表中的位置

tl = [1, 'Hello', 1, "你好", [2, 'World']]
print(tl.index([2, 'World']))

  输出:

4

(5)list.insert(a,b)向列表中的a位置插入数据b

tl = [1, 'Hello', 1, "你好", [2, 'World']]
tl.insert(2, '位置二')
print(tl)

  输出:

[1, 'Hello', '位置二', 1, '你好', [2, 'World']]

(6)list.copy()拷贝列表,两者互相独立

tx = [1, 'Hello', 1, "你好", [2, 'World']]
ty = tx.copy()
print(tx)
print(ty)
tx.pop(4)
print(tx)
print(ty)

  输出:

[1, 'Hello', 1, '你好', [2, 'World']]
[1, 'Hello', 1, '你好', [2, 'World']]
[1, 'Hello', 1, '你好']
[1, 'Hello', 1, '你好', [2, 'World']]

(7)list.extend(L)向列表中追加另一个列表L

tx = [1, 'Hello', 1, "你好", [2, 'World']]
ty = [9, 8, 7, 6]
tx.extend(ty)
print(tx)

  输出:

[1, 'Hello', 1, '你好', [2, 'World'], 9, 8, 7, 6]

(8)list.count(y)计算列表中参数y出现的次数,想知道列表长度可以用len(L)

ty = [9, 8, 7, 6, 8]
print(ty.count(8))

  输出:

2

(9)list.sort()将列表中的成员排序,前提是成员数据类型一致

tx = ['1', 'Hello', '1', "你好"]
ty = [9, 8, 7, 6, 8]
ty.sort()
print(ty)
tx.sort()
print(tx)

  输出:

[6, 7, 8, 8, 9]
['1', '1', 'Hello', '你好']

(10)list.reverse()将列表中成员的顺序颠倒

(11)list.clear()将列表清空

 

2.元组

  元组是以圆括号“()”包围的数据集合,不同成员以“,”分隔。

  元组的特点:有序,数据不可变,数据可重复,数据类型可不同,可嵌套。元组通常在需要一组安全稳定的值的时候使用。

  元组和列表的区别除了语法就只有一个:数据不可变,也正是这个特点导致元组没有操作数据的方法,比列表要掌握的东西少得多。

(1)tuple.index(x)获得参数x在列表中的位置

(2)tuple.count(y)计算列表中参数y出现的次数

 

3.字典

  字典是以大括号“{}”包围的数据集合,成员内部用“:”分隔,不同成员以“,”分隔。

  元组的特点:无序,数据可变,键不可重复,数据类型可不同,可嵌套。通过键来访问成员。

  创建一个字典:td = {'k': 'v', 'g': 'd'},下面我们看一下字典的常用操作:

(1)dict.get('k') 获取键为'k'的值

(2)dict.copy() 拷贝字典,两者互相独立

(3)dict.pop('k') 删除键为'k'的值,并可将删除的值赋值给变量

(4)dict.popitem() 随机删除一对键值,并可将删除的键值赋给变量,注意此时变量的类型将变成元组

 

td = {'k': 'v', 'g': 'd'}
print(td)
x = td.popitem()
print(td)
print(x, type(x))

 

  输出:

{'g': 'd', 'k': 'v'}
{'k': 'v'}
('g', 'd') <class 'tuple'>

(5)dict.values() 获取字典中所有的“值”

td = {'k': 'v', 'g': 'd'}
print(td)
x = td.values()
for i in x:
    print(i)

  输出:

{'g': 'd', 'k': 'v'}
d
v

(6)dict.keys() 获取字典中所有的“键”

(7)dict.items() 获取字典的所有键值对,以元组返回

td = {'k': 'v', 'g': 'd'}
print(td)
x = td.items()
for i in x:
    print(i)

  输出:

{'g': 'd', 'k': 'v'}
('g', 'd')
('k', 'v')

 

(8)dict.fromkeys(seq[, value]))  用于创建一个新字典,以序列seq中元素做字典的键,value为字典所有键对应的初始值。

a = ('d', 'g', 's')
b = {}
b = b.fromkeys(a, 'test')
print(a, b)
td = {'k': 'v', 'g': 'd'}
print(td)
x = td.fromkeys('k')
print(x)
y = td.fromkeys(td.values(), 1000)
print(y)

  输出:

('d', 'g', 's') {'s': 'test', 'd': 'test', 'g': 'test'}
{'g': 'd', 'k': 'v'}
{'k': None}
{'v': 1000, 'd': 1000}

(9)dict.setdefault('k','v')   和get()方法类似, 如果键不存在于字典中,将会添加键并将值设为默认值。

dict = {'Name': 'Zara', 'Age': 7}
print("Value : %s" % dict.setdefault('Age', 10))
print("Value : %s" % dict.setdefault('Sex', 'f'))
print(dict)

  输出:

Value : 7
Value : f
{'Name': 'Zara', 'Sex': 'f', 'Age': 7}

(10)dict.update(dict2) 函数把字典dict2的键/值对更新到dict里,即dict2中的成员是一定会保留的

dict1 = {'Name': 'Zara', 'Age': 7}
dict2 = {'Sex': 'female', 'Age': 11}
dict1.update(dict2)
print("Value : %s" % dict1)

  输出:

Value : {'Sex': 'female', 'Age': 11, 'Name': 'Zara'}

(11)dict.clear() 清空

 

4.集合

  集合的特点:无序,数据可变,数据不可重复,数据类型可不同,不可嵌套。集合最好的应用是去重和关系操作(交集、并集等)。集合没有特殊的表示方法,而是通过一个set函数转换成集合。

  创建一个字典:t = set("Hello"):

a = set('asdsf')
b = set([8, 5, 7,'xx', 10, 'asdf'])
print(a)
print(b)

  输出:

{'d', 's', 'f', 'a'}
{'xx', 5, 7, 8, 10, 'asdf'}

可以看到将一个字符串转换为集合,会把字符串每个字符分开,最终成为一个集合。

     下面我们看一下字典的常用操作:

(1)set.add(x) 添加x元素到集合。

a = set(['asdsf', 10])
a.add('iis')
print(a)

  输出:

{'iis', 'asdsf', 10}

(2)set.remove(y)  删除集合中的y元素,如果y不存在会报错

a = set(['asdsf', 10])
a.remove('asdsf')
print(a)

  输出:

{10}

(3)set.discard(x)  删除集合中的x元素,如果x不存在,不会报错,注意和remove的区别

b = set([8, 5, 7,'xx', 10, 'asdf'])
b.discard(9)
print(b)

  输出:

{5, 7, 8, 10, 'asdf', 'xx'}

(4)set.pop()  随机删除一个集合元素,可将删除的元素赋值给变量

a = set(['asdsf', 10])
x = a.pop()
print(a)
print(x)

  输出:    #注意:删除是随机的,多执行几次结果会有变化

{'asdsf'}
10

(5)set.copy() 拷贝一个集合

a = set(['asdsf', 10])
x = a.copy()
print(a)
print(x)
a.remove(10)
print(a, x)
x.remove('asdsf')
print(a, x)

  输出:

{10, 'asdsf'}
{10, 'asdsf'}
{'asdsf'} {10, 'asdsf'}
{'asdsf'} {10}

可见,对两个集合的操作互不影响

(6)set.union()和set.update()  将两个集合取并集,这两个方法效果一样,但是union字面意思好理解一些。

b = set([8, 5, 7,'xx', 10, 'asdf'])
a = ['kk','vv']
b.update(a)
print(b)
b.union(a)
print(b)

  输出:

{'asdf', 5, 7, 8, 10, 'vv', 'xx', 'kk'}
{'asdf', 5, 7, 8, 10, 'vv', 'xx', 'kk'}

(7)set.intersection()  将两个集合取交集。

s = set([3, 5, 9,'asdsf', 10, 'asdf'])
b = set([8, 5, 7,'xx', 10, 'asdf'])
xx = b.intersection(s)
print(xx)

  输出:

{10, 'asdf', 5}

(8)b.intersection_update(s)  将两个集合取交集,并将所取的交集覆盖到集合b中

s = set([3, 5, 9,'asdsf', 10, 'asdf'])
b = set([8, 5, 7,'xx', 10, 'asdf'])
b.intersection_update(s)
print(b)

  输出:

{10, 'asdf', 5}

(9)yy = b.difference(s)  将b中存在但s中不存在的元素放到集合yy中

s = set([3, 5, 9,'asdsf', 10, 'asdf'])
b = set([8, 5, 7,'xx', 10, 'asdf'])
yy = b.difference(s)
print(yy)

  输出:

{8, 'xx', 7}

(10)b.difference_update(s)  将b中存在但s中不存在的元素覆盖到集合b中

s = set([3, 5, 9,'asdsf', 10, 'asdf'])
b = set([8, 5, 7,'xx', 10, 'asdf'])
b.difference_update(s)
print(b)

  输出:

{'xx', 7, 8}

(11)b.issunset(s)  判断b是不是s的子集

s = set([3, 5, 9,'asdsf', 10, 'asdf'])
b = set([5, 10, 'asdf'])
x = b.issubset(s)
y = s.issubset(b)
print(x)
print(y)

  输出:

True
False

(12)set.issuperset()  和上一个相反,判断超集

(13)x = s.isdisjoint(b)  判断s和b没有交集,没有返回True,有返回False。

s = set([3, 5, 9,'asdsf', 10, 'asdf'])
b = set([6, 10, 'asdf'])
c = set([6, 8, 0])
x = s.isdisjoint(b)
y = s.isdisjoint(c)
print(x)
print(y)

  输出:

False
True

(14)x = s.symmetric_difference(b)   将s和b两个集合的非重复项合并为一个新的集合。

s = set([3, 5, 9,'asdsf', 10, 'asdf'])
b = set([6, 10, 'asdf'])
x = s.symmetric_difference(b)
print(x)

  输出:

{3, 5, 6, 'asdsf', 9}

(15)s.symmetric_difference_update(b)   将s和b两个集合的非重复项合并为一个新的集合并赋值给s。

s = set([3, 5, 9,'asdsf', 10, 'asdf'])
b = set([6, 10, 'asdf'])
s.symmetric_difference_update(b)
print(s)

  输出:

{3, 5, 6, 'asdsf', 9}

标签
易学教程内所有资源均来自网络或用户发布的内容,如有违反法律规定的内容欢迎反馈
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!