python挖掘信息,python挖掘数据教程

2022-10-04 11:07:46 商业观察

基本介绍

　　 Python有一些内置的数据类型，比如str、int、list、tuple、dict等。在这些内置数据类型的基础上，集合模块提供了几个额外的数据类型，如下所示。这些类平时在Python代码中非常有用。掌握这个模块可以大大简化Python代码，提高Python代码强制。　　

　　导入收藏　　

　　打印收藏。__全部_ _ 　　

　　' Counter '，' deque '，' defaultdict '，' namedtuple '，' OrderedDict '，' Hashable '，' Iterable '，' Iterator '，' Sized '，' Container '，' Callable '，' Set '，' MutableSet '，' Mapping '，' MutableMapping '，' MappingView '，' KeysView '，' ItemsView '，' ValuesView '，' Sequence '，' MutableSequence ' 　　

　　本文主要介绍馆藏库中常用的几个类：　　

　　Counter: counter主要用于计算deque:的deque，可以快速添加和推出对方的对象。OrderedDict:有序字典namedtuple:生成元组子类defaultdict:字典具有默认值

Counter类

　　计数器类用于跟踪值的出现次数。它是一种无序的容器类型，作为一个键-值对存储在字典中，其中元素是键，它的计数是值。计数值可以是任何整数(包括0和负数)。　　

　　Counter类的创建 　　

　　从集合导入计数器　　

　　C1=Counter() #创建一个空的计数器类　　

　　C2=Counter('zhongguo') #从可迭代对象(列表、元组、字典、字符串等)创建。) 　　

　　C3=从字典对象创建的计数器({'a' : 5，' b' 3360 1}) # 　　

　　C4=Counter(a=3，b=8) #从一组键值对中创建　　

　　most_common()方法 　　

　　如果你用心去做，没有什么是困难的　　

　　c=计数器　　

　　打印c.most_common(5) 　　

　　《' ', 9》，(' I '，7)，(' t '，6)，(' o '，4)，(' u '，4) 　　

　　键值的访问与计数器的更新 　　

　　c=计数器(“中国”) 　　

　　打印c'z '，c'o '，c'l ' 　　

　　输出：1，2，0 　　

　　#注意：与字典键值查找不同，当查找的键值不存在时，计数器返回0。　　

　　#添加了第一种更新方式- updatez 　　

　　C.update('ren') #用另一个可迭代对象更新　　

　　打印编号#2 　　

　　d=计数器(“niubi”) 　　

　　C.update(d) #用另一个计数器对象更新　　

　　打印编号4 　　

　　#第二种更新方法-减去减少　　

　　c=计数器(“中国”) 　　

　　c .减去(“任”) 　　

　　打印密码#0 　　

　　d=计数器(“niubi”) 　　

　　c .最新情况　　

　　打印' n' #-1(可以是负数) 　　

　　elements()方法以及删除键值 　　

　　c=计数器(a=2，b=1，c=0，d=-1) 　　

　　list(c.elements()) 　　

　　#'a '，' a '，' b' #小于或等于0的不显示。　　

　　#删除键值　　

　　德尔卡　　

　　打印c 　　

　　#计数器({'b': 1，' c': 0，' d': -1}) 　　

　　一些基本操作 　　

　　c1=计数器(a=1，b=2) 　　

　　c2=计数器(a=2，b=3) 　　

　　打印c1 c2 　　

　　C1-C2 #不返回0或负数。　　

　　#计数器({'b': 5，' a': 3}) 　　

　　#计数器() 　　

　　Sum(c.values()) #所有帐户　　

数的总数

c.clear() # 重置Counter对象，注意不是删除

list(c) # 将c中的键转为列表

set(c) # 将c中的键转为set

dict(c) # 将c中的键值对转为字典

c += Counter() # 移除0和负值

defaultdict 类

defaultdict 是 dict 的子类，因此 defaultdict 也可被当成 dict 来使用，dict 支持的功能，defaultdict 基本都支持。但它与 dict 最大的区别在于，如果程序试图根据不存在的 key 采访问 dict 中对应的 value，则会引发 KeyError 异常；而 defaultdict 则可以提供一个 default_factory 属性，该属性所指定的函数负责为不存在的 key 来生成 value。

