python基础--列表、元组、字典和集合

列表、元组、字典和集合

在 Python 编程中,我们既需要独立的变量来保存一份数据,也需要序列来保存大量数据。

列表(list)和元组(tuple)比较相似,它们都按顺序保存元素,所有的元素占用一块连续的内存,每个元素都有自己的索引,因此列表和元组的元素都可以通过索引(index)来访问。

它们的区别在于:列表是可以修改的,而元组是不可修改的。

字典(dict)和集合(set)存储的数据都是无序的,每份元素占用不同的内存,其中字典元素以 key-value 的形式保存。

1、序列:

序列,指的是一块可存放多个值的连续内存空间,这些值按一定顺序排列,可通过每个值所在位置的编号(称为索引)访问它们。

序列类型包括字符串、列表、元组、集合和字典,这些序列支持以下几种通用的操作,但比较特殊的是,集合和字典不支持索引、切片、相加和相乘操作。

序列切片:

切片操作是访问序列中元素的另一种方法,它可以访问一定范围内的元素,通过切片操作,可以生成一个新的序列。

语法格式:

strname[start : end : step]
  • strname:表示序列的名称;
  • start:表示切片的开始索引位置(包括该位置),此参数也可以不指定,会默认为 0,也就是从序列的开头进行切片;
  • end:表示切片的结束索引位置(不包括该位置),如果不指定,则默认为序列的长度;
  • step:表示在切片过程中,隔几个存储位置(包含当前位置)取一次元素,也就是说,如果 step 的值大于 1,则在进行切片去序列元素时,会“跳跃式”的取元素。
str = "中国惊奇先生,狐妖小红娘"
print(str[:2])   # 中国
print(str[1:7])   # 国惊奇先生,
print(str[3:])    # 奇先生,狐妖小红娘
print(str[::2])   # 中惊先,妖红
print(str[:])   # 中国惊奇先生,狐妖小红娘
序列相加:

Python 中,支持两种类型相同的序列使用“+”运算符做相加操作,它会将两个序列进行连接,但不会去除重复的元素。

str02 = "神墓"
print("画江湖之不良人," + "万妖谱," + str02)   # 画江湖之不良人,万妖谱,神墓
序列相乘:

Python 中,使用数字 n 乘以一个序列会生成新的序列,其内容为原来序列被重复 n 次的结果。

str03 = "hello"
print(str03 * 5)   # hellohellohellohellohello
检查元素是否包含在序列中:

Python 中,可以使用 in 关键字检查某元素是否为序列的成员。

str04 = 'h'
print(str04 in "hello world!")   # true

not in 关键字,它用来检查某个元素是否不包含在指定的序列中。

和序列相关的内置函数:
函数 功能
len() 计算序列的长度,即返回序列中包含多少个元素。
max() 找出序列中的最大元素。注意,对序列使用 sum() 函数时,做加和操作的必须都是数字,不能是字符或字符串,否则该函数将抛出异常,因为解释器无法判定是要做连接操作(+ 运算符可以连接两个序列),还是做加和操作。
min() 找出序列中的最小元素。
list() 将序列转换为列表。
str() 将序列转换为字符串。
sum() 计算元素和。
sorted() 对元素进行排序。
reversed() 反向序列中的元素。
enumerate() 将序列组合为一个索引序列,多用在 for 循环中。
str05 = "hello,world"
print(max(str05))   # w
print(min(str05))   # ,
print(sorted(str05))   # [',', 'd', 'e', 'h', 'l', 'l', 'l', 'o', 'o', 'r', 'w']

2、列表操作:

1、什么是列表?

  • 需求:经常需要将一组(不只一个)数据存储起来,以便后边的代码使用。

  • 数组(Array),它就可以把多个数据挨个存储到一起,通过数组下标可以访问数组中的每个元素。

  • Python 中没有数组,但是加入了更加强大的列表。如果把数组看做是一个集装箱,那么 Python 的列表就是一个工厂的仓库。

**列表 **会将所有元素都放在一对中括号[ ]里面,相邻元素之间用逗号,分隔。

lst = [1,2,3,4,5]

**列表 **中的元素,个数没有限制,只要是 Python 支持的数据类型就可以。

列表 可以存储整数小数字符串列表元组等任何类型的数据,并且同一个列表中元素的类型也可以不同。

