精华内容
下载资源
问答
  • 关系元组中允许出现重复元组 我怎么感觉这句话是错的啊?? 比如我再Sql server2005 向数据库的table1插入了2个相同的元组,也没有报错啊? 请问倒底是书本错了?还是我理解的有偏差?? ...
  • 满意答案lxy704522013.03.31采纳率:46%等级:11已帮助:8117人1. 解释下述名词关系模型,关系模式,关系实例...3. 为什么关系中允许重复元组?4. 关系与普通的表格、文件有什么区别?5. 广义笛卡尔乘积、等值...

    满意答案

    dcebd7a0de6265b6ccae5ead692f1eab.png

    lxy70452

    2013.03.31

    dcebd7a0de6265b6ccae5ead692f1eab.png

    采纳率:46%    等级:11

    已帮助:8117人

    1. 解释下述名词

    关系模型,关系模式,关系实例,属性,域, 元组,超键,候选键,主键,

    实体完整性规则,参照完整性规则,过程性语言,非过程性语言,无限关系,无穷验证。

    2. 为什么关系中的元组没有先后顺序?

    3. 为什么关系中不允许有重复的元组?

    4. 关系与普通的表格、文件有什么区别?

    5. 广义笛卡尔乘积、等值连接、自然连接三者之间有什么区别?

    6. 设有关系R、S如下:

    关系R 关系S

    A

    B

    C

    A

    B

    C

    a

    b

    c

    b

    a

    d

    b

    a

    d

    d

    f

    g

    c

    d

    e

    f

    h

    k

    d

    f

    g

    试求出R∪S、R-S、R∩S、R S、σA>B(S)和 。

    7. 设有关系R、S如下:

    关系R 关系S

    A

    B

    C

    A

    B

    C

    a

    b

    c

    a

    c

    d

    b

    a

    d

    d

    f

    g

    c

    d

    e

    b

    d

    g

    d

    f

    g

    试求 R S。

    8. 设有关系R、S如下:

    关系R 关系S

    a

    B

    C

    D

    C

    D

    a

    b

    c

    d

    C

    d

    a

    b

    e

    f

    E

    f

    a

    b

    h

    k

    b

    d

    e

    f

    b

    e

    d

    f

    b

    d

    d

    l

    c

    k

    c

    d

    c

    k

    e

    f

    试求R S。

    9. 设有关系数据库(S,SC,C),其中:

    S=S (S#,Sn,Sa,Sex);SC=SC (S#,C#,Cn);C=C (C#,Cn,Tn)

    这里,S#表示学号,Sn表示学生姓名,Sex 表示学生性别,Sa表示学生年龄,C# 表示课程号,Cn表示课程名,Tn表示任课教师姓名。

    试用关系代数表达式表示下列查询语句:

    (1) 查询LI老师所授课程的课程号和课程名称。

    (2) 查询年龄大于23岁的男学生学号和课程名。

    (3) 查询WANG同学不学课程的课程号。

    (4) 查询至少选修了两门课程的学生学号。

    (5) 查询全部学生都选修的课程的课程号和课程名称。

    10. 试用元组演算表达式表示第9题中各个查询语句。

    11. 试用域演算表达式表示第9题中各个查询语句。

    05分享举报

    展开全文
  • 习题1:{0,1,{0,1},{1,2}... 缺点:集合的元素之间可能发生部分数据的重复,给问题的解决增添复杂。 习题2:∅ 的基数是多少? {∅} 呢? ∅是没有元素的集合,因此∅的基数为0。 {∅} 不是空集,该集合里有..

    习题原文链接:minfanphd

    1. 集合

    1.1 朴素的定义

    Definition 1. A set is a collection of elements, and an element is an object in a set.

    集合的两种表示法:
    a) 列举法,如:\small A = \small \{​\small 0,\small 1,\small 2,\small 3,\small 4,\small 5,\small 6,\small 7,\small 8,\small 9\small \};
    b) 谓词法,如:\small O = \small \{​\small x \small \in \small N\small x mod \small 2 = \small 1\small \}.

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

    • 上述集合有4个元素,分别是0、1、{0,1}、{1,2} ,其中元素{0,1}为一个集合,它的元素为0、1,元素{1,2}也为一个集合,它的元素为1、2。
    • 优点:集合中的元素是确定的,且集合可以容纳多种类型的数据。
    • 缺点:判断一个对象是否为指定集合的元素需一一对比;不同的维度出现重复的数据,可能意味着同一对象的重复表达,给问题的解决增添复杂。

    1.2 基数 

    集合 \small A 的基数,即其元素的个数,记为 |\small A|,读的时候,需读成“the cardinality of A”.

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

    • ∅ 是没有元素的集合,因此∅的基数为0。
    • {∅} 不是空集,该集合里有一个∅元素,因此{∅} 的基数为1。

    1.3 笛卡尔积 

    Definition 2. The Cartesian product of \small A_1 \small , \small ... \small , \small A_n is \small A_1  \small \times \small A_2  \small ... \small A_n = \small \{​\small \(\small x_1 \small , \small ... \small , \small x_n\small \) \small | \small x_1 \small \in \small A_1 \small , \small ... \small , \small x_n \small \in \small A_n\small \}.
    笛卡尔积不满足结合律,如 \small A ={\small a}, \small B = {\small b}, \small C = {\small c}.那么 \small A \small \times \small B = {(\small a\small , \small b)}, (\small A \small \times \small B\small \times \small C = ((\small a\small , \small b)\small , \small c), 同理 \small A \small \times (\small B \small \times \small C) = (\small a\small , (\small b\small , \small c)).

    数据集的两种表示法:
    a) 矩阵表示法:记\small D = \small \(\small x_1\small , \small x_2,  \small ... \small , \small x_n\small \)^T,则 \small x_i \small \in \small R^m, 可支持矩阵的相乘,易于表示加权等操作;
    b) 集合与向量混合法:记 \small D = {\small x_1\small , \small x_2,  \small ... \small , \small x_n},其中 \small x_i \small \in \small R^m,元素可随意交换顺序,但不允许两个元素相同。

    1.4 幂集 

    Definition 2. The power set of \small A is given by \small 2^A = {\small B\small |\small B \small \subseteq \small A}.
    例:\small A = {1,2,3}, \small 2^A = {\small \phi,{1},{2},{3},{1,2},{1,3},{2,3},{1,2,3}}.幂集里的每个元素都是一个集合,另外,\small |\small 2^A\small | = \small 2^{|A|} = \small 2^3 = 8.

    2. 二元关系

    Definition 3. Let \small A and \small B be two sets. Any \small R\small \subseteq \small A \small \times \small B is a binray relation. 
    例如二元关系\small :=\small \{​\small {(x,y)} \small \in \small R^2 \small | \small x=y\small \}.

    3. 函数

    Definition 4. Let \small V_1\small ,...V_m be the domain of conditional attribute \small a_1,...,a_m,  respectively, and \small L  be the set of classes. A classifier is a function \small f:V_1\times...\times \small V_m\small \rightarrow\small L.
    需注意:函数的定义域、值域都是集合;对于函数定义域上的每个点,均在值域中有一个唯一的点与之对之,反之不然。因此,函数的逆函数不一定存在,若逆函数存在,就是一一映射。

    习题 5: 多标签学习中, 输出为一个向量,相应的学习器算不算函数呢? 

    • 算函数。在多标签学习的学习器中,输入数据形式一定(如图像、音频),输出数据为向量,映射关系是一定的,符合函数的性质:定义域上的每个点,均在值域中有一个唯一的点与之对之的关系。

    4. 元组

    需注意:元组用\small ();向量既可用\small (), 也可用\small [];集合用\small {}\small {\left \{ \right \}}.

    元组的各个部分,既可以是个集合,也可以是一个基本元素。图 (Graph) 就是最经典的二元组,因为一个图由两个元素确定,即顶点\small (V)和边\small (E).
    a) 定义有向图:
    directed graph is a tuple \small G_d = \small (V,E), where \small V=\small {}\small \{​\small v_1,...,v_n\} is the set of nodes, and \small E\subseteq V\times V is the set of edges.

    b) 定义无向图:
    An undirected graph is a tuple \small G_u = \small (V,E), where \small V=\small {}\small \{​\small v_1,...,v_n\} is the set of nodes, \small E\subseteq V\times V is the set of edges, and \small \langle \small v_i \small , \small v_j\small \rangle \small \in \small E iff  \small \langle \small v_j \small , \small v_i\small \rangle \small \in \small E (iff 为if and only if).

    c) 定义带权有向图:
    weighted directed graph is a tuple \small G_w=(V,w), where \small V=\small {}\small \{​\small v_1,...,v_n\} is the set of nodes, and\small w:V\times V\rightarrow R^+\cup \small \{0\small \}  is the edge weight function.
    \small R^+ 表示正实数, 不包括 0, 所以只有把 0 加进来, 表示非负实数;若限定\small w只能取0或1,即\small w:V\times V\rightarrow \{0,1\},带权有向图就退化为有向图。

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

    • 可以完整的表达一个对象。在Python中,有多种方式表示对象,元组只是其中的一个。
    # 对象属性为name、age、height
    >>> student=('jack',18,170.0)
    >>> student
    ('jack', 18, 170.0)
    >>> student[1]
    18
    # tuple不能修改
    >>> student[2]=175.0
    TypeError: 'tuple' object does not support item assignment

    5. 字母表、二叉树、树 

    5.1 字母表

    Definition 11. An alphabet \small \Sigma is a set of characters. 常见的字母表包括:\small \Sigma = {0,1}, \small \Sigma = {a,...,z}.

    字母表的正闭包定义如下:
    Definition 12. The positive closure of alphabet \small \Sigma is given by \small \Sigma^+ = \small \Sigma^1 \small \cup \small \Sigma^2 \small \cup \small ....若 \small \Sigma ={0,1}, 那么 \small \Sigma^+ = {0,1,00,01,10,11,000,\small ...}, 若 \small \Sigma = {\small \mathrm{l},\small \mathrm{r}}, 那么 \small \Sigma^+ = {\small \mathrm{l},\small \mathrm{r},\small \mathrm{ll},\small \mathrm{lr},\small \mathrm{rl},\small \mathrm{rr},\small \mathrm{lll},\small ...}.

    字母表的克林闭包(考虑空串\small \varepsilon)定义如下:
    Definition 13. The Cling closure of alphabet \small \Sigma is given by \small \Sigma^* = \small \Sigma^0 \small \cup \small \Sigma^+ = {\small \varepsilon\small \cup \small \Sigma^+.字母表克林闭包的元素,就称为字符串.

    5.2 二叉树

    习题 7: 定义二叉树.

    • 参照闵老师的定义:https://blog.csdn.net/minfanphd/article/details/116245485?spm=1001.2014.3001.5501
    • 初始版本:Let \small \Sigma = \small \{​\small \mathrm{l} \small , \small \mathrm{r}\small \} be the alphbet and \small \phi be a null node. A binary tree is a triple \small T \small \(\small V \small , \small r \small , \small c\small \), where \small V =  \small \{​\small v_1 \small , \small ... \small , \small v_n\small \} is the set of nodes, \small r \small \in \small V is the root, and c \small : \small V \small \cup \small \{​\small \phi\small \} \small \times \small \Sigma^+ \small \to \small V \small \cup \small \{​\small \phi\small \} satisfying
      a) \small c\small \(\small \phi \small , \small \mathrm{l}\small \) = \small c\small \(\small \phi \small , \small \mathrm{r}) = \small \phi;
      b) \small \forall v \small \in \small V \small \setminus \small \{​\small r\small \}\small \exists 1 s \small \in \small \Sigma^+ st. \small c\small \(\small r \small , \small s ) = \small v;
      c) \small \forall_v\in V,\small a\in\Sigma,c(v,a)\neq r.
    • 打磨版本:Let \small \Sigma = \small \{​\small \mathrm{l} \small , \small \mathrm{r}\small \} be the alphbet and \small \phi be a null node. A binary tree is a triple \small T \small \(\small V \small , \small r \small , \small c\small \), where \small V =  \small \{​\small v_1 \small , \small ... \small , \small v_n\small \} is the set of nodes, \small r \small \in \small V is the root, and c \small : \small V \small \cup \small \{​\small \phi\small \} \small \times \small \Sigma^* \small \to \small V \small \cup \small \{​\small \phi\small \} satisfying
      \small \forall v \small \in \small V\small \exists 1 s \small \in \small \Sigma^* st. \small c\small \(\small r \small , \small s ) = \small v;
      若仅保留初始版本中的 b), 会出现 bug. 反例: \small V\small \{​\small \mathrm{r}\small \}\small c\small \(\small r \small , \small \mathrm{l}) = \small c\small \(\small r \small , \small \mathrm{r}) = \small \phi\small c\small \(\small \phi \small , \small \mathrm{l}) = \small c\small \(\small \phi \small , \small \mathrm{r}) = \small \phi.
      \small c\small \(\small r \small , \small \varepsilon) = \small r, 即从 \small r 读入空串到自己.

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

    • weighted undirected graph is a tuple \small G_w = \small (\small V \small , \small E \small , \small w\small ), where \small V = \small \{​\small v_1 \small , \small ... \small , \small v_n\small \} is the set of nodes, \small E \small \subseteq\small V \small \times \small V is the set of edges, \small w:V\times V\rightarrow R^+\cup \small \{0\small \}  is the edge weight function, and \small \langle \small v_i \small , \small v_j\small \rangle \small \in \small E iff  \small \langle \small v_j \small , \small v_i\small \rangle \small \in \small E.

    5.3 树

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

    • Definition 7. A tree is a triple \small T = \small \(\small V \small , \small r \small , \small p\small ), where \small V =  \small \{​\small v_1 \small , \small ... \small , \small v_n\small \} is the set of nodes,\small r\in V is the root, and p:(V\cup\{\phi\}) \setminus \{r\}\rightarrow(V\cup\{\phi\}) satisfying
      a) \small \forall v \small \in \small V\small \forall\small k\geq 1\small p^k(v) \small \neq \small v;
      b) \small \forall\small v \in V \small \setminus \{r\}\small \exists 1 \small k\geq 1, st.\small p^k(v) = \small r;
      c) \small \forall v\in V \small \setminus \{r\}p(v) \neq \small \phi.
      此定义与 Amaris-Bunny讨论、交流完成,如有错误,还请指正!

    6. 自动机描述

    确定的有穷状态自动机定义如下:
    A deterministic finite state automata (DFA) is a 5-tuple \small M = \small (\small \Sigma \small , \small Q \small , \small q_0 \small , \small T \small , \small f\small ), where
    a) \small \Sigma is the alphabet;
    b) \small Q is the set of states;
    c) \small q_0 \small \in \small Q is the start state;
    d) \small T \small \subseteq \small Q is the set of terminal states;
    e) \small f \small : \small Q \small \times \small \Sigma^*\small \rightarrow\small Q is the transition function.
    Any \small s \small \in \small \Sigma^* is accepted by the automata iff \small f\small (q_0,s) \small \in \small T.

    说明:
    a) DFA 的开始状态只有一个, 因此为\small Q的元素;
    b) DFA 的终止状态可以有多个, 因此为\small Q的子集;
    c) DFA 的基础目标是看状态 \small s 是否合法 (被接受).

    6.1 二叉树的自动机描述

    如果将二叉树看作是一个自动机, 它包括如下几个方面:
    a) 有一个字母表, 即(\mathrm{l} , \mathrm{r});
    b) 有一个状态集合, 包括所有节点与空节点;
    c) 有一个开始状态, 即根节点 r;
    d) 有一个终止状态, 即空节点 \phi;
    e) 从任一状态读入任一字母, 确定地转移到下一状态 (可以是自己), 这个用状态转移函数来描述.
    通过分析可以看出, 二叉树在其中 4 点都与自动机完全契合, 唯一有问题的是终止状态. 二叉树本身没有一个“判断字符串是否合法”的目标,因此不存在终止状态. 但它又有一个特殊的状态, 即 \phi.

    习题 3.1 模仿自动机的样子来重新定义二叉树.

    • A binary tree is a 6-tuple \small T = \small (\small \Sigma \small , \small Q \small , V \small , r \small , \phi \small , \small f\small ), where
      a) \small \Sigma = \small \{​\small \mathrm{l} \small , \small \mathrm{r}\small \} is the alphabet;
      b) \small Q = V\small \cup\{\phi\} is the set of states,and \phi is a null node;
      c) \small V =  \small \{​\small v_1 \small , \small ... \small , \small v_n\small \} is the set of nodes;
      d) r \small \in \small V is the start state(root);
      e) \phi is the special terminal states;
      f) \small f \small : \small Q \small \times \small \Sigma^*\small \rightarrow \small Q is the transition function, satisfying
      \small \forall v \small \in \small V\small \exists 1 s \small \in \small \Sigma^* st. \small c\small \(\small r \small , \small s ) = \small v;

    6.2 树的自动机描述

    如果将树看作是一个自动机, 它包括如下几个方面:
    a) 有一个状态集合, 包括所有节点与空节点;
    b) 有多个开始状态, 即V;
    c) 有一个终止状态, 即r;
    d) 树中所有节点有0或多个后继,,即父节点的分支数目不确定,无法通过父节点准确的找到相应的子节点,而每个子节点有且只有唯一的一条路径到达父节点.

    习题3.2 模仿自动机的样子来重新定义树.

    • A tree is a 5-tuple \small T = \small (\small Q \small , V \small , r \small , \phi \small , p\small ), where
      a)  \small Q = V\small \cup\{\phi\} is the set of states,and \phi is a null node;
      a) \small V =  \small \{​\small v_1 \small , \small ... \small , \small v_n\small \} is the set of nodes, and \small V is the set of start states;
      b) r \small \in \small V is the terminal state;
      c) \phi is a special state;
      d) p :  \small Q \small \times \small \Sigma^*\small \rightarrow \small Q is the transition function, satisfying
      \small \forall\small v \in V\small \exists 1 s \small \in \small \Sigma^*, st.p(v,s) = \small r;

      如有错误,还请指正!

    展开全文
  • 包括一个运算的集合,集合运算以一个或两个关系为输入,产生一个新的关系作为结果。 关系代数的基本运算包括:选择、投影、并、集合差、笛卡尔积、更名。 其他运算:集合交、自然连接、赋值,可用基本运算来定义...

    关系代数

    关系代数(relational algebra):一种过程化查询语言。包括一个运算的集合,集合中运算以一个或两个关系为输入,产生一个新的关系作为结果。

    关系代数的基本运算包括:选择、投影、并、集合差、笛卡尔积、更名。

    其他运算:集合交、自然连接、赋值,可用基本运算来定义。

    关系运算的结果自身也是一个关系,可用一个关系运算表达式作为另一个关系运算的参数,因此可以把多个关系代数运算组合成一个关系代数表达式(relational-algebra expression

     

    关系代数定义了一套在表上运算且输出结果也是表的代数运算。这些运算可以混合使用来得到表达所希望查询的表达式。关系代数定义了关系查询语言中使用的基本运算。

    关系代数运算可分为:基本运算、附加的运算(可用基本运算表达)、扩展的运算(其中一些扩展了关系代数的表达能力)。

    关系代数是一种简介的、形式化的语言,不适用于那些偶尔使用数据库系统的用户,因此商用数据库系统采用有更多“语法修饰”的语言。(SQL基于关系代数)

     

    1. 基本运算

    一元运算:对一个关系进行运算,包括选择、投影、更名运算。

    二元运算:对两个关系进行运算,包括并、集合差、笛卡尔积运算。

     

    选择(select)运算选出满足给定谓词的元组,用小写sigma(σ)表示,下标为谓词,括号中为参数关系。

    e.g. 找出关系instructor中属于物理系的所有教师

    σdept_name=”Physics”(instructor)

    e.g. 找出工资额大于90000美元的所有教师

    σsalary>90000(instructor)

    可用连词and(∧)、or(∨)、not(¬)将多个谓词合并为一个较大的谓词。

    e.g. 找出属于物理系且工资大于90000美元的所有教师

    σdept_name=”Physic”salary>90000(instructor)

    选择谓词中可包括两个属性的比较。

    e.g. 找出所有系名与楼名相同的系

    σdept_name=building(department)

    注意:关系代数中的属于select与SQL中的关键词select含义不同,关系代数中属于select对应SQL中的where。

     

    投影(project)运算:返回作为参数的关系,但把某些属性排除在外,所有重复行均被去除。用大写pi(Π)表示,下标为在结果中出现的属性,括号中为参数关系。

    e.g. 列出所有教师的ID、name和salary,而不关系dept_name。

    ΠID, name, salary(instructor)

    e.g. 找出物理系所有教师的名字

    Πnamedept_name=”Physics”(instructor))

     

    并(union)运算: 可将两个集合并起来,找出出现在两个集合之一或同时出现在两个集合中的所有元组。用表示。

    e.g. 找出开设在2009年秋季学期或者2010年春季学期或者这二者皆开的所有课程的集合。

    Πcourse_idsemester=”Fall”year=2009(section))∪Πcourse_idsemester=”Spring”year=2010(section))

    /*注意:结果中重复值只留下单个元组。*/

    必须保证做并运算的关系是相容的,否则运算结果没有意义。要使并运算rs有意义(rs可以是数据库关系或作为关系代数表达式结果的临时关系),要求以下两个条件同时成立:

    a. 关系r和s必须是同元的(属性数目相同)。

    b. 对所有的i,r的第i个属性的域必须和s的第i个属性的域相同。

     

    集合差(set-difference)运算:表达式r-s包含所有在r中而不在s中的元组的关系。

    e.g. 找出所有开设在2009年秋季学期但是在2010年春季学期不开的课程。

    Πcourse_idsemester=”Fall”year=2009(section))-Πcourse_idsemester=”Spring”year=2010(section))

    类似并运算,必须保证做集合叉运算的关系是相容的,否则运算结果没有意义。要使集合差运算r-s有意义,要求一下两个条件同时成立:

    a. 关系r和s必须是同元的。

    b. 对所有的i,r的第i个属性的域必须和s的第i个属性的域相同。

     

    笛卡尔积(Cartesian-product)运算:将任意两个关系的信息组合在一起,结果中包含所有可能的元组对。关系r1和r2的笛卡尔积写作r1×r2,假如r1有n1个元组,r2有n2个元组,则可由n1×n2种方式选择元组对。

    由于相同的属性名可能同时出现在r1和r2中,需要一个命名机制来区别这些属性。可采用把属性所来自的关系名称附加到该属性上的方法。

    e.g. r = instructor×teaches的关系模式

    (instructor.ID, instructor.name, instructor.dept_name, instructor.salary, teaches.ID, teaches.course_id, teaches.sec_id, teaches.semeser, teaches.year)

    /*对于只在两个关系模式之一出现的属性,通常省略其关系名前缀。因此可将r的关系模式写作:*/

    (instructor.ID, name, dept_name, salary, teaches.ID, course_id, sec_id, semester, year)

    注意:该命名规则规定作为笛卡尔积运算参数的关系名称必须不同,因此当某个关系要与自身做笛卡尔积或在笛卡尔积中使用关系代数表达式结果时可能产生问题,可通过更名运算给关系一个名字以引用其属性来解决。

    e.g. 找出物理系中的所有教师,以及他们所教授的所有课程。

    /* σdept_name=”Physics”(instructor×teaches)只包含物理系的教师的元组,但course_id列可能包含并非这些教师所教授的课程;

    σinstructor.ID=teaches.IDdept_name=”Physics”(instructor×teaches))包含物理系教师以及他们所教的课程的元组;

    Πname, course_idinstructor.ID=teaches.IDdept_name=”Physics”(instructor×teaches)))投影得到需要的教师名字列和corse_id列。*/

    Πname, course_idinstructor.ID=teaches.IDdept_name=”Physics”(instructor×teaches)))

    /*用关系代数表达查询的方法并不唯一,也可采用如下等价查询:*/

    Πname, course_idinstructor.ID=teaches.ID((σdept_name=”Physics”(instructor))×teaches))

     

    更名(rename)运算:给关系代数表达式的结果赋上名字以供引用,用小写rho(ρ)表示。

    表达式ρx(E)返回给定关系代数表达式E的结果并把名字x赋给它。更名运算也可用于关系,可得到具有新名字的一个相同的关系。

    更名运算的另一形式:ρx(A1, A2, …, An)(E)。假设关系代数表达式E是n元的,运算返回表达式E的结果,并把名字x赋给它,同时将各属性更名为A1, A2, …, An

    e.g. 找出大学里的最高工资

    /*步骤1:计算出一个由非最高工资组成的临时关系。

    首先通过更名运算引用其中一个instructor关系以便计算笛卡尔积instructor×instructor,再构造选择运算比较任意两个出现在同一元组中的salary选择较低的元组。通过投影选取instructor.salary列得到非最高工资构成的临时关系*/

    Πinstructor.salaryinstructor.salary<d.salary(instructor×ρd(instructor)))

    /*步骤2:计算关系Πsalary (instructor)和刚才计算出的非最高工资构成的临时关系的集合差,得到结果。*/

    Πsalary (instructor)-Πinstructor.salaryinstructor.salary<d.salary(instructor×ρd(instructor)))

     

    更名运算不是必须的,因为可以用位置标记隐含地作为关系(或关系代数表达式运算的结果)的属性名,用$1、$2、…指代第一个属性、第二个属性…以此类推。

    e.g. 用位置标记来计算大学里的非最高工资构成的临时关系

    /*在笛卡尔积(instructor×instructor)中,$4代表第一个instructor的属性salary,$8代表第二个instructor的属性salary。*/

    Π$4$4<$8(instructor×instructor))

    如果一个二元运算需要区分其运算对象的两个关系,也可使用为指标及作为关系的名称。E.g. $R1指代第一个作为运算对象的关系,$R2指代第二个关系。

     

     

    2. 关系代数的形式化定义

    关系代数中基本的表达式是以下二者之一:a. 数据库中的一个关系;b. 一个常数关系。

     

    常数关系:可在{}内列出其元组来表示。

    E.g. {(22222, Einstein, Physics, 95000), (76543, Singh, Finance, 80000)}

     

    设E1和E2都是关系代数表达式,则以下这些都是关系代数表达式:

    ·E1∪E2

    ·E1-E2

    ·E1×E2

    ·σp(E1),P为E1属性上的谓词。

    ·ΠS(E1),S为E1上某些属性的列表。

    ·ρx(E1),x为E1结果的新名字。

     

     

    3. 附加的关系代数表达式

    关系代数的基本运算足以表达任何关系代数查询。附加的关系代数运算不能增强关系代数的表达能力,但可以简化一些常用的查询。

     

    集合交(intersection)运算 ()

    e.g. 找出在2009年秋季和2010年春季都开设的课程

    Πcourse_idsemester=”Fall”year=2009(section))∩Πcourse_idsemester=”Spring”year=2010(section))

    任何使用了集合交的关系代数表达式都可以通过一对集合差运算替代重写:

    r∩s=r-(r-s)

     

    自然连接(natural join)运算 ():首先形成两个参数关系的笛卡尔积,然后基于两个关系模式中都出现的属性上的相等性进行选择(只考虑两个关系在所有相同属性有相同值的元组组成的元组对),最后去除重复属性(并不重复记录在两个关系模式中都出现的属性)。

    自然连接的形式化定义:

    设r(R)和s(S)(模式分别为R和S的两个关系),其自然连接的结果r ⋈ s是模式R∪S上的一个关系。

    r ⋈ s = ΠRSr.A1=s.A1r.A2=s.A2r.An=s.An(r×s)),其中R∩S={A1, A2, …, An}。

    如果r和s不含有任何相同属性,即R∩S=∅,则r ⋈ s = r×s。

    所列出的属性的顺序:两个关系模式的相同属性排在最前,只属于第一个关系模式的属性其次,只属于第二个关系模式的属性最后。

    e.g. 找出所有教师的姓名,连同他们教的所有课程的course_id。

    /*instructor和teaches自然连接的结果模式为(ID, name, dept_name, salary, course_id),投影后得到模式为(name, course_id)的关系。*/

    Πname, course_id(instructor ⋈ teaches)

     考虑两个关系模式R和S,可将关系模式看作集合:用R∩S表示同时出现在R和S中的属性名,用R∪S表示出现在R中、S中或在二者中都出现的属性名,用R-S表示出现在R中而不出现在S中的属性名,用S-R表示出现在S中而不出现在R中的属性名。

    自然连接时可结合的(associative)。

    e.g. 找出计算机系的所有教师,以及他们教授的所有课程的名称。

    /* 自然连接instructor ⋈ teaches ⋈ course的执行顺序可能为

    (instructor ⋈ teaches) ⋈ course 或 instructor ⋈ (teaches ⋈ course),二者是等价的。*/

    Πname, titledept_name=”Comp.Sci.”(instructor ⋈ teaches ⋈ course))

     theta连接(theta join)运算:是自然连接的扩展。

    考虑关系r(R)和s(S),θ是模式R∪S的属性上的谓词。r ⋈θ s = σθ(r×s)

     

    赋值(assignment)运算 ():可用于给临时关系变量赋值,便于写关系代数表达式。

    e.g. 自然连接运算r ⋈s的定义可写作

    temp1←r×s

    temp2←σr.A1=s.A1r.A2=s.A2r.An=s.An(temp1)

    result = ΠRS(temp2)

    对关系代数查询而言,赋值必须是赋给一个临时关系变量。对永久关系的赋值形成了对数据库的修改。

     

    外连接(outer-join)运算:连接运算的扩展,可处理缺失的信息(因为不满足自然连接条件而不能在自然连接结果中找到的元组),避免信息的丢失。

    外连接运算与自然连接运算类似,不同之处在于外连接在连接计算结果中添加额外的带空值的元组,以此保留在连接中丢失的元组。

    外连接运算有三种形式:

    左外连接(left outer join)():取出左侧关系中所有与右侧关系的任一元组都不匹配的元组,用空值填充所有来自右侧关系的属性,再把产生的元组加到自然连接的结果中。所有来自左侧关系的信息在左外连接结果中都得到保留。

    右外连接(right outer join)():与左外连接相对称,用空值填充来自右侧关系的所有与左侧关系任一元组都不匹配的元组,将结果加到自然连接的结果中。所有来自右侧关系的信息在右外连接中都得到保留。

    全外链接(full outer join)():既做左外连接又做右外连接,既填充左侧关系中与右侧关系的任一元组都不匹配的元组,又填充右侧关系中与左侧关系任一元组都不匹配的元组,并把结果都加到连接的结果中。

    注意:外连接运算可用基本关系代数运算表示。E.g. 左外连接运算r⟕s可写作

    /*其中常数关系{(null, …, null)}的模式为S-R。*/

    (r ⋈ s)∪(r - ΠR(r ⋈ s)) × {(null, …, null)}

     

     

    4. 扩展的关系代数运算

    扩展的关系代数(extended relational-algebra)运算可实现一些不能用基本的关系代数运算来表达的查询

     

    广义投影(generalized-projection):通过允许在投影列表使用算术运算和字符串函数等来对投影进行扩展。

    运算形式:

    ΠF1, F2, …, Fn(E)

    其中E为任意关系代数表达式,F1, F2, …, Fn都是涉及常量以及E的模式中属性的算术表达式。

    最基本情况下算术表达式可以仅仅是一个属性或常量,在表达式中可使用对数值属性或产生数值结果的表达式的+、-、*、/等代数运算。广义投影还允许其他数据类型上的运算(如字符串的串接)。

    e.g. 查询每个教师的ID、name、dept_name以及每月的工资

    ΠID, name, dept_name, salary/12(instructor)

     

    聚集运算(?)

    聚集函数(aggregate function):输入值的一个汇集,将单一值作为结果返回。E.g. 聚集函数sum、avg、count、min、max。

    e.g. 使用聚集查询所有教师的工资总和的关系代数表达式

    ? sum(salary)(instructor)

     

    在计算聚集函数前如果想去除重复,可使用连字符将distinct附加在函数名后。

    e.g. 找出在2010年春季学期教课的教师数(每名教师只应计算一次,而不管他教了几门课程。)

    /*聚集函数count-distinct确保:即使某位教师授课多于一门,在结果中也只对他计数一次。*/

    ? count-distinct(ID)semester=”Spring”year=2010(teaches) )

     

    可对一组元组集合(而不是单个元组集合)执行聚集函数。

    聚集运算的通常形式为:

    G1, G2, …, Gn? F1(A1), F2(A2), …, Fm(Am)(E)

    其中E为任意关系代数表达式,G1, G2, …, Gn是用于分组的一系列属性,每个Fi是一个聚集函数,每个Ai是一个属性名。表达式E的结果中的元组被分成若干组,各组用属性G1, G2, …, Gn上的值唯一标识。

    属性列G1, G2, …, Gn可以为空,则唯一一组包含关系中所有的元组(相当于没有分组)。

    e.g. 分别查询a. 每个系教师的平均工资 b. 所有教师的平均工资

    /*先通过dept_name属性对关系instructor进行分组,再对每个分组执行指定查询。*/

    dept_name ? average(salary)(instructor)

    /*从运算符?左边去掉了属性dept_name,整个关系被当做单个组来执行聚集。*/

    ? average(salary)(instructor)

     

    多重集(multiset):使用聚集函数对其进行操作的汇集中,一个值可以出现多次,值出现的顺序是无关紧要的,这样的汇集称为多重集。集合(set)是多重集的特例,其中每个值都只出现一次。

    多重集关系代数(multiset relational algebra):SQL与关系代数不同,允许在输入关系以及查询结果汇总存在元组的多重拷贝。为了映射SQL的这种模式,我们定义了多重集关系代数来对多重集进行操作。

    多重集关系代数基本运算的定义:

    1. 如果在r1元组t1有c1份拷贝,并且t1满足选择σθ,那么在σθ(r1)中元组t1有c1份拷贝;

    2. 对于r1中元组t1的每份拷贝,在ΠA(r1)中都有一个与之对应的ΠA(t1),表示单个元组t1的投影。

    3. 如果在r1中元组t1有c1份拷贝,在r2中元组t2有c2份拷贝,那么在r1×r2中就有元组t1t2的c1*c2份拷贝。

    按照SQL中的相应含义,还可用相似方法定义多重集的并、交、集合差运算。(聚集运算在多重集定义下没有变化)

     

     

    元组关系演算

    不同于关系代数表达式,元组关系演算(tuple relational calculus非过程化的(nonprocedural)查询语言,只描述所需信息,而不给出获得该信息的具体过程。

    元组关系演算中的查询表达为:{ t | P(t) }。含义:所有使谓词P为真的元组t的集合。

     

    1. 查询示例

    e.g. 找出工资大于80000美元的所有教师的ID

    /*所有满足如下条件的元组t的集合:在关系instructor中存在元组s使t和s在属性ID上的值相等,且s在属性salary上的值大于80000美元。

    因为ID属性是对t进行限制的条件所涉及的唯一属性,因此结果只得到ID列上的关系。*/

    { t| ∃s∈instructor( t[ID] = s[ID] ∧ s[salary] >80000 ) }

    e.g. 找出位置在Watson楼的系中的所有教师姓名

    /*元组变量u保证该系位于Watson楼,元组变量s被限制到与u的dept_name相同。结果得到name列上的关系。*/

    { t | ∃s∈instructor( t[name] = s[name]

    ∧∃u∈department( u[dept_name] = s[dept_name]

                         ∧ u[building] = ‘Watson’ ) ) }

    e.g. 找出在2009年秋季学期或2010年春季学期或这两个学期都开设的所有课程的course_id

    /*给出至少满足下面两个条件之一的couse_id元组的集合:

    ·在关系section中满足semester=Fall且year=2009的某个元组包含该course_id;

    ·在关系section中满足semester=Spring且year=2010的某个元组包含该course_id。*/

    { t | ∃s∈section ( t[course_id] = s[course_id] )

         ∧s[semester] = “Fall”∧s[year] = 2009 )

    ∨∃u∈section (u[course_id] = t[course_id] )

         ∧u[semester] = “Spring”∧u[year] = 2010 )

    e.g. 找出只在2009年秋季和2010年春季两个学期都开设的所有课程的course_id

    { t | ∃s∈section ( t[course_id] = s[course_id] )

         ∧s[semester] = “Fall”∧s[year] = 2009 )

    ∧∃u∈section (u[course_id] = t[course_id] )

         ∧u[semester] = “Spring”∧u[year] = 2010 )

    e.g. 找出2009年秋季开设而2010年春季不开的所有课程的course_id

    /*从2009年秋季开设的课程中去掉那些在2010年春季开设的课程*/

    { t | ∃s∈section ( t[course_id] = s[course_id] )

         ∧s[semester] = “Fall”∧s[year] = 2009 )

    ∧¬∃u∈section (u[course_id] = t[course_id] )

         ∧u[semester] = “Spring”∧u[year] = 2010 )

    e.g. 找出所有那些选了生物系全部课程的学生

    /*所有满足如下条件的ID列上的元组t的集合:

    对关系course中所有元组u,如果u在dept_name属性上的值是’Biology’,那么在关系takes中一定存在一个包含该学生ID以及该课程course_id的元组。

    注意:如果生物系没有开设任何课程,则所有学生ID都满足条件。该情况下,∃r∈student ( r[ID] = t[ID] )保证结果是关系student里的学生ID的值。*/

    { t | ∃r∈student ( r[ID] = t[ID] ) ∧

      ∀u∈course (u[dept_name] = “Biology”⇒

    ∃s∈takes ( t[ID] = s[ID]

    ∧s[course_id] = u[course_id] ) ) }

     

     

    形式化定义

    元组关系演算表达式的形式:{ t | P(t) }

    P为一个公式,公式中可出现多个元组变量,如果元组变量不被∃或∀修饰则称为自由变量,否则称为受限变量

    公式由原子构成。原子可以为如下形式之一:

    ·s∈r,其中s为元组变量,r为关系;

    ·s[x] ? u[y],其中s、u为元组变量,x为s所基于的关系模式中的一个属性,y为u所基于的关系模式中的一个属性,?为比较运算符(<, ≤, =, ≠, >, ≥)(要求x和y所属域成员可用?比较);

    ·s[x] ? c,其中s为元组变量,x为s所基于的关系模式中的一个属性,c是属性x所属域中的常量。

    根据如下规则用原子构造公式:

    ·原子是公式;

    ·如果P1是公式,则¬P1和(P1)也都是公式;

    ·如果P1和P2是公式,则P1∨P2、P1∧P2和P1⇒P2也都是公式;

    ·如果P1(s)是包含自由元组变量s的公式,r为关系,则∃s∈r(P1(s))和∀s∈(P1(s))也都是公式。

     

    元组关系演算中的等价性规则:

    ·P1∧P2等价¬(¬(P1)∨¬(P2));

    ·∀t∈r(P1(t))等价¬∃t∈r(¬P1(t));

    ·P1⇒P2等价¬(P1)∨P2

     

     

    元组关系演算表达式的安全性

    为避免元组关系演算表达式产生一个无限的关系,需对元组关系演算进行限制。

    域(domain):元组关系公式P的域用dom(P)表示,是P所引用的所有值的集合。它既包括P自身用到的值,又包括P中所涉及的关系的元组中出现的所有值。(i.e. P中显式出现的值,以及名称出现在P中的那些关系的所有值的集合)。

    如果出现在表达式{ t | P(t) }结果中的所有值均来自dom(P),则表达式是安全的,安全的表达式一定包含有限的结果。

     

    语言表达能力

    限制在安全表达式范围内的元组关系演算和基本关系代数(不包括扩展的关系代数运算符)具有相同的表达能力。

    因此:

    对于每个只运用基本操作的关系代数表达式,都有与之等价的元组关系演算表达式;

    对于每个元组关系演算表达式,也都有与之等价的关系代数表达式。

     

     

    域关系演算

    域关系演算(domain relational calculus):关系演算的另一种形式,使用从属性域中取值的域变量,而不是整个元组的值。

     

    1. 形式化定义

    域关系演算中的表达式形式:

    { <x1, x2, …, xn> | P(x1, x2, …, xn) }

    其中x1, x2, …, xn代表域变量,P代表由原子构成的公式。

    原子可以为如下形式之一:

    ·<x1, x2, …, xn>∈r,其中r为n个属性上的关系,x1, x2, …, xn为域变量或域常量;

    ·x?y,其中x和y为域变量,?为比较运算符(要求属性x和y所属域可用?比较);

    ·x?c,其中x为域变量,c是x作为域变量的那个属性域中的常量。

    根据如下规则用原子构造公式:

    ·原子是公式;

    ·如果P1是公式,则¬P1和(P1)也都是公式;

    ·如果P1和P2是公式,则P1∨P2、P1∧P2和P1⇒P2也都是公式;

    ·如果P1(x)是包含自由域变量x的公式,则∃x(P1(x))和∀x(P1(x))也都是公式。

    我们把∃a,b,c(P(a,b,c))作为a(∃b(∃c(P(a,b,c))))的简写。

     

    2. 查询示例

    e.g. 找出工资在80000美元以上的教师的ID、name、dept_name和salary。

    { <i, n, d, s> | <i, n, d, s>∈instructor∧s>80000 }

    e.g. 找出工资大于80000美元的所有教师的姓名

    { < i > | ∃n, d, s (<i, n, d, s>∈instructor∧s>80000) }

    e.g. 找出在物理系的所有教师的姓名,以及他们教授的所有课程的course_id。

    { <n, c> | ∃i, a, s, y (<I, c, a, s, y>∈teaches

       ∧∃d, s(<i, n, d, s>∈instructor∧d=”Physics”) ) }

    e.g. 找出在2009年秋季学期或2010年春季学期或这两个学期都开设的所有课程的集合

    { < c > | ∃a, s, y, b, r, t(<c, a, s, y, b, r, t>∈section

         ∧s=”Fall”∧y=”2009”)

       ∨∃a, s, y, b, r, t(<c, a, s, y, b, r, t>∈section

         ∧s=”Spring”∧y=”2010”) }

    e.g. 找出选了生物系开设的全部课程的所有学生

    /*如果生物系没开设任何课程,结果将包含所有学生。*/

    { < i > | ∃n, d, tc(<i, n, d, tc>∈student) ∧

      ∀ci, ti, dn, cr(<ci, ti, dn, cr>∈course ∧ dn=“Biology” ⇒

      ∃si, se, y, g(<I, ci, si, se, y, g>∈takes) ) }

     

    表达式的安全性

    不安全的域关系演算表达式的结果中会出现不在表达式域中的值。

    如果下列条件同时成立,则认为表达式{ <x1, x2, …, xn> | P(x1, x2, …, xn) }是安全的:

    1. 表达式的元组中所有值均来自dom(P);

    2. 对每个形如∃x(P1(x))的子公式,子公式为真当且仅当dom(P1)中有某个值x使P1(x)为真;

    3. 对每个形如∀x(P1(x))的子公式,子公式为真当且仅当P1(x)对dom(P1)中所有值x均为真。

     

    语言表达能力

    限制在安全表达式范围内的域关系演算和限制在安全表达范围内的元组关系演算具有相同的表达能力(因此也与基本关系代数的表达能力等价)。

    注意:没有任何一个域关系演算等价于聚集运算,但它可以扩展以支持聚集。

     

    元组关系演算和域关系演算是非过程化语言,代表了关系查询语言所需的基本能力。基本关系代数是一种过程化的语言,在能力上等价于被限制在安全表达式范围内的关系演算的这两种形式。

    关系演算是简介的、形式化的语言,不适合于那些偶尔使用数据库系统的用户。(QBE和Datalog基于元祖关系演算和域关系演算)

    转载于:https://www.cnblogs.com/RDaneelOlivaw/p/8149086.html

    展开全文
  • 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)
    
    展开全文
  • 本片目录元组tuple元组的介绍元组的创建元组与列表相同的操作元组中允许的操作元组与列表之间的转换字典dict集合set下一篇文章 元组tuple 元组的介绍 元组也是序列结构,但是是一种不可变的序列,可以简单理解为...
  • Python元组

    2018-10-16 23:05:09
    目录 创建元组 访问元组 修改元组 删除元组 元组运算符 ...元组内置函数 ...创建元组 ...Python 的元组与列表类似,不同之处...元组创建很简单,只需要在括号添加元素,并使用逗号隔开即可。 list = [1, 2, 3, 4, ...
  • 列表在遍历数据时对于重复的数据我们不进行过滤,直接输出,对于集合而言,遍历时重复的数字不给予遍历,即不会存储在集合,在以下代码会有明显的体现: str1=['ll',1,3.0,3,4] str2={'ll',1,3.0,3,4} for i ...
  • 元组和集合

    2021-03-09 19:37:09
    目录元组创建方式原理元组的遍历集合创建方式相关操作集合间的关系集合的数学操作集合生成式 元组 pyhton内置的数据结构之一,是一个不可变序列,没有增删改操作。包括字符串和元组。 可变序列具有增删改操作,且...
  • 理解Python列表,元组,字典,集合的区别

    万次阅读 多人点赞 2017-02-21 18:18:03
    列表,元组,字典,集合的区别是python面试最常见的一个...由于我们买一种东西可能不止一次,所以清单允许重复项的。如果我们扩大清单的范围,统计我们过去一周所有的花费情况,那么这也是一个清单,但这个清
  • python字典、元组

    2020-08-22 19:46:39
    一、元组 元组是python的一个重要序列结构,属于不可变序列,一旦创建,没有任何方法可以修改元组中...元组在内部实现上不允许修改其元素值,从而使得代码更加安全,例如,使用函数时使用元组传递参数可以防止在函数
  • 理解Python列表,元组,字典,集合的区别 列表,元组,字典,集合的区别是python面试最常见的一个问题。这个问题虽然很基础,但确实能反映出面试者的基础水平。 1.列表(List)  什么是列表呢?我觉得列表...
  • 列表,元组,字典,集合的区别是python面试最常见的一个问题。这个问题虽然很基础,但确实能反映出面试者的基础水平。 1.列表(...
  • 元组、集合

    2021-09-27 15:47:34
    # -*- coding: utf-8 -*- # @Time : 2021/9/27 14:25 # @Author : 李新宇 # @FileName: demo1.py # @Software: PyCharm ...'''不可变序列,字符串,元组''' s='hello' print(id(s)) s=s+'world' print(id.
  • 元组基础 # # 主题:元组基础 # if __name__ == '__main__': # 元组是不可变序列,没有增删改操作 # 修改不可变序列后,会生成新的对象,储存在新的位置 # 可变序列:列表、字典 # 不可变序列:字符串、元组 ...
  • #关于元组: #列表推导式 #字符串是数字有序序列 #字符串里面的元素是只读的 #和列表比较:列表里面的元素是可以修改的 #字符串为不变类型,相同值指向同一个对象 #节约内存 #比如: s1="123" s2="123" print(id(s1...
  • 序列是具有先后关系的一组元素,它是一维元素向量,元素类型可以不同。元素间由序号引导,通过下标访问序列的特定元素。 序列是一个基类类型,元组、列表是序列类型的一种扩展,继承序列类型的全部通用操作。 ...
  • 一、元组介绍 元组(tuple)是无法修改的其他对象的结合.元组由简单的对象构成,元组与列表类似,不过元组不能在原处修改。通常写成圆括号的一系列项。...同字符串,列表一样,在元组中的元素通过偏...
  • ·括号 把所有元素绑在一起 ·逗号 将每一个元素一一分开 2.列表的创建 ·创建一个普通列表 【例子】 x = ['Monday', 'Tuesday', 'wednesday', 'Thursday', 'Friday'] print(x, type(x)) # ['Monday', '...
  • Python常用的序列结构有列表、元组、字符串,字典、集合以及range等对象也支持很多类似的操作。 列表、元组、字符串支持双向索引,第一个元素下标为0,第二个元素下标为1,以此类推;最后 一个元素下标为-1,倒数...
  • 本篇博客为博主第一次学 Python 所做的笔记 ...放在一对方括号,相邻元素之间使用逗号分隔。 同一个列表元素的数据类型可以各不相同。 列表包含: 整数、浮点数、复数、字符串等基本类型元素。 .
  • 一、元组 1.元组的定义及一个值的元组定义 2.元组的常见操作: 索引、切片、长度 3.元组的常见方法: ....5.应用场景:将不允许操作的列表可以转化为元组,将允许操作的元组转化为列表 1、定义 t1 = () print(t1, t...
  • Python入门——元组

    2016-11-12 22:54:32
    列表可以任意插入和删除,可以任意的改变列表任意位置的元素值,而元组是不行的 下面,我们通过比较,学习元组: 列表和元组的异同: 异: (1) 空列表 tmp = [ ] 空元组 tmp = ( ) (2)插入 ...
  • 列表由一系列按特定顺序排序的元素组成,可以创建包含字母,数字(0~9)的列表,也可以将任何东西加入列表,其中的元素之间可以没有任何关系。 1.1创建数字列表 在Python,可以使用方法range()创建数字列表。...
  • 列表 元组 集合字典区别与函数用法

    千次阅读 2019-09-25 15:31:25
    理解Python列表,元组,字典,集合的区别 列表,元组,字典,集合的区别是python面试最常见的一个问题。...由于我们买一种东西可能不止一次,所以清单允许重复项的。如果我们扩大清单的范围,统计...
  • 元组和字典的详解

    2021-01-29 23:30:14
    1.元组 元组是一个不可变的序列(元组内的数据是不可变的,不可更改)(不希望数据发生改变的时候我们就用元组,其余的情况都用列表) 元组的表达形式() tuple tuple1=10#这是一个整型 tuple1=10, #这是一个元组...
  • python元组(Tuple)学习

    2020-09-11 20:20:06
    元组的元素不可变,但可以包含可变对象,如list。 注意:定义只有一个元素的tuple时,必须加逗号。 1 元组的定义与访问 1.1、创建空元组 tup1 = () print(type(tup1)) #<class 'tuple'> 1.2、元组的...
  • 1.元组的读写操作 ...(3) 元组允许使用 “元组运算符” 来创建新元素 1.创建元组: 加小括号() 与 不加小括号 都可以创建元组: 例: t1 = ‘a’, ‘b’, ‘c’, 1, 2, 3 t2 = (‘a’, ‘b’, ‘c’, 1, 2, 3) p...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 18,876
精华内容 7,550
关键字:

关系中的元组允许重复