《零基础学Python（第二版）》（一）

      这本书是在师兄师姐推荐的一个网站上看到的电子版，作者是一名自称老齐的python大牛，链接如下点击打开链接，进一步学习这门语言还得坚持坚持再坚持了。

     下面对这部分的内容总结一下：

零、预备

      1 关于Python的故事

      并没有什么好说的，还是那个经典的起源：1989年的圣诞节期间，吉多·范罗苏姆为了在阿姆斯特丹打发时间，决心开发一个新的脚本解释程序，作为ABC语言的一种继承。之所以选中Python作为程序的名字，是因为他是一个蒙提·派森的飞行马戏团的爱好者。

      2 从小工到专家

      必经之路就是要多阅读代码，多调试程序。

      3 安装Python的开发环境

      Python的官网上下载东西：www.python.org/downloads/ 。同样是在windows上运行，采用的是python2.7版本。

      4 集成开发环境

      这里使用的是Python自带的IDLE。

一、基本数据类型

       1 数和四则运算

       “对象有类型，变量无类型 ”这是Python比较特殊的地方。另外，python里没有整数计算溢出的问题。type(Obeject)可以得出该实体的类型。

       2 除法

       整数除以整数，结果是整数（商）。不管是被除数还是除数，只要有一个数是浮点数，结果就是浮点数。对于需要非常精确的情况，可以使用 decimal 模块，它实现的十进制运算适合会计方面的应用和高精度要求的应用。fractions 模块支持另外一种形式的运算，它实现的运算基于有理数（因此像1/3这样的数字可以精确地表示）。最高要求则可是使用由 SciPy提供的 Numerical Python 包和其它用于数学和统计学的包。

       有两种形式可以调用模块：

       1）import module-name。import后面跟空格，然后是模块名称，例如：import os。

       2）from module1 import module11。module1是一个大模块，里面还有子模块module11，只想用module11，就这么写。

       divmod()函数返回商和余数，如divmod(5,2)返回(2,1)。

       round()函数用来返回四舍五入的值，但有时会出现小的偏差，与二进制浮点数有关。

      3 常用数学函数和运算优先级

      当安装好python之后，就有一些模块默认安装了，这个称之为“标准库”，“标准库”中的模块不需要安装，就可以直接使用。 如果没有纳入标准库的模块，需要安装之后才能使用。模块的安装方法，特别推荐使用pip来安装。

      math模块直接用import引用，math.pi代表圆周率。dir(模块)可以列出模块里包含的工具。help(函数)可以查看函数的使用说明。pow函数和x**y是等效的，都是计算x的y次方。

      4 写一个简单的程序

      通常，计算机程序要经过编译和链接而成为一种人们不易看清而计算机可解读的格式，然后运行。未经编译就可运行的程序，通常称之为脚本程序（script）。python也被称之为解释性语言，编程出来的程序被叫做脚本程序。

     注释的方式有两种，一种是单行注释，用#开头，另外一种是多行注释，用一对'''包裹起来。

      5 字符串

      拼接字符串必须是同一类型的，可将其中的int型转化成字符串的时候用· ·（反引号）括起来，不过很少用了，更多的时候用强制类型转化，如str(a)，再或者是用repr()函数，就相当于反引号了。

      由r开头引起的字符串，是原始字符串，在里面放任何字符都表示该字符的原始含义。这种方法在做网站设置网站目录结构的时候非常有用。使用了原始字符串，就不需要转义了。如 r"c:\news"。

      id()的作用就是查看该对象在内存地址（就是在内存中的位置编号）。切片操作： b = lang[1:] 得到从1号到最末尾的字符，这时最后那个序号不用写；c = lang[:] 得到所有字符，并没有生成一个新的字符串，而是将变量c这个标签也贴在了原来那个字符串上了；d = lang[:10] 得到从第一个到10号之前的字符。

      字符串的一些基本操作：

      1）len()：求序列长度。
      2）+ ：连接2个序列。
      3）* : 重复序列元素。
      4）in :判断元素是否存在于序列中，如 "a" in str1。
      5）max() :返回最大值，min() :返回最小值。
      6）cmp(str1,str2) :比较2个序列值是否相同，也可以比较整数，这时候就是整数的直接比较了。

      ord()是一个内建函数，能够返回某个字符（注意，是一个字符，不是多个字符组成的串）所对一个的ASCII值（是十进制的），如ord('a') ，反过来，根据整数值得到相应字符，可以使用chr()，如chr(97)。

      python非常提倡的string.format()的格式化方法，其中{}作为占位符。

