6 元组和集合类型

元组（tuple）

　　为何要有元组？===>存多个值，对比列表来说，元组不可变，主要是用来读

　　定义：与列表类型相似，只不过[]换成()，元组是不可变类型所以可以当做字典的key

常用方法：

#!/usr/bin/env python3 
# _*_ coding:utf-8 _*_
# @Time    : 2017/08/31 
# @Author  : tony
# @File    : tuple_set
# @Version : 1.0




# 弄个tuple尝尝

t = ('tony',28,'male',['a','b','c'],('e','f','g'))     # () 定义 tuple ，此序列的元素一旦定了不可改变,元素的类型不限制。

print(t)            # ('tony', 28, 'male', ['a', 'b', 'c'], ('e', 'f', 'g'))
print(type(t))      #  <class 'tuple'>


##############################################################
#
# 元组所以可以当做字典的key  dict 的 key 必须是不可变类型
##############################################################



d = {(1,):'tony'}       #  如果tuple里面就一个元素，记得用逗号结尾
print(d)                # {(1,): 'tony'}
print(type(d))          #  <class 'tuple'>
print(d[(1,)])          # 'tony'




# tuple index

goods = ('iphone','Thinkpad','sanxing','sony')

print('iphone' in goods)        # return bool 

#goods[1] = 'huawei'             # tuple 元素不支持修改，硬来的话
#print(goods)                    # TypeError: 'tuple' object does not support item assignment



# tuple items 可以是 可变元素 , 这样就可操作元素的元素

t = (1,2,3,['a','b','c'])      # 内部元素是可变的类型

t[3][0] = 'A'                  # 操作元素的可变类型元素
print(t)                       # (1, 2, 3, ['A', 'b', 'c'])

t[3].append(0)                # 操作元素的元素（元素是可变类型）

print(t)                      # (1, 2, 3, ['A', 'b', 'c', 0])



for k in enumerate(t):       # enumerate() 返回序的元素和元素的下标 每一组用tuple 包起来
    print(k)                 # (0,1) (1,2),(2,3),(3,['a','b','c'])
    print(k[1])        # 

集合（set）

集合：可以包含多个元素，用逗号分割

作用：去重，关系运算

集合的元素遵循三个原则：

1、集合是可变类型但每个元素必须是不可变类型

2、没有重复的元素

3、无序

注意：集合的目的是将不同的值存放到一起，不同的集合间用来做关系运算，无需纠结于集合中单个值

定义：

　　PS： s = {'tony','Tony'}

 重点及方法：

#!/usr/bin/env python3 
# _*_ coding:utf-8 _*_
# @Time    : 2017/09/01 
# @Author  : tony
# @File    : set_
# @Version : 1.0




print('33[34;10m define set  ,集合是无序序列,不支持索引取值 33[34;0m')
# define set   集合是无序序列 ,不支持索引取值


s = {1,2,3,'a','b','c',(4,5,6,7)}       # {} 像 dict 一样包起来，不同的是不用Key value 的形式
print(s)                                # {1, 2, 3, 'c', 'b', 'a', (4, 5, 6, 7)}
print(type(s))                          # <class 'set'>


print(
'''33[34;10m
########################################################################################
#
#                   set 常用方式
#
########################################################################################
33[34;0m ''')


print('33[34;10m in 和 not in 33[34;0m')
# in 和 not in 

pythons = {'tony','alex','egon','wupeiqi','yuanhao','gandan','biubiu'}             # define set 
linuxs = {'wupeiqi','oldboy','gandan'}                              # defind set 
print('tony' in pythons)        # return bool




print('33[34;10m |   union 并集 ：所有报名的学生集合 (去掉重复的)33[34;0m')
# |   union 并集 ：所有报名的学生集合 (去掉重复的)

