python 3 三维数组或者多维数组 怎么计算元素的百分比,详细里面会具体一点

Posted

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了python 3 三维数组或者多维数组 怎么计算元素的百分比,详细里面会具体一点相关的知识，希望对你有一定的参考价值。

import Collections#百度过知道collections这个模块,可是不知道适不适合用数组 = [["帅哥",1],["帅哥",0],["帅哥",1],["美女",1],["美女",0],["美女",0],["美女",1]]#数据从数据库取出来的#如何统计数组中"帅哥"为1占全体帅哥的百分比,"美女"为1占"美女"全体的百分
比#返回数组,变量,或者对象都可以#假如事先是不知道数组[i][0]里面是什么字符串的,需要在处理过程中...呃....取值(大概就是这样的意思)最终目标是得到帅哥的百分比:0.66666或者说是2/3和美女的1/3或者说是1/3
多谢 "jjdsjeff" 这个这么优雅的方法

import pandas as pd
df=pd.DataFrame([["帅哥",1],["帅哥",0],["帅哥",1],["美女",1],["美女",0],["美女",0],["美女",1]],columns=['性别','数据'])
df.groupby('性别').mean()

追问

这代码赏心悦目啊

 参考技术A 在Python中，一个像这样的多维表格可以通过“序列的序列”实现。一个表格是行的序列。每一行又是独立单元格的序列。这类似于我们使用的数学记号，在数学里我们用Ai,j，而在Python里我们使用A[i][j]，代表矩阵的第i行第j列。

这看起来非常像“元组的列表”（Lists of Tuples）。

“列表的列表”示例

我们可以使用嵌套的列表推导式（list comprehension）创建一个表格。 下面的例子创建了一个“序列的序列”构成的表格，并为表格的每一个单元格赋值。
table= [ [ 0 for i in range(6) ] for j in range(6) ]
print table
for d1 in range(6):
for d2 in range(6):
table[d1][d2]= d1+d2+2
print table
123456

程序的输出结果如下：
[[0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0]]
[[2, 3, 4, 5, 6, 7], [3, 4, 5, 6, 7, 8], [4, 5, 6, 7, 8, 9],
[5, 6, 7, 8, 9, 10], [6, 7, 8, 9, 10, 11], [7, 8, 9, 10, 11, 12]]
1234

这个程序做了两件事：创建了一个6 × 6的全0表格。 然后使用两枚骰子的可能组合的数值填充表格。 这并非完成此功能最有效的方式，但我们通过这个简单的例子来演示几项技术。我们仔细看一下程序的前后两部分。

程序的第一部分创建并输出了一个包含6个元素的列表，我们称之为“表格”；表格中的每一个元素都是一个包含6个0元素的列表。它使用列表推导式，对
于范围从0到6的每一个j都创建对象。每一个对象都是一个0元素列表，由i变量从0到6遍历产生。初始化完成之后，打印输出二维全0表格。

推导式可以从里向外阅读，就像一个普通表达式一样。内层列表[ 0 for i in range(6) ]创建了一个包含6个0的简单列表。外层列表[ [...] for j in range(6) ]创建了这些内层列表的6个深拷贝。

程序的第2个部分对2个骰子的每一个组合进行迭代，填充表格的每一个单元格。这由两层嵌套循环实现，每一个循环迭代一个骰子。外层循环枚举第一个骰子的所有可能值d1。内层循环枚举第二个骰子d2。

更新每一个单元格时需要通过table[d1]选择每一行；这是一个包含6个值的列表。这个列表中选定的单元格通过...[d2]进行选择。我们将掷骰子的值赋给这个单元格，d1+d2+2

其他示例

打印出的列表的列表不太容易阅读。下面的循环会以一种更加可读的形式显示表格。
>>>
for row in table:

...
print row

...
[2, 3, 4, 5, 6, 7]
[3, 4, 5, 6, 7, 8]
[4, 5, 6, 7, 8, 9]
[5, 6, 7, 8, 9, 10]
[6, 7, 8, 9, 10, 11]
[7, 8, 9, 10, 11, 12]
12345678910111213

作为练习，读者可以试着在打印列表内容时，再打印出行和列的表头。提示一下，使用"%2d" % value字符串运算符可以打印出固定长度的数字格式。

显示索引值（Explicit Index Values）

我们接下来对骰子表格进行汇总统计，得出累计频率表。我们使用一个包含13个元素的列表（下标从0到12）表示每一个骰子值的出现频率。观察可知骰子值2在矩阵中只出现了一次，因此我们期望fq[2]的值为1。遍历矩阵中的每一个单元格，得出累计频率表。
fq= 13 * [0]
for i in range(6):
for j in range(6):
c= table[i][j]
fq[ c ] += 1
12345

使用下标i选出表格中的行，用下标j从行中选出一列，得到单元格c。然后用fq统计频率。

