澳门在线威尼斯官方 > 澳门在线威尼斯官方 > python模块之numpy与pandas

原标题:python模块之numpy与pandas

浏览次数:107 时间:2019-11-01

一、numpy

  numpy是python数据分析和机器学习的基础模块之一。它有两个作用:1.区别于list列表,提供了数组操作、数组运算、以及统计分布和简单的数学模型;2.计算速度快[甚至要由于python内置的简单运算],使得其成为pandas、sklearn等模块的依赖包。高级的框架如TensorFlow、PyTorch等,其数组操作也和numpy非常相似。

四、ndarray数组的操作

  1、创建和存取pandas对象

澳门在线威尼斯官方 1澳门在线威尼斯官方 2

dic = [
    {
        "name": "Li",
        "age": 18,
        "gender": "male"
    },
    {
        "name": "Wusir",
        "age": 16, 
        "gender": "female", 
    }
]

df = pd.DataFrame(
    data=dic, 
    index=None, 
    columns=["name", "age", "gender"], # list(dic.keys()),
    dtype=None, # dtype不可用列表去给每个column去定义
)

字典创建

澳门在线威尼斯官方 3澳门在线威尼斯官方 4

lis = np.random.random(size=(13, 5))
index = pd.period_range(start="2017-01-01", end="2018-01-01", freq="M")
# index = pd.period_range(start=pd.Period('2017Q1', freq='Q'), end=pd.Period('2017Q2', freq='Q'), freq='M')
df= pd.DataFrame(lis, index=index, columns=list("ABCED")).reset_index(drop=False)

数组创建

澳门在线威尼斯官方 5澳门在线威尼斯官方 6

df.to_csv("test", header=True, index=False)
pd.read_csv("test")

保存成csv

澳门在线威尼斯官方 7澳门在线威尼斯官方 8

import pandas as pd
import threading
import sqlalchemy
from sqlalchemy import create_engine

engine = create_engine(
    "mysql+pymysql://root:1234@127.0.0.1:3306/test?charset=utf8",
    max_overflow=5,
    pool_size=10,
    pool_timeout=30,
    pool_recycle=-1,
)

df = pd.read_sql_table("test1", con=engine, columns=None)

读取一张table

澳门在线威尼斯官方 9澳门在线威尼斯官方 10

import numpy as np
import pandas as pd
import pymysql

def conn(sql):
    # 连接到mysql数据库
    conn = pymysql.connect(
        host="localhost",
        port=3306,
        user="root",
        passwd="1234",
        db="test",
    )
    try:
        data = pd.read_sql(sql, con=conn)
        return data
    except Exception as e:
        print("SQL is not correct!", sep="rnrn")
    finally:
        conn.close()

sql = "select * from test1 limit 0, 10"  # sql语句
data = conn(sql)
# print(data.columns.tolist())   # 查看字段
print(data)  # 查看数据

读取sql语句

    使用的数据文件为: 

一维数组的索引和切片

a = np.array([9, 8, 7, 6, 5])

a[2]
Out[5]: 7

a[1 : 4 : 2]
Out[6]: array([8, 6])

  3、数组运算

澳门在线威尼斯官方 11澳门在线威尼斯官方 12

# 加法
np.sum(l1)  # 有意思的sum
np.sum(l1, axis=0)
np.sum(l1, axis=1)
np.sum([l1, l2])
np.subtract(l1, l2)  # 减法
np.multiply(l1, l2)  # 乘法
np.divide(l1, l2)   # 除法
np.power(l1, l2)    # 幂乘
np.floor_divide(l1, l2)  # 地板除
np.floor(l1)  # 向下取整
np.ceil(l1)  # 向上取整
np.dot(l1, l2.T)  # 点积 l2.T表示转置
np.

# 以下和sum的使用方式相同
np.max(l1)    
np.min(l1)
np.mean(l1)
np.median(l1)
np.std(l1)
np.var(l1)
# np.vander()  # 必须是一维数组,
# li = np.arange(1, 5, step=1, dtype=int)
# np.vander(li, len(li))

View Code

  numpy还有其它的一些常用函数,如np.exp(), np.abs()等,也可以通过np.loadtxt读取txt文件。

七、多维数据的存取

  2、数组切片

   array对象的切片和list列表的切片操作相同。记住一个规则array[start: end: step]。

澳门在线威尼斯官方 13澳门在线威尼斯官方 14

dt = np.random.binomial(100, 0.5, size=(10, 5))
dt[1: 3, :]
dt[[1,5], :]
dt[[1, 4, 7]]
dt[:, [2, 4]]

