Python数据类型方法精心整理，不必死记硬背，看看源码一切都有了

Python认为一切皆为对象；比如我们初始化一个list时：

li = list('abc')

实际上是实例化了内置模块builtins（python2中为__builtin__模块）中的list类；

class list(object):

    def __init__(self, seq=()): # known special case of list.__init__
        """
        list() -> new empty list
        list(iterable) -> new list initialized from iterable's items
        # (copied from class doc)
        """
        pass

验证：

In [1]: li = list('abc')

In [2]: li.__class__
Out[2]: list

In [3]: li.__class__.__name__
Out[3]: 'list'

1. Python对象特性

python使用对象模型来存储数据。构造任何类型的值都是一个对象。所有python对象都拥有三个特性：身份、类型、值：

1）身份：每个对象都有一个唯一的身份标识自己，任何对象的身份可以使用内建函数 id() 来得到。

2）类型：对象的类型决定了该对象可以保存什么类型的值，可以进行什么样的操作，以及遵循什么样的规则。可以使用 type() 函数查看python对象的类型。type()返回的是对象而不是简单的字符串。

3）值：对象表示的数据。

python不需要事先声明对象类型，当python运行时，会根据“=“右侧的数据类型来确定变量类型；

2.Python对象类型

（1）标准类型（基本数据类型）

a) .数字（分为几个字类型，其中三个是整型）

• 　　Integer  整型
• 　　Boolean  布尔型
• 　　Long integer  长整型
• 　　Floating point real number  浮点型
• 　　Complex number 复数型

b) String 字符串

c) List 列表

d) Tuple 元祖

e) Dictionary 字典

（2）其他内建类型

类型、Null对象（None）、文件、集合/固定集合、函数/方法、模块、类

3. 基本对象类型分类

有3种不同的模型可以帮助我们对基本类型进行分类

1）存储类型

一个能保存单个字面对象的类型，称为原子或标量存储；可以容纳多个对象的类型，称为容器存储；并且所有的python容器对象都可以容纳不同类型的对象；

注意，python没有字符类型，所以虽然字符串你看上去像容器类型，实际是原子类型

2）更新模型（是否可变）

这里所说的是否可变，可更新是针对的对象的值而言的；是在对象身份不变的情况下（id不变），值是否可更新；

s = 'abc'
print('id of s: ', id(s))
s = 'xyz'
print('id of s: ', id(s))

结果：

id of s:  41643960
id of s:  46319184

上例中，很多人会说s是字符串，也可变啊，但是注意，这里s指向的对象发生了变化（id值发生了变化），所以这不是我们所说的可更新；让我们看一下list

li = ['a', 'b']
print('li before update', li)
print('id of li: ', id(li))
li[0] = 'x'
print('li after update', li)
print('id of li: ', id(li))

结果：

li before update ['a', 'b']
id of li:  48447304
li after update ['x', 'b']
id of li:  48447304

li的值发生了变化，但是li还是原来的对象（id值不变）

另外，对于元祖，元祖本身不可变，但是当元祖存在可变元素时，元祖的元素可变，比如

t = (1, ['a','b'])
print('t before update', t)
print('id of t: ', id(t))
t[1][0] = 'x'
print('t after update', t)
print('id of t: ', id(t))

结果：

t before update (1, ['a', 'b'])
id of t:  48328968
t after update (1, ['x', 'b'])
id of t:  48328968

注意：在使用for循环来遍历一个可更新对象过程中，增加删除可更新对象容器的大小会得到意想不到的结果（不期望的结果）甚至出现异常，其中对于字典，直接报错；

直接遍历列表：

lst = [1, 1, 0, 2, 0, 0, 8, 3, 0, 2, 5, 0, 2, 6]

for item in lst:
    if item == 0:
        lst.remove(item)
print(lst)    #结果为 [1, 1, 2, 8, 3, 2, 5, 0, 2, 6]

遍历索引：

lst = [1, 1, 0, 2, 0, 0, 8, 3, 0, 2, 5, 0, 2, 6]

for item in range(len(lst)):
    if lst[item] == 0:
        del lst[item]
print(lst)    #结果为IndexError: list index out of range

字典：

