Author:@南非波波

作者注：

经过第一天的学习以及后续的代码练习,给自己一个约定的代码风格、格式：
1. 模块名：
    模块应该使用尽可能短的、全小写命名，可以在模块命名时使用下划线以增强可读性。
    例如：
        login_shop.py
2. 类名定义：
    由于类名要求首字母必须大写，所以这样定义：
    class MyFristClass:  # 类名有三个单词组成，分别首字母大写
        def __init__(self,a):
            pass
3. 函数名定义：
    普通函数：
        选择使用字母小写，单词直接使用下划线_分割：
            shop_mag(users):
                pass
4. 变量名定义：
    全局变量名：
        字母全大写： SHOPLIST
    普通变量名：
        字母小写，单词分割选择使用首字母大写： shopUsers

以上规范并不是必须，但是作为个人的编程习惯而言，是一种很好的养成约束。

课程大纲地址： http://www.cnblogs.com/wupeiqi/articles/5115190.html

python知识拾忆：

Python2.x与Python3.x关于dict.keys()返回值的类型对比：

一、python种类

关于Python的一些版本内部执行的一些原理。从原理上来看待执行快慢的类型，从而选择自己需要的去学习。目前而言，最火的就是cpython了，这也是官方版本的Python。后面出现的pypy渐渐崭露头角，用银角大王的话讲：这货日后指定会火…

1. cpython  使用c解释器生产.pyc(字节码)，然后转换成机器码，最后到cpu
2. javapython java解释器-->字节码-->机器码-->cpu
3. IronPython C#解释器-->字节码 --> 机器码--> cpu
4. pypy  内部使用自己的解释器编译成字节码-->机器码.最后在外部执行的时候直接是机器码，速度要快

银角大王推荐阅读书：《python源码剖析》

二、字节码

在Python内部字节码直接的转换过程如图：

python中进行字节码之间的转换流程大概是这样的：字节码类型转换从utf-8转换成gbk类型，首先需要执行解码变成Unicode类型，然后再由Unicode类型编码成gbk类型。[图片来源：银角大王课堂笔记]

三、字符串

博客链接：http://www.cnblogs.com/songqingbo/p/5126957.html

字符串的常用操作包括但不限于以下操作：

字符串的替换、删除、截取、复制、连接、比较、查找、分割等

这里将对字符串的内置操作方法进行总结归纳，重点是以示例的方式进行展示。

使用type获取创建对象的类 type(name)
使用dir获取类的成员dir(name)
使用vars获取类的成员和各个成员的值

capitalize

功能：字符串首字母大写
name = 'swhthaitun'
name.capitalize()
返回结果：'Swht'

casefold()首字母小写

name = 'HelloWord'
reault = name.casefold()
print(reault)
返回结果：helloword

casefold

功能：将字符串中所有的大写字母转换成小写字母
s1 = "['bsondump', 'mongo', 'mongod', 'mongodump', 'mongoexport', 'mongofiles', 'mongoimport', 'mongooplog', 'mongoperf', 'mongoLLKJKKore', 'mongos', 'UUUngostat', 'monGGtop']"
s1.casefold()
返回结果："['bsondump', 'mongo', 'mongod', 'mongodump', 'mongoexport', 'mongofiles', 'mongoimport', 'mongooplog', 'mongoperf', 'mongollkjkkore', 'mongos', 'uuungostat', 'monggtop']"

center

功能：字符串宽度填充，使用原有字符串+填充字符构成指定长度的新的字符串
name = 'swhthaitun'
name.center(15)
返回结果：'   swhthaitun  ' #默认以空格进行填充
name.center(16,'*')
返回结果：'***swhthaitun***'

功能：字符串居中，以‘*’分割(20为新产生字符串的总的宽度)
name = 'HelloWord'
reault = name.center(20,'*')
print(reault)
返回结果：*****HelloWord******

count

功能：统计某个字符在字符串中出现的次数，或在字符串指定区间内完成上述操作
name = 'swhthaitun'
name.count('h')
返回结果：2
name.count('h',0,3)  #从索引值0-3范围的字符中统计'h'出现的次数
返回结果：1

