zdb呀

python数据分析模块：numpy、pandas全解

文章目录

- 第3章数组的存储和处理：numpy模块
- - 3.1 创建数组
  - - 3.1.1 创建数组：array()函数
    - 3.1.2 创建等差数组：arange()函数
    - 3.1.3 创建随机数组：rand()、randn()、randint()函数
  - 3.2 查看数组的属性
  - - 3.2.1 查看行列数：shape属性
    - 3.2.2 查看元素个数：size属性
    - 3.2.3 查看元素的数据类型：dtype属性
    - 3.2.4 转换元素的数据类型：astype()函数
    - 3.2.5 查看数组维度：ndim属性
  - 3.3 选取数组元素
  - - 3.3.1 一维数组元素的选取
    - 3.3.2 二维数组的元素选取
  - 3.4 数组的重塑和转置
  - - 3.4.1 一维数组的重塑：reshape()函数
    - 3.4.2 多维数组的重塑：reshape()函数
    - 3.4.3 多维重塑为一维：flatten()、ravel()函数
    - 3.4.4 数组的转置：T属性、transpose()函数
  - 3.5 数组的处理
  - - 3.5.1 添加数组元素：append()、insert()函数
    - 3.5.2 删除数组元素：delete()函数
    - 3.5.3 处理数组的缺失值：isnan()函数
    - 3.5.4 处理数组的重复值：unique()函数
    - 3.5.5 拼接数组：concatenate()、hstack()、vstack()函数
    - 3.5.6 拆分数组：split()、hsplit()、vsplit()函数
  - 3.6 数组的运算
  - - 3.6.1 数组之间的四则运算
    - 3.6.2 数组元素的统计运算：sum()、mean()、max()函数
- 第4章 pandas模块入门
- - 4.1 数据结构
  - - 4.1.1 Series对象
    - 4.1.2 DataFrame对象
  - 4.2 读取数据
  - - 4.2.1 读取Excel数据：read_excel()函数
    - - 1. 读取特定工作簿：sheet_name参数
      - 2. 指定列标签：header参数
      - 3. 指定行标签：index_col参数
      - 4. 读取指定列：usecols参数
    - 4.2.2 读取csv文件数据：read_csv()函数
  - 4.3 查看数据的行数和列数
  - - 4.3.1 查看数据的前几行：head()函数
    - 4.3.2 查看行数和列数：shape属性
    - 4.3.3 查看数据的类型
    - - 1. info()函数
      - 2. dtype参数
      - 3. astype()函数
  - 4.4 选择数据
  - - 4.4.1 选择行数据：loc()、iloc()函数
    - - 1. 挑选单行数据
      - 2. 挑选多行数据
      - 3. 挑选满足条件的行
    - 4.4.2 选择列数据：iloc()函数
    - - 1. 挑选单列数据
      - 2. 挑选多列数据
    - 4.4.3 同时选择行列数据
  - 4.5 修改行、列标签：columns、index参数；set_index()函数
- 第五章：pandas模块进阶
- - 5.1 数据的查找和替换
  - - 5.1.1 查找数据：isin()函数
    - 5.1.2 替换数据：replace()函数
  - 5.2 数据的处理
  - - 5.2.1 插入数据：insert()函数
    - 5.2.2 删除元素：drop()函数
    - 5.2.3 处理缺失值
    - - 1. 查看缺失值：isnull()函数
      - 2. 删除缺失值：dropna()函数
      - 3. 缺失值的填充：fillna()函数
    - 5.2.4 处理重复值
    - - 1. 删除重复行：drop_duplicates()函数
      - 2. 删除某一列的重复值：subset参数
      - 3. 获取唯一值：unique()函数
    - 5.2.5 排序数据
    - - 1. sort_values()函数排序数据
      - 2. rank()函数获取数据的排名
    - 5.2.6 筛选数据
  - 5.3 数据表的处理
  - - 5.3.1 转置数据表的行列：T属性
    - 5.3.2 将数据表转换成树形结构：stack()函数
    - 5.3.3 数据表的拼接
    - - 1. merge()函数
      - 2. concat()函数
      - 3. append()函数
  - 5.4 数据的运算
  - - 5.4.1 数据的统计运算：sum()、mean()、max()
    - 5.4.2 获取数值分布情况：describe()
    - 5.4.3 计算相关系数：corr()
    - 5.4.4 分组汇总数据：groupby()
    - 5.4.5 创建数据透视表：pivot_table()
    - 5.4.4 分组汇总数据：groupby()
    - 5.4.5 创建数据透视表：pivot_table()

链接：https://pan.baidu.com/s/10KSLtxnCY3vY6jpmNddgpg
获取提取码可关注威心公宗浩zdb呀，笔记整理不易，我给你白嫖，支持一下加个粉撒~

第3章数组的存储和处理：numpy模块

3.1 创建数组

3.1.1 创建数组：array()函数

一维数组情况：

import numpy as np
a = np.array([1, 2, 3, 4])
b = np.array(['产品编号', '销售数量', '销售单价', '销售金额'])
print(a)
print(b)

[1 2 3 4]
['产品编号' '销售数量' '销售单价' '销售金额']

二维数组情况：

import numpy as np
c = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print (c)

[[1 2 3]
 [4 5 6]
 [7 8 9]]

参数见下表

array(object, dtype=None, copy=True, order=None, subok=False, ndmin=0)

参数	说明
object	必选，为一个序列型对象，如列表、元组、集合等，还可以是一个已创建好的数组
dtype	可选，用于指定数组元素的数据类型
copy	可选，用于设置是否需要复制对象
order	可选，用于指定创建数组的样式
subok	可选，默认返回一个与基类的类型一致的数组
ndmin	可选，用于指定生成数组的最小维度

3.1.2 创建等差数组：arange()函数

索引从0开始，记左不记右

3参数情况：

import numpy as np
d = np.arange(1,20,4)   #第3个参数为步长  可选  默认为1   1~19，步长4   记左不记右
print(d)

[ 1  5  9 13 17]

2参数情况：

import numpy as np
d = np.arange(1,20)
print(d)

[ 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19]

1参数情况：

import numpy as np
d = np.arange(20)
print(d)

[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19]

参数说明见表

arange(start, stop, step, dtype=None)

参数	说明
start	可选，表示起始值。省略时默认为0
stop	必选，表示结束值。生成的数组元素不包括该值
step	可选，表示步长。省略时默认为1。给出该参数则必须给出start参数
dtype	可选，表示数组元素类型。默认为None

3.1.3 创建随机数组：rand()、randn()、randint()函数

1. rand()函数：生成元素值在[0,1)区间的随机数

一维情况：

import numpy as np
e = np.random.rand(3)
print(e)

[0.8412559  0.63220568 0.7395547 ]

二维情况：

import numpy as np
e = np.random.rand(2, 3)
print(e)

[[0.03654404 0.33348249 0.30089453]
 [0.35291365 0.56683093 0.41812811]]

2. randn()函数：生成元素值在[0,1)区间的随机数，且符合标准正态分布

一维情况：

import numpy as np
e = np.random.randn(3)
print(e)

[ 0.36809175 -0.07224965 -0.33366574]

二维情况：

import numpy as np
e = np.random.randn(3, 3)
print(e)

[[ 1.14014499 -0.95577809 -0.94003745]
 [-2.61768236 -0.6565676   0.74041531]
 [-0.3138474   0.68276791  0.17315121]]

3. randint()函数：生成指定范围的随机数，记左不记右

一维情况：

import numpy as np
e = np.random.randint(1, 5, 10)   #随机数范围：[1,5)  10个数
print(e)

[4 1 2 4 1 3 2 4 1 2]

二维情况：第三个参数指定维度

import numpy as np
e = np.random.randint(1, 10, (4, 2))   #随机数范围：[1,10)
print(e)

[[4 4]
 [2 5]
 [3 3]
 [7 8]]

3.2 查看数组的属性

3.2.1 查看行列数：shape属性

import numpy as np
arr = np.array([[1, 2],[3, 4],[5, 6]])
print(arr.shape)

(3, 2)

只查看行数、或者列数

import numpy as np
arr = np.array([[1, 2],[3, 4],[5, 6]])
print(arr.shape[0])   #查看行数
print(arr.shape[1])   #查看列数

3
2

3.2.2 查看元素个数：size属性

import numpy as np
arr = np.array([[1, 2],[3, 4],[5, 6]])
print(arr.size)

3.2.3 查看元素的数据类型：dtype属性

import numpy as np
arr = np.array([[1.3, 2, 3.6, 4], [5, 6, 7.8, 8]])
print(arr.dtype)

float64

3.2.4 转换元素的数据类型：astype()函数

import numpy as np
arr = np.array([[1.3, 2, 3.6, 4], [5, 6, 7.8, 8]])
arr1 = arr.astype(int)
print(arr1)
print(arr1.dtype)

[[1 2 3 4]
 [5 6 7 8]]
int32

3.2.5 查看数组维度：ndim属性

import numpy as np
arr = np.array([[1, 2],[3, 4],[5, 6]])
print(arr.ndim)

3.3 选取数组元素

3.3.1 一维数组元素的选取

1. 选取单个元素

import numpy as np
arr = np.array([12, 2, 40, 64, 56, 6, 57, 18, 95, 17, 21, 12])
print(arr[0])
print(arr[5])
print(arr[-1])   #倒数第1个
print(arr[-4])

2. 选取连续的元素

import numpy as np
arr = np.array([12, 2, 40, 64, 56, 6, 57, 18, 95, 17, 21, 12])
print(arr[1:6])
print(arr[3:-2])
print(arr[:3])
print(arr[:-3])
print(arr[3:])
print(arr[-3:])

[ 2 40 64 56  6]
[64 56  6 57 18 95 17]
[12  2 40]
[12  2 40 64 56  6 57 18 95]
[64 56  6 57 18 95 17 21 12]
[17 21 12]

3. 选取不连续的元素

import numpy as np
arr = np.array([12, 2, 40, 64, 56, 6, 57, 18, 95, 17, 21, 12])
print(arr[1:5:2])  #[1,5) 步长为2 
print(arr[5:1:-2])  #第三个参数指定步长
print(arr[::3])
print(arr[3::])
print(arr[:3:])

[ 2 64]
[ 6 64]
[12 64 57 17]
[64 56  6 57 18 95 17 21 12]
[12  2 40]

3.3.2 二维数组的元素选取

逗号隔开两个索引

1. 选取单个元素

import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])
print(arr[1, 2])  #第1行第2列  索引从0开始

2. 选取单行或单列元素

import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])
print(arr[2])
print(arr[:, 1])

[7 8 9]
[ 2  5  8 11]

3. 选取某些行或某些列的元素

某些行

import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])
print(arr[1:3])
print(arr[:2])
print(arr[2:])

[[4 5 6]
 [7 8 9]]
[[1 2 3]
 [4 5 6]]
[[ 7  8  9]
 [10 11 12]]

某些列

import numpy as np
arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]])
print(arr[:, 1:3])
print(arr[:, :2])
print(arr[:, 2:])

[[ 2  3]
 [ 6  7]
 [10 11]
 [14 15]]
[[ 1  2]
 [ 5  6]
 [ 9 10]
 [13 14]]
[[ 3  4]
 [ 7  8]
 [11 12]
 [15 16]]

4. 同时选取行列元素

import numpy as np
arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]])
print(arr[0:2, 1:3])

[[2 3]
 [6 7]]

3.4 数组的重塑和转置

3.4.1 一维数组的重塑：reshape()函数

import numpy as np
arr = np.array([1, 2, 3, 4, 5, 6, 7, 8])
a = arr.reshape(2, 4)   #需要重塑前后元素个数相等才行
b = arr.reshape(4, 2)
print(a)
print(b)

[[1 2 3 4]
 [5 6 7 8]]
[[1 2]
 [3 4]
 [5 6]
 [7 8]]

3.4.2 多维数组的重塑：reshape()函数

import numpy as np
arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
c = arr.reshape(4, 3)
d = arr.reshape(2, 6)
print(c)
print(d)