["xiaoche", 1, [2,3,4] , 3.0, (5,6,7)]

注意:一般列表中只放入同一类型的数据,这样可以提高程序的可读性。

2、创建列表:

  • 使用 [ ] 直接创建:
listname = [element1 , element2 , element3 , ... , elementn]
# 例如:
num = [1, 2, 3, 4, 5, 6, 7]
name = ["Jack", "tom"]
program = ["php", "Python", "Java"]

# 也可以是个空列表:
lst = []
  • 使用list()函数创建:
# 将字符串转换成列表
list1 = list("hello")
print(list1)

# 将元组转换成列表
tuple1 = ('Python', 'Java', 'C++', 'JavaScript')
list2 = list(tuple1)
print(list2)

# 将字典转换成列表
dict1 = {'a':100, 'b':42, 'c':9}
list3 = list(dict1)
print(list3)

# 将区间转换成列表
range1 = range(1, 6)
list4 = list(range1)
print(list4)

# 创建空列表
print(list())

3、访问列表元素

  • 使用索引(Index)访问列表中的某个元素(得到的是一个元素的值)。
  • 使用切片访问列表中的一组元素(得到的是一个新的子列表)。
lst = [10,20,30,40,45]
print(lst)     # [10, 20, 30, 40, 45]
print(lst[3])   # 40
print(lst[2:])    # [30, 40, 45]

4、删除列表:

对于已经创建的列表,如果不再使用,可以使用del关键字将其删除。

  • 但是在实际开发中,并不经常用del来删除列表。

  • Python 自带的垃圾回收机制会自动销毁无用的列表,即使开发者不手动删除,Python 也会自动将其回收。

del lst    # 删除列表
print(lst)

删除列表之后,在打印列表会报错,如下图:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1fv4yekq-1678548787538)(assets/image-20230301222645223.png)]

5、列表添加元素:

实际开发中,经常需要对 Python 列表进行更新,包括向列表中添加元素、修改表中元素以及删除元素。

1)使用+运算符可以将多个序列连接起来;
name_list = ["jack","tom","andy","lihua"]
age_list = [21,19,32,43]
print(name_list + age_list)   # ['jack', 'tom', 'andy', 'lihua', 21, 19, 32, 43]

从上面,我们不难看出,使用+会生成一个新的列表,原有的列表不会被改变。

2)append()方法添加元素

append() 方法用于在列表的末尾追加元素。

lst = ['java','python','linux']
lst.append("php")
print(lst)   # ['java', 'python', 'linux', 'php']

lst.append((1,2,3))
print(lst)  # ['java', 'python', 'linux', 'php', (1, 2, 3)]

lst.append(["apple","banana"])
print(lst)  # ['java', 'python', 'linux', 'php', (1, 2, 3), ['apple', 'banana']]

从上面可以看出,当给 append() 方法传递列表或者元组时,此方法会将它们视为一个整体,作为一个元素添加到列表中,从而形成包含列表和元组的新列表。

3)extend()方法添加元素

extend()append() 的不同之处在于:extend() 不会把列表或者元祖视为一个整体,而是把它们包含的元素逐个添加到列表中。

item = ['java','python','linux']
item.extend('C')
print(item)  # ['java', 'python', 'linux', 'C']

t = (1,2,3)
item.extend(t)
print(item)   # ['java', 'python', 'linux', 'C', 1, 2, 3]

item.extend(['Vue','html'])
print(item)   # ['java', 'python', 'linux', 'C', 1, 2, 3, 'Vue', 'html']
4)insert()方法插入元素

append()extend() 方法只能在列表末尾插入元素,如果希望在列表中间某个位置插入元素,那么可以使用 insert() 方法

当插入列表或者元祖时,insert() 也会将它们视为一个整体,作为一个元素插入到列表中,这一点和 append() 是一样的。

lst = ['Python', 'C++', 'Java']
lst.insert(1, 'linux')
print(lst)  # ['Python', 'linux', 'C++', 'Java']

t = (1,2)
lst.insert(2,t)
print(lst)   # ['Python', 'linux', (1, 2), 'C++', 'Java']

lst.insert(1,['js','html'])
print(lst)   # ['Python', ['js', 'html'], 'linux', (1, 2), 'C++', 'Java']