功能：统计子序列出现的次数
name = 'HelloWord'
reault = name.count('W') #如果换成'w'，返回结果为0，python对大小写敏感
print(reault)
返回结果：1

name = 'HelloWord'
reault = name.count('l',0,3) #统计单个字符出现的次数,可以指定起始范围,另外在python中起始范围讲究顾头不顾尾的原则，即[0,3)
print(reault)

encode

功能：对字符串进行编码操作
name = 'swhthaitun'
name.encode()
返回结果：b'swhthaitun'

功能：转变字符串的编码
name = '南非波波'
reault = name.encode('gbk')
print(reault)
返回结果：b'\xc4\xcf\xb7\xc7\xb2\xa8\xb2\xa8'

endswith

功能：判断字符串是否以某个字符串结尾的，返回值为bool型
name = 'swhthaitun'
name.endswith('s')
返回结果：False
name.endswith('n')
返回结果：True
name.endswith('tun')
返回结果：True

name = 'Iamalatterboy'
reault = name.endswith('y')
print(reault)
返回结果：True

expandtabs

功能：将制表符'\t'转换成指定宽度的tab键分割，默认tabsize=8
li = 'sw\tht'
li.expandtabs(4)
返回结果：'sw  ht'
li.expandtabs()
返回结果：'sw      ht'

find

功能：在字符串中查找指定字符串，找不到时返回-1
name = 'swht'
name.find('s')
返回结果：0
name.find('h')
返回结果：2

format

功能：格式化输出字符串
li = 'I\'m {},{}' #两个'{}'是占位符
li.format('swht','欢迎来中国')
返回结果："I'm swht,欢迎来中国"
参考：http://blog.chinaunix.net/uid-23802873-id-4477364.html

__contains__

功能：包含 -->'eal' in name
name = 'swhtkkskjj'
reault = name.__contains__('swht')
print(reault)
返回结果：True

index

功能：在字符串中查找指定的字符串,找不到时直接报错
name = 'swhthaitun'
name.index('w')
返回结果：1    

join()

功能：字符串连接
name = 'swhthaitun'
'*'.join(name)
返回结果：'s*w*h*t*h*a*i*t*u*n'

isalnum

功能：检查判断字符串是否包含字母数字字符（http://www.yiibai.com/python/string_isalnum.html）
name = 'swhthaitun'
name.isalnum()
返回结果：True

isalpha

功能：检测字符串是否只由字母组成（http://www.runoob.com/python/att-string-isalpha.html）
name = 'swhthaitun'
name.isalpha()
返回结果：True

isdecimal

功能：检查字符串是否只包含十进制字符。这种方法只存在于unicode对象。（参考：http://www.runoob.com/python/att-string-isdecimal.html）
name = 'swhthaitun'
name.isdecimal()
返回结果：False

isdigit