[[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [10 11 12]]
[[ 1  2  3  4  5  6]
 [ 7  8  9 10 11 12]]

3.4.3 多维重塑为一维：flatten()、ravel()函数

import numpy as np
arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
print(arr.flatten())  #降为一维
print(arr.ravel())

[ 1  2  3  4  5  6  7  8  9 10 11 12]
[ 1  2  3  4  5  6  7  8  9 10 11 12]

3.4.4 数组的转置：T属性、transpose()函数

1. T属性

import numpy as np
arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
print(arr)
print(arr.T)

[[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]]
[[ 1  5  9]
 [ 2  6 10]
 [ 3  7 11]
 [ 4  8 12]]

2. transpose()函数

import numpy as np
arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
arr1 = np.transpose(arr)
print(arr1)

[[ 1  5  9]
 [ 2  6 10]
 [ 3  7 11]
 [ 4  8 12]]

3.5 数组的处理

3.5.1 添加数组元素：append()、insert()函数

1. append()函数

import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6]])
arr1 = np.append(arr, [[7, 8, 9]])
print(arr1)

[1 2 3 4 5 6 7 8 9]

可以看出append()函数在二维数组中添加元素，结果转为了一维数组。

那怎么保持二维数组呢？可以设置axis参数按行或者按列添加

axis=0：按行添加

import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6]])
arr1 = np.append(arr, [[7, 8, 9]], axis = 0)
print(arr1)

[[1 2 3]
 [4 5 6]
 [7 8 9]]

axis=1：按列添加

import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6]])
arr1 = np.append(arr, [[7, 8],[9, 10]], axis = 1)
print(arr1)

[[ 1  2  3  7  8]
 [ 4  5  6  9 10]]

append()函数参数如下

append(arr, values, axis=None)

参数	说明
arr	必选，要添加元素的数组
values	必选，要添加的数组元素
axis	可选，默认为None。省略此参数时，默认当一维数组尾插元素。为0按行添加；为1按列添加

2. insert()函数

import numpy as np
arr = np.array([[1, 2], [3, 4], [5, 6]])
arr1 = np.insert(arr, 1, [7, 8])
print(arr1)

[1 7 8 2 3 4 5 6]

可以看出先把二维数组降成了一维数组，再在索引为1的位置添加元素。

那么怎么保持在二维添加元素呢？同样设置axis参数

import numpy as np
arr = np.array([[1, 2], [3, 4], [5, 6]])
arr1 = np.insert(arr, 1, [7, 8], axis = 0)
arr2 = np.insert(arr, 1, [7, 8, 9], axis = 1)
print(arr1)
print(arr2)

[[1 2]
 [7 8]
 [3 4]
 [5 6]]
[[1 7 2]
 [3 8 4]
 [5 9 6]]

insert()参数如下

insert(arr, obj, values, axis)

参数	说明
arr	必选，要插入元素的数组
obj	必选，数组的索引值，表示插入元素的位置
values	必选，要插入的元素
axis	可选，省略此参数时，默认当一维数组插入。为0按行；为1按列

3.5.2 删除数组元素：delete()函数

也分按行和按列删除

import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
arr1 = np.delete(arr, 2)
arr2 = np.delete(arr, 2, axis = 0)
arr3 = np.delete(arr, 2, axis = 1)
print(arr1) 
print(arr2)
print(arr3)

[1 2 4 5 6 7 8 9]
[[1 2 3]
 [4 5 6]]
[[1 2]
 [4 5]
 [7 8]]

3.5.3 处理数组的缺失值：isnan()函数

标记缺失值：isnan()函数

import numpy as np
arr = np.array([1, 2, 3, 4, 5, 6, np.nan, 8, 9])
print(arr)
print(np.isnan(arr))

[ 1.  2.  3.  4.  5.  6. nan  8.  9.]
[False False False False False False  True False False]

补充缺失值：

arr[np.isnan(arr)] = 0
print(arr)

[1. 2. 3. 4. 5. 6. 0. 8. 9.]

3.5.4 处理数组的重复值：unique()函数

import numpy as np
arr = np.array([8, 4, 2, 3, 5, 2, 5, 5, 6, 8, 8, 9])
arr1 = np.unique(arr)
arr1, arr2 = np.unique(arr, return_counts=True) # 两个返回值   arr1为去重后数组   arr2为每个元素出现的次数
print(arr1)
print(arr2)

[2 3 4 5 6 8 9]
[2 1 1 3 1 3 1]

3.5.5 拼接数组：concatenate()、hstack()、vstack()函数

1. concatenate()函数

同样axis参数可以指定拼接按行还是按列

import numpy as np
arr1 = np.array([[1, 2, 3], [4, 5, 6]])
arr2 = np.array([[7, 8, 9], [10, 11, 12]])
arr3 = np.concatenate((arr1, arr2), axis=0)   #行方向上拼接
arr4 = np.concatenate((arr1, arr2), axis=1)   #列方向上拼接
print(arr3)
print(arr4)

[[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [10 11 12]]
[[ 1  2  3  7  8  9]
 [ 4  5  6 10 11 12]]

2. hstack()函数：以水平堆叠的方式拼接数组

import numpy as np
arr1 = np.array([[1, 2, 3], [4, 5, 6]])
arr2 = np.array([[7, 8, 9], [10, 11, 12]])
arr3 = np.hstack((arr1, arr2))
print(arr3)

[[ 1  2  3  7  8  9]
 [ 4  5  6 10 11 12]]

3. vstack()函数：以垂直堆叠的方式拼接数组

import numpy as np
arr1 = np.array([[1, 2, 3], [4, 5, 6]])
arr2 = np.array([[7, 8, 9], [10, 11, 12]])
arr3 = np.vstack((arr1, arr2))
print(arr3)

[[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [10 11 12]]

3.5.6 拆分数组：split()、hsplit()、vsplit()函数

1. split()函数

import numpy as np
arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
arr1 = np.split(arr, 2)   #第2个参数指定拆成几个数组
arr2 = np.split(arr, 4)
print(arr1)
print(arr2)

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

第二个参数还可以是数组，指定拆分的位置

import numpy as np
arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
arr3 = np.split(arr, [2, 6])
arr4 = np.split(arr, [2, 3, 8, 10])
print(arr3)
print(arr4)

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

2. hsplit()函数和vsplit()函数

hsplit()函数：横向拆成几个数组

vsplit()函数：纵向拆成几个数组

import numpy as np
arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9 , 10, 11, 12],[13, 14, 15, 16]])
arr5 = np.hsplit(arr, 2)
arr6 = np.vsplit(arr, 2)
print(arr5)
print(arr6)

[array([[ 1,  2],
       [ 5,  6],
       [ 9, 10],
       [13, 14]]), array([[ 3,  4],
       [ 7,  8],
       [11, 12],
       [15, 16]])]
[array([[1, 2, 3, 4],
       [5, 6, 7, 8]]), array([[ 9, 10, 11, 12],
       [13, 14, 15, 16]])]

3.6 数组的运算

3.6.1 数组之间的四则运算

数组与数组之间的运算

import numpy as np
arr1 = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])         
arr2 = np.array([[9, 10, 11, 12], [13, 14, 15, 16]])
arr3 = arr1 + arr2     #对应位置的元素相加
arr4 = arr1 * arr2     #对应位置的元素相乘
print(arr3)
print(arr4)

[[10 12 14 16]
 [18 20 22 24]]
[[  9  20  33  48]
 [ 65  84 105 128]]

数组与数值的运算

import numpy as np
arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])
arr5 = arr + 5       #每个位置的元素+5
arr6 = arr * 10      #每个位置的元素*10
print(arr5)
print(arr6)

[[ 6  7  8  9]
 [10 11 12 13]]
[[10 20 30 40]
 [50 60 70 80]]

3.6.2 数组元素的统计运算：sum()、mean()、max()函数

1. 求和：sum()函数

可以指定整个数组求和，还是按行或者按列

axis=0：每一列的元素求和

axis=1：每一行的元素求和

import numpy as np
arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
arr1 = arr.sum()
arr2 = arr.sum(axis=0)  #每一列的元素求和
arr3 = arr.sum(axis=1)  #每一行的元素求和
print(arr1)
print(arr2)
print(arr3)

78
[15 18 21 24]
[10 26 42]

2. 求平均值：mean()函数

axis=0：每一列求均值

axis=1：每一行求均值

import numpy as np
arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
arr1 = arr.mean()
arr2 = arr.mean(axis=0)  #每一列求均值
arr3 = arr.mean(axis=1)  #每一行求均值
print(arr1)
print(arr2)
print(arr3)

6.5
[5. 6. 7. 8.]
[ 2.5  6.5 10.5]

3. 求最值：max()函数

axis=0：每一列求最大值

axis=1：每一行求最大值

import numpy as np
arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
arr1 = arr.max()
arr2 = arr.max(axis=0)   #每一列求最大值
arr3 = arr.max(axis=1)   #每一行求最大值
print(arr1)
print(arr2)
print(arr3)

12
[ 9 10 11 12]
[ 4  8 12]

第4章 pandas模块入门

4.1 数据结构

pandas有两个重要的数据结构对象：Series和DataFrame。

4.1.1 Series对象

Series是创建一个一维数组对象，会自动生成行标签。

import pandas as pd
s = pd.Series(['短裤', '毛衣', '连衣裙', '牛仔裤'])
print(s)

0     短裤
1     毛衣
2    连衣裙
3    牛仔裤
dtype: object

index参数可以指定行标签

import pandas as pd
s1 = pd.Series(['短裤', '毛衣', '连衣裙', '牛仔裤'], index = ['a001', 'a002', 'a003', 'a004'])
print(s1)

a001     短裤
a002     毛衣
a003    连衣裙
a004    牛仔裤
dtype: object

使用Series对象还可以基于字典创建数据

import pandas as pd
s2 = pd.Series({'a001':'短裤', 'a002':'毛衣', 'a003':'连衣裙', 'a004':'牛仔裤'})
print(s2)

a001     短裤
a002     毛衣
a003    连衣裙
a004    牛仔裤
dtype: object

4.1.2 DataFrame对象

会自动生成行列标签

import pandas as pd
df = pd.DataFrame([['短裤', 45], ['毛衣', 69], ['连衣裙', 119], ['牛仔裤', 99]])
print(df)

     0    1
0   短裤   45
1   毛衣   69
2  连衣裙  119
3  牛仔裤   99

可以columns参数指定列标签；index参数指定行标签

import pandas as pd
df1 = pd.DataFrame([['短裤', 45], ['毛衣', 69], ['连衣裙', 119], ['牛仔裤', 99]], 
                   columns=['产品', '单价'], index=['a001', 'a002', 'a003', 'a004'])
print(df1)

       产品   单价
a001   短裤   45
a002   毛衣   69
a003  连衣裙  119
a004  牛仔裤   99

也可以用字典形式生成数据

import pandas as pd
df3 = pd.DataFrame({'产品':['短裤', '毛衣', '连衣裙', '牛仔裤'],'单价':[45, 69, 119, 99]})
print(df3)

    产品   单价
0   短裤   45
1   毛衣   69
2  连衣裙  119
3  牛仔裤   99

在用字典生成数据的基础上，同时指定行标签

import pandas as pd
df3 = pd.DataFrame({'产品':['短裤', '毛衣', '连衣裙', '牛仔裤'],'单价':[45, 69, 119, 99]}, index = ['a001', 'a002', 'a003', 'a004'])
print(df3)

       产品   单价
a001   短裤   45
a002   毛衣   69
a003  连衣裙  119
a004  牛仔裤   99

4.2 读取数据

4.2.1 读取Excel数据：read_excel()函数

1. 读取特定工作簿：sheet_name参数

例如对下表的数据进行读取

4月是第四个表，我们应把sheet_name参数指定为3；因为索引是从0开始的。

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name=3)
print(data)

   订单编号   产品  数量    金额
0  d001  投影仪  5台  2000
1  d002  马克笔  5盒   300
2  d003  打印机  1台   298
3  d004  点钞机  1台   349
4  d005  复印纸  2箱   100
5  d006  条码纸  6卷    34

可以看出read_excel()函数自动创建了一个DataFrame对象，同时自动把第一行数据当做列标签。

2. 指定列标签：header参数

header参数可以指定列标签

可以看出不给出header参数时，该参数默认为0。

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name=3, header=0)
print(data)

   订单编号   产品  数量    金额