lst.insert(0,"hello")
print(lst)   # ['hello', 'Python', ['js', 'html'], 'linux', (1, 2), 'C++', 'Java']

注意:insert() 主要用来在列表的中间位置插入元素,如果你仅仅希望在列表的末尾追加元素,那我更建议使用 append() 和 extend()。

6、列表删除元素:

Python 列表中删除元素主要分为以下 3 种场景:

  • 根据目标元素所在位置的索引进行删除,可以使用 del 关键字或者 pop() 方法
  • 根据元素本身的进行删除,可使用列表(list类型)提供的 remove() 方法
  • 将列表中所有元素全部删除,可使用列表(list类型)提供的 clear() 方法
1)del:根据索引值删除元素

del 不仅可以删除整个列表,还可以删除列表中的某些元素。

  • del 可以删除单个元素,也可以删除一段连续的元素。
lst = ['java','python','php','html','linux','C++','Vue']
del lst[3]
print(lst)   # ['java', 'python', 'php', 'linux', 'C++', 'Vue']

del lst[-1]
print(lst)  # ['java', 'python', 'php', 'linux', 'C++']

lst02 = ['java','python','php','html','linux','C++','Vue']
del lst02[2:5]
print(lst02)  # ['java', 'python', 'C++', 'Vue']

lst03 = ['java','python','php','html','linux','C++','Vue']
del lst03[-4:-1]
print(lst03)   # ['java', 'python', 'php', 'Vue']

注意:使用切片删除时左闭右开的。

2) pop():根据索引值删除元素

pop() 方法用来删除列表中指定索引处的元素:listname.pop(index)

  • 如果不写 index 参数,默认会删除列表中的最后一个元素,类似于数据结构中的“出栈”操作。
lst04 = ['apple','banana', 'watermelon', 'orange']
lst04.pop(2)
print(lst04)  # ['apple', 'banana', 'orange']

lst04.pop()
print(lst04)   # ['apple', 'banana']
3)remove():根据元素值进行删除

remove() 方法,会根据元素本身的值来进行删除操作。

  • remove() 方法只会删除第一个和指定值相同的元素,而且必须保证该元素是存在的,否则会引发 ValueError 错误
num = [23,67,98,342,21,43,23]
num.remove(67)
print(num)  # [23, 98, 342, 21, 43, 23]

num.remove(23)
print(num)  # [98, 342, 21, 43, 23]

num.remove(23)
print(num)   # [98, 342, 21, 43]

num.remove(12)
print(num)  # ValueError: list.remove(x): x not in list
4) clear():删除列表所有元素

clear() 用来删除列表的所有元素,也即清空列表。

num = [23,67,98,342,43]
num.clear()
print(num)

7、列表修改元素:

1) 修改单个元素

修改单个元素非常简单,直接对元素赋值即可。

num = [23,54,76,98,12]
num[2] = 100
print(num)   # [23, 54, 100, 98, 12]

num[-1] = -190
print(num)   # [23, 54, 100, 98, -190]
2) 修改一组元素

Python 支持通过切片语法给一组元素赋值。

num = [40,23,54,76,33]
num[1:3] = [1,2,3,4]
print(num)   # [40, 1, 2, 3, 4, 76, 33]

num = [1,2,3,4,5,6]
num[1:4] = [10,20]
print(num)   # [1, 10, 20, 5, 6]
  • 如果不指定步长(step 参数),Python 就不要求新赋值的元素个数与原来的元素个数相同;
  • 这意味,该操作既可以为列表添加元素,也可以为列表删除元素。
  • 如果对空切片(slice)赋值,就相当于插入一组新的元素。
num = [10,20,30,40,50]
num[3:3] = [100,200,300]
print(num)  # [10, 20, 30, 100, 200, 300, 40, 50]

注意:使用切片语法赋值时,Python 不支持单个值。

使用切片语法时也可以指定步长(step 参数),但这个时候就要求所赋值的新元素的个数与原有元素的个数相同

8、列表查找元素:

Python 列表(list)提供了 index()count() 方法,它们都可以用来查找元素

1)index() 方法用来查找某个元素在列表中出现的位置(也就是索引)。
  • 如果该元素不存在,则会导致 ValueError 错误,所以在查找之前最好使用 count() 方法判断一下。

语法格式: listname.index(obj, start, end)

