（四）列表/元祖、字典和集合常用方法

最新推荐文章于 2024-03-23 20:12:02 发布

拥有一只傻猫和蠢狗的测试媛

最新推荐文章于 2024-03-23 20:12:02 发布

阅读量205

点赞数

分类专栏： python基础语法

本文链接：https://blog.csdn.net/weixin_42984773/article/details/115564238

版权

python基础语法专栏收录该内容

10 篇文章 0 订阅

订阅专栏

列表的常用方法

append函数
将一个元素添加到当前列表，被添加的元素只会被添加到末尾，append函数是在原有列表的基础上添加，不需额外添加新的变量
用法：list.append(new_item)，没事只能添加一个变量，如想多次添加可配合循环使用

books = []
print(id(books))    #140199184643648
books.append('python')
books.append('java')
print(books)    #['python', 'java']

number = '1.1'
tuple_list = (1,)
dict_list = {'name':'shaishai'}
books.append(number)
books.append(tuple_list)
books.append(dict_list)
books.append(True)
books.append(None)
print(books)    #['python', 'java', '1.1', (1,), {'name': 'shaishai'}, True, None]
print(id(books))    #140199184643648

count函数
返回当前列表中某个元素的个数，如查询的元素不存在，则返回0，列表只会检查完整元素是否存在
用法：inttype = list.count(item)

animals = ['小猫','小兔子','小狗','小猫','龙猫','小狗','小兔子','乌龟','小猫']
print('我家里有小猫{}只'.format(animals.count('小猫')))  #我家里有小猫3只
print('我家里有小兔子{}只'.format(animals.count('小兔子')))    #我家里有小兔子2只
print('我家里有小狗%s只' %(animals.count('小狗')))   #我家里有小狗2只
print('我家里有鲤鱼%s只' %(animals.count('鲤鱼')))   #我家里有鲤鱼0只

remove函数
删除列表中的某个元素，如果删除的元素不存在，会直接报错，如果被删除的元素有多个，只会删除第一个，remove函数不会返回一个新的列表，而是在原先的列表中对元素进行删除
用法：list.remove(item)
python有del内置函数，del是把变量完全删除

animals = ['小猫','小兔子','小狗','小猫','龙猫','小狗','小兔子','乌龟','小猫']
animals.remove('小兔子')
print(animals)  #['小猫', '小狗', '小猫', '龙猫', '小狗', '小兔子', '乌龟', '小猫']
print('我家里有小兔子{}只'.format(animals.count('小兔子')))    #我家里有小兔子1只
del animals     #直接删除animals列表
print(animals)      #NameError: name 'animals' is not defined

reverse函数
对当前列表的顺序进行反转
用法：list.reverse()

list_info = ['python', 'java', '1.1', (1,), {'name': 'shaishai'}, True, None]
list_info.reverse()
print(list_info)        #[None, True, {'name': 'shaishai'}, (1,), '1.1', 'java', 'python']

sort函数
对当前列表按照一定规律进行排序，列表中的元素类型必须相同，否则会报错，无法排序
用法：list.sort(key=None,reverse=False)
key — 参数比较，在sort内部会将可迭代对象中的每一个元素传递给这个函数的参数，根据函数运算的结果进行排序
reverse – 排序规则，reverse = True 降序，reverse = False 升序（默认）

books = ['python','django','java','nodejs','web']
books.sort()		#['django', 'java', 'nodejs', 'python', 'web']
books.sort(reverse=True)    	#['web', 'python', 'nodejs', 'java', 'django']

books = ['python','django','java','nodejs','web',1]
books.sort()	#TypeError: '<' not supported between instances of 'int' and 'str'

info = [
    {"name": 'yanmai'},
    {"name": 'shaishai'},
    {"name":'xixi'}
]
info.sort(key=lambda x: x['name'])
print(info)     #[{'name': 'shaishai'}, {'name': 'xixi'}, {'name': 'yanmai'}]

clear函数
把当前列表中的数据清空
用法：list.clear()

list_info = ['python', 'java', '1.1', (1,), {'name': 'shaishai'}, True, None]
list_info.clear()
print(list_info)    #[]