0  d001  投影仪  5台  2000
1  d002  马克笔  5盒   300
2  d003  打印机  1台   298
3  d004  点钞机  1台   349
4  d005  复印纸  2箱   100
5  d006  条码纸  6卷    34

header=1时结果如下：

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name=3, header=1)
print(data)

   d001  投影仪  5台  2000
0  d002  马克笔  5盒   300
1  d003  打印机  1台   298
2  d004  点钞机  1台   349
3  d005  复印纸  2箱   100
4  d006  条码纸  6卷    34

header=None时结果如下：

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name = 3, header = None)
print(data)

      0    1   2     3
0  订单编号   产品  数量    金额
1  d001  投影仪  5台  2000
2  d002  马克笔  5盒   300
3  d003  打印机  1台   298
4  d004  点钞机  1台   349
5  d005  复印纸  2箱   100
6  d006  条码纸  6卷    34

3. 指定行标签：index_col参数

该参数默认为None

index_col=0时，第0列为列标签

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name=3, index_col=0)
print(data)

       产品  数量    金额
订单编号               
d001  投影仪  5台  2000
d002  马克笔  5盒   300
d003  打印机  1台   298
d004  点钞机  1台   349
d005  复印纸  2箱   100
d006  条码纸  6卷    34

index_col=0时

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name=3, index_col=1)
print(data)

     订单编号  数量    金额
产品                 
投影仪  d001  5台  2000
马克笔  d002  5盒   300
打印机  d003  1台   298
点钞机  d004  1台   349
复印纸  d005  2箱   100
条码纸  d006  6卷    34

4. 读取指定列：usecols参数

usecols=[2]：指定第二列

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name=3, usecols=[2])
print(data)

指定多列

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name=3, usecols=[1, 3])
print(data)

    产品    金额
0  投影仪  2000
1  马克笔   300
2  打印机   298
3  点钞机   349
4  复印纸   100
5  条码纸    34

4.2.2 读取csv文件数据：read_csv()函数

数据如下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-j1SHxY8y-1637655972909)(C:\Users\14051\AppData\Roaming\Typora\typora-user-images\image-20211114192949607.png)]

import pandas as pd
data = pd.read_csv('订单表.csv')
print(data)

   订单编号   产品  数量    金额
0  d001  投影仪  5台  2000
1  d002  马克笔  5盒   300
2  d003  打印机  1台   298
3  d004  点钞机  1台   349
4  d005  复印纸  2箱   100
5  d006  条码纸  6卷    34

nrows参数可以指定显示的行数

nrows=3时

import pandas as pd
data = pd.read_csv('订单表.csv', nrows=3)
print(data)

   订单编号   产品  数量    金额
0  d001  投影仪  5台  2000
1  d002  马克笔  5盒   300
2  d003  打印机  1台   298

4.3 查看数据的行数和列数

4.3.1 查看数据的前几行：head()函数

head()函数中参数为空默认前5行

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name=3)
print(data.head())

   订单编号   产品  数量    金额
0  d001  投影仪  5台  2000
1  d002  马克笔  5盒   300
2  d003  打印机  1台   298
3  d004  点钞机  1台   349
4  d005  复印纸  2箱   100

指定head(3)时如下

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name=3)
print(data.head(3))

   订单编号   产品  数量    金额
0  d001  投影仪  5台  2000
1  d002  马克笔  5盒   300
2  d003  打印机  1台   298

4.3.2 查看行数和列数：shape属性

numpy模块也是shape

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name=3)
print(data)
print(data.shape)

   订单编号   产品  数量    金额
0  d001  投影仪  5台  2000
1  d002  马克笔  5盒   300
2  d003  打印机  1台   298
3  d004  点钞机  1台   349
4  d005  复印纸  2箱   100
5  d006  条码纸  6卷    34
(6, 4)

4.3.3 查看数据的类型

1. info()函数

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name = 3)
print(data.info())

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 6 entries, 0 to 5
Data columns (total 4 columns):
 #   Column  Non-Null Count  Dtype 
---  ------  --------------  ----- 
 0   订单编号    6 non-null      object
 1   产品      6 non-null      object
 2   数量      6 non-null      object
 3   金额      6 non-null      int64 
dtypes: int64(1), object(3)
memory usage: 320.0+ bytes
None

2. dtype参数

查看特定列的书库类型

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name = 3)
print(data['金额'].dtype)

int64

3. astype()函数

特定列数据类型转换

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name = 3)
data['金额'] = data['金额'].astype('float64')
print(data)
print(data['金额'].dtype)

   订单编号   产品  数量      金额
0  d001  投影仪  5台  2000.0
1  d002  马克笔  5盒   300.0
2  d003  打印机  1台   298.0
3  d004  点钞机  1台   349.0
4  d005  复印纸  2箱   100.0
5  d006  条码纸  6卷    34.0
float64

4.4 选择数据

4.4.1 选择行数据：loc()、iloc()函数

先查看一下所有数据

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name=3, index_col=0)  #index_col指定行标签
print(data)

       产品  数量    金额
订单编号               
d001  投影仪  5台  2000
d002  马克笔  5盒   300
d003  打印机  1台   298
d004  点钞机  1台   349
d005  复印纸  2箱   100
d006  条码纸  6卷    34

1. 挑选单行数据

loc()函数加行标签指定行

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name=3, index_col=0)
print(data.loc['d001'])

产品     投影仪
数量      5台
金额    2000
Name: d001, dtype: object

iloc()函数加索引指定行号

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name=3, index_col=0)
print(data.iloc[2])

产品    打印机
数量     1台
金额    298
Name: d003, dtype: object

2. 挑选多行数据

与单行相比，结果显示的格式不一样了

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name=3, index_col=0)
print(data.loc[['d002', 'd004']])

       产品  数量   金额
订单编号              
d002  马克笔  5盒  300
d004  点钞机  1台  349

iloc()挑选：

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name=3, index_col=0)
print(data.iloc[[1, 5]])

       产品  数量   金额
订单编号              
d002  马克笔  5盒  300
d006  条码纸  6卷   34
       产品  数量   金额

或者给出区间

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name=3, index_col=0)
print(data.iloc[1:5])

       产品  数量   金额
订单编号              
d002  马克笔  5盒  300
d003  打印机  1台  298
d004  点钞机  1台  349
d005  复印纸  2箱  100

3. 挑选满足条件的行

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name=3, index_col=0)
a = data['金额'] < 300   #挑选金额>300的行
print(data[a])

       产品  数量   金额
订单编号              
d003  打印机  1台  298
d005  复印纸  2箱  100
d006  条码纸  6卷   34

4.4.2 选择列数据：iloc()函数

1. 挑选单列数据

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name=3)
print(data['产品'])

0    投影仪
1    马克笔
2    打印机
3    点钞机
4    复印纸
5    条码纸
Name: 产品, dtype: object

2. 挑选多列数据

挑选数据要么标签，要么索引挑选

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name=3)
print(data[['产品', '金额']])

    产品    金额
0  投影仪  2000
1  马克笔   300
2  打印机   298
3  点钞机   349
4  复印纸   100
5  条码纸    34

或者

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name=3)
print(data.iloc[:, [1,3]])

    产品    金额
0  投影仪  2000
1  马克笔   300
2  打印机   298
3  点钞机   349
4  复印纸   100
5  条码纸    34

或者写成区间

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name=3)
print(data.iloc[:, 1:3])

    产品  数量
0  投影仪  5台
1  马克笔  5盒
2  打印机  1台
3  点钞机  1台
4  复印纸  2箱
5  条码纸  6卷

4.4.3 同时选择行列数据

标签挑选

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name=3, index_col=0)
data1 = data.loc[['d001', 'd005'], ['产品', '金额']]
print(data1)

       产品    金额
订单编号           
d001  投影仪  2000
d005  复印纸   100

或者索引挑选

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name=3, index_col=0)
data2 = data.iloc[[2, 4], [0, 2]]
print(data2)

       产品   金额
订单编号          
d003  打印机  298
d005  复印纸  100

4.5 修改行、列标签：columns、index参数；set_index()函数

先查看一下数据

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name=3)
print(data)

   订单编号   产品  数量    金额
0  d001  投影仪  5台  2000
1  d002  马克笔  5盒   300
2  d003  打印机  1台   298
3  d004  点钞机  1台   349
4  d005  复印纸  2箱   100
5  d006  条码纸  6卷    34

set_index()设置行标签

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name=3)
print(data.set_index('订单编号'))

       产品  数量    金额
订单编号               
d001  投影仪  5台  2000
d002  马克笔  5盒   300
d003  打印机  1台   298
d004  点钞机  1台   349
d005  复印纸  2箱   100
d006  条码纸  6卷    34

或者用字典一对一修改

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name=3)
data = data.rename(columns={'订单编号':'编号', '产品':'产品名称', '数量':'订单数量', '金额':'订单金额'}, 
                   index = {0:'A', 1:'B', 2:'C', 3:'D', 4:'E', 5:'F'})
print(data)

     编号 产品名称 订单数量  订单金额
A  d001  投影仪   5台  2000
B  d002  马克笔   5盒   300
C  d003  打印机   1台   298
D  d004  点钞机   1台   349
E  d005  复印纸   2箱   100
F  d006  条码纸   6卷    34

columns、index参数分别修改列、行标签

import pandas as pd
data = pd.read_excel('订单表.xlsx', sheet_name=3)
data.columns = ['编号', '产品名称', '订单数量', '订单金额']
data.index = ['A', 'B', 'C', 'D', 'E', 'F']
print(data)

     编号 产品名称 订单数量  订单金额
A  d001  投影仪   5台  2000
B  d002  马克笔   5盒   300
C  d003  打印机   1台   298
D  d004  点钞机   1台   349
E  d005  复印纸   2箱   100
F  d006  条码纸   6卷    34

第五章：pandas模块进阶

5.1 数据的查找和替换

5.1.1 查找数据：isin()函数

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-a6QKIoie-1637655972912)(C:\Users\14051\AppData\Roaming\Typora\typora-user-images\image-20211123110431201.png)]

import pandas as pd
data = pd.read_excel('产品统计表.xlsx')
print(data)

     编号   产品  成本价(元/个)  销售价(元/个)  数量(个)  成本(元)  收入(元)  利润(元)
0  a001   背包        16        65     60    960   3900   2940
1  a002   钱包        90       187     50   4500   9350   4850
2  a003   背包        16        65     23    368   1495   1127
3  a004  手提包        36       147     26    936   3822   2886
4  a005   钱包        90       187     78   7020  14586   7566
5  a006  单肩包        58       124     63   3654   7812   4158
6  a007  单肩包        58       124     58   3364   7192   3828

isin()函数查看表中是否有该值

data1 = data.isin(['a005','钱包'])
print(data1)

      编号     产品  成本价(元/个)  销售价(元/个)  数量(个)  成本(元)  收入(元)  利润(元)
0  False  False     False     False  False  False  False  False
1  False   True     False     False  False  False  False  False
2  False  False     False     False  False  False  False  False
3  False  False     False     False  False  False  False  False
4   True   True     False     False  False  False  False  False
5  False  False     False     False  False  False  False  False
6  False  False     False     False  False  False  False  False

查看特定列是否有该值

data2 = data['产品'].isin(['手提包'])
print(data2)

0    False
1    False
2    False
3     True
4    False
5    False
6    False
Name: 产品, dtype: bool

5.1.2 替换数据：replace()函数

import pandas as pd
data = pd.read_excel('产品统计表.xlsx')
data.replace('背包', '挎包')    #并没有替换
print(data)

     编号   产品  成本价(元/个)  销售价(元/个)  数量(个)  成本(元)  收入(元)  利润(元)
0  a001   背包        16        65     60    960   3900   2940
1  a002   钱包        90       187     50   4500   9350   4850
2  a003   背包        16        65     23    368   1495   1127
3  a004  手提包        36       147     26    936   3822   2886
4  a005   钱包        90       187     78   7020  14586   7566
5  a006  单肩包        58       124     63   3654   7812   4158
6  a007  单肩包        58       124     58   3364   7192   3828

可以看出上述代码并没有替换，那怎么替换呢？

1. 一对一替换