数组切片

   一维和n维数组的转化

澳门在线威尼斯官方 15澳门在线威尼斯官方 16

li = np.random.random((1, 100)).reshape(20, 5)   # 将1行100列的数组转换成20行5列的新数组
print(li)

li = li.reshape((2, -1))  # 将20行5列的数组转换成2行50列的新数组
# 将20行5列的数组转换为2行50列的数组,-1表示根据原数据和当前行[列]参数来自动生成列[行]数
print(li)

li = li.reshape(-1, 100)  # 将2行50列的数组转换成1行100列的数组
print(li)

数组维度转化

ndarray的元素类型

数据类型 说明
bool 布尔类型,true或false
intc 与C语言中的int类型一致,一般是int32或int64
intp 用于索引的整数,与C语言中的ssize_t一致,int32或int64
int8 字节长度的整数,取值:【-128,127】
int16 16位长度的整数,取值:【-32768,32767】
int32 32位长度的整数,取值:【-231,231-1】
int64 64位长度的整数,取值:【-263,263-1】
uint8 8位无符号整数,取值【0,255】
uint16 16位无符号整数,取值【0,65535】
unit32 32位无符号整数,取值【0,232-1】
uint64 64位无符号整数,取值【2,264-1】
float16 16位半精度浮点数:1位符号位,5位指数位,10位尾数
float32 32位半精度浮点数:1位符号位,8位指数位,23位尾数
float64 16位半精度浮点数:1位符号位,11位指数位,52位尾数
complex64 复数类型,实部和虚部都是32位浮点数
complex128 复数类型,实部和虚部都是64位浮点数

    待续。。。。。。

    

 

 

 

    

一、数据的维度


  2、切片与增删改查

十一、图像的数组表示

二、pandas

  官方api:

  pandas是python数据分析的核心模块。它主要提供了五大功能:

    - 1.支持文件存取操作,支持数据库(sql)、html、json、pickle、csv(txt、excel)、sas、stata、hdf等。

    - 2.支持增删改查、切片、高阶函数、分组聚合等单表操作,以及和dict、list的互相转换。

    - 3.支持多表拼接合并操作。

    - 4.支持简单的绘图操作。

    - 5.支持简单的统计分析操作。

ndarray数组的类型变换

new_a = a.astype(new_type)

a = np.ones((2,3,4), dtype=np.int)

a
Out[32]: 
array([[[1, 1, 1, 1],
        [1, 1, 1, 1],
        [1, 1, 1, 1]],

       [[1, 1, 1, 1],
        [1, 1, 1, 1],
        [1, 1, 1, 1]]])

b = a.astype(np.float)

b
Out[34]: 
array([[[ 1.,  1.,  1.,  1.],
        [ 1.,  1.,  1.,  1.],
        [ 1.,  1.,  1.,  1.]],

       [[ 1.,  1.,  1.,  1.],
        [ 1.,  1.,  1.,  1.],
        [ 1.,  1.,  1.,  1.]]])

astype()方法一定会创建新的数组。


  1、随机数生成

    常用的生成随机数的几个函数:

    澳门在线威尼斯官方 17

澳门在线威尼斯官方 18澳门在线威尼斯官方 19

li = list(range(10))
print(li, type(li))

li = np.array(li)
print(li, type(li))

li = li.tolist()   # list(li)也可以
print(li, type(li))

list和array互相转化

澳门在线威尼斯官方 20澳门在线威尼斯官方 21

np.random.rand(10, 5)   # 生成[0, 1]之间均匀分布的数组10行,5列

np.random.randn(10, 5)  # 生成[0, 1]之间均匀分布的数组10行,5列

np.random.randint(10, 20, size=(10, 5))  #  生成[10, 20]之间随机数组10行,5列

np.random.random(size=(10, 5))  # 生成[0, 1]之间的10行5列的数组

li = list(range(10))
np.random.choice(li, size=(10, 5))  # 从li中产生随机数,生成10行5列的数组

np.arange(10, 20, 2, )      # 从[10, 20]中以步长为2生成一维数组

函数使用

     其它不常见的随机数生成函数:

    澳门在线威尼斯官方 22

澳门在线威尼斯官方 23澳门在线威尼斯官方 24

np.random.binomial(100, 0.5, size=(10, 5))

二项分布

图像的RGB色彩模式

  • 取值:0-255

  4、数组拼接

澳门在线威尼斯官方 25澳门在线威尼斯官方 26