num = [12,54,21,65,342,21]
#检索列表中的所有元素
print(num.index(21))  # 2
#检索1~5之间的元素
print(num.index(65,1,5))  # 3
#检索2之后的元素
print(num.index(342,2))  # 4
#检索一个不存在的元素
print(num.index(100))  # ValueError: 100 is not in list
2) count() 方法用来统计某个元素在列表中出现的次数
  • 如果 count() 返回 0,就表示列表中不存在该元素,所以 count() 也可以用来判断列表中的某个元素是否存在。
num = [1,2,3,4,5,2,2,3,4]
print("2在列表中共出现了%d次" %num.count(2))  # 2在列表中共出现了3次
if num.count(100):
    print("列表中有100")
else:
    print("列表中没有100")

3、元组操作:

元组(tuple)是 Python 中另一个重要的序列结构,和列表类似,元组也是由一系列按特定顺序排序的元素组成。

元组和列表(list)的不同之处在于:

  • 列表的元素是可以更改的,包括修改元素值,删除和插入元素,所以列表是可变序列;
  • 而元组一旦被创建,它的元素就不可更改了,所以元组是不可变序列。
  • 元组的所有元素都放在一对小括号( )中,相邻元素之间用逗号,分隔。
  • 元组可以存储整数、实数、字符串、列表、元组等任何类型的数据,并且在同一个元组中,元素的类型可以不同。但是不推荐这样。
  • 元组是 tuple 类型。

1)创建元组:

通过( )创建元组后,一般使用=将它赋值给某个变量。

t = (1,2,2,3)
print(type(t),t)

当元组中只有一个字符串类型的元素时,该元素后面必须要加一个逗号,,否则 Python 解释器会将它视为字符串。

t2 = ('hello')
print(type(t2))  # 

t3 = ('hello', )
print(type(t3))  # 

使用tuple()函数创建元组:

#将字符串转换成元组
tup1 = tuple("hello")
print(tup1)

#将列表转换成元组
list1 = ['Python', 'Java', 'C++', 'JavaScript']
tup2 = tuple(list1)
print(tup2)

#将字典转换成元组
dict1 = {'a':100, 'b':42, 'c':9}
tup3 = tuple(dict1)
print(tup3)   # ('a', 'b', 'c')

#将区间转换成元组
range1 = range(1, 6)
tup4 = tuple(range1)
print(tup4)

#创建空元组
print(tuple())

2) 访问元组元素

  • 使用索引访问单个元素。
  • 使用切片访问一组元素。
url = tuple("www.baidu.com")
print(url)   # ('w', 'w', 'w', '.', 'b', 'a', 'i', 'd', 'u', '.', 'c', 'o', 'm')
print(url[4])  # b
print(url[-2])  # o

print(url[1:5])  # ('w', 'w', '.', 'b')
print(url[-6:-1])  # ('d', 'u', '.', 'c', 'o')

3)修改元组

元组是不可变序列,元组中的元素不能被修改,所以我们只能创建一个新的元组替代旧的元组

  • 对元组变量进行重新赋值。
t5 = (1,2,3,5)
print(t5)  #(1, 2, 3, 5)
t5 = ('java', 'python', 'linux')
print(t5)  # ('java', 'python', 'linux')
  • 通过连接多个元组(使用+可以拼接元组)的方式向元组中添加新元素。
t6 = (10,20,30)
t7 = ('jack', 'tom', 'andy')
print(t6 + t7)  # (10, 20, 30, 'jack', 'tom', 'andy')

4) 删除元组

当创建的元组不再使用时,可以通过 del 关键字将其删除。

t8 = ('java', 'python', 'linux', 'C++')
print(t8)  # ('java', 'python', 'linux', 'C++')
del t8
print(t8)  # NameError: name 't8' is not defined. Did you mean: 't'?

Python 自带垃圾回收功能,会自动销毁不用的元组,所以一般不需要通过 del 来手动删除。

4、有序无序、可变与不可变

有序无序:是指可以使用下标索引的方式获取到值数据类型;只要是能够调用用_ iter _()方法获取值的数据类型都是可迭代对象;

  • 有序数据类型:字符串、列表、元组。
  • 无序数据类型:字典、集合。

