Python基础知识七 元组&字典&集合

文章目录

  • 一、元组
    • 1、元组的概念
    • 2、元组的解包
  • 二、字典
    • 1、字典的概念
    • 2、语法
    • 3、字典的使用
      • 3.1 创建字典
      • 3.2 len()
      • 3.3 in、not in
      • 3.4 获取字典中的值
        • 3.4.1 根据键获取字典中的值
        • 3.4.2 用get方法获取字典中的值
      • 3.5 修改字典
        • 3.5.1 d[key] = value
        • 3.5.2 setdefault(key,[default])
        • 3.5.3 update( )
      • 3.6 删除
        • 3.6.1 del
        • 3.6.2 popitem( )
        • 3.6.3 pop(key,[default])
        • 3.6.4 clear( )
      • 3.7 copy( )
    • 4、遍历字典
      • 4.1 keys( )
      • 4.2 values( )
      • 4.3 items( )
  • 三、集合
    • 1、集合的概念
    • 2、集合的使用
      • 2.1 in 和 not in
      • 2.2 len( )
      • 2.3 add( )
      • 2.4 update( )
      • 2.5 pop( )
      • 2.6 remove( )
      • 2.7 clear( )
    • 3、集合的运算
      • 3.1 交集运算 &
      • 3.2 并集运算 |
      • 3.3 差集运算 -
      • 3.4 异或集运算 ^
      • 3.5 比较运算
  • 四、可变对象

一、元组

1、元组的概念

  • 元组 tuple,是一个不可变序列
  • 一般情况下如果不希望数据改变的时候就用元组,其余情况都用列表
my_tuple = (1,2,3,4,5)
print(my_tuple,type(my_tuple))    # (1, 2, 3, 4, 5) 
my_tuple[3] = 8    # TypeError: 'tuple' object does not support item assignment
  • 当元组中只有一个元素时,元素后面应该要加一个逗号,这样才能成为元组。
a_tuple = (1)
print(a_tuple,type(a_tuple))    # 1 

a_tuple = (1,)
print(a_tuple,type(a_tuple))    # (1,) 

2、元组的解包

  • 元组的解包指将元组当中的每一个元素都赋值给一个变量。
  • 在对一个元祖解包的时候,变量的数量要和元组中元素的数量保持一致。
  • 如果变量的数量和元素的数量不一致,也可以在变量前面加上一个 星号*。这样会获取元组中剩余的元素,并以列表的形式返回。
  • 任何可迭代对象都支持解包,可迭代对象包括元组、列表、字典、集合、字符串、生成器等。
my_tuple = 1,2,3,4,5
print(my_tuple, type(my_tuple))    # (1, 2, 3, 4, 5) 

a,b,*c = my_tuple
print('a =',a)    # a = 1
print('b =',b)    # b = 2
print('c =',c)    # c = [3, 4, 5]

a,*b,c = my_tuple
print('a =',a)    # a = 1
print('b =',b)    # b = [2, 3, 4]
print('c =',c)    # c = 5

*a,b,c = my_tuple
print('a =',a)    # a = [1, 2, 3]
print('b =',b)    # b = 4
print('c =',c)    # c = 5

*a,*b,c = my_tuple    # SyntaxError: two starred expressions in assignment
print('a =',a)
print('b =',b)
print('c =',c)

a,b,*c = 'hello python'
print('a =',a)    # a = h
print('b =',b)    # b = e
print('c =',c)    # c = ['l', 'l', 'o', ' ', 'p', 'y', 't', 'h', 'o', 'n']

a,b,*c = [1,2,3,4,5,6]
print('a =',a)    # a = 1
print('b =',b)    # b = 2
print('c =',c)    # c = [3, 4, 5, 6]

二、字典

1、字典的概念

  • 字典 dict,映射(mapping)类型的数据结构。
  • 字典的作用其实和列表类似,是用来存储对象的容器。
  • 列表存储数据的性能非常好,但是查询数据的性能很差。而字典正好相反。
  • 在字典当中每一个元素都有唯一的一个名字,通过这个名字可以快速查询到指定的元素。
  • 这个唯一的名字我们一般称之为键 key,通过 key 我们可以查询到 value 值。
  • 所以字典我们也称之为 键值对(key-value)。
  • 每个字典当中可以有多个键值对,每一个键值对我们可以称之为一项(item)。
  • 字典中的键是不能重复的,如果重复后面的会替换前面的。

2、语法

  • 语法: {key:value,key:value…}
d = {'name':'钢铁侠','age':38,'sex':'男'}
# 需要根据键来获取值
print(d['name'],d['age'],d['sex'])    # 钢铁侠 38 男

