元祖 字典 集合set

元组

定义：

　　ti=（）

　　print(ti,type(ti))

参数：for可以循环的对象（可迭代对象）

t2=tuple("123")   # ('1', '2', '3') <class 'tuple'> ←print(t2,type(t2))  

t3=tuple([1,2,3]) # (1, 2, 3) <class 'tuple'>

t4=tuple((7,8,9)) # (7, 8, 9) <class 'tuple'>

定义一个只有一个值的元祖：
print(('owen',))           # ('owen',)

print(tuple(['owen']))  # ('owen',)

常用操作：元组有序存储
# 索引 | 切片 | 长度
# .count(obj)  |  .index(obj, bIndex, eIndex)

索引取值

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

切片

print(id(t))       #2121545418120

nt = t[:-1:]
print(nt, id(nt))#(1, 2, 3, 2, 3) 2121544282448

长度（item元素个数）
print(len(t))     #6

元组内置方法
print(t.count(2))  # 该数据集合可以存放相同数据
print(t.index(2, 2, 3)) #ValueError: tuple.index(x): x not in tuple

# 案例一
# 提前拥有一个老师列表，打算开除，如果是校长亲友团，免开

# 原始列表为list类型
# 手动输入是否是亲友团，决定是否能开除（）

teas = ['Bob', 'Alex']

friends = input("亲友团[0, 1]：")

if friends == '1':
    teas = tuple(teas)

# => 异常处理
# 判断teas对象是否是tuple类型
if not isinstance(teas, tuple):  # 老师是否是亲友团，不是就开除
    teas.clear()

for t in teas:
    print("在职老师：%s" % t)
print（teas）
--------------------------------------------------------------
#亲友团[0,1]:1
在职老师：Bob
在职老师：Alex
('Bob', 'Alex')

亲友团[0,1]:0
[]

# 案例二
# 元组中的数据一定不能改变，但是元组中的数据(可变类型)的数据可以改变
t1 = (1, 2, "abc", True, (1, 2))  # t1永远无法改变

t2 = (1, 2, [])
print(t2, type(t2), id(t2), id(t2[2]))
       #(1, 2, []) <class 'tuple'> 1795565163288 1795565198216

t2[2].extend((10, 20))
print(t2, type(t2), id(t2), id(t2[2]))
       #(1, 2, [10, 20]) <class 'tuple'> 1795565163288 1795565198216

具名元组 namedtuple

tuple的升级版本

collections.namedtuple(typename, field_names, verbose=False, rename=False) 

　　创建一个具名元组，需要两个参数，一个是类名，另一个是类的各个字段名（多个字符串组成的可迭代对象，或者是有空格分隔开的字段名组成的字符串）。

import collections

# 两种方法来给 namedtuple 定义方法名
#User = collections.namedtuple('User', ['name', 'age', 'id'])
User = collections.namedtuple('User', 'name age id')
user = User('tester', '22', '464643123')

print(user)
# User(name='tester', age='22', id='464643123')

 

具名元组的特有属性:

类属性 _fields：包含这个类所有字段名的元组

类方法 _make(iterable)：接受一个可迭代对象来生产这个类的实例

实例方法 _asdict()：把具名元组以 collections.OrdereDict 的形式返回，可以利用它来把元组里的信息友好的展示出来

from collections import namedtuple

# 定义一个namedtuple类型User，并包含name，sex和age属性。
User = namedtuple('User', ['name', 'sex', 'age'])

# 创建一个User对象：
user = User(name='Runoob', sex='male', age=12)  # 方式1
user = User._make(['Runoob', 'male', 12])              # 方式2：类方法

# 获取所有字段名：类属性
print( user._fields )

print( user )
# User(name='user1', sex='male', age=12)

# 获取用户的属性
print( user.name )
print( user.sex )
print( user.age )

# 修改对象属性，注意要使用"_replace"方法
user = user._replace(age=22)
print( user )
# User(name='user1', sex='male', age=22)

# 将User对象转换成字典，注意要使用"_asdict"：实例方法
print( user._asdict() )
# OrderedDict([('name', 'Runoob'), ('sex', 'male'), ('age', 22)])


"""
以上实例输出结果为：

('name', 'sex', 'age')
User(name='Runoob', sex='male', age=12)
Runoob
male
12
User(name='Runoob', sex='male', age=22)
OrderedDict([('name', 'Runoob'), ('sex', 'male'), ('age', 22)])
"""

字典dict

一、声明 *****

dict的key：可以为所以不可变类型：int float tuple str bool None， 一般就采用字符串

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

特别了解：dict是python中仅存的mapping类型  # mapping映射

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

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

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

字典无序存储数据，无索引与切片，用key来取值

二、增删改查

