1)关系(Relation)
一个关系对应通常说的一张表
2)元组(Tuple)
表中的一行即为一个元组
3)属性(Attribute)
表中的一列即为一个属性，给每一个属性起一个名称，即属性名
4)码（键）
码是数据系统中的基本概念。所谓码就是能唯一标识实体的属性，他是整个实体集的性质，而不是单个实体的性质。它包括超码，候选码，主码。

超码是一个或多个属性的集合，这些属性可以让我们在一个实体集中唯一地标识一个实体。
候选码:关系(表)中的某个属性组,它可以唯一确定一个元组。
若一个关系(表)中有多个候选码,则选定其中一个为主码。
全码:关系的所有属性都包含在候选码中。
主属性:包含在任何一个候选码中的属性
非主属性 不包含在任何码中的属性
主码: 主键就是候选键里面的一个，是人为规定的，例如学生表中，我们通常会让“学号”做主键，教师表中让“教师编号”做主键。
外码： 外键比较简单，学生表中的外键就是“教师编号”。外键主要是用来描述两个表的关系。
域(Domain):属性的取值范围。
分量:元组中的一个属性值。
形式化定义

R(D 1 ,D 2 ,…D n )

R:关系名

n:关系的目或度(Degree)

例:

关系名(属性1,属性2,…,属性n)

学生(学号,姓名,年龄,性别,系,年级)

候补码和超码：

候选码是从超码中选出的，自然地候选码也是一个或多个属性的集合。

因为超码的范围太广，很多是我们并不感兴趣即无用处的。所以候选码是最小超码，它们的任意真子集都不能成为超码。

例如，如果K是超码，那么所有包含K的集合都不能是候选码；如果K，J都不是超码，那么K和J组成的集合（K，J）有可能是候选码。

1、候选码：能够唯一标识一条记录的最小属性集。若关系中的一个属性或属性组的值能够唯一地标识一个元组，且他的真子集不能唯一的标识一个元组，则称这个属性或属性组做候选码。

2、主码：主码指主关键字。主关键字(primary key)是表中的一个或多个字段，它的值用于唯一地标识表中的某一条记录。在两个表的关系中，主关键字用来在一个表中引用来自于另一个表中的特定记录。主关键字是一种唯一关键字，表定义的一部分。一个表的主键可以由多个关键字共同组成，并且主关键字的列不能包含空值。主关键字是可选的，并且可在 CREATE TABLE 或 ALTER TABLE 语句中定义。

3、全码：All-key关系模型的所有属性组组成该 关系模式的 候选码，称为全码。即所有属性当作一个码。若关系中只有一个候选码,且这个候选码中包含全部属性,则该候选码为全码。如，关系模式R（T，C，S），属性T表示教师，属性C表示课程，属性S表示学生。假如设一个教师可以讲授多门课程，某门课程可以有多个教师讲授，学生可以听不同教师讲授的不同课程，那么，要区分关系中的每一个元组，这个关系模式R的码（主键）应为全属性T、C和S，即All-key。

4、外码：外码是相对于内码而言的辞汇。在计算机科学及相关领域中，外码指的是“外在的‘经过学习之后，可直接了解的编码形式（例如：文字或语音符号）’”。外键（foreign key）：子数据表中出现的父数据表的主键，称为子数据表的外键。



5、主属性：包含在任一候选码中的属性称主属性。简单来说，主属性是候选码所有属性的并集      非主属性  不包含在候选码中的属性称为非主属性。 非主属性是相对于主属性来定义的。

6、主码和候选码的区别：主码唯一标识，候选码是可以作为主码的码，主码一定是候选码的子集，但候选码不一定是主码。