import pandas as pd
data = pd.read_excel('产品统计表.xlsx')
data.replace('背包', '挎包', inplace = True)
print(data)

     编号   产品  成本价(元/个)  销售价(元/个)  数量(个)  成本(元)  收入(元)  利润(元)
0  a001   挎包        16        65     60    960   3900   2940
1  a002   钱包        90       187     50   4500   9350   4850
2  a003   挎包        16        65     23    368   1495   1127
3  a004  手提包        36       147     26    936   3822   2886
4  a005   钱包        90       187     78   7020  14586   7566
5  a006  单肩包        58       124     63   3654   7812   4158
6  a007  单肩包        58       124     58   3364   7192   3828

2. 多对一替换

import pandas as pd
data = pd.read_excel('产品统计表.xlsx')
data.replace(['背包', '手提包'], '挎包', inplace = True)
print(data)

     编号   产品  成本价(元/个)  销售价(元/个)  数量(个)  成本(元)  收入(元)  利润(元)
0  a001   挎包        16        65     60    960   3900   2940
1  a002   钱包        90       187     50   4500   9350   4850
2  a003   挎包        16        65     23    368   1495   1127
3  a004   挎包        36       147     26    936   3822   2886
4  a005   钱包        90       187     78   7020  14586   7566
5  a006  单肩包        58       124     63   3654   7812   4158
6  a007  单肩包        58       124     58   3364   7192   3828

3. 多对多替换

import pandas as pd
data = pd.read_excel('产品统计表.xlsx')
data.replace({'背包':'挎包', 16:39, 65:88}, inplace = True)
print(data)

     编号   产品  成本价(元/个)  销售价(元/个)  数量(个)  成本(元)  收入(元)  利润(元)
0  a001   挎包        39        88     60    960   3900   2940
1  a002   钱包        90       187     50   4500   9350   4850
2  a003   挎包        39        88     23    368   1495   1127
3  a004  手提包        36       147     26    936   3822   2886
4  a005   钱包        90       187     78   7020  14586   7566
5  a006  单肩包        58       124     63   3654   7812   4158
6  a007  单肩包        58       124     58   3364   7192   3828

5.2 数据的处理

5.2.1 插入数据：insert()函数

末尾插入一列

import pandas as pd
data = pd.read_excel('产品统计表.xlsx')
data['品牌'] = ['AM', 'DE', 'SR', 'AM', 'TY', 'DE', 'UD']
print(data)

     编号   产品  成本价(元/个)  销售价(元/个)  数量(个)  成本(元)  收入(元)  利润(元)  品牌
0  a001   背包        16        65     60    960   3900   2940  AM
1  a002   钱包        90       187     50   4500   9350   4850  DE
2  a003   背包        16        65     23    368   1495   1127  SR
3  a004  手提包        36       147     26    936   3822   2886  AM
4  a005   钱包        90       187     78   7020  14586   7566  TY
5  a006  单肩包        58       124     63   3654   7812   4158  DE
6  a007  单肩包        58       124     58   3364   7192   3828  UD

指定插入到哪列

import pandas as pd
data = pd.read_excel('产品统计表.xlsx')
data.insert(2, '品牌', ['AM', 'DE', 'SR', 'AM', 'TY', 'DE', 'UD'])
print(data)

     编号   产品  品牌  成本价(元/个)  销售价(元/个)  数量(个)  成本(元)  收入(元)  利润(元)
0  a001   背包  AM        16        65     60    960   3900   2940
1  a002   钱包  DE        90       187     50   4500   9350   4850
2  a003   背包  SR        16        65     23    368   1495   1127
3  a004  手提包  AM        36       147     26    936   3822   2886
4  a005   钱包  TY        90       187     78   7020  14586   7566
5  a006  单肩包  DE        58       124     63   3654   7812   4158
6  a007  单肩包  UD        58       124     58   3364   7192   3828

5.2.2 删除元素：drop()函数

axis参数可以指定删除行还是删除列

1. 删除列

指定标签删除

import pandas as pd
data = pd.read_excel('产品统计表.xlsx')
a = data.drop(['成本价(元/个)', '成本(元)'], axis = 1)
print(a)

     编号   产品  销售价(元/个)  数量(个)  收入(元)  利润(元)
0  a001   背包        65     60   3900   2940
1  a002   钱包       187     50   9350   4850
2  a003   背包        65     23   1495   1127
3  a004  手提包       147     26   3822   2886
4  a005   钱包       187     78  14586   7566
5  a006  单肩包       124     63   7812   4158
6  a007  单肩包       124     58   7192   3828

指定索引删除

import pandas as pd
data = pd.read_excel('产品统计表.xlsx')
b = data.drop(data.columns[[2, 5]], axis = 1)
print(b)

     编号   产品  销售价(元/个)  数量(个)  收入(元)  利润(元)
0  a001   背包        65     60   3900   2940
1  a002   钱包       187     50   9350   4850
2  a003   背包        65     23   1495   1127
3  a004  手提包       147     26   3822   2886
4  a005   钱包       187     78  14586   7566
5  a006  单肩包       124     63   7812   4158
6  a007  单肩包       124     58   7192   3828

方法三

import pandas as pd
data = pd.read_excel('产品统计表.xlsx')
c = data.drop(columns = ['成本价(元/个)', '成本(元)'])
print(c)

     编号   产品  销售价(元/个)  数量(个)  收入(元)  利润(元)
0  a001   背包        65     60   3900   2940
1  a002   钱包       187     50   9350   4850
2  a003   背包        65     23   1495   1127
3  a004  手提包       147     26   3822   2886
4  a005   钱包       187     78  14586   7566
5  a006  单肩包       124     63   7812   4158
6  a007  单肩包       124     58   7192   3828

2. 删除行

指定行标签删除

import pandas as pd
data = pd.read_excel('产品统计表.xlsx', index_col = 0)
a = data.drop(['a001', 'a004'], axis = 0)
print(a)

       产品  成本价(元/个)  销售价(元/个)  数量(个)  成本(元)  收入(元)  利润(元)
编号                                                       
a002   钱包        90       187     50   4500   9350   4850
a003   背包        16        65     23    368   1495   1127
a005   钱包        90       187     78   7020  14586   7566
a006  单肩包        58       124     63   3654   7812   4158
a007  单肩包        58       124     58   3364   7192   3828

指定索引删除

import pandas as pd
data = pd.read_excel('产品统计表.xlsx', index_col = 0)
b = data.drop(data.index[[0, 4]], axis = 0)
print(b)

       产品  成本价(元/个)  销售价(元/个)  数量(个)  成本(元)  收入(元)  利润(元)
编号                                                       
a002   钱包        90       187     50   4500   9350   4850
a003   背包        16        65     23    368   1495   1127
a004  手提包        36       147     26    936   3822   2886
a006  单肩包        58       124     63   3654   7812   4158
a007  单肩包        58       124     58   3364   7192   3828

方法三：

import pandas as pd
data = pd.read_excel('产品统计表.xlsx', index_col = 0)
c = data.drop(index = ['a001', 'a004'])
print(c)

       产品  成本价(元/个)  销售价(元/个)  数量(个)  成本(元)  收入(元)  利润(元)
编号                                                       
a002   钱包        90       187     50   4500   9350   4850
a003   背包        16        65     23    368   1495   1127
a005   钱包        90       187     78   7020  14586   7566
a006  单肩包        58       124     63   3654   7812   4158
a007  单肩包        58       124     58   3364   7192   3828

5.2.3 处理缺失值

1. 查看缺失值：isnull()函数

先查看所有数据

import pandas as pd
data = pd.read_excel('产品统计表1.xlsx')
print(data)

     编号   产品  成本价(元/个)  销售价(元/个)  数量(个)   成本(元)  收入(元)  利润(元)
0  a001   背包      16.0        65     60   960.0   3900   2940
1  a002   钱包      90.0       187     50  4500.0   9350   4850
2  a003   背包       NaN        65     23   368.0   1495   1127
3  a004  手提包      36.0       147     26   936.0   3822   2886
4  a005   钱包      90.0       187     78  7020.0  14586   7566
5  a006  单肩包      58.0       124     63  3654.0   7812   4158
6  a007  单肩包      58.0       124     58     NaN   7192   3828

info()函数查看数据类型，还可以查看是否有缺失值

import pandas as pd
data = pd.read_excel('产品统计表1.xlsx')
data.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 7 entries, 0 to 6
Data columns (total 8 columns):
 #   Column    Non-Null Count  Dtype  
---  ------    --------------  -----  
 0   编号        7 non-null      object 
 1   产品        7 non-null      object 
 2   成本价(元/个)  6 non-null      float64
 3   销售价(元/个)  7 non-null      int64  
 4   数量(个)     7 non-null      int64  
 5   成本(元)     6 non-null      float64
 6   收入(元)     7 non-null      int64  
 7   利润(元)     7 non-null      int64  
dtypes: float64(2), int64(4), object(2)
memory usage: 576.0+ bytes

isnull()函数查看是否有缺失值

在numpy模块中用isnan()函数

import pandas as pd
data = pd.read_excel('产品统计表1.xlsx')
a = data.isnull()
print(a)

      编号     产品  成本价(元/个)  销售价(元/个)  数量(个)  成本(元)  收入(元)  利润(元)
0  False  False     False     False  False  False  False  False
1  False  False     False     False  False  False  False  False
2  False  False      True     False  False  False  False  False
3  False  False     False     False  False  False  False  False
4  False  False     False     False  False  False  False  False
5  False  False     False     False  False  False  False  False
6  False  False     False     False  False   True  False  False

2. 删除缺失值：dropna()函数

删除有缺失值的行

import pandas as pd
data = pd.read_excel('产品统计表1.xlsx')
b = data.dropna()
print(b)

     编号   产品  成本价(元/个)  销售价(元/个)  数量(个)   成本(元)  收入(元)  利润(元)
0  a001   背包      16.0        65     60   960.0   3900   2940
1  a002   钱包      90.0       187     50  4500.0   9350   4850
3  a004  手提包      36.0       147     26   936.0   3822   2886
4  a005   钱包      90.0       187     78  7020.0  14586   7566
5  a006  单肩包      58.0       124     63  3654.0   7812   4158

删除整行都为缺失值的行：需要指定how参数

import pandas as pd
data = pd.read_excel('产品统计表1.xlsx')
c = data.dropna(how = 'all')
print(c)

     编号   产品  成本价(元/个)  销售价(元/个)  数量(个)   成本(元)  收入(元)  利润(元)
0  a001   背包      16.0        65     60   960.0   3900   2940
1  a002   钱包      90.0       187     50  4500.0   9350   4850
2  a003   背包       NaN        65     23   368.0   1495   1127
3  a004  手提包      36.0       147     26   936.0   3822   2886
4  a005   钱包      90.0       187     78  7020.0  14586   7566
5  a006  单肩包      58.0       124     63  3654.0   7812   4158
6  a007  单肩包      58.0       124     58     NaN   7192   3828

3. 缺失值的填充：fillna()函数

import pandas as pd
data = pd.read_excel('产品统计表1.xlsx')
d = data.fillna(0)   # 缺失值全部填充为0
print(d)

     编号   产品  成本价(元/个)  销售价(元/个)  数量(个)   成本(元)  收入(元)  利润(元)
0  a001   背包      16.0        65     60   960.0   3900   2940
1  a002   钱包      90.0       187     50  4500.0   9350   4850
2  a003   背包       0.0        65     23   368.0   1495   1127
3  a004  手提包      36.0       147     26   936.0   3822   2886
4  a005   钱包      90.0       187     78  7020.0  14586   7566
5  a006  单肩包      58.0       124     63  3654.0   7812   4158
6  a007  单肩包      58.0       124     58     0.0   7192   3828

不同列的缺失值设置不同的填充值

import pandas as pd
data = pd.read_excel('产品统计表1.xlsx')
e = data.fillna({'成本价(元/个)':16, '成本(元)':3364})
print(e)

     编号   产品  成本价(元/个)  销售价(元/个)  数量(个)   成本(元)  收入(元)  利润(元)
0  a001   背包      16.0        65     60   960.0   3900   2940
1  a002   钱包      90.0       187     50  4500.0   9350   4850
2  a003   背包      16.0        65     23   368.0   1495   1127
3  a004  手提包      36.0       147     26   936.0   3822   2886
4  a005   钱包      90.0       187     78  7020.0  14586   7566
5  a006  单肩包      58.0       124     63  3654.0   7812   4158
6  a007  单肩包      58.0       124     58  3364.0   7192   3828

