Python,Collection模块自学小记

Collection模块的Tuple一些用法：

# -*- coding:utf-8 -*-
# @Author Tony

#pyc 字节码编译 #tuple 无法修改，可以线程安全。 
#可以作为dict的key. 拆包特性 ，immutable

name_tuple =  ("babby1", "bobby2")
user_tuple =  ("body", 29, 175)

name, age, height = user_tuple
print(name, age, height)

#name = =user_tuple[0]
#age = =user_tuple[1]
#height = =user_tuple[2]
#以上为拆包的用法。

name_tuple1 = ('bobay1', [19, 9721, 12])
name_tuple1[1].append(22)
print(name_tuple1)
#输出 ('bobay1', [19, 9721, 12, 22])

user_info_dict = {}
user_info_dict[user_tuple] = 'body'
print(user_info_dict[user_tuple])
#可以将不变可哈希指针当做，索引
#debug ,pass可以当做节点测试。

Collection模块的namedtuple一些用法：

# -*- coding:utf-8 -*-
# @Author Tony
#内存和效率很简单，用处非常大 
#代码量增加，他取出来的类型是一个tuple,

from collections import namedtuple
User = namedtuple("User", ["name", "age", "height"])
user = User(name="baduu", age=29, height=175)
print(user.age, user.name, user.height)
#输出：29 baduu 175
#第一个是User是namedtuple对象，对二个User解释是Typename(str类型)


User = namedtuple("User", ["name", "age", "height", "edu"])
user_tuple =('bady', 29, 2257)
user_dict = ['bady', 19, 289, "master"]
#方法一：字典。
#*是函数接受，没有参数指定，**是有参数指定，字典接收
user = User(*user_tuple, "master")

#方法二：字典。
#User._make接受可迭代对象创建dict对象
user = User._make(user_dict)

#asdict()方法字母的排序
user_paixu_dict = user._asdict()
print(user_paixu_dict)

#输出OrderedDict([('name', 'bady'), ('age', 19), ('height', 289), ('edu', 'master')])

'''
可以进行拆包的
'''
User = namedtuple("User", ["name", "age", "height", "edu"])
user = User(name="baduu", age=29, height=175, edu = "master")
name, age, *other = user
print(other)
def ask1(*arg, **kwarg):
    pass
ask1(29, name = '192')

Collection模块的ordered_dict一些用法：

from collections import OrderedDict
user_dict = OrderedDict()
user_dict["b"] = "bobby1"
user_dict["a"] = "bobby2"
user_dict["c"] = "bobby3"
print(user_dict)
'''
OrderedDict为dict有序，你创建一个普通的dict,python3为自动有序
interpret 为解释器。
'''
user_dict.pop("a")
#pop接受key,删除元素。
user_dict.move_to_end("b")
#move_to_end，将元素移动到最后。
print(user_dict)

Collection模块的defaultdict一些用法：

from collections import defaultdict
users = ["boby", "bodyy1", "bobby3", "bobby4", "boby"]
user_dict  = {}
for user in users:
    '''
    if user not in user_dict:
        user_dict[user] = 1
    else:
        user_dict[user] += 1
    '''
    #下面的操作可以减少一次上面逻辑的查询操作
    user_dict.setdefault(user, 0)
    user_dict[user] += 1
print(user_dict)
#可以传递进来一个可调用的对象,函数也可以。
#输出为keys,值和tuple中含有多少个keys统计当做value,就是对keys的统计。

users = ["boby", "bodyy1", "bobby3", "bobby4", "boby"]
default_dict = defaultdict(int)
#也可以这样用：
default_dict = defaultdict(list)

default_dict = defaultdict(list)
for user in users:
    default_dict[user].append(1)
print(default_dict)

#default_dict实现为missing函数。
print(default_dict["bobby6"])

Collection模块的deque一些用法：

''' from queue import Queue queue用到了deque进行操作。 deque,GIL锁是线程安全的，list不是线程安全的。 deque做多线程操作就可以。 '''

from collections import deque
import copy
user_list = ["bobby", "bobby2"]
user_list.pop()
user_list = deque(["bobby", "bobby2"])
#可迭代对象都可以初始化对象,只会取键值
user_list = deque(
    {
        "bobby":29,
        "bobby2":"age"
    }
)
print(user_list)
user_list.appendleft("nihao")
#deque它只获取了dict的keys的值。

#下面介绍浅拷贝
user_deque = deque(["bobby1", "bobby2", ["bobby3", "bobby4"], "bobby5"])
user_deque2 = user_deque.copy()
user_deque2[2].append('bobby6')
print(user_deque, user_deque2)
print(id(user_deque), id(user_deque2))


#深拷贝
user_deque2 = copy.deepcopy(user_deque)

'''
deque的extend，和list一样只是当前元素扩容，不会改变
如：
user_deque3 = user_deque.extend(user_deque2) 
'''

Collection模块的Counter一些用法：

'''
Counter可以用来做统计
update,可以对于原先字符（dict）对象进行扩加
'''
from collections import Counter
user = ["b1", "b2", "b3", "b2", "b1", "b3", "b1"]
print(Counter(user))
jisun_counter = Counter("aahkjsbabasnbasn")
print(jisun_counter)
jisun_counter.update("sahj")


'''
update也可传递Counter,传递可的跌代对象，Counter也是继承dict
'''
jisun_counter2 = Counter("abbdb")
jisun_counter.update(jisun_counter2)
print(jisun_counter)
print(jisun_counter.most_common(2))
#2表示例举多少个。  _heapq是一个堆的数据结构。
#top n的问题，内置的heapq比我们自己方法要效率高

Collection模块的ChainMap一些用法：

from collections import ChainMap
user_dict1 = {"a": "bobby1", "b": "bobby2"}
user_dict2 = {"b": "bobby1", "d": "bobby3"}
# for key, value in user_dict1:
#     print(key, value)
# for key, value in user_dict2:
#    print(key, value)

'''
当同时存在相同键值时，则不会处理。
'''
user_dict3 = ChainMap(user_dict1, user_dict2)
for key, value in user_dict3.items():
    print(key, value)
print(user_dict3)

user_dict4 = {"aa": "aa", "bb": "bb"}
print(user_dict3.new_child(user_dict4))
print(user_dict3)
for key, value in user_dict3.items():
    print(key, value)
print()

'''
chainmap还有一个属性，maps()
chainmap没有创建一个新的dict，只是对他进行了迭代。
'''
print()
user_dict1 = {"a": "bobby1", "b": "bobby2"}
user_dict2 = {"b": "bobby1", "d": "bobby3"}
user_dict3.maps[0]["a"] = "bobby"
user_dict3.maps[0]["b"] = "bobby5"
for key, value in user_dict3.items():
    print(key, value)

from collections import *
if __name__ == '__main__':
    print("hello world")
    dict1={"hello":1,"world":2}
    dict2={"hello":3,"java":3}
    dict4={"hello":5,"java":5}
    dict3=ChainMap(dict1,dict2)
    print(dict3)
    # maps:把ChainMap对象转化为list对象，可以被访问和修改。
    print(dict3.maps)
    # new_child:在字典前插入一个新的字典，参数为空：插入一个空的字典。参数不为空，插入第一个位置。
    #ChainMap({}, {'world': 2, 'hello': 1}, {'java': 3, 'hello': 3})
    print(dict3.new_child())
    #ChainMap({'java': 5, 'hello': 5}, {'world': 2, 'hello': 1}, {'java': 3, 'hello': 3})
    print(dict3.new_child(dict4))