print "my name is {}, I am {} years old".format("why",22)

     还可以这样来做：

print "my name is {name}, I am {old} years old".format(name="why",old=22)

      一些字符串的操作函数:

       isalpha函数用来判断如果字符串全是字母就返回true，否则返回false.

print "python".isalpha()      #trueprint "22python".isalpha()  #false

       split函数的作用是将字符串根据某个分割符进行分割，得到了一个名字叫做列表（list）的返回值。

a = "I love zmq"print a                #I love zmqprint a.split(" ")    #['I', 'love', 'zmq']

       S.strip() 去掉字符串的左右空格，S.lstrip() 去掉字符串的左边空格，S.rstrip() 去掉字符串的右边空格，原来的值没有变化，而是新返回了一个结果。

a = "  why  "print a                #  whyprint a.strip()        #why

        在python中有下面一堆内建函数，用来实现各种类型的大小写转化  ：

        1）S.upper() ：S中的字母大写

        2）S.lower() ：S中的字母小写

        3）S.capitalize() ：首字母大写

             4）S.isupper() ：S中的字母是否全是大写

        5）S.islower() ：S中的字母是否全是小写

        6）S.istitle()

       将列表中的每个字符（串）元素拼接成一个字符串，并且用某个符号连接，用字符串的join就比较容易实现。

a = "w h y"b = a.split(" ")print b                #['w', 'h', 'y']c = ".".join(b)print c                #w.h.y

       6. 字符编码

       在python2中还要考虑编码的问题，而在python3中则不用考虑这些问题了。python2默认的编码是ascii，通过encode可以将对象的编码转换为指定编码格式（称作“编码”），而decode是这个过程的逆过程（称作“解码”）。

       那么在python中如何避免中文是乱码呢？首先，提倡使用utf-8编码方案，因为它跨平台不错。

       1）在开头声明。

# -*- coding: utf-8 -*-

       2）遇到字符（节）串，立刻转化为unicode，不要用str()，直接使用unicode()。

unicode_str = unicode('中文', encoding='utf-8')print unicode_str.encode('utf-8')

       3）如果对文件操作，打开文件的时候，最好用codecs.open，替代open。

import codecscodecs.open('filename', encoding='utf8')

       7. 列表

       在python中，用方括号表示一个list：[ ]。bool()是一个布尔函数，它的作用就是来判断一个对象是“真”还是“空”（假）。如果list中什么也没有，就是空的，用bool()函数来判断，得到False。list里面所能容纳的元素数量无限，list中的元素是任意类型的。     

a = [1,'why',22.5]print a            #[1, 'why', 22.5]print type(a)    #<type 'list'>print bool(a)     #True

       索引和切片操作在list中同样可以应用。

a = [1,'why',22.5]print a                #[1,'why',22.5]print a[0]            #1print a[2]            #22.5print a[1:]            #['why', 22.5]print a.index(22.5)    #2

        还有一种编号方式，就是从右边开始，右边第一个可以编号为-1，然后向左依次是：-2,-3,...，依次类推下来。这对字符串、列表等各种序列类型都可。序列的切片，一定要左边的数字小有右边的数字，没有遵守这个规则，返回的就是一个空。

a = [1,'why',22.5]print a[-1]            #22.5print a[-2]            #whyprint a[-3:-1]        #[1,'why']b = "why"print b[-1]            #yprint b[-3:-1]        #wh

        对于反转，不是在“原地”把原来的值倒过来，而是新生成了一个值，那个值跟原来的值相比，是倒过来了。

        第一种方式是：