copy函数
将当前的列表复制一份相同的列表，新列表与旧列表内容相同，但内存空间不同
用法：list.copy()
和二次赋值的区别
二次赋值的变量和原始变量享有相同内存空间，copy函数创建的新列表与原始列表不是一个内存空间，不同享数据变更，copy属于浅拷贝（只对第一层数据进行copy）

old_list = ['python','django','flask',['web','ios']]
new_list = old_list.copy()
new_list.append('java')         #不会对old_list有影响
new_list[3].append('android')   #浅拷贝，有两层数据时，old_list也新增了'android'元素
print(old_list)                 #['python', 'django', 'flask', ['web', 'ios', 'android']]
print(new_list)                 #['python', 'django', 'flask', ['web', 'ios', 'android'], 'java']

extend函数
讲其他列表或元组中的元素导入到当前列表中
用法：list.extend(iterable)

history = []
new_history = ['中国历史','韩国历史','朝鲜历史']
manhua = ('a','b','cd')  #字符串导入时，会被打散为不同元素
history.extend(new_history)
history.extend(manhua)
print(history)              #['中国历史', '韩国历史', '朝鲜历史', 'a', 'b', 'c','d']

insert
将一个元素添加到当前列表的指定位置中，
apend和insert的区别：append只能添加到列表的末尾，insert可以选择任何一个位置；insert传入的位置列表中不存在，则将元素添加到列表的末尾；索引从0开始计算
用法：list.insert(index,new_item)

students = [
    {'name' : 'shaishai','age' : 18},
    {'name' : 'xixi','age' : 16}
]
yanmai = {'name' : 'yanmai','age' : 14}
students.insert(1,yanmai)
students.insert(0,None)
print(students)         #[None, {'name': 'shaishai', 'age': 18}, {'name': 'yanmai', 'age': 14}, {'name': 'xixi', 'age': 16}]

索引与切片
什么是索引：字符串，列表和元组，从最左边记录的位置就是索引，从0开始计算，最大索引是他们的长度 -1。
什么是切片：最一定范围内的元素进行访问，通过冒号在中括号内把两个索引查找出来，切片规则：左含，右不含

number = [1,2,3,4,5,6,7,8,9]
print('获取列表完整数据：',number[:])          #获取列表完整数据： [1, 2, 3, 4, 5, 6, 7, 8, 9]
print('另一种获取完整的列表数据：',number[0:])     #另一种获取完整的列表数据： [1, 2, 3, 4, 5, 6, 7, 8, 9]
print('第三种获取列表数据：',number[0:-1])         #第三种获取列表数据： [1, 2, 3, 4, 5, 6, 7, 8]
print('列表反序：',number[::-1])              #列表反序： [9, 8, 7, 6, 5, 4, 3, 2, 1]
print('列表反向获取：',number[-4:-1])          #列表反向获取： [6, 7, 8]
print('列表步长获取：',number[0:8: 2])         #列表步长获取： [1, 3, 5, 7]
print('切片生成空列表：',number[0: 0])         #切片生成空列表： []

列表的索引，获取与修改

number = [1,2,3,4,5,6,7,8,9]
number[2] = 'a'
number[4:6] = 'shai','花'
print(number)       #[1, 2, 'a', 4, 'shai', '花', 7, 8, 9]

pop函数
通过索引删除并获取列表的元素，如传入的index索引不存在则报错
用法：list.pop(index)

number = [1,2,3,4,5,6,7,8,9]
new_number = number.pop(5)
print(new_number)   #6
print(number)       #[1, 2, 3, 4, 5, 7, 8, 9]

del函数
用法：del list[index]

number = [1,2,3,4,5,6,7,8,9]
del number[5]
print(number)   #[1, 2, 3, 4, 5, 7, 8, 9]

索引在元组中的特殊性：
可以和列表一样获取索引和切片索引，元组函数index和列表用法完全一致，但是无法通过索引修改与删除元素

字典的常用方法
字典中每一个key一定是唯一的，数据量没有限制，字典中的value可以是任何python的内置数据类型的对象和自定义的对象

直接读取和添加字典数据