功能：检测字符串是否只由数字组成。(参考:http://www.runoob.com/python/att-string-isdigit.html)
name = 'swhthaitun'
name.isdigit()
返回结果：False

isidentifier

功能：检测字符串是否是字母开头
name = 'swhthaitun'
name.isidentifier()
返回结果：True
name = '1swhthaitun'
name.isidentifier()
返回结果：False

isnumeric

功能：检测字符串是否只由数字组成。这种方法是只针对unicode对象。
name = 'swhthaitun'
name.isnumeric()
返回结果：False
Li = '5523'
Li.isnumeric()
返回结果：True

isprintable

功能：判断字符串中所有字符是否都属于可见字符
a = "\tPuppy"
a.isprintable()
返回结果：False
name = 'swhthaitun'
name.isprintable()
返回结果：True

isspace

功能：检测字符串是否为空格
name = 'swhthaitun'
name.isspace()
返回结果：False
Li = ' '
Li.isspace()
返回结果：True

istitle

功能：判断字符串是否适合当作标题（其实就是每个单词首字母大写）
a = "a puppy"
b = "Puppy"
a.istitle()
返回结果：False
b.istitle()
返回结果：True

isupper

功能：判断字符串中所有字母字符是否都是大写字母
a = "puppy"
b = "PUPPY"
a.isupper()
返回结果：False
b.isupper()
返回结果：True

ljust

功能：返回一个原字符串左对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。（参考：http://www.runoob.com/python/att-string-ljust.html）
语法：str.ljust(width[, fillchar])
     width -- 指定字符串长度。
     fillchar -- 填充字符，默认为空格。
name = 'swhthaitun'
name.ljust(50,'*')
返回结果：'swhthaitun****************************************'

lower

功能：将所有的字母转换成小写字母
name = 'SWHT'
name.lower()
返回结果：'swht'

lstrip

功能：去除字符串左边开头的空格
name = '  swht   '
name.lstrip()
返回结果：'swht   '

rstrip

功能：去除字符串右边结尾的空格
name = '  swht   '
name.rstrip()
返回结果：'   swht'

strip

功能：去除字符串两边的空格
name = '  swht   '
name.rstrip()
返回结果：'swht'

maketrans

功能：用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
注：两个字符串的长度必须相同，为一一对应的关系。
语法：str.maketrans(intab, outtab)
参数：intab -- 字符串中要替代的字符组成的字符串。
      outtab -- 相应的映射字符的字符串。
intab = "swhtr"
outtab = "12345"
name = "hjjksknsnjmk"
name.maketrans(intab, outtab)
返回结果：{104: 51, 114: 53, 115: 49, 116: 52, 119: 50}

partition

功能：根据指定的分隔符将字符串进行分割。
    如果字符串包含指定的分隔符，则返回一个3元的元组，第一个为分隔符左边的子串，第二个为分隔符本身，第三个为分隔符右边的子串。
name = 'swht'
li = 'hhsslswhtolljm'
li.partition(name)
返回结果：('hhssl', 'swht', 'olljm')

replace

功能：把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次。
语法：str.replace(old, new[, max])
参数：old -- 将被替换的子字符串。
     new -- 新字符串，用于替换old子字符串。
     max -- 可选字符串, 替换不超过 max 次
str = "this is string example....wow!!! this is really string"
str.replace("is", "was")
返回结果：'thwas was string example....wow!!! thwas was really string'
str.replace("is", "was", 3)
返回结果：'thwas was string example....wow!!! thwas is really string'

split

功能：字符串分割，默认是空格
name.split()
返回结果：['swht']
name.split('s') #以's'字符进行分割
返回结果：['', 'wht']

__add__

功能：在字符串后面增加指定的字符或字符串
name = 'swht'
name.__add__('e')
返回结果：'swhte'
li = 'hjh'
name.__add__(li)
返回结果：'swhthjh'

__contains__

功能：判断指定字符串是否包含在字符串中,返回值为True和False
name = 'swht'
name.__contains__('s')
返回结果：True

__eq__

功能：判断字符串是否相等，返回值为True和False
name = 'swht'
li = 'test'
name.__eq__(li)
返回结果：False        

splitlines

功能：按照行分隔，返回一个包含各行作为元素的列表，如果 num 指定则仅切片 num 个行.
语法：str.splitlines( num=string.count('\n'))
参数：num -- 分割行的次数
Li = "Line1-a b c d e f\nLine2- a b c\n\nLine4- a b c d"
Li.splitlines(0)
返回结果：['Line1-a b c d e f', 'Line2- a b c', '', 'Line4- a b c d']
Li.splitlines(1)
返回结果：['Line1-a b c d e f\n', 'Line2- a b c\n', '\n', 'Line4- a b c d']

startswith

功能：判断一个字符串是否以某个或几个字符开始，结果以True或者False返回。
name = "swhtlllds"
name.startswith('s')
返回结果：True

endswith

功能：判断一个字符串是否以某个或几个字符结束，结果以True或者False返回。
name = "swhtlllds"
name.endswith('ds')
返回结果：True

swapcase

功能：用于对字符串的大小写字母进行转换。
name = 'swht'
name.swapcase()
返回结果：'SWHT'
name = 'Swht'
name.swapcase()
返回结果：'sWHT'

upper

功能：将字符串中的小写字母转为大写字母
name = 'swht'
name.swapcase()
返回结果：'SWHT'

title

功能：进行标题转换,即单词首字母大写
name = 'swht ni li'
name.title()
返回结果： 'Swht Ni Li'

translate

功能：根据参数table给出的表(包含 256 个字符)转换字符串的字符, 要过滤掉的字符放到 del 参数中。
方法：str.translate(table[, deletechars]);
参数：table -- 翻译表，翻译表是通过maketrans方法转换而来。
     deletechars -- 字符串中要过滤的字符列表。
intab = "aeiou"
outtab = "12345"
trantab = maketrans(intab, outtab)

str = "this is string example....wow!!!";
print str.translate(trantab);
返回结果：th3s 3s str3ng 2x1mpl2....w4w!!!

zfill

功能：垫零左侧的字符串，以填补宽度
语法：str.zfill(width)
参数：width：最后的字符串宽度
str = "this is string example....wow!!!"        
print str.zfill(40)
print str.zfill(50)
返回结果：00000000this is string example....wow!!!
         000000000000000000this is string example....wow!!!

四、列表

博客链接：http://www.cnblogs.com/songqingbo/p/5126943.html

列表的基本操作示例展示：

append

功能：列表追加元素
name = ['sd','dfdf','drer']
name.append('sdsd')
返回结果：name
        ['sd', 'dfdf', 'drer', 'sdsd']

clear

功能：情况列表元素
name = ['sd','dfdf','drer']
name.clear()
返回结果：name
         []

copy

功能：浅拷贝，即只拷贝第一层的元素
name = ['sd','dfdf','drer']
li = ['ssd']
li = name.copy()
返回结果：li
         ['sd', 'dfdf', 'drer']

name = ['sd','dfdf','drer',['sddss','sdsdsd']]
li = ['ssd']
li = name.copy()
返回结果：li
['sd', 'dfdf', 'drer', ['sddss', 'sdsdsd']]

count

功能：统计列表指定元素个数
name = ['sd','dfdf','drer',['sddss','sdsdsd']]
name.count('sd')
返回结果：1
li = ['sd','sdsds',['sd','dffdg',],]
li.count('sd') #只统计第一层的元素个数
返回结果：1

extend

功能：追加字符元素或列表元素
name = ['sd','dfdf','drer',['sddss','sdsdsd']]
li = ['sd','sdsds',['sd','dffdg',],]
name.extend('ss')
返回结果：name
['sd', 'dfdf', 'drer', ['sddss', 'sdsdsd'], 's', 's']
name.extend('d')
返回结果：name
['sd', 'dfdf', 'drer', ['sddss', 'sdsdsd'], 's', 's', 'd']
name.extend(li)
返回结果：name
['sd', 'dfdf', 'drer', ['sddss', 'sdsdsd'], 's', 's', 'd', 'sd', 'sdsds', ['sd', 'dffdg']]

index

功能：定位列表中某元素
name = ['sd','dfdf','drer',['sddss','sdsdsd']]
name.index('sd')
返回结果：0
name.index('drer')
返回结果：2
返回结果：name.index('dr')  #当出现某元素不在列表中的时候会直接报错
        Traceback (most recent call last):
          File "<stdin>", line 1, in <module>
        ValueError: 'dr' is not in list

insert

功能：在指定索引位置的元素前面插入新的元素
name = ['sd','dfdf','drer',['sddss','sdsdsd']]
name.insert(3,'sd')
返回结果：name
['sd', 'dfdf', 'drer', 'sd', ['sddss', 'sdsdsd']]

pop

功能：删除指定索引值的元素,返回值为当前删除的元素的值。不指定索引值，默认删除最后一个元素
name = ['sd','dfdf','drer',['sddss','sdsdsd']]
name.pop(3)
返回结果：'sd'

remove

功能：删除列表中指定的元素
name = ['sd','dfdf','drer',['sddss','sdsdsd']]
name.remove('sd')
name
返回结果：['dfdf', 'drer', ['sddss', 'sdsdsd']]

reverse

功能：用于反向列表中元素。
name = ['sd','dfdf','drer',['sddss','sdsdsd']]
name.reverse()
name
返回结果：[['sddss', 'sdsdsd'], 'drer', 'dfdf', 'sd']

sort

功能：对单层列表进行元素的排序
name = ['sd','dfdf','drer',]
name.sort()
name
返回结果：['dfdf', 'drer', 'sd']

name = ['sd','dfdf','drer',['sddss','sdsdsd']]
name.sort() #报错的
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>

五、元组

关于元组的常用操作，请参考：http://www.runoob.com/python/python-tuples.html

博客链接：http://www.cnblogs.com/songqingbo/p/5126947.html

元组的元素不可修改 ，元组的元素的元素可修改

count(self,value)

功能：统计当前元组中某元素的个数
tup = (55,77,85,55,96,99,22,55,)
tup.count(55)
返回结果：3 
备注：元素‘55’在元组tup中出现了3次

index(self, value, start=None, stop=None)

功能：获取元素在元组中的索引值,对于重复的元素,默认获取从左起第一个元素的索引值
tup = (55,77,85,55,96,99,22,55,)
tup.index(55)
返回结果：0
tup.index(85)
返回结果：2
tup.index(55,2,7)
返回结果：3

__add__

功能：将另一个元组追加到当前元组后面.__add__()只接收元组类型的序列
tup1 = (12,33,566,78,)
tup2 = (55,66,77,)
tup1.__add__(tup2)
返回结果：(12,33,566,78,55,66,77,)

__contains__

功能：包含，判断某元素是否包含在元组中
tup = (55,77,85,55,96,99,22,55,)
tup.__contains__(55)
返回结果：True  
备注：返回值类型是bool型，该方法判断在对成员元素是否存在元组中，程序根据返回不同的bool值进行相应的值返回或者操作

__eq__

功能：判断两个元组是否相等，返回值类型为bool型
tup = (55,77,85,55,96,99,22,55,)
tup1 = (55,77,85,55,96,99,22,551,)
tup.__eq__(tup1)
返回结果：False

__getattribute__

pass

__getitem__

功能：获取指定索引值的元素值
tup = (55,77,85,55,96,99,22,55,)
tup.__getitem__(5)
返回结果：99

__getnewargs__

功能：只是获取原来的元组？？无卵用
tup = (55,77,85,55,96,99,22,55,)
tup.__getnewargs__()
返回结果：((55, 77, 85, 55, 96, 99, 22, 55),)

__ge__

功能：判断当前元组是否大于等于某个元组
tup = (55,77,85,55,96,99,22,55,)
tup1 = (55,77,85,55,96,99,22,551,)
tup.__ge__(tup1)
返回结果：False #bool类型

__gt__

功能：判断当前元组是否大于某个元组
tup = (55,77,85,55,96,99,22,55,)
tup1 = (55,77,85,55,96,99,22,551,)
tup.__ge__(tup1)
返回结果：False #bool类型

__hash__

功能：计算元组的hash值
tup = (55,77,85,55,96,99,22,55,)
tup1 = (55,77,85,55,96,99,22,551,)
tup.__hash__()
返回结果：-2123087613
tup1.__hash__()
返回结果：1338854611

__init__

功能：初始化作用，无返回值

__iter__

功能：获取元组的内存地址
tup = (55,77,85,55,96,99,22,55,)
tup1 = (55,77,85,55,96,99,22,551,)
tup.__iter__()
返回结果：<tuple_iterator object at 0x01C21F70>
tup1.__iter__()
返回结果：<tuple_iterator object at 0x01C21F50>

__len__

功能：获取元组的长度
tup.__len__()  #该方法已经被放到python的内置函数中，可以使用len(tup)获取长度
返回结果：8

__le__

功能：判断当前元组是否小于等于某个元组
tup = (55,77,85,55,96,99,22,55,)
tup1 = (55,77,85,55,96,99,22,551,)
tup.__le__(tup1)
返回结果：True #bool类型

__lt__

功能：判断当前元组是否小于某个元组
tup = (55,77,85,55,96,99,22,55,)
tup1 = (55,77,85,55,96,99,22,551,)
tup.__lt__(tup1)
返回结果：True #bool类型

__mul__

功能：把当前元组按照某个值的倍数进行元组的扩展，产生新的元组
tup = (55,77,85,55,96,99,22,55,)
tup.__mul__(2)
返回结果：(55, 77, 85, 55, 96, 99, 22, 55, 55, 77, 85, 55, 96, 99, 22, 55)
tup.__iter__()
返回结果：<tuple_iterator object at 0x01C21F70>
tup.__mul__(2).__iter__()
返回结果：<tuple_iterator object at 0x01C2F050>

__new__

pass

__ne__

功能：判断当前元组不等于某个元组
tup = (55,77,85,55,96,99,22,55,)
tup1 = (55,77,85,55,96,99,22,551,)
tup.__ne__(tup1)
返回结果：True #bool类型

__repr__

功能：将元组转换成一个字符串
tup = (55,77,85,55,96,99,22,55,)
tup.__repr__()
返回结果：'(55, 77, 85, 55, 96, 99, 22, 55)'
 type(tup.__repr__())
返回结果：<class 'str'>

__rmul__

功能：？？怎么感觉跟__mul__一个德行？？
tup = (55,77,85,55,96,99,22,55,)
tup.__rmul__(2)
返回结果：(55, 77, 85, 55, 96, 99, 22, 55, 55, 77, 85, 55, 96, 99, 22, 55)

六、字典

博客链接：http://www.cnblogs.com/songqingbo/p/5127044.html

字典的常用操作：

clear

功能：清空字典
dict_li = {'users':'swht','age':'18',}
dict_li.clear()
返回结果：dict_li
        {}

copy

功能：浅拷贝
dict_li = {'users':'swht','age':'18',}
dict_li.copy()
返回结果：{'age': '18', 'users': 'swht'}
dict_li = {'users':'swht','age':'18','address':{'sd':'dz'}}
dict_li.copy()
返回结果：{'age': '18', 'users': 'swht', 'address': {'sd': 'dz'}}

fromkeys()

功能：用于创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值。
语法：dict.fromkeys(seq[, value]))
参数：seq -- 字典键值列表。
     value -- 可选参数, 设置键序列（seq）的值。