可变与不可变:指是否能够对序列进行增、删、改操作;并且,增删改操作后的对象地址不发生改变

  • 不可变数据类型:整形,浮点型,字符串,复数,布尔,元组,固定集合。
  • 可变数据类型:列表,字典,集合。

5、字典操作:

python 字典(dict)是一种无序的、可变的序列,它的元素以“键值对(key-value)”的形式存储。

字典类型是 Python 中唯一的映射类型。

  • 它指的是元素之间相互对应的关系,即通过一个元素,可以唯一找到另一个元素。

python基础--列表、元组、字典和集合_第1张图片

主要特征 解释
通过键而不是通过索引来读取元素 字典类型有时也称为关联数组或者散列表(hash)。它是通过键将一系列的值联系起来的,这样就可以通过键从字典中获取指定项,但不能通过索引来获取。
字典是任意数据类型的无序集合 和列表、元组不同,通常会将索引值 0 对应的元素称为第一个元素,而字典中的元素是无序的。
字典是可变的,并且可以任意嵌套 字典可以在原处增长或者缩短(无需生成一个副本),并且它支持任意深度的嵌套,即字典存储的值也可以是列表或其它的字典。
字典中的键必须唯一 字典中,不支持同一个键出现多次,否则只会保留最后一个键值对。
字典中的键必须不可变 字典中每个键值对的键是不可变的,只能使用数字、字符串或者元组,不能使用列表。
dit = {'id':1, 'name':'xiaoche', 'email':'[email protected]'}
print(dit,type(dit))

1) 创建字典:

使用 { } 创建字典:
  • 键和值之间使用冒号:分隔。
  • 相邻元素之间使用逗号,分隔。
  • 同一字典中的各个键必须唯一,不能重复。
scores = {
    '语文': 98,
    '数学': 81,
    '英语': 87,
    '体育': 21,
}
print(scores)  # {'语文': 98, '数学': 81, '英语': 87, '体育': 21}
#使用元组和数字作为key
dict1 = {(20, 30): 'great', 30: [1,2,3]}
print(dict1)

#创建空元组
dict2 = {}
print(dict2)

从上面可以看出:字典的键可以是整数、字符串或者元组,只要符合唯一和不可变的特性就行;字典的值可以是 Python 支持的任意数据类型。

通过 fromkeys() 方法创建字典:
lst = ['语文', '数学', '英语']
scores = dict.fromkeys(lst,80)  # 默认值为80,若不写,则为none
print(scores)
通过 dict() 映射函数创建字典
a = dict(name = '张三', passwd = 1234)
print(a)  # {'name': '张三', 'passwd': 1234}
通过应用 dict() 函数和 zip() 函数,可将前两个列表转换为对应的字典。
t1 = ('英语', '数学', '语文')  # #还可以是字符串或列表
l1 = [90,87,45]   #还可以是字符串或元组
a = dict(zip(t1,l1))
print(a)

2) 访问字典元素

通过键来访问对应的值。
  • 元素无序,位置不固定,不能使用切片一次性访问多个元素。
d2 = {
    'id': 1,
    'name': 'xiaoch',
    'age': 21,
    'address': '杭州',
}
print(d2)  # {'id': 1, 'name': 'xiaoch', 'age': 21, 'address': '杭州'}
print(d2['name'])  # xiaoch
print(d2['id'])   # 1
print(d2['eamil'])  # KeyError: 'eamil'

注意,键必须是存在的,否则会抛出异常。

get() 方法来获取指定键对应的值
  • 当指定的键不存在时,get() 方法不会抛出异常。
d2 = {
    'id': 1,
    'name': 'xiaoch',
    'age': 21,
    'address': '杭州',
}
print(d2.get('email'))  # none
print(d2.get('address'))  # 杭州

当键不存在时,get() 返回空值 None,如果想明确地提示用户该键不存在,那么可以手动设置 get() 的第二个参数。

print(d2.get('email', '[email protected]'))  # [email protected]

3) 删除字典:

和删除列表、元组一样,手动删除字典也可以使用 del 关键字。

del d2
print(d2)  # NameError: name 'd2' is not defined

Python 自带垃圾回收功能,会自动销毁不用的字典,所以一般不需要通过 del 来手动删除。

4) 字典添加键值对:

  • 直接给不存在的 key 赋值即可。