dct = {'name':'winter'}
for key in dct:
    if key == 'name':
        di['gender'] = 'male'
print(dct)        #结果报错RuntimeError: dictionary changed size during iteration

for循环来遍历可变对象时，遍历顺序在最初就确定了，而在遍历中如果增加删除了元素，更新会立即反映到迭代的条目上，会导致当前索引的变化，这样一是会导致漏删或多增加元素，二是会导致遍历超过链表的长度。那么有解决方案吗？

a) 通过创建一个新的可变对象实现，比如：

b) 通过while循环

#通过创建新的copy
for item in lst[:]:
    if item == 0:
        lst.remove(item)
print (lst)
#通过while循环
while 0 in lst:
    lst.remove(0)
print (lst)

更多的内容，看我关于“迭代器”的博客

3）访问模型

序列是指容器内的元素按从0开始的索引顺序访问；

字典的元素是一个一个的键值对，类似于哈希表；通过获取键，对键执行一个哈希操作，根据计算的结果，选择在数据结构的某个地址中存储你的值。任何一个值的存储地址取决于它的键；所以字典是无序的，键必须是不可变类型（对于元祖，只能是元素不可变的元祖）

总结：

 

 既然字符串，列表，元祖，字典都是对象，那么任何一种实例化的对象都会有相同的方法，下面让我们来依次来认识这些常见的数据类型：

4. 字符串

1）创建字符串

两种方式：

#直接创建字符串引用
s = 'winter'
#通过使用str()函数创建
s = str(123)

2）字符串方法

作为内建对象，字符串类的定义在内建模块builtins中，通过源码可以查看到所有字符串方法；如果你在用pycharm，那么更加方便，选中str类以后，点击按钮"Scroll from Source"；就可以看到所有方法的列表；

针对每一种方法都有详细的方法文档；在这里吐血一一罗列出，有的注释部分很重要：

'''字符串方法'''

#index，字符串查找，返回第一个匹配到的索引值，没有就报错，可以提供开始，结束位置
s = 'xyzabc'
ret = s.index('za') #结果为2
ret = s.index('z',2)    #结果为2
#rindex，反向查找，结果和index方法得到的结果一样
#find，也是字符串查找，与index不同的是找不到时，不会报错，而是返回-1，注意bool(-1)为True


#split，字符串分隔，如果不指定分割符，则默认采用任意形式的空白字符：空格，tab（	），换行(
)，回车(
)以及formfeed
res = 'a b    c   d
e'.split()       #结果res为['a', 'b', 'c', 'd', 'e']
res = 'a:b:c:d'.split(':')          #结果为['a', 'b', 'c', 'd']
#rsplit，从字符串尾部开始分割，没有设置maxsplit参数时和split的结果一样
#splitlines用于将多行字符串，列表的每个元素为一行字符串，默认不带换行符


#partition，类似于s.split(sep, 1)，只是输出是一个包括了sep的元祖，且没有默认分隔符sep
res = 'a:b:c:d'.partition(':')  #结果为('a', ':', 'b:c:d')
#rpartition，从字符串末尾开始执行partition方法
res = 'a:b:c:d'.rpartition(':') #结果为('a:b:c', ':', 'd')


#strip，去掉字符串两端的字符，如果没指定字符，则默认去掉任意形式的空白字符：空格，tab（	），换行(
)，回车(
)以及formfeed
res = 'abcd'.strip('a')     #结果res为'bcd'
res = ' abcd   
'.strip()  #结果res为'abcd'，可以通过len(res)验证
#rstrip，去掉右端的字符
#lstrip，去掉左端的字符


