精华内容
下载资源
问答
  • 2019-05-23 11:03:38

    Series的索引和切片

       可以取中括号取单个索引(此时返回的是元素类型),或者中括号里一个列表取多个索引(此时返回的仍然是一个Series类型)

        分为显示索引隐式索引

    (1) 显示索引 (必须给索引的值):

        -- 使用index中的元素作为索引值
        -- 使用 .loc[]  (推荐)

    注意此时是闭区间

    import numpy as np
    from pandas import Series
    
    # 创建好Series
    s = Series(np.random.random(10),index=list('abcdefghig'))
    print(s)
    print(s['a'])  # 可以直接取出行号为 'a' 的数据
    print(s.loc['a'])  # 通过 .loc[]  的 方式取出索引为'a'的值
    '''
        运行结果:
        a    0.866009
        b    0.173073
        c    0.679109
        d    0.247098
        e    0.115333
        f    0.085793
        g    0.135284
        h    0.203943
        i    0.125305
        g    0.564275
        dtype: float64
        0.8598185678819752
        0.8598185678819752
    '''
    

    (2) 隐式索引:

       --- 使用整数作为索引值
       --- 使用  .iloc[]  (推荐)

     注意: 此时是半开区间

    print(s[0])  # 通过[]整数的方法取出相应索引的值
    print(s.iloc[0])  # 通过 .iloc[] 取出相应索引的值
    """
       运行结果:
       0.32848002630924467
        0.32848002630924467 
    """

    (3) 切片   (代码实例)

    # 切片
    '''# 取出索引值为 'a'到'e'的值'''
    print(s['a':'e'])
    '''# 取出从第一个开始到第五个'''
    print(s[0:5])
    '''取的方法和列表大致相同'''

     

     Series的基本概念

        1. 可以把Series看成一个定长的有序字典
             可以通过shape,size,index,values等得到series的属性

    '''# 打印Series的形状 对于Series而言只能是一维的'''
    print(s.shape)
    # 结果  (10,)   代表 10 行
    
    '''# 打印出Series的大小'''
    print(s.size)  
    # 结果  10
    
    '''打印出索引值'''
    print(s.index)
    # 结果 Index(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'g'], dtype='object')
    
    '''打印出所有的值'''
    print(s.values)
    # 结果 [0.08580958 0.06484278 0.86393773 0.99667033 0.93736993 0.55856375
    #  0.86119536 0.396556   0.30890221 0.51369992]

    2. 可以通过head(),tail()快速查看Series对象的样式

         对于大数据来说,读取文件的前几行和读取文件的后几行来说是非常必要的

    '''head()方法,打印前几行,默认只打印前5行'''
    print(s.head())
    '''可以给head()方法中传递正整数值,数值为几,就打印前几行'''
    print(s.head(7))  # 打印前7行
    
    '''tail()方法,打印后几行,默认只打印后5行'''
    print(s.tail())
    '''可以给tail()方法中传递正整数值,数值为几,就打印后几行'''
    print(s.tail(7))  # 打印后5行

    3.当索引没有对应的值时,可能出现缺失数据显示NaN(not a number)的情况

    s1 = Series([1, 26, None, np.nan], index=list('金木水火'))
    print(s1)
    """
        运行结果:
        金     1.0
        木    26.0
        水     NaN
        火     NaN
        dtype: float64
    """

        有空值时,是可以进行加和等运算的,Series会自动将无效的空值等转化为float型,而在numpy的类型中是不可以的  

    4.可以使用pd.isnull(),pd.notnull(),或自带isnull(),notnull()函数检测缺失数据

    '''判断Series是否为空,返回的类型还是Series'''
    print(s1.isnull())
    """ 结果
        金    False
        木    False
        水     True
        火     True
        dtype: bool
    """
    
    '''判断Series不为空吗 , 为空返回False,不为空返回True'''
    print(s1.notnull())
    """ 结果:
        金     True
        木     True
        水    False
        火    False
        dtype: bool
    """
    
    '''取出Series中不为空的数据 Series[Series.notnull()]'''
    print(s1[s1.notnull()])
    """
        金     1.0
        木    26.0
        dtype: float64
    """

    5.Series对象本身及其索引都有一个name属性,  

        name的作用: 区分,在DataFrame中用于区分,在DataFrame中是列名

    s1.name = '元素'
    print(s1)  # 然后就会有Name属性
    """ 结果:
        金     1.0
        木    26.0
        水     NaN
        火     NaN
        Name: 元素, dtype: float64
    """

    在运算中自动对齐不同索引的数据
    如果索引不对应,则补NaN
        注意:要想保留所有的index,则需要使用.add()函数

     Series的运算

       1.可以进行加减乘除    (直接利用加减乘除符号进行运算时,Nan是不会进行加减乘除的)

    print(s1 + 10)
    """
    金    11.0
    木    36.0
    水     NaN
    火     NaN
    Name: 元素, dtype: float64
    """

    2.  使用add()方法,参数fill_value,    如果在进行加减乘除运算的时候,有NaN的值,

        那么fill_value默认会将NaN设置为= 后面的值

    print(s1.add(10,fill_value=0))  # fill_value=0把NaN设置为0
    """
    金    11.0
    木    36.0
    水    10.0
    火    10.0
    Name: 元素, dtype: float64
    """

     3.Series之间进行运算

       ---  在运算中自动对齐不同索引的数据        Series最重要的特征是有索引值

       --- 如果索引对应,,在进行相加时,索引相同进行相加
       ---  如果索引不对应,则补NaN
                                 注意:要想保留所有的index,则需要使用.add()函数

    from pandas import Series
    
    s1 = Series([2, 4, 7, 9], index=[0, 1, 2, 3])
    s2 = Series([1, 2, 3, 4], index=[2, 3, 4, 5])
    # 索引不对应
    print(s1 + s2)
    """
        0     NaN
        1     NaN
        2     8.0
        3    11.0
        4     NaN
        5     NaN
        dtype: float64
    """
    # 保留所有的引用,即连个索引取并集
    # fill_value: 有空即填充等号后面的值
    print(s1.add(s2,fill_value=0))
    """
        0     2.0
        1     4.0
        2     8.0
        3    11.0
        4     3.0
        5     4.0
        dtype: float64
    """

    Series数据有空值(None)时,是可以的进行相加的

    更多相关内容
  • 一、文件读取与写入 1.读取 (a)csv格式 df = pd.read_csv(r'C:\Users\chenyiqun\Desktop\joyful-pandas-master\joyful-pandas-master\data\table.csv') df.head() (b)txt格式 df_txt = pd.read_table(r'C:\...

    import pandas as pd
    import numpy as np

    查看Pandas版本

    pd.__version__

    一、文件读取与写入

    1.读取

    (a)csv格式

    df = pd.read_csv(r'C:\Users\chenyiqun\Desktop\joyful-pandas-master\joyful-pandas-master\data\table.csv')
    df.head()

    在这里插入图片描述

    (b)txt格式

    df_txt = pd.read_table(r'C:\Users\chenyiqun\Desktop\joyful-pandas-master\joyful-pandas-master\data\table.txt') #可设置sep分隔符参数
    df_txt

    在这里插入图片描述

    (c)xls或xlsx格式

    #需要安装xlrd包
    df_excel = pd.read_excel(r'C:\Users\chenyiqun\Desktop\joyful-pandas-master\joyful-pandas-master\data\table.xlsx')
    df_excel.head()

    在这里插入图片描述

    2. 写入

    (a)csv格式

    df.to_csv('data/new_table.csv')
    #df.to_csv('data/new_table.csv', index=False) #保存时除去行索引

    (b)xls或xlsx格式

    #需要安装openpyxl
    df.to_excel('data/new_table2.xlsx', sheet_name='Sheet1')

    二、基本数据结构

    1.Series

    (a)创建一个Series

    对于一个Series,其中最常用的属性为值(values),索引(index),名字(name),类型(dtype)

    s = pd.Series(np.random.randn(5),index=['a','b','c','d','e'],name='这是一个Series',dtype='float64')
    s
    a    1.456004
    b   -0.707533
    c    0.485580
    d   -1.356148
    e   -0.202208
    Name: 这是一个Series, dtype: float64

    (b)访问Series属性

    s.values

    array([ 1.45600438, -0.70753348, 0.48558013, -1.35614791, -0.20220802])

    s.name

    ‘这是一个Series’

    s.index

    Index([‘a’, ‘b’, ‘c’, ‘d’, ‘e’], dtype=‘object’)

    s.dtype

    dtype(‘float64’)

    (c)取出某一个元素

    s['a']

    1.4560043774073959

    (d)调用方法

    s.mean()

    -0.06486097947792556

    Series有相当多的方法可以调用:

    print([attr for attr in dir(s) if not attr.startswith('_')])
    ['T', 'a', 'abs', 'add', 'add_prefix', 'add_suffix', 'agg', 'aggregate', 'align', 'all', 'any', 'append', 'apply', 'argmax', 'argmin', 'argsort', 'array', 'asfreq', 'asof', 'astype', 'at', 'at_time', 'attrs', 'autocorr', 'axes', 'b', 'between', 'between_time', 'bfill', 'bool', 'c', 'clip', 'combine', 'combine_first', 'convert_dtypes', 'copy', 'corr', 'count', 'cov', 'cummax', 'cummin', 'cumprod', 'cumsum', 'd', 'describe', 'diff', 'div', 'divide', 'divmod', 'dot', 'drop', 'drop_duplicates', 'droplevel', 'dropna', 'dtype', 'dtypes', 'duplicated', 'e', 'empty', 'eq', 'equals', 'ewm', 'expanding', 'explode', 'factorize', 'ffill', 'fillna', 'filter', 'first', 'first_valid_index', 'floordiv', 'ge', 'get', 'groupby', 'gt', 'hasnans', 'head', 'hist', 'iat', 'idxmax', 'idxmin', 'iloc', 'index', 'infer_objects', 'interpolate', 'is_monotonic', 'is_monotonic_decreasing', 'is_monotonic_increasing', 'is_unique', 'isin', 'isna', 'isnull', 'item', 'items', 'iteritems', 'keys', 'kurt', 'kurtosis', 'last', 'last_valid_index', 'le', 'loc', 'lt', 'mad', 'map', 'mask', 'max', 'mean', 'median', 'memory_usage', 'min', 'mod', 'mode', 'mul', 'multiply', 'name', 'nbytes', 'ndim', 'ne', 'nlargest', 'notna', 'notnull', 'nsmallest', 'nunique', 'pct_change', 'pipe', 'plot', 'pop', 'pow', 'prod', 'product', 'quantile', 'radd', 'rank', 'ravel', 'rdiv', 'rdivmod', 'reindex', 'reindex_like', 'rename', 'rename_axis', 'reorder_levels', 'repeat', 'replace', 'resample', 'reset_index', 'rfloordiv', 'rmod', 'rmul', 'rolling', 'round', 'rpow', 'rsub', 'rtruediv', 'sample', 'searchsorted', 'sem', 'set_axis', 'shape', 'shift', 'size', 'skew', 'slice_shift', 'sort_index', 'sort_values', 'squeeze', 'std', 'sub', 'subtract', 'sum', 'swapaxes', 'swaplevel', 'tail', 'take', 'to_clipboard', 'to_csv', 'to_dict', 'to_excel', 'to_frame', 'to_hdf', 'to_json', 'to_latex', 'to_list', 'to_markdown', 'to_numpy', 'to_period', 'to_pickle', 'to_sql', 'to_string', 'to_timestamp', 'to_xarray', 'transform', 'transpose', 'truediv', 'truncate', 'tshift', 'tz_convert', 'tz_localize', 'unique', 'unstack', 'update', 'value_counts', 'values', 'var', 'view', 'where', 'xs']

    2.DataFrame

    (a)创建一个DataFrame

    df = pd.DataFrame({'col1':list('abcde'),'col2':range(5,10),'col3':[1.3,2.5,3.6,4.6,5.8]},
                     index=list('一二三四五'))
    df

    在这里插入图片描述

    (b)从DataFrame取出一列为Series

    df['col1']
    1.32.53.64.65.8
    Name: col3, dtype: float64
    type(df)

    pandas.core.frame.DataFrame

    type(df['col3'])

    pandas.core.series.Series

    (c)修改行或列名

    df.rename(index={'一':'1'},columns={'col1':'第一列'})

    在这里插入图片描述

    (d)调用属性和方法

    df.index

    Index([‘一’, ‘二’, ‘三’, ‘四’, ‘五’], dtype=‘object’)

    df.columns

    Index([‘col1’, ‘col2’, ‘col3’], dtype=‘object’)

    df.values

    array([[‘a’, 5, 1.3],
    [‘b’, 6, 2.5],
    [‘c’, 7, 3.6],
    [‘d’, 8, 4.6],
    [‘e’, 9, 5.8]], dtype=object)

    df.shape

    (5, 3)

    df.mean() #本质上是一种Aggregation操作,将在第3章详细介绍

    col2 7.00
    col3 3.56
    dtype: float64

    (e)索引对齐特性

    这是Pandas中非常强大的特性,不理解这一特性有时就会造成一些麻烦

    df1 = pd.DataFrame({'A':[1,2,3]},index=[1,2,3])
    df2 = pd.DataFrame({'A':[1,2,3]},index=[3,1,2])
    df1-df2 #由于索引对齐,因此结果不是0

    在这里插入图片描述

    (f)列的删除与添加

    对于删除而言,可以使用drop函数或del或pop

    df.drop(index='五',columns='col1') #设置inplace=True后会直接在原DataFrame中改动

    在这里插入图片描述

    df['col1']=[1,2,3,4,5]
    del df['col1']
    df

    在这里插入图片描述
    pop方法直接在原来的DataFrame上操作,且返回被删除的列,与python中的pop函数类似

    df['col1']=[1,2,3,4,5]
    df.pop('col1')

    一 1
    二 2
    三 3
    四 4
    五 5
    Name: col1, dtype: int64

    df

    在这里插入图片描述
    可以直接增加新的列,也可以使用assign方法

    df1['B']=list('abc')
    df1

    在这里插入图片描述

    df1.assign(C=pd.Series(list('def')))
    #思考:为什么会出现NaN?(提示:索引对齐)assign左右两边的索引不一样,请问结果的索引谁说了算?

    在这里插入图片描述
    但assign方法不会对原DataFrame做修改

    (g)根据类型选择列

    df.select_dtypes(include=['number']).head()

    在这里插入图片描述

    df.select_dtypes(include=['float']).head()

    在这里插入图片描述

    (h)将Series转换为DataFrame

    # 此部操作之后,s成为一series
    s = df.mean()
    s.name='to_DataFrame'
    s
    col2    7.00
    col3    3.56
    Name: to_DataFrame, dtype: float64
    # 将s,转换成dataframe
    s.to_frame()

    在这里插入图片描述
    使用T符号可以转置

    s.to_frame().T

    在这里插入图片描述

    三、常用基本函数

    df = pd.read_csv(r'C:\Users\chenyiqun\Desktop\joyful-pandas-master\joyful-pandas-master\data\table.csv')

    从下面开始,包括后面所有章节,我们都会用到这份虚拟的数据集

    1.head和tail

    df.head()

    在这里插入图片描述

    df.tail()

    在这里插入图片描述
    可以指定n参数显示多少行

    df.head(2)

    在这里插入图片描述

    2.unique和nunique

    nunique显示有多少个唯一值

    df['Physics'].nunique()

    7
    unique显示所有的唯一值

    df['Physics'].unique()
    array(['A+', 'B+', 'B-', 'A-', 'B', 'A', 'C'], dtype=object)

    3.count和value_counts

    count返回非缺失值元素个数

    df['Physics'].count()

    35
    value_counts返回每个元素有多少个

    df['Physics'].value_counts()
    B+    9
    B     8
    B-    6
    A     4
    A-    3
    A+    3
    C     2
    Name: Physics, dtype: int64

    4.describe和info

    info函数返回有哪些列、有多少非缺失值、每列的类型

    df.info()
    <class 'pandas.core.frame.DataFrame'>
    RangeIndex: 35 entries, 0 to 34
    Data columns (total 9 columns):
     #   Column   Non-Null Count  Dtype  
    ---  ------   --------------  -----  
     0   School   35 non-null     object 
     1   Class    35 non-null     object 
     2   ID       35 non-null     int64  
     3   Gender   35 non-null     object 
     4   Address  35 non-null     object 
     5   Height   35 non-null     int64  
     6   Weight   35 non-null     int64  
     7   Math     35 non-null     float64
     8   Physics  35 non-null     object 
    dtypes: float64(1), int64(3), object(5)
    memory usage: 2.6+ KB

    describe默认统计数值型数据的各个统计量

    df.describe()

    在这里插入图片描述
    可以自行选择分位数

    df.describe(percentiles=[.05, .25, .75, .95])

    在这里插入图片描述
    对于非数值型也可以用describe函数

    df['Physics'].describe()
    count     35
    unique     7
    top       B+
    freq       9
    Name: Physics, dtype: object

    5.idxmax和nlargest

    idxmax函数返回最大值所在索引,在某些情况下特别适用,idxmin功能类似

    df['Math'].idxmax()

    5

    nlargest函数返回前几个大的元素值,nsmallest功能类似

    df['Math'].nlargest(3)
    5     97.0
    28    95.5
    11    87.7
    Name: Math, dtype: float64

    6.clip和replace

    clip和replace是两类替换函数

    clip是对超过或者低于某些值的数进行截断

    df['Math'].head()
    0    34.0
    1    32.5
    2    87.2
    3    80.4
    4    84.8
    Name: Math, dtype: float64
    df['Math'].clip(33,80).head()
    0    34.0
    1    33.0
    2    80.0
    3    80.0
    4    80.0
    Name: Math, dtype: float64
    df['Math'].mad()

    16.924244897959188

    replace是对某些值进行替换

    df['Address'].head()
    0    street_1
    1    street_2
    2    street_2
    3    street_2
    4    street_4
    Name: Address, dtype: object
    df['Address'].replace(['street_1','street_2'],['one','two']).head()
    0         one
    1         two
    2         two
    3         two
    4    street_4
    Name: Address, dtype: object

    通过字典,可以直接在表中修改

    df.replace({'Address':{'street_1':'one','street_2':'two'}}).head()

    在这里插入图片描述

    7.apply函数

    apply是一个自由度很高的函数,在第3章我们还要提到

    对于Series,它可以迭代每一列的值操作:

    df['Math'].apply(lambda x:str(x)+'!').head() #可以使用lambda表达式,也可以使用函数
    0    34.0!
    1    32.5!
    2    87.2!
    3    80.4!
    4    84.8!
    Name: Math, dtype: object

    对于DataFrame,它在默认axis=0下可以迭代每一个列操作:

    df.apply(lambda x:x.apply(lambda x:str(x)+'!')).head() #这是一个稍显复杂的例子,有利于理解apply的功能

    在这里插入图片描述
    对于Pandas中axis参数的理解如下:

    https://blog.csdn.net/qq_40317204/article/details/106993293

    四、排序

    1.索引排序

    df.set_index('Math').head() #set_index函数可以设置索引,将在下一章详细介绍

    在这里插入图片描述

    df.set_index('Math').sort_index().head() #可以设置ascending参数,默认为升序,True

    在这里插入图片描述

    2.值排序

    df.sort_values(by='Class').head()

    在这里插入图片描述
    多个值排序,即先对第一层排,在第一层相同的情况下对第二层排序

    df.sort_values(by=['Address','Height']).head()

    在这里插入图片描述

    五、问题与练习

    1. 问题

    使用assign添加列的时候,为什么会出现NaN?(提示:索引对齐)assign左右两边的索引不一样,请问结果的索引谁说了算?(内容定位:二-1-f)

    2. 练习

    【练习一】 现有一份关于美剧《权力的游戏》剧本的数据集,请解决以下问题:
    (a)在所有的数据中,一共出现了多少人物?
    (b)以单元格计数(即简单把一个单元格视作一句),谁说了最多的话?
    (c)以单词计数,谁说了最多的单词?(不是单句单词最多,是指每人说过单词的总数最多,为了简便,只以空格为单词分界点,不考虑其他情况)

    (a)

    pd.read_csv(r'C:\Users\chenyiqun\Desktop\joyful-pandas-master\joyful-pandas-master\data\Game_of_Thrones_Script.csv').head()

    在这里插入图片描述

    df['Name'].nunique()

    564

    (b)

    df['Name'].value_counts()

    可以得到每个人物的台词数量:

    tyrion lannister          1760
    jon snow                  1133
    daenerys targaryen        1048
    cersei lannister          1005
    jaime lannister            945
                              ... 
    night watch stable boy       1
    tell me something            1
    little sam                   1
    ser vance                    1
    allister                     1
    Name: Name, Length: 564, dtype: int64
    df['Name'].value_counts().index[0]

    台词最多的人物为:

    'tyrion lannister'

    (c)

    df_words = df.assign(Words=df['Sentence'].apply(lambda x:len(x.split()))).sort_values(by='Name')
    df_words.head()

    在这里插入图片描述

    L_count = []
    N_words = list(zip(df_words['Name'],df_words['Words']))
    for i in N_words:
        if i == N_words[0]:
            L_count.append(i[1])
            last = i[0]
        else:
            L_count.append(L_count[-1]+i[1] if i[0]==last else i[1])
            last = i[0]
    df_words['Count']=L_count
    df_words['Name'][df_words['Count'].idxmax()]

    得到说过单词总数最多的人:

    'tyrion lannister'

    **【练习二】**现有一份关于科比的投篮数据集,请解决如下问题:
    (a)哪种action_type和combined_shot_type的组合是最多的?
    (a)在所有被记录的game_id中,遭遇到最多的opponent是一个支?(由于一场比赛会有许多次投篮,但对阵的对手只有一个,本题相当于问科比和哪个队交锋次数最多)

    (a)

    df = pd.read_csv(r'C:\Users\chenyiqun\Desktop\joyful-pandas-master\joyful-pandas-master\data\Kobe_data.csv',index_col='shot_id')
    df.head()

    在这里插入图片描述

    pd.Series(list(zip(df['action_type'],df['combined_shot_type']))).value_counts()

    得到所有的组合及数量:

    (Jump Shot, Jump Shot)                             18880
    (Layup Shot, Layup)                                 2567
    (Driving Layup Shot, Layup)                         1978
    (Turnaround Jump Shot, Jump Shot)                   1057
    (Fadeaway Jump Shot, Jump Shot)                     1048
    (Running Jump Shot, Jump Shot)                       926
    (Pullup Jump shot, Jump Shot)                        476
    (Turnaround Fadeaway shot, Jump Shot)                439
    (Slam Dunk Shot, Dunk)                               411
    (Reverse Layup Shot, Layup)                          395
    (Jump Bank Shot, Jump Shot)                          333
    (Driving Dunk Shot, Dunk)                            310
    (Dunk Shot, Dunk)                                    262
    (Tip Shot, Tip Shot)                                 182
    (Alley Oop Dunk Shot, Dunk)                          122
    (Step Back Jump shot, Jump Shot)                     118
    (Floating Jump shot, Jump Shot)                      114
    (Driving Reverse Layup Shot, Layup)                   97
    (Hook Shot, Hook Shot)                                84
    (Driving Finger Roll Shot, Layup)                     82
    (Alley Oop Layup shot, Layup)                         80
    (Reverse Dunk Shot, Dunk)                             75
    (Running Layup Shot, Layup)                           72
    (Turnaround Bank shot, Bank Shot)                     71
    (Driving Finger Roll Layup Shot, Layup)               69
    (Driving Slam Dunk Shot, Dunk)                        48
    (Running Bank shot, Bank Shot)                        48
    (Running Hook Shot, Hook Shot)                        41
    (Finger Roll Layup Shot, Layup)                       33
    (Fadeaway Bank shot, Jump Shot)                       31
    (Finger Roll Shot, Layup)                             28
    (Driving Jump shot, Jump Shot)                        28
    (Jump Hook Shot, Jump Shot)                           24
    (Running Dunk Shot, Dunk)                             19
    (Reverse Slam Dunk Shot, Dunk)                        16
    (Putback Layup Shot, Layup)                           15
    (Follow Up Dunk Shot, Dunk)                           15
    (Driving Hook Shot, Hook Shot)                        14
    (Turnaround Hook Shot, Hook Shot)                     14
    (Pullup Bank shot, Bank Shot)                         12
    (Running Reverse Layup Shot, Layup)                   11
    (Cutting Layup Shot, Layup)                            6
    (Running Finger Roll Layup Shot, Layup)                6
    (Driving Bank shot, Bank Shot)                         5
    (Hook Bank Shot, Bank Shot)                            5
    (Putback Dunk Shot, Dunk)                              5
    (Driving Floating Jump Shot, Jump Shot)                5
    (Running Finger Roll Shot, Layup)                      4
    (Running Pull-Up Jump Shot, Jump Shot)                 4
    (Tip Layup Shot, Layup)                                2
    (Running Tip Shot, Tip Shot)                           2
    (Putback Slam Dunk Shot, Dunk)                         2
    (Turnaround Finger Roll Shot, Layup)                   2
    (Cutting Finger Roll Layup Shot, Layup)                1
    (Driving Floating Bank Jump Shot, Jump Shot)           1
    (Turnaround Fadeaway Bank Jump Shot, Jump Shot)        1
    (Running Slam Dunk Shot, Dunk)                         1
    dtype: int64
    pd.Series(list(zip(df['action_type'],df['combined_shot_type']))).value_counts().index[0]

    (‘Jump Shot’, ‘Jump Shot’)

    (b)

    pd.Series(list(list(zip(*(pd.Series(list(zip(df['game_id'],df['opponent'])))
                              .unique()).tolist()))[1])).value_counts()

    得到与所有对手交战次数:

    SAS    91
    PHX    87
    UTA    84
    DEN    83
    POR    81
    SAC    80
    HOU    77
    MIN    76
    LAC    68
    GSW    67
    DAL    64
    MEM    49
    BOS    44
    SEA    44
    IND    39
    DET    38
    PHI    37
    ORL    34
    NYK    34
    CLE    34
    OKC    33
    TOR    33
    WAS    32
    MIA    32
    MIL    31
    CHA    31
    NOH    31
    CHI    31
    ATL    29
    NJN    28
    VAN    18
    NOP    16
    BKN     3
    dtype: int64
    ​
    pd.Series(list(list(zip(*(pd.Series(list(zip(df['game_id'],df['opponent'])))
                              .unique()).tolist()))[1])).value_counts().index[0]

    ‘SAS’

    部分python函数参考文章:
    Python zip() 函数解析
    Python split()函数解析

    Pandas基础:
    https://github.com/datawhalechina/joyful-pandas/blob/master/%E7%AC%AC1%E7%AB%A0%20Pandas%E5%9F%BA%E7%A1%80.ipynb

    练习题参考答案:
    https://github.com/datawhalechina/joyful-pandas/blob/master/%E5%8F%82%E8%80%83%E7%AD%94%E6%A1%88.ipynb

    所用数据集下载连接:
    https://download.csdn.net/download/qq_40317204/12568932

    展开全文
  • gulp.task('scripts', gulp.series('clean', function() {...})); gulp.task('clean', function() {...}); gulp.task('default', gulp.parallel('scripts', 'styles')); 这样好多了,然而还有需要解决的问题。...
    Gulp 4 在任务执行体系上有一个很重要的改动,下面我们一起来看一下这个新的特性和如何从Gulp 3迁移到新版本

    Gulp 3中的任务执行链

    在了解新特性之前,让我们先看看之前是怎么做的。通常Gulp允许给task定义依赖(dependency),这保证了task执行之前它依赖的task已经获得执行。看下面代码:

    // 默认任务,执行scripts和styles这两个任务
    gulp.task('default', ['scripts', 'styles'], function() {...});
    
    // scripts 和 styles 任务都调用了 clean 任务
    gulp.task('styles', ['clean'], function() {...});
    gulp.task('scripts', ['clean'], function() {...});
    
    // Clean 任务清空了build目录
    gulp.task('clean', function() {...});

    这是很典型的Gulpfile代码,你目的是执行scripts任务和styles任务,在此之前把build输出的目录清空以保证每次都都可以获得最新的build结果。这种语法很优雅,跟其他构建工具也类似。

    当Gulp开始工作,它会创建一个任务依赖树,见下图。
    folie1.jpg
    它发现clean任务是另外两个task的依赖,从而确保clean只执行一次。

    有一点需要注意:所有task都以最大并发量执行。它(default task)的执行顺序见下图:
    folie2.jpg
    首先执行clean任务,然后并行执行scriptsstyles任务。

    这种方式有一些问题:

    一旦你定义了上面的依赖链,依赖链的执行顺序就被确定了。

    例如,给其中一个styles任务添加了监听(watcher)当css文件改变时重新执行styles任务,这时候就会出问题。想象一下,你每次改动了css文件就会触发styles任务,gulp会首先执行clean然后执行styles。如此一来,你构建打包的文件会因为clean任务执行被删除。

    目前没有好的办法来顺序执行前面定义的各个task。“执行某一任务前先执行其依赖的任务” -- 这种执行方式导致了前面的问题。

    有一个Gulp插件用来解决这个问题:run-sequence。它现在已经是Gulp 4的一部分了。

    Gulp 4中的任务执行函数

    Gulp 4抛弃了依赖参数(dependency parameter),用执行函数来代替:

    • gulp.series 用于串行(顺序)执行
    • gulp.parallel 用于并行执行

    上面的两个函数接受两个参数:

    • 要执行的任务的名字
    • 需要执行的函数

    如果你想并行执行scriptsstyles,你可以这么写:

    gulp.task('default', gulp.parallel('scripts', 'styles'));

    更棒的是,gulp.parallelgulp.series是函数,可以接受其它函数做参数,所以你可以随意嵌套使用它们,从而创建复杂的执行顺序。
    folie4.jpg
    上图的执行顺序是:A, 然后 B, 然后 C 和 D 并行执行, 最后 E。

    从Gulp 3迁移到Gulp 4

    尽量让任务以最大并发量执行可以提高执行效率,我们可以考虑把依赖的任务数组替换为gulp.parallel函数,最上面的任务代码可以改为像下面这样:

    gulp.task('styles', gulp.parallel('clean', function() {...}));
    gulp.task('scripts', gulp.parallel('clean', function() {...}));
    
    gulp.task('clean', function() {...});
    
    gulp.task('default', gulp.parallel('scripts', 'styles'));

    这个方法的第一个问题是,执行scripts任务和styles任务时,clean任务会先执行。在并发的情况下,这意味着,执行styles时,可能把scripts任务的输出删掉。我们不想这样,让我们把上面的代码修改一下,使用gulp.series来创建串行执行的任务。

    gulp.task('styles', gulp.series('clean', function() {...}));
    gulp.task('scripts', gulp.series('clean', function() {...}));
    
    gulp.task('clean', function() {...});
    
    gulp.task('default', gulp.parallel('scripts', 'styles'));

    这样好多了,然而还有需要解决的问题。首先,依赖仍然写死在了代码里,我们执行scripts或者styles时,clean任务会先被执行。其次,Gulp 4 不会进行依赖检查,我们的执行树(执行default task)看起来像这样:
    folie3.jpg
    clean任务被执行两次,这是致命的,因为有可能上一个任务的执行结果被下一个任务的执行删除。

    为了做一次完美的健壮的迁移,实现最初的执行顺序,并且避免写死代码,我们可以这样做:

    先来看一下最初的执行顺序:
    folie2.jpg
    default task的执行顺序是:先clean,然后stylesscripts并行执行。

    每一个可以并发进行的步骤可以组合在gulp.parallel函数中,其余的任务按顺序放在gulp.series函数中,像这样:
    folie5.jpg
    对应的代码是:

    // 去掉了clean任务依赖
    gulp.task('styles', function() {...});
    gulp.task('scripts', function() {...});
    
    gulp.task('clean', function() {...});
    
    // Per default, start scripts and styles
    gulp.task('default',
      gulp.series('clean', gulp.parallel('scripts', 'styles'),
      function() {...}));

    这样一来,default task的任务执行顺序就跟最初一样了。

    展开全文
  • Pandas知识点-Series数据结构介绍

    千次阅读 2021-02-23 23:25:25
    Pandas知识点-Series数据结构介绍

    Pandas知识点-Series数据结构介绍

    本文用到的数据来源于网易财经,具体下载方式可以参考上一篇文章:https://blog.csdn.net/weixin_43790276/article/details/113923039

    获取数据的链接为:http://quotes.money.163.com/trade/lsjysj_600519.html#01b07

    下载下来的数据是一个.csv格式的文本,数据无需处理,可以直接使用,也可以直接用办公软件Excel打开。为了方便后面的代码调用,下载完成后将这个.csv文件拷贝到代码的同级目录下。

    一、Series数据结构介绍

    1. 获取csv文件中的一列数据

    # coding=utf-8
    import pandas as pd
    
    
    df = pd.read_csv('600519.csv', encoding='gbk')
    data = df['收盘价']
    print(data)
    print(type(data))

    数据文件是600519.csv,将此文件放到代码同级目录下,从文件中读取出数据,然后取其中的一列,数据如下图。

    使用type()函数打印数据的类型,数据类型为Series。从csv文件中读取出来的数据是DataFrame数据,取其中的一列,数据是一个Series数据。

    <class 'pandas.core.series.Series'>

    2. Series数据结构的构成

    Series数据结构是一种类似于一维数组的数据对象,由一组数据(numpy中的数据类型)和行索引构成。因为数据是一维的(只有一列),所以Series只有行索引,没有列索引。

    Series由行索引和数据组成。如果数据行数很多,会自动将数据折叠,中间的显示为“...”。

    与DataFrame相比,DataFrame有行索引和列索引,而Series只有行索引。取出DataFrame中的任意一列(或任意一行,行用iloc获取,如df.iloc[0]),其数据类型都是Series,说明DataFrame是由Series构成的。

    二、创建Series和DataFrame

    1. 创建Series

    s1 = pd.Series({'a': 10, 'b': 20, 'c': 30, 'd': 40})
    print(s1)
    print(type(s1))
    a    10
    b    20
    c    30
    d    40
    dtype: int64
    <class 'pandas.core.series.Series'>
    import numpy as np
    
    
    s2 = pd.Series(np.random.rand(5), index=[alpha for alpha in 'abcde'])
    print(s2)
    print(type(s2))
    a    0.269565
    b    0.520705
    c    0.419913
    d    0.182670
    e    0.031500
    dtype: float64
    <class 'pandas.core.series.Series'>

    实例化一个Pandas中的Series类对象,即可创建出一个Series数据。传入Series中的数据时,可以传入一个字典,每个键值对的key是行索引,value是对应的数据,如上面的s1。也可以传入一个一维数组,然后用index参数设置行索引,不设置行索引时默认为数值型索引,即从0开始的整数,如上面的s2。

    Series中保存的数据data可以是整数、浮点数、字符串、Python对象等类型的数据。数据data和索引index都是array-like的数据,且都是一维的。此外,还可以按需指定保存的数据类型dtype,Series的命名name,是否复制已有数据copy(bool)。

    关于索引还需要注意,Pandas中的索引值是可以重复的,当然最好不要设置重复,避免在进行一些索引不可重复的操作时出现错误。

    2. 创建DataFrame

    df1 = pd.DataFrame({
        'one': s2,
        'two': pd.Series(np.random.rand(4), index=[alpha for alpha in 'abcd'])
    })
    print(df1)
    print(type(df1))
            one       two
    a  0.988763  0.592909
    b  0.093969  0.674316
    c  0.593211  0.253496
    d  0.374765  0.565424
    e  0.850890       NaN
    <class 'pandas.core.frame.DataFrame'>
    df2 = pd.DataFrame(np.random.randn(3, 3), index=pd.date_range('1/1/2021', periods=3), columns=['one', 'two', 'three'])
    print(df2)
    print(type(df2))
                     one       two     three
    2021-01-01  0.736518 -0.012771  0.459488
    2021-01-02  0.665910  0.700380 -1.124228
    2021-01-03 -0.418457 -1.907136 -0.207422
    <class 'pandas.core.frame.DataFrame'>

    实例化一个Pandas中的DataFrame类对象,即可创建出一个DataFrame数据。传入DataFrame中的数据时,可以传入一个字典,每个键值对是一列数据,key是列索引,value是列中保存的数据,每个value都是一个Series数据,如上面的df1,这也再次说明DataFrame是由Series组成的。也可以传入一个二维数组,然后用index参数和columns参数设置行索引和列索引,index和columns都是array-like的数据,如上面的df2。

    同理,也可以根据需要指定保存的数据类型dtype,是否复制已有数据copy(bool)。

    DataFrame由多个Series组成,当多个Series的长度不一样时,DataFrame中会有缺失值,Pandas中用NaN(Not a Number)表示缺失值,如上面的df1中就有一个缺失值。

    三、Series的基本属性

    1. Series的行索引index

    df = pd.read_csv('600519.csv', encoding='gbk')
    s = df['涨跌幅']
    print(s.index)
    RangeIndex(start=0, stop=4726, step=1)

    2. Series中的数据values和array

    df = pd.read_csv('600519.csv', encoding='gbk')
    s = df['涨跌幅']
    print(s.values)
    print(type(s.values))
    print(s.array)
    ['-0.4452' '-4.9981' '5.8854' ... '-1.3022' '3.685' '13.2526']
    <class 'numpy.ndarray'>
    <PandasArray>
    ['-0.4452', '-4.9981',  '5.8854',  '3.6993',  '2.4125', '-0.3382',  '5.9792',
      '2.0937',  '1.6915', '-0.3242',
     ...
     '-2.7793', '-1.9765', '-0.0534',  '1.2706', '-0.2965', '-0.2426',  '1.9791',
     '-1.3022',   '3.685', '13.2526']
    Length: 4726, dtype: object

    values是一个ndarray对象,即一维数组,是numpy中的基本数据类型。array是一个PandasArray,是Pandas中的array数据类型。后面会专门写文章说明他们的区别。

    3. Series的形状shape和转置.T

    df = pd.read_csv('600519.csv', encoding='gbk')
    s = df['涨跌幅']
    print("形状: ", s.shape)
    s2 = s.T
    print("转置后形状: ", s2.shape)
    形状:  (4726,)
    转置后形状:  (4726,)

    需要注意的是,Series转置之后的形状与转置之前是一样的,这是因为Series本身是一维的。

    四、Series的索引设置

    1. 设置Series的行索引

    df = pd.read_csv('600519.csv', encoding='gbk')
    s = df['涨跌幅'].head(3)
    print(s)
    s.index = [alpha for alpha in 'abc']
    print(s)
    0    -0.4452
    1    -4.9981
    2     5.8854
    Name: 涨跌幅, dtype: object
    a    -0.4452
    b    -4.9981
    c     5.8854
    Name: 涨跌幅, dtype: object

    Series没有set_index()方法,如果需要修改Series的索引,可以直接对index属性赋值。

    2. 重设索引

    s2 = s.reset_index()
    print(s2)
    print(type(s2))
    s3 = s.reset_index(drop=True)
    print(s3)
    print(type(s3))
      index      涨跌幅
    0     a  -0.4452
    1     b  -4.9981
    2     c   5.8854
    <class 'pandas.core.frame.DataFrame'>
    0    -0.4452
    1    -4.9981
    2     5.8854
    Name: 涨跌幅, dtype: object
    <class 'pandas.core.series.Series'>

    修改Series的行索引后,如果要将行索引还原成初始状态,可以使用reset_index()方法还原。在调用reset_index()时,要将drop参数设置为True,否则Pandas不会删除前面设置的行索引,而是将设置的行索引移动到数据中,使数据变成两列,这样数据就变成了DataFrame,而不再是Series,如上面的s2。

    以上就是Pandas中Series数据结构的基本介绍。Series与DataFrame的很多方法是一样的,如使用head()和tail()来显示前n行或后n行。后面会陆续介绍更多相关的属性和方法。

    如果不想自己下载数据,可以扫码关注公众号“Python碎片”,然后在后台回复“pandas02”关键字获取本文代码和数据。

     

     

    展开全文
  • Pandas 系列是带有轴标签的一维ndarray。...Pandas Series.to_csv()函数将给定的系列对象写入以逗号分隔的值(csv)文件/格式。用法: Series.to_csv(*args, **kwargs)参数:path_or_buf:文件路径或对象,如果提供No...
  • 今天我们主要解决以下实际问题:一份黑名单数据存储在excel中,由于数据量庞大,现需要通过pandas处理后再存入到excel中 pandas 是基于NumPy 的一种工具,该工具是为了解决数据分析任务而...pandas.core.series.Series
  • 我上上篇博客说过:Pandas数据结构为...而构成DataFrame结构的每一列或每一行是Series结构,令人吃惊的是Series里面的结构是ndarray (numpy中的) 结构 Pandas之Series常用操作方法1 import pandas as pd fa...
  • # 打开csv文件,用于读取文件头3行的零散字段 csv1 = csv.reader(f_in2) i = 0 rows = [] # 循环读取前三行 for row in csv1: if i print(row) rows.append(row) else: break i += 1 # 第四行加入表头...
  • ASTM Gloves Series - 包含全部4份最新标准文件.zip
  • 永宏 FBs Series OS V4.48升级文件rar,永宏 FBs Series OS V4.48升级文件
  • ASTM Gloves Series - 包含全部4份最新标准文件.7z
  • ASTM Masks Series - 包含全部7份最新英文版标准文件.zip
  • ASTM Hand Sanitizers Series - 包含全部7份最新标准文件.7z
  • IEC 61512 Series Batch control - 包含全部4份英文版标准文件 .zip
  • ASTM Masks Series - 包含全部7份最新英文版标准文件.7z
  • IEC 60300 Series Dependability management - 包含全部12份最新英文版标准文件.zip
  • IEC 62433 Series EMC IC modelling - 包含全部6份最新英文标准文件.zip
  • ASTM Medical Gowns Series - 包含全部10份最新英文电子版标准文件.zip
  • IEC 62258 Series Semiconductor die products - 包含8份最新英文版标准文件 .zip
  • ANSI ISA-88 Series Batch Control -包含6份最新英文版标准文件 .zip
  • IEC 60300 Series Dependability management - 包含全部12份最新英文版标准文件.7z
  • IEC 60747 Series - Semiconductor devices - 包含全部38份最新英文标准文件.7z
  • ASTM Medical Gowns Series - 包含全部10份最新英文电子版标准文件.7z
  • IEC 61512 Series Batch control - 包含全部4份英文版标准文件_.7z
  • IEC 60269 Series Low-voltage fuses - 包含全部6份最新完整英文标准文件.zip
  • IEC 60730 Series Automatic electrical controls - 包含全部15份最新英文版标准文件.7z
  • IEC 62258 Series Semiconductor die products - 包含8份最新英文版标准文件_.7z
  • pandas时间序列分析和处理Timeseries

    万次阅读 2017-10-24 22:03:50
    pandas 最基本的时间序列类型就是以时间戳(TimeStamp)为 index 元素的 Series 类型。 其它时间序列处理相关的包 [P4J 0.6: Periodic light curve analysis tools based on Information Theory] [p4j github] ...
  • IEEE Std 1857 Series Audio and Video Coding - 包含全部11份最新英文版标准文件.z
  • IEC 60269 Series Low-voltage fuses - 包含全部6份最新完整英文标准文件.7z

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 71,381
精华内容 28,552
关键字:

.series文件怎么打开