python_day3学习笔记

• 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'>