一、定义与特性
1、列表：列表是一组有序存储的数据，它的特性包括：(1、和一般的变量一样都有唯一的标识命名称；(2、列表中的元素都是相同类型的；(3、列表元素都有索引和值两个属性，索引从0开始，每个索引都对应一个值；(4、有中括号括起来元素，元素之间有逗号隔开。

2、元组：(1、一经定义内容无法改变；(2、元组元素可以是不同的类型；(3、元组使用圆括号括起来元素。

3、字典：(1、字典是在内存中保存的一组数据结构，每个元素都是有键值对组合而成的；(2、可以通过键找到其对应的值；(3、元素使用花括号括起来。

4、集合：集合特性：集合是由一组无序排列的元素组成，可以分为可变集合(set)和不可变集合(frozenset).可变集合可以添加、删除、修改，不可变集合创建后不能改变。
二、测试代码
#-*-coding: UTF-8 -*-

#一、列表是一组有序存储的数据，它的特性包括：1、和一般的变量一样都有唯一的标识命名称；
# 2、列表中的元素都是相同类型的；3、列表元素都有索引和值两个属性，索引从0开始，每个索引都对应一个值；
#4、有中括号括起来元素，元素之间有逗号隔开。
# list定义
list_t1 = ['I','love','use','python']

# list打印
print(list_t1)

# list获取长度
print('list length:%d'.format(len(list_t1)))

# list访问
print('list访问')
print(list_t1[0])

# list添加
print('list添加')
list_t1.append(', too')
print(list_t1)

# list插入
print('list插入')
list_t1.insert(1,'ISMILELI')
print(list_t1)

# 把一个list添加到另一个list中
print('把一个list添加到另一个list中')
list_t2 = []
list_t2.extend(list_t1)
print(list_t2)

# 合并两个list
print('合并两个list')
list_t3 = list_t1+list_t2

# 删除list中的元素
print('删除list中的元素')
del[list_t2[0]]
print('del list_t2[0]:')
print(list_t2)

# index函数定位列表位置
print('index函数定位列表位置')
print('index %d'.format(list_t1.index('python')))

# 遍历列表
print('遍历列表')
for i in range(len(list_t3)):
    print(list_t3[i])

# 同时遍历列表的索引和对应值
print('同时遍历列表的索引和对应值')
for index,value in enumerate(list_t2):
    print('index: {0} value: {1}'.format(index,value))

# 排序
print('排序')
list_t1.sort()
print(list_t1)
list_t1.reverse()
print(list_t1)

#二、元组特性：1、一经定义内容无法改变；2、元组元素可以是不同的类型；3、元组使用圆括号括起来元素

#元组和列表一样支持索引的访问、获取长度函数len、for和range遍历、for和enumerate遍历等这里不再示例
print('元组和列表一样支持索引的访问、获取长度函数len、for和range遍历、for和enumerate遍历等')

#元组的排序和列表不一样：由于元组的内容是不可以修改的所以它不支持sort()和reverse()排序方法，但是可以将元组先转化为列表排序，
# 然后再把值赋给元组，这样就间接的实现了元组排序。
print('测试元组排序')
tuple_t1 = ('banana','color','apple','dark')
tmp_l1 = list(tuple_t1)
tmp_l1.sort()
tuple_t1 = tuple(tmp_l1)
for index,value in enumerate(tuple_t1):
    print('index:%d value:%s'%(index,value))

# 字典特性：1、字典是在内存中保存的一组数据结构，每个元素都是有键值对组合而成的；2、可以通过键找到其对应的值；3、元素使用花括号括起来。

print('字典测试')
#字典定义
# import json解决使用print直接打印容器中的中文出现'name': '\xe5\xb0\x8f\xe6\x98\x8e'问题,逐个遍历没有此问题，留意下面测试代码，
# 但这种方法字典中的单引号都会被改成双引号,其他解决办法请自行查找.(python之父知道这个问题，拒绝改变！牛人就是任性阿！)
import json
dict1 = {'name':'小明','sex':'girl','age':'18','high':'180'}
dict1_json = json.dumps(dict1,ensure_ascii=False)
print(dict1_json)#下面代码不再处理中文问题

#长度
print('dict1 length is:%d'%(len(dict1)))
#通过键访问元素
print('by key name visit dict value:%s.'%(dict1['name']))
#添加元素
dict1['score'] = '100'
#合并两个字典
dict2 = {'country':'china','city':'BeiJing'}
dict1.update(dict2)
print('merge dict1 and dict2')
print(dict1)
#字典删除
dict1.pop('score')
print('字典删除')
print(dict1)
#判断字典中是否存在元素
if 'score' in dict1:
    print(dict1['score'])
else:
    print('不存在score')

#遍历字典元素
print('遍历字典元素')
for key in dict1.keys():
    print('键:'+key+' 值:'+dict1[key])

print('字典的清空使用dict1.clear().')

#四、集合特性：集合是由一组无序排列的元素组成，可以分为可变集合(set)和不可变集合(frozenset).
# 可变集合可以添加、删除、修改，不可变集合创建后不能改变。
print('集合测试')
#创建集合
s1 = set('python')
print(type(s1))
print(s1)
fs1 = frozenset('python')
print(type(fs1))
print(fs1)

print("获取集合长度：%d"%(len(s1)))

#由于集合的无序性，访问集合只能遍历
print('访问集合只能遍历')
for elem in s1:
    print(elem)

#集合中添加元素add和update
print('集合中添加元素')
s1.add('1')
s2 = set([2,3,4])
s1.update(s2)
print(s1)

print('集合中删除元素使用remove和clear')

#判断元素是否在集合中
if 3 in s1:
    print('3 在集合s1中')
else:
    print('3 不在集合s1中')

#子集与超集
#对于两个集合A和集合B，如果A中每个元素都是集合B的元素，则A是B的子集，B是A的超集。
#判断集合关系的操作符：==、!=、<、<=、>、>=

if s1 != s2:
    if s1<s2:
        print('s1是s2的子集')
    else:
        print ('s1是s2的超集')

#集合的并集
print('集合的并集')
s = s1 | s2
s3 = s1.union(s2)
print(s)
print(s3)

#集合的交集
print('集合的交集')
s4 = s1 & s2
s5 = s1.intersection(s2)
print(s4)
print(s5)

#集合的差集
print('集合的差集')
s6 = s1-s2
s7 = s1.difference(s2)
print(s6)
print(s7)

#集合的对称差分:有所有属于集合A和集合B，并且不同时属于集合A和集合B的元素组成。
print('集合的对称差分')
s8 = s1^s2
s9 = s1.symmetric_difference(s2)
print(s8)
print(s9)

三、测试结果：

	

     本篇文章所介绍的主要是针对关系数据库中概念数据模型和逻辑数据模型之间的转换。
　　一、码
　　首先，说明一下数据库中经常用到的用于标示一条记录(元组)的的码的概念，码又分为超码、候选码、主码。
　　超码：在一个关系中，可以用来唯一标识一个元组的属性的集合称之为超码。
　　候选码：在一个关系中，能够用来唯一标识一个元组的最少属性集合称之为候选码。
　　主码：在一个关系中，如果用来唯一标识一个元组的候选码中只有一个属性，则这个属性称之为主码。
　　三者之间的关系如下：超码是候选码的超集，候选码是主码的超集。下面以一个讲解清楚。假设一个关于学生信息的表格student，其中的属性有，stu_id(学号)，name(姓名)，age(年龄)，address(地址)。那么超码可以由所有的属性组成的集合构成，例如(stu_id，name，age，adress)、(stu_id，name)、(stu_id，age)等都可以叫做student的超码；候选码为(stu_id)；因为候选码只是由其中的一个属性组成，因此这个候选码又可以称之为主码。
　　二、概念数据模型到逻辑数据模型的转化(以关系数据模型为例)
　　前面博文讨论过，概念数据模型是用E-R图表示的，其中的三要素是实体、属性、联系。将概念数据模型转化为逻辑数据模型的步骤其实就是将E-R图中的各个部分转化为逻辑数据模型中使用的具体数据模型的各个部分。如果没有特别的交代，下面所说的逻辑数据模型指代的是关系数据模型。将概念数据模型转化为逻辑数据模型的大体规则如下：概念数据模型中的实体转化为逻辑数据模型中的关系，对应的实体的属性转化为关系数据模型关系的属性(也就是列)；根据实体之间联系的不同具有不同的处置策略。
　　实体之间的联系分为1:1、1：n、和m:n。下面分别对这三种联系转化为关系的步骤做讨论。
　　1:1：这种关系是最好理解，同时也是最容易处理的关系。实体之间存在着一一对应的关系。在这种联系中，可以创建新的关系描述这种联系，这事将两个实体的主码作为新的关系的候选码；当然也可以不必创建新的关系，将一方关系的主码作为另一方关系的外键。例如两个关系A和B存在1：1联系，那么可以将A的主码作为B的外键，同时将B的主码作为A的外键，具体情况依据于具体的环境。以所做的红包的小练习为例，注册用户和账户之间存在着1:1的联系，用户管理者账户。E-R图如下：
图 1 用户与账户的E-R图
　　用户与账户之间存在一一对应关系，但是创建账户的时候需要用户已经存在，因此这种情况下需要将用户的"uid"作为账户的外键，那么对应的关系如下：
图 2 用户和账户的关系
　　因为，在这个例子中额外的创建关系会导致不必要的额外存储空间的增加，因此不再重新创建额外的关系。
　　1:n：一个实体可以对应额外的多个实体。这种联系中可以不必创建额外的关系表示二者之间的1:n的联系，此时只需要将“1”方的关系的主码放入到“n”方的关系的属性中作为其外键即可，同时将联系的属性加入到“n”方的关系中；当然也可以创建额外的关系表示二者之间的联系，那么“1”和“n”方的关系的主码作为候选码，同时将联系的属性加入到新建立的关系中。但是，这种情况下额外的创建新的关系显得冗余。还是以所练习的红包项目为例，一个大的红包根据指定的数值可以派生出很多的小红包。这两个实体分别对应着一个关系，其E-R图如下：
图 3 小红包的大红包的E-R图
　　由图3得知，小红包必须依赖大红包存在，因此在小红包中将大红包的bid作为小红包的外键即可，这样就不必建立额外的关系了。对应的关系如下：
　　
图 4 大红包和小红包对应的关系
　　m:n：对于这种多对多的联系，必须建立新的关系以描述这种联系。“联系”对应的关系的属性中至少包含他说关联的双方实体的“主键”，若联系也有自身的属性，那么该属性一样纳入新建立的关系的属性中。由于红包项目中没有遇到类似的联系，因此以最经典的学生选课系统为例。很明显学生选课系统中的实体对应有学生和课程，一个学生可以选修多门课程，一门可能可被多个学生选修，因此两个实体之间是一种多对多的关系，对应的E-R图如下：
图 5 学生与课程多对多关系图 
图 6 学生与课程对应关系
　　在上例中，学生与课程之间存在着多对多的联系，因此建立起新的选课关系来描述这种联系。在新的关系中将学生的主码和课程的主码作为选课的候选码，学生的主码和选课的主码的组合会出现在对应的选课关系中。如果此时要查询一个学生的成绩，需要使用联合查询的方式。
《数据科学与人工智能》公众号推荐朋友们学习和使用Python语言，需要加入Python语言群的，请扫码加我个人微信，备注【姓名-Python群】，我诚邀你入群，大家学习和分享。
     关于Python语言，有任何问题或者想法，请留言或者加群讨论。