print(pythons|linuxs)            # 符号  | 操作并集 两集合并在一起生 {'gandan', 'oldboy', 'alex', 'wupeiqi', 'biubiu', 'egon', 'yuanhao', 'tony'}  #  去掉重复的
print(pythons.union(linuxs))       # 内部提供union方法 等同于 符号 | 操作       {'gandan', 'oldboy', 'alex', 'wupeiqi', 'biubiu', 'egon', 'yuanhao', 'tony'} 




print('33[34;10m   &  isinstance 交集 ：两个共同的元素 33[34;0m')

# &  isinstance 交集 ：两个共同的元素

print(pythons & linuxs)     # 符号 & 是操作集合的交集，就是共同的元素  {'gandan', 'wupeiqi'}
print(pythons.intersection(linuxs))     # 内部提供 intersection 方法 等同于 符号 & 操作 {'gandan', 'wupeiqi'}


# - difference  差集 :求只报名python,没有报名linux 的学生
print('33[34;10m   - difference  差集 :求只报名python,没有报名linux 的学生 33[34;0m')

print(pythons - linuxs) #  - 符号操作集合 差集 :求只报名python,没有报名linux 的学生  {'tony', 'biubiu', 'yuanhao', 'egon', 'alex'}
print(pythons.difference(linuxs))         # 内部difference方法求差集  {'tony', 'biubiu', 'yuanhao', 'egon', 'alex'}


# ^ symmetric_difference 对称差集 就是两个集合bu共有的 ,我有你没有的，你有我没有的
print('33[34;10m   ^ symmetric_difference 对称差集 两个集合bu共有的 33[34;0m')

print(pythons ^ linuxs)             # ^ 符号操作集合 对称差集  不共有的, 我有你没有的，你有我没有的 {'oldboy', 'tony', 'yuanhao', 'alex', 'egon', 'biubiu'}
print(pythons.symmetric_difference(linuxs))     # 内部方法 symmetric_difference 方法 求对称差集 {'oldboy', 'tony', 'yuanhao', 'alex', 'egon', 'biubiu'}


#####################################################################################################################################################
print('#'*80)

#  == 
print('33[34;10m == 33[34;0m')

set1 = {1,2,3}      # 顺序不一样，元素一样
set2 = {3,2,1}      # # 顺序不一样，元素一样

print(set1 == set2 )    #  return bool 


#  > , >= , < , <= ,  父集 子集 
print('33[34;10m == 33[34;0m')

set3 = {1,2,3,4,5}
set4 = {2,3,5}

print(set3 >= set4)         # 符号操作  set3 包含set4 return bool
print(set3.issuperset(set4))    # set 内置方法 issuperset ， return bool

print(set4 <= set3)        # 符号操作，set4 是否是set3的子集合 return bool 
print(set4.issubset(set3))      # set 内置方法  issubset , set4 是否是set3的子集合 return bool 


# set 集合是可变类型,但其元素一定是不可变类型
print('33[34;10m set 集合是可变类型,但其元素一定是不可变类型 33[34;0m')


linuxs = {'wupeiqi','oldboy','gandan'}      # set 集合是可变类型,但其元素一定是不可变类型

linuxs.add('asb')               # 支持添加元素
print(linuxs)                   # {'asb', 'oldboy', 'wupeiqi', 'gandan'} 可变但无序




# pop 随机删除不需要参数，有返回值的
print('33[34;10m pop 随机删除不需要参数，有返回值的33[34;0m')

ret = linuxs.pop()              # 不需要指定参数，随机删除，有返回值的，不然不知道搞的那个
print(ret)                      # 返回被pop的值



# pop 随机删除不需要参数，有返回值的
print('33[34;10m pop 随机删除不需要参数，有返回值的33[34;0m')
'''
ret = linuxs.remove('wupeiqi')          #   指定删除存在的元素，单纯的删除，没有返回值。
print(ret)                              # None

ret = linuxs.remove('peiqi')          #   指定删除元素不存的报错 KeyError，单纯的删除，没有返回值。
print(ret)                              # None
'''


# discard 指定删除元素,不存在的不报错
print('33[34;10m discard 指定删除元素,不存在的不报错 33[34;0m')

