目录
1 Numpy库
1.1 数组创建
可以使用array函数从常规Python列表或元组中创建数组。得到的数组的类型是从Python列表中元素的类型推导出来的。
创建数组最简单的办法就是使用array函数。它接受一切序列型的对象（包括其他数组），然后产生一个新的含有传入数据的numpy数组。其中，嵌套序列（比如由一组等长列表组成的列表）将会被转换为一个多维数组。
import numpy as np # 一般使用np作为numpy的别名
a = np.array([1,2,3,4]) # 创建数组
#将列表转换为数组
array = np.array([[1,2,3],
[4,5,6]])
#将元组转换为数组
array = np.array(((1,2,3),
(4,5,6)))
# zeros和ones分别可以创建指定长度或者形状的全0或全1数组
# 创建10行10列的数值为浮点0的矩阵
array_zero = np.zeros([10,10])
# 创建10行10列的数值为浮点1的矩阵
array_one = np.ones([10,10])
# Empty可以创建一个没有任何具体值的数组
emptyarray = np.empty((3,4))
为了创建数字组成的数组，NumPy提供了一个类似于range的函数，该函数返回数组而不是列表。
array = np.arange( 10, 31,5 ) # 此时array [10 15 20 25 30]输出数组的一些信息，如维度、形状、元素个数、元素类型等。
array = np.array([[1,2,3],[4,5,6],[7,8,9],[10,11,12]])
print(array)
# 数组维度
print(array.ndim) # 2
# 数组形状
print(array.shape) # (4,3)
# 数组元素个数
print(array.size) # 12
# 数组元素类型
print(array.dtype) # int64
np.average(array) # 将数组中所有元素求和，然后除以元素个数，任何维度的数组都可以使用，# 重新定义数字的形状 ----reshape([a, b])
# a*b 应该等于原数组的元素个数
array1 = np.arange(6)
print(array1)
# [0 1 2 3 4 5]
# 使用一维数组来创建二维数组
array1 = np.arange(6).reshape([2,3])
print(array1)
# [[0 1 2]
# [3 4 5]]
array2 = np.array([[1,2,3],[4,5,6]],dtype=np.int64).reshape([3,2])
print(array2)
# [[1 2]
# [3 4]
# [5 6]]1.2 数组的计算
数组很重要，因为它可以使我们不用编写循环即可对数据执行批量运算。这通常叫做矢量化（vectorization）。
大小相等的数组之间的任何算术运算都会将运算应用到元素级。同样，数组与标量的算术运算也会将那个标量值传播到各个元素。------广播
# 矩阵的基础运算： 矩阵加减法，要求参与运算的矩阵是 同型矩阵，形状相同。
arr1 = np.array([[1,2,3],[4,5,6]])
arr2 = np.ones([2,3],dtype=np.int64)
print(arr1 + arr2)
print(arr1 - arr2)
# print(arr1 * arr2) # 对应元素相乘
# print(arr1 / arr2) # 对应元素相除
print(arr1 ** 2) # 相当于 print(arr1 * arr1)
# 矩阵乘法：要求参与运算的两个矩阵，内标相同，如，[4,3]和[3,4]可以相乘，结果为[4, 4]的矩阵。
arr3 = np.array([[1,2,3],[4,5,6]])
arr4 = np.ones([3,2],dtype=np.int64)
print(np.dot(arr3,arr4))
矩阵的其他计算：
print(arr3)
print(np.sum(arr3,axis=1)) #axis=1,每一行求和 axie=0,每一列求和
print(np.max(arr3))
print(np.min(arr3))
print(np.mean(arr3))
# print(np.argmax(arr3))
# print(np.argmin(arr3))
arr3_tran = arr3.transpose() # 转置矩阵
print(arr3_tran)
print(arr3.flatten()) # 拍平拉直，[1 2 3 4 5 6]1.3 数组的索引与切片
# 读取、切片操作与列表相同，
arr5 = np.arange(0,6).reshape([2,3])
print(arr5)
print(arr5[1])
print(arr5[1][2]) # 相当于arr5[1,2]
# 切片操作，要用逗号来分隔他们，左边是对行切，右边是对列切
print(arr5[1,:])
print(arr5[:,1])
print(arr5[1,0:2])1.4 广播
for 走的是 python 的流程，而自带函数和广播，底层走的是C 的流程，并且对并行计算进行了优化，效率高。
同样，数组与标量的算术运算也会将那个标量值传播到各个元素。------广播
会将这个标量，扩展成与数组相同形状，然后在运算。加减乘除幂。
arr1 = np.array([[1,2,3],[4,5,6]])
arr1 + 3 # 使得每一个元素值加3
arr1 * 3 # 使得每一个元素乘以32 Pandas
pandas是python第三方库，提供高性能易用数据类型和分析工具。
pandas基于numpy实现，常与numpy和matplotlib一同使用
更多学习，请参考pandas中文网：https://www.pypandas.cn/
2.1 读取文件
# csv，txt 都用read_csv来读取。
# sep 是数据的分隔符，header是数据是否有首行的列名，manes是可以指定列名。
fpath = '文件路径'
data = pd.read_csv(fpath, sep= '\t', header=None, names= ['date', 'pv', 'uv'])
# 如果有列名，但是header=None，会发生什么，去掉列名么？
fpath = '文件路径'
data = pd.read_excel(fpath)
import pymysql
conn = pymysql.connect(
host = '',
user = '',
password = '',
database = '',
cjarset = ''
)
data = pd.read_sql("select * from user", con = conn)2.2 Series
Series是一种类似于一维数组的对象，它由一维数组（各种numpy数据类型）以及一组与之相关的数据标签（即索引）组成。
可理解为带标签的一维数组，可存储整数、浮点数、字符串、Python 对象等类型的数据。
import pandas as pd
import numpy as np
# 使用列表创建Series
s = pd.Series(['a','b','c','d','e'])
print(s) # 两侧，左侧是索引，右侧是数据，
s.index # RangeIndex(start=0, stop=4, step=1)
s.values # array([1, 'a', 5.2, 7], dtype = object)
# Seris中可以使用index设置索引列表。不使用默认的数字索引，索引也可以是字符串
#----------- 与字典不同的是：Series允许索引重复
s = pd.Series(['a','b','c','d','e'],index=[100,200,100,400,500])
print(s)
# Series 可以用字典实例化，key->索引，value->value
d = {'b': 1, 'a': 0, 'c': 2}
pd.Series(d)
# 可以通过Series的values和index属性获取其数组表示形式和索引对象
print(s)
print(s.values) # ['a' 'b' 'c' 'd' 'e']
print(s.index) # RangeIndex(start=0, stop=5, step=1)
#与普通numpy数组相比，可以通过索引的方式选取Series中的单个或一组值
# 根据标签索引查询数据，类似于字典的查询，
print(s[100])
# 100 a
# 100 c
print(s[[400, 500]])
# 400 d
# 500 e
s = pd.Series(np.array([1,2,3,4,5]), index=['a', 'b', 'c', 'd', 'e'])
print(s)
print(s+s) #对应元素求和
print(s*3) #对应元素乘
Series中最重要的一个功能是：它会在算术运算中自动对齐不同索引的数据
Series 和多维数组的主要区别在于， Series 之间的操作会自动基于标签对齐数据。因此，不用顾及执行计算操作的 Series 是否有相同的标签。
obj1 = pd.Series({"Ohio": 35000, "Oregon": 16000, "Texas": 71000, "Utah": 5000})
print(obj1)
Ohio 35000
Oregon 16000
Texas 71000
Utah 5000
obj2 = pd.Series({"California": np.nan, "Ohio": 35000, "Oregon": 16000, "Texas": 71000})
print(obj2)
California NaN
Ohio 35000.0
Oregon 16000.0
Texas 71000.0
print(obj1 + obj2)
California NaN
Ohio 70000.0
Oregon 32000.0
Texas 142000.0
Utah NaN #跟原Series一样，如果传入的列在数据中找不到，就会产生NAN值
s = pd.Series(np.array([1,2,3,4,5]), index=['a', 'b', 'c', 'd', 'e'])
print(s[1:])
b 2
c 3
d 4
e 5
print(s[:-1])
a 1
b 2
c 3
d 4
print(s[1:] + s[:-1])
a NaN
b 4.0
c 6.0
d 8.0
e NaN
2.3 DataFrame
DataFrame是一个表格型的数据结构，类似于Excel或sql表，二维数据，多行多列，
它含有一组有序的列，每列可以是不同的值类型（数值、字符串、布尔值等）
DataFrame既有行索引也有列索引，它可以被看做由Series组成的字典（共用同一个索引）。
创建DataFrame最常用的方法是，读取纯文本文件（csv/txt），读取excel，读取sql数据库。
# 用多维数组字典、列表字典（外层是列表，内层元素是字典）生成 DataFrame
data = {'state': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada'], 'year': [2000, 2001, 2002, 2001, 2002], 'pop': [1.5, 1.7, 3.6, 2.4, 2.9]}
frame = pd.DataFrame(data)
print(frame)
# 如果指定了列顺序，则DataFrame的列就会按照指定顺序进行排列
frame1 = pd.DataFrame(data, columns=['year', 'state', 'pop'])
print(frame1)
# 跟原Series一样，如果传入的列在数据中找不到，就会产生NAN值
frame2 = pd.DataFrame(data, columns=['year', 'state', 'pop', 'debt'], index=['one', 'two', 'three', 'four', 'five'])
print(frame2)
# 用 Series 字典或字典生成 DataFrame
d = {'one': pd.Series([1., 2., 3.], index=['a', 'b', 'c']),
'two': pd.Series([1., 2., 3., 4.], index=['a', 'b', 'c', 'd'])}
print(pd.DataFrame(d))
# 通过类似字典标记的方式或属性的方式，可以将DataFrame的列获取为一个Series,返回的Series拥有原DataFrame相同的索引
print(frame2['state'])
# 列可以通过赋值的方式进行修改,例如，给那个空的“delt”列赋上一个标量值或一组值
frame2['debt'] = 16.5
print(frame2)
在DataFrame中查询，如果查询结果是一行或者一列，返回的是Series ；如果查询结果是多行多列，返回的是Series
查询结果是二维数据，结构仍然是DataFrame，如果是一维数据（一列或者一行），结构会变成Series，
为什么这么做？因为一维数据，类似于Python的字典，对一维字典数据处理起来会比二维数据DataFrame要快速和方便。
扫一扫
397
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