#join，字符串拼接
#format，字符串格式化
#解决万恶的‘+’号，每次'+'操作都会创建一个新的对象，就需要在内存空间开辟一块新的区域来存储；所以大量使用'+'会浪费内存空间
#解决方法1，使用join
#join，字符串拼接
li = ['a', 'b']
res = ':'.join(li)      #使用字符串来拼接一个可迭代对象的所有元素，结果res为'a:b'
#解决方法2，使用format，有两种方式：
#方式1，其中{0}可以简写为{}:
res = 'my name is {0}, my age is {1}'.format('winter',30)   #{0},{1}为实参的索引
#方式2：
res = 'my name is {name}, my age is {age}'.format(name='winter', age=30)
#或者直接下面这样
userInfo = {'name':'winter','age':30}
res = 'my name is {name}, my age is {age}'.format(**userInfo)
#或者用format_map(python3.x新增）
userInfo = {'name':'winter','age':30}
res = 'my name is {name}, my age is {age}'.format_map(userInfo)
#解决方法3，除了format以外，还可以使用占位符%，看上去没那么高级，同样有两种方式
#方式1
res = 'my name is %s, my age is %s'%('winter',30)
#方式2
userInfo = {'name':'winter','age':30}
res = 'my name is %(name)s, my age is %(age)s'%userInfo
#结果为'my name is winter, my age is 30'

#replace，字符串替换，因为字符串为不可变数据类型，所以原字符串不会改变，改变的字符串以返回值形式返回
s = '123xyz'
ret = s.replace('1','a')    #结果s不变，ret为'a23xyz'
ret = s.replace('12', 'ab') #结果为'ab3xyz'


#maketrans和translate，一对好基友；用于字符串替换和删除，很好用，python2.x与python3.x语法不同
#maketrans用于创建翻译表，translate用于翻译表
s = 'abccba'
trans_table = str.maketrans('ab','12','c')
res = s.translate(trans_table)  #结果为'1221'，注意与replace的区别


s.count(strings)   #count，统计字符串中字符的数目


s.encode()      #以某种编码格式编码，比如utf-8


#大小写切换类方法
s = 'aBcD'
res = s.capitalize()    #首字母大写，结果res为'Abc'
res = s.lower()         #所有字母小写，结果res为'abcd',注意仅对ASCII编码的字母有效
res = s.casefold()      #所有字母小写，结果res为'abcd',注意对unicode编码的字母有效
res = s.upper()         #所有字母大写，结果res为'ABCD'
res = s.swapcase()      #字符串中大小写互换，结果res为'AbCd'
s = 'aB cD,ef'
res = s.title()         #每个单词首字母大写，结果res为'Ab Cd,Ef'，其判断“单词”的依据则是基于空格和标点


#字符串判断类方法，以下方法除了isspace()以外，对于空字符串都返回False
s.isalpha()      #判断字符串是否全为字母，等价于^[a-zA-Z]+$
s.islower()      #判断字符串中字母部分是否全为小写字母，可以有其他字符，但是至少要有一个小写字母，等价于[a-z]+
s.isupper()      #判断字符串中字母部分是否全为小写字母，可以有其他字符，但是至少要有一个小写字母，等价于[A-Z]+
s.istitle()      #判断字符串首字母是否全为大写，可以有其他字符
s.isnumeric()    #判断字符串是否全为数字（包括unicode数字，罗马数字，汉字数字）
s.isdigit()       #也是判断字符串是否全为数字（包括unicode数字，罗马数字）
s.isdecimal()    #判断字符串是否全为十进制数字（包括unicode数字）
s.isalnum()      #判断字符串是否为数字与字母的组合，等价于^[0-9a-zA-Z]+$
s.isidentifier()    #判断标识符是否合法
s.isspace()     #判断是否为任意形式的空白字符：空格，tab（	），换行(
)，回车(
)以及formfeed
s.isprintable() #判断字符串是否可打印
s.startswith(strings)  #判断字符串是否以某个字符串开头
s.endswith(stings)  #判断字符串是否以某个字符串结尾


#center，ljust，rjust，zfill字符串排版，填充
s = '123'
res = s.center(50,'-')  #center是字符串居中，结果为-----------------------123------------------------
#ljust为居左，rjust为居右，zfill使用0来左填充


s.expandtabs()  #expandtables，用于将字符串中的tab字符转换为空格，如果没有指定tabsize，默认为8个

5. 列表

1）创建列表

三种方式：

a = ['a','b','c']   #直接创建
b = list('abc')     #通过创建list实例创建，结果为['a','b','c']
c = [x for x in range(4)]　　#列表推导式，结果为[1,2,3,4]

注意，第二种方法，我们来看一下它的构造函数：

    def __init__(self, seq=()): # known special case of list.__init__
        """
        list() -> new empty list
        list(iterable) -> new list initialized from iterable's items
        # (copied from class doc)
        """
        pass