3、字典的使用

3.1 创建字典

  • 使用dict()函数来创建字典
d = dict(name='钢铁侠',age=35,sex='男')
print(d,type(d))    # {'name': '钢铁侠', 'age': 35, 'sex': '男'} 
  • dict()函数也可以将一个包含有双值子序列转换为字典
    • 双值序列:序列中有2个值。例如 [1,2]、(‘b’,‘a’)、‘ab’
    • 子序列:如果序列中的元素也是序列,那么我们就称这个元素为子序列。例如 [(1,2),(3,4)]
d = dict([('name','钢铁侠'),('age',35)])
print(d,type(d))    # {'name': '钢铁侠', 'age': 35} 

3.2 len()

  • len() 获取字典中键值对的个数
d = {'name':'钢铁侠','age':38,'sex':'男'}
print(len(d))    # 3

3.3 in、not in

  • in 检查字典中是否包含指定的键,返回True / False
  • not in 检查字典中是否不包含指定的键
d = {'name':'钢铁侠','age':38,'sex':'男'}
print('name' not in d)    # False

3.4 获取字典中的值

3.4.1 根据键获取字典中的值

  • 语法:d[key]
d = {'name':'钢铁侠','age':38,'sex':'男'}
print(d['age'])    # 38

3.4.2 用get方法获取字典中的值

  • 语法:字典名.get(key,[default])
  • 如果字典当中没有这个Key值,会返回一个None;
  • 也可以指定一个默认值来作为第二个参数,这样获取不到Key值的时候就返回默认值。
d = {'name':'钢铁侠','age':38,'sex':'男'}
print(d.get('age'))    # 38
print(d.get('job'))    # None
print(d.get('birthday','这个key值不存在'))    # 这个key值不存在

3.5 修改字典

3.5.1 d[key] = value

  • 修改字典中的key-value
d = {'name':'钢铁侠','age':38,'sex':'男'}
d['name'] = '葫芦娃'
print(d)    # {'name': '葫芦娃', 'age': 38, 'sex': '男'}
  • 向字典中添加key-value
d = {'name':'钢铁侠','age':38,'sex':'男'}
d['phone'] = '12345678'
print(d)    # {'name': '钢铁侠', 'age': 38, 'sex': '男', 'phone': '12345678'}

3.5.2 setdefault(key,[default])

  • 向字典中添加 key-value
  • 如果这个key已经存在于字典当中,则返回key值,不会对字典有任何的影响;
  • 如果Key不存在,则向字典中添加这个key,并设置value。
d = {'name':'钢铁侠','age':38,'sex':'男'}
result = d.setdefault('name','葫芦娃')
print(result)    # 钢铁侠
print(d)    # {'name': '钢铁侠', 'age': 38, 'sex': '男'}

d = {'name':'钢铁侠','age':38,'sex':'男'}
result = d.setdefault('hello','葫芦娃')
print(result)    # 葫芦娃
print(d)    # {'name': '钢铁侠', 'age': 38, 'sex': '男', 'hello': '葫芦娃'}

3.5.3 update( )

  • 将其他字典当中的key-value添加到当前字典当中
d1 = {'a':1,'b':2,'c':3}
d2 = {'d':4,'e':5,'f':6}
d1.update(d2)
print(d1)    # {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
print(d2)    # {'d': 4, 'e': 5, 'f': 6}

3.6 删除

3.6.1 del

  • 删除字典中的一对key-value
d1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
del d1['a']
del d1['b']
print(d1)    # {'c': 3, 'd': 4, 'e': 5, 'f': 6}

3.6.2 popitem( )

  • 随机删除一个键值对,一般都会删除最后一个
  • 它会将删除之后的键值对作为返回值返回。返回的是一个元组, 元组中有2个元素:第一个元素是删除的key,第二个元素是删除的value。
d1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
result = d1.popitem()
print(result)    # ('f', 6)
print(d1)    # {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}

3.6.3 pop(key,[default])

  • 根据key来删除 key-value
d1 = {'c': 3, 'd': 4, 'e': 5}
result = d1.pop('b','这个key值不存在')
print(result)    # 这个key值不存在
print(d1)    # {'c': 3, 'd': 4, 'e': 5}
result = d1.pop('c')
print(result)    # 3
print(d1)    # {'d': 4, 'e': 5}

3.6.4 clear( )

  • 清空字典
d1 = {'c': 3, 'd': 4, 'e': 5}
d1.clear()
print(d1)    # {}

3.7 copy( )

  • copy( )用于对字典进行一个浅复制。
  • 浅复制只会复制字典的本身,如果字典中还有字典,是不会被复制的。
  • 复制以后的对象,和原对象是独立的。修改一个不会影响另一个。
