数据挖掘实例

1.Numpy基础

1.创建数组

创建一维数组

import numpy as np
a = np.arange(5)

注:将0 ,1, 2, 3, 4赋值给a这个变量

创建m*n的多维数组

import numpy  as np

def cnmda(m,n):
    '''创建numpy数组
    参数:
    m:第一维的长度
    n:第二维的长度
    '''
    ret = 0
    
    n = [y for y in range(n)]
    ret = np.array([n]*m)

    return ret

2.数组的基本运算

二维数组

a = np.array( [ [1, 2 , 3],[4 ,5 , 6] ] )

b = np.array( [ [ 4, 5, 6], [1, 2, 3] ] )

二维数组矩阵转置

In: a.T
Out: array([[1,4],
            [2,5]
            [3, 6])

二维数组的加和乘

import numpy  as np

#定义函数
def opeadd(m, b, n):
    '''
    m:是一个数组
    b: 是一个列表
    n: 是列表的索引
    返回 m+b[n] 
'''
    ret = 0
#创建多维数组, 并赋值给ret
    ret  = m + b[n]
    return ret

def opemul(m,b ,n):
    '''
     m:是一个数组
    b: 是一个列表
    n: 是列表的索引
    返回 m*b[n] 
    '''
    ret = 0
#创建多维数组,并赋值给ret
    ret = m* b[n]
    return ret

3.numpy数组的切片和索引

import numpy as  np
 def ce(a, m, n):
    '''
    a:是一个numpy数组
    m:是第m维数组的索引
    n:第m维数组的前n个元素的索引
    你需要做的是 m+b[n]
    返回值:
    ret:一个Numpy数组
'''
    ret = 0
    #实现找出多维数组a中第m个数组的前n个元素 并赋值给ret
    
    ret = a[m, :n]
    return ret

4.numpy数组的堆叠

改变数组的形状

 b = np.arange(24).reshape(2, 3, 4)

reshape()

import numpy as np
In: b = np.arange(24).reshape(2, 3, 4)
Out: b
Out:  array([ [ [0, 1, 2, 3],
                [4, 5, 6, 7],
                [8, 9, 10, 11]],
                
               [
                [12, 13,14, 15],
                [15, 16, 17, 18],
                [19, 20, 21, 22,23] ]
                ]  )

ravel():拆解,将多维数组变成一维数组

In: b.ravel()
Out: array(
           [0, 1, 2, 3,
           4, 5, 6, 7,
           8, 9, 10, 11,
           12, 13,14, 15,
           16, 17, 18,
           19, 20, 21, 22,23 ])

flatten():拉直,其功能与ravel()相同,但是flatten()返回的是真实的数组,需要分配新的内存空间,而ravel()仅仅是改变视图。

 

shape():使用元组改变数组形状

In: b.shape = (6,4)
In: b
out: array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11],
       [12, 13, 14, 15],
       [16, 17, 18, 19],
       [20, 21, 22, 23]])

transpose():转置

In: b.transpose()
Out: array([[ 0,  4,  8, 12, 16, 20],
       [ 1,  5,  9, 13, 17, 21],
       [ 2,  6, 10, 14, 18, 22],
       [ 3,  7, 11, 15, 19, 23]])

数组的堆叠

创建两个数组

In: a = np.arange(9).reshape(3,3)
In: a
Out: array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])
In: b = a*2
In: b
Out: array([[ 0,  2,  4],
       [ 6,  8, 10],
       [12, 14, 16]])

hstack():水平叠加

In: np.hstack((a, b))# 注意这是两个括号
Out: array([[ 0,  1,  2,  0,  2,  4],
       [ 3,  4,  5,  6,  8, 10],
       [ 6,  7,  8, 12, 14, 16]])

vstack():垂直叠加

In: np.vstack((a, b))
Out:array([[ 0,  1,  2],
       [ 3,  4,  5],
       [ 6,  7,  8],
       [ 0,  2,  4],
       [ 6,  8, 10],
       [12, 14, 16]])

dstack():深度叠加

In : np.dstack((a, b))
Out: array([[[ 0,  0],
        [ 1,  2],
        [ 2,  4]],

       [[ 3,  6],
        [ 4,  8],
        [ 5, 10]],

       [[ 6, 12],
        [ 7, 14],
        [ 8, 16]]])