info = {'name': 'shaishai','age': 18,'sex':'man'}
print(info['name'])     #shaishai
info["iphone"] = 88888888   
print(info)     #{'name': 'shaishai', 'age': 18, 'sex': 'man', 'iphone': 88888888}

update函数
添加新的字典，如新字典中有和原字典相同的key，则改key的value会被新字典的value覆盖
用法：dict.update(new_dict)

info = {'name': 'shaishai','age': 18,'sex':'man'}
new_info = {'name' : 'xixi','iphone' : 99999999}
info.update(new_info)
print(info)     #{'name': 'xixi', 'age': 18, 'sex': 'man', 'iphone': 99999999}

setdefault函数
获取某个key的value，如key不存在在于字典中，将会添加key并将value设为默认值
用法：dict.setdefault(key,value)

info = {'name': 'shaishai','age': 18,'sex':'man'}
value = info.setdefault('name','xixi')
print(value)    #shaishai
value = info.setdefault('birthday','2013-10-3')
print(value)    #2013-10-3
print(info)     #{'name': 'shaishai', 'age': 18, 'sex': 'man', 'birthday': '2013-10-3'}

keys函数
获取当前字典中所有键，返回一个伪列表
用法：dict.keys()

info = {'name': 'shaishai','age': 18,'sex':'man'}
print(info.keys())      #dict_keys(['name', 'age', 'sex']) 得到的是一个虚假列表
key_list = list(info.keys())
print(key_list)

values函数
获取当前字典中所有键值对中的值,返回一个value集合的伪列表
用法：dict.values()

info = {'name': 'shaishai','age': 18,'sex':'man'}
print(info.values())        #dict_values(['shaishai', 18, 'man'])
key_list = list(info.values())
print(key_list)     #['shaishai', 18, 'man']

get函数
获取当前字典中指定key的value
用法：dict.get(key, default=None)

info = {'name': 'shaishai','age': 18,'sex':'man'}
print(info.get('name'))     #shaishai
print(info.get('iphone'))   #None
print(info.get('iphone',88888888))   #88888888 未找到对应key，就返回设置的值
print(info['iphone'])       #KeyError: 'iphone'
print(info)     #{'name': 'shaishai', 'age': 18, 'sex': 'man'}

[]如果获取的key不存在，则直接报错，get如果获取的key不存在，则返回默认值，所以在开发开发中，优先使用get函数

clear函数
清空当前字典中所有数据
用法：dict.clear()

info = {'name': 'shaishai','age': 18,'sex':'man'}
info.clear()
print(info)     #{}

pop函数
删除字典中指定的key，并将其结果返回，如果key不存在则报错
用法：dict.pop(key)

info = {'name': 'shaishai','age': 18,'sex':'man'}
new_info = info.pop('name')
print(new_info) #shaishai
print(info)     #{'age': 18, 'sex': 'man'}
new_info2 = info.pop('iphone')  #KeyError: 'iphone'

del函数
删除字典数据
用法：del dict[key]

info = {'name': 'shaishai','age': 18,'sex':'man'}
del info['age']
print(info)     #{'name': 'shaishai', 'sex': 'man'}
del info #info被彻底删除

copy函数
将当前字典复制一个新的字典
用法：dict.copy()

info = {'name': 'shaishai','age': 18,'sex':'man'}
copy_info = info.copy()
print(copy_info)        #{'name': 'shaishai', 'age': 18, 'sex': 'man'}
print(id(info),id(copy_info))   #140564049207872 140564049207936

popitem函数
删除当前字典里末尾一组键值对并将其返回，返回的是元组类型，如字典为空，则直接报错
用法：dict.popitem()

info = {'name': 'shaishai','age': 18,'sex':'man'}
last_info = info.popitem()
print(last_info)    #('sex', 'man')

items函数
遍历字典数据，生成key和value为元组组成的列表类型
用法：dict.items()

info = {'name': 'shaishai','age': 18,'sex':'man'}
s = info.items()
print(list(s))      #[('name', 'shaishai'), ('age', 18), ('sex', 'man')]

fromkeys
生成以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值
用法：dict.fromkeys(seq[, value])