接收的参数是一个可迭代对象，即拥有__iter__方法的对象，元祖，集合和字典的构造函数的参数都是可迭代对象；

第三种方法称为列表推导式，语法为

[expr for iter_var in iterable]     #迭代iterable里所有内容，每一次迭代，都把iterable里相应内容放到iter_var中，再在表达式中应用该iter_var的内容，最后用表达式的计算值生成一个列表。

扩展形式

[expr for iter_var in iterable if cond_expr]    #加入了判断语句

2）列表方法

与查看字符串方法类似，可以通过源码查看，这里也一一罗列出：

#增，append，insert，extend
#追加append
li = ['a','b','c']
li.append('d')  #结果li = ['a','b','c','d']，list是可变类型，所以li元素的增加删除会影响源列表
#插入insert
li = ['a','b','c']
li.insert(1,'d')    #结果li = ['a','d','b','c']
#extend，将一个可迭代对象增加追加到列表里
li = ['a','b','c']
li.extend(['x','y'])    #结果li = ['a','b','c','x','y']
li.extend(('m','n'))    #结果li = ['a', 'b', 'c', 'x', 'y', 'm', 'n']


#删，remove，pop，clear
#remove，删除第一个与参数值相等的元素，删除不存在的元素报ValueError
li = ['a','b','c','a']
li.remove('a')  #结果li =  ['b', 'c', 'a']
#pop，参数为索引值，弹出对应索引值的元素，返回值为弹出的元素，默认为弹出最后一个元素，索引不存在报IndexError
li = ['a','b','c','a']
res = li.pop(1)   #结果res = ‘b'，li = ['a', 'c', 'a']
#clear，清空列表，但是列表对象依然存在，没有被回收
li = ['a','b','c','a']
li.clear()  #结果li = []


#查，count，index
#count，统计列表内元素个数
li = ['a','b','c','a']
res = li.count('a') #结果res = 2
#index，查找元素对应的索引值，不存在报ValueError
li = ['a', 'b', 'c', 'a']
res = li.index('a')   #结果res = 0


#reverse，反转
li = ['a','b','c']
li.reverse()    #结果li = ['c','b','a']


#sort，根据key排序，默认从小到大，同样可以实现反转
li = ['c','b','a']
li.reverse()    #结果li = ['a', 'b', 'c']
li = [[4,5,6], [7,2,5], [6,1,8]]
li.sort(key=lambda x:x[1])  #结果li =  [[6, 1, 8], [7, 2, 5], [4, 5, 6]]，根据li元素的第二个值进行排序


#copy，浅复制，注意与赋值和深复制的区别
li = [[1,2,3], 'a']
li_new = li.copy()
li_new[0][0] = 4    #li_new = [[4, 2, 3], 'a']，但是li也发生了变化li = [[4, 2, 3], 'a']
li_new[1] = 'b'     #li_new =  [[1, 2, 3], 'b']，但是li不变，[[1, 2, 3], 'a']

6. 元祖

1）创建元祖

两种方式：

t = (1,2,3)     #直接创建
t = tuple([1,2,3])  #通过tuple函数创建，参数为可迭代对象，结果为(1,2,3)

2）元祖方法

和字符串，一样，通过源码查看，这里一一列出：

#count，统计元祖内元素个数
t = (1,2,3,1)
res = t.count(1)      #结果res = 2


#index，查找元素对应的索引值，不存在报ValueError
t = (1,2,3,1)
res = t.index(1)      #结果res = 0

元祖的方法很少，而且元祖对象是不可变的，元组不可变的好处。保证数据的安全，比如我们传数据到一个不熟悉的方法或者数据接口， 确保方法或者接口不会改变我们的数据从而导致程序问题。

注意，因为()处理用于定义元祖，还可以作为分组操作符，比如if ( a> b) and (a < c)中的()，且python遇到()包裹的单一元素，首先会认为()是分组操作符，而不是元组的分界符，所以一般我们对于元组，会在)之前再加入一个,

a = (1,2,3,)

3) 列表vs元组

使用不可变类型变量的情况：如果你在维护一些敏感数据，并且需要把这些数据传递给一个不了解的函数（或一个根本不是你写的API），作为一个只负责一个软件某一部分的工程师，如果你希望你的数据不要被调用的函数篡改，考虑使用不可变类型的变量；