实例:

import numpy as np
def varray(m,n):
    '''
    m:是第一个数组
    n:是第二个数组
    ret:一个numpy数组
'''
    ret = 0
   # 实现数组的垂直叠加并赋值给ret
    ret = np.vstack((m, n))
    return ret

def darray(m, n):
    ret = 0
    #实现数组的深度叠加并赋值给ret
    ret = np.dstack((m,n))
    return ret
def harray(m, n):
    ret = 0 
    #实现数组的水平叠加并赋值给ret
    ret = np.hstack((m, n))
    return ret

5.Numpy的拆分

拆分数组

新建数组

import numpy as np
In: a= np.arange(9).reshape(3,3)
In: a
Out: array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])

hsplit():横向拆分

In: np.hsplit(a,3)
Out: [ array([[0],[3], [6]]),
       array([[1], [4],[7]]), 
       array([[2],[5], [8]])   ]

vsplit():纵向拆分

In: np.vsplit(a,3)
Out: [ array([[0, 1, 2]]),
       array([[3, 4, 5]]),
       array([[6, 7, 8]])  ]

dsplit():深度拆分

深度拆分要求数组的的秩大于等于3

c= np.arange(27).reshape(3,3,3)
In: np.dsplit(c,3)
Out:[
    array([
           [[ 0], [ 3], [ 6]],
           [[ 9], [12],[15]],
           [[18], [21], [24]]
            ]), 

    array([
        [[ 1], [ 4],[ 7]],
        [[10],[13],[16]],
        [[19], [22],[25]]
        ]), 
    
    array([
        [[ 2], [ 5],[ 8]],
        [[11],[14],[17]],
        [[20], [23],[26]]
        ])
    ]

实例

import numpy as np

def vsarray(m, n):
    '''
    m: 第一个数组
    n: 是需要拆分到的维度
    返回值
    ret: 一个Numpy数组
  '''
    ret = 0
    #实现数组的纵向拆分并赋值给ret
    ret = np.vsplit(m,n)
    return ret
def hsarray(m,n):
    ret = 0
    #实现数组的水平拆分并赋值给ret
    ret = np.hsplit(m,n)
    return ret
def dsarray(m, n):
     ret =0
    #实现数组的深度拆分并赋值给ret
    ret = np.dsplit(m, n)
    return ret

2.pandas基础

1.了解数据的处理对象--series

数据结构:

Series:一维数组,类似于Python中的基本数据结构list,区别是Series只允许存储相同的数据类型,这样可以更有效的使用内存,提高运行效率。

DataFrame:二维的表格型数据结构,可以理解为Series容器。

Panel:三维的数组,可以理解为DataFrame容器。

 

Series是一个类似数组的对象,包含一个数组的数据(任何的Numpy的数据累心)和一个与数组关联的数据标签,被叫做索引。最简单的Series是由一个数组的数据构成。

In: obj = Series([4, 7, -5, 3])

In  :obj

Out :

0 4

1 7

2  -5

3  3

创建一个带有索引来确定每个数据点的Series 

In :obj2=Series([4,7,-5,3],index=['d','b','a','c'])
In :obj2
Out:
d 4
b 7
a -5
c 3

通过传递字典来创建一个Series

In :sdata={'Ohio':35000,'Texas':71000,'Oregon':16000,'Utah':5000}
In :obj3=Series(sdata)
In :obj3
Out:
Ohio   35000
Texas  71000
Oregon 16000
Utah   5000

实例

  1. 创建一个名为series_a的series数组,当中值为[1,2,5,7],对应的索引为['nu', 'li', 'xue', 'xi']
  2. 创建一个名为dict_a的字典,字典中包含如下内容{'ting':1, 'shuo':2, 'du':32, 'xie':44}
  3. 将dict_a字典转化成名为series_b的series数组。
# -*- coding: utf-8 -*-
from pandas import Series,DataFrame\
import pandas as pd

