一、元组tuple

定义：与列表相比，只是把 [ ] 换成 ( )

t1 = (1, 2)
t2 = tuple((1, 2))
t3 = (1, )
思考:如何定义一个只有一个值的元组
print(("Owen", ))
print(tuple(['Owen']))

 

1、参数为for可以循环的对象(可迭代对象)

t2 = tuple("123")       #字符串
print(t2, type(t2))
t3 = tuple([1, 2, 3])   #列表
print(t3, type(t3))
t4 = tuple((7, 8, 9))   #元组
print(t4, type(t4))

2、索引取值

t = (1,2,3,2,3,2)
    print(t[1])
    print(t[-2])

3、切片

print(id(t))
nt=t[:-1:]
print(nt,id(nt))

4、长度

print(len(t))

5、元组内置方法

print(t.count(2))    #该数据集合可以存放相同数据
print(t.index(2,1,2))

6、元组取值的两个方法：6.1、.count(obj) 

                                          6.2、 .index(obj, bIndex, eIndex)

7、有序存储 | 可存放多个数据 | 不可变(内部可以包含可变对象，可变对象已久可变)

 

8、应用场景：将不允许操作的列表可以转化为元组，将允许操作的元组转化为列表

 

二、字典dict

声明：dict的key：可以为所有不可变类型：int float tuole str bool None,一般就采用字符串

           dict的value：可以为所有数据类型

注：key具有唯一性（重复会覆盖旧值），value可以重复

dic = {1: None, None: None, 3.14: None,
           True: None, 'abc': None, (1,): None,
           None: 12345
           }
        print(dic)

    # 1、
    d1 = {'name': 'Owen', 'age': 18}
        print(d1)
    # 2、
    d2 = dict({'name': 'Owen', 'age': 18})
           print(d2)
    # 3、
    d3 = dict(name='Egon', age=58)
        print(d3)

1、定义

d1 = {'a': 10, 'b': 20}

2、无序，存放多个值，可变 => 通过key取值

d1['a']

3、增删改查

d1[key] = value: key存在就是改，不存在就是增
d1[key]: 取，如果key存在就报错，所以用get(key, defalut)
update({'a': 100, 'c': 300}): key有更新，无新增
pop(key): 根据key删且返回对应value

4、key存在，不操作，不存在设置key=default 

setDefault(key, default)

5、get取值*****

dic = {'a': 10, 'b': 20}
        # print(dic['c'])  # KeyError
    res = dic.get('c')  # 拥有默认值，None，可以避免错误
        print(res)
    res = dic.get('d', 'key不存在')  # 可以自定义默认值
        print(res)

6、随机删除，返回值是(key, value)

print(dic)
print(dic.popitem())
print(dic.popitem())
print(dic)

7、如何定义一个空字典

7.1、第一个参数：keys：list|tuple|str，第二个参数：统一的默认value
    d10 = {}.fromkeys(['a', 'b', 'c'], '')
        print(d10)  # {'a': '', 'b': '', 'c': ''}

7.2、独自设置默认值
    d11 = {'a': 10, 'teas': ['Owen']}
    d11 = {'a': 10}

7.3、添加老师

如果有teas，在原teas基础上添加老师，如果没有，新建一个空teas
    if 'teas' not in d11:  # 成员运算
        d11['teas'] = []
    d11['teas'].append('Egon')
    d11['teas'].append('LiuXX')
        print(d11)

原d11中，如果有teas这个key，setdefault相当于什么都没干
如果没有，就将第二个参数(默认值)传给teas存放到d11中
    d11.setdefault('teas', [])
    d11['teas'].append('Egon')
    d11['teas'].append('LiuXX')
        print(d11)

 

三、集合set

1、定义

s1 = set()
s2 = set({1, 2, 3})

2、重点：数据具有唯一性

# i) 单列数据集合：str，list，tuple，set 双列：dict
# ii) 无序存储：无key无index，无法取值
# iii) 可变数据类型，内部可以存放任意类型数据，但数据具有唯一性

 

{}代表空字典，用set()来创建空集合
s1 = set()
　　print(s1, type(s1))
s2 = set('abc')
　　print(s2, type(s2))

 

3、运算

p_set = {'a', 'b', 'c', 'egon'}
l_set = {'x', 'y', 'z', 'egon'}

3.1、交集

res = p_set & l_set
　　print(res)
res = p_set.intersection(l_set)
　　print(res)  # {'egon'}

3.2、并集

res = p_set | l_set
　　print(res)
res = p_set.union(l_set)
　　print(res)  # {'z', 'c', 'y', 'x', 'b', 'a', 'egon'}

3.3、差集

res = p_set - l_set
    print(res)  # {'a', 'b', 'c'}
res = l_set.difference(p_set)
    print(res)  # {'x', 'z', 'y'}

3.4、对称差集

res = p_set ^ l_set
　　print(res)
res = p_set.symmetric_difference(l_set)
　　print(res)  # {'y', 'a', 'b', 'x', 'z', 'c'}

4、了解：

sup_set = {1, 2, 3, 4, 5}
sub_set = {1, 2, 3}
temp_set = {3, 2, 1}
flag_set = {7, 8, 9}

print(sup_set > sub_set)  # True
print(sup_set < sub_set)  # False
print(temp_set == sub_set)  # True


# 两个set是否没有交集
res = flag_set.isdisjoint(temp_set)  # True

5、添加删除操作

s = set()
s.add('abc')
s.add('xyz')
print(s)
res = s.pop()  # 随机删除一个ele元素
print(res)
if 'xyz' in s:
s.remove('xyz')  # 有ele删除，无ele抛异常

6、利用set去重

classes = set()
for _, cless in class_map:
    classes.add(cless)
classes = list(classes)
print(classes)

7、了解：父子set

sup_set = {1, 2, 3, 4, 5}
sub_set = {1, 2, 3}
temp_set = {3, 2, 1}
flag_set = {7, 8, 9}

print(sup_set > sub_set)
print(sup_set < sub_set)
print(temp_set == sub_set)

8、案例

选课：
class_map = [
    ('owen', 'python'),
    ('egon', 'linux'),
    ('egon', 'python'),
    ('liuxx', 'python'),
    ('liuxx', 'java')
]
需求：
1.多少人参加了选课: ['owen', 'egon', 'liuxx']
2.都选了哪些课程: ['python', 'linux', 'java']
#利用逻辑代码去重
names = []
for name, _ in class_map:
    # 判断列表中是否已存在，不存在才添加
    if name not in names:
        names.append(name)
print(names)
案例：选课