需要可变类型参数的情况：管理动态数据集合时，你需要先创建，然后渐渐地不定期地添加，或者有时需要移除一些单个的元素，这时必须使用可变类型对象；将可变类型变量作为参数传入函数，在函数内可以对参数进行修改，可变类型变量也会相应修改；

7. 序列共有特性

字符串，列表，元祖统称序列，是可以顺序访问的；他们的关系和共有特性如下：

1）相互转换

2）序列操作符

a）根据索引取值，可以正向索引，也可以反向索引

li = [1,2,3,4]
res = li[0]   #结果为1
res = li[-1]    #结果为4
li[1] = ['a']    #结果li = [1,'a',3,4]

b）切片

seq[ind1:ind2:step]，原则是顾头不顾尾

li = [1,2,3,4]
res = li[:]     #结果为[1, 2, 3, 4]
res = li[1:]    #结果为[2,3,4]
res = li[:-2]   #结果为[1,2]
res = li[1:3]   #结果为[2,3]
res = li[::2]   #取索引值为偶数的元素[1,3]，对应的li[1::2]为取索引值为基数的元素
res = li[::-1]  #步进为-1，结果为[4, 3, 2, 1]
res = li[-1:-3:-1]  #结果为[4,3]
res = li[3:1:-1]    #结果为[4,3]
res = li[1:1]       #结果为[]
li[1:2] = ['a','b'] #结果li = [1, 'a', 'b', 3, 4]
li[1:1] = [9]   #结果li = [1, 9, 'a', 'b', 3, 4]，相当于插入

注意序列不能读写不存在的索引值，但是切片可以

li = [1,2,3]
li[9]    #报IndexError
li[1:9]    #结果为[2,3]
li[8:9] = [9]    #结果为[1,2,3,9]

 c）重复操作符*

[1]*3    #结果为[1,1,1]
[1,2,3]*3    #结果为[1, 2, 3, 1, 2, 3, 1, 2, 3]

d）连接操作符+

 [1,2,3]+[4,5,6]    结果为 [1, 2, 3, 4, 5, 6]

e）成员关系操作符in, no in

li = [1,2,3]
1 in li     #结果为True
4 not in li #结果为True

f）删除序列对象，元素关键字del

 l = [1,2,3]
del l[0]    #结果l为[2,3]
del l    #结果访问l后，报NameError

3）可操作内建函数

#enumerate，枚举
li = ['a','b','c']
for item in enumerate(li):
    print(item)
'''
结果为：
(0, 'a')
(1, 'b')
(2, 'c')
'''
for item in enumerate(li,5):
    print(item)
'''
结果为：
(5, 'a')
(6, 'b')
(7, 'c')
'''


#len
len([1,2,3])    #结果为3
len([[1,2],[3,4]])  #结果为2


#max, min
max([1,2,3])    #结果为3
min([1,2,3])    #结果为1


#sorted，注意与list.sort()方法的区别
li = [[1,4],[2,3],[3,2]]
res = sorted(li, key=lambda x:x[1])     #结果res为[[3, 2], [2, 3], [1, 4]]


#zip，和倒置有点像
l1 = [1,2,3]
l2 = [1,2,3]
for item in zip(l1,l2):
    print(item)
'''
结果为：
(1, 1)
(2, 2)
(3, 3)
'''
l1 = [1,2,3]
l2 = [1,2]
for item in zip(l1,l2):
    print(item)
'''
结果为：
(1, 1)
(2, 2)
'''

8. 字典

字典是Python语言中唯一的映射类型。映射对象类型里哈希值（键，key）和指向的对象（值，value）是一对多的关系；

特性：

a）字典是无序的可变的容器类型

b）字典的键是唯一的，且必须是不可变类型，如果是元组，要求元组的元素也不可变（因为值的内存地址与键的哈希值有关）

1）创建字典

#直接创建
d = {
    'name':'winter',
    'age':18,
    'hobbies':['basketball','football']
}