dic = {}
# 增：key不存在
dic['name'] = 'Mac'   #>>>{'name': 'Mac'}
print(dic)

# 改：key已存在
dic['name'] = 'Big Mac'
print(dic)                #>>>{'name': 'Big Mac'}

# 查：
print(dic['name'])    #>>>Big Mac

# 删：
del dic['name']
print(dic)               #>>>{}

三、get取值 *****

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


# 增
# 添加的参数字典，与dic可以重复，就是更新值，新key就是新增
dic.update({'a': 100, 'c': 300})
dic.update([('age', 18),])
dic.update(hob='study')
print(dic)            #>>>{'a': 100, 'b': 20, 'c': 300, 'age': 18, 'hob': 'stydy'}

# 删 **
res = dic.pop('c')  # 根据key删除指定对象，并返回删除的对象的value
print(res)            #>>>300

# 复制：(浅拷贝|深拷贝)
newDic = dic.copy()
print(newDic)            #>>>{'a': 100, 'b': 20}


d1 = {'list': [1, 2]}   
d2 = d1.copy()
print(id(d1), id(d1['list']))
print(id(d2), id(d2['list']))
d1['list'].append('abc')
print(d2)
# 浅copy：只做第一层copy，内部的成员地址还是原来的地址


# 随机删除，返回值是(key, value)
print(dic)
print(dic.popitem())
print(dic.popitem())
print(dic)


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


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


# 添加老师
# 如果有teas，在原teas基础上添加老师，如果没有，新建一个空teasif '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)

dic = {'a': 10, 'b': 20, 'c': 30}
# 直接for循环(遍历)字典得到的是key
for k in dic:
    print(k, dic[k])

# 能不能只循环值
values = dic.values()
print(values, type(values))
# 存放key的集合
keys = dic.keys()
print(keys, type(keys))
# 存放key-value的键值对关系
k_vs = dic.items()
print(k_vs, type(k_vs))

# dic.values() | dic.keys() | dic.items() 不是原生list，不能直接索引取值，但可以for循环取值
# vs = list(values)
# print(vs[1])
# for v in vs:
#     print(v)

for v in values:
    print(v)
print()
for k in keys:  # 跟直接遍历字典是一样的
    print(k)

print()
# ***** 同时遍历k-v
for k, v in dic.items():
    print(k, v)
'''

'''
# 案例: 不区分大小写，计算每一个名字出现的次数，记录在字典中
ls = ['Owen', 'owen', 'Egon', 'LiuXX', 'Liuxx', 'egon', 'egon']
# {'owen': 2, 'egon': 3 ...}
name_dic = {}
for name in ls:
    # 名字全小写，不用区分大小写
    name = name.lower()
    # 名字是否在字典中存在：存在 - 次数+1 | 不存在 - 添加并设置初值1
    if name not in name_dic:
        # 不存在
        name_dic[name] = 1
    else:
        # 存在
        name_dic[name] += 1
print(name_dic)

ls = ['Owen', 'owen', 'Egon', 'LiuXX', 'Liuxx', 'egon', 'egon']
name_dic = {}
for name in ls:
    name = name.lower()
    # name已存在，不管，不存在，初始化指定key：name值为1
    name_dic.setdefault(name, 0)
    name_dic[name] += 1
print(name_dic)

集合set

1、定义与声明 什么是set： 
　　i) 单列数据集合：str，list，tuple，set    
　　　　双列：dict 
　　ii) 无序存储：无key无index，无法取值 
　　iii) 可变数据类型，内部可以存放任意类型数据，但数据具有唯一性 *****

　　{}代表空字典，用set()来创建空集合

s1 = set()
print(s1, type(s1))        #>>>set() <class 'set'>

s2 = set('abc')
print(s2, type(s2))        #>>>{'c', 'a', 'b'} <class 'set'>

2、内置方法与使用 - 集合间的运算 （& | ^ - > < ==）

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


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

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

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

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

print(p_set)
print(l_set)
# p_set.difference_update(l_set)  # 将运算结果赋值给调用者
p_set = p_set - l_set
print(p_set)  # {'c', 'a', 'b'}
print(l_set)  # {'egon', 'z', 'y', 'x'}


# 添加删除操作
s = set()
s.add('abc')
s.add('xyz')
print(s)          #>>>{'xyz', 'abc'}
res = s.pop()  # 随机删除一个ele元素
print(res)      #abc  /  xyz
if 'xyz' in s:
    s.remove('xyz')  # 有ele删除，无ele抛异常

3、案例与应用场景

# 选课：
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)

# 利用set去重
classes = set()
for _, cless in class_map:
    classes.add(cless)
classes = list(classes)
print(classes)

# 了解：父子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)    #True
print(sup_set < sub_set)    #False
print(temp_set == sub_set)  #True

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