a = [1,'why',22.5]print a[::-1]        #[22.5, 'why', 1]print a                #[1,'why',22.5]

       还有一种方式是：     

a = [1,'why',22.5]print list(reversed(a))        #[22.5, 'why', 1]print a                     #[1, 'why', 22.5]

      reversed()函数可以返回一个可以迭代的对象，不过是已经将原来的序列对象反转了。

      对List的基本操作如下：

      1）len()：求和。

a = [1,'why',22.5]print len(a)       #3

      2）+：连接两个序列。

a = [1,'why',22.5]b = [2,'z',21.5]print a + b        #[1, 'why', 22.5, 2, 'z', 21.5]

      3）*：重复元素。

a = [1,'why',22.5]print a * 3        #[1, 'why', 22.5, 1, 'why', 22.5, 1, 'why', 22.5]

      4）in：判断元素是否在列表中。

a = [1,'why',22.5]print 3 in a          #Falseprint 'why' in a      #True

      5）max()和min()：最大值和最小值。

a = [1,'why',22.5]print max(a)        #whyprint min(a)        #1

       6）cmp()：列表比较。

a = [1,'why',22.5]b = [2,'z',21.5]print cmp(a,b)        #-1

       7）append()：追加元素。

a = [1,'why',22.5]a.append(2)print a#[1, 'why', 22.5, 2]a[len(a):] = ['z']print a#[1, 'why', 22.5, 2, 'z']a[5:] = [21.5]print a#[1, 'why', 22.5, 2, 'z', 21.5]

       8）extend()：将两个list合并，或者说将一个list追加到另外一个list中。extend(str)的时候，str被以字符为单位拆开，然后追加到la里面。如果extend的对象是数值型，则报错。所以，extend的对象是一个list，如果是str，则python会先把它按照字符为单位转化为list再追加到已知list。

a = [1,'why',22.5]b = [2,'z',21.5]a.extend(b)print a            #[1, 'why', 22.5, 2, 'z', 21.5]c = 'and'a.extend(c)        print a            #[1, 'why', 22.5, 2, 'z', 21.5, 'a', 'n', 'd']d = 2a.extend(d)print a            #TypeError: 'int' object is not iterable

        这个函数需要的参数就是iterable类型的对象。用内建函数hasattr()判断一个字符串是否是可迭代的，hasattr()的判断本质就是看那个类型中是否有__iter__函数。

a = [1,'why',22.5]print hasattr(a,'_iter_')print hasattr("why",'_iter_')print hasattr(2,'_iter_')

        列表有一个重要特征：列表是可以修改的。这种修改，不是复制一个新的，而是在原地进行修改。原地修改没有返回值，就不能赋值给某个变量。

        下面演示了append()和extend()的区别。即append是整建制地追加，extend是个体化扩编。

a1 = [1,'why',22.5]a2 = [1,'why',22.5]b = [2,'z',21.5]a1.append(b)print a1 #[1, 'why', 22.5, [2, 'z', 21.5]]a2.extend(b)print a2        #[1, 'why', 22.5, 2, 'z', 21.5]

        9）count()：数一数某个元素在该list中出现多少次，也就是某个元素有多少个。如果不存在就返回0。

a1 = [1,1,'why',22.5]print a1.count(1)#2print a1.count("why")        #1print a1.count(2)#0

        10）index()：返回该元素在list中的位置。如果元素不存在就报错。        

a1 = [1,'why',22.5]print a1.index(1)        #0print a1.index(22.5)    #2print a1.index(3)        #ValueError: 3 is not in list

        11）insert()：也是对list元素的增加。只不过是可以在任何位置增加一个元素。list.insert(i, x)中的i是将元素x插入到list中的位置，即将x插入到索引值是i的元素前面。，如果遇到那个i已经超过了最大索引值，会自动将所要插入的元素放到列表的尾部，即追加。

a = [1,'why',22.5]a.insert(2,'z')a.insert(9,'remember')print a        #[1, 'why', 'z', 22.5, 'remember']

        12）remove()：删除列表中的一个元素，如果列表不包含此元素则返回出错信息。如果列表中包含多个此元素，则删除第一个此元素。在实际应用中应该先用if..else..和in做一个判断。

