python学习笔记三 深浅copy，扩展数据类型（基础篇）

深浅copy以及赋值

对于字符串和数字而言，赋值、浅拷贝和深拷贝无意义，因为其永远指向同一个内存地址。

import copy

n1 =
#n1 = 'hahahaha'
#赋值
n2 = n1
#浅copy
n3 = copy.copy(n1)
#深copy
n4 = copy.deepcopy(n1)
print(id(n1),id(n2)) #打印内存地址
5787536 5787536
print(id(n1),id(i3))
5787536 5787536
print(id(n1),id(n4))
5787536 5787536

字典，列表，元组等进行赋值，深浅copy时，它们的内存地址变化是不一样的。

在赋值操作时，仅仅只是做了一个别名而已。因为字典的存储空间比字符串和数字要大很多，当你赋值给另一个变量的时候，按原来的方式copy一份独立的数据会浪费很多资源，

效率还会很低。

n1 = {'k1':,'k2':'koka','k3':['haha','xixi','hehe','houhou']}

n2 = n1
print(n2)
print(n1)
{'k3': ['haha', 'xixi', 'hehe', 'houhou'], 'k2': 'koka', 'k1': }
{'k3': ['haha', 'xixi', 'hehe', 'houhou'], 'k2': 'koka', 'k1': }
n1['k1']=
print(n2)
print(n1)
{'k3': ['haha', 'xixi', 'hehe', 'houhou'], 'k2': 'koka', 'k1': }
{'k3': ['haha', 'xixi', 'hehe', 'houhou'], 'k2': 'koka', 'k1': }
n1['k3'][]='ajx'
print(n2)
print(n1)
{'k3': ['ajx', 'xixi', 'hehe', 'houhou'], 'k2': 'koka', 'k1': }
{'k3': ['ajx', 'xixi', 'hehe', 'houhou'], 'k2': 'koka', 'k1': }

#从结果可以发现n1和n2的值同时改变，因为他们只是两个不同的别名而已。

在浅copy操作时，只是copy了字典下的第一层数据，对于更深层次的数据还是原来的。

n3 =copy.copy(n1)
print(n3)
print(n1)
{'k1': , 'k2': 'koka', 'k3': ['haha', 'xixi', 'hehe', 'houhou']}
{'k1': , 'k2': 'koka', 'k3': ['haha', 'xixi', 'hehe', 'houhou']}
n1['k2'] = 'dada'
print(n3)
print(n1)
{'k1': , 'k2': 'koka', 'k3': ['haha', 'xixi', 'hehe', 'houhou']}
{'k1': , 'k2': 'dada', 'k3': ['haha', 'xixi', 'hehe', 'houhou']}
n1['k3'][] = 'heihei'
print(n3)
print(n1)
{'k1': , 'k2': 'koka', 'k3': ['haha', 'xixi', 'heihei', 'houhou']}
{'k1': , 'k2': 'dada', 'k3': ['haha', 'xixi', 'heihei', 'houhou']}

#可以看出第一层的字符串数据改变了，而后面的列表还是同一个。

在深度copy操作时，在内存中将所有的数据重新创建一份（排除最后一层，即：python内部对字符串和数字的优化）

n4 = copy.deepcopy(n1)
print(n4)
print(n1)
{'k2': 'koka', 'k3': ['haha', 'xixi', 'hehe', 'houhou'], 'k1': 1024}
{'k2': 'koka', 'k3': ['haha', 'xixi', 'hehe', 'houhou'], 'k1': 1024}
n1['k1'] = 8192
n4['k2'] = 'akok'
print(n4)
print(n1)
{'k2': 'akok', 'k3': ['haha', 'xixi', 'hehe', 'houhou'], 'k1': 1024}
{'k2': 'koka', 'k3': ['haha', 'xixi', 'hehe', 'houhou'], 'k1': 8192}
n1['k3'][0] = "lolo"
n4['k3'][1] = "lala"
print(n4)
print(n1)
{'k2': 'akok', 'k3': ['lala', 'xixi', 'hehe', 'houhou'], 'k1': 1024}
{'k2': 'koka', 'k3': ['lolo', 'xixi', 'hehe', 'houhou'], 'k1': 8192}

#真正的完全copy一份数据。

数据结构扩展

Collection系列

1、计数器（counter）

Counter是对字典类型的补充，用于追踪值的出现次数。

ps：具备字典的所有功能 + 自己的功能

c1 = collections.Counter('aabc')
c2 = collections.Counter(('a','b','c','a'))
print(c1)
Counter({'a': , 'b': , 'c': })
print(c2)
Counter({'a': , 'b': , 'c': })
#类似于c1 + c2
c1.update(c2)
print(c1)
Counter({'a': , 'b': , 'c': })
c1.subtract('a')
print(c1)
Counter({'a': , 'b': , 'c': })
#列出前几位
print(c1.most_common())
[('a', ), ('b', )]
for i  in c2.elements():
#elements返回元素迭代器
    print(i)
b
a
a
c

2、有序字典(orderedDict )

有序字典跟字典使用没有区别，记录key的存储顺序

o1 = collections.OrderedDict()
o1['k1'] =
o1['k2'] =
o1['k3'] =
for i,k in o1.items():
    print(i,k)

k1
k2
k3 