d = {'a':{'name':'黑猫警长','age':18},'b':2,'c':3}
d1 = d
print('d =',d,id(d))  # d = {'a': {'name': '黑猫警长', 'age': 18}, 'b': 2, 'c': 3} 3039239036648
print('d1 =',d1,id(d1))  # d1 = {'a': {'name': '黑猫警长', 'age': 18}, 'b': 2, 'c': 3} 3039239036648

d1['b'] = 20
print('d =',d,id(d))  # d = {'a': {'name': '黑猫警长', 'age': 18}, 'b': 20, 'c': 3} 3039239036648
print('d1 =',d1,id(d1))  # d1 = {'a': {'name': '黑猫警长', 'age': 18}, 'b': 20, 'c': 3} 3039239036648

d1['a']['name'] = '皮卡丘'
print('d =',d,id(d))  # d = {'a': {'name': '皮卡丘', 'age': 18}, 'b': 20, 'c': 3} 3039239036648
print('d1 =',d1,id(d1))  # d1 = {'a': {'name': '皮卡丘', 'age': 18}, 'b': 20, 'c': 3} 3039239036648
d = {'a':{'name':'黑猫警长','age':18},'b':2,'c':3}
d2 = d.copy()
print('d =',d,id(d))  # d = {'a': {'name': '黑猫警长', 'age': 18}, 'b': 2, 'c': 3} 2039041318632
print('d2 =',d2,id(d2))  # d2 = {'a': {'name': '黑猫警长', 'age': 18}, 'b': 2, 'c': 3} 2039041347728

d2['b'] = 20
print('d =',d,id(d))  # d = {'a': {'name': '黑猫警长', 'age': 18}, 'b': 2, 'c': 3} 2039041318632
print('d2 =',d2,id(d2))  # d2 = {'a': {'name': '黑猫警长', 'age': 18}, 'b': 20, 'c': 3} 2039041347728

d2['a']['name'] = '皮卡丘'
print('d =',d,id(d))  # d = {'a': {'name': '皮卡丘', 'age': 18}, 'b': 2, 'c': 3} 2039041318632
print('d2 =',d2,id(d2))  # d2 = {'a': {'name': '皮卡丘', 'age': 18}, 'b': 20, 'c': 3} 2039041347728
# 修改d2中‘a’对应的字典,d中的字典也变了,说明字典{'name': '皮卡丘', 'age': 18}没有被复制。

4、遍历字典

4.1 keys( )

  • 该方法返回的是一个序列,保存的是字典中所有的键。
d = {'name':'钢铁侠','age':38,'sex':'男'}
print(d.keys())    # dict_keys(['name', 'age', 'sex'])
list_keys = []
for k in d.keys():
    list_keys.append(k)
print(list_keys)    # ['name', 'age', 'sex']

4.2 values( )

  • 该方法返回的是一个序列,保存的是字典中所有的值。
d = {'name':'钢铁侠','age':38,'sex':'男'}
print(d.values())    # dict_values(['钢铁侠', 38, '男'])
list_values = []
for k in d.values():
    list_values.append(k)
print(list_values)    # ['钢铁侠', 38, '男']

4.3 items( )

  • 该方法返回的是一个序列,保存的是字典中所有的项。
  • 这个序列当中包含有双值子序列,双值就是字典中的key-value。
d = {'name':'钢铁侠','age':38,'sex':'男'}
print(d.items())
for k,v in d.items():
    print(k,'=',v)
# 运行结果:
# dict_items([('name', '钢铁侠'), ('age', 38), ('sex', '男')])
# name = 钢铁侠
# age = 38
# sex = 男

三、集合

1、集合的概念

集合 set 和列表非常相似,但也有不同点:

  • 1 集合中只能存储不可变对象
  • 2 集合中存储的对象是无序的
  • 3 集合中不能出现重复的元素
# 集合中只能存储不可变对象
s = {[1,2,3],[4,5,6]}    # TypeError: unhashable type: 'list'
print(s,type(s))
# 集合中存储的对象是无序的
s = {'a','b',1,2,3}
print(s[0])    # TypeError: 'set' object does not support indexing
# 集合中不能出现重复的元素
s = {2,3,1,4,2,2,3,1}
print(s,type(s))    # {1, 2, 3, 4} 
s = {}
print(s,type(s))    # {} 

s = {1,2,3}
print(s,type(s))    # {1, 2, 3} 

# set() 可以将序列和字典转换为集合
s = set()
print(s,type(s))    # set() 