a = [1,'why',1,22.5]a.remove(22.5)print a                #[1, 'why', 1]a.remove(1)print a                #['why', 1]a.remove('z')print a                #ValueError: list.remove(x): x not in list

        13）pop()：list.remove(x)中的参数是列表中元素，即删除某个元素；list.pop([i])中的i是列表中元素的索引值，这个i用方括号包裹起来，意味着还可以不写任何索引值即删除列表的最后一个。     

a = [1,'why',1,22.5]a.pop()print a        #[1, 'why', 1]a.pop(0)print a     #['why', 1]

        14）reverse()：把列表的元素顺序反过来。是原地反过来，不是另外生成一个新的列表。所以，它没有返回值。因为list.reverse()不返回值，所以不能实现对列表的反向迭代，如果要这么做，可以使用reversed函数。

a = [1,'why',22.5]a.reverse()print a            #[22.5, 'why', 1]

        15）sort()：对列表进行排序。list.sort()也是让列表进行原地修改，没有返回值。默认情况，实现的是从小到大的排序。还可以实现从大到小的排序。

a = [1,'why',22.5]a.sort(reverse=True)print a        #['why', 22.5, 1]

              还能够设置按照哪个关键字进行排序。

a = ['a','aa','aaa']a.sort(key = len)print a        #['a', 'aa', 'aaa']

       8. 回顾列表和字符串

       相同点：都属于序列类型的数据。所谓序列类型的数据，就是说它的每一个元素都可以通过指定一个编号，行话叫做“偏移量”的方式得到，而要想一次得到多个元素，可以使用切片。偏移量从0开始，总元素数减1结束。      

       区别：list和str的最大区别是list是可以改变的，str不可变。 多维List也可以看做一个区别，在str中，里面的每个元素只能是字符，在list中，元素可以是任何类型的数据。

       list 和 str 的转化：

      1）str.split()：这个内置函数实现的是将str转化为list。如果split()不输入任何参数，显示就是见到任何分割符号，就用其分割了。

      2）"[sep]".join(list)：join可以说是split的逆运算。

      9.元组

      元组是用圆括号括起来的，其中的元素之间用逗号隔开（都是英文半角），元组中的元素类型是任意的python数据。

a = 123,"come on",[1,'why',22.5]print a#(123,"come on",[1,'why',22.5])

      tuple是一种序列类型的数据，这点上跟list/str类似。它的特点就是其中的元素不能更改，这点上跟list不同，倒是跟str类似；它的元素又可以是任何类型的数据，这点上跟list相同，但不同于str。

      同样可以进行索引和切片操作。

a = 123,"come on",[1,'why',22.5]print a[0]            #123print a[1:]            #('come on', [1, 'why', 22.5])print a[2][1]        #why

      如果一个元组中只有一个元素的时候，应该在该元素后面加一个半角的英文逗号。如果不加那个逗号，就不是元组，加了才是。

a = (1)print type(a)   #inta = (1,) print type(a)#tuple

      所有在list中可以修改list的方法，在tuple中，都失效。可以分别用list()和tuple()能够实现两者的转化：

a = 123,"come on",[1,'why',22.5],(2,'z')lis = list(a)print lis            #[123, 'come on', [1, 'why', 22.5], (2, 'z')]tup = tuple(a)print tup            #(123, 'come on', [1, 'why', 22.5], (2, 'z'))

      一般认为tuple的使用情景是：

       1）Tuple 比 list 操作速度快。如果定义了一个值的常量集，并且唯一要用它做的是不断地遍历它，使用 tuple 代替 list。

       2）如果对不需要修改的数据进行 “写保护”，可以使代码更安全。使用 tuple 而不是 list 如同拥有一个隐含的 assert 语句，说明这一数据是常量。如果必须要改变这些值，则需要执行 tuple 到 list 的转换 。

       3）Tuples 可以在 dictionary中被用做 key，但是 list 不行。Dictionary key 必须是不可变的。Tuple 本身是不可改变的，但是如果有一个 list 的 tuple，那就认为是可变的了，用做 dictionary key 就是不安全的。只有字符串、整数或其它对 dictionary 安全的 tuple 才可以用作 dictionary key。

       4）Tuples 可以用在字符串格式化中。     

      10.字典

      在一个dict中，键是唯一的，不能重复。值则是对应于键，值可以重复。键值之间用(:)英文的分号，每一对键值之间用英文的逗号隔开。

      创建dict有三种方法：

      1）创建一个空的dict，这个空dict，可以在以后向里面加东西用。字典可以原地修改，即它是可变的。