ret = linuxs.discard('peiqi')          #   指定删除元素不存的不报错 ，单纯的删除，没有返回值。
print(ret)                              # None







print(
'''33[34;10m
########################################################################################
#
#                   set 了解的方法
#
########################################################################################
33[34;0m ''')


# update 更新
print('33[34;10m  update 更新 33[34;0m')

new_set = {'alex_SB','seven'}
print(linuxs.update(new_set))               # 更新 linuxs set 
print(linuxs)                               # {'wupeiqi', 'seven', 'oldboy', 'asb', 'alex_SB'}


print(new_set.update(linuxs))               # 反过来更新也行
print(new_set)                              # {'wupeiqi', 'seven', 'oldboy', 'asb', 'alex_SB'}



# clear 清除
print('33[34;10m  clear 清除 33[34;0m')

new_set.clear()             # clear new_set
print(new_set)              # set() 空集合



# copy 复制 
print('33[34;10m  copy 复制 33[34;0m')

new_set1 = linuxs.copy()     # copy set 
print('old:{0},copy:{1}'.format(linuxs,new_set1))   # old:{'alex_SB', 'gandan', 'seven', 'asb', 'wupeiqi'},copy:{'alex_SB', 'seven', 'gandan', 'wupeiqi', 'asb'

文件执行结果

 define set  ,集合是无序序列,不支持索引取值 
{1, 2, 'c', 3, 'a', 'b', (4, 5, 6, 7)}
<class 'set'>

########################################################################################
#
#                   set 常用方式
#
########################################################################################
 
 in 和 not in 
True
 |   union 并集 ：所有报名的学生集合 (去掉重复的)
{'alex', 'tony', 'oldboy', 'biubiu', 'egon', 'yuanhao', 'gandan', 'wupeiqi'}
{'alex', 'tony', 'oldboy', 'biubiu', 'egon', 'yuanhao', 'gandan', 'wupeiqi'}
   &  isinstance 交集 ：两个共同的元素 
{'gandan', 'wupeiqi'}
{'gandan', 'wupeiqi'}
   - difference  差集 :求只报名python,没有报名linux 的学生 
{'biubiu', 'tony', 'egon', 'yuanhao', 'alex'}
{'biubiu', 'tony', 'egon', 'yuanhao', 'alex'}
   ^ symmetric_difference 对称差集 两个集合bu共有的 
{'tony', 'biubiu', 'egon', 'alex', 'oldboy', 'yuanhao'}
{'tony', 'biubiu', 'egon', 'alex', 'oldboy', 'yuanhao'}
################################################################################
 == 
True
 == 
True
True
True
True
 set 集合是可变类型,但其元素一定是不可变类型 
{'asb', 'oldboy', 'gandan', 'wupeiqi'}
 pop 随机删除不需要参数，有返回值的
asb
 pop 随机删除不需要参数，有返回值的
 discard 指定删除元素,不存在的不报错 
None

########################################################################################
#
#                   set 了解的方法
#
########################################################################################
 
  update 更新 
None
{'oldboy', 'alex_SB', 'seven', 'gandan', 'wupeiqi'}
None
{'wupeiqi', 'oldboy', 'seven', 'alex_SB', 'gandan'}
  clear 清除 
set()
  copy 复制 
old:{'oldboy', 'alex_SB', 'seven', 'gandan', 'wupeiqi'},copy:{'wupeiqi', 'oldboy', 'seven', 'alex_SB', 'gandan'}

练习题：

1、有列表data=['alex',49,[1900,3,18]]，分别取出列表中的名字，年龄，出生的年，月，日赋值给不同的变量

2、模拟队列

      模拟堆栈

3、有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中。

　　即： {'k1': 大于66的所有值, 'k2': 小于66的所有值}

4、统计s='hello alex alex say hello sb sb'中每个单词的个数

　　结果如：{'hello': 2, 'alex': 2, 'say': 1, 'sb': 2}

 解答