from collections import defaultdict

my_dict = {}

# 使用int作为defaultdict的default_factory

# 将key不存在时，将会返回int()函数的返回值

my_defaultdict = defaultdict(int)

print my_defaultdict<'a'> # 0

print my_dict<'a'> # KeyError

#与Counter性质类似

#上面分别创建了空的 dict 对象和 defaultdict 对象，当程序试图访问 defaultdict 中不存在的 key 对应的 value 时，程序输出 defaultdict 的 default_factory 属性（int 函数）的返回值 0；如果程序试图访问 dict 中不存在的 key 对应的 value，就会引发 KeyError异常。

对比dict操作

###dict####

s = 《'Python', 1》, ('Swift', 2), ('Python', 3), ('Swift', 4), ('Python', 9)>

d = {}

for k, v in s:

# setdefault()方法用于获取指定key对应的value.

# 如果该key不存在，则先将该key对应的value设置为默认值:<>

d.setdefault(k, <>).append(v)

print list(d.items())

#需要处理 key 不存在的情况，如果该key不存在，setdefault()方法就会先为该key设置一个默认的value。

###defaultdict###

s = 《'Python', 1》, ('Swift', 2), ('Python', 3), ('Swift', 4), ('Python', 9)>

# 创建defaultdict，设置由list()函数来生成默认值

d = defaultdict(list)

for k, v in s:

# 直接访问defaultdict中指定key对应的value即可。

# 如果该key不存在，defaultdict会自动为该key生成默认值

d.append(v)

print(list(d.items()))

相比于普通dict是不是方便很多。

deque类

deque是一个双向链表，针对list连续的数据结构插入和删除进行优化。它提供了两端都可以操作的序列，这表示在序列的前后你都可以执行添加或删除操作。

from collections import deque

d=deque()

类似于list方法

d.append(3)

d.append(8)

print d

#deque(<3,8>)

print len(d) #2,

d<0> #3

d<-1> #8

d.pop() #5,默认pop()抛出的是队列的最后一个元素

d.leftpop() #3

长度限制

d=deque(maxlen=10)

for i in range(20):

d.append(i)

#deque(10, 11, 12, 13, 14, 15, 16', 17, 18, 19, 20>, maxlen=10)

#当限制长度的deque增加超过限制数时，左边会自动删除，这也符合队列的性质。

extend()方法

d=deque(<1,2,3,4,5>)

d.extend(<6>)

#deque(<1,2,3,4,5,6>)

d.extendleft(<-2,-1,0>)

#deque(<-2,-1,0, 1, 2, 3, 4, 5, 6>)

rotate()方法

b=deque("ABCDEFG")

print b

b.rotate(2)

print b

b.rotate(3)

print b

#deque(<'A', 'B', 'C', 'D', 'E', 'F', 'G'>)

#deque(<'F', 'G', 'A', 'B', 'C', 'D', 'E'>)

#deque(<'C', 'D', 'E', 'F', 'G', 'A', 'B'>)

OrderedDict类

OrderedDict 也是 dict 的子类，其最大特征是，它可以“维护”添加 key-value 对的顺序。简单来说，就是先添加的 key-value 对排在前面，后添加的 key-value 对排在后面。相比于dict更加灵活。

基础性质

from collections import OrderedDict

# 创建OrderedDict对象

dx = OrderedDict(b=5, c=2, a=7)

print dx # OrderedDict(《'b', 5》, ('c', 2), ('a', 7)>)

d = OrderedDict()

# 向OrderedDict中添加key-value对

d<'Python'> = 89

d<'Swift'> = 92

d<'Kotlin'> = 97

d<'Go'> = 87

# 遍历OrderedDict的key-value对

for k,v in d.items():

print k, v

顺序

# 创建普通的dict对象

my_data = {'Python': 20, 'Swift':32, 'Kotlin': 43, 'Go': 25}

# 创建基于key排序的OrderedDict

d1 = OrderedDict(sorted(my_data.items(), key=lambda t: t<0>))

# 创建基于value排序的OrderedDict

d2 = OrderedDict(sorted(my_data.items(), key=lambda t: t<1>))

print(d1) # OrderedDict(《'Go', 25》, ('Kotlin', 43), ('Python', 20), ('Swift', 32)>)

