- set集合
python的set是一个无序不重复元素集，基本功能包括关系测试和消除重复元素. 集合对象还支持并、交、差、对称差等。
sets 支持 x in set、 len(set)、和 for x in set。作为一个无序的集合，sets不记录元素位置或者插入点。因此，sets不支持 indexing, slicing, 或其它类序列（sequence-like）的操作。
1、运算操作
>>> x = set("hello!")
>>> y = set(['d','i','m','i','t','e'])
>>> x #把字符串转化为set，去重复了
set(['!', 'h', 'e', 'l', 'o'])
>>> y
set(['i', 'e', 'm', 'd', 't'])
>>> set(['i','e','m','d','t'])
set(['i', 'm', 'e', 'd', 't'])
>>> x & y #交
set(['e'])
>>> x | y #并
set(['!', 'e', 'd', 'i', 'h', 'm', 'l', 'o', 't'])
>>> x - y #差
set(['!', 'h', 'l', 'o'])
>>> y -x
set(['i', 'm', 'd', 't'])
>>> x ^ y #对称差：x和y的交集减去并集
set(['!', 'd', 'i', 'h', 'm', 'l', 'o', 't'])
>>> 2、基本方法
>>> x
set(['i', 'h', 'j', 'e', 't'])
>>> s = set("hi")
>>> s
set(['i', 'h'])
>>> len(x) #长度
>>> 'i' in x
True
>>> s.issubset(x) #s是否为x的子集
True
>>> y
set(['i', 'e', 'm', 'd', 't'])
>>> x.union(y) #交
set(['e', 'd', 'i', 'h', 'j', 'm', 't'])
>>> x.intersection(y) #并
set(['i', 'e', 't'])
>>> x.difference(y) #差
set(['h', 'j'])
>>> x.symmetric_difference(y) #对称差
set(['d', 'h', 'j', 'm'])
>>> s.update(x) #更新s，加上x中的元素
>>> s
set(['e', 't', 'i', 'h', 'j'])
>>> s.add(1) #增加元素
>>> s
set([1, 'e', 't', 'i', 'h', 'j'])
>>> s.remove(1) #删除已有元素，如果没有会返回异常
>>> s
set(['e', 't', 'i', 'h', 'j'])
>>> s.remove(2) Traceback (most recent call last):
File "<pyshell#29>", line 1, in <module>
s.remove(2)
KeyError: 2
>>> s.discard(2) #如果存在元素，就删除；没有不报异常
>>> s
set(['e', 't', 'i', 'h', 'j'])
>>> s.clear() #清除set
>>> s
set([])
>>> x
set(['i', 'h', 'j', 'e', 't'])
>>> x.pop() #随机删除一元素
'i'
>>> x
set(['h', 'j', 'e', 't'])
>>> x.pop()
'h'
- 深浅拷贝
对于字典、元祖、列表 而言，进行赋值、浅拷贝和深拷贝时，其内存地址的变化是不同的。
1、赋值
赋值，只是创建一个变量，该变量指向原来内存地址，如：
n1 = {"k1": "yin", "k2": 123, "k3": ["laonanhai", 456]}
n2 = n1
print n2
结果如下：
{'k3': ['laonanhai', 456], 'k2': 123, 'k1': 'yin'}2、利用切片操作和工厂方法list方法拷贝
代码场景：有一个小伙jack，tom通过切片操作拷贝jack，anny通过工厂方法拷贝jack。
>>> jack = ['jack', ['age',20]]
>>> tom = jack[:]
>>> anny = list(jack)
查看三者的不同id值：
>>> print id(jack), id(tom), id(anny)
29596368 29586816 29584200
从id值来看，三者是不同的对象。为tom和anny重新命名为各自的名称：
>>> tom[0] = 'tom'
>>> anny[0] = 'anny'
>>> print jack, tom, anny
['jack', ['age', 20]] ['tom', ['age', 20]] ['anny', ['age', 20]]
从这里来看一切正常，可是anny只有18岁，重新为anny定义岁数。
>>> anny[1][1] = 18
>>> print jack, tom, anny
['jack', ['age', 18]] ['tom', ['age', 18]] ['anny', ['age', 18]]
这时候奇怪的事情发生了，jack、tom、anny的岁数都发生了改变，都变成了18了。jack、tom、anny他们应当都是不同的对象，怎么会互相影响呢？看下jack，tom，anny的内部元素每个元素id：
>>> [id(x) for x in jack]
[3073896320L, 3073777580L]
>>> [id(x) for x in tom]
[144870744, 3073777580L]
>>> [id(x) for x in anny]
[144977344, 3073777580L]
原来jack、tom、anny的岁数元素指向的是同一个元素。修改了其中一个，当然影响其他人了。那为什么修改名称没影响呢？原来在python中字符串不可以修改，所以在为tom和anny重新命名的时候，会重新创建一个’tom’和’anny’对象，替换旧的’jack’对象。
3、浅拷贝方法
浅拷贝方法跟上述第二个例子相同，如下代码：
>>>import copy
>>> yin = copy.copy(jack)
>>> yin
['jack', ['age', 20]]
>>> print jack,tom,anny,yin
['jack', ['age', 20]] ['jack', ['age', 20]] ['jack', ['age', 20]] ['jack', ['age', 20]]
>>> tom[0] = 'tom'
>>> anny[0] = 'anny'
>>> yin[0] = 'yinjia'
>>> print jack,tom,anny,yin
['jack', ['age', 20]] ['tom', ['age', 20]] ['anny', ['age', 20]] ['yinjia', ['age', 20]]
>>> anny[1][1] = 18
>>> print jack,tom,anny,yin
['jack', ['age', 18]] ['tom', ['age', 18]] ['anny', ['age', 18]] ['yinjia', ['age', 18]]
4、深拷贝方法
为了让他们之间不互相影响，用deepcopy深拷贝来试试。
>>> jack = ['jack', ['age', '']]
>>> import copy
>>> tom = copy.deepcopy(jack)
>>> anny = copy.deepcopy(jack)
根据上述第二个例子思路进行重命名，重定岁数操作：
>>> tom[0] = 'tom'
>>> anny[0] = 'anny'
>>> print jack, tom, anny
['jack', ['age', '']] ['tom', ['age', '']] ['anny', ['age', '']]
>>> anny[1][1] = 18
>>> print jack, tom, anny
['jack', ['age', '']] ['tom', ['age', '']] ['anny', ['age', 18]]
这时候他们之间就不会互相影响了。打印出每个人的内部元素每个id：
>>> [id(x) for x in jack]
[139132064, 3073507244L]
>>> [id(x) for x in tom]
[139137464, 139132204]
>>> [id(x) for x in anny]
[139141632, 139157548]
他们的内部元素也都指向了不同的对象。
- 参数
下面简述普通参数、指定参数、默认参数、动态参数的区别以及举例说明。
'''
普通参数：以正确的顺序传入函数，调用时数量必须和声明的一样。
指定参数：参数和函数调用关系密切，函数调用使用使用关键字参数来确定传入的参数值，参数允许函数调用时参数的顺序和声明时不一致。
默认参数：函数进行调用时，如果没有新的参数传入则默认的情况下，就调用默认参数
动态参数：个函数能处理比当初声明时更多的参数，这些参数叫动态参数
''' # 普通参数就是函数传入的参数一样，传入函数，没有默认值
def f(a):
a += 1
return a
b = f(3)
print(b) ''' 指定参数 '''
# 如果没有指定参数的值那么就会按照顺序分别给a,b,c赋初始值
def f(x,y,z):
print('z=',z,'y=',y,'x=',x)
a = x + y + z
return a
d = f(3,4,5)
print(d)
# 如果像这样指定a,b,c的值，那么它们就是指定参数，可以不按照它们原来的顺序传入
def f(a,b,c):
print('a=',a,'b=',b,'c=',c)
z = a + b + c
return z
e = f(c=5,b=4,a=3)
print(e) ''' 默认参数 '''
# 在括号里指定b的初始值,那么b就成为默认参数
def f(a,b = 9):
sum = a + b
return(sum)
# 我们只传入一个参数3，它就会默认按照顺序赋值给第一个变量a,b就等于原来的默认值9
c = f(3)
print(c)
#当传入两个参数时，按照顺序分别赋值给a,b，那么a=3,b=4,b被重新赋值了
d = f(3,4)
print(d) ''' 动态参数 '''
# 动态参数 *args是指当我们需要传入多个参数时，可以用*args代表多个参数，不用分别在括号里指定多个参数
def f(*args):
print(args,type(args)) d = f(1,2,3) 或 d = f(*[1,2,3]) #动态参数 **kwargs, 当我们需要传入键值对类型的参数时就可以用**kwargs
def f(**kwargs):
print (kwargs,type(kwargs)) c = f(a = 3,b = 4) 或 c = f(**{'a':3,'b':4}) #动态参数之参数的万能模式,这样我们无论怎么传参数几乎都不会报错
def f(a,*args,**kwargs):
print(a,args,type(args),kwargs,type(kwargs)) e = f(22,33,44,k1 = 55,k2 = 66)
代码运行结果如下：
4
z= 5 y= 4 x= 3
12
a= 3 b= 4 c= 5
12
12
7
(1, 2, 3) <class 'tuple'>
{'b': 4, 'a': 3} <class 'dict'>
22 (33, 44) <class 'tuple'> {'k1': 55, 'k2': 66} <class 'dict'>