def create_series():
    '''
    返回值:
    series_a:一个Series类型的数据
    series_b: 一个Series类型的数据
    dict_a: 一个字典类型的数据

    series_a = Series([1,2,5,7], index= ['nu', 'li', 'xue','xi'])
    dict_a = {'ting':1, 'shuo':2, 'du':32, 'xie':44}
    series_b = Series(dict_a)

    return series_a, dict_a, series_b

 

 

DataFrame是一个表格型数据结构,是以一个或多个二维块存放的数据表格(层次化索引),DataFrame即有行索引还有列索引,他有一组有序的列,每个列既可以是不同的类型(数值、字符串、布尔型)的数据,也可以看做由Series组成的字典。

DataFrame创建:

dictionary = {   'state'['0hio','0hio','0hio','Nevada','Nevada'],
'year':[2000,2001,2002,2001,2002],
'pop':[1.5,1.7,3.6,2.4,2.9] }


frame = DataFrame(dictionary)

修改行名:

frame = DataFrame(dictionary, index =['one','two','three','four','five'])

 

添加修改:

frame[add] = [[0,0,0,0,0]

添加Series类型:

value =Series([1,3,1,4,6,8],index = [0,1,2,3,4,5])
frame['add1'] = value

实例:、

  1. 创建一个五行三列的名为 df1 的DataFrame数组,列名为 [states,years,pops],行名['one','two','three','four','five']
  2. 给df1添加新列,列名为 new_add,值为[7,4,5,8,2]
from pandas import Series,DataFrame
import pandas as pd

def create_dataFrame():
    '''
    返回值:
    df1: 一个DataFrame数据
'''
#**********************************#
    dictionary = {
        'states':['0hio','0hio','0hio','Nevada','Nevada'],
        'years':[2000,2001,2002,2001,2002],
        'pops':[1.5,1.7,3.6,2.4,2.9]  }
    df1 = DataFrame(dictionary)
    df1 = DataFrame(dictionary, index=['one','two','three','four','five'])
    df1['new_add'] =[7,4,5,8,2]
    return df1

 

2.读取csv格式数据

读取csv,并储存在 DataFrame 中。header 关键字告诉 Pandas 哪些是数据的列名。如果没有列名的话就将它设定为 None 。

# Reading a csv into Pandas.
# 如果数据集中有中文的话,最好在里面加上 encoding = 'gbk' ,以避免乱码问题。后面的导出数据的时候也一样。

df = pd.read_csv('uk_rain_2014.csv', header = 0)

查看前n行:df.head(5)

查看后n行:df.tail(5)

查看总行数:len(df)

修改列名:

df.columns = ['water_year','rain_octsep','outflow_octsep','rain_decfeb', 'outflow_decfeb', 'rain_junaug', 'outflow_junaug']

实例:

  1. 将test3/uk_rain_2014.csv中的数据导入到df1中;
  2. 将列名修改为['water_year','rain_octsep','outflow_octsep','rain_decfeb', 'outflow_decfeb', 'rain_junaug', 'outflow_junaug'];
  3. 计算df1的总行数并存储在length1中。
from pandas import Series,DataFrame
import pandas as pd

def read_csv_data():
    '''