l1 = np.linspace(10, 20, num=72).reshape(12, 6)
l2 = np.random.random(size=(12, 6))

np.vstack((l1, l2))  # 按列拼接
np.hstack((l1, l2))  # 按行拼接

np.vsplit(l1, [3, 6, 9]) # 按行切割,参数3, 6, 9表示在第几行切割一下[包括这一行],生成一个list对象
np.hsplit(l1, [1, 3,])  #  按列切割

View Code

ndarray数组的创建方法

1.从python中的列表、元组等类型创建ndarray数组

x = np.array(list/tuple)
x = np.array(list/tuple, dtype=np.float32)

当np.array()不指定dtype时,numpy将根据数据情况关联一个dtype类型。


2.使用numpy中函数创建ndarray数组,如:arange,ones,zeros等。

函数 说明
np.arange(n) 类似range()函数,返回ndarray类型,元素从0到n-1
np.ones(shape) 根据shape生成一个全1数组,shape是元组类型
np.zeros(shape) 根据shape生成一个全0数组,shape是元组类型
np.full(shape,val) 根据shape生成一个数组,每个元素值都是val
np.eye(n) 创建一个正方的n*m单位矩阵,对角线为1,其余为0
np.ones_like(a) 根据数组a的形状生成一个全1数组
np.zeros_like(a) 根据数组a的形状生成一个全0数组
np.full_like(a,val) 根据数组a的形状生成一个数组,每个元素值都是val
np.arange(10)
Out[14]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

np.ones((3, 6))
Out[15]: 
array([[ 1.,  1.,  1.,  1.,  1.,  1.],
       [ 1.,  1.,  1.,  1.,  1.,  1.],
       [ 1.,  1.,  1.,  1.,  1.,  1.]])

np.zeros((3, 6), dtype=np.int32)
Out[16]: 
array([[0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0]])

np.eye(5)
Out[17]: 
array([[ 1.,  0.,  0.,  0.,  0.],
       [ 0.,  1.,  0.,  0.,  0.],
       [ 0.,  0.,  1.,  0.,  0.],
       [ 0.,  0.,  0.,  1.,  0.],
       [ 0.,  0.,  0.,  0.,  1.]])

x = np.ones((2, 3, 4))

print(x)
[[[ 1.  1.  1.  1.]
  [ 1.  1.  1.  1.]
  [ 1.  1.  1.  1.]]

 [[ 1.  1.  1.  1.]
  [ 1.  1.  1.  1.]
  [ 1.  1.  1.  1.]]]

x.shape
Out[20]: (2, 3, 4)

3.使用numpy中其他函数创建ndarray数组

函数 说明
np.linspace() 根据起止数据等间距地填充数据,形成数组
np.concatenate() 将两个或多个数组合并成一个新的数组
a = np.linspace(1, 10, 4)

a
Out[9]: array([  1.,   4.,   7.,  10.])

b = np.linspace(1, 10, 4, endpoint=False)

b
Out[11]: array([ 1.  ,  3.25,  5.5 ,  7.75])

c = np.concatenate((a,b))

c
Out[13]: array([  1.  ,   4.  ,   7.  ,  10.  ,   1.  ,   3.25,   5.5 ,   7.75])

六、数据的CSV文件存取

numpy一元函数对ndarray中的数据执行元素级运算的函数

函数 说明
np.abs(x) np.fabs(x) 计算数组各元素的绝对值
np.sqart(x) 计算数组各元素的平方根
np.square(x) 计算数组各元素的平方
np.log(x) np.log10(x) np.log2(x) 计算数组各元素的自然对数、10底对数和2底对数
np.ceil(x) np.floor(x) 计算数组各元素的ceiling值或floor值
np.rint(x) 计算数组各元素的四舍五入值
np.modf(x) 将数组各元素的小数和整数部分以两个独立数组形式返回
np.cos(x) np.cosh(x) np.sin(x) np.sinh(x) np.tan(x) np.tanh(x) 计算数组各元素的普通型和双曲型三角函数
np.sign(x) 计算数组各元素的符号值,1(+),0,-1(-)
np.exp(x) 计算数组各元素的指数值

三、ndarray数组的创建和变换


数据维度的python表示

一维数据:列表和集合类型

[3.14, 5.44 ,5.55] 有序
{3.14, 5.44 ,5.55} 无序

二维数据:列表类型
多维数据:列表类型

[ [3.14, 5.44 ,5.55],
  [3.14, 5.44 ,5.55]  ]

高维数据:字典类型或数据类型表示