print(d2) # OrderedDict(《'Python', 20》, ('Go', 25), ('Swift', 32), ('Kotlin', 43)>)

print(d1 == d2) # False

# OrderedDict能维护key-value对的添加顺序，因此即使两个 OrderedDict中的key-value对完全相同，但只要顺序不同，程序在判断它们是否相等时也依然会返回false

特殊方法

popitem(last=True)：默认弹出并返回最右边(最后加入)的 key-value 对；如果将 last 参数设为 False，则弹出并返回最左边(最先加入)的 key-value 对。move_to_end(key, last=True)：默认将指定的 key-value 对移动到最右边(最后加入)；如果将 last 改为 False，则将指定的 key-value 对移动到最左边(最先加入)d = OrderedDict.fromkeys('abcde')

# 将b对应的key-value对移动到最右边（最后加入）

d.move_to_end('b')

print(d.keys()) # odict_keys(<'a', 'c', 'd', 'e', 'b'>)

# 将b对应的key-value对移动到最左边（最先加入）

d.move_to_end('b', last=False)

print(d.keys()) # odict_keys(<'b', 'a', 'c', 'd', 'e'>)

# 弹出并返回最右边（最后加入）的key-value对

print(d.popitem()<0>) # e

# 弹出并返回最左边（最先加入）的key-value对

print(d.popitem(last=False)<0>) # b

namedtuple类

namedtuple() 是一个工厂函数，使用该函数可以创建一个 tuple 类的子类，该子类可以为 tuple 的每个元素都指定宇段名，这样程序就可以根据字段名来访问 namedtuple 的各元素了,也可以根据索引来访问 namedtuple 的各元素。

基本属性

namedtuple(typename, field_names, *, verbose=False, rename=False, module=None)

typename：该参数指定所创建的 tuple 子类的类名，相当于用户定义了一个新类。field_names：该参数是一个字符串序列，如 <'x'，'y'>。此外，field_names 也可直接使用单个字符串代表所有字段名，多个字段名用空格、逗号隔开，如 'x y' 或 'x,y'。任何有效的 Python 标识符都可作为字段名（不能以下画线开头）。有效的标识符可由字母、数字、下画线组成，但不能以数字、下面线开头，也不能是关键字（如 return、global、pass、raise 等）。rename：如果将该参数设为 True，那么无效的字段名将会被自动替换为位置名。例如指定 <'abc','def','ghi','abc'>，它将会被替换为 <'abc', '_1','ghi','_3'>，这是因为 def 字段名是关键字，而 abc 字段名重复了。verbose：如果该参数被设为 True，那么当该子类被创建后，该类定义就被立即打印出来。module：如果设置了该参数，那么该类将位于该模块下，因此该自定义类的 __module__ 属性将被设为该参数值。from collections import namedtuple

# 定义命名元组类：Point

Point = namedtuple('Point', <'x', 'y'>)

# 初始化Point对象，即可用位置参数，也可用命名参数

p = Point(11, y=22)

# 像普通元组一样用根据索引访问元素

print(p<0> + p<1>) # 33

# 执行元组解包，按元素的位置解包

a, b = p

print(a, b) # 11, 22

# 根据字段名访问各元素

print(p.x + p.y) # 33

print(p) # Point(x=11, y=22)

方法

_make(iterable)：类方法。该方法用于根据序列或可迭代对象创建命名元组对象。_asdict()：将当前命名元组对象转换为 OrderedDict 字典。_replace(**kwargs)：替换命名元组中一个或多个字段的值。_source：该属性返回定义该命名元组的源代码。_fields：该属性返回该命名元组中所有字段名组成的元组。my_data = <'East', 'North'>

# 创建命名元组对象

p2 = Point._make(my_data)

print(p2) # Point(x='East', y='North')

# 将命名元组对象转换成OrderedDict

print(p2._asdict()) # OrderedDict(《'x', 'East'》, ('y', 'North')>)

# 替换命名元组对象的字段值

p2._replace(y='South')

print(p2) # Point(x='East', y='North')

# 输出p2包含的所有字段

print(p2._fields) # ('x', 'y')

# 再次定义一个命名元组类

Color = namedtuple('Color', 'red green blue')