info = {}
b1 = info.fromkeys(['n','d'],[1,2,3,4])   #{'n': [1, 2, 3, 4], 'd': [1, 2, 3, 4]}
b2 = info.fromkeys('name',{'id':3})      #{'n': {'id': 3}, 'a': {'id': 3}, 'm': {'id': 3}, 'e': {'id': 3}}
b3 = info.fromkeys('1',2)        #{'1': 2}

数据类型与布尔值的关系
在这里插入图片描述
集合的常用方法
集合set是一个无序的不重复元素序列，常用来对两个列表进行交并差的处理性，集合与列表一样，支持所有数据类型.
集合无法通过索引获取元素，也无获取任何元素的方法，集合只是用来处理列表或元组的一种临时类型，不适合存储与传输
在这里插入图片描述
通过set函数来创建集合，但是不能使用{}来创建空集合，因为会被认为是dict类型

a_set = set()
print(type(a_set))  #<class 'set'>
b_set = set({'name': 'shaishai','age': 18,'sex':'man'})
print(type(b_set),b_set)    #<class 'set'>   {'sex', 'age', 'name'}
c_set = set([1, 2, 3, 4, 5, 7, 8, 9])
print(type(c_set),c_set)    #<class 'set'>   {'sex', 'age', 'name'}
d_set = {(1,2.3),'d',True}
print(d_set)    #{True, (1, 2.3), 'd'}

add函数
用于集合中添加一个元素，如集合中已存在此元素，则不执行
用法：set.add(item)

a_set = set()
a_set.add('shaishai')
a_set.add(True)
a_set.add(None)
print(a_set)    #{'shaishai', True, None}

update函数
加入一个新的集合（或列表，元组，字符串），如新集合内的元素在原集合中存在则无视
用法：set.update(iterable)

a_set = set()
a_set.update(['a','b',1])
a_set.update('yanmai')
a_set.update({'id':1})
print(a_set)    #{1, 'id', 'm', 'n', 'a', 'y', 'i', 'b'}

remove函数
将集合中的某个元素删除，如元素不存在将会报错
用法：set.remove(item)

a_set = {1, 'id', 'm', 'n', 'a', 'y', 'i', 'b'}
a_set.remove('id')
print(a_set)    #{'a', 1, 'm', 'i', 'b', 'n', 'y'}

clear函数
清除集合的全部元素
用法：set.clear()

a_set = {1, 'id', 'm', 'n', 'a', 'y', 'i', 'b'}
a_set.clear()
print(a_set)    #set()

del函数
删除集合
用法：del set

a_set = {1, 'id', 'm', 'n', 'a', 'y', 'i', 'b'}
del a_set
print(a_set)    #NameError: name 'a_set' is not defined

difference函数
返回集合的差集
用法：a_set.difference(b_set)

a_set = {'shaishai','xixi','yanmai'}
b_set = {'huahua','yanmai'}
print(a_set.difference(b_set))  #{'shaishai', 'xixi'}

intersection函数
返回两个或更多集合中都包含的元素，即交集
用法：a_set.difference(b_set,c_set…) #多个集合用,隔开

a_set = {'shaishai','xixi','yanmai'}
b_set = {'huahua','yanmai'}
c_set = {'yanmai','laosiji','xixi'}
print(a_set.intersection(b_set))  # {'yanmai'}
print(a_set.intersection(b_set,c_set))  # {'yanmai'}

union函数
返回两个或更多集合中除都包含外的元素，即并集
用法：a_set.union(b_set,c_set…) #多个集合用,隔开

a_set = {'shaishai','xixi','yanmai'}
b_set = {'huahua','yanmai'}
c_set = {'yanmai','laosiji','xixi'}
print(a_set.union(b_set))   #{'huahua', 'yanmai', 'shaishai', 'xixi'}
print(a_set.union(b_set,c_set)) #{'huahua', 'yanmai', 'shaishai', 'xixi', 'laosiji'}

isdisjoint函数
判断两个集合是否包含相同的元素，如果没有返回True，否则返回False
用法：a_set.isdisjoint(b_set)

a_set = {'shaishai','xixi','yanmai'}
b_set = {'huahua','yanmai'}
c_set = {'baozi','laosiji'}
result = a_set.isdisjoint(b_set)
print(result)   #False
result = a_set.isdisjoint(c_set)
print(result)   #True