字典 dict：
  1，字典是一种可变的容器，可以存储任意类型的数据
  2，字典中每个数据都是用‘键’（key）进行索引，而不像序列可以用下标进行索引
  3，字典的数据没有先后顺序关系，字典的存储是无序的
  4，字典中的数据以键（key）-值（value）队进行映射存储
  5，字典的键不能重复，且只能用不可变类型作为字典的键。

字典的字面值表示方式；
  用{}括起来，以冒号（：）分割键-值对，各键值对用分号分隔开

创建空字典：
  d = {}

创建非空字典：
  d = {'name':'tarena','age':'15'}
  d = {'姓名'：'小张'}
  d = {1:'壹',2:'贰'}

***☆字典的构造函数 dict：
  dict（）  创建一个空字典，等同于{}
  dict（iterable）  用可迭代对象初始化一个字典

  dict（**kwargs）  关键字传参形式生成一个字典

示例：
  d = dict（）
  d = dict（[('name','tarena'),('age',15)]）
  d = dict（name='tarena',age=15）

例：
  >>> d = dict(('AB','CD'))
  >>> d
  {'A': 'B', 'C': 'D'}


  >>> d = dict(('AB','CD',[1,2],(3,4)))
  >>> d
  {'A': 'B', 1: 2, 'C': 'D', 3: 4}


  >>> d = dict(('ab',))  
  >>> d
  {'a': 'b'}
#d = dict（）创建字典时，括号内必须是可迭代对象
 上例为（'ab',）,是一个元组，当括号内没有‘，’，为字符串，则创建字典会报错



不可变类型：
  int ,float ,complex,bool,str,tuple,frozenset(固定集合)，bytes(字节串)
可变类型：
  list,dict,set(集合),bytearray(字节数组)


字典的键索引
  用[]运算符可以获取字典内‘键’所对应的‘值’
  语法：
    字典[键]
  获取数据元素
    d = dict(name='tarena',age=15)
    print(d['age'])   #15
例：
  >>> d = dict(name='tarena',age=15)
  >>> d
  {'age': 15, 'name': 'tarena'}
  >>> print(d['age'])
  15
  >>> print(d[age])
  Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  NameError: name 'age' is not defined


添加/修改字典元素
  字典[键] = 表达式
示例：
  d = {}
  d['name']='tarena'  #创建一个新的键值对
  d['age']=15         #创建键值对   
  d['age']=16         #修改键值对


del 语句删除字典的元素
  语法：  
    del 字典[键] 
  示例：
    d = {'name':'china','pos':'asia'}
    del d['pos']
    print(d)
    del d['name']
    print(d)   #{}


字典的in运算速率高于列表的in运算速率
字典的in /not in 运算符：
  可以用in 运算符来判断一个‘键’是否存在在字典中，如果存在返回True，否则返回False
  not in 与in返回值相反
示例：
  d={'a':1,'b':2}
  'a'in d     #True
  1 in d      #False
  100 not in d  #True
  2 not in d   #True

字典的迭代访问：
  字典是可迭代对象，字典只能对键进行迭代访问
  d={'name':'tarena',(2002,1,1):'生日'}
  for x in d:
      print(x)

可以用于字典的内建函数：
len（x）   返回字典键值对的个数
max（x）   返回字典的键的最大值
min（x）   返回字典的键的最小值
sum（x）   返回字典的所有键的和
any（x）   真值测试，只对键测试，如果其中一个键为True，结果为True
all（x）   真值测试，全部键为True时，结果才为True


字典的方法：

  见：/dict.hyml

  d = {'name':'china','pos':'asia'} 
  for x,v in d.items():
      print("键：",x,"值：",v)
  >>> 键：'name',值：'china'
  >>> 键：'pos',值：'asia'


练习;
  写程序，实现以下需求：
  将以下数据形成一个字典seasons
  '键'   ‘值’
   1      ‘春季有1,2,3月’
   2      ‘夏季有4,5,6月’
   3      ‘秋季有7,8,9月’
   4      ‘冬季有10,11,12月’
  让用户输入一个数字代表这个季度，打印这个季度的信息，
  若输入信息不在字典的键内，打印信息不存在


练习：
  写程序，输入一串字符串，打印出这个字符串中
每个字母出现的次数，用字典打印出来


字典推导式：
  字典推导式是用可迭代对象依次生成字典内元素的表达式
  语法：
    {键表达式：值表达式 for 变量 in 可迭代对象 [if 真值表达式]}
     注：[]内的内容可以省略
  示例;
    d={x:x**2 for x in range(10)}


练习：
1，有字符串列表如下：
  L=['tarena','xiaozhang','xiaowang']
  生成如下字典
  d ={'tarena':6,'xiaozhang':9,'xiaowang':8} 注：字典值为键长
2，编号列表如下：
  Nos=[1001,1002,1003,1004]
  names=['Tom','Jerry','Spike','Tyke']
  生成用Nos数据为键以names为值的字典，如下：
  {1001：‘Tom’，1002：‘Jerry’...}

练习：
1，写一个程序，输入一些单词和解释，将单词作为键，解释作为值，
  将这些数据存入字典中
然后：
  输入查询的单词，显示单词的解释