a = {}print id(a)        #32871288a['name'] = 'why'print a            #{'name': 'why'}print id(a)        #32871288

      2）利用元组建构字典

a = (['name','why'],['age',22.5])b = dict(a)print b            #{'age': 22.5, 'name': 'why'}

          或

a = dict(name='why',age=22.5)print a        #{'age': 22.5, 'name': 'why'}

      3）跟上面的不同在于使用fromkeys。需要提醒的是，这种方法是重新建立一个dict。

a = {}.fromkeys(('name','nickname'),'why')print a        #{'nickname': 'why', 'name': 'why'}

           需要提醒注意的是，在字典中的“键”，必须是不可变的数据类型；“值”可以是任意数据类型。列表是可变的，字符串和元组是不可变的。

a = {(1,2):1}print a#{(1,2):1}a = {[1,2]:1}print a#error

          接下来谈了访问dict的值。

          通过“键”能够增加dict中的“值”，通过“键”能够改变dict中的“值”，通过“键”也能够访问dict中的“值”。在dict中没有索引和切片，因为它没有顺序。

          dict的基本操作有以下几种：

         1. len(d)，返回字典(d)中的键值对的数量

         2. d[key]，返回字典(d)中的键(key)的值

         3. d[key]=value，将值(value)赋给字典(d)中的键(key)

         4. del d[key]，删除字典(d)的键(key)项（将该键值对删除） 

         5. key in d，检查字典(d)中是否含有键为key的项

a = {'num':1, 'name':'why', 'age':22.5}print len(a)        #3print a['name']        #whya['age']=22.6print a                #{'age': 22.6, 'num': 1, 'name': 'why'}del a['num']print 'num' in a    #FALSE

       对于dict的字符串格式化输出可采用如下方式：

a = {'num':1, 'name':'why', 'age':22.5}b = 'my name is %(name)s' % aprint b            #my name is why

       可将此技术应用在做网页的模板上。

       字典方法有如下几种：

       1）copy()：实现字典的拷贝。

            普通的赋值操作实际上没有重新开辟空间，改变一个另一个也跟着变。

a = {'num':1, 'name':'why', 'age':22.5}b = aprint id(a)            #31953784print id(b)            #31953784a['age'] = 22.6print b                #{'age': 22.6, 'num': 1, 'name': 'why'}

            然后通过copy函数的方法实现了拷贝。但python只存储基本类型的数据，比如int,str，对于不是基础类型的，比如字典的值是列表，python不会在被复制的那个对象中重新存储，而是用引用的方式，指向原来的值。在编程语言中，把实现上面那种拷贝的方式称之为“浅拷贝”。

a = {'num':1, 'name':'why', 'age':22.5, 'le':['z',21.5]}b = a.copy()print id(a)#differentprint id(b)#differenta['age'] = 22.6print a#{'num':1, 'name':'why', 'age':22.6,2:['z',21.5]}print b#{'num':1, 'name':'why', 'age':22.5,2:['z',21.5]}a['le'].remove(21.5)print a#{'num':1, 'name':'why', 'age':22.5,2:['z']}print b#{'num':1, 'name':'why', 'age':22.5,2:['z']}print id(a['num'])#differentprint id(b['num'])#differentprint id(a['le'])#sameprint id(b['le'])#same

           可用copy.deepcopy()深拷贝了一个新的副本，此时即使字典里有列表元素，也是实现了真正的拷贝。需要用import导入一个模块。