#通过dict函数创建，参数为可迭代对象，字典或列表组成的任意形式；[(),()]或((),())或([],[])或[[],[]]或使用dict(zip())
d = dict([('name', 'winter'),
          ('age',18),
          ('hobbies',['basketball','football'])]) #结果为{'age': 18, 'hobbies': ['basketball', 'football'], 'name': 'winter'}

#通过字典推导式
d = {x:y for x, y in zip(['name','age','hobbies'],['winter',18,['basketball','football']])} #结果为{'age': 18, 'hobbies': ['basketball', 'football'], 'name': 'winter'}
d = {x:y for x, y in zip(['name','age','hobbies'],['winter',18,['basketball','football']]) if x=='name'}#结果为{'name': 'winter'}

#通过字典方法fromkeys()创建一个含有默认值的字典，fromkeys方法是dict类的静态方法
d = dict.fromkeys(['name','gender'], 'unknown') #结果{'gender': 'unknown', 'name': 'unknown'}

2）字典方法

#增
d = {
    'name':'winter',
    'age':18,
    'hobbies':['basketball','football']
}
#update，类似于list.extend()，将键值对参数加到字典中，对于已存在的更新
d.update({'gender':'male'}) #结果为：{'age': 18, 'gender': 'male', 'hobbies': ['basketball', 'football'], 'name': 'winter'}


#删
d = {
    'name':'winter',
    'age':18,
    'hobbies':['basketball','football']
}
#popitem，随机删除一组键值对，并返回该组键值对
res = d.popitem()   #结果为res = ('hobbies', ['basketball', 'football'])， d为{'age': 18, 'name': 'winter'}
#pop，删除指定键的键值对，返回对应的值
res = d.pop('name') #结果为res = 'winter', d为{'age': 18}
#clear，清空字典，字典对象还在，没有被回收
d.clear()   #结果d为{}
#del关键字，可以用于删除字典对象和元素
d = {
    'name':'winter',
    'age':18,
    'hobbies':['basketball','football']
}
del d['hobbies']   #结果为 {'age': 18, 'name': 'winter'}
del d   #结果访问d，报NameError


#查
d = {
    'name':'winter',
    'age':18,
    'hobbies':['basketball','football']
}
#get，根据键取对应的值，没有对应的键，就返回第二个参数，默认为None
res = d.get('name', 'not found')   #res = ’winter'
res = d.get('gender', 'not found')    #res = 'not found'
#setdefault，根据键取对应的值，如果不存在对应的键，就增加键，值为第二个参数，默认为None
res = d.setdefault('name','winter')   #res = ’winter'
res = d.setdefault('gender','male')   #res = 'male',d变为{'age': 18, 'gender': 'male', 'hobbies': ['basketball', 'football'], 'name': 'winter'}
#keys，获得所有的键
res = d.keys()    #res = dict_keys(['name', 'age', 'hobbies', 'gender'])
#values，获得所有的值
res = d.values()    #res = dict_values(['winter', 18, ['basketball', 'football'], 'male'])
#items，获得所有的键值对
res = d.items()     #res = dict_items([('name', 'winter'), ('age', 18), ('hobbies', ['basketball', 'football']), ('gender', 'male')])


#copy方法， 和list.copy一样，是浅复制

3）字典元素的访问

dic = {'name':'winter', 'age':18}
'''
下面3中方式的结果都为
name winter
age 18
'''
#方式1
for item in dic:
    print(item, dic[item])
#方式2
for item in dic.keys():
    print(item, dic[item])
#方式3
for k,v in dic.items():
    print(k, v)

推荐方式1），采用了迭代器来访问；

4）字典vs列表

a) 字典：

•       查找和插入的速度极快，不会随着key的数目的增加而增加（直接查找hash后得到的内存地址）；
•       需要占用大量的内存，内存浪费多（大量的hash值，占用内存你空间）
•       key不可变
•       默认无序

b) 列表：

•       查找和插入的时间随着元素的增加而增加
•       占用空间小，浪费内存很少
•       通过下标查询
•       有序

9. 集合

这是高一数学的内容了

集合对象是一组无序排列的值，分为可变集合（set）和不可变集合（frozenset）；可变集合不可hash；不可变集合可以hash，即可以作为字典的键；

特性：

a) 无序性，无法通过索引访问

b) 互异性，元素不可重复，即有去重的功能