dit = {
    '语文': 91,
    '数学': 87,
    '英语': 76,
}
print(dit)  # {'语文': 91, '数学': 87, '英语': 76}

dit['体育'] = 32
print(dit)  # {'语文': 91, '数学': 87, '英语': 76, '体育': 32}

dit['java'] = 96
print(dit)  # {'语文': 91, '数学': 87, '英语': 76, '体育': 32, 'java': 96}

5) 字典修改键值对:

Python 字典中键(key)的名字不能被修改,我们只能修改值(value)

  • 将原先的值修改。
dit['语文'] = 79
print(dit)  # {'语文': 79, '数学': 87, '英语': 76, '体育': 32, 'java': 96}

6) 字典删除键值对:

del dit['英语']
del dit['体育']
print(dit)   # {'语文': 79, '数学': 87, 'java': 96}

7) 字典是否存在键值对:

  • 一般是判断字典是否包含指定的键。
  • 用in 或者 not in 运算符。
print('数学' in dit)  # True
print('python' in dit)  # False

8) 字典中的方法:

使用 dir(dict) 来查看该类型包含哪些方法。

print(dir(dict))
['clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
① keys、values、items方法
  • keys() 方法用于返回字典中的所有键(key);
  • values() 方法用于返回字典中所有键对应的值(value);
  • items() 用于返回字典中所有的键值对(key-value)。
d2 = {'语文': 87, '数学': 98, '英语': 76}
print(d2.keys())  # dict_keys(['语文', '数学', '英语'])
print(d2.values())  # dict_values([87, 98, 76])
print(d2.items())   # dict_items([('语文', 87), ('数学', 98), ('英语', 76)])

若想操作这几个方法的返回值:

  • 使用 list() 函数,将它们返回的数据转换成列表。
  • 使用 for in 循环遍历它们的返回值。
l2 = list(d2.keys())
print(l2)   # ['语文', '数学', '英语']

for i in d2.keys():
    print(i)
语文
数学
英语
② copy()方法:

copy() 方法返回一个字典的拷贝,也即返回一个具有相同键值对的新字典

d3 = {'one': 1, 'two': 2, 'three': 3}
d4 = d3.copy()
print(id(d3), d3)  # 1493226277248 {'one': 1, 'two': 2, 'three': 3}
print(id(d4), d4)  # 1493226287168 {'one': 1, 'two': 2, 'three': 3}

注意,copy() 方法所遵循的拷贝原理,既有深拷贝,也有浅拷贝。

  • 上面的例子是深拷贝,对键值对进行了拷贝,从新开了个新内存来存放。

  • 对于某些列表类型的值来说,此方法对其做的是浅拷贝,也就是说,d4 中的 [1,2,3] 的值不是自己独有,而是和 d3 共有。

d3 = {'one': 1, 'two': 2, 'three': [1,2,3]}
d4 = d3.copy()
print("列表id", id(d3['three']), "字典d3的id", id(d3))  # 列表id 2557259429568 字典d3的id 2557256518016
print("列表id", id(d4['three']), "字典d4的id", id(d4))  # 列表id 2557259429568 字典d4的id 2557256527936

d3['four'] = 4
print(d3)  # {'one': 1, 'two': 2, 'three': [1, 2, 3], 'four': 4}
print(d4)   # {'one': 1, 'two': 2, 'three': [1, 2, 3]}

d3['three'].remove(1)
print(d3)   # {'one': 1, 'two': 2, 'three': [2, 3], 'four': 4}
print(d4)   # {'one': 1, 'two': 2, 'three': [2, 3]}

python基础--列表、元组、字典和集合_第2张图片

③ update() 方法

update() 方法可以使用一个字典所包含的键值对来更新己有的字典。

  • 如果被更新的字典中己包含对应的键值对,那么原 value 会被覆盖;
  • 如果被更新的字典中不包含对应的键值对,则该键值对被添加进去。
d5 = {'one': 1, 'two': 2, 'three': 3}
d5.update({'one': 10, 'four': 20})
print(d5)  # {'one': 10, 'two': 2, 'three': 3, 'four': 20}
④ pop() 和 popitem() 方法
  • pop() 和 popitem() 都用来删除字典中的键值对。
  • pop() 用来删除指定的键值对。
  • popitem() 用来随机删除一个键值对。
d6 = {'数学': 95, '语文': 89, '英语': 90, '化学': 83, '生物': 98, '物理': 89}
d6.pop('英语')
print(d6)  # {'数学': 95, '语文': 89, '化学': 83, '生物': 98, '物理': 89}
d6.popitem()
print(d6)   # {'数学': 95, '语文': 89, '化学': 83, '生物': 98}

注意:说 popitem() 随机删除字典中的一个键值对是不准确的,虽然字典是一种无须的列表,但键值对在底层也是有存储顺序的,popitem() 总是弹出底层中的最后一个 key-value,这和列表的 pop() 方法类似,都实现了数据结构中“出栈”的操作。

⑤ setdefault() 方法:

setdefault() 方法用来返回某个 key 对应的 value。

  • 如果该 key 存在,那么直接返回该 key 对应的 value;
  • 如果该 key 不存在,那么先为该 key 设置默认的 defaultvalue,然后再返回该 key 对应的 defaultvalue。
  • 如果没设置默认的 defaultvalue,则是none。
d7 = {'数学': 95, '语文': 89, '英语': 90}
d7.setdefault('物理', 17)
print(d7)  # {'数学': 95, '语文': 89, '英语': 90, '物理': 17}
d7.setdefault('化学')
print(d7)   # {'数学': 95, '语文': 89, '英语': 90, '物理': 17, '化学': None}
d7.setdefault('数学', 100)
print(d7)   # {'数学': 95, '语文': 89, '英语': 90, '物理': 17, '化学': None}

6、集合操作

  1. 集合中的元素都是唯一的,互不相同。

  2. Python 集合会将所有元素放在一对大括号 {} 中,相邻元素之间用“,”分隔。

  3. 只能存储不可变的数据类型,包括整形、浮点型、字符串、元组

Python 中有两种集合类型,一种是 set 类型的集合,另一种是 frozenset 类型的集合,它们唯一的区别是,set 类型集合可以做添加、删除元素的操作,而 forzenset 类型集合不行。

1)创建set集合:

  • 使用 {} 创建。