#!/usr/bin/env python3 
# _*_ coding:utf-8 _*_
# @Time    : 2017/09/01 
# @Author  : tony
# @File    : set_prctice
# @Version : 1.0

import time


##############################################################
#
#                       练习题
#
##############################################################


# 一  有列表data=['alex',49,[1900,3,18]]，分别取出列表中的名字，年龄，出生的年，月，日赋值给不同的变量
data = ['alex',49,[1900,3,18]]

    # 列表解压
name,age,birth = data
year,month,day = birth

print('name:{0} age:{1} Date of Birth :{2}-{3}-{4}'.format(name,age,year,month,day))        # name:alex age:49 Date of Birth :1900-3-18



    # 扩展列表解压

l1 = ['tony',28,'male','tel']
#name,age,sex = l1               # 解压的元素的个数要跟变量的个数一致，不然报错 ValueError: too many values to unpack (expected 3)
#print(name,age,sex)


    # 万能 * 号 解决 多的元素

list1 = [1,2,3,4,5,6,7,8,9]
a,b,*c ,d = list1
print(a)    # 1
print(b)    # 2
print(c)    # [3,4,5,6,7,8]
print(d)    # 9


# 二  模拟队列
            #   模拟堆栈




# first in first out
print('33[34;10m first in first out 33[34;0m')

queue_l = []        # 模拟队列


for k in range(10):
    queue_l.append(k)       # 追加到最后一个
    print(queue_l)
    print('{0} in queue'.format(k))
    time.sleep(0.5)


for i in range(len(queue_l)):
    queue_l.pop(0)           # 默认弹出最后一个 pop(-1),先进入的在最前 所以改参数
    print(queue_l)
    print('{0} out queue '.format(i))
    time.sleep(0.5)


# first in last out
print('33[34;10m first in last out 33[34;0m')

for k in range(10):
    queue_l.append(k)       # 追加到最后一个
    print(queue_l)
    print('{0} in queue'.format(k))
    time.sleep(0.5)


for i in range(len(queue_l)):
    queue_l.pop()           # 默认弹出最后一个 pop(-1), so last in first out
    print(queue_l)
    time.sleep(0.5)




# 三 有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中。

l = [11,22,33,44,55,66,77,88,99,90]
dic = {'k1':[],'k2':[]}         # Dict Have key Value 

# 第一种：

for k in l:
    if k > 66:
        dic['k1'].append(k)
    else:
       dic['k2'].append(k)

print(dic)              # {'k2': [11, 22, 33, 44, 55, 66], 'k1': [77, 88, 99, 90]}



# 第二种

dict1 = {}        # Dict Not Have key Value 

for k in l:
    if k > 66:
        dict1.setdefault('k1',[]).append(k)     #   setdefault 字典中有key 返回 Value ，没有key 直接添加，默认 Value None 
    else:
        dict1.setdefault('k2',[]).append(k)     # 直到没有当前的key ，直接添加的时，跟上value 即可 

print(dict1)        # {'k2': [11, 22, 33, 44, 55, 66], 'k1': [77, 88, 99, 90]}





#  统计没有单词出现的次数  key,Value 的形式 

'''
s='hello alex alex say hello sb sb'中每个单词的个数
　　结果如：{'hello': 2, 'alex': 2, 'say': 1, 'sb': 2}
'''
s = 'hello alex alex say hello sb sb '
word_count = {}

s = s.split()     # split 分割开 返回一个list  ['hello', 'alex', 'alex', 'say', 'hello', 'sb', 'sb']


for k in s:
    if k in word_count:
        word_count[k] += 1      # 有当期的单词 个数加 1
    else:
        word_count[k] = 1       # 没有当前的单词，建立新的key  Value 为 1 说明第一次遇到这货

print(word_count)

小知识点：

in：字符串，列表，元组，字典，集合

for：字符串，列表，元组，字典，集合

解压:字符串，列表，元组，字典，集合