元组（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('\033[34;10m define set ,集合是无序序列,不支持索引取值 \033[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(
'''\033[34;10m
########################################################################################
#
# set 常用方式
#
########################################################################################
\033[34;0m ''')
print('\033[34;10m in 和 not in \033[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('\033[34;10m | union 并集 ：所有报名的学生集合 (去掉重复的)\033[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('\033[34;10m & isinstance 交集 ：两个共同的元素 \033[34;0m')
# & isinstance 交集 ：两个共同的元素
print(pythons & linuxs) # 符号 & 是操作集合的交集，就是共同的元素 {'gandan', 'wupeiqi'}
print(pythons.intersection(linuxs)) # 内部提供 intersection 方法 等同于 符号 & 操作 {'gandan', 'wupeiqi'}
# - difference 差集 :求只报名python,没有报名linux 的学生
print('\033[34;10m - difference 差集 :求只报名python,没有报名linux 的学生 \033[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('\033[34;10m ^ symmetric_difference 对称差集 两个集合bu共有的 \033[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('\033[34;10m == \033[34;0m')
set1 = {1,2,3} # 顺序不一样，元素一样
set2 = {3,2,1} # # 顺序不一样，元素一样
print(set1 == set2 ) # return bool
# > , >= , < , <= , 父集 子集
print('\033[34;10m == \033[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('\033[34;10m set 集合是可变类型,但其元素一定是不可变类型 \033[34;0m')
linuxs = {'wupeiqi','oldboy','gandan'} # set 集合是可变类型,但其元素一定是不可变类型
linuxs.add('asb') # 支持添加元素
print(linuxs) # {'asb', 'oldboy', 'wupeiqi', 'gandan'} 可变但无序
# pop 随机删除不需要参数，有返回值的
print('\033[34;10m pop 随机删除不需要参数，有返回值的\033[34;0m')
ret = linuxs.pop() # 不需要指定参数，随机删除，有返回值的，不然不知道搞的那个
print(ret) # 返回被pop的值
# pop 随机删除不需要参数，有返回值的
print('\033[34;10m pop 随机删除不需要参数，有返回值的\033[34;0m')
'''
ret = linuxs.remove('wupeiqi') # 指定删除存在的元素，单纯的删除，没有返回值。
print(ret) # None
ret = linuxs.remove('peiqi') # 指定删除元素不存的报错 KeyError，单纯的删除，没有返回值。
print(ret) # None
'''
# discard 指定删除元素,不存在的不报错
print('\033[34;10m discard 指定删除元素,不存在的不报错 \033[34;0m')
ret = linuxs.discard('peiqi') # 指定删除元素不存的不报错 ，单纯的删除，没有返回值。
print(ret) # None
print(
'''\033[34;10m
########################################################################################
#
# set 了解的方法
#
########################################################################################
\033[34;0m ''')
# update 更新
print('\033[34;10m update 更新 \033[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('\033[34;10m clear 清除 \033[34;0m')
new_set.clear() # clear new_set
print(new_set) # set() 空集合
# copy 复制
print('\033[34;10m copy 复制 \033[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]]，分别取出列表中的名字，年龄，出生的年，月，日赋值给不同的变量View Code
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 python3View Code
# _*_ 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('\033[34;10m first in first out \033[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('\033[34;10m first in last out \033[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：字符串，列表，元组，字典，集合
解压:字符串，列表，元组，字典，集合