s1 = {1,'c',1,(1,2,3),'c'}
print(s1)
  • 使用 set() 函数将字符串、列表、元组、range 对象等可迭代对象转换成集合。。
str = "hello,world"
s2 = set(str)
print(s2)   # {'d', 'r', 'o', 'l', 'h', 'e', ',', 'w'}

lst = ['python', 'java', 'linux']
s3 = set(lst)
print(s3)  # {'linux', 'python', 'java'}

t = ('英语', '数学', '语文')
s4 = set(t)
print(s4)   # {'语文', '英语', '数学'}

2) 问set集合元素:

使用循环结构,将集合中的数据逐一读取出来。

s02 = {'java', 'python', 'linux', 'C++'}
for i in s02:
    print(i,end=' ')   # python java C++ linux 

3)删除set集合:

使用 del() 语句。python会自动释放不使用的set集合。

4)set集合添加元素:

使用add() 方法。

  • 使用 add() 方法添加的元素,只能是数字、字符串、元组或者布尔类型(True 和 False)值。也就是不可变的数据。
  • 不能添加列表,字典,集合这种可变数据。
s02.add('Vue')
print(s02)   # {'java', 'linux', 'Vue', 'C++', 'python'}

5) 集合删除元素:

使用 remove() 方法。

  • 如果被删除元素本就不包含在集合中,则此方法会抛出 KeyError 错误。
  • discard() 方法与remove() 用法一样,但是此方法不会抛出异常。
s02.remove('C++')
print(s02)   # {'linux', 'java', 'python', 'Vue'}

6) 集合做交集、并集、差集运算:

运算操作 Python运算符 含义 例子
交集 & 取两集合公共的元素 >>> set1 & set2 {3}
并集 | 取两集合全部的元素 >>> set1 | set2 {1,2,3,4,5}
差集 - 取一个集合中另一集合没有的元素 >>> set1 - set2 {1,2} >>> set2 - set1 {4,5}
对称差集 ^ 取集合 A 和 B 中不属于 A&B 的元素 >>> set1 ^ set2 {1,2,4,5}

7) 集合的方法:

dir(set)  # 查看集合的方法
  • add() 方法,像集合中添加元素,上面已例举。
  • clear() 方法。清空集合中的所有元素。