s = set([4,2,1,5,3,1,2,3,5,5])
print(s,type(s))    # {1, 2, 3, 4, 5} 

s = set('hello')
print(s,type(s))    # {'h', 'o', 'e', 'l'} 

# 使用set()函数将字典转换为集合的时候,只会包含字典中的键
s = set({'a':1,'b':2,'c':3})
print(s,type(s))    # {'a', 'c', 'b'} 

s = {'a','b',1,2,3}
print(s,type(s))    # {1, 2, 3, 'b', 'a'} 
a = list(s)
print(a,type(a))    # [1, 2, 3, 'b', 'a'] 

2、集合的使用

2.1 in 和 not in

s = {'a','b',1,2,3}
print('a' in s)    # True
print('a' not in s)    # False

2.2 len( )

  • 获取集合的长度(即集合内元素的个数)
s = {'a','b',1,2,3}
print(len(s))     # 5

2.3 add( )

  • 向集合中添加元素
s = {'a','b',1,2,3}
s.add(4)
print(s)    # {1, 2, 3, 4, 'a', 'b'}

2.4 update( )

  • 将一个集合中的元素添加到另一个集合中
s = {'a','b',1,2,3}
s2 = set('hello')
s.update(s2)
print(s)    # {'b', 2, 3, 1, 'h', 'o', 'e', 'l', 'a'}
print(s2)    # {'l', 'h', 'o', 'e'}

2.5 pop( )

  • 删除集合中的一个元素
s = {'a','b',1,2,3}
r = s.pop()
print(s)    # {1, 2, 3, 'a'}
print(r)    # b

2.6 remove( )

  • 删除集合中指定的元素
s = {'a','b',1,2,3}
s.remove('a')
print(s)    # {1, 2, 3, 'b'}

2.7 clear( )

  • 清空集合中的元素
s = {'a','b',1,2,3}
s.clear()
print(s)    # set()

3、集合的运算

3.1 交集运算 &

s1 = {1,2,3,4,5}
s2 = {3,4,5,6,7}
r = s1 & s2
print(r)    # {3, 4, 5}

3.2 并集运算 |

s1 = {1,2,3,4,5}
s2 = {3,4,5,6,7}
r = s1 | s2
print(r)    # {1, 2, 3, 4, 5, 6, 7}

3.3 差集运算 -

s1 = {1,2,3,4,5}
s2 = {3,4,5,6,7}
r1 = s1 - s2
print(r1)    # {1, 2}
r2 = s2 - s1
print(r2)    # {6, 7}

3.4 异或集运算 ^

  • 集合里面不相交的部分
s1 = {1,2,3,4,5}
s2 = {3,4,5,6,7}
r = s1 ^ s2
print(r)    # {1, 2, 6, 7}

3.5 比较运算

  • 返回的是布尔类型
  • <= 检查一个集合是否是另一个集合的子集
  • < 检查一个集合是否是另一个集合的真子集
  • >= 检查一个集合是否是另一个集合的超集
  • > 检查一个集合是否是另一个集合的真超集
a = {1,2,3}
b = {1,2,3,4,5}
c = {1,2,3}
r1 = a <= b
print(r1)    # True
r2 = a < b
print(r2)    # True
r3 = a < c
print(r3)    # False

四、可变对象

  • 每个对象都保存了三个数据:
    • 1.id(标识)
    • 2.type(类型)
    • 3.value(值)
  • a = [1,2,3] 列表就是一个可变对象
  • a[0] = 10 (改的是对象里面的value)
    • 这个操作是在通过变量去修改对象里面的值
    • 这个操作不会改变变量所指向的对象
  • a = [4,5,6] (改的是变量)
    • 这个操作是在给变量重新赋值
    • 这个操作会让变量指向新的对象
a = [1,2,3]
print('修改前',a,id(a))    # 修改前 [1, 2, 3] 2537002821000
a[0] = 10
print('修改后',a,id(a))    # 修改后 [10, 2, 3] 2537002821000
a = [1,2,3]
print('修改前',a,id(a))    # 修改前 [1, 2, 3] 1669417788296
a = [4,5,6]
print('修改后',a,id(a))    # 修改后 [4, 5, 6] 1669417788808
a = [1,2,3]
b = a
b[0] = 10
print('a',a,id(a))    # a [10, 2, 3] 2114062766984
print('b',b,id(b))    # b [10, 2, 3] 2114062766984
a = [1,2,3]
b = a
b = [7,8,9]
print('a',a,id(a))    # a [1, 2, 3] 1662926902152
print('b',b,id(b))    # b [7, 8, 9] 1662926901640

你可能感兴趣的:(Python基础知识,python,元组,字典,集合,数据结构)