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', '20']]
>>> import copy
>>> tom = copy.deepcopy(jack)
>>> anny = copy.deepcopy(jack)

根据上述第二个例子思路进行重命名，重定岁数操作：

>>> tom[0] = 'tom'
>>> anny[0] = 'anny'
>>> print jack, tom, anny
['jack', ['age', '20']] ['tom', ['age', '20']] ['anny', ['age', '20']]
>>> anny[1][1] = 18
>>> print jack, tom, anny
['jack', ['age', '20']] ['tom', ['age', '20']] ['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'>