products = collections.OrderedDict()
products = {
   :['nectarine',],
   :['orange',],
   :['raspberry',],
   :['cherry',],
   :['Apple',],
   :['Banana',]
}

format = '%-*s%*s%*s'
for i,k in products.items():
    print(format %(,i,,k[],,k[]))
          nectarine
             orange
          raspberry
             cherry
              Apple
             Banana         

3、默认字典(defaultdict)

defaultdict是对字典的类型的补充，他默认给字典的值设置了一个类型。

values = [, , ,,,,,,]
newvalues = collections.defaultdict(list)

for i in values:
    if i >= :
        newvalues['k1'].append(i)
    else:
        newvalues['k2'].append(i)
print(newvalues)

4、可命名元组(namedtuple)

根据nametuple可以创建一个包含tuple所有功能以及其他功能的类型。

可命名元组：

1.创建类
2.使用类创建对象
3.使用对象
4.用于坐标
——————

普通元组：
1.直接使用类创建对象
2.使用对象

#old = tuple(1,2) <==> old = (1,2)
#创建一个扩展tuple的类，Mytuple

import collections
Mytuple = collections.namedtuple('Mytuple',['x','y'])
new = Mytuple(,)
print(new)

Mytuple(x=1, y=2

5、双向队列(deque)

在需要按照元素增加的顺序来移除元素时非常有用，双向队列可以通过可迭代对象来创建。

q = collections.deque(range())
q.append()
q.appendleft()
print(q)
deque([, , , , , , ])

q.rotate()
print(q)
deque([, , , , , ])

q.rotate(-)
print(q)
deque([, , , , , ])

q.remove()
print(q)
deque([, , , , , ])

ret1 = q.pop()
print(ret1)

ret2 = q.popleft()
print(ret2)

q.extend([,,])
print(q)
deque([, , , , , , ])

q.extendleft([,,])
print(q)
deque([, , , , , , , , , ])

set 集合

set是一个无序且不重复的元素集合，主要用于成员查找。

>>> a = set([,,,])
>>> b = set([,,,,])
#去除重复项合并
a.update(b)
print(a)
{, , , , , , }

#添加一个数
>>> a.add()
>>> print(a)
{, , , , , , , }

#清空集合
>>>a.clear()
set()

>>> c = a.copy()
>>> print(c)
{, , , , , , , }

#并集
>>> result1 = a.union(b)
>>> result2 = a | b
>>> print(result1,result2)
{, , , , , , , } {, , , , , , , }

#交集
>>> result = a.intersection(b)
>>> print(result)
{, , , , }
>>> result = a & b
>>> print(result)
{, , , , }

#子集
>>> result = c.issubset(a)
>>> print(result)
True

#父集
>>> result = a.issuperset(c)
>>> print(result)
True

#取差集 -
>>> result1 = a.difference(b)
>>> result2 = a - b
>>> print(result1,result2)
{, , } {, , }

#异或差集 &
result1 = a ^ b
result2 = a.symmetric_difference(b)
print(result1,result2)
{, , } {, , }

#删除
# remove(If the element is not a member, raise a KeyError.)
# discard (If the element is not a member, do nothing.)
#pop (Remove and return an arbitrary set element.Raises KeyError if the set is empty.)
a.remove()
print(a)
{, , , , , , }

a.discard()
print(a)
{, , , , , }

a.pop()

print(a)
{, , , , }

集合练习：

找出下面字典中不同的键，同样的更新，现在没有的删除，现在有的更新

old_dict = {
    "#1":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 },
    "#2":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 },
    "#3":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 }
}
new_dict = {
    "#1":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 800 },
    "#3":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 },
    "#4":{ 'hostname':'c2', 'cpu_count': 2, 'mem_capicity': 80 }
}

old_set =set(old_dict.keys())
new_set = set(new_dict.keys())
update_set = old_set.intersection(new_set)
del_list = list(old_set.difference(update_set))
add_list = list(new_set.difference(update_set))
print(list(update_set),add_list,del_list)

堆（heap）

它是一种优先队列。它能够以任意顺序增加对象，并且能在任何时间（可能在增加对象的同时）找到（也可能是移除）最小的元素，它比列表的min方法更有效率。
相关函数：
heappush(x)          将X入堆
heappop(heap)        将堆中最小的元素弹出
heapify(heap)        将堆中属性强制应用到任意一个列表，如果没有使用haeppush创建堆，可以使用heapif（heap）
heapreplace(heap,x)  将堆中最小元素弹出，同时将x入堆
nlargest(n,iter) 　　返回iter中第n大的元素
nsmallest(n,iter)    返回iter中第n小的元素

from heapq import *
from random import shuffle

seq = [11,22,33,44,55]
shuffle(seq)
heap = []
for i in seq:
    heappush(heap,i)
print(heap)
[11, 22, 44, 55, 33]
heappush(heap,10)
print(heap)
[10, 22, 11, 55, 33, 44]

元素的顺序并不像看起来那么随意，算法：位于i位置上的元素总比1//2位置处的元素大（反过来说就是i位置的元素总比2*以及2*i+1位置处的元素小）

print(heappop(heap))
10
print(heappop(heap))
11
print(heappop(heap))
22

一般来说都是在索引0处的元素，并且会确保剩余元素中最小的那个占据这个位置

li = [1,2,5,4,67,27,2]
heapify(li)
print(li)

heapreplace(li,0.5)
print(li)