5.2.4 处理重复值

import pandas as pd
data = pd.read_excel('产品统计表2.xlsx')
print(data)

     编号   产品  成本价(元/个)  销售价(元/个)  数量(个)  成本(元)  收入(元)  利润(元)
0  a001   背包        16        65     60    960   3900   2940
1  a002   钱包        90       187     50   4500   9350   4850
2  a003   背包        16        65     23    368   1495   1127
3  a004  手提包        36       147     26    936   3822   2886
4  a004  手提包        36       147     26    936   3822   2886   # 重复
5  a005   钱包        90       187     78   7020  14586   7566
6  a006  单肩包        58       124     63   3654   7812   4158

1. 删除重复行：drop_duplicates()函数

a = data.drop_duplicates()
print(a)

     编号   产品  成本价(元/个)  销售价(元/个)  数量(个)  成本(元)  收入(元)  利润(元)
0  a001   背包        16        65     60    960   3900   2940
1  a002   钱包        90       187     50   4500   9350   4850
2  a003   背包        16        65     23    368   1495   1127
3  a004  手提包        36       147     26    936   3822   2886
5  a005   钱包        90       187     78   7020  14586   7566
6  a006  单肩包        58       124     63   3654   7812   4158

2. 删除某一列的重复值：subset参数

默认保留第一个重复值所在的行，删除其他重复值所在的行

b = data.drop_duplicates(subset = '产品')
print(b)

     编号   产品  成本价(元/个)  销售价(元/个)  数量(个)  成本(元)  收入(元)  利润(元)
0  a001   背包        16        65     60    960   3900   2940
1  a002   钱包        90       187     50   4500   9350   4850
3  a004  手提包        36       147     26    936   3822   2886
6  a006  单肩包        58       124     63   3654   7812   4158

保留第一个重复值所在的行

c = data.drop_duplicates(subset = '产品', keep = 'first')
print(c)

     编号   产品  成本价(元/个)  销售价(元/个)  数量(个)  成本(元)  收入(元)  利润(元)
0  a001   背包        16        65     60    960   3900   2940
1  a002   钱包        90       187     50   4500   9350   4850
3  a004  手提包        36       147     26    936   3822   2886
6  a006  单肩包        58       124     63   3654   7812   4158

保留最后一个重复值所在的行

d = data.drop_duplicates(subset = '产品', keep = 'last')
print(d)

     编号   产品  成本价(元/个)  销售价(元/个)  数量(个)  成本(元)  收入(元)  利润(元)
2  a003   背包        16        65     23    368   1495   1127
4  a004  手提包        36       147     26    936   3822   2886
5  a005   钱包        90       187     78   7020  14586   7566
6  a006  单肩包        58       124     63   3654   7812   4158

是重复的就删除

e = data.drop_duplicates(subset = '产品', keep = False)
print(e)

     编号   产品  成本价(元/个)  销售价(元/个)  数量(个)  成本(元)  收入(元)  利润(元)
6  a006  单肩包        58       124     63   3654   7812   4158

3. 获取唯一值：unique()函数

f = data['产品'].unique()
print(f)

['背包' '钱包' '手提包' '单肩包']

5.2.5 排序数据

1. sort_values()函数排序数据

import pandas as pd
data = pd.read_excel('产品统计表2.xlsx')
a = data.sort_values(by = '数量(个)', ascending = True) #第一个参数指定列  第二个参数指定升序
print(a)

     编号   产品  成本价(元/个)  销售价(元/个)  数量(个)  成本(元)  收入(元)  利润(元)
2  a003   背包        16        65     23    368   1495   1127
3  a004  手提包        36       147     26    936   3822   2886
4  a004  手提包        36       147     26    936   3822   2886
1  a002   钱包        90       187     50   4500   9350   4850
0  a001   背包        16        65     60    960   3900   2940
6  a006  单肩包        58       124     63   3654   7812   4158
5  a005   钱包        90       187     78   7020  14586   7566

降序如下

b = data.sort_values(by = '数量(个)', ascending = False)
print(b)

     编号   产品  成本价(元/个)  销售价(元/个)  数量(个)  成本(元)  收入(元)  利润(元)
5  a005   钱包        90       187     78   7020  14586   7566
6  a006  单肩包        58       124     63   3654   7812   4158
0  a001   背包        16        65     60    960   3900   2940
1  a002   钱包        90       187     50   4500   9350   4850
3  a004  手提包        36       147     26    936   3822   2886
4  a004  手提包        36       147     26    936   3822   2886
2  a003   背包        16        65     23    368   1495   1127

2. rank()函数获取数据的排名

c = data['利润(元)'].rank(method = 'average', ascending = False)  #指定利润降序排序  有重复值则返回重复值的平均排名
print(c)

0    4.0
1    2.0
2    7.0
3    5.5
4    5.5
5    1.0
6    3.0
Name: 利润(元), dtype: float64

参数指定first时，表示在数据有重复值时，越先出现的数据排名越靠前

d = data['利润(元)'].rank(method = 'first', ascending = False)
print(d)

0    4.0
1    2.0
2    7.0
3    5.0
4    6.0
5    1.0
6    3.0
Name: 利润(元), dtype: float64

5.2.6 筛选数据

获取产品为单肩包的行数据

import pandas as pd
data = pd.read_excel('产品统计表.xlsx')
a = data[data['产品'] == '单肩包']   #获取产品为单肩包的行数据
print(a)

     编号   产品  成本价(元/个)  销售价(元/个)  数量(个)  成本(元)  收入(元)  利润(元)
5  a006  单肩包        58       124     63   3654   7812   4158
6  a007  单肩包        58       124     58   3364   7192   3828

获取数量>60的行数据

b = data[data['数量(个)'] > 60]  # 获取数量>60的行数据
print(b)

     编号   产品  成本价(元/个)  销售价(元/个)  数量(个)  成本(元)  收入(元)  利润(元)
4  a005   钱包        90       187     78   7020  14586   7566
5  a006  单肩包        58       124     63   3654   7812   4158

获取产品为单肩包且数量>60 的行数据

c = data[(data['产品'] == '单肩包') & (data['数量(个)'] > 60)]
print(c)

     编号   产品  成本价(元/个)  销售价(元/个)  数量(个)  成本(元)  收入(元)  利润(元)
5  a006  单肩包        58       124     63   3654   7812   4158

获取产品为单肩包或数量>60 的行数据

d = data[(data['产品'] == '单肩包') | (data['数量(个)'] > 60)]
print(d)

     编号   产品  成本价(元/个)  销售价(元/个)  数量(个)  成本(元)  收入(元)  利润(元)
4  a005   钱包        90       187     78   7020  14586   7566
5  a006  单肩包        58       124     63   3654   7812   4158
6  a007  单肩包        58       124     58   3364   7192   3828

5.3 数据表的处理

5.3.1 转置数据表的行列：T属性

import pandas as pd
data = pd.read_excel('产品统计表.xlsx')
a = data.T
print(a)

             0     1     2     3      4     5     6
编号        a001  a002  a003  a004   a005  a006  a007
产品          背包    钱包    背包   手提包     钱包   单肩包   单肩包
成本价(元/个)    16    90    16    36     90    58    58
销售价(元/个)    65   187    65   147    187   124   124
数量(个)       60    50    23    26     78    63    58
成本(元)      960  4500   368   936   7020  3654  3364
收入(元)     3900  9350  1495  3822  14586  7812  7192
利润(元)     2940  4850  1127  2886   7566  4158  3828

5.3.2 将数据表转换成树形结构：stack()函数

import pandas as pd
data = pd.read_excel('产品统计表3.xlsx')
print(data)

     编号   产品  销售价(元/个)  数量(个)  收入(元)
0  a001   背包        65     60   3900
1  a002   钱包       187     50   9350
2  a003  单肩包       124     58   7192

stack()函数转换成树形结构

a = data.stack()
print(a)

0  编号          a001
   产品            背包
   销售价(元/个)      65
   数量(个)         60
   收入(元)       3900
1  编号          a002
   产品            钱包
   销售价(元/个)     187
   数量(个)         50
   收入(元)       9350
2  编号          a003
   产品           单肩包
   销售价(元/个)     124
   数量(个)         58
   收入(元)       7192
dtype: object

5.3.3 数据表的拼接

import pandas as pd
data1 = pd.read_excel('产品表.xlsx', sheet_name = 0)  #第0张工作簿
data2 = pd.read_excel('产品表.xlsx',sheet_name = 1)   #第1张工作簿
print(data1)
print(data2)

   员工编号 员工姓名 员工性别
0  a001   张三    男
1  a002   李四    女
2  a003   王五    男
3  a004   赵六    男
   员工编号 员工姓名    销售业绩
0  a001   张三  360000
1  a002   李四  458000
2  a003   王五  369000
3  a004   赵六  450000
4  a005   钱七  500000

1. merge()函数

a = pd.merge(data1, data2)  #行取交集  列取并集
print(a)

   员工编号 员工姓名 员工性别    销售业绩
0  a001   张三    男  360000
1  a002   李四    女  458000
2  a003   王五    男  369000
3  a004   赵六    男  450000

how参数指定外连接

b = pd.merge(data1, data2, how = 'outer')    #行取并集  列取并集
print(b)

   员工编号 员工姓名 员工性别    销售业绩
0  a001   张三    男  360000
1  a002   李四    女  458000
2  a003   王五    男  369000
3  a004   赵六    男  450000
4  a005   钱七  NaN  500000

on参数指定按哪一列合并

c = pd.merge(data1, data2, on = '员工姓名')
print(c)

  员工编号_x 员工姓名 员工性别 员工编号_y    销售业绩
0   a001   张三    男   a001  360000
1   a002   李四    女   a002  458000
2   a003   王五    男   a003  369000
3   a004   赵六    男   a004  450000

2. concat()函数

concat()函数采用全连接的方式，没有的数设置为缺失值

d = pd.concat([data1, data2])
print(d)

   员工编号 员工姓名 员工性别      销售业绩
0  a001   张三    男       NaN
1  a002   李四    女       NaN
2  a003   王五    男       NaN
3  a004   赵六    男       NaN
0  a001   张三  NaN  360000.0
1  a002   李四  NaN  458000.0
2  a003   王五  NaN  369000.0
3  a004   赵六  NaN  450000.0
4  a005   钱七  NaN  500000.0

重置行标签

e = pd.concat([data1, data2], ignore_index = True)  #重置行标签
print(e)

   员工编号 员工姓名 员工性别      销售业绩
0  a001   张三    男       NaN
1  a002   李四    女       NaN
2  a003   王五    男       NaN
3  a004   赵六    男       NaN
4  a001   张三  NaN  360000.0
5  a002   李四  NaN  458000.0
6  a003   王五  NaN  369000.0
7  a004   赵六  NaN  450000.0
8  a005   钱七  NaN  500000.0

3. append()函数

效果与concat()一样

f = data1.append(data2)
print(f)

   员工编号 员工姓名 员工性别      销售业绩
0  a001   张三    男       NaN
1  a002   李四    女       NaN
2  a003   王五    男       NaN
3  a004   赵六    男       NaN
0  a001   张三  NaN  360000.0
1  a002   李四  NaN  458000.0
2  a003   王五  NaN  369000.0
3  a004   赵六  NaN  450000.0
4  a005   钱七  NaN  500000.0

末尾添加行元素

g = data1.append({'员工编号':'a005', '员工姓名':'孙七', '员工性别':'男'}, ignore_index = True)
print(g)

   员工编号 员工姓名 员工性别
0  a001   张三    男
1  a002   李四    女
2  a003   王五    男
3  a004   赵六    男
4  a005   孙七    男

5.4 数据的运算

5.4.1 数据的统计运算：sum()、mean()、max()

1. 求和：sum()

import pandas as pd
data = pd.read_excel('产品统计表.xlsx')
a = data.sum()
print(a)

编号          a001a002a003a004a005a006a007
产品                     背包钱包背包手提包钱包单肩包单肩包
成本价(元/个)                             364
销售价(元/个)                             899
数量(个)                                358
成本(元)                              20802
收入(元)                              48157
利润(元)                              27355
dtype: object

