视情况选择列表或者数组和memoryview对象和numpy方法——《流畅的python》

        从最初认识python到现在的前一分钟，认为python中的列表挺全能的，int，str，float，tuple，list，set什么都能填充进去。但为了后续追求开发效率，得考虑python代码内存的占用，也就引出了另一个概念python数组。

        当列表中只包含数值型数据时，那么使用array.array会更加高效。

PS：这里说的是array数组，当然numpy模块中也有一个ndarray数组 

 array数组的使用

#创建一个含有1000万随机浮点数的数组，存入文件，再从文件中读取出来

from array import array
from random import random

#写入参数'd',表示生成的array数组是存放双精度浮点数的数组

%time floats=array('d',(random() for _ in range(10**8)))
floats[-1]

#%time  只能使用在ipython或者是jupternotebook里面 

 这是CPU处理时间

#array数组保存为二进制流文本
fp=open('floats.bin','wb')
floats.tofile(fp)
fp.close()


#读取二进制流文本，转化为array数组
floats2=array('d')
fp=open('floats.bin','rb')
floats2.fromfile(fp,10**7)
fp.close()
floats2[-1]

---

         又又又发现了新大陆了——memoryview，内置的memoryview是一种共享内存的序列类型，可以在不复制字节的情况下处理数组的切片。这个灵感来自于numpy库中，一般numpy库用来处理数学问题，里面有线性回归等方法，在python进行数据分析和挖掘中有一席之地——这对于处理大型数据集来说非常重要。 

        下面简单介绍下，memoryview对象的使用方法。

 memoryview共享数据对象的使用

#下面举个例子
#建议导包时，就仅仅导入它的方法，减少内存开销
from array import array

#创建array数组，里面存放的是int类型的数据,'B'参数
octets=array('B',range(6))

#创建共享数据memoryview对象
m1=memoryview(octets)

#类型
print(type(m1))
print(m1)

#该类型得转化成列表才能看到
print(m1.tolist())

#当然也可以使用
#print(list(m1))

 

 

"""接着上方的代码"""

#创建第二个memoryview对象
#cast方法，将m1的array数组，从一维变为两行三列的二维类型
m2=m1.cast('B',[2,3])

#同理查看
print(type(m2))
print(m2)
print(m2.tolist())

#创建第三个memoryview对象
m3=m1.cast('B',[3,2])

print(type(m3))
print(m3)
print(m3.tolist())

#改变共享的值
m2[1,1]=22
m3[1,1]=33

#查看m1中更改后的值
print(m1.tolist())

   ——————m2和m3的参考数据

————————最后的共享数据 

memoryview案例——搞破坏

#实例：搞破坏
"""
    下面你将创建自己的array数组，存入短整形数据，占两个字节
    创建你的共享数据1，（字形数据）
    根据你的共享数据1创建共享数据2，（字节型数据）
    
    破坏数据原理：
    改变某个短整型数据的某个位置上的字节，从而改变短整型数据
    
    通过你的共享数据2去破坏字节
    
    ------> 目的达成

"""

#'h' 是一个参数，用于指定数组中元素的类型。在这里，'h' 表示有符号的短整型（signed short integer）。这意味着数组 numbers 中的每个元素都是一个有符号的短整数，占据两个字节的存储空间。

import array
numbers=array.array('h',[-2,-1,0,1,2])
#[0, 1, 2, 33, 22, 5]   短整型数据

#共享对象1
memv=memoryview(numbers)

#基于共享对象1创建共享对象2
new_memv=memv.cast('B')  #构建新的共享对象，不过为字节型数据
print(new_memv.tolist())
#[254, 255, 255, 255, 0, 0, 1, 0, 2, 0]   #字节型数据


#我们去改变一个字节，int是两个字节组成的，
new_memv[5]=4
print(numbers)

#array('h', [-2, -1, 1024, 1, 2])   破坏后的短整型数据集

 目前正在初学习《流畅的python》，对于《python进行数据分析》已经了解了一半，对于numpy模块，发现了些新奇的方法，还是基于《流畅的python》进行的补充。

 numpy新奇方法

 np.shape属性的使用

import numpy as np

#根据之前有的知识，一般创建ndarray数组，把它构建为二维一般使用如下方式:

my_ndarray=np.arrange(12).reshape((3,4))

print(my_ndarray)

"""
    array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])

"""

"""np.shapge的使用"""
import numpy as np
a=np.arange(12)

#查看a的数据结构
print(a.shape)
print(a)

"""
array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])
"""

#居然可以用这种方法改变ndarray的结构
a.shape=3,4

print(a)

"""
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
"""

转置数组（行列转换）

#转置数组，行列转换
a.transpose()
print(a)

"""
array([[ 0,  4,  8],
       [ 1,  5,  9],
       [ 2,  6, 10],
       [ 3,  7, 11]])
"""

 双端队列的使用

普通列表有append和pop方法，所以可以当做栈或者队列使用
collections.deque实现了一种线程安全的双端队列，可以设置固定长度,对于添加元素时超过长度会做相应处理。

下面简单对双端队列做点介绍:

 

#导入deque
from collections import deque

#创建双端队列，长度设置为10
dq=deque(range(10),maxlen=10)


#deque([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], maxlen=10)


#向右不断移动元素
dq.rotate(3)
print(dq)
"""
    deque([7, 8, 9, 0, 1, 2, 3, 4, 5, 6], maxlen=10)  观察到向右移动，对于出界的元素依次回到了        
                                                                                       前面
"""

#向左边移动元素
dq.rotate(-4)
print(dq)

#从左边添加元素，超出范围的时候，弹出最右边的元素
dq.appendleft(-1)
print(dq)

#从右边添加一些元素
dq.extend([11,22,33])
print(dq)

#从左边添加一些元素
dq.extendleft([10,20,30,40])
print(dq)

dq队列的变化:
deque([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], maxlen=10)

deque([7, 8, 9, 0, 1, 2, 3, 4, 5, 6], maxlen=10)

deque([1, 2, 3, 4, 5, 6, 7, 8, 9, 0], maxlen=10)

deque([-1, 1, 2, 3, 4, 5, 6, 7, 8, 9], maxlen=10)

deque([3, 4, 5, 6, 7, 8, 9, 11, 22, 33], maxlen=10)

deque([40, 30, 20, 10, 3, 4, 5, 6, 7, 8], maxlen=10)

 看到这，相信各位uu又收获满满，小编也是教学相长嘛(@_@)，哈哈。