s02.clear()
print(s02)  # set()
  • copy() 方法,拷贝集合元素。
s03 = {10,20,30}
s04 = s03.copy()
print(id(s03), s03)  # 2790463051744 {10, 20, 30}
print(id(s04), s04)  # 2790463050176 {10, 20, 30}
  • difference() 方法。将 set1 中有而 set2 没有的元素给 set3。
s05 = {10,20,30}
s06 = {10,100,1000}
s07 = s05.difference(s06)
print(s07)  # {20, 30}
  • difference_update() 方法。从 set1 中删除与 set2 相同的元素。
s05.difference_update(s06)
print(s05)  # {20, 30}
  • discard() 方法。与remove() 方法用法一样,但是此方法不会抛异常。

  • intersection()。取 set1 和 set2 的交集给 set3。

s08 = {10,20,30}
s09 = {30,40,50}
s10 = s08.intersection(s09)
print(s10)  # {30}
  • intersection_update()。 取 set1和 set2 的交集,并更新给 set1。
s08.intersection_update(s09)
print(s08)  # {30}
  • isdisjoint()。判断 set1 和 set2 是否有交集,有交集返回 False;没有交集返回 True。
print(s08.isdisjoint(s09))  # False
  • issubset()。判断 set2 是否是 set1 的子集。
print(s08.issubset(s09))  # True
  • pop()。取 set1 中一个元素,并赋值给 a。
a = s09.pop()
print(a)  # 40
  • symmetric_difference()。取 set1 和 set2 中互不相同的元素,给 set3。
s = {10,20,30}
s02 = {10,100,1000}
s03 = s.symmetric_difference(s02)
print(s03)  # {100, 1000, 20, 30}
  • symmetric_difference_update()。取 set1 和 set2 中互不相同的元素,并更新给 set1。

  • union()。取 set1 和 set2 的并集,赋给 set3。

s03 = s.union(s02)
print(s03)  # {20, 100, 1000, 10, 30}
  • update()。添加列表或集合中的元素到 set1。
ss = {1,2,3}
lst = ['jack', 'tom']
ss.update(lst)
print(ss)  # {1, 2, 3, 'tom', 'jack'}

tt = ('python', 'java')
ss.update(tt)
print(ss)  # {1, 2, 3, 'java', 'jack', 'tom', 'python'}

7、zip函数:

zip() 函数是 Python内置函数之一,它可以将多个序列(列表、元组、字典、集合、字符串以及 range() 区间构成的列表)“压缩”成一个 zip 对象。所谓“压缩”,其实就是将这些序列中对应位置的元素重新组合,生成一个个新的元组。

my_list = [11,12,13]
my_tuple = (21,22,23)
print([x for x in zip(my_list,my_tuple)])  # [(11, 21), (12, 22), (13, 23)]

my_dic = {31:2,32:4,33:5}
my_set = {41,42,43,44}
print([x for x in zip(my_dic)])  # [(31,), (32,), (33,)]

my_pychar = "python"
my_shechar = "shell"
print([x for x in zip(my_pychar,my_shechar)])  # [('p', 's'), ('y', 'h'), ('t', 'e'), ('h', 'l'), ('o', 'l')]

lst = [11,12,13]
t = (21,22,23)
print({x for x in zip(lst,t)})  # {(12, 22), (11, 21), (13, 23)}

d = {'id': 1, 'name': 'tom', 'age': 21}
s = {'linux', 'python', 'java'}
print({x for x in zip(d,s)})   # {('name', 'linux'), ('age', 'java'), ('id', 'python')}

当多个序列中元素个数不一致时,会以最短的序列为准进行压缩。

lst = [11,12,13]
t = (21,22,23,24,25)
print({x for x in zip(lst,t)})  # {(12, 22), (11, 21), (13, 23)}

8、reversed 函数

reversed 函数:对于给定的序列(包括列表、元组、字符串以及 range(n) 区间),该函数可以返回一个逆序序列的迭代器(用于遍历该逆序序列)。

lst = [1,2,3,4,5]
print([x for x in reversed(lst)])  # [5, 4, 3, 2, 1]

str = 'hello'
print([x for x in reversed(str)])  # ['o', 'l', 'l', 'e', 'h']

你可能感兴趣的:(Python,python,开发语言)