dict = {
          "firstName":"Mace",
          "lastName":"Jin",
}

numpy的random子库

np.random的随机数函数

函数 说明
rand(d0,...,dn) 根据d0-d创建随机数数组,浮点数,[0,1),均匀分布
randn(d0,...,dn) 根据d0-d创建随机数数组,标准正态分布
randint(low[,high,shape]) 根据shape创建随机整数或整数数组,范围是[low,high]
seed(s) 随机数种子,s是给定的种子值
import numpy as np

a = np.random.rand(3, 4, 5)

a
Out[3]: 
array([[[ 0.90054795,  0.71624173,  0.79112233,  0.32650461,  0.84619615],
        [ 0.44591395,  0.36828326,  0.76291491,  0.05558484,  0.12433055],
        [ 0.07534764,  0.8384202 ,  0.11716862,  0.47834772,  0.54191282],
        [ 0.2388626 ,  0.35017533,  0.25186745,  0.15812048,  0.41712066]],

       [[ 0.44394913,  0.91778932,  0.74652455,  0.91372906,  0.5342139 ],
        [ 0.3797729 ,  0.29731658,  0.21936994,  0.2333807 ,  0.7610462 ],
        [ 0.10821976,  0.04970031,  0.18018693,  0.11947951,  0.03711413],
        [ 0.97599868,  0.31263183,  0.52624546,  0.35155422,  0.5016402 ]],

       [[ 0.10641334,  0.5153669 ,  0.81933421,  0.44368124,  0.94465126],
        [ 0.31304866,  0.5379593 ,  0.19853566,  0.07185523,  0.36389356],
        [ 0.77520593,  0.74260994,  0.43217268,  0.26971247,  0.50587306],
        [ 0.69963568,  0.72048552,  0.97696634,  0.17689354,  0.02467841]]])

sn = np.random.randn(3, 4, 5)

sn
Out[5]: 
array([[[ 1.43524925, -0.01709225,  0.74060875,  0.10516008,  1.67940313],
        [-2.03931972,  0.4263534 , -0.18865956,  1.00951697, -0.17700187],
        [ 0.42265079, -0.56889342,  0.42843036,  0.1482564 , -0.99566954],
        [-1.89553322,  0.03920585, -0.53351015, -0.58438961, -2.62456031]],

       [[-1.23407899, -0.12697763, -0.13177403,  0.28296367,  1.2963296 ],
        [ 0.34109667, -1.16165189, -0.39677244, -0.32564733, -0.85124886],
        [ 0.27403558,  0.97343758, -0.80993655, -0.00463434, -1.87235953],
        [ 1.23773591,  0.05530726, -0.08753156, -0.25033669, -0.00327984]],

       [[ 1.07393704,  1.16992607, -2.91612329, -1.55628507,  0.83542134],
        [-0.83865651, -0.85258962,  1.04403901,  1.64369287,  0.19337034],
        [ 0.16633997, -0.09558055,  0.05283974, -1.31325106,  0.0460602 ],
        [ 0.52758321,  1.29531339, -0.92198878,  0.19512485,  0.1081831 ]]])

b = np.random.randint(100, 200, (3,4))

b
Out[7]: 
array([[153, 173, 139, 150],
       [190, 110, 180, 150],
       [178, 118, 174, 172]])

np.random.seed(10)

np.random.randint(100, 200, (3,4))
Out[9]: 
array([[109, 115, 164, 128],
       [189, 193, 129, 108],
       [173, 100, 140, 136]])

np.random.seed(10)

np.random.randint(100, 200, (3,4))
Out[11]: 
array([[109, 115, 164, 128],
       [189, 193, 129, 108],
       [173, 100, 140, 136]])

函数 说明
shuffle(a) 根据数组a的第1轴进行随机排列,改变数组x
permutation(a) 根据数组a的第一个轴产生一个新的乱序数组,不改变数组x
choice(a[,size,replace,p]) 从一维数组a中以概率p抽取元素,形成size形状新数组replace表示是否可以重用元素,默认位False
np.random.randint(100, 200, (3,4))
Out[11]: 
array([[109, 115, 164, 128],
       [189, 193, 129, 108],
       [173, 100, 140, 136]])

a = np.random.randint(100, 200, (3,4))

a
Out[13]: 
array([[116, 111, 154, 188],
       [162, 133, 172, 178],
       [149, 151, 154, 177]])

np.random.shuffle(a)

a
Out[15]: 
array([[116, 111, 154, 188],
       [149, 151, 154, 177],
       [162, 133, 172, 178]])