li = ['users','age']
dict_li = dict.fromkeys(li,'swht')
返回结果：dict_li
        {'age': 'swht', 'users': 'swht'}

get

功能：获取字典的value值
dict_li = {'users':'swht','age':'18',}
dict_li.get('users')
返回结果：'swht'

items

功能：返回可遍历的(键, 值) 元组数组
dict_li = {'users':'swht','age':'18',}
dict_li.items()
返回结果：dict_items([('age', '18'), ('users', 'swht')])

keys

功能：获取字典可遍历的键
dict_li = {'users':'swht','age':'18',}
dict_li.keys()
返回结果：dict_keys(['age', 'users'])

pop

功能：删除字典中指定的键值
dict_li = {'users':'swht','age':'18',}
dict_li.pop('age')
返回结果：'18'

popitem

功能：随机返回并删除字典中的一对键和值
dict_li = {'users':'swht','age':'18',}
dict_li.popitem()
返回结果：('age', '18')
dict_li
{'users': 'swht'}

setdefault

功能：查找键值，如果键不已经存在于字典中，将会添加键并将值设为默认值。
dict_li = {'users':'swht','age':'18',}
dict_li.setdefault('ID',5)
返回结果：5
dict_li
返回结果：{'age': '18', 'users': 'swht', 'ID': 5}

