精华内容
下载资源
问答
  • 集合、关系元组 原文链接:https://blog.csdn.net/minfanphd/article/details/116245485 一:集合与元素的关系 基数:(cardinal number) 一个集合内所有元素的个数称为基数,即为|A|或者cardA,其中A是集合名称 ...

    集合、关系、元组

    原文链接:https://blog.csdn.net/minfanphd/article/details/116245485

    一:集合与元素的关系

    基数:(cardinal number)

    一个集合内所有元素的个数称为基数,即为|A|或者cardA,其中A是集合名称

    例如

       1:集合A = (a,b,c),那么|A|=3(cardA=3),因为A中的元素为{a},{b},{c}.
    
         
       2:B = ((a,b,c),d),那么|B|=2,(cardB=2),因为B中只有两个元素{a,b,c}和{d}.
    

    习题 1: { 0 , 1 , { 0 , 1 } , { 1 , 2 } } 有几个元素? 机器学习中, 这类形式的集合有什么优点和缺点?

    { 0 , 1 , { 0 , 1 } , { 1 , 2 } } 有4个元素,分别为{0},{1},{0,1},{1,2}。
    优点:机器学习,会对样本数据进行分类,使用该集合的表示方法,可以很好的对其不同类的数据进行统一表示。
    缺点:样本数据涉及多个维度,处理过程较麻烦。

    习题 2: ∅的基数是多少? { ∅ } 呢?

    card(∅)=0,card({ ∅ })=1.

    二、函数

    对于函数定义域上的每个点, 均在值域中有一个唯一的点与之对之. 反之不然.

    单标签分类

    在传统的单标签分类中,训练集中的每一个样本只有一个相关的标签 l ,这个标签来自于一个不重合的标签集合L

    多标签分类

    简单的说就是同一个实例,可以有多个标签, 或者被分为多个类

    一个多标签分类器h是一个映射X(样本空间)->Y(可能的标签集),对每一个实例x∈X分配一个标签子集。因此分类器h的输出是一个向量h(x)=(h1(x),h2(x)…hm(x)).

    习题 5: 多标签学习中, 输出为一个向量,相应的学习器算不算函数呢?
    在多标签分类中,对于每一个实例x,都会有一组对应的标签集合,所以多标签分类器是函数。

    三、元组

    从数据结构的角度, 元组就是抽象数据类型; 从面向程序设计的角度, 元组就是一个类. 当我们定义一个类的时候, 它有 k 个成员变量, 就是 k 元组. 各个成员变量可以取不同的定义域, 可以是数值、字符、集合,甚至元组.

    习题 6: 元组只能表达对象的数据部分, 还是可以完整地表达? 用一个具体的程序来说明.
    可以完整的表达.

    public class Graph {
        private List<Node> node;
        private List<E> vector;
    }
    class Node {
        private int val;
        private char info;
    }
    class E{
        private Node from;
        private Node to;
    }
    

    习题 7: 定义二叉树.

    ----------答案参考闵老师原文-----------

    习题 8: 定义带权无向图.

    A weighted undirected graph is a tuple G w G_w Gw =( V , E , w V,E,w V,E,w),where V V V = { v 1 v_1 v1 , . . . , {,...,} ,..., v n v_n vn} is the set of nodes,and E ⊆ E\sube E V V V × \times × V V Vis the set of edges, and w w w : V V V × \times × V V V → R ∪ \rightarrow\R\cup R{0} is the edge weight function,and < \lt < v i , v j v_i,v_j vi,vj > \gt > ∈ \isin E E E iff < \lt < v j , v i v_j,v_i vj,vi > \gt > ∈ \isin E E E

    习题 9. 考虑 ϕ \phi ϕ, 重新写 Definition 7 以解决其存在的问题, 见其讨论 d).

    Let ∑ = \sum= = { l , r } \{ l,r \} {l,r} be the alphbet and ϕ \phi ϕ be a null node.A binary tree is a triple T = T= T= ( V , r , c ) (V,r,c) (V,r,c),where V = V= V= { v 1 , . . . , v 2 } \{ v_1,...,v_2 \} {v1,...,v2} is the set of nodes, r ∈ r \in r V V V is the root,and c : V ∪ c:V\cup c:V { ϕ } \{ \phi \} {ϕ} × \times × ∑ + \sum^+ + → \rightarrow V V V ∪ \cup { ϕ } \{\phi \} {ϕ} satisfying
    a) ∀ \forall v ∈ v\isin v V V V, ∃ 1 s ∈ ∑ ∗ \exist1s\isin\sum^* 1sst. c ( r , s ) = v c(r,s)=v c(r,s)=v.----存在唯一一条路径使得根节点到节点集中的所有任意节点。

    在初始版本的基础上,a),c)是冗余的,整棵二叉树,考虑的部分就是根节点,空节点,其余剩下节点,而打磨后的版本,对着三部分都有考虑:
    1)对于根节点: c ( r c(r c(r, ϕ ) \phi) ϕ) = r =r =r.
    2)对于空节点: c ( c( c( ϕ \phi ϕ,l ) ) ) = = = c ( c( c( ϕ \phi ϕ,r ) ) ) = ϕ =\phi =ϕ
    3) ∀ \forall v ∈ v\isin v V V V \ \backslash \ { r } \{ r\} {r}, ∃ 1 s ∈ ∑ + \exist1 s\isin\sum^+ 1s+st. c ( r , s ) = v c(r,s)=v c(r,s)=v

    接下来是对二叉树性质的讨论:
    1:二叉树任何节点(除空节点)不会有自己的环:就是说到同一个节点不能有两条路经
    -----先假设 v i v_i vi有一条路径能到 v i v_i vi,通过二叉树的定义,根节点可以有一条路径可以到达 v i v_i vi r r r根节点通过 s 1 s_1 s1 v i v_i vi,然后又通过 s ′ s^{\prime} s到达 v i v_i vi, r r r存在两条路径到达 v i v_i vi,与定义不符合,所以不存在环。(s1=r->任意节点-v1);(s2=r->v1->v1)
    2:空节点的左右孩子都是自己。
    假设n个实节点+一个空节点,访问它,我们先不知道访问多少次,访问第一个节点开始,设访问n+1次,就会访问n+1个节点,加上根节点,那么总共有会涉及到n+2个节点,而二叉树一开始只有n+1个节点,由鸽笼原理可知其中会有两个节点指向一个节点(在我们列子中,可以说是空指向空),即两个相同节点,存在环,而由性质一,该节点不属于总结点集 V V V,所以 v i = v_i= vi= v j = ϕ v_j=\phi vj=ϕ,判断他们之间是个否为有效节点,即空节点指向空节点。假设, v k v_k vk v i 与 v_i与 viv_j节点之间,从r到ak,会经过某一路径比如a1,a2…aj/ai,ai+1…到ak,所以路径就不唯一,由性质一,不是有效节点,只能 v k v_k vk也为无效节点为 ϕ \phi ϕ
    在这里插入图片描述涉及正闭包,克林闭包,跳转函数,笛卡尔积。-------后续加

    习题 3.1 模仿自动机的样子来重新定义二叉树.
    A binary is a 5-tuple T = ( ∑ , Q , r , ϕ , c ) T=(\sum,Q,r,\phi,c) T=(,Q,r,ϕ,c),where
    a) ∑ \sum is the alphabet, ∑ = \sum= ={l,r};
    b) Q = V ∪ ϕ Q=V\cup\phi Q=Vϕ;
    c) { r } \{ r\} {r} is the root;
    d) ϕ \phi ϕ is the terminal state;
    e) c : Q × ∑ ∗ c:Q\times\sum^* c:Q× → Q \rightarrow Q Q satisfying ∀ v ∈ Q \forall v\isin Q vQ, ∃ 1 s ∈ ∑ ∗ \exist1s\isin\sum^* 1sst. c ( r , s ) = v c(r,s)=v c(r,s)=v.

    习题3.2 模仿自动机的样子来重新定义树.
    A tree is a 5-tuple T = ( Σ , Q , r , ϕ , p ) T=(\Sigma,Q,r,\phi,p) T=(Σ,Q,r,ϕ,p),where
    a) Σ \Sigma Σ is the alphabet, Σ = 0 , 1 , . . . , n − 1 ; \Sigma={0,1,...,n-1}; Σ=0,1,...,n1;
    b) Q = V ∪ ϕ Q=V \cup \phi Q=Vϕ
    c) r ∈ Q r\in Q rQ is the root;
    d) ϕ \phi ϕ is a terminal state;
    e) p : Q × Σ ∗ → Q p:Q \times\Sigma^*→Q p:Q×ΣQ satisfying ∀ v ∈ Q \forall v \in Q vQ , ∃ 1 s ∈ Σ ∗ ,\exist1s\in\Sigma^* ,1sΣst. c ( r , s ) = v c(r,s)=v c(r,s)=v;

    展开全文
  • 说明文档网址:... 关系:类似数据库,不过目前只限两个字段 元组:也类似数据库,不过只是关系返回的每条记录 结构体: GTuples typedef struct { guint len; } GTupl

    说明文档网址:http://web.mit.edu/barnowl/share/gtk-doc/html/glib/glib-Relations-and-Tuples.html


    关系:类似数据库,不过目前只限两个字段
    元组:也类似数据库,不过只是关系返回的每条记录


    结构体:

    GTuples

    typedef struct {
      guint len;
    } GTuples;

    功能函数:

    Synopsis

    #include <glib.h>
    
    
                        GRelation;
    GRelation*          g_relation_new                      (gint fields);
    void                g_relation_index                    (GRelation *relation,
                                                             gint field,
                                                             GHashFunc hash_func,
                                                             GEqualFunc key_equal_func);
    void                g_relation_insert                   (GRelation *relation,
                                                             ...);
    gboolean            g_relation_exists                   (GRelation *relation,
                                                             ...);
    gint                g_relation_count                    (GRelation *relation,
                                                             gconstpointer key,
                                                             gint field);
    GTuples*            g_relation_select                   (GRelation *relation,
                                                             gconstpointer key,
                                                             gint field);
    gint                g_relation_delete                   (GRelation *relation,
                                                             gconstpointer key,
                                                             gint field);
    void                g_relation_destroy                  (GRelation *relation);
    
    void                g_relation_print                    (GRelation *relation);
    
                        GTuples;
    void                g_tuples_destroy                    (GTuples *tuples);
    gpointer            g_tuples_index                      (GTuples *tuples,
                                                             gint index_,
                                                             gint field);

    下面是一段例子代码:

    #include <glib.h>
    
    struct map {
        int key;
        char *value;
    } m[10] = {
        {0,"zero"},
        {1,"one"},
        {2,"two"},
        {3,"three"},
        {4,"four"},
        {5,"five"},
        {6,"six"},
        {7,"seven"},
        {8,"eight"},
        {9,"nine"}
    };
    
    typedef struct map map;
    
    #define NUMS    (sizeof(m)/sizeof(m[0]))
    
    static void 
    test_relation(void)
    {
    // GRelation* g_relation_new(gint fields);      创建新的关系表,fields域的数量,现在这个值必须是2,也就是一个key域,一个value域
        GRelation *relation = g_relation_new(2);
    
    // void g_relation_index(GRelation *relation, gint field, GHashFunc hash_func, GEqualFunc key_equal_func);创建一个域的索引
        g_relation_index(relation, 0, g_int_hash, g_int_equal);
        g_relation_index(relation, 1, g_str_hash, g_str_equal);
    
    // void g_relation_insert(GRelatioin *relation, ...);   插入记录到关系表中,...的参数必须与域对应
        gint i;
        for (i = 0; i < NUMS; i++)
            g_relation_insert(relation, &m[i].key, m[i].value);
    
    // gint g_relation_count(GRelation *relation, gconstpointer key, gint fields);  在域fields中key值对应的元组值
        g_printf("The '%d' should be exist '%d' times now.\t\tResult: %d.\n", 
                m[1].key, 1, g_relation_count(relation, &m[1].key, 0));
    
    // gboolean g_relation_exists(GRelation *relation, ...);    被给的键值如果在关系表中存在则返回true
        gboolean b = g_relation_exists(relation, &m[1].key, m[1].value);
        g_printf("The key: '%d' and value: '%s' should be %sfound now.\n", 
                m[1].key, m[1].value, b ? "" : "not ");
    
    // gint g_relation_delete(GRelation *relation, gconstpointer key, gint field);  在域field中删除所有的key,返回删除的个数
        g_printf("The key: '%d' has been found '%d' times and deleted now.\n",
                m[1].key, g_relation_delete(relation, &m[1].key, 0));
        
    // GTuples* g_relation_select(GRelation *relation, gconstpointer key, gint field);  返回所有的key对应的元组,配合g_tuples_index使用取出记录值
    // gpointer g_tuples_index(GTuples *tuples, gint index_, gint field);   从g_relation_select的返回中取出field中的元组值
    // void g_tuples_destroy(GTuples *tuples);  销毁元组
        g_printf("The all records now:\n");
        for (i = 0; i < NUMS; i++) {
            GTuples *tuples = g_relation_select(relation, m[i].value, 1);
            gint j;
            for (j = 0; j < tuples->len; j++)
                g_printf("Key: %d\t\tValue: %s\n", 
                        *(gint *)g_tuples_index(tuples, j, 0),
                        (gchar *)g_tuples_index(tuples, j, 1));
            g_tuples_destroy(tuples);
        }
        g_printf("\n");
    // void g_relation_print(GRelation *relation);
    //    g_relation_print(relation);
    
    // void g_relation_destroy(GRelation *relation);    销毁关系表
        g_relation_destroy(relation);
    }
    
    int
    main(void)
    {
        g_printf("BEGIN:\n************************************************************\n");
        test_relation();
        g_printf("\n************************************************************\nDONE\n");
        
        return 0;
    }
    

    运行结果:

    linux@ubuntu:~/16021/glibDemo$ gcc Relations_and_Tuples.c -o Relations_and_Tuples -lglib-2.0
    linux@ubuntu:~/16021/glibDemo$ ./Relations_and_Tuples BEGIN:
    ************************************************************
    The '1' should be exist '1' times now.		Result: 1.
    The key: '1' and value: 'one' should be found now.
    The key: '1' has been found '1' times and deleted now.
    The all records now:
    Key: 0		Value: zero
    Key: 2		Value: two
    Key: 3		Value: three
    Key: 4		Value: four
    Key: 5		Value: five
    Key: 6		Value: six
    Key: 7		Value: seven
    Key: 8		Value: eight
    Key: 9		Value: nine
    
    
    ************************************************************
    DONE
    linux@ubuntu:~/16021/glibDemo$ 
    


    结语:

    关于glib的基本数据类型就讲到这里,其实这里并不是所有的类型,还有几个没有讲到,但是那些没有特殊的要求是不会用到的。

    glib其实还有很多的功能,它还带有核心应用支持,例如线程的实现也可以使用glib完成,那些就是后面有机会再去研究,目前为止可能对我最有用的就是strings和单链表。

    几天的更新也算是对我的学习一个记录和分享,以后有什么心得体会也会记录在这里。

    接下来要接触linux移植,希望能够将每天的学习分享在这里,可以和大家一起交流,争取做到中国的stackoverflow。





    展开全文
  • 列举法:无疑是最没有技术含量的,一股脑把集合的元素全部写出来。如:A\AlphaA = {0, 1, 2, 3, 4, 5} 是阿拉伯数字的集合;N\NuN = {0, 1, 2,…} 是自然数的集合; 描述法:有些地方叫谓词法。如:A\AlphaA = {...

    1. 集合

      话不多说,先甩一张图。
    在这里插入图片描述


    1.1 集合定义

      由上图可知,集合通常有三种表示方法。

    • 列举法:无疑是最没有技术含量的,一股脑把集合中的元素全部写出来。如: A \Alpha A = {0, 1, 2, 3, 4, 5} 是阿拉伯数字的集合; N \Nu N = {0, 1, 2,…} 是自然数的集合;
    • 描述法:有些地方叫谓词法。如: A \Alpha A = { x x x N \Nu N | x x x mod 2 = 1};
    • 韦恩图:通常用一个圆来代表一个集合;

      问题来了:集合 A \Alpha A = {0, 1, {0, 1} , {1, 2}} 有几个元素? 机器学习中, 这类形式的集合有什么优点和缺点?

    1. c a r d card card 表示有限集 A \Alpha A 中的元素个数, c a r d card card( A \Alpha A) = 4。
    2. 在机器学习中,我们通常会用自然数表示分类任务中的标签。例如,0 通常表示第一类,1 表示第二类,依次类推。集合 A \Alpha A 通常会被用在多标签分类任务中。一个实例可能有一个或多个标签,类似于选择题中的不定项选择题。对于集合 A \Alpha A,我们可以认为它的标签数目不是固定的,有的一个标签,有的有两个标签,但是标签的总数是固定的,有 3 类。我们在标签编码时,可以使用标签补齐的方法,将缺失的标签全部用 0 标记,这样就不能使用 one-hot 编码了。例如,标签总数为 10,编号 0-9,一张图片中包含 0,3,9 号标签,那么这张图片的标签编码为:1 0 0 1 0 0 0 0 0 1。而且在多标签分类任务中,最后一层的输出就不能看成一个分布了,因为加起来不为 1,可以把输出层每个神经元看作一个二项分布,这相当于将一个多标签问题转化为在每个标签上的二分类问题。

      令 A = { 5 , 6 , 7 , 8 , 9 } \mathbf{A}=\{5,6,7,8,9\} A={5,6,7,8,9},写出 A \mathbf{A} A 的其它两种表示方法。
    ① 描述法: A = { x ∣ x ∈ N , 4 < x < 10 } \mathbf{A} = \{x \vert x \in \mathbf{N}, 4 < x < 10\} A={xxN,4<x<10}, 源码为 \mathbf{A} = {x \vert x \in \mathbf{N}, 4 < x < 10}。
    ② 枚举法: [ 5..9 ] = { 5 , 6 , 7 , 8 , 9 } [5..9] = \{5,6,7,8,9\} [5..9]={5,6,7,8,9},源码为 [5…9] = {5,6,7,8,9}.


    1.2 基数

    1.2.1 无穷集合比较大小

      说到基数,先提一下无穷集合比较大小。

      首先提出一个问题 “自然数的个数和正偶数的个数哪个多呢?” 有人说,当然是自然数的个数多,因为自然数包括正偶数;也有人说这两类数的个数都是无穷大,所以应该是一样多。

      这里面引出来一个很本质的问题,到底比较两个集合元素个数多少的标准是什么?虽然我们还是孩子的时候,就知道自己分了一个苹果而其他小朋友分到了两个苹果是不公平的,但是直到19世纪末,才由伟大的集合论开创者康托尔提出集合元素个数之间严格比较大小的标准。

      我们平时一般靠数数来记录一个集合元素的个数,再比较这两个数字大小来确定两个集合之间谁的元素更多,实际上这是在拿一个集合的元素去与自然数集合的元素做对应。如果某个集合中的元素能够与从小到大排列的自然数某个子集建立一一对应,那么就认为这个集合中元素的个数就是自然数子集中最大的那个数。

      再提出一个问题?下面的两条线段哪一条中包含的点更多?
              在这里插入图片描述
      我第一次看到这个问题就觉得肯定有鬼。肯定不是下面这条长,应该是一样长,但是又不知道为什么它们一样长。我的导师直接画了两条线,我就恍然大悟了。
              在这里插入图片描述
      下面那条线中的任一点总能在上面那一条线找到一一对应的点。这就是康托尔提出集合之间元素个数多少的判定标准,集合之间元素个数多少的比较,本质上在于集合间的对应(映射)。

      如果两个集合 A 和 B 之间能够建立一一对应(集合论中将这种对应叫做双射),那么就说这两个集合的元素个数一样多,记作 ∣ A ∣ |\Alpha| A = ∣ B ∣ |\Beta| B;如果能够建立 A 到 B 的单射(指每个 A 中的元素都对应一个 B 中的元素,且不同的 A 中元素对应的B中元素也不同),那么就说集合 B 的元素个数不少于 A 的元素个数,记作 ∣ A ∣ ≤ |\Alpha| \leq A ∣ B ∣ |\Beta| B ∣ B ∣ ≥ |\Beta| \geq B ∣ A ∣ |\Alpha| A

      对于元素个数有限的有限集来说,这种判定标准与日常人们熟悉的“数数”判定标准是一样的。一个有着100个元素的集合肯定能够与另外一个也有着100个元素的集合建立一一对应,但是绝不能与一个有着101个元素的集合建立起一一对应。

      设 N \Nu N = {1, 2, 3, …} 是自然数集合, E \Epsilon E = {2, 4, 6,…} 是正偶数集合, n ∈ n ∈ n N \Nu N e ∈ e ∈ e E \Epsilon E,则建立集合 N \Nu N E \Epsilon E 之间的映射 f f f N \Nu N → \to E \Epsilon E e = f ( n ) = 2 n e = f(n) = 2n e=f(n)=2n。由此我们知道了,自然数的个数与正偶数的个数是一样多的


    1.2.2 基数

      有了前面关于集合元素个数比较大小的标准,我们就可以定义一个概念 —— 集合的基数。作为普及性文章,我们没有必要给出严格的基数定义,描述性的来说,

    基数就是一个集合元素的个数(集合的基数有时也被叫做集合的势)。

      显然,对于有限集合来说,其基数就是这个集合的元素的个数,必然是一个自然数。但是对于无限集合来说,由于其元素个数无穷多,没有一个自然数能够表示,我们需要定义一些新的 “数”。我们首先定义自然数的个数是 ℵ₀ (这个符号来自于希伯来字母,可以读作阿列夫,自然数的个数就是阿列夫零)。显然,我们知道有理数、整数、奇数、偶数、代数数的个数都是 ℵ₀ 。

      那么问题来了,∅ 的基数是多少? { ∅ } 呢?

       c a r d ( ∅ ) card(∅) card() = 0; c a r d card card( {∅} ) = 1


    1.3 笛卡尔积

      我们最常用的是笛卡尔坐标系,一维数轴可表示为 R \Bbb{R} R,二维平面可表示为 R \Bbb{R} R × \times × R \Bbb{R} R = R 2 \Bbb{R}^2 R2 n n n 维空间当然就是 R n \Bbb{R}^n Rn 了。

    一维数轴上的点就是一个实数 x x x R \Bbb{R} R
    二维数轴上的点就是一个实数对 ( x , y ) (x, y) (x,y) R 2 \Bbb{R}^2 R2
    一维数轴上的点就是一个向量( x 1 , x 2 , . . . , x n ) x_1, x_2,..., x_n) x1,x2,...,xn) R n \Bbb{R}^n Rn

      设 A \Alpha A B \Beta B 是两个集合,称集合 A \Alpha A × \times × B \Beta B = {< x , y x, y x,y> | ( x ∈ x∈ x A \Alpha A) ∧ \wedge ( y ∈ y∈ y B \Beta B) } 为集合 A \Alpha A B \Beta B笛卡尔积

    由笛卡尔积定义可以看出:

    1. A \Alpha A, B \Beta B 是任意两个集合,则不一定有 A \Alpha A × \times × B \Beta B = B \Beta B × \times × A \Alpha A,即笛卡尔积不满足交换律;
    2. A \Alpha A × \times × B \Beta B = ∅ 当且仅当 A \Alpha A = ∅ 或者 B \Beta B = ∅;
    3. A \Alpha A, B \Beta B, C C C 是任意三个集合,则不一定有 A \Alpha A × \times × ( B (\Beta (B × \times × C ) C) C) = ( A \Alpha A × \times × B \Beta B) × \times × C C C,即笛卡尔积不满足结合律;
    4. 当集合 A \Alpha A, B \Beta B 都是有限集时, ∣ A |\Alpha A × \times × B ∣ \Beta| B = ∣ B |\Beta B × \times × A ∣ \Alpha| A = ∣ A ∣ |\Alpha| A × \times × ∣ B ∣ |\Beta| B;
    5. 笛卡尔积对并运算和交运算满足分配律。

      上述 4 在机器学习中最为常见,可以完美地表示混合类型的数据。任何实例都可以使用这种元素描述,但反过来,并非所有的元素都对应于数据集中的一个实例,即数据不会填满整个空间, 甚至通常在这个空间内是非常稀疏的。找出数据在空间中的分布规律,这也是数据挖掘的基本意义。

      说到数据集,这里介绍两种表示方法。

    1. 矩阵表示法
      当各个属性都为实型值时,数据集可表示为 D D D R n × m ) \Bbb{R}^{n \times m)} Rn×m) ,它表示每个实际的数据集,都是 n × m n \times m n×m 维空间的一个点而已。如果记 D = ( x 1 , x 2 , . . . , x n ) T D = (x_1, x_2,..., x_n)^T D=(x1,x2,...,xn)T,则 x i x_i xi R m \Bbb{R}^ m Rm;
    2. 集合与向量混合法
      D D D = { x 1 , x 2 , . . . , x n x_1, x_2,..., x_n x1,x2,...,xn},则 x i x_i xi R m \Bbb{R}^ m Rm;

    优缺点

    1. 集合与向量混合法中,元素可以随意交换顺序,这与现实数据的独立性一致。
    2. 集合与向量混合法中,不允许两个元素相同,这与现实情况不一致。
    3. 矩阵表示法可以支持矩阵的相乘,,易于表示加权等操作,,用于神经网络, 线性回归时方便。

    注意:在机器学习中,经常用一个列向量表示一个实例。


    1.4 幂集

      设 A \Alpha A 为任意集合,以 A \Alpha A 的子集为元素所组成的集合,称为 A \Alpha A 的幂集。

    P ( A ) = P(\Alpha) = P(A)= { x ∣ x | x x ⊆ A x \subseteq \Alpha xA}; 若 ∣ A ∣ |\Alpha| A = n n n,则 ∣ P ( A ) ∣ = |P(\Alpha)| = P(A)= 2 n 2^n 2n


    举例:
    P ( ∅ ) P(\emptyset) P() = { ∅ \emptyset }
    P P P({ ∅ \emptyset }) = { ∅ \emptyset , { ∅ \emptyset }}
    P P P({1, {2, 3}}) = { ∅ \emptyset , {1}, {2,3}, {1, {2, 3}}}
    ④ 令 A = { 3 , 5 } \mathbf{A}=\{3,5\} A={3,5}, P ( A ) P(A) P(A) = { ∅ \emptyset , {3}, {5}, {3,5}}

      幂集不仅限于有穷集,对于任意无穷集也有效。


    2. 二元关系

      二元关系的数学定义:Let A \mathbf{A} A and B \mathbf{B} B be sets. Any R ⊆ \mathbf{R} \subseteq R A × B \mathbf{A} \times \mathbf{B} A×B is called a binary relation.

      其实不用想得太复杂,关系就是关系。比如,1 < 2 是二元关系,我爱学习也是二元关系。我认为如果两个东西之间有联系,并且说明了联系的方式,那就可以称之为关系。

      另外,两个集合的笛卡尔积是遍历了所有的 “对”,之所以是子集是因为上述 “联系的描述” 可能对某些对有效,对某些对无效。

      在平面直角坐标系中, 等于关系就是 45 度方向的一条线 ( x = y x = y x=y);小于关系就是这条线的左上部分 ( x < y x < y x<y);同理,大于关系就是这条线的右下部分 ( x > y x > y x>y)。如果 A \mathbf{A} A = B \mathbf{B} B = N \mathbb{N} N,即它们都为整数集合,则 R = \mathbf{R}^= R= = {(0, 0), (1, 1), (2, 2), … \dots };如果 A \mathbf{A} A = B \mathbf{B} B = R \mathbb{R} R,则 R < \mathbf{R}^< R< = { ( x , y ) ∈ R 2 ∣ x < y (x, y) \in \mathbb{R}^2 \vert x < y (x,y)R2x<y},在二维平面上,它表示 y = x y=x y=x 左上方向的区域。

    二元关系的性质。对于 A \mathbf{A} A 的关系,即 R ⊆ A × A \mathbf{R} \subseteq \mathbf{A} \times \mathbf{A} RA×A.
    ①自反性:如果 ∀ x ∈ A \forall x \in \mathbf{A} xA,均有 ( x , x ) ∈ R (x, x) \in \mathbf{R} (x,x)R,则称 R \mathbf{R} R 具有自反性。
    ② 对称性:如果 ∀ ( x , y ) ∈ R \forall (x, y) \in \mathbf{R} (x,y)R,均有 ∀ ( y , x ) ∈ R \forall (y, x) \in \mathbf{R} (y,x)R,则称 R \mathbf{R} R 具有对称性。
    ③ 传递性:如果 ∀ ( x , y ) , ( y , z ) ∈ R \forall (x, y), (y, z) \in \mathbf{R} (x,y),(y,z)R,均有 ( x , z ) ∈ R (x, z) \in \mathbf{R} (x,z)R,则称 R \mathbf{R} R 具有传递性。

    二元关系的运算
    给定 A = { a , b , c , d } \mathbf{A} = \{a, b, c, d\} A={a,b,c,d} 上的关系 R 1 = { ( a , b ) , ( a , c ) } \mathbf{R}_1 = \{(a, b), (a, c)\} R1={(a,b),(a,c)} R 2 = { ( a , b ) , ( c , d ) , ( b , d ) } \mathbf{R}_2 = \{(a, b), (c, d), (b, d)\} R2={(a,b),(c,d),(b,d)},则 R 1 R 2 \mathbf{R}_1\mathbf{R}_2 R1R2 = { ( a , d ) (a, d) (a,d)},这个有点像矩阵维度相乘(3x2 的矩阵与 2x4 的矩阵得 3x4 的矩阵),中间得有个媒介。
    或者 R 1 R 2 \mathbf{R}_1\mathbf{R}_2 R1R2 = { ( x , y ) ∣ ∃ ( x , z ) ∈ R 1  and  ( z , y ) ∈ R 2 (x, y) \vert \exists(x, z) \in \mathbf{R}_1 \textrm{ and } (z, y) \in \mathbf{R}_2 (x,y)(x,z)R1 and (z,y)R2}.

    给定 A = { a , b , c , d } \mathbf{A} = \{a, b, c, d\} A={a,b,c,d} 上的关系 R \mathbf{R} R
    ① 正闭包: R + = ⋃ i = 1 ∣ A ∣ R i \mathbf{R}^+ = \bigcup_{i=1}^{|\mathbf{A}|} \mathbf{R}^i R+=i=1ARi.
    ② 克林闭包: R ∗ = R + ∪ A 0 \mathbf{R}^* = \mathbf{R}^+ \cup \mathbf{A}^0 R=R+A0,其中 A 0 = { ( x , x ) ∣ x ∈ A } \mathbf{A}^0 = \{(x, x) \vert x \in \mathbf{A}\} A0={(x,x)xA}

    练一练:

    1. A = { 1 , 2 , 5 , 8 , 9 } \mathbf{A} = \{1, 2, 5, 8, 9\} A={1,2,5,8,9},写出 A \mathbf{A} A 上的 “模2同余” 关系及相应的划分。

    R = { ( a , b ) ∈ A × A ∣ a  mod  2 = b  mod  2 } \mathbf{R} = \{(a, b) \in \mathbf{A} \times \mathbf{A} \vert a \textrm{ mod } 2 = b \textrm{ mod } 2\} R={(a,b)A×Aa mod 2=b mod 2}.
    可将其划分为:
    P = { { 2 , 8 } , { 1 , 5 , 9 } } \mathcal{P} = \{\{2, 8\}, \{1, 5, 9\}\} P={{2,8},{1,5,9}}

    1. 给定 A = { 1 , 2 , 5 , 8 , 9 } \mathbf{A} = \{1, 2, 5, 8, 9\} A={1,2,5,8,9} 上的关系 R 1 = { ( 1 , 2 ) , ( 5 , 8 ) } \mathbf{R}_1 = \{(1, 2), (5, 8)\} R1={(1,2),(5,8)} R 2 = { ( 2 , 8 ) , ( 8 , 9 ) , ( 2 , 5 ) } \mathbf{R}_2 = \{(2, 8), (8, 9), (2, 5)\} R2={(2,8),(8,9),(2,5)},则

    R 1 R 2 \mathbf{R}_1\mathbf{R}_2 R1R2 = { ( 1 , 8 ) , ( 1 , 5 ) , ( 5 , 9 ) } \{(1, 8), (1, 5), (5, 9)\} {(1,8),(1,5),(5,9)}.
    R 1 + \mathbf{R}_1^+ R1+ = ⋃ i = 1 i R i \bigcup_{i=1}^i \mathbf{R}_i i=1iRi = { ( 1 , 2 ) , ( 5 , 8 ) } \{(1, 2), (5, 8)\} {(1,2),(5,8)}.
    R 1 ∗ \mathbf{R}_1^* R1 = R 1 + ⋃ A 0 \mathbf{R}_1^+\bigcup \mathbf{A^0} R1+A0 = { ( 1 , 2 ) , ( 5 , 8 ) , ( 1 , 1 ) , ( 2 , 2 ) , ( 5 , 5 ) , ( 8 , 8 ) } \{(1, 2), (5, 8), (1, 1), (2, 2), (5, 5), (8, 8)\} {(1,2),(5,8),(1,1),(2,2),(5,5),(8,8)}.


    3. 函数

      函数也叫映射、变换或对应。但是我们需要区别函数与方程的区别以及与关系的区别。

      函数定义:设 f f f 是集合 A \Alpha A B \Beta B 的关系,如果对每个 x ∈ A x ∈ \Alpha xA,都存在唯一的 y ∈ B y ∈ \Beta yB,使得 < x , y x, y x,y> ∈ f f f,则称关系 f f f A \Alpha A B \Beta B 的函数,记作 f f f: A → B \Alpha \to \Beta AB A \Alpha A 为函数 f f f 的定义域, f ( A ) f(\Alpha) f(A) 为函数 f f f 的值域。

    注意

    1. f ( x ) f(x) f(x) 表示一个变值, f f f 代表一个集合。因此 f ≠ f ( x ) f \neq f(x) f=f(x)
    2. f ( x ) f(x) f(x) B \Beta B 的子集,即 B \Beta B 中有些元素跟 A \Alpha A 不对应也可以。
    3. 如果存在元素 a ∈ A a ∈ \Alpha aA,在 B \Beta B 中没有对应元素,那么关系 f f f 就不是函数。
    4. 如果存在元素 a ∈ A a ∈ \Alpha aA,在 B \Beta B 中有两个或两个以上对应的元素,那么关系 f f f 就不是函数。

    辨别函数与方程:从本质上,方程就是一个等式,而函数是一个对应关系。

    辨别函数与关系的联系与区别

    1. 在离散数学中,函数可以看作是一种特殊的二元关系
    2. A \Alpha A B \Beta B 的不同的关系有 2| A \Alpha A|| B \Beta B|个,但从 A \Alpha A B \Beta B 不同的函数却只有 | A \Alpha A|| B \Beta B| 个。(每个 B \Beta B 中的元素都可以有 ∣ A ∣ |\Alpha| A A \Alpha A 中元素匹配)。
    3. 关系的第一个元素可以相同;函数的第一个元素一定是互不相同的。

      举个栗子,令函数的定义域为 D D D, 值域为 V V V,可以认为函数 D × V D \times V D×V 的子集,也就是一种特殊的关系。如 x 2 + y 2 = 1 x^2 + y^2 = 1 x2+y2=1,它是二维平面 R 2 \Bbb{R}^2 R2 中的一个单位圆,为若干平面中的元素 (点) 所构成, 因此为 R \Bbb{R} R 上(即定义域、值域均为 R \Bbb{R} R)的二元关系。但它不是一个函数。 y = 1 − x 2 y = \sqrt{1 - x^2} y=1x2 就既是函数,也是二元关系。

      在机器学习中,单标签任务学习器可以看做一个函数(毫无疑问)。对于多标签分类器,一个实例 x x x 虽然同时拥有多个标签,但是可以把多个标签看作一个标签组合,每个实例对应的标签组合是唯一的,所以多标签分类器仍然是一个函数。

    举例说明你对函数的认识。.
      我们先从理解最简单地例子开始: f ( x ) = x + 1 f (x) = x + 1 f(x)=x+1 给定一个 x x x 的值,那么右边的式子的值为 2,那么 f ( x ) f(x) f(x) 就是2。 f f f 就是连接1 和 2 的一个函数。 f f f 除了连接1 和 2 的关系,也同时可以连接 1.1 和 2.1 等等。

      但是你以为你见到上面的例子就理解函数概念了么?没有! 比方说你知道西瓜是绿色的,也是圆的。但是给你一个绿色的圆的东西,你就能一定知道是西瓜么?不行!所以你必须多看不同种类的西瓜,也看看冬瓜,南瓜这种相似的物种,然后你西瓜的概念就清晰起来。函数的种类是很多的,可以是用式子表示,也可以用图表表示。广义一点,输入可以是数,也可以是任何东西。我可以说函数 f ( x ) f(x) f(x) = “智商的大小”,x表示人。那么 f f f 就相当于给出对应每个人,即 x x x 的智商大小。函数(英文:function),实际就是一种关系的连接,数学上称之为映射。也就是说如果你要用非数学的语言,给一个完全不懂数学概念的人讲解函数,那么就给出各种对应关系。慢慢的他脑中就会模模糊糊有一种感觉,好像这样子就是一个函数。如果真让他说什么是函数,那就说不出来。

      这时候定义就有用了!我们再回顾下函数的概念。“给定一个数集 A \mathbf{A} A,对 A \mathbf{A} A 施加对应法则 f f f,记作 f ( A ) f(\mathbf{A}) f(A),得到另一数集 B \mathbf{B} B,也就是 B = f ( A ) \mathbf{B} = f(\mathbf{A}) B=f(A).那么这个关系式就叫函数关系式,简称函数。

      下图能在你理解了函数基础上更加强你的理解。

                    在这里插入图片描述


    4. 元组(tuple)

      百度百科中提到。元组是关系库中的基本概念,关系是一张表,表中的每行(即数据库中的每条记录)就是一个元组,每列就是一个属性。在二维表中,元组也称为行或记录。

      但是离散数学中的元组又与之不同,图(Graph)是最经典的元组,图可分为有向图和无向图。图的数学定义如下:

    (1)A directed graph is a tuple G d = ( V , E ) G_d = (\bm{V}, \bm{E}) Gd=(V,E), where V \bm{V} V = { v 1 , … , v n v_1, \dots, v_n v1,,vn} is the set of nodes, and E ⊆ V × V \bm{E} \subseteq \bm{V} \times \bm{V} EV×V is the set of edges.
    (2)A undirected graph is a tuple G u = ( V , E ) G_u = (\bm{V}, \bm{E}) Gu=(V,E), where V \bm{V} V = { v 1 , … , v n v_1, \dots, v_n v1,,vn} is the set of nodes, and E ⊆ V × V \bm{E} \subseteq \bm{V} \times \bm{V} EV×V is the set of edges, and $\langle v_i, v_j \rangle ∈ \bm{E} iff ⟨ v j , v i ⟩ ∈ E \langle v_j, v_i \rangle ∈ \bm{E} vj,viE.
    iff 是 if and only if (当且仅当) 的缩写, 更多细节参考 mf 的博客

      图又可以根据是否有权值分为带权有向图和带权无向图。其数学定义如下:

    (1)A weighted directed graph is a tuple G w d = ( V , w ) G_{wd} = (\bm{V}, w) Gwd=(V,w), where V \bm{V} V = { v 1 , … , v n v_1, \dots, v_n v1,,vn} is the set of nodes, and w : V × V → R + ∪ w: \bm{V} \times \bm{V} \to \Bbb{R}^+ \cup w:V×VR+ { 0 0 0} is the edge weight function.
    (2)A weighted undirected graph is a tuple G w u = ( V , w ) G_{wu} = (\bm{V}, w) Gwu=(V,w), where V \bm{V} V = { v 1 , … , v n v_1, \dots, v_n v1,,vn} is the set of nodes, and w : V × V → R + ∪ w: \bm{V} \times \bm{V} \to \Bbb{R}^+ \cup w:V×VR+ { 0 0 0} is the edge weight function, and w ( v i , v j ) w(v_i, v_j) w(vi,vj) = w ( v j , v i ) w(v_j, v_i) w(vj,vi).

      元组的数学定义请参考 mf 的博客 的 Definition 6.

      以 Python 为例。元组也是一种序列,元组使用小括号表示,元素中各元素之间用逗号隔开。元组不支持修改或删除其所包含的元素。这也是与列表最本质的区别,列表是动态数组,如果想要修改元组中的元素,可先将其转换成列表。

      C++中也引入了元组 tuple, 可以定义任意多个类型的对象的组合,下面是 C++ tuple 的栗子。

    #include <iostream>  
    #include <vector>  
    #include <string>  
    #include <tuple>  
      
    using namespace std;  
      
    std::tuple<std::string, int>  
    giveName(void)  
    {  
        std::string cw("Caroline");  
        int a(2013);  
        std::tuple<std::string, int> t = std::make_tuple(cw, a);  
        return t;  
    }  
      
    int main()  
    {  
        std::tuple<int, double, std::string> t(64, 128.0, "Caroline");  
        std::tuple<std::string, std::string, int> t2 =  
                std::make_tuple("Caroline", "Wendy", 1992);  
      
        //返回元素个数  
        size_t num = std::tuple_size<decltype(t)>::value;  
        std::cout << "num = " << num << std::endl;  
      
        //获取第1个值的元素类型  
        std::tuple_element<1, decltype(t)>::type cnt = std::get<1>(t);  
        std::cout << "cnt = " << cnt << std::endl;  
      
        //比较  
        std::tuple<int, int> ti(24, 48);  
        std::tuple<double, double> td(28.0, 56.0);  
        bool b = (ti < td);  
        std::cout << "b = " << b << std::endl;  
      
        //tuple作为返回值  
        auto a = giveName();  
        std::cout << "name: " << get<0>(a)  
                << " years: " << get<1>(a) << std::endl;  
      
        return 0;  
    } 
    

    输出结果:

    num = 3  
    cnt = 128  
    b = 1  
    name: Caroline years: 2013  
    

    5. 范数

    给定矩阵 X = [ x i j ] n × m \mathbf{X} = [x_{ij}]_{n \times m} X=[xij]n×m,其 l p l_p lp 范数定义为

    ∥ X ∥ p = ( ∑ i j ∣ x i j ∣ p ) 1 p (1) \|\mathbf{X}\|_p = \left (\sum_{ij} \vert x_{ij} \vert ^p \right)^{\frac{1}{p} \tag{1}} Xp=(ijxijp)p1(1)

    源码:|\mathbf{X}|p = \left (\sum{ij} \vert x_{ij} \vert ^p \right)^{\frac{1}{p} \tag{1}}

    5.1 l 0 l_0 l0 范数

    计算非零项个数。

    ∥ X ∥ 0 = ∣ { ( i , j ) ∣ x i j ≠ 0 } \|\mathbf{X}\|_0 = \vert \{(i, j) \vert x_{ij} \neq 0\} X0={(i,j)xij=0}

    5.2 l 1 l_1 l1 范数

    计算绝对值之和。

    ∥ X ∥ 1 = ∑ i j ∣ x i j ∣ \|\mathbf{X}\|_1 = \sum_{ij} \vert x_{ij} \vert X1=ijxij

    5.3 l 2 l_2 l2 范数

    计算平方和。

    ∥ X ∥ 2 2 = ∑ i j x i j 2 \|\mathbf{X}\|_2^2 = \sum_{ij} x_{ij}^2 X22=ijxij2

    5.4 l ∞ l_\infty l 范数

    ∥ X ∥ ∞ = max ⁡ i j ∣ x i j ∣ \|\mathbf{X}\|_\infty = \max_{ij} \vert x_{ij} \vert X=ijmaxxij
    ∥ X ∥ − ∞ = min ⁡ i j ∣ x i j ∣ \|\mathbf{X}\|_-\infty = \min_{ij} \vert x_{ij} \vert X=ijminxij

    源码:||\mathbf{X}||{\infty} = \max{i, j} \vert x_{ij} \vert \tag{6}.

    题目:假设矩阵 A \mathbf{A} A,计算各个范数。

    [ 1 0 2 3 − 1 − 3 ] \left[ \begin{matrix} 1 & 0 & 2 \\ 3 & -1 & -3 \end{matrix} \right] [130123]

    l 0 l_0 l0 = 5;
    l 1 l_1 l1 = 1 + 2 + 3 + 1 + 3 = 13;
    l 2 = 1 + 4 + 9 + 1 + 9 = 24 = 2 6 l_2 = \sqrt{1 + 4 + 9 + 1 + 9} = \sqrt{24} = 2\sqrt{6} l2=1+4+9+1+9 =24 =26 ;
    l ∞ l_\infty l = 3;
    l − ∞ l_{-\infty} l = 0;

    原文链接:向量/矩阵的范数


    6. min 与 argmin

    原文链接: 7. min 与 argmin

      min 即获得集合中的最小值,argmin 即获取函数取最小值时的参数

      在基于用户、商品信息的评分预测任务中,有评分矩阵 R \mathbf{R} R,用户信息表 X = [ x 1 , … , x n ] T = [ x i j ] n × d u \mathbf{X} = [\mathbf{x}_1, \dots, \mathbf{x_n}]^\mathrm{T} = [x_{ij}]_{n \times d_u} X=[x1,,xn]T=[xij]n×du,商品信息表 T = [ t 1 , … , t m ] T = [ t i j ] m × d t \mathbf{T} = [\mathbf{t}_1, \dots, \mathbf{t_m}]^\mathrm{T} = [t_{ij}]_{m \times d_t} T=[t1,,tm]T=[tij]m×dt,其中 d u d_u du 是用户的属性数, d t d_t dt 是商品属性数。输出函数 f : R d u × R d t → R f: R^{d_u} \times R^{d_t} \to R f:Rdu×RdtR
    有以下优化目标:
    min ⁡ ∑ ( i , j ) ∈ Ω ( f ( x i , t i ) − r i j ) 2 \min \sum_{(i,j) \in \Omega} \left(f(\mathbf{x}_i, \mathbf{t}_i ) - r_{ij} \right)^2 min(i,j)Ω(f(xi,ti)rij)2

      其中对象个数为 ∣ Ω ∣ \vert \Omega \vert Ω,条件属性个数为 d u + d t d_u + d_t du+dt,该优化函数使用 l 2 l_2 l2 范数, r i j r_{ij} rij 为真实的评分, f ( x i , t i ) f(\mathbf{x}_i, \mathbf{t}_i) f(xi,ti) 为预测的评分,其优化目标就是最小化预测评分和实际评分的差值和的平方。


      想了解更专业的离散数学集合、关系、元组相关概念,请移步 minfanphd的博客

    展开全文
  • Python元组和集合

    2021-01-10 19:49:55
    集合2.1 什么是集合2.2 集合的创建2.2 集合的增、删、改、查操作2.2.1 集合元素的判断操作2.2.2 集合元素的新增操作2.2.3 集合元素的删除操作2.3 集合生成式2.3.1 集合间的相关关系2.3.2 集合的数据操作2.3.3 集合...

    1. 元组

    1.1 什么是元组

    Python内置的数据结构之一,是一个不可变序列。
    例如: t=(‘python’,‘hello’,90)

    1.1.1 不可变序列与可变序列

    不可变序列:没有增、删、改的操作。
    例如:字符串、元组。
    可变序列
    可以对序列执行增、删、改操作,对象地址不发生更改。
    例如:列表、字典、集合。

    # 可变序列:列表、字典
    lst=[10,20,45]
    print(lst,id(lst))
    lst.append(30)
    print(lst,id(lst))
    
    # 不可变序列:元组、字符串
    s='hello'
    print(s,id(s))
    s=s+'world'
    print(s,id(s))
    

    1.1.2 元组的创建方式

    1. 直接小括号 t=(‘python’,‘hello’,90)
    2. 使用内置函数t=tuple((‘python’,‘hello’,90))
    3. 只包含一个元组的元素需要使用小括号和逗号 t=(10,)
    # 元组的创建方式
    '''第一种 使用小括号()'''
    t=('python','world',20)
    print(t,type(t))
    
    t='python','world',20  # 元组的小括号可以省略
    print(t,type(t))
    
    t=('python',) # 如果元组种只含有一个元素,要加上逗号
    print(t,type(t))
    
    '''第二种创建方式 使用内置函数tuple()'''
    t=tuple(('python','world',20))
    print(t,type(t))
    
    '''空列表的创建方式'''
    lst=[]
    lst1=list()
    print(lst)
    print(lst1)
    
    '''空字典的创建方式'''
    d={}
    d1=dict()
    print(d)
    print(d1)
    
    '''空元组的创建方式'''
    t=()
    t1=tuple()
    print(t)
    print(t1)
    

    为什么要将元组设计成不可变序列?
    在多任务环境下,同时操作对象时不需要加锁,因此,在程序种尽量使用不可变序列。

    注意事项:元组中存储的是对象的引用
    a)如果元组中对象本身是不可变对象,则不能再引用其他对象。
    b)如果元组中对象本身是可变对象,则可变对象的引用不允许改变,当数据可以改变。

    t=(10,[20,30],9)
    print(t)
    print(type(t))
    print(t[0],type(t[0]),id(t[0]))
    print(t[1],type(t[1]),id(t[1]))
    print(t[2],type(t[2]),id(t[2]))
    '''尝试将t[1]修改为100'''
    print(id(100))
    #t[1]=100  元组不允许修改元素
    '''由于[20,30]是列表,而列表是可变序列,所以可以向列表中添加元素,而列表的内存地址不变'''
    t[1].append(100)
    print(t,id(t))
    

    1.2 元组的遍历

    元组是可迭代对象,所以可以使用for in 遍历。

    # 获取元组中的元素
    '''第一种方式,通过索引的方式 但是必须知道元组中元素的个数'''
    t=('python','world',98)
    print(t[0])
    print(t[1])
    print(t[2])
    '''第二种方式 for...in  遍历'''
    for item in t:
        print(item)
    

    2. 集合

    2.1 什么是集合

    1. python语言提供的内置数据结构
    2. 与列表、字典一样都属于可变类型的序列
    3. 集合是没有value的字典

    2.2 集合的创建

    1. 直接{ }
      例如 :s={‘python’,‘hello’,90}
    2. 使用内置函数set()
      例如 :s=set(range(6))
    # 集合的创建
    '''第一种创建方式 使用花括号{}'''
    s={2,3,55,6,6} # 集合中的元素不允许重复
    print(s)
    
    '''第二种创建方式 使用内置函数set()'''
    s=set(range(6))
    print(s,type(s))
    s=set([10,20,30]) # 将列表数据类型转换成集合数据类型
    print(s,type(s))
    s=set((10,20,30,40)) # 将元组数据类型转换成集合数据类型
    print(s,type(s))
    s=set('python')  # 将字符串数据类型转换成集合数据类型
    print(s,type(s))
    s=set({12,3,456,8,3})
    print(s)
    
    '''定义空集合'''
    # s={} 类型为dict
    s=set()
    print(s,type(s))
    

    2.2 集合的增、删、改、查操作

    2.2.1 集合元素的判断操作

    in 或 not in

    # 集合元素的判断操作
    s={10,20,30,40,50}
    print(10 in s)
    print(100 in s)
    print(10 not in s)
    print(100 not in s)
    

    2.2.2 集合元素的新增操作

    1. 调用add()方法,一次添中一个元素
    2. 调用update()方法,一次至少添中一个元素
    # 集合元素的新增操作
    '''一次添加一个元素'''
    s.add(80)
    print(s)
    '''一次至少添加一个元素'''
    s.update({200,400,300})
    print(s)
    print(s)
    s.update([12,546,87])
    print(s)
    print(s)
    s.update((45,89,76))
    print(s)
    

    2.2.3 集合元素的删除操作

    1. 调用remove()方法,一次删除一个指定元素,如果指定的元素不存在抛出KeyError
    2. 调用discard()方法,一次删除一个指定元素,如果指定的元素不存在抛出异常
    3. 调用pop()方法,一次删除一个任意元素
    4. 调用clear()方法,清空集合
    # 集合元素的删除操作
    '''一次删除一个指定元素'''
    s.remove(89)
    print(s)
    # s.remove(500) 抛出异常
    s.discard(500)  # 不会抛出异常
    '''一次删除一个任意元素'''
    s.pop()
    print(s)
    s.pop()
    print(s)
    # s.pop(400) 抛出异常 不能指定参数
    '''清空集合'''
    s.clear()
    print(s)
    

    2.3 集合生成式

    2.3.1 集合间的相关关系

    集合是否相等
    可以使用运算符==或!=进行判断
    一个集合是否是另一个集合的子集
    可以调用issubset进行判断B是A的子集
    一个集合是否是另一个集合的超集
    可以调用issuperset进行判断B是A的超集
    两个集合是否没有交集
    可以调用isdisjoint方法进行判断

    # 集合间的关系
    '''两个集合是否相等(元素相同,就相等)'''
    s1={10,20,30,40}
    s2={30,40,20,10}
    print(s1==s2)  # True 集合中的元素是无序的
    
    '''一个集合是否是另一个集合的子集'''
    s1={10,20,30,40,50}
    s2={10,20,30}
    s3={10,20,90}
    print(s2.issubset(s1))
    print(s3.issubset(s1))
    
    '''一个集合是否是另一个集合的超集'''
    print(s1.issuperset(s2))
    print(s1.issuperset(s3))
    
    '''两个集合是否没有交集'''
    print(s2.isdisjoint(s3)) # False 有交集为False
    s4={100,200,300}
    print(s2.isdisjoint(s4)) # True  没有交集为True
    

    2.3.2 集合的数据操作

    1. 交集操作
    2. 并集操作
    3. 差集操作
    4. 对称差集操作
    # 集合的数学操作
    '''交集操作'''
    s1={10,20,30,40}
    s2={20,30,40,50,60}
    print(s1.intersection(s2))
    print(s1 & s2)
    
    '''并集操作'''
    print(s1.union(s2))
    print(s1 | s2)
    
    '''差集操作'''
    print(s1.difference(s2))
    print(s1-s2)
    
    '''对称差集操作'''
    print(s1.symmetric_difference(s2))
    print(s1^s2)
    

    2.3.3 集合生成式

    集合生成式:生成集合的公式
    i ∗ i f o r i i n r a n g e ( 1 , 10 ) {i* i \quad for\quad i\quad in \quad range(1,10)} iiforiinrange(1,10)
    注:没有元组生成式

    # 集合生成式:生成集合的公式
    s={i*i for i in range(10)}
    print(s)
    
    展开全文
  • Python元组和字典

    2021-07-20 20:13:17
    Python元组和字典 1. 元组 什么是元组(tuple) 元组是容器型数据类型;将()作为容器的标志,里面多个文件用逗号隔开(元素1, 元素2, …) 元组不可变(只能查) 元组有序-支持下标操作 元素:和列表一样 只有...
  • 可以把字符串,数字,字典等都可以任何东西加入到列表,列表的元素之间没有任何关系。列表也是自带下标的,默认也还是从0开始。列表常用方括号表示,即:[],元素用逗号隔开。例子:a = ["huangzhenping","laoma...
  • 2.一旦创建,元组中的元素是不可以修改的 元组可以使用小括号()或者tuple()方法来创建,元素间用逗号分隔。在某些情况下也可以省略小括号,如: def func(): return1,2 //当函数的返回值有多...
  • 一、元组 tuple列表属于可变序列,可以任意修改列表的元素。元组属于不可变序列,不能修改元组中的元素。因此,元组没有增加元素、修改元素、删除元素相关的方法。下面只介绍元组的创建和删除,元组中元素的访问和...
  • erlang元组与列表的区别与联系

    千次阅读 2014-07-23 10:47:38
    在erlang程序设计元组与列表本人很容易混淆,不知道什么时候应该使用元组,什么时候应该使用列表,为此,我查阅了一些网上的资料,并添加了一些 自己的理解,如果有理解不到位的地方,欢迎大家指正。 元组: ...
  • 元组和字典

    2018-12-18 09:40:21
    元组 tuple: 元组是不可改变的序列,同list一样,元组可以存放任意类型元素 元组一旦创建将不可改变 元组的表示方式: 用小括号()括起来,单个元素括起来后加逗号(,) 区分单个对象还是元组 创建空元组的字面值...
  • 字符串、列表、元组、字典1.字符串2.列表 1.字符串 1.1 Python的字符串可以使用单引号、双引号和三引号(三个单引号或三个双引号)括起来,遇到重复使用时可以使用反斜杠\转义特殊字符。 使用转义字符: my_str = ...
  • Python元组详解

    千次阅读 2016-08-23 13:56:29
    关于元组 元组是一个元素不可变的容器,这也就意味着,通过他们做hash算法总是得到一个值,而这恰恰是作为键值的必备条件,元组的切片,更新,合并,操作
  • 数据库元组与元数的区别

    千次阅读 2020-04-15 16:37:20
    关系中属性的个数称为“元数”,元组个数称为“基数”。有时也称关系为表格,元组为行,属性为列。元数是指字段的个数,也就是属性的个数,即列数,而基数是行数。 例题1: 在关系模型关系的“元数”(Arity)...
  • c++11的tuple(元组

    2016-05-17 15:15:12
    c++11的tuple(元组) 转自:http://www.cnblogs.com/qicosmos/p/3318070.html 这次要讲的内容是:c++11的tuple(元组)。tuple看似简单,其实它是简约而不简单,可以说它是c++11中一个既简单又...
  • 元组, 字典

    2018-05-10 22:22:22
    元组 tuple 元组是不可改变的序列,同list一样,元组可以存放任意类型的元素, 一但元组生成,则它不可以改变 添加,删除,修改,访问 元组的表示方式 用小括号()括起来,单个元素括起来用逗号(,) 区分是单个...
  • Python列表、元组、字典的异同

    千次阅读 2015-09-30 11:36:38
    Python三种重要的数据类型为:列表、元组、字典。下面比较一下三者的异同点。 1.列表 list是处理一组有序项目的数据结构,即你可以在一个列表存储一个序列的项目。列表的项目。列表的项目应该包括在方...
  • 1.取元组中指定索引的值 my_tuple = ('jay', 18, 180, 'music', 'jay') print my_tuple[0] 2.查找元组中指定元素所在的位置index print my_tuple.index('jay') 3.统计元组中指定元素出现的次数count ...
  • 创建元组元组创建很简单,只需要在括号添加元素,并使用逗号隔开即可tuple = () #空元组tuple2 = ('a','b','c')tuple3 = ('d','e','f')可以用dir(tuple)查看元组支持的操作;元组操作方法及实例...
  • 元组和列表

    2019-04-16 10:01:40
    元组和列表一、序列类型1、序列2、序列类型的6个通用操作符3、序列类型的6个通用函数4、可变与不可变数据类型二、元组1、元组2、元组的用法3、元组的应用场景三、列表1、列表2、列表类型操作函数和方法3、列表推导式...
  • 文章目录 参考: 列表、元组、字典、集合 Python列表、元组、集合、字典的区别和相互转换 列表的一般用法: ...#使用下标索引来访问列表的值,同样你也可以使用方括号的形式截取字符,如下所示: print (lis...
  • 1653关于元组:1、元组属于序列,可以存放任意元素(任意类型对象),且有序(前后位置关系)。2、元组支持整数索引访问其中的数据,也支持切片。3、元组和列表不同是,元组不可变,列表可变。元组不可变,某些操作...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 11,864
精华内容 4,745
关键字:

关系中元组的个数