np.random.shuffle(a)

a
Out[17]: 
array([[162, 133, 172, 178],
       [116, 111, 154, 188],
       [149, 151, 154, 177]])

a = np.random.randint(100, 200, (3,4))

a
Out[23]: 
array([[177, 122, 123, 194],
       [111, 128, 174, 188],
       [109, 115, 118, 180]])


b = np.random.permutation(a)

b
Out[26]: 
array([[109, 115, 118, 180],
       [111, 128, 174, 188],
       [177, 122, 123, 194]])

a
Out[27]: 
array([[177, 122, 123, 194],
       [111, 128, 174, 188],
       [109, 115, 118, 180]])

b = np.random.randint(100, 200, (8,))

b
Out[30]: array([117, 146, 107, 175, 128, 133, 184, 196])

np.random.choice(b, (3, 2))
Out[31]: 
array([[117, 128],
       [133, 128],
       [196, 117]])

np.random.choice(b, (3, 2), replace=False)
Out[32]: 
array([[133, 175],
       [146, 196],
       [184, 128]])

np.random.choice(b, (3, 2), p=b/np.sum(b))
Out[33]: 
array([[196, 107],
       [146, 196],
       [133, 133]])

函数 说明
uniform(low,high,size) 产生具有均匀分布的数组,low起始值,high结束值,size形状
normal(loc,scale,size) 产生具有正态分布的数组,loc均值,scale标准差,size形状
poisson(lam,size) 产生具有泊松分布的数组,lam随机事件发生率值,size形状
u = np.random.uniform(0, 10, (3,4))

u
Out[35]: 
array([[ 4.36353698,  3.56250327,  5.87130925,  1.49471337],
       [ 1.71238598,  3.97164523,  6.37951564,  3.72519952],
       [ 0.02406761,  5.48816356,  1.26971841,  0.79792681]])

n = np.random.normal(10, 5, (3,4))

n
Out[37]: 
array([[ 13.57941572,   4.07115727,   6.81836048,   6.94593078],
       [  3.40304302,   7.19135792,  11.02692287,   5.23319662],
       [ 11.60758976,   2.39530663,  -0.80726459,  11.72656647]])

八、numpy的随机数函数

二、NumPy的数组对象:ndarray

一个强大的N维数组对象


澳门在线威尼斯官方 ,PIL库

from PIL import Image

Image是PIL库中代表一个图像的类(对象)

from PIL import Image

import numpy as np

a = np.array(Image.open("D:/py/el.jpg"))

print(a.shape, a.dtype)
(375, 500, 3) uint8

b = [255, 255, 255] - a

im = Image.fromarray(b.astype('uint8'))

im.save("D:/py/el2.jpg")

澳门在线威尼斯官方 27

el.jpg

澳门在线威尼斯官方 28

el2.jpg


from PIL import Image

import numpy as np

a = np.array(Image.open("D:/py/el.jpg").convert('L'))

b = 255 - a

im = Image.fromarray(b.astype('uint8'))

im.save("D:/py/el3.jpg")

澳门在线威尼斯官方 29

el3.jpg

from PIL import Image

import numpy as np

a = np.array(Image.open("D:/py/el.jpg").convert('L'))

c = (100/255)*a + 150 #区间变换

im = Image.fromarray(c.astype('uint8'))

im.save("D:/py/el4.jpg")

澳门在线威尼斯官方 30

el4.jpg

from PIL import Image

import numpy as np

a = np.asarray(Image.open("D:/py/pd.jpg").convert('L')).astype('float')

depth = 10

grad = np.gradient(a)

grad_x, grad_y = grad

grad_x = grad_x*depth/100.

grad_y = grad_y*depth/100.

A = np.sqrt(grad_x**2 + grad_y**2 + 1.)

uni_x = grad_x/A

uni_y = grad_y/A

uni_z = 1./A

vec_el = np.pi/2.2

vec_az = np.pi/4.

dx = np.cos(vec_el)*np.cos(vec_az)

dy = np.cos(vec_el)*np.sin(vec_az)

dz = np.sin(vec_el)

b = 255*(dx*uni_x + dy*uni_y + dz*uni_z)

b = b.clip(0, 255)

im = Image.fromarray(b.astype('uint8'))

im.save("D:/py/pdHD.jpg")

本文由澳门在线威尼斯官方发布于澳门在线威尼斯官方,转载请注明出处:python模块之numpy与pandas

关键词:

上一篇:没有了

下一篇:没有了