update

功能：把指定字典的键值更新到当前字典中
dict_li = {'users':'swht','age':'18',}
dict_ai = {'address':'山东'}
dict_li.update(dict_ai)
dict_li
返回结果：{'age': '18', 'users': 'swht', 'address': '山东'}

values

功能：获取字典的所有值
dict_li = {'age': '18', 'users': 'swht', 'address': '山东'}
dict_li.values()
返回结果：dict_values(['18', 'swht', '山东'])

七、set集合

博客链接：http://www.cnblogs.com/songqingbo/p/5128066.html

set集合是一个无序且不重复的集合。
创建一个set集合：
    name = set('sdd')
    name
    返回结果：{'d', 's'}

add

功能：增加集合元素
name = {'d', 's'}
name.add('d')
name
返回结果：{'d', 's'}
name.add('sd')
name
返回结果：{'sd', 'd', 's'}

clear

功能：清空集合元素
name = {'d', 's'}
name.clear()
name
返回结果：{}

copy

功能：浅拷贝
name = {'sd', 'd', 's'}
li = name.copy()
返回结果：li
        {'sd', 'd', 's'}

difference

功能：取差集
name = {'sd', 'd', 's'}
li = set()
name.difference(li)
返回结果：name.difference()
{'sd', 'd', 's'}