指定列求和

b = data['利润(元)'].sum()
print(b)

2. 求平均值：mean()

c = data.mean()
print(c)

成本价(元/个)      52.000000
销售价(元/个)     128.428571
数量(个)         51.142857
成本(元)       2971.714286
收入(元)       6879.571429
利润(元)       3907.857143
dtype: float64

指定列求均值

d = data['利润(元)'].mean()
print(d)

3907.8571428571427

3. 求最值：max()

e = data.max()
print(e)

编号           a007
产品             钱包
成本价(元/个)       90
销售价(元/个)      187
数量(个)          78
成本(元)        7020
收入(元)       14586
利润(元)        7566
dtype: object

指定列求最值

f = data['利润(元)'].max()
print(f)

5.4.2 获取数值分布情况：describe()

import pandas as pd
data = pd.read_excel('产品统计表.xlsx')
a = data.describe()
print(a)

        成本价(元/个)    销售价(元/个)      数量(个)        成本(元)         收入(元)        利润(元)
count   7.000000    7.000000   7.000000     7.000000      7.000000     7.000000
mean   52.000000  128.428571  51.142857  2971.714286   6879.571429  3907.857143
std    31.112698   50.483849  20.053500  2391.447659   4352.763331  2002.194498
min    16.000000   65.000000  23.000000   368.000000   1495.000000  1127.000000
25%    26.000000   94.500000  38.000000   948.000000   3861.000000  2913.000000
50%    58.000000  124.000000  58.000000  3364.000000   7192.000000  3828.000000
75%    74.000000  167.000000  61.500000  4077.000000   8581.000000  4504.000000
max    90.000000  187.000000  78.000000  7020.000000  14586.000000  7566.000000

获取单列的

b = data['利润(元)'].describe()
print(b)

count       7.000000
mean     3907.857143
std      2002.194498
min      1127.000000
25%      2913.000000
50%      3828.000000
75%      4504.000000
max      7566.000000
Name: 利润(元), dtype: float64

5.4.3 计算相关系数：corr()

import pandas as pd
data = pd.read_excel('相关性分析.xlsx')
print(data)

   代理商编号  年销售额（万元）  年广告费投入额（万元）  成本费用（万元）  管理费用（万元）
0  A-001      20.5         15.6      2.00      0.80
1  A-003      24.5         16.7      2.54      0.94
2  B-002      31.8         20.4      2.96      0.88
3  B-006      34.9         22.6      3.02      0.79
4  B-008      39.4         25.7      3.14      0.84
5  C-003      44.5         28.8      4.00      0.80
6  C-004      49.6         32.1      6.84      0.85
7  C-007      54.8         35.9      5.60      0.91
8  D-006      58.5         38.7      6.45      0.90

corr()函数获取相关系数

a = data.corr()
print(a)

             年销售额（万元）  年广告费投入额（万元）  成本费用（万元）  管理费用（万元）
年销售额（万元）     1.000000     0.996275  0.914428  0.218317
年广告费投入额（万元）  0.996275     1.000000  0.918404  0.223187
成本费用（万元）     0.914428     0.918404  1.000000  0.284286
管理费用（万元）     0.218317     0.223187  0.284286  1.000000

获取指定列与其他列的相关系数

b = data.corr()['年销售额（万元）']
print(b)

年销售额（万元）       1.000000
年广告费投入额（万元）    0.996275
成本费用（万元）       0.914428
管理费用（万元）       0.218317
Name: 年销售额（万元）, dtype: float64

5.4.4 分组汇总数据：groupby()

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-46g9qgQw-1637655972913)(C:\Users\14051\AppData\Roaming\Typora\typora-user-images\image-20211123135643804.png)]

import pandas as pd
data = pd.read_excel('产品统计表.xlsx')
a = data.groupby('产品')    #根据产品列分组
print(a)

<pandas.core.groupby.generic.DataFrameGroupBy object at 0x00000213943E4640>

groupby()函数返回的是一个DataFrameBy对象，该对象包含分组后的数据，但是不能直观地显示出来。

b = data.groupby('产品').sum()
print(b)

     成本价(元/个)  销售价(元/个)  数量(个)  成本(元)  收入(元)  利润(元)
产品                                                 
单肩包       116       248    121   7018  15004   7986
手提包        36       147     26    936   3822   2886
背包         32       130     83   1328   5395   4067
钱包        180       374    128  11520  23936  12416

分组后获取指定列的汇总情况

c = data.groupby('产品')['利润(元)'].sum()
print(c)

产品
单肩包     7986
手提包     2886
背包      4067
钱包     12416
Name: 利润(元), dtype: int64

获取多列的汇总情况

d = data.groupby('产品')['数量(个)', '利润(元)'].sum()
print(d)

     数量(个)  利润(元)
产品               
单肩包    121   7986
手提包     26   2886
背包      83   4067
钱包     128  12416

5.4.5 创建数据透视表：pivot_table()

values参数用于指定要计算的列
index参数用于指定一个列作为数据透视表的行标签
aggfunc参数用于指定参数values的计算类型

import pandas as pd
data = pd.read_excel('产品统计表.xlsx')
a = pd.pivot_table(data, values = '利润(元)', index = '产品', aggfunc = 'sum')  #data.groupby('产品')['利润(元)'].sum()  同样功能
print(a)

     利润(元)
产品        
单肩包   7986
手提包   2886
背包    4067
钱包   12416

获取多列的情况

b = pd.pivot_table(data, values = ['利润(元)', '成本(元)'], index = '产品', aggfunc = 'sum')
print(b)

     利润(元)  成本(元)
产品               
单肩包   7986   7018
手提包   2886    936
背包    4067   1328
钱包   12416  11520

ta = pd.read_excel(‘相关性分析.xlsx’)
print(data)