返回值:
    df1: 一个DataFrame类型数据
    length1: 一个int类型数据
    '''
#********************
    df1 = pd.read_csv('test3/uk_rain_2014.csv', header =0)
    df1.columns = ['water_year','rain_octsep','outflow_octsep','rain_decfeb', 'outflow_decfeb', 'rain_junaug', 'outflow_junaug']
    length1 = len(df1)
    return df1 , length1

3.数据的基本操作-排序

对索引进行排序

series用sort_index()按索引排序,sort()按值排序

1.
In: obj = Series(range(4), index=['d','a','b','c'])
In  obj.sort_index()  
Out :
a    1
b    2
c    3
d    0

2.
In :frame = DataFrame(np.arange(8).reshape((2,4)),index=['three', 'one'],columns=['d','a','b','c'])
In: frame

Out:
       d  a  b  c
three  0  1  2  3
one    4  5  6  7

In: frame.sort_index()
Out:
       d  a  b  c
one    4  5  6  7
three  0  1  2  3

In:frame.sort()
Out:
       d  a  b  c
one    4  5  6  7
three  0  1  2  3

按行排序

In : frame.sort_index(axis=1, ascending = False)
Out:
       d  c  b  a
three  0  3  2  1
one    4  7  6  5

按列排序(只针对Series)

In: obj.sort()
In : obj
Out:
d    0
a    1
b    2
c    3

按值排序

series

In : obj =Series([4, 7, -3, 2])
In: obj.order()
out:
2   -3
3    2
0    4
1    7

DataFrame:

In: frame = DataFrame({'b':[4, 7, -3, 2], 'a':[0, 1, 0, 1]})
In: frame.sort_values(by='b')
Out: 
   a  b
2  0 -3
3  1  2
0  0  4
1  1  7

实例:

  1. 对代码中s1进行按索引排序,并将结果存储到s2;
  2. 对代码中d1进行按值排序(index为f),并将结果存储到d2。
from pandas import Series,DataFrame
import pandas as pd

def sort_gate():
    '''
    返回值:
    s2: 一个Series类型数据
    d2: 一个DataFrame类型数据
    '''
  # s1是Series类型数据,d1是DataFrame类型数据
    s1 = Series([4, 3, 7, 2, 8], index=['z', 'y', 'j', 'i', 'e'])
    d1 = DataFrame({'e': [4, 2, 6, 1], 'f': [0, 5, 4, 2]})

#*******************************************************************
    s2 = s1.sort_index() 
    d2 = d1.sort_values(by='f')
    return s2,d2

4.数据的基本操作删除

删除指定轴上的项:即删除Series的元素或DataFrame的某一行(列)。我们可以通过对象drop(labels, axis=0)方法实现此功能。

删除Series的一个元素:

In: ser = Series([4.5,7.2,-5.3,3.6], index=['d','b','a','c'])
In: ser.drop('c')
Out: 
d    4.5
b    7.2
a   -5.3

删除DataFrame的行和列

In: df = DataFrame(np.arange(9).reshape(3,3), index=['a','c','d'], columns=['oh','te','ca'])
In: df
Out: 
   oh  te  ca
a   0   1   2
c   3   4   5
d   6   7   8


In: df.drop('a')
Out[19]: 
   oh  te  ca
c   3   4   5
d   6   7   8
In: df.drop(['oh','te'],axis=1)
Out[20]: 
   ca
a   2
c   5
d   8

注意:drop()返回的是一个新对象,元素对象不会被改变。

实例:

  1. 在s1中删除'z'行,并赋值到s2;
  2. 在d1中删除'yy'列,并赋值到d2。
from pandas import Series, DataFrame
import pandas as pd
import numpy as np

def delete_data():
      '''
    返回值:
    s2: 一个Series类型数据
    d2: 一个DataFrame类型数据
    '''
    # s1是Series类型数据,d1是DataFrame类型数据
    s1 = Series([5, 2, 4, 1], index=['v', 'x', 'y', 'z'])
    d1=DataFrame(np.arange(9).reshape(3,3), columns=['xx','yy','zz'])
 
    # ********** Begin *********#
    s2 = s1.drop('z')
    d2 = d1.drop('yy')
    return s2,d2

5.数据的基本操作-算数运算

DataFrame中的算数运算是df中对应位置的元素的算术运算。如果没有共同的元素,则用NaN代替。

In: df1 = DataFrame(np.arange(12.).reshape((3,4)),columns=list('abcd'))
In: df2 = DataFrame(np.arange(20.).reshape((4,5)),columns=list('abcde'))
In: df1+df2
Out: 
    a   b   c   d   e
0   0   2   4   6 NaN
1   9  11  13  15 NaN
2  18  20  22  24 NaN
3 NaN NaN NaN NaN NaN

此外,如果我们想设置默认的其他填充值吗,而非NaN的话,可以传入填充值。

In: df1.add(df2, fill_value=0)
Out: 
    a   b   c   d   e
0   0   2   4   6   4
1   9  11  13  15   9
2  18  20  22  24  14
3  15  16  17  18  19

实例:

  1. 让df1与df2相加得到df3,并设置默认填充值为4。
from pandas import Series,DataFrame
import numpy as np
import pandas aspd

def add_way():
    '''
    返回值:
    df3: 一个DataFrame类型数据
    '''

    # df1,df2是DataFrame类型数据
    df1 = DataFrame(np.arange(12.).reshape((3, 4)), columns=list('abcd'))
    df2 = DataFrame(np.arange(20.).reshape((4, 5)), columns=list('abcde'))
 # ********** Begin *********#
    df3 = df1.add(df2,fill_value =4)
    return df3

6.数据的基本操作-去重

duplicated()

DataFrame的duplicated方法返回一个布尔类型Series,表示各行是否是重复行。

创建DataFrame
In: df = DataFrame({'k1':['one']*3 + ['two']*4, 'k2':[1,1,2,3,3,4,4]})
In: df
Out: 
    k1  k2
0  one   1
1  one   1
2  one   2
3  two   3
4  two   3
5  two   4
6  two   4


检测:
In: df.duplicated()
Out: 
0    False
1     True
2    False
3    False
4     True
5    False
6     True

drop_duplicates()用于去除重复的行数,具体用法:

In: df.drop_duplicates()
Out: 
    k1  k2
0  one   1
2  one   2
3  two   3
5  two   4

实例:

  1. 去除df1中重复的行,并把结果保存到df2中。
from pandas import Series, DataFrame 
import pandas as pd

def delete_duplicated():
    '''
    返回值:
    df2: 一个DataFrame类型数据
    '''

    # df1是DataFrame类型数据
    df1 = DataFrame({'k1': ['one'] * 3 + ['two'] * 4, 'k2': [1, 1, 2, 3, 3, 4, 4]})
    
    # ********** Begin *********#
    df2 = df1.drop_duplicates()
    return df2

7.层次化索引

层次化索引使我们能在一个轴上拥有多个(两个以上)索引级别。

如:

In:data = Series(np.random.randn(10), index = [['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'd', 'd' ],[1,2,3,1,2,3,1,2,2,3]])
In:data
Out:
a  1    0.169239
   2    0.689271
   3    0.879309
b  1   -0.699176
   2    0.260446
   3   -0.321751
c  1    0.893105
   2    0.757505
d  2   -1.223344
   3   -0.802812

索引方式

In:data['b':'d']
Out:
b  1   -0.699176
   2    0.260446
   3   -0.321751
c  1    0.893105
   2    0.757505
d  2   -1.223344
   3   -0.802812

内层选取

In:data[:, 2]
Out:
a    0.689271
b    0.260446
c    0.757505
d   -1.223344

数据重塑

将Series转化为DataFrame:

In:data.unstack()
Out:
         1          2            3
a    0.169239    0.689271    0.879309
b    -0.699176   0.260446  -0.321751
c    0.893105    0.757505    NaN
d    NaN        -1.223344   -0.802812

实例:

  1. 对s1进行数据重塑,转化成DataFrame类型,并复制到d1。
from pandas import Series, DataFrame
import pandas as pd
import numpy as np

def  suosaying():
     '''
    返回值:
    d1: 一个DataFrame类型数据
    '''
    #s1是Series类型数据
    s1=Series(np.random.randn(10),
           index=[['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'd', 'd'],              [1, 2, 3, 1, 2, 3, 1, 2, 2, 3]])
 
    # ********** Begin *********#
    d1 = s1.unstack()
    return d1
suoying()

 

  • 5
    点赞
  • 29
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Yelp数据集是一个包含了商家信息、用户评论和评分、照片等多种数据的丰富数据集。在这个数据集上,可以进行多种数据挖掘任务,包括用户行为分析、评论情感分析、商家评价等。 以下是一个简单的 Yelp数据集数据挖掘实例: 1. 数据集准备:从 Yelp 数据集中提取所需数据,如商家信息、用户评论和评分等。可以使用 Pandas 等工具进行数据清洗和处理。 2. 用户行为分析:通过分析用户的评论行为,可以了解用户的偏好和行为习惯,进而提高商家的服务质量和用户满意度。可以通过分析用户的评论数量、评论内容、评分等指标,进行用户行为分析。 3. 评论情感分析:通过对用户评论进行情感分析,可以了解用户对商家和产品的态度和情感倾向。可以使用自然语言处理技术,如情感词典和机器学习算法,对评论进行情感分析。 4. 商家评价:通过对商家的评价进行综合分析,可以了解商家的服务质量和用户满意度。可以使用多种指标,如平均评分、评论数量、用户反馈等,进行商家评价。 5. 推荐系统:通过对用户历史行为和偏好进行分析,可以为用户推荐符合其兴趣和需求的商家和产品。可以使用协同过滤算法、内容推荐算法等技术,进行推荐系统开发。 以上是一个简单的 Yelp数据集数据挖掘实例。在实际应用中,可以根据具体需求进行数据挖掘和分析,以提高商家服务质量和用户满意度。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值