import copya = {'num':1, 'name':'why', 'age':22.5, 'le':['z',21.5]}b = copy.deepcopy(a)a['le'].remove(21.5)print a#{'num':1, 'name':'why', 'age':22.5,2:['z']}print b#{'num':1, 'name':'why', 'age':22.5,2:['z',21.5]}print id(a['num'])#differentprint id(b['num'])#differentprint id(a['le'])#differentprint id(b['le'])#different

       2）clear()：这是一个清空字典中所有元素的操作。这个和del有着很大的区别。del是将字典删除，内存中就没有它了，不是为“空”。

a = {'num':1, 'name':'why', 'age':22.5}a.clear()print a#{}del aprint a#Error

       3）get()：如果存在则返回对应的值，如果不存在默认返回空或在后面指定返回值（和直接获取的区别），但原字典不会改变。

a = {'num':1, 'name':'why', 'age':22.5}b = a.get('num')print b#1c = a.get('major')print c#Noned = a.get('major','computer science')print d#computer scienceprint a#{'num':1, 'name':'why', 'age':22.5}

         4）setdefault()：如果存在则返回对应的值，如果不存在就在原字典中增加对应的键值（后面不写默认增加值是空）。

a = {'num':1, 'name':'why', 'age':22.5}b = a.setdefault('num')print b#1a.setdefault('class')print a#{'num':1, 'name':'why', 'age':22.5, 'class':None}a.setdefault('major','computer science')print a#{'num':1, 'name':'why', 'age':22.5, 'class':None, 'major':'computer science'}

         5）items/iteritems, keys/iterkeys, values/itervalues：能够得到一个关于字典的列表，列表中的元素是由字典中的键和值/键/值组成的元组。iterxxx返回的是一个'dictionary-xxxiterator'类型，不过这种迭代器类型的数据不能直接输出，必须用list()转换一下，才能看到里面的真面目。

a = {'num':1, 'name':'why', 'age':22.5}print a.items()#[('age', 22.5), ('num', 1), ('name', 'why')]print a.keys()#['age', 'num', 'name']print a.values()#[22.5, 1, 'why']a_iter = a.iteritems()print type(a_iter)#<type 'dictionary-itemiterator'>print list(a_iter)#[('age', 22.5), ('num', 1), ('name', 'why')]

        6）pop()：D.pop(k[,d])是以字典的键为参数，删除指定键的键值对，当然，如果输入对应的值也可以，那个是可选的。返回的是键对应的值。值得注意的是，pop函数中的参数是不能省略的，这跟列表中的那个pop有所不同。如果要删除字典中没有的键值对，也会报错。

a = {'num':1, 'name':'why', 'age':22.5}print a.pop('num')#1print a#{'age': 22.5, 'name': 'why'}print a.pop()#Errorprint a.pop('major')#Error

        7）popitem()：跟list.pop()有相似之处，不用写参数（list.pop是可以不写参数），但是，D.popitem()不是删除最后一个，它是随机删除一个，并将所删除的返回，返回的数据格式是tuple。如果字典是空的，就要报错了。另外要注意是popitem而不是popitems，因为删除的是一组键值对。

a = {'num':1, 'name':'why', 'age':22.5}print a.popitem()#('age', 22.5)print a#{'num': 1, 'name': 'why'}print a.popitem()print aprint a.popitem()print aprint a.popitem()print a#Error

         8）update()：更新字典。这个函数没有返回值，或者说返回值是None。其参数可以是字典或者某种可迭代的数据类型。

a = {'num':1, 'name':'why', 'age':22.5}b = {'major':'computer'}a.update(b)print a#{'age': 22.5, 'num': 1, 'name': 'why', 'major': 'computer'}print b#{'major': 'computer'}

         9）has_key()：这个函数的功能是判断字典中是否存在某个键，跟前一节中遇到的k in D类似。