2，学生管理项目起步准备工作：
  写一个程序，任意输入n个学生的信息，形成字典后存于列表中：
  学生信息包括：
  姓名：（字符串）
  年龄：（整数）
  成绩：（整数）
  循环输入学生信息，直到输入学生姓名为空时结束输入，最后形成字典如下：
  L=[{'name':'xiaozhang','age':20,'score':100}
     {'name':'xiaoli','age':21,'score':98}
     {'name':'xiaowang','age':19,'score':89}
     ...]
   将以上列表显示成如下表格：
   +---------------+-----+-------+
   |      name         | age  | s core |
   +---------------+-----+-------+
   |   xiaozhang    |  20    |  100    |
   |     xiaoli          |  21    |  98      |
   |   xiaowang     |  19    |  89      |

   +---------------+-----+-------+

集合 set
  集合是可变的容器
  集合内的数据对象是唯一的（不能重复多次的）
  集合是无序的存储结构，集合中的数据没有先后关系
  集合内的元素必须是不可变对象
  集合是可迭代的
  集合是相当于只有键没有值的字典（键则是集合的数据）


创建空的集合
  set（）   #set（）创建一个空的集合
 
创建非空集合
  s = {1,2,3}  #集合中的三个整数1,2,3


集合的构造函数 set
  set（）创建空集合
  set（iterable）  用可迭代对象创建一个新的集合对象


示例：
  s = set("ABC")
  s = set('ABCCBA')
  s = set({1:"一",2:'二'，5：‘五’})
  s = set（[1,3.14,False]）
  s = set((2,3,5,7))
  #s =set([1.2.[3.1,3.2],4]) #错误 [3.1,3.2]是可变对象


集合的运算：
  交集，并集，补集，子集，超集
  
&  生成两个元素的交集
   s1={1,2,3}  s2={2,3,4}
   s3 = s1 & s2    #s3={2,3}


|  生成两个集合的并集
   s1={1,2,3}  s2={2,3,4}
   s3 = s1 | s2    #s3={1，2, 3，4} 


-  生成两个集合的补集
   s1={1,2,3}  s2={2,3,4}
   #（生成属于s1，但不属于s2的所有元素的集合）：
   s3 = s1 - s2    #s3={1}


^  生成两个集合的对称补集  
   s1={1,2,3}  s2={2,3,4}
   s3 = s1 ^ s2    #s3={1，4} 
   #等同于s3=(s1-s2)|(s2-s1)


<  判断一个集合是另一个集合的子集
>  判断一个集合是否是另一个集合的超集
   s1={1,2,3}  s2={2,3}
   s2 < s1    #True   判断子集
   s1 > s2    #True   判断超集




==  !=  判读集合相同/不同
   s1={1,2,3}  s2={2,3，1}
   s2 == s1    #True 
   s1 != s2    #False   #集合的数据没有先后关系


in / not in 运算符
  等同于字典，
  in运算符用于集合中，当某个值存在集合中，则为真，否则为假
  not in 与in 返回值相反
示例：
  s={1,'Two',3.14}
  1 in s          #True
  2 in s          #False
  3.14 not in s   #False
  4 not in s      #True




python3中可用于集合的函数：
  len(s)
  max(s)
  min(s)
  sum(s）
  any(s)
  all(s)




集合是可迭代对象
  s={1,2,3}
  for x in s:
      prinr(x)




练习：
  经理有：曹操，刘备，周瑜
  技术员有：曹操，周瑜，张飞，赵云
  用集合求：
  1，既是经理也是技术员的有：
  2，是经理，但不是技术员的有：
  3，是技术员，但不是经理的有：
  4，张飞是经理么？
  5，身兼一职的有谁
  6，经理和技术员一共多少人


思考：
  集合是可变对象，有方法能添加，删除集合的数据么？


集合的方法：

  见:file:///E:/python-study/python_base_docs_html/set.html

对于不可变对象，有时复合赋值运算符不等同于运算后再赋值
  如：s1 = s1 | s2  不等同于 s1 |= s2
      
s.copy()  


>>> s1 = {1,2,3}
>>> s2 = {2,3,4}
>>> id(s1)
139960777726664
>>> s1 = s1 | s2
>>> s1
{1, 2, 3, 4}
>>> id(s1)
139960777724872

练习：
  任意输入一些单词，存入集合中，输入空字符串时结束输入，
  1）打印输入单词的种类数（去重）
  2）每个单词都打印到终端上显示
  思考：如何让打印的次序和输入的次序一致？

集合推导式：
  用可迭代对象来创建（生成）集合的表达式

  语法：
  {表达式 for 变量 in 可迭代对象 [if 真值表达式]}
   []内容部分可省略

  示例：
    L=[2,3,5,7,3,5,7,11]
    s={x**2 for x in L}    #s={4,9,25,49,121}

集合推导式的嵌套规则与列表推导式相同：

练习：
  模拟一个点名系统，已知全班学生名单，随机打印学生的姓名进行点名
  并得到此学生是否已到信息，输入y代表已到，其他输入代表未到场
  点名结束后打印未到者名单


问题：
  能用集合作为字典的键么？


固定集合 frozenset
  固定集合是不可变的，无序的，含有唯一元素的集合

作用：
  固定集合可以作为字典的键，也可作为集合的值（元素）

创建空的固定集合：
  fs = frozenset()
创建非空的固定集合：
  fs = frozenset([2,3,5,7])

构造函数：
  frozenset()
  frozenset(可迭代对象)  #同set函数一致，返回固定集合

固定集合的运算：
  & 交集
  | 并集
  - 补集
  ^ 对称补集
  >  >=  <  <=  ==  !=
  in /not in
  (以上运算规则等同于set中的用法）

固定集合的方法：
  相当于集合的全部方法去掉修改集合的方法