difference_update

功能：删除当前set中的所有包含在 new set 里的元素
li = ('s', 'd')
name = {'sd', 'd', 's'}
name.difference_update(li)
name
返回结果：{'sd'}

discard

功能：移除元素
name = {'sd', 'd', 's'}
name.discard('s')
返回结果：name 
        {'sd', 'd'}

intersection

功能：取交集,建立新的set集合
li = ('s', 'd')
name = {'sd', 'd', 's'}
name.intersection(li)
返回结果：{'d', 's'}

intersection_update

功能：取交集,更新原来的set集合
li = ('s', 'd')
name = {'sd', 'd', 's'}
name.intersection_update(li)
返回结果：{'d', 's'}

isdisjoint

功能：判断没有交集，返回True,否则,返回False
li = {'s', 'd'}
name = {'sd', 'd', 's'}
name.isdisjoint(li)

issubset

功能：判断是否是子集
li = {'s', 'd'}
name = {'sd', 'd', 's'}
name.issubset(li)  #判断name是不是li的子集
返回结果：False
li.issubset(name)  #判断li是不是name的子集
返回结果：True

issuperset

功能：判断是否是父集
li = {'s', 'd'}
name = {'sd', 'd', 's'}
name.issuperset(li)  #判断name是不是li的父集
返回结果：True
li.issuperset(name)  #判断li是不是name的父集
返回结果：False