1)  创建集合

#直接创建可变集合
s1 = {1,2,3,3}      #结果，python3.x为{1,2,3}，python2.x为set([1, 2, 3]),因为集合不允许有重复元素，所以只有一个3元素
#通过函数创建
s2 = set([1,2,3,4]) #创建可变集合{1, 2, 3, 4}
s3 = frozenset([1,2,3,3]) #创建不可变集合，结果为frozenset({1, 2, 3})

2) 集合方法和操作符

这里直接用一张表：

这里只列出可变集合的方法示例，因为不可变集合的方法可变集合都有

a) 单个集合的操作

#集合

#直接创建可变集合
s1 = {1,2,3,3}      #结果，python3.x为{1,2,3}，python2.x为set([1, 2, 3]),因为集合不允许有重复元素，所以只有一个3元素
#通过函数创建
s2 = set([1,2,3,4]) #创建可变集合{1, 2, 3, 4}
s3 = frozenset([1,2,3,3]) #创建不可变集合，结果为frozenset({1, 2, 3})


s1 = {1,2,3}

#增
s1.add('456')   #结果s1 = {1, 2, 3, '456'}
s1.update('789')    #结果s1 = {1, 2, 3, '7', '8', '9', '456'}

#删
res = s1.pop()      #结果res = 1，s1 = {2, 3, '7', '8', '9', '456'}
s1.remove(3)    #结果s1 =  {2, '7', '8', '9', '456'}
s1.discard(4)   #结果s1 =  {2, '7', '8', '9', '456'}，同时不报Error
s1.clear()      #结果s1 = set()

#浅复制
s1 = {1,2,3}
s2 = s1.copy()  #结果s2 = {1,2,3}

b) 集合之间的操作，集合的主要功能

s0 = {1,2}
s1 = {1,2,3,4}
s2 = {3,4,5,6}

#子集，超级判断
res = s0.issubset(s1)   #结果res = True
res = s1.issubset(s2)   #结果res = False
res = s1.issuperset(s0) #结果res = True
res = s0 <= s1      #结果res = True

#并集
res = s1.union(s2)  #结果res = {1, 2, 3, 4, 5, 6}
res = s1 | s2   #结果res = {1, 2, 3, 4, 5, 6}

#交集
res = s1.intersection(s2)   #结果为{3, 4}
res = s1 & s2   #结果为{3, 4}

#差集
res = s2.difference(s1) #结果res = {5, 6}
res = s2 - s1 #结果res = {5, 6}
res = s1.difference(s2) #结果res = {1, 2}

#对称差集
res = s2.symmetric_difference(s1)   #结果为{1, 2, 5, 6}
res = s2 ^ s1   #结果为{1, 2, 5, 6}

#在原集合基础上修改原集合
s1.intersection_update(s2)
s1.difference_update(s2)
s1.symmetric_difference_update(s2)

 用一张图来解释一下：

---

2017年9月20日更新

1. 推导式

有列表推导式，字典推导式，集合推导式

1）列表推导式

li_1 = [item for item in range(5)]  #结果li_1 = [0, 1, 2, 3, 4]

li_2 = [item for item in range(5) if item > 2]  #结果li_2 = [3, 4]

li_3 = [item if item>2 else 0 for item in range(5)] #结果li_3 = [0, 0, 0, 3, 4]

li_4 = [(x,y) for x in range(3) for y in range(3,6)]    #结果li_4 = [(0, 3), (0, 4), (0, 5), (1, 3), (1, 4), (1, 5), (2, 3), (2, 4), (2, 5)]

li_raw = [['winter', 'tom', 'lily'], ['winter']]
li_5 = [item for li in li_raw for item in li if item.count('l') > 1]    #结果li_5 = ['lily']

2）集合推导式

和列表推导式一样，只要把[]换成{}即可

3）字典推导式

和列表推导式一样，只是没有if...else...形式

4）有元祖推导式吗？

(x for x in range(5))就是元祖推导式呢？

答案是：不是的

(x for x in range(5)得到的是一个生成器

>>>a = (x for x in range(10))
>>>a
>>><generator object <genexpr> at 0x0000000004B09F68>
>>>a.__next__()
>>>0
>>>a.__next__()
>>>1