a = {'num':1, 'name':'why', 'age':22.5}print a.has_key('num')#Trueprint 'num' in a#True

         11.集合

         在已经学过的数据类型中：

         1）能够索引的，如list/str，其中的元素可以重复。

         2）可变的，如list/dict，即其中的元素/键值对可以原地修改。

         3）不可变的，如str/int，即不能进行原地修改。

         4）无索引序列的，如dict，即其中的元素（键值对）没有排列顺序。

         而集合（set）的特点是：有的可变，有的不可变；元素无次序，不可重复。

         对于集合的创建有两种方式：

         1）用set()创建。在创建集合的时候，如果发现了重复的元素，就会过滤一下，剩下不重复的。如果是str，就把str中的字符拆解开,形成set。

a = set("whyw")print a#set(['y', 'h', 'w'])b = set([1,'why',1])print b#set([1, 'why'])

              2）使用{ }创建。但是不提倡使用这种方式。因为在某些情况下，python搞不清楚是字典还是集合。

a = {1,'why'}print a#set([1, 'why'])b = {2,[1,'why'],22.5}print b#TypeError: unhashable type: 'list'

            集合的元素要是“可哈希”的。某数据“不可哈希”(unhashable)就是其可变，如list/dict，都能原地修改，就是unhashable。否则，不可变的，类似str那样不能原地修改，就是hashable（可哈希）的。利用set()建立起来的集合是可变集合，可变集合都是unhashable类型的。

       集合没有序列，不能用索引方式对其进行修改。

a = set("why")a[1] = 'z' print a#TypeError: 'set' object does not support item assignment

        但可分别用list()和set()能够实现两种数据类型之间的转化。

a = set("why")b = list(a)print b#['y', 'h', 'w']b[1] = 'z'print b#['y', 'z', 'w']

           下面谈到了set的一些方法。

        1）add()：向集合中添加元素。

a = {1,'why'}a.add(22.5)print a#set([22.5, 1, 'why'])a.add('[2,z]')print a#set([22.5, 1, 'why', '[2,z]'])

        2）update()：能够从另外一个set中合并过来元素。

a = {1,'why'}b = {2,'z'}a.update(b)print a#set([1, 2, 'z', 'why'])print b#set([2, 'z'])

           3）pop()：set.pop()是从set中任意选一个元素，删除并将这个值返回。但是，不能指定删除某个元素，即pop()不能有参数。如果set是空的了，那么也将报错。

a = {1,'why',22.5}a.pop()print a#set([1, 'why'])

          4）remove()：删除set中的指定元素，如果元素不存在则会报错。

a = {1,'why',22.5}a.remove('why')print a#set([22.5, 1])

        5）discard()：也是删除set中的指定元素，与remove不同的是如果元素不存在就不会报错，只是什么也不做。

      6）clear()：清空set。

a = {1,'why',22.5}a.clear()print a#set([])

          以set()来建立集合，这种方式所创立的集合都是可原处修改的集合，或者说是可变的，也可以说是unhashable。还有一种集合，不能在原处修改。这种集合的创建方法是用frozenset()，这种集合就是hashable类型——可哈希。

a = frozenset('why')a.add(1)print a#AttributeError: 'frozenset' object has no attribute 'ad

         判断集合A是否是集合B的子集，可以使用A<B，返回true则是子集，否则不是。另外，还可以使用函数A.issubset(B)判断。

a = set('why')b = set('w')print b<a#Trueprint b.issubset(a)#Trueprint a.issuperset(b)#True

         表达式是A | B，也可使用函数A.union(B)，得到的结果就是两个集合并集，注意，这个结果是新生成的一个对象，不是将结合A扩充。

a = set('why')b = set('w')print a | b#set(['y', 'h', 'w'])print a.union(b)#set(['y', 'h', 'w'])

        表达式是A & B，也可使用函数A.intersection(B)，得到的结果就是两个集合交集。

a = set('why')b = set('www')print a & b#set(['w'])print a.intersection(b)#set(['w'])

        表达式是A - B得到的结果就是A相对B的差（补），即A相对B不同的部分元素。

a = set('why')b = set('www')print a - b#set(['y', 'h'])

     表达式A.symmetric_difference(B)表示的A、B的对称差集，即A-B与B-A的差集。

     至此，前两章的内容已总结完毕。