pop

功能：移除集合元素
name = {'sd', 'd', 's'}
name.pop()
返回结果：'sd' #随机删除集合元素
se1 = {'a','s','sb'}
se1.pop()
返回结果：'sb'

remove

功能：移除指定集合元素
name = {'sd','d','s'}
name.remove('s')
返回结果：name
{'sd', 'd'}

symmetric_difference

功能：去两个集合的差集，建立新的set集合对象
name = {'sd', 'd', 's'}
li = {'s', 'd'}
name.symmetric_difference(li)
返回结果：{'sd'}

symmetric_difference_update

功能：去两个集合的差集，更新原来的集合对象
name = {'sd', 'd', 's'}
li = {'s', 'd'}
name.symmetric_difference_update(li)
返回结果：{'sd'}

union

功能：并集，创建新的对象
name = {'sd', 'd', 's'}
li = {'s', 'd','h'}
name.union(li)
返回结果：{'h', 's', 'd', 'sd'}

update

功能：更新已有集合
name = {'sd', 'd', 's'}
name.update('df')
name
返回结果：{'sd', 'd', 'f', 's'}

八、类与对象

对象

python中一切事物皆对象,对象是一开始就有的,只是我们无法访问它。访问对象需要以变量的形式去访问（即创建变量指向到对象的，变量即对对象的引用）
在python中，一个对象的特征也称为属性（attribute）。它所具有的行为也称为方法（method）
结论：对象=属性+方法

类

在python中，把具有相同属性和方法的对象归为一个类（class）
比如人类，动物，植物等等，这些都是类的概念。 
类是对象的模板或蓝图，类是对象的抽象化，对象是类的实例化。类不代表具体的事物，而对象表示具体的事物。
类包含描述对象的方法。

int

取绝对值：
    age = -19
    age.__abs__() #int类函数调用
    abs(-19) #内置函数方式操作
取商和余数：
    age = 95
    age.__divmod__(10) #95/10 -->(9,5)
相加：
    a = 5，b=6
    a.__add__(b) #调用int的类函数add，相当于a + b  -->11
    a + b #内置函数方式操作

作业：

1. 博客整理
2. 购物商城实现
    1. 商品展示，价格
    2. 购物车添加商品（进行差异商品，同一种商品应该只存在一条数据）
    3. 付款（根据钱进行判断是否可以满足付款）
3. 预习
    http://www.cnblogs.com/wupeiqi/articles/5115190.html  后面的部分