这看起来非常的数学和规范。Python提供了另外一种更简单一些的方式。

使用列表迭代器而非下标

表格是列表的列表，可以采用无下标的for循环遍历列表元素。
fq= 13 * [0]
print fq
for row in table:
for c in row:
fq[c] += 1
print fq[2:]追问

原文看过了,并非想要的处理方式

 参考技术B 这种情况正常，去修理店看看，不行买新的吧。这种情况正常，去修理店看看，不行买新的吧。你可以上网搜索这种情况正常，去修理店看看，不行买新的吧。这种情况正常，去修理店看看，不行买新的吧。你可以上网搜索这种情况正常，去修理店看看，不行买新的吧。这种情况正常，去修理店看看，不行买新的吧。你可以上网搜索

python模块 - numpy

numpy - 基础数组操作

基础

  • 数据分析及机器学习底层库，C语言实现，提供基础数值计算

  • 核心是多维数组的操作，减少python对多维数组操作时的循环

  • numpy.ndarray类表示n维数组类

  • ndarray对象在内存中储存内容

    • 元数据：描述数组信息，如ndim、dimensions、dtype、data等
    • 实际数据：和元数据分离，一定程度减少实际数据访问，提高性能

  • 特点

    • 同质性：数组所有元素必须是相同类型
    • 数组下标：从0开始

array对象

数据类型

类型 符号 字符码(进行类型转换，自定义符合类型标注)
布尔 bool_ ?
有符号整数 int8(-128~127)/int16/32/64 i1/i2/i4/i8
无符号整数 uint8(0~255)/uint16/32/64 u1/u2/u4/u8
浮点数 float/16/32/64 f2/f4/f8
复数 complex64/128 c8/c16
字符串 str_ U<字符数>
日期 datetime64 M8[Y] M8[M] M8[D] M8[h] M8[m] M8[s]

  • 日期 datetime64

    • 常见格式：‘年‘, ‘年-月-日‘, ‘年-月-日 时:分:秒‘
    • 规范化：可对不同精确度的时间精确到统一时间单位 array.astype(‘M8[Y/M/D/h/m/s]‘)
    • 可进行减操作得到时间差，精确到数据中最小时间单位

  • 自定义复合类型

    # 实例
data=[
	(‘zs‘, [90, 80, 85], 15),
	(‘ls‘, [92, 81, 83], 16),
	(‘ww‘, [95, 85, 95], 15)
]

# 方法一：字符串对应每条数据格式
# 创建
a = numpy.array(data,dtype=‘U3, 3int32, int32‘)
# 访问
a[0][‘f0‘] # ‘zs‘

# 方法二：字典对应每条数据字段名称
# 创建
c = np.array(data, dtype={‘names‘: [‘name‘, ‘scores‘, ‘ages‘],
                          ‘formats‘: [‘U3‘, ‘3int32‘, ‘int32‘]})
# 访问
c[0][‘name‘] # ‘zs‘
# 方法三：列表对应每条数据字段名称
# 创建
b = np.array(data, dtype=[(‘name‘, ‘str_‘, 2),
                    	  (‘scores‘, ‘int32‘, 3),
                    	  (‘ages‘, ‘int32‘, 1)])
# 访问
b[0][‘name‘] # ‘zs‘

创建：

  • numpy.array([]) 普通一维数组
  • numpy.arange(start,end,step) 从起始值到终止值按指定步长生成数组
  • numpy.zeros(count,dtype=‘类型‘) 生成count个0组成的一维数组
  • numpy.ones(count,dtype=‘类型‘) 生成count个1组成的一维数组

属性

可查看和修改部分属性

  • 维度(每层元素个数) array.shape
  • 维数 array.ndim
  • 元素类型 array.dtype
  • 个数类
    • 总元素个数 array.size [[1,2],[3,4]]的size为4
    • 最外层元素数 len(array) [[1,2],[3,4]]的len为2
    • 元素字节数 itemsize
    • 总字节数 nvytes
  • 复数
    • 实数部 real
    • 虚数部 iamg
  • 迭代器 flat
  • array[索引] [0][0][0]==[0,0,0]

操作

  • 偏移缩放转置：

    • 每个元素进行相同操作
    • +、-、*、/、**、T

  • 遍历(扁平迭代器)

    • elem for elem in a.flat

  • 类型转换：

    • array.astype(type) 类型强制转换

  • 变维：

    • 就地变维：改变源数据格式
    • 视图变维：数据不同展示形式
    • 复制变维：复制出新的独立数据
    变维类型 方法 描述 数据是否共享
    就地变维 shape() 转为指定格式，无返回值 共享(本身)
    就地变维 resize() 转为指定格式，无返回值 共享(本身)
    视图变维 reshape() 转为指定格式，返回新数组对象 共享(同一数据)
    视图变维 reval() 退化为一维，返回新数组对象 共享共享(同一数据)
    复制变维 flatten() 退化为一维，返回新数组对象 不共享(不同数据) 
    array1 = numpy.arange(1,9) # 1*8 一维数组
