Python的列表、元组、字典、集合的常用操作

一、列表的常用操作

1、count()

描述：统计列表中指定元素的个数

参数：value  指定的元素

返回值：返回这个值在列表中的个数，若未找到则返回0

示例1：

l = ['knight','sky','xiaobai','xiaoxiaobai']
l1 = l.count('sky')
print(type(l1),l1)

输出结果：

<class 'int'> 1

示例2：

l = ['knight','sky','xiaobai','xiaoxiaobai']
l1 = l.count(hahahahaha') # 若没有找到则返回0
print(type(l1),l1)

 输出结果：

<class 'int'> 0

 

2、index()

描述：与count()方法相似，统计列表中指定值的位置，不同之处是没找到指定的值则会抛出异常

参数：value  指定的值

　　　start  起始位置

　　　stop  结束位置

返回值：返回这个值在列表中的位置，若未找到则抛出异常

示例1：

l = ['knight','sky','xiaobai','xiaoxiaobai']
l1 = l.count('sky')
print(type(l1),l1)

 输出结果：

<class 'int'> 1

示例2：

l = ['knight','sky','xiaobai','xiaoxiaobai']
l1 = l.count(hahahahaha') # 若没有找到则报错
print(type(l1),l1)

  输出结果：

Traceback (most recent call last):
  File "C:/Users/William/PycharmProjects/day3/practice1.py", line 2, in <module>
    l1 = l.index('hahahahaha')
ValueError: 'hahahahaha' is not in list

 

3、append()

描述：在列表的末尾添加元素

参数：p_object   添加的元素

返回值：None（原列表会被修改）

示例：

l = ['william','lisa','knight','pudding']
l.append('sky')
print(type(l),l)

输出结果：

<class 'list'> ['william', 'lisa', 'knight', 'pudding', 'sky']

 

4、insert()

描述：将元素插入到列表中指定的位置

参数：index  指定的索引位置

　　　p_object  要插入的元素

返回值：None（原列表会被修改）

示例：

l = ['william','lisa','knight','pudding']
l.insert(2,'sky')  # 往索引2的位置前面插入一个“sky”的元素
print(type(l),l)

 输出结果：

<class 'list'> ['william', 'lisa', 'sky', 'knight', 'pudding']

 

5、extend()

描述：扩展列表（扩展的值添加到列表末尾）

参数：iterable  元素列表

返回值：None（原列表会被修改）

示例：

l = ['william','lisa','knight','pudding']
l2 = ['hello','world']
l.extend(l2)   # 为列表“l”扩展
print(type(l),l)

输出结果：

<class 'list'> ['william', 'lisa', 'knight', 'pudding', 'hello', 'world']

 

6、copy()

描述：复制列表

参数：无

返回值：得到一个复制后的新列表

示例：

l = ['william','lisa','knight','pudding']
l2 = l.copy()
print(type(l),l)
print(type(l2),l2)

输出结果：

<class 'list'> ['william', 'lisa', 'knight', 'pudding']
<class 'list'> ['william', 'lisa', 'knight', 'pudding']

 

7、clear()

描述：清空列表中所有的元素

参数：无

返回值：无（原列表会被修改）

示例：

l = ['william','lisa','knight','pudding']
l.clear()
print(type(l),l)

 输出结果：

<class 'list'> []

 

8、pop()

描述：移除列表中指定的元素（默认删除列表中最后一个元素）

参数：index   索引位置

返回值：返回被移除的元素

示例1：

l = ['william','lisa','knight','pudding']
l1 = l.pop() # 不指定索引位置，默认删除列表中最后一个元素
print(type(l),l)

 输出结果：

<class 'list'> ['william', 'lisa', 'knight']

示例2：

l = ['william','lisa','knight','pudding']
l.pop(2)  # 指定删除索引2位置的元素
print(type(l),l)

 输出结果：

<class 'list'> ['william', 'lisa', 'pudding']

 

9、sort()

描述：对列表进行排序

参数：key  默认key=None，key在使用时必须提供一个排序过程总调用的函数

　　　reverse 默认reverse=False，当reverse=True时元素的排序会按降序排序

返回值：None（原列表会被修改）

示例1：

l = ['william','lisa','knight','pudding']
l.sort()　　# 默认按元素中的第一个字母，以a-z的顺序进行排序
print(type(l),l)

 输出结果：

<class 'list'> ['knight', 'lisa', 'pudding', 'william']

示例2：

l = [5,3,2,7,4,1,6]
l.sort()　　# 数字按0-9的升序排序。注意列表中若既有数字又有字符串则不能用sort方法排序，否则报错
print(type(l),l)

 输出结果：

<class 'list'> [1, 2, 3, 4, 5, 6, 7]

示例3：

l = [5,3,2,7,4,1,6]
l.sort()       # 不加参数时默认按升序排序
print(type(l),l)
l.sort(reverse=True) # 加上reverse=True时，表示将列表按降序排序
print(type(l),l)

输出结果：

<class 'list'> [1, 2, 3, 4, 5, 6, 7]
<class 'list'> [7, 6, 5, 4, 3, 2, 1]

示例4：

l = ['x','xxxx','xx','xxxxx','xxx']
l.sort(key=len)       # 提供一个排序过程调用的函数，本例用len函数得到元素的长度，然后按升序排序
print(type(l),l)

输出结果：

<class 'list'> ['x', 'xx', 'xxx', 'xxxx', 'xxxxx']

 

10、reverse()

描述：反转列表中的元素

参数：无

返回值：None （原列表会被修改）

示例：

l = ['william','lisa','knight','pudding']
l.reverse()  # 反转列表中的元素
print(type(l),l)

输出结果： 

<class 'list'> ['pudding', 'knight', 'lisa', 'william']

 

11、remove()

描述：移除列表中指定的元素

参数：value  指定的元素

返回值：None（原列表会被修改）

示例：

l = ['william','lisa','knight','pudding']
l.remove('lisa') # 删除元素“lisa”
print(type(l),l)

输出结果：

<class 'list'> ['william', 'knight', 'pudding']

 

二、元组的常用操作

1、count()

描述：查找指定元素的索引位置

参数：value  指定的元素

返回值：返回指定元素的索引位置，若没元组中没有这个元素则返回0

示例：

t = ('william','lisa','knight','pudding')
t2 = t.count('lisa')
print(type(t2),t2)
t3 = t.count('xxxxx')
print(type(t3),t3)

输出结果：

<class 'int'> 1
<class 'int'> 0

 

2、index()

描述：和count()一样，查找指定元素的索引位置，不同点是如果元组里没有这个元素则会抛异常

参数：value  指定的元素

返回值：返回指定元素的索引位置，若没元组中没有这个元素则抛异常

示例：

t = ('william','lisa','knight','pudding')
t2 = t.index('lisa')
print(type(t2),t2)

 输出结果：

<class 'int'> 1

 

三、字典的常用方法

1、key()

描述：取出字典中所有的键

参数：无

返回值：返回这个字典所有的键

示例：

d = {'name':'william','age':30,'sex':'male'}
d2 = d.keys()　　# 取出字典中所有的键
print(type(d2),d2)

输出结果：

<class 'dict_keys'> dict_keys(['name', 'age', 'sex'])

 

2、values()

描述：取出字典中所有的值

参数：无

返回值：返回这个字典中所有的值

示例：

d = {'name':'william','age':30,'sex':'male'}
d2 = d.values()　　# 取出字典中所有的值
print(type(d2),d2)

输出结果：

<class 'dict_values'> dict_values(['william', 30, 'male'])

 

3、clear()

描述：清空字典

参数：无

返回值：None（原字典会被修改）

示例：

d = {'name':'william','age':30,'sex':'male'}
d.clear()    # 清空字典
print(type(d),d)

输出结果：

<class 'dict'> {}

4、pop()

描述：删除指定的键值

参数：指定的key

返回值：返回被删除键的值

示例：

d = {'name':'william','age':30,'sex':'male'}
d2 = d.pop('name') # 删除指定的键
print(type(d2),d2) # 打印返回被删除的键的值
print(type(d),d) 

输出结果：

<class 'str'> william
<class 'dict'> {'age': 30, 'sex': 'male'}

5、copy()

描述：复制当前字典

参数：无

返回值：得到一个新的字典

示例：

d = {'name':'william','age':30,'sex':'male'}
d2 = d.copy()  # 复制当前字典
print(type(d2),d2) # 打印得到的新字典
print(type(d),d)

输出结果：

<class 'dict'> {'name': 'william', 'age': 30, 'sex': 'male'}
<class 'dict'> {'name': 'william', 'age': 30, 'sex': 'male'}

 

6、update()

描述：扩展字典

参数：要添加的字典

返回值：None（原字典会被修改）

示例：

d = {'name':'william','age':30,'sex':'male'}
d2 = {'hobby':'football'}
d.update(d2)　　# 扩展字典
print(type(d),d)

输出结果：

<class 'dict'> {'name': 'william', 'age': 30, 'sex': 'male', 'hobby': 'football'}

7、get()

 

描述：返回指定键的值

 

参数：key  指定查找的键

 

　　　defaullt  如果要查找的键不存在时，则返回自定的值

 

返回值：返回指定键的值，如果要查找的键不存在时，则返回自定的值（不写默认为None）

示例1：

d = {'name':'william','age':30,'sex':'male'}
d2 = d.get('hobby')  # 查找的键不在字典中且后面不加值，则输出为None
print(type(d2),d2)

输出结果：

<class 'NoneType'> None

 

示例2：

d = {'name':'william','age':30,'sex':'male'}
d2 = d.get('hobby','football') # 查找的键不在字典中且后面有值，则输出这个值
print(type(d2),d2)

输出结果：

 

<class 'str'> football

 

示例3：

d = {'name':'william','age':30,'sex':'male'}
d2 = d.get('age')  # 查找的键存在字典中，则输出这个键对应的值
print(type(d2),d2)

输出结果：

<class 'int'> 30

 

8、popitem()

描述：随机返回并删除字典中的一对键和值。

参数：无

返回值：返回一对键和值（原字典会被修改）

示例：

d = {'name':'william','age':30,'sex':'male'}
d2 = d.popitem()
print(type(d2),d2)　　# 随机返回一对键和值
print(type(d),d)　　　# 原有的字典将会被更改

输出结果：

<class 'tuple'> ('sex', 'male')
<class 'dict'> {'name': 'william', 'age': 30}

 

9、items

描述：返回可遍历的（键、值）元组数组

参数：无

返回值：返回可遍历的（键、值）元组数组

示例：

d = {'name':'william','age':30,'sex':'male'}
d2 = d.items()
print(type(d2),d2)

输出结果：

<class 'dict_items'> dict_items([('name', 'william'), ('age', 30), ('sex', 'male')])

 

10、fromkeys

描述：从序列键和值设置为value来创建一个新的字典。

参数：seq  用于字典的键准备的列表

　　　value  若提供值将被设置为这个值，否则默认为None

返回值：得到一个新的列表

示例：

seq = ('name', 'age', 'sex')
dict = dict.fromkeys(seq)　　
print(dict)
 
dict = dict.fromkeys(seq, 10)
print(dict)

输出结果：

{'name': None, 'age': None, 'sex': None}
{'name': 10, 'age': 10, 'sex': 10}

 

11、setdefault()

描述：和get方法类似，如果键不存在，则将这个键加入到字典里，对应一个空值

参数：key  查找的键

　　　default  键不存在时，设置的默认键值

返回值：返回指定键的值（原字典不会被修改），如果键不存在，则返回None（原字典会被修改）

示例1：

d = {'name':'william','age':30,'sex':'male'}
d2 = d.setdefault('name')　　# 返回指定键的值
print(type(d2),d2)

输出结果：

<class 'str'> william

 

示例2：

d = {'name':'william','age':30,'sex':'male'}
d2 = d.setdefault('xxxxx')
print(type(d2),d2)
print(type(d),d)

输出结果：

<class 'NoneType'> None
<class 'dict'> {'name': 'william', 'age': 30, 'sex': 'male', 'xxxxx': None}

 

四、集合的常用方法

1、update()

描述：扩展集合

参数：要添加的集合

返回值：None（原集合会被修改）

示例：

s1 = {'william','lisa','knight','pudding'}
s2 = {'sky'}
s3 = s1.update(s2)  # 扩展集合s1
print(type(s3),s3)  # 查看返回值
print(type(s1),s1)  # 打印扩展后的集合s1

输出结果：

<class 'NoneType'> None
<class 'set'> {'knight', 'sky', 'pudding', 'lisa', 'william'}

 

2、copy()

描述：复制集合

参数：无

返回值：返回一个和原集合一样的新的集合

示例：

s1 = {'william','lisa','knight','pudding'}
s2 = s1.copy()  # 对集合s1进行复制
print(type(s1),s1)
print(type(s2),s2)

输出结果：

<class 'set'> {'knight', 'pudding', 'william', 'lisa'}
<class 'set'> {'knight', 'pudding', 'william', 'lisa'}

3、pop()

描述：随机删除集合中的一个元素

参数：无

返回值：返回被删除的元素

示例：

 

s1 = {'william','lisa','knight','pudding'}
s2 = s1.pop()    # 随机删除集合中的一个元素
print(type(s1),s1) 
print(type(s2),s2)

 

输出结果：

<class 'set'> {'lisa', 'knight', 'william'}
<class 'str'> pudding

 

4、clear()

描述：清空字典

参数：无

返回值：None（原集合会被修改）

示例：

s1 = {'william','lisa','knight','pudding'}
s2 = s1.clear()　　# 清空集合
print(type(s1),s1)
print(type(s2),s2)

输出结果：

<class 'set'> set()
<class 'NoneType'> None

5、remove()

描述：删除集合中指定的元素，删除集合中的元素若不存在则会报错

参数：element  元素

返回值：None（原集合会被修改）

示例：

s1 = {'william','lisa','knight','pudding'}
s2 = s1.remove('lisa')
print(type(s1),s1) 
print(type(s2),s2)  # 返回值为空

输出结果：

<class 'set'> {'william', 'pudding', 'knight'}
<class 'NoneType'> None

 

6、add()

描述：为集合增加元素

参数：element  元素

返回值：None（原集合会被修改）

示例：

s1 = {'william','lisa','knight','pudding'}
s2 = s1.add('sky')
print(type(s1),s1)
print(type(s2),s2)  # 返回值为空

输出结果：

<class 'set'> {'pudding', 'lisa', 'william', 'knight', 'sky'}
<class 'NoneType'> None

 

7、difference()

描述：差集运算，原集合不更新

参数：set  要对比的集合

返回值：得到一个差集

示例：

s1 = {'william','lisa','knight','pudding'}
s2 = {'sky','william','hello','knight'}
s3 = s1.difference(s2)
print(type(s3),s3)  # 得到一个差集。
print(type(s1),s1)  # 原集合不更新

输出结果：

<class 'set'> {'lisa', 'pudding'}
<class 'set'> {'pudding', 'lisa', 'knight', 'william'}

 

8、difference_update

描述：差集运算，原集合更新

参数：set  要对比的集合

返回值：None（原集合会被修改）

示例：

s1 = {'william','lisa','knight','pudding'}
s2 = {'sky','william','hello','knight'}
s3 = s1.difference_update(s2)
print(type(s3),s3)  # 返回None
print(type(s1),s1)  # 原集被更新

输出结果：

<class 'NoneType'> None
<class 'set'> {'pudding', 'lisa'}

 

9、discard()

描述：删除集合中指定的元素，删除集合中的元素若不存在也不会报错

参数：element  元素名

返回值：None（原集合会被修改）

示例：

s1 = {'william','lisa','knight','pudding'}
s2 = s1.discard('william')
print(type(s2),s2)  　
print(type(s1),s1) 

输出结果：

<class 'NoneType'> None
<class 'set'> {'lisa', 'knight', 'pudding'}

 

10、intersection()

描述：交集运算，原集合不更新

参数：set  要对比的集合

返回值：得到一个交集

示例：

s1 = {'william','lisa','knight','pudding'}
s2 = {'william','xxxx'}
s3 = s1.intersection(s2)
print(type(s3),s3)  # 得到一个交集
print(type(s1),s1)  # 原集合不更新

输出结果：

<class 'set'> {'william'}
<class 'set'> {'william', 'lisa', 'knight', 'pudding'}

 

11、intersection_update()

描述：交集运算，原集合更新

参数：set  要对比的集合

返回值：None（原集合会被修改）

示例：

s1 = {'william','lisa','knight','pudding'}
s2 = {'william','xxxx'}
s3 = s1.intersection_update(s2)
print(type(s3),s3)  # 返回None
print(type(s1),s1)  # 原集合更新

输出结果：

<class 'NoneType'> None
<class 'set'> {'william'}

 

12、isdisjoint()

描述：判断是否有交集，如果有交集则返回False，没有返回True

参数：set  要对比的集合

返回值：返回一个布尔值

示例：

s1 = {'william','lisa','knight','pudding'}
s2 = {'xxxx','lisa'}
s3 = s1.isdisjoint(s2)   # 有交集则返回False
print(type(s3),s3)
#--------------------------------------------
s4 = {'william','lisa','knight','pudding'}
s5 = {'xxxx','yyyyy','kkkkkk','uuuuuu'}
s6 = s4.isdisjoint(s5)   # 没有交集则返回True
print(type(s6),s6）

输出结果：

<class 'bool'> False
<class 'bool'> True

 

13、issubset()

描述：判断原集合是否是要对比的集合的子集，如果是则返回True，否则返回False，若两个集合相等则返回True，表示两个集合互为子集

参数：set  要对比的集合

返回值：得到一个布尔值

示例：

s1 = {'william','pudding'}
s2 = {'william','lisa','knight','pudding'}
s3 = s1.issubset(s2)    # s1是否是s2的子集，所以返回True
print(type(s3),s3)
#--------------------------------------
s4 = {'william','xxxxx'}
s5 = {'william','lisa','knight','pudding'}
s6 = s4.issubset(s5)    # s4不是s5的子集，所以返回False
print(type(s6),s6)

输出结果：

<class 'bool'> True
<class 'bool'> False

 

14、issuperset()

描述：判断原集合是否是要对比的集合的超（父）集，如果是则返回True，否则返回False

参数：set  要对比的集合

返回值：得到一个布尔值

示例：

s1 = {'william','lisa','knight','pudding'}
s2 = {'william','pudding'}
s3 = s1.issuperset(s2)    # s1是s2的超(父)集，所以返回True
print(type(s3),s3)
#--------------------------------------
s4 = {'william','xxxxx'}
s5 = {'william','lisa','nnnnn','xxxx'}
s6 = s4.issuperset(s5)    # s4不是s5的超(父)集，所以返回False
print(type(s6),s6)

输出结果：

<class 'bool'> True
<class 'bool'> False

 

15、symmetric_difference()

描述：对称差集运算，原集合不更新

参数：set  要对比的集合

返回值：返回一个对称差集

示例：

s1 = {'william','lisa','knight','pudding'}
s2 = {'william','pudding','xxxxxx'}
s3 = s1.symmetric_difference(s2)
print(type(s3),s3)   # 得到一个对称差集
print(type(s1),s1)   # 对称差集运算，原集合不更新

输出结果：

<class 'set'> {'knight', 'lisa', 'xxxxxx'}
<class 'set'> {'knight', 'william', 'lisa', 'pudding'}

 

16、symmetric_difference_update()

描述：对称差集运算，原集合更新

参数：set  要对比的集合

返回值：None（原集合会被修改）

示例：

s1 = {'william','lisa','knight','pudding'}
s2 = {'william','pudding','xxxxxx'}
s3 = s1.symmetric_difference_update(s2)
print(type(s3),s3)   # 返回None
print(type(s1),s1)   # 对称差集运算，原集合更新

输出结果：

<class 'NoneType'> None
<class 'set'> {'lisa', 'knight', 'xxxxxx'}

 

17、union()

描述：并集运算，原集合不更新

参数：set  要对比的集合

返回值：得到一个新的集合，两个集合中都有的元素都合并成一个。

示例：

s1 = {'william','lisa','knight','pudding'}
s2 = {'william','pudding','xxxxxx'}
s3 = s1.union(s2)
print(type(s3),s3)   # 返回得到一个新的集合，两个集合中都有的元素都合并成一个。
print(type(s1),s1)   # 并集运算，原集合不更新
 

输出结果：

<class 'set'> {'xxxxxx', 'knight', 'william', 'lisa', 'pudding'}
<class 'set'> {'pudding', 'lisa', 'knight', 'william'}