精华内容
下载资源
问答
  • 还记得数据结构这个经典的分类图吧: pic1 今天主要关注一下线性表。 什么是线性表 线性表的划分是从数据的逻辑结构上进行的。线性指的是在数据的逻辑结构上是线性的。即在数据元素的非空有限集中 (1) 存在唯一的...

    还记得数据结构这个经典的分类图吧:


    今天主要关注一下线性表。

    什么是线性表

    线性表的划分是从数据的逻辑结构上进行的。线性指的是在数据的逻辑结构上是线性的。即在数据元素的非空有限集中

    (1) 存在唯一的一个被称作“第一个”的数据元素,(2) 存在唯一的一个被称作“最后一个”的数据元素,(3) 除第一个外,集合中的每个数据元素均只有一个前继元素,(4)除最后一个外,集合中的每个数据元素均只有一个后继元素。

    那么对于线性表,从存储结构上分,可以有顺序存储结构和链式存储结构。顺序存储结构包括顺序表、顺序队列和顺序栈;链式存储结构包括链表、链队列和链栈。所有这些分类数据结构的实现,后续的博文将陆续进行介绍。

    顺序表(数组,向量)

    顺序表的结构:

    顺序表的结构如下图所示:

    从结构上可以看出,顺序表实际上就是一个动态数组,在C++的标准模板库(STL)中类似的对应着vector模板类。所以理解顺序表对于使用vector进行高级应用的开发有着极为重要的作用。
    存储结构定义如下:

    typedef struct

    {

      DataType *m_pData;

        int m_nMax,m_nSize;

    }SeqList;

    typedef int DataType;

    顺序表的基本操作及其实现

    有了数据的结构定义,就必须有对应的方法实现从来进行相关的操作,基本的运算函数如下:

    Void SetList(SeqList *L,int n);// 构造函数,建立数组长是n的空表

    Void FreeList(SeqList *L); // 析构函数,释放数组空间


    int ListSize(SeqList *L) // 求表的长度

    int IsEmpty(SeqList *L); // 判断数组是否空,1:,0

    int IfFull(SeqList *L); // 判断数组是否满


    DataType GetData(int pos); // 获取数组某元素

    int Locate(SeqList *L,DataTypeitem); // 判断元素位置

    Void SetData(SeqList *L,DataTypeitem,int pos); //元素位置赋值


    Void Insert(SeqList *L,int pos,DataType item); //在某位置插入元素

    void InsertRear(SeqList *L,DataType&item); // 在末尾插入元素


    void Delete(SeqList *L,int pos);//删除某位置元素

    void ClearList(SeqList *L); // 清表,表中的元素个数是0;

    Void DeleteBetween(SeqList *L,intstart, int end)


    对应某些函数方法的实现如下:

    voidSetList(SeqList *L,int n)

    {

    L->m_pData=newDataType[n];

    if(L->m_pData==NULL)

    {

      cout<<”overflow”<<endl;exit(1);

    }

    L->m_nMax=n;

    L->m_nSize=0;

    }


    Void FreeList(SeqList *L)

    {

    delete [ ]L->m_pData;

    L->m_nSize=0;

    L->m_nMax=0;

    }


    void Insert(SeqList *L,DataType item,int pos)

    {

    //在顺序表中在pos处插入item

      i=1;

      if(L->m_nSize==L->m_nMax){printf(“SeqListis FULL\n”);exit(1)}

      if(pos<=0||pos>L->m_nSize)

      {

      printf(“Pos is out of range”);exit(1);

      }

      for(i=L->m_nSize-1;i>=pos;i--)

      L->m_nData[i+1]=L->m_nData[i];

      L->m_nData[pos]=item;

      L->m_nSize++;

    }


    顺序表的应用:动态字符串

    C语言字符串

    char str[13]=“Hello, world!”;

     char *pStr = str;

    字符串函数

     gets(char *str);

     puts(char *str);

     strcpy(char *str1, char *str2); //字符串拷贝

     strcat(char *str1, char *str2); //字符串连接,str1必须足够大

     strcmp(char *str1, char *str2); //字符串比较

     strlen(char *str); //字符串求长,不包含’\0’的长度


    动态字符串:

    Typedef struct

     {

       int m_nSize;//不含结束符的长度

       char*m_pStr;

     }String;

    基本运算: Concat(), SubString(), Insert(),Delete(),Clear()…

    顺序队列

    一种特殊的线性表:只能在表的一端插入,另一端删除,是先进先出的线性表;头指针(删除位置)和尾指针(插入位置)
    First come, first serve(FIFO)
    优点:循环结构、删除时不需移动元素

    顺序队列的结构:

    顺序队列的结构如下图所示:

    存储结构定义如下:
    typedef struct

    {

      DataType *m_pData;

      int m_nMax;

      int m_nFront,m_nRear, m_nSize;

    }Queue;


    顺序队列的基本操作及其实现

    Void SetQueue(Queue *Q,int n); // 构造函数
    void FreeQueue(Queun *Q); // 析构函数
    int QSize(Queue *Q); // 队列长度
    int QEmpty(Queue *Q); // 判断队列是否空
    int QFull(Queue *Q); // 判断队列是否满
    DataType QGetData(Queue *Q); // 获取数据
    int QInsert(Queue *Q,DataType item); // 进队列
    DataType QDelete(Queue *Q); // 出队列
    void QClear(); // 清空
    队列删除操作:

    DataTypeQDelete(Queue *Q)

    {

      DataType item;

      if(Q->m_nSize==0)

      {

    printf(“队列空\n”);

        Exit(1);

      }

      item=Q->m_pData[Q->m_nFront];

      Q->m_nFront=(Q->m_nFront+1)%Q->m_nMax;

      Q->m_nSize--;

    }

    顺序栈

    一种特殊的线性表:只能在表的一端插入和删除,是后进先出的线性表;进栈和出栈

    顺序栈的结构:


    结构如下图所示:

    Typedef struct

    {

      DataType *m_pData;

      int m_nMax;

      int m_nTop;//插入数据的位置,空为-1,入栈+1,出栈-1

    }Stack;

    顺序栈的基本操作

    顺序栈的基本操作如下:
    CStack()/CStack(int n); // 构造函数
    ~CStack(); // 析构函数
    int SetSize(int n); // 设置栈的大小
    int Free(); // 释放空间
    int Size(); // 栈的大小
    int Empty(); // 判断是否空
    int Full(); // 判断是否满
    int Push(DataType item); // 压栈
    DataType Pop(); // 出栈
    DataType GetPeek(); // 取栈顶元素
    int Clear(); // 清空栈
    顺序栈的基本运算函数声明如下:
    Void SetStack(Stack *S,int n);
    Void FreeStack(Stack *S);
    Int StackEmpty(Stack *S);
    Int StackFull(Stack *S);
    Void Push(Stack *S,DataType item);
    DataType Pop(Stack *S);
    Void ClearStack(Stack *S);
    DataType Peek(Stack *S);


    展开全文
  • Pandas 分类数据

    2020-04-04 13:34:16
    除了固定长度,分类数据可能有顺序,但不能执行数字操作。 分类是Pandas数据类型。 分类数据类型在以下情况下非常有用 - 一个字符串变量,只包含几个不同的值。将这样的字符串变量转换为分类变量将会节省一些内存...

    通常实时的数据包括重复的文本列。例如:性别,国家和代码等特征总是重复的。这些是分类数据的例子。

    分类变量只能采用有限的数量,而且通常是固定的数量。除了固定长度,分类数据可能有顺序,但不能执行数字操作。 分类是Pandas数据类型。

    分类数据类型在以下情况下非常有用 -

    • 一个字符串变量,只包含几个不同的值。将这样的字符串变量转换为分类变量将会节省一些内存。
    • 变量的词汇顺序与逻辑顺序("one""two""three")不同。 通过转换为分类并指定类别上的顺序,排序和最小/最大将使用逻辑顺序,而不是词法顺序。
    • 作为其他python库的一个信号,这个列应该被当作一个分类变量(例如,使用合适的统计方法或plot类型)。

    对象创建

    分类对象可以通过多种方式创建。下面介绍了不同的方法 -

    类别/分类

    通过在pandas对象创建中将dtype指定为“category”

    import pandas as pd
    s = pd.Series(["a","b","c","a"], dtype="category")
    print (s)
    

    执行上面示例代码,得到以下结果 -

    0    a
    1    b
    2    c
    3    a
    dtype: category
    Categories (3, object): [a, b, c]
    

    传递给系列对象的元素数量是四个,但类别只有三个。观察相同的输出类别。

    pd.Categorical

    使用标准Pandas分类构造函数,我们可以创建一个类别对象。语法如下 -

    pandas.Categorical(values, categories, ordered)
    

    举个例子 -

    import pandas as pd
    cat = pd.Categorical(['a', 'b', 'c', 'a', 'b', 'c'])
    print (cat)
    

    执行上面示例代码,得到以下结果 -

    [a, b, c, a, b, c]
    Categories (3, object): [a, b, c]
    

    再举一个例子 -

    import pandas as pd
    cat = cat=pd.Categorical(['a','b','c','a','b','c','d'], ['c', 'b', 'a'])
    print (cat)
    

    执行上面示例代码,得到以下结果 -

    [a, b, c, a, b, c, NaN]
    Categories (3, object): [c, b, a]
    

    这里,第二个参数表示类别。因此,在类别中不存在的任何值将被视为NaN

    现在,看看下面的例子 -

    import pandas as pd
    cat = cat=pd.Categorical(['a','b','c','a','b','c','d'], ['c', 'b', 'a'],ordered=True)
    print (cat)
    

    执行上面示例代码,得到以结果 -

    [a, b, c, a, b, c, NaN]
    Categories (3, object): [c < b < a]
    

    从逻辑上讲,排序(ordered)意味着,a大于bb大于c

    描述

    使用分类数据上的.describe()命令,可以得到与类型字符串的Series或DataFrame类似的输出。

    import pandas as pd
    import numpy as np
    
    cat = pd.Categorical(["a", "c", "c", np.nan], categories=["b", "a", "c"])
    df = pd.DataFrame({"cat":cat, "s":["a", "c", "c", np.nan]})
    print (df.describe())
    print ("=============================")
    print (df["cat"].describe())
    

    执行上面示例代码,得到以下结果 -

           cat  s
    count    3  3
    unique   2  2
    top      c  c
    freq     2  2
    =============================
    count     3
    unique    2
    top       c
    freq      2
    Name: cat, dtype: object
    

    获取类别的属性

    obj.cat.categories命令用于获取对象的类别。

    import pandas as pd
    import numpy as np
    
    s = pd.Categorical(["a", "c", "c", np.nan], categories=["b", "a", "c"])
    print (s.categories)
    

    执行上面示例代码,得到以下结果 -

    Index(['b', 'a', 'c'], dtype='object')
    

    obj.ordered命令用于获取对象的顺序。

    import pandas as pd
    import numpy as np
    
    cat = pd.Categorical(["a", "c", "c", np.nan], categories=["b", "a", "c"])
    print (cat.ordered)
    

    执行上面示例代码,得到以下结果 -

    False
    

    该函数返回结果为:False,因为这里没有指定任何顺序。

    重命名类别

    重命名类别是通过将新值分配给series.cat.categories属性来完成的。参考以下示例代码 -

    import pandas as pd
    
    s = pd.Series(["a","b","c","a"], dtype="category")
    s.cat.categories = ["Group %s" % g for g in s.cat.categories]
    
    print (s.cat.categories)
    

    执行上面示例代码,得到以下结果 -

    Index(['Group a', 'Group b', 'Group c'], dtype='object')
    

    初始类别[a,b,c]由对象的s.cat.categories属性更新。

    附加新类别
    使用Categorical.add.categories()方法,可以追加新的类别。

    import pandas as pd
    
    s = pd.Series(["a","b","c","a"], dtype="category")
    s = s.cat.add_categories([4])
    print (s.cat.categories)
    

    执行上面示例代码,得到以下结果 -

    Index(['a', 'b', 'c', 4], dtype='object')
    

    删除类别
    使用Categorical.remove_categories()方法,可以删除不需要的类别。

    import pandas as pd
    
    s = pd.Series(["a","b","c","a"], dtype="category")
    print ("Original object:")
    print (s)
    print("=====================================")
    print ("After removal:")
    print (s.cat.remove_categories("a"))
    

    执行上面示例代码,得到以下结果 -

    Original object:
    0    a
    1    b
    2    c
    3    a
    dtype: category
    Categories (3, object): [a, b, c]
    =====================================
    After removal:
    0    NaN
    1      b
    2      c
    3    NaN
    dtype: category
    Categories (2, object): [b, c]
    

    分类数据的比较

    在三种情况下可以将分类数据与其他对象进行比较 -

    • 将等号(==!=)与类别数据相同长度的类似列表的对象(列表,系列,数组…)进行比较。
    • ordered==True和类别是相同时,所有比较(==!=>>=<,和<=)分类数据到另一个分类系列。
    • 将分类数据与标量进行比较。

    看看下面的例子 -

    import pandas as pd
    
    cat = pd.Series([1,2,3]).astype("category", categories=[1,2,3], ordered=True)
    cat1 = pd.Series([2,2,2]).astype("category", categories=[1,2,3], ordered=True)
    
    print (cat>cat1)
    

    执行上面示例代码,得到以下结果 -

    0    False
    1    False
    2     True
    dtype: bool

     

    展开全文
  • Pandas分类数据

    2018-09-13 16:10:00
    除了固定长度,分类数据可能有顺序,但不能执行数字操作。 分类是Pandas数据类型。 分类数据类型在以下情况下非常有用 - 一个字符串变量,只包含几个不同的值。将这样的字符串变量转换为分类变量将会节省一些...

    通常实时的数据包括重复的文本列。例如:性别,国家和代码等特征总是重复的。这些是分类数据的例子。

    分类变量只能采用有限的数量,而且通常是固定的数量。除了固定长度,分类数据可能有顺序,但不能执行数字操作。 分类是Pandas数据类型。

    分类数据类型在以下情况下非常有用 -

    • 一个字符串变量,只包含几个不同的值。将这样的字符串变量转换为分类变量将会节省一些内存。
    • 变量的词汇顺序与逻辑顺序("one""two""three")不同。 通过转换为分类并指定类别上的顺序,排序和最小/最大将使用逻辑顺序,而不是词法顺序。
    • 作为其他python库的一个信号,这个列应该被当作一个分类变量(例如,使用合适的统计方法或plot类型)。

    对象创建

    分类对象可以通过多种方式创建。下面介绍了不同的方法 -

    类别/分类

    通过在pandas对象创建中将dtype指定为“category”

    import pandas as pd
    s = pd.Series(["a","b","c","a"], dtype="category")
    print (s)
    
    Python

    执行上面示例代码,得到以下结果 -

    0    a
    1    b
    2    c
    3    a
    dtype: category
    Categories (3, object): [a, b, c]
    
    Shell

    传递给系列对象的元素数量是四个,但类别只有三个。观察相同的输出类别。

    pd.Categorical

    使用标准Pandas分类构造函数,我们可以创建一个类别对象。语法如下 -

    pandas.Categorical(values, categories, ordered)
    
    Python

    举个例子 -

    import pandas as pd
    cat = pd.Categorical(['a', 'b', 'c', 'a', 'b', 'c'])
    print (cat)
    
    Python

    执行上面示例代码,得到以下结果 -

    [a, b, c, a, b, c]
    Categories (3, object): [a, b, c]
    
    Shell

    再举一个例子 -

    import pandas as pd
    cat = cat=pd.Categorical(['a','b','c','a','b','c','d'], ['c', 'b', 'a'])
    print (cat)
    
    Python

    执行上面示例代码,得到以下结果 -

    [a, b, c, a, b, c, NaN]
    Categories (3, object): [c, b, a]
    
    Shell

    这里,第二个参数表示类别。因此,在类别中不存在的任何值将被视为NaN

    现在,看看下面的例子 -

    import pandas as pd
    cat = cat=pd.Categorical(['a','b','c','a','b','c','d'], ['c', 'b', 'a'],ordered=True)
    print (cat)
    
    Python

    执行上面示例代码,得到以结果 -

    [a, b, c, a, b, c, NaN]
    Categories (3, object): [c < b < a]
    
    Shell

    从逻辑上讲,排序(ordered)意味着,a大于bb大于c

    描述

    使用分类数据上的.describe()命令,可以得到与类型字符串的Series或DataFrame类似的输出。

    import pandas as pd
    import numpy as np
    
    cat = pd.Categorical(["a", "c", "c", np.nan], categories=["b", "a", "c"])
    df = pd.DataFrame({"cat":cat, "s":["a", "c", "c", np.nan]})
    print (df.describe())
    print ("=============================")
    print (df["cat"].describe())
    
    Python

    执行上面示例代码,得到以下结果 -

           cat  s
    count    3  3
    unique   2  2
    top      c  c
    freq     2  2
    =============================
    count     3
    unique    2
    top       c
    freq      2
    Name: cat, dtype: object
    
    Shell

    获取类别的属性

    obj.cat.categories命令用于获取对象的类别。

    import pandas as pd
    import numpy as np
    
    s = pd.Categorical(["a", "c", "c", np.nan], categories=["b", "a", "c"])
    print (s.categories)
    
    Python

    执行上面示例代码,得到以下结果 -

    Index(['b', 'a', 'c'], dtype='object')
    
    Shell

    obj.ordered命令用于获取对象的顺序。

    import pandas as pd
    import numpy as np
    
    cat = pd.Categorical(["a", "c", "c", np.nan], categories=["b", "a", "c"])
    print (cat.ordered)
    
    Python

    执行上面示例代码,得到以下结果 -

    False
    
    Shell

    该函数返回结果为:False,因为这里没有指定任何顺序。

    重命名类别

    重命名类别是通过将新值分配给series.cat.categories属性来完成的。参考以下示例代码 -

    import pandas as pd
    
    s = pd.Series(["a","b","c","a"], dtype="category")
    s.cat.categories = ["Group %s" % g for g in s.cat.categories]
    
    print (s.cat.categories)
    
    Python

    执行上面示例代码,得到以下结果 -

    Index(['Group a', 'Group b', 'Group c'], dtype='object')
    
    Shell

    初始类别[a,b,c]由对象的s.cat.categories属性更新。

    附加新类别
    使用Categorical.add.categories()方法,可以追加新的类别。

    import pandas as pd
    
    s = pd.Series(["a","b","c","a"], dtype="category")
    s = s.cat.add_categories([4])
    print (s.cat.categories)
    
    Python

    执行上面示例代码,得到以下结果 -

    Index(['a', 'b', 'c', 4], dtype='object')
    
    Shell

    删除类别
    使用Categorical.remove_categories()方法,可以删除不需要的类别。

    import pandas as pd
    
    s = pd.Series(["a","b","c","a"], dtype="category")
    print ("Original object:")
    print (s)
    print("=====================================")
    print ("After removal:")
    print (s.cat.remove_categories("a"))
    
    Python

    执行上面示例代码,得到以下结果 -

    Original object:
    0    a
    1    b
    2    c
    3    a
    dtype: category
    Categories (3, object): [a, b, c]
    =====================================
    After removal:
    0    NaN
    1      b
    2      c
    3    NaN
    dtype: category
    Categories (2, object): [b, c]
    
    Shell

    分类数据的比较

    在三种情况下可以将分类数据与其他对象进行比较 -

    • 将等号(==!=)与类别数据相同长度的类似列表的对象(列表,系列,数组…)进行比较。
    • ordered==True和类别是相同时,所有比较(==!=>>=<,和<=)分类数据到另一个分类系列。
    • 将分类数据与标量进行比较。

    看看下面的例子 -

    import pandas as pd
    
    cat = pd.Series([1,2,3]).astype("category", categories=[1,2,3], ordered=True)
    cat1 = pd.Series([2,2,2]).astype("category", categories=[1,2,3], ordered=True)
    
    print (cat>cat1)
    
    Python

    执行上面示例代码,得到以下结果 -

    0    False
    1    False
    2     True
    dtype: bool

    转载于:https://www.cnblogs.com/navysummer/p/9641215.html

    展开全文
  • 一、category的创建及其性质通常实时的数据...除了固定长度,分类数据可能有顺序,但不能执行数字操作。 分类是Pandas数据类型。1、分类变量的创建(a)用Series创建pd.Series(["a", "b", "c", "a"], dtype="category"...

    一、category的创建及其性质

    通常实时的数据包括重复的文本列。例如:性别,国家和代码等特征总是重复的。这些是分类数据的例子。分类变量只能采用有限的数量,而且通常是固定的数量。除了固定长度,分类数据可能有顺序,但不能执行数字操作。 分类是Pandas数据类型。

    1、分类变量的创建

    (a)用Series创建

    pd.Series(["a", "b", "c", "a"], dtype="category")

    (b)对DataFrame指定类型创建

    df = pd.DataFrame({'A':pd.Series(["a", "b", "c", "a"], dtype="category"),'B':list('abcd')})

    (c)利用内置Categorical类型创建

    cat = pd.Categorical(["a", "b", "c", "a"], categories=['a','b','c'])

    (d)利用cut函数创建,又分为两种。

    1、默认使用区间类型为标签

    pd.cut(np.random.randint(0,60,5), [0,10,30,60])

    2、可指定字符为标签

    pd.cut(np.random.randint(0,60,5), [0,10,30,60], right=False, labels=['0-10','10-30','30-60'])

    2、分类变量的结构

    一个分类变量包括三个部分,元素值(values)、分类类别(categories)、是否有序(order)

    下面介绍如何获取或修改这些属性:

    (a)

    describe

    方法,该方法描述了一个分类序列的情况,包括非缺失值个数、元素值类别数(不是分类类别数)、最多次出现的元素及其频数

    s = pd.Series(pd.Categorical(["a", "b", "c", "a",np.nan], categories=['a','b','c','d']))

    s.describe()

    输出:

    count 4

    unique 3

    top a

    freq 2

    dtype: object

    count

    :非缺失值个数

    unique

    :唯一值的个数(缺失值np.nan不算)

    top

    :出现次数最多的元素

    freq

    :出现次数最多的元素,出现的次数,也就是上面top字符出现的次数

    (b)categories和ordered属性,查看分类类别和是否排序

    s.cat.categories

    输出:

    Index(['a', 'b', 'c', 'd'], dtype='object')

    s.cat.ordered

    输出:

    False

    3、类别的修改

    (a)利用set_categories修改,修改分类,但本身值不会变化

    s = pd.Series(pd.Categorical(["a", "b", "c", "a",np.nan], categories=['a','b','c','d']))

    s.cat.set_categories(['new_a','c'])

    (b)利用rename_categories修改,需要注意的是该方法会把值和分类同时修改

    s = pd.Series(pd.Categorical(["a", "b", "c", "a",np.nan], categories=['a','b','c','d']))

    s.cat.rename_categories(['new_%s'%i for i in s.cat.categories])

    利用字典修改值:

    s.cat.rename_categories({'a':'new_a','b':'new_b'})

    (c)利用add_categories添加

    s = pd.Series(pd.Categorical(["a", "b", "c", "a",np.nan], categories=['a','b','c','d']))

    s.cat.add_categories(['e'])

    (d)利用remove_categories移除

    s = pd.Series(pd.Categorical(["a", "b", "c", "a",np.nan], categories=['a','b','c','d']))

    s.cat.remove_categories(['d'])

    (e)删除元素值未出现的分类类型

    s = pd.Series(pd.Categorical(["a", "b", "c", "a",np.nan], categories=['a','b','c','d']))

    s.cat.remove_unused_categories()

    二、分类变量的排序

    1、序的建立

    (a)一般来说会将一个序列转为有序变量,可以利用as_ordered方法

    s = pd.Series(["a", "d", "c", "a"]).astype('category').cat.as_ordered()

    退化为无序变量,只需要使用as_unordered

    s.cat.as_unordered()

    (b)利用set_categories方法中的order参数

    pd.Series(["a", "d", "c", "a"]).astype('category').cat.set_categories(['a','c','d'],ordered=True)

    (c)利用reorder_categories方法,这个方法的特点在于,新设置的分类必须与原分类为同一集合

    s = pd.Series(["a", "d", "c", "a"]).astype('category')

    s.cat.reorder_categories(['a','c','d'],ordered=True)

    三、分类变量的比较操作

    1. 与标量或等长序列的比较

    (a)标量比较

    s = pd.Series(["a", "d", "c", "a"]).astype('category')

    s == 'a'

    输出:

    0 True

    1 False

    2 False

    3 True

    dtype: bool

    (b)等长序列比较

    s == list('abcd')

    输出:

    0 True

    1 False

    2 True

    3 False

    dtype: bool

    2、与另一个分类变量的比较

    (a)等式判别(包含等号和不等号),两个分类变量的等式判别需要满足分类完全相同

    s = pd.Series(["a", "d", "c", "a"]).astype('category')

    s == s

    输出:

    0 True

    1 True

    2 True

    3 True

    dtype: bool

    s != s

    输出:

    0 False

    1 False

    2 False

    3 False

    dtype: bool

    (b)不等式判别(包含>=,<=,),两个分类变量的不等式判别需要满足两个条件:① 分类完全相同 ② 排序完全相同

    s = pd.Series(["a", "d", "c", "a"]).astype('category').cat.reorder_categories(['a','c','d'],ordered=True)

    s >= s

    输出:

    0 True

    1 True

    2 True

    3 True

    dtype: bool

    参考文档:

    展开全文
  • 数据结构分类

    2020-10-18 22:29:02
    数据结构分类线性结构非线性结构 线性结构 1.线性结构作为最常用的数据结构,其特点是数据元素之间存在一对一的线性关系 2.线性结构有两种不同的存储结构,顺序存储结构(数组)链式存储结构(链表)。顺序存储的...
  • 定性数据包括分类数据和顺序数据,通常可以用频数分布图和图形来描述。 (一)生成频数分布表 定性数据生成频数分布表的步骤: 1、列出个类别 2、计算各类别的频数 3、生成频数分布表 注:频数是指频数分布表中落在...
  • 数据结构的分类

    2020-11-26 16:55:17
    数据结构包括线性结构非线性结构 线性结构非线性结构 线性结构 线性结构作为最常用的数据结构,其特点是数据元素之间存在一对一的线性关系 线性结构有两种不同的存储结构,即顺序存储结构链式存储结构。顺序...
  • 除了固定长度,分类数据可能有顺序,但不能执行数字操作。 分类是Pandas数据类型。 1、分类变量的创建 (a)用Series创建 pd.Series(["a", "b", "c", "a"], dtype="category") (b)对DataFrame指定类型创建 df = ...
  • 数据结构 的分类

    2019-09-25 16:34:05
    其中线性结构 包括 线性表 栈 队列 这三种基本结构 非线性结构 包括:树 图 两种结构 再者 存储 结构包括 顺序存储 链式存储 索引存储 离散存储(又称为哈希存储) 顺序存储指 数据元素在内存是被连续存储的。...
  • 定性数据包括分类数据和顺序数据(通常用频数分布表和图形描述)。 饼图、直方图、环形图来描述的是单变量的数据。 (一)频数分布表 频数分布表中落在某一特定类别的数据个数称为次数或频数,各组频数与各组次数...
  • 还记得数据结构这个经典的分类图吧: 今天主要关注一下线性表。 什么是线性表 线性表的划分是从数据的逻辑结构上进行的。线性指的是在数据的逻辑结构上是线性的。即在数据元素的非空有限集中 ...
  • 数据结构-分类

    2019-09-28 07:50:34
    数据结构包括线性结构非线性结构。 线性结构: 1)特点是数据元素之间存在一对一的线性关系。 2)线性结构有两种存储方式,即顺序存储链式存储。 3)顺序存储的线性表称为顺序表(数组),顺序表中的存储元素是...
  • React数据是通过网络抓取HTML解析从NIST Kinetics数据库获取的,以将在线数据库转换为更易访问的数据框(Pandas)格式。 然后,我们设计了一个特征向量来捕获某些物种键的存在,并利用它来训练我们的模型以预测...
  • 自由/公共领域数据集的字母顺序列表,其中包含用于自然语言处理(NLP)的文本数据。 如果您正在寻找带注释的语料库或树库,请参阅底部的源,此处的大多数内容只是原始的非结构化文本数据数据集(英语,多语言) ...
  • ListView 里面数据重复或者顺序乱了

    千次阅读 2015-09-13 21:05:47
    由于getview的时候,listview自身会复用已存在的item,即重用最先新建的那几个item,还有就是注意tag的使用,convertView.getTag()返回的也是重用的view,其状态是被重用的一样,包括图片的显示与隐藏的状态,...
  • C语言数据结构实战(一)顺序表的插入与删除博客分类: C语言 今天学习了思成老师的数据结构实战教程 写了一个顺序表 插入删除的操作 把源码共享给大家 一共包括list.c stu.h main.c list.h .h文件是头文件 需要...
  • 包括R语言的许多基本代码以及某些数据科学算法的实现。 内容 1号 向量的基本用法,矩阵, tibble ,数组,列表,因子 线性代数 缺失值 类型转换 随机顺序 简单概率 采样 分布 硬汉2 循环 选择 一元 生成图案化...
  • 数据结构包括三方面的内容:逻辑结构、存储结构和数据的运算。 1.数据的逻辑结构 数据的逻辑结构分类图如下: 2.数据的存储结构 存储结构是指数据结构在计算机中的表示(又称映象)。也称物理结构。它包括数据元素...
  • 数据结构分类与抽象数据类型1.1数据结构分类现实世界中讨论的数据结构是指逻辑结构(包括:集合结构,线性结构,树结构,图结构)计算机世界里的数据结构是指存储结构(也是物理结构,包括顺序结构,链接结构,...
  • 前言: 数据结构的分类 如果完全不懂数据结构,很难写出优秀的代码,有缺陷的底层数据结构容易导致系统风险高,可...线性结构包括顺序表,链表,栈表,队列等,其中栈队列是访问受限的结构。栈是后进先出,LIF...
  • 数据结构包括:线性结构非线性结构 线性结构 线性结构是最常用的数据结构,其特点是数据元素之间存在一对一的线性关系 线性结构有两种不同的存储结构,即顺序存储结构链式存储结构。顺序存储的线性表称为顺序...
  • 数据的预处理是在对数据分类或分组之前所做的必要处理,内容包括数据的审核、筛选、排序等。 数据审核:就是检查数据中是否存在错误。包括:完整性审核正确性审核。 数据筛选:根据需要找出符合特定条件的某类...
  • 数据分类:分类数据顺序数据,数值型数据。 顺序数据分类数据有序化。1.数据预处理1.1数据审核数据审核检查数据是否有错误,从完整性准确性审核。完整性检查是否存在数据遗漏,项目缺失;准确性检查数据是否...
  • 由于不必须按照顺序存储,链表在插入的时候可以达到o(1)的复杂读,比另一种线性表顺序表快得多,但是查找一个节点或者访问特定编号的节点则需要O(n)的时间,而线性表和顺序表相应的时间复杂度分别是O(logn)和O(1)。...
  • 数据结构笔记-线性结构和非... 存储:包括链式存储结构(链表)和顺序存储结构(数组) 顺序存储的相邻元素地址连续,但是链式存储中相邻的元素地址不一定连续。 线性结构中存在两种操作受限的使用场景,即队列和栈
  • 数据结构

    2021-03-01 00:17:18
    数据结构包括:线性结构非线性结构。 线性结构: 1、线性结构作为最常用的数据结构,其特点是数据元素之间存在一对一的线性关系。 2、线性结构有两种不同的存储结构,即顺序存储结构链式存储结构。顺序存储的...
  • 数值型值包括实型变量整型变量如年龄,速度或长度。 数值型特征有两个重要的属性:其值有顺序关系距离关系。 与其形成对照的是,分类型变量没有上述两种关系,分类型变量的两个值 可以相等或者不等。它们只...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 424
精华内容 169
关键字:

包括分类数据和顺序数据