array1.shape(2,4) # 2*4 二维数组
array1.resize(2,4) # 2*4 二维数组
array2 = array1.reshape(2,4) # 2*4 二维数组

array1 = numpy.arange(1,9) # 1*8 一维数组
array1.shape(2,2,2) # 2*2*2 三维数组
array1.resize(2,2,2) # 2*2*2 三维数组
array3 = array1.reshape(2,2，2) # 2*2*2 三维数组
array4 = array3.reval() # 1*8 一维数组

array1 = numpy.arange(1,9) # 1*8 一维数组
array5 = array1.flatten() # 1*8 一维数组

array1,array2,array3,array4 共享数据
array5 独立数据

案例：
生成3*3*3的三维数组，元素为1到27
array1 = numpy.arange(1,28).resize(3,3,3)

  • 切片：

    • array([start: end: step，start: end: step，start: end: step]）根据维度切出指定页行列
    # 一维数组
a = numpy.arange(1, 10)
# 1 2 3 4 5 6 7 8 9
# 正序
print(a[::])  # 1 2 3 4 5 6 7 8 9
print(a[:])  # 1 2 3 4 5 6 7 8 9
# 倒序
print(a[::-1])  # 9 8 7 6 5 4 3 2 1
# 省略start，倒推到边界，step=1就end-1倒推，step=-1就end+1倒推
print(a[:4:-1])  # 9 8 7 6 相当于[8:4:-1]
print(a[:-4:-1])  # 9 8 7 相当于[-1:-4:-1]
# 省略end，正推到边界，step=1就start+1正推，step=-1就start-正推
print(a[7::-1])  # 8 7 6 5 4 3 2 1 相当于[7:-1:-1]
print(a[-7::-1])  # 3 2 1 相当于[-7:-10:-1]

  • 掩码：根据指定条件进行筛选

    array = numpy.arange(1, 5)
mask = [True, False,True, False,True]
print(array[mask])
# array([1,3,5])
print(array[array>3])
# array([4,5])
print(array>3)
# array([False, False,True, True,True])

  • 合并拆分

    • 水平方向

      • 合并 c = numpy.hstack((a,b))/row_stack((a,b))

      • 等分a,b = numpy.hsplit(c,2)

        a = numpy.arange(1,1+6).reshape(2,3)
# array([[1,2,3],
#		 [4,5,6]])
b = numpy.arange(1+6,1+12).reshape(2,3)
# array([[7,8,9],
#		 [10,11,12]])
c = numpy.hstack((a,b))
# array([[1,2,3,7,8,9],
#		 [4,5,6,10,11,12]])
d,e = numpy.hsplit(c,2)
# d同a，e同b

    • 垂直方向

      • 合并c = numpy.vstack((a,b))/column_stack((a,b))

      • 等分a,b = numpy.vsplit(c,2)

        a = numpy.arange(1,1+6).reshape(2,3)
# array([[1,2,3],
#		 [4,5,6]])
b = numpy.arange(1+6,1+12).reshape(2,3)
# array([[7,8,9],
#		 [10,11,12]])
c = numpy.vstack((a,b))
# array([[1,2,3],
#		 [4,5,6],
#        [7,8,9],
#		 [10,11,12]])
d,e = numpy.vsplit(c,2)
# d同a，e同b

    • 深度方向

      • 合并c = numpy.dstack((a,b))，等分a,b = numpy.dsplit(c,2)

        a = numpy.arange(1,1+6).reshape(2,3)
# array([[1,2,3],
#		 [4,5,6]])
b = numpy.arange(1+6,1+12).reshape(2,3)
# array([[7,8,9],
#		 [10,11,12]])
c = numpy.dstack((a,b))
# array([[[1,7],
#         [2,8],
#         [3,9]],
#        [[4,10],
#         [5,11],
#         [6,12]]])
d,e = numpy.dsplit(c,2)
# array([[[1],
#         [2],
#         [3]],
#        [[4],
#         [5],
#         [6]]])

    • 通用方法

      • 合并c = numpy.concatenate((a,b),axis=0)
      • 等分a,b = numpy.dsplit(c,2,,axis=0)

以上是关于python 3 三维数组或者多维数组 怎么计算元素的百分比,详细里面会具体一点的主要内容，如果未能解决你的问题，请参考以下文章

Python怎么生成三维数

三维及多维数组

Java 多维数组 三维数组 初始化 赋值 打印

三维数组

JAVA的 一维数组二维数组三维数组多维数组等。

MATLAB中如何定义多维矩阵