```python
   代理商编号  年销售额（万元）  年广告费投入额（万元）  成本费用（万元）  管理费用（万元）
0  A-001      20.5         15.6      2.00      0.80
1  A-003      24.5         16.7      2.54      0.94
2  B-002      31.8         20.4      2.96      0.88
3  B-006      34.9         22.6      3.02      0.79
4  B-008      39.4         25.7      3.14      0.84
5  C-003      44.5         28.8      4.00      0.80
6  C-004      49.6         32.1      6.84      0.85
7  C-007      54.8         35.9      5.60      0.91
8  D-006      58.5         38.7      6.45      0.90

corr()函数获取相关系数

a = data.corr()
print(a)

             年销售额（万元）  年广告费投入额（万元）  成本费用（万元）  管理费用（万元）
年销售额（万元）     1.000000     0.996275  0.914428  0.218317
年广告费投入额（万元）  0.996275     1.000000  0.918404  0.223187
成本费用（万元）     0.914428     0.918404  1.000000  0.284286
管理费用（万元）     0.218317     0.223187  0.284286  1.000000

获取指定列与其他列的相关系数

b = data.corr()['年销售额（万元）']
print(b)

年销售额（万元）       1.000000
年广告费投入额（万元）    0.996275
成本费用（万元）       0.914428
管理费用（万元）       0.218317
Name: 年销售额（万元）, dtype: float64

5.4.4 分组汇总数据：groupby()

[外链图片转存中…(img-46g9qgQw-1637655972913)]

import pandas as pd
data = pd.read_excel('产品统计表.xlsx')
a = data.groupby('产品')    #根据产品列分组
print(a)

<pandas.core.groupby.generic.DataFrameGroupBy object at 0x00000213943E4640>

groupby()函数返回的是一个DataFrameBy对象，该对象包含分组后的数据，但是不能直观地显示出来。

b = data.groupby('产品').sum()
print(b)

     成本价(元/个)  销售价(元/个)  数量(个)  成本(元)  收入(元)  利润(元)
产品                                                 
单肩包       116       248    121   7018  15004   7986
手提包        36       147     26    936   3822   2886
背包         32       130     83   1328   5395   4067
钱包        180       374    128  11520  23936  12416

分组后获取指定列的汇总情况

c = data.groupby('产品')['利润(元)'].sum()
print(c)

产品
单肩包     7986
手提包     2886
背包      4067
钱包     12416
Name: 利润(元), dtype: int64

获取多列的汇总情况

d = data.groupby('产品')['数量(个)', '利润(元)'].sum()
print(d)

     数量(个)  利润(元)
产品               
单肩包    121   7986
手提包     26   2886
背包      83   4067
钱包     128  12416

5.4.5 创建数据透视表：pivot_table()

values参数用于指定要计算的列
index参数用于指定一个列作为数据透视表的行标签
aggfunc参数用于指定参数values的计算类型

import pandas as pd
data = pd.read_excel('产品统计表.xlsx')
a = pd.pivot_table(data, values = '利润(元)', index = '产品', aggfunc = 'sum')  #data.groupby('产品')['利润(元)'].sum()  同样功能
print(a)

     利润(元)
产品        
单肩包   7986
手提包   2886
背包    4067
钱包   12416

获取多列的情况

b = pd.pivot_table(data, values = ['利润(元)', '成本(元)'], index = '产品', aggfunc = 'sum')
print(b)

     利润(元)  成本(元)
产品               
单肩包   7986   7018
手提包   2886    936
背包    4067   1328
钱包   12416  11520

理解Gunicorn：Python WSGI服务器的基石范范0825 ipython linux 运维
理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
Python数据分析与可视化实战指南 William数据分析 python python 数据
在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
python os.environ 江湖偌大 python 深度学习
os.environ['TF_CPP_MIN_LOG_LEVEL']='0'#默认值，输出所有信息os.environ['TF_CPP_MIN_LOG_LEVEL']='1'#屏蔽通知信息（INFO）os.environ['TF_CPP_MIN_LOG_LEVEL']='2'#屏蔽通知信息和警告信息（INFO\WARNING）os.environ['TF_CPP_MIN_LOG_LEVEL']='
Python中os.environ基本介绍及使用方法鹤冲天Pro #Python python 服务器开发语言
文章目录python中os.environos.environ简介os.environ进行环境变量的增删改查python中os.environ的使用详解1.简介2.key字段详解2.1常见key字段3.os.environ.get()用法4.环境变量的增删改查和判断是否存在4.1新增环境变量4.2更新环境变量4.3获取环境变量4.4删除环境变量4.5判断环境变量是否存在python中os.envi
Pyecharts数据可视化大屏：打造沉浸式数据分析体验我的运维人生信息可视化数据分析数据挖掘运维开发技术共享
Pyecharts数据可视化大屏：打造沉浸式数据分析体验在当今这个数据驱动的时代，如何将海量数据以直观、生动的方式展现出来，成为了数据分析师和企业决策者关注的焦点。Pyecharts，作为一款基于Python的开源数据可视化库，凭借其丰富的图表类型、灵活的配置选项以及高度的定制化能力，成为了构建数据可视化大屏的理想选择。本文将深入探讨如何利用Pyecharts打造数据可视化大屏，并通过实际代码案例
Python教程：一文了解使用Python处理XPath 旦莫 Python进阶 python 开发语言
目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
python os.environ_python os.environ 读取和设置环境变量 weixin_39605414 python os.environ
>>>importos>>>os.environ.keys()['LC_NUMERIC','GOPATH','GOROOT','GOBIN','LESSOPEN','SSH_CLIENT','LOGNAME','USER','HOME','LC_PAPER','PATH','DISPLAY','LANG','TERM','SHELL','J2REDIR','LC_MONETARY','QT_QPA
使用Faiss进行高效相似度搜索 llzwxh888 faiss python
在现代AI应用中，快速和高效的相似度搜索是至关重要的。Faiss（FacebookAISimilaritySearch）是一个专门用于快速相似度搜索和聚类的库，特别适用于高维向量。本文将介绍如何使用Faiss来进行相似度搜索，并结合Python代码演示其基本用法。什么是Faiss？Faiss是一个由FacebookAIResearch团队开发的开源库，主要用于高维向量的相似性搜索和聚类。Faiss
python是什么意思中文-在python中%是什么意思编程大乐趣
Python中%有两种：1、数值运算：%代表取模，返回除法的余数。如：>>>7%212、%操作符（字符串格式化，stringformatting），说明如下：%[(name)][flags][width].[precision]typecode(name)为命名flags可以有+，-，''或0。+表示右对齐。-表示左对齐。''为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。0表示使用0填
Day1笔记-Python简介&标识符和关键字&输入输出 ~在杰难逃~ Python python 开发语言大数据数据分析数据挖掘
大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
python八股文面试题分享及解析(1) Shawn________ python
#1.'''a=1b=2不用中间变量交换a和b'''#1.a=1b=2a,b=b,aprint(a)print(b)结果：21#2.ll=[]foriinrange(3):ll.append({'num':i})print(11)结果:#[{'num':0},{'num':1},{'num':2}]#3.kk=[]a={'num':0}foriinrange(3):#0,12#可变类型，不仅仅改变
每日算法&面试题，大厂特训二十八天——第二十天（树）肥学 ⚡算法题⚡面试题每日精进 java 算法数据结构
目录标题导读算法特训二十八天面试题点击直接资料领取导读肥友们为了更好的去帮助新同学适应算法和面试题，最近我们开始进行专项突击一步一步来。上一期我们完成了动态规划二十一天现在我们进行下一项对各类算法进行二十八天的一个小总结。还在等什么快来一起肥学进行二十八天挑战吧！！特别介绍小白练手专栏，适合刚入手的新人欢迎订阅编程小白进阶python有趣练手项目里面包括了像《机器人尬聊》《恶搞程序》这样的有趣文章
Python快速入门 —— 第三节：类与对象孤华暗香 Python快速入门 python 开发语言
第三节：类与对象目标：了解面向对象编程的基础概念，并学会如何定义类和创建对象。内容：类与对象：定义类：class关键字。类的构造函数：__init__()。类的属性和方法。对象的创建与使用。示例：classStudent:def__init__(self,name,age,major):self.name&#
pyecharts——绘制柱形图折线图 2224070247 信息可视化 python java 数据可视化
一、pyecharts概述自2013年6月百度EFE(ExcellentFrontEnd）数据可视化团队研发的ECharts1.0发布到GitHub网站以来，ECharts一直备受业界权威的关注并获得广泛好评，成为目前成熟且流行的数据可视化图表工具，被应用到诸多数据可视化的开发领域。Python作为数据分析领域最受欢迎的语言，也加入ECharts的使用行列，并研发出方便Python开发者使用的数据
Python 实现图片裁剪（附代码） | Python工具剑客阿良_ALiang
前言本文提供将图片按照自定义尺寸进行裁剪的工具方法，一如既往的实用主义。环境依赖ffmpeg环境安装，可以参考我的另一篇文章：windowsffmpeg安装部署_阿良的博客-CSDN博客本文主要使用到的不是ffmpeg，而是ffprobe也在上面这篇文章中的zip包中。ffmpy安装：pipinstallffmpy-ihttps://pypi.douban.com/simple代码不废话了，上代码
【华为OD技术面试真题 - 技术面】- python八股文真题题库（4) 算法大师华为od 面试 python
华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选**1.Python中的`with`**用途和功能自动资源管理示例：文件操作上下文管理协议示例代码工作流程解析优点2.\_\_new\_\_和**\_\_init\_\_**区别__new____init__区别总结3.**切片（Slicing）操作**基本切片语法
python os 环境变量 CV矿工 python 开发语言 numpy
环境变量：环境变量是程序和操作系统之间的通信方式。有些字符不宜明文写进代码里，比如数据库密码，个人账户密码，如果写进自己本机的环境变量里，程序用的时候通过os.environ.get（）取出来就行了。os.environ是一个环境变量的字典。环境变量的相关操作importos"""设置/修改环境变量：os.environ[‘环境变量名称’]=‘环境变量值’#其中key和value均为string类
Python爬虫解析工具之xpath使用详解 eqa11 python 爬虫开发语言
文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
【华为OD技术面试真题 - 技术面】- python八股文真题题库（1）算法大师华为od 面试 python
华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.数据预处理流程数据预处理的主要步骤工具和库2.介绍线性回归、逻辑回归模型线性回归（LinearRegression）模型形式：关键点：逻辑回归（LogisticRegression）模型形式：关键点：参数估计与评估：3.python浅拷贝及深拷贝浅拷贝（Shal
nosql数据库技术与应用知识点皆过客，揽星河 NoSQL nosql 数据库大数据数据分析数据结构非关系型数据库
Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
《Python数据分析实战终极指南》 xjt921122 python 数据分析开发语言
对于分析师来说，大家在学习Python数据分析的路上，多多少少都遇到过很多大坑**，有关于技能和思维的**：Excel已经没办法处理现有的数据量了，应该学Python吗？找了一大堆Python和Pandas的资料来学习，为什么自己动手就懵了？跟着比赛类公开数据分析案例练了很久，为什么当自己面对数据需求还是只会数据处理而没有分析思路？学了对比、细分、聚类分析，也会用PEST、波特五力这类分析法，为啥
Python中深拷贝与浅拷贝的区别 yuxiaoyu.
转自：http://blog.csdn.net/u014745194/article/details/70271868定义：在Python中对象的赋值其实就是对象的引用。当创建一个对象，把它赋值给另一个变量的时候，python并没有拷贝这个对象，只是拷贝了这个对象的引用而已。浅拷贝：拷贝了最外围的对象本身，内部的元素都只是拷贝了一个引用而已。也就是，把对象复制一遍，但是该对象中引用的其他对象我不复
Python开发常用的三方模块如下：换个网名有点难 python 开发语言
Python是一门功能强大的编程语言，拥有丰富的第三方库，这些库为开发者提供了极大的便利。以下是100个常用的Python库，涵盖了多个领域：1、NumPy，用于科学计算的基础库。2、Pandas，提供数据结构和数据分析工具。3、Matplotlib，一个绘图库。4、Scikit-learn，机器学习库。5、SciPy，用于数学、科学和工程的库。6、TensorFlow，由Google开发的开源机
ES聚合分析原理与代码实例讲解光剑书架上的书大厂Offer收割机面试题简历程序员读书硅基计算碳基计算认知计算生物计算深度学习神经网络大数据 AIGC AGI LLM Java Python 架构设计 Agent 程序员实现财富自由
ES聚合分析原理与代码实例讲解1.背景介绍1.1问题的由来在大规模数据分析场景中，特别是在使用Elasticsearch（ES）进行数据存储和检索时，聚合分析成为了一个至关重要的功能。聚合分析允许用户对数据集进行细分和分组，以便深入探索数据的结构和模式。这在诸如实时监控、日志分析、业务洞察等领域具有广泛的应用。1.2研究现状目前，ES聚合分析已经成为现代大数据平台的核心组件之一。它支持多种类型的聚
Python编译器鹿鹿~ Python编译器 Python python 开发语言后端
嘿嘿嘿我又来了啊有些小盆友可能不知道Python其实是有编译器的，也就是PyCharm。你们可能会问到这个是干嘛的又不可以吃也不可以穿好像没有什么用，其实你还说对了这个还真的不可以吃也不可以穿，但是它用来干嘛的呢。用来编译你所打出的代码进行运行（可能这里说的有点不对但是只是个人认为）现在我们来说说PyCharm是用来干嘛的。PyCharm是一种PythonIDE，带有一整套可以帮助用户在使用Pyt
一文掌握python面向对象魔术方法（二）程序员neil python python 开发语言
接上篇：一文掌握python面向对象魔术方法（一）-CSDN博客目录六、迭代和序列化：1、__iter__(self):定义迭代器，使得类可以被for循环迭代。2、__getitem__(self,key):定义索引操作，如obj[key]。3、__setitem__(self,key,value):定义赋值操作，如obj[key]=value。4、__delitem__(self,key):定义
一文掌握python常用的list（列表）操作程序员neil python python 开发语言
目录一、创建列表1.直接创建列表：2.使用list()构造器3.使用列表推导式4.创建空列表二、访问列表元素1.列表支持通过索引访问元素，索引从0开始：2.还可以使用切片操作访问列表的一部分：三、修改列表元素四、添加元素1.append()：在末尾添加元素2.insert()：在指定位置插入元素五、删除元素1.del：删除指定位置的元素2.remove()：删除指定值的第一个匹配项3.pop()：
Python实现简单的机器学习算法 master_chenchengg python python 办公效率 python开发 IT
Python实现简单的机器学习算法开篇：初探机器学习的奇妙之旅搭建环境：一切从安装开始必备工具箱第一步：安装Anaconda和JupyterNotebook小贴士：如何配置Python环境变量算法初体验：从零开始的Python机器学习线性回归：让数据说话数据准备：从哪里找数据编码实战：Python实现线性回归模型评估：如何判断模型好坏逻辑回归：从分类开始理论入门：什么是逻辑回归代码实现：使用skl
推荐算法_隐语义-梯度下降 _feivirus_ 算法机器学习和数学推荐算法机器学习隐语义
importnumpyasnp1.模型实现"""inputrate_matrix:M行N列的评分矩阵，值为P*Q.P:初始化用户特征矩阵M*K.Q:初始化物品特征矩阵K*N.latent_feature_cnt:隐特征的向量个数max_iteration:最大迭代次数alpha:步长lamda:正则化系数output分解之后的P和Q"""defLFM_grad_desc(rate_matrix,l
自然语言处理_tf-idf _feivirus_ 算法机器学习和数学自然语言处理 tf-idf 逆文档频率词频
importpandasaspdimportmath1.数据预处理docA="Thecatsatonmyface"docB="Thedogsatonmybed"wordsA=docA.split("")wordsB=docB.split("")wordsSet=set(wordsA).union(set(wordsB))print(wordsSet){'on','my','face','sat',
枚举的构造函数中抛出异常会怎样 bylijinnan java enum 单例
首先从使用enum实现单例说起。为什么要用enum来实现单例？这篇文章（ http://javarevisited.blogspot.sg/2012/07/why-enum-singleton-are-better-in-java.html）阐述了三个理由： 1.enum单例简单、容易，只需几行代码： public enum Singleton { INSTANCE;
CMake 教程 aigo C++
转自：http://xiang.lf.blog.163.com/blog/static/127733322201481114456136/ CMake是一个跨平台的程序构建工具，比如起自己编写Makefile方便很多。介绍：http://baike.baidu.com/view/1126160.htm 本文件不介绍CMake的基本语法，下面是篇不错的入门教程： http:
cvc-complex-type.2.3: Element 'beans' cannot have character Cb123456 spring Webgis
cvc-complex-type.2.3: Element 'beans' cannot have character Line 33 in XML document from ServletContext resource [/WEB-INF/backend-servlet.xml] is i
jquery实例:随页面滚动条滚动而自动加载内容 120153216 jquery
<script language="javascript"> $(function (){ var i = 4;$(window).bind("scroll", function (event){ //滚动条到网页头部的高度，兼容ie,ff,chrome var top = document.documentElement.s
将数据库中的数据转换成dbs文件何必如此 sql dbs
旗正规则引擎通过数据库配置器（DataBuilder）来管理数据库，无论是Oracle，还是其他主流的数据都支持，操作方式是一样的。旗正规则引擎的数据库配置器是用于编辑数据库结构信息以及管理数据库表数据，并且可以执行SQL 语句，主要功能如下。 1)数据库生成表结构信息：主要生成数据库配置文件(.conf文
在IBATIS中配置SQL语句的IN方式 357029540 ibatis
在使用IBATIS进行SQL语句配置查询时，我们一定会遇到通过IN查询的地方，在使用IN查询时我们可以有两种方式进行配置参数：String和List。具体使用方式如下： 1.String:定义一个String的参数userIds，把这个参数传入IBATIS的sql配置文件，sql语句就可以这样写： <select id="getForms" param
Spring3 MVC 笔记（一） 7454103 spring mvc bean REST JSF
自从 MVC 这个概念提出来之后 struts1.X struts2.X jsf 。。。。。这个view 层的技术一个接一个！都用过！不敢说哪个绝对的强悍！要看业务，和整体的设计！最近公司要求开发个新系统！
Timer与Spring Quartz 定时执行程序 darkranger spring bean 工作 quartz
有时候需要定时触发某一项任务。其实在jdk1.3，java sdk就通过java.util.Timer提供相应的功能。一个简单的例子说明如何使用，很简单： 1、第一步，我们需要建立一项任务，我们的任务需要继承java.util.TimerTask package com.test; import java.text.SimpleDateFormat; import java.util.Date;
大端小端转换，le32_to_cpu 和cpu_to_le32 aijuans C语言相关
大端小端转换，le32_to_cpu 和cpu_to_le32 字节序 http://oss.org.cn/kernel-book/ldd3/ch11s04.html 小心不要假设字节序. PC 存储多字节值是低字节为先(小端为先, 因此是小端), 一些高级的平台以另一种方式(大端)
Nginx负载均衡配置实例详解 avords
[导读] 负载均衡是我们大流量网站要做的一个东西，下面我来给大家介绍在Nginx服务器上进行负载均衡配置方法，希望对有需要的同学有所帮助哦。负载均衡先来简单了解一下什么是负载均衡，单从字面上的意思来理解就可以解负载均衡是我们大流量网站要做的一个东西，下面我来给大家介绍在Nginx服务器上进行负载均衡配置方法，希望对有需要的同学有所帮助哦。负载均衡先来简单了解一下什么是负载均衡
乱说的 houxinyou 框架敏捷开发软件测试
从很久以前，大家就研究框架，开发方法，软件工程，好多！反正我是搞不明白！这两天看好多人研究敏捷模型，瀑布模型！也没太搞明白. 不过感觉和程序开发语言差不多，瀑布就是顺序，敏捷就是循环. 瀑布就是需求、分析、设计、编码、测试一步一步走下来。而敏捷就是按摸块或者说迭代做个循环，第个循环中也一样是需求、分析、设计、编码、测试一步一步走下来。也可以把软件开发理
欣赏的价值——一个小故事 bijian1013 有效辅导欣赏欣赏的价值
　　第一次参加家长会，幼儿园的老师说："您的儿子有多动症，在板凳上连三分钟都坐不了，你最好带他去医院看一看。"　　回家的路上，儿子问她老师都说了些什么，她鼻子一酸，差点流下泪来。因为全班30位小朋友，惟有他表现最差；惟有对他，老师表现出不屑，然而她还在告诉她的儿子："老师表扬你了，说宝宝原来在板凳上坐不了一分钟，现在能坐三分钟。其他妈妈都非常羡慕妈妈，因为全班只有宝宝
包冲突问题的解决方法 bingyingao eclipse maven exclusions 包冲突
包冲突是开发过程中很常见的问题：其表现有： 1.明明在eclipse中能够索引到某个类，运行时却报出找不到类。 2.明明在eclipse中能够索引到某个类的方法，运行时却报出找不到方法。 3.类及方法都有，以正确编译成了.class文件，在本机跑的好好的，发到测试或者正式环境就抛如下异常： java.lang.NoClassDefFoundError: Could not in
【Spark七十五】Spark Streaming整合Flume-NG三之接入log4j bit1129 Stream
先来一段废话：实际工作中，业务系统的日志基本上是使用Log4j写入到日志文件中的，问题的关键之处在于业务日志的格式混乱，这给对日志文件中的日志进行统计分析带来了极大的困难，或者说，基本上无法进行分析，每个人写日志的习惯不同，导致日志行的格式五花八门，最后只能通过grep来查找特定的关键词缩小范围，但是在集群环境下，每个机器去grep一遍，分析一遍，这个效率如何可想之二，大好光阴都浪费在这上面了
sudoku solver in Haskell bookjovi sudoku haskell
这几天没太多的事做，想着用函数式语言来写点实用的程序，像fib和prime之类的就不想提了（就一行代码的事），写什么程序呢？在网上闲逛时发现sudoku游戏，sudoku十几年前就知道了，学生生涯时也想过用C/Java来实现个智能求解，但到最后往往没写成，主要是用C/Java写的话会很麻烦。现在写程序，本人总是有一种思维惯性，总是想把程序写的更紧凑，更精致，代码行数最少，所以现
java apache ftpClient bro_feng java
最近使用apache的ftpclient插件实现ftp下载，遇见几个问题，做如下总结。 1. 上传阻塞，一连串的上传，其中一个就阻塞了，或是用storeFile上传时返回false。查了点资料，说是FTP有主动模式和被动模式。将传出模式修改为被动模式ftp.enterLocalPassiveMode();然后就好了。看了网上相关介绍，对主动模式和被动模式区别还是比较的模糊，不太了解被动模
读《研磨设计模式》-代码笔记-工厂方法模式 bylijinnan java 设计模式
声明：本文只为方便我个人查阅和理解，详细的分析以及源代码请移步原作者的博客http://chjavach.iteye.com/ package design.pattern; /* * 工厂方法模式：使一个类的实例化延迟到子类 * 某次，我在工作不知不觉中就用到了工厂方法模式（称为模板方法模式更恰当。2012-10-29）： * 有很多不同的产品，它
面试记录语 chenyu19891124 招聘
或许真的在一个平台上成长成什么样，都必须靠自己去努力。有了好的平台让自己展示，就该好好努力。今天是自己单独一次去面试别人，感觉有点小紧张，说话有点打结。在面试完后写面试情况表，下笔真的好难，尤其是要对面试人的情况说明真的好难。今天面试的是自己同事的同事，现在的这个同事要离职了，介绍了我现在这位同事以前的同事来面试。今天这位求职者面试的是配置管理，期初看了简历觉得应该很适合做配置管理，但是今天面
Fire Workflow 1.0正式版终于发布了 comsci 工作 workflow Google
Fire Workflow 是国内另外一款开源工作流，作者是著名的非也同志，哈哈.... 官方网站是 http://www.fireflow.org 经过大家努力,Fire Workflow 1.0正式版终于发布了正式版主要变化: 1、增加IWorkItem.jumpToEx(...)方法，取消了当前环节和目标环节必须在同一条执行线的限制，使得自由流更加自由 2、增加IT
Python向脚本传参 daizj python 脚本传参
如果想对python脚本传参数，python中对应的argc, argv(c语言的命令行参数)是什么呢？需要模块：sys 参数个数：len(sys.argv) 脚本名： sys.argv[0] 参数1： sys.argv[1] 参数2： sys.argv[
管理用户分组的命令gpasswd dongwei_6688 passwd
NAME： gpasswd - administer the /etc/group file SYNOPSIS： gpasswd group gpasswd -a user group gpasswd -d user group gpasswd -R group gpasswd -r group gpasswd [-A user,...] [-M user,...] g
郝斌老师数据结构课程笔记 dcj3sjt126com 数据结构与算法
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
yii2 cgridview加上选择框进行操作 dcj3sjt126com GridView
页面代码 <?=Html::beginForm(['controller/bulk'],'post');?> <?=Html::dropDownList('action','',[''=>'Mark selected as: ','c'=>'Confirmed','nc'=>'No Confirmed'],['class'=>'dropdown',])
linux mysql fypop linux
enquiry mysql version in centos linux yum list installed | grep mysql yum -y remove mysql-libs.x86_64 enquiry mysql version in yum repositoryyum list | grep mysql oryum -y list mysql* install mysq
Scramble String hcx2013 String
Given a string s1, we may represent it as a binary tree by partitioning it to two non-empty substrings recursively. Below is one possible representation of s1 = "great":
跟我学Shiro目录贴 jinnianshilongnian 跟我学shiro
历经三个月左右时间，《跟我学Shiro》系列教程已经完结，暂时没有需要补充的内容，因此生成PDF版供大家下载。最近项目比较紧，没有时间解答一些疑问，暂时无法回复一些问题，很抱歉，不过可以加群（334194438/348194195）一起讨论问题。 ----广告-----------------------------------------------------
nginx日志切割并使用flume-ng收集日志 liyonghui160com
nginx的日志文件没有rotate功能。如果你不处理，日志文件将变得越来越大，还好我们可以写一个nginx日志切割脚本来自动切割日志文件。第一步就是重命名日志文件，不用担心重命名后nginx找不到日志文件而丢失日志。在你未重新打开原名字的日志文件前，nginx还是会向你重命名的文件写日志，linux是靠文件描述符而不是文件名定位文件。第二步向nginx主
Oracle死锁解决方法 pda158 oracle
　select p.spid,c.object_name,b.session_id,b.oracle_username,b.os_user_name from v$process p,v$session a, v$locked_object b,all_objects c where p.addr=a.paddr and a.process=b.process and c.object_id=b.
java之List排序 shiguanghui list排序
在Java Collection Framework中定义的List实现有Vector，ArrayList和LinkedList。这些集合提供了对对象组的索引访问。他们提供了元素的添加与删除支持。然而，它们并没有内置的元素排序支持。　　你能够使用java.util.Collections类中的sort()方法对List元素进行排序。你既可以给方法传递
servlet单例多线程 utopialxw 单例多线程 servlet
转自http://www.cnblogs.com/yjhrem/articles/3160864.html 和 http://blog.chinaunix.net/uid-7374279-id-3687149.html Servlet 单例多线程 Servlet如何处理多个请求访问？Servlet容器默认是采用单实例多线程的方式处理多个请求的：1.当web服务器启动的

python数据分析模块：numpy、pandas全解

文章目录

第3章 数组的存储和处理：numpy模块

3.1 创建数组

3.1.1 创建数组：array()函数

3.1.2 创建等差数组：arange()函数

3.1.3 创建随机数组：rand()、randn()、randint()函数

3.2 查看数组的属性

3.2.1 查看行列数 ：shape属性

3.2.2 查看元素个数：size属性

3.2.3 查看元素的数据类型：dtype属性

3.2.4 转换元素的数据类型：astype()函数

3.2.5 查看数组维度：ndim属性

3.3 选取数组元素

3.3.1 一维数组元素的选取

3.3.2 二维数组的元素选取

3.4 数组的重塑和转置

3.4.1 一维数组的重塑：reshape()函数

3.4.2 多维数组的重塑：reshape()函数

3.4.3 多维重塑为一维：flatten()、ravel()函数

3.4.4 数组的转置：T属性、transpose()函数

3.5 数组的处理

3.5.1 添加数组元素：append()、insert()函数

3.5.2 删除数组元素：delete()函数

3.5.3 处理数组的缺失值：isnan()函数

3.5.4 处理数组的重复值：unique()函数

3.5.5 拼接数组：concatenate()、hstack()、vstack()函数

3.5.6 拆分数组：split()、hsplit()、vsplit()函数

3.6 数组的运算

3.6.1 数组之间的四则运算

3.6.2 数组元素的统计运算：sum()、mean()、max()函数

第4章 pandas模块入门

4.1 数据结构

4.1.1 Series对象

4.1.2 DataFrame对象

4.2 读取数据

4.2.1 读取Excel数据：read_excel()函数

1. 读取特定工作簿：sheet_name参数

2. 指定列标签：header参数

3. 指定行标签：index_col参数

4. 读取指定列：usecols参数

4.2.2 读取csv文件数据：read_csv()函数

4.3 查看数据的行数和列数

4.3.1 查看数据的前几行：head()函数

4.3.2 查看行数和列数：shape属性

4.3.3 查看数据的类型

1. info()函数

2. dtype参数

3. astype()函数

4.4 选择数据

4.4.1 选择行数据：loc()、iloc()函数

1. 挑选单行数据

2. 挑选多行数据

3. 挑选满足条件的行

4.4.2 选择列数据：iloc()函数

1. 挑选单列数据

2. 挑选多列数据

4.4.3 同时选择行列数据

4.5 修改行、列标签：columns、index参数；set_index()函数

第五章：pandas模块进阶

5.1 数据的查找和替换

5.1.1 查找数据：isin()函数

5.1.2 替换数据：replace()函数

5.2 数据的处理

5.2.1 插入数据：insert()函数

5.2.2 删除元素：drop()函数

5.2.3 处理缺失值

1. 查看缺失值：isnull()函数

2. 删除缺失值：dropna()函数

3. 缺失值的填充：fillna()函数

5.2.4 处理重复值

1. 删除重复行：drop_duplicates()函数

2. 删除某一列的重复值：subset参数

3. 获取唯一值：unique()函数

5.2.5 排序数据

1. sort_values()函数排序数据

2. rank()函数获取数据的排名

5.2.6 筛选数据

5.3 数据表的处理

5.3.1 转置数据表的行列：T属性

第3章数组的存储和处理：numpy模块

3.2.1 查看行列数：shape属性