-
【知识图谱】知识图谱的基础概念与构建流程
2019-11-09 18:46:49本质上, 知识图谱旨在描述真实世界中存在的各种实体或概念及其关系,其构成一张巨大的语义网络图，节点表示实体或概念，边则由属性或关系构成。现在的知识图谱已被用来泛指各种大规模的知识库。 在具体介绍知识图谱的...展开全文目录
【导读】知识图谱技术是人工智能技术的组成部分，其强大的语义处理和互联组织能力，为智能化信息应用提供了基础。我们专知的技术基石之一正是知识图谱-构建AI知识体系-专知主题知识树简介。下面我们特别整理了关于知识图谱的技术全面综述，涵盖基本定义与架构、代表性知识图谱库、构建技术、开源库和典型应用。
1、引言
随着互联网的发展，网络数据内容呈现爆炸式增长的态势。由于互联网内容的大规模、异质多元、组织结构松散的特点，给人们有效获取信息和知识提出了挑战。知识图谱（Knowledge Graph) 以其强大的语义处理能力和开放组织能力，为互联网时代的知识化组织和智能应用奠定了基础。最近，大规模知识图谱库的研究和应用在学术界和工业界引起了足够的注意力[1-5]。一个知识图谱旨在描述现实世界中存在的实体以及实体之间的关系。知识图谱于2012年5月17日由[Google]正式提出[6]，其初衷是为了提高搜索引擎的能力，改善用户的搜索质量以及搜索体验。随着人工智能的技术发展和应用，知识图谱作为关键技术之一，已被广泛应用于智能搜索、智能问答、个性化推荐、内容分发等领域。
2、知识图谱的定义
在维基百科的官方词条中：知识图谱是Google用于增强其搜索引擎功能的知识库。本质上, 知识图谱旨在描述真实世界中存在的各种实体或概念及其关系,其构成一张巨大的语义网络图，节点表示实体或概念，边则由属性或关系构成。现在的知识图谱已被用来泛指各种大规模的知识库。 在具体介绍知识图谱的定义，我们先来看下知识类型的定义：
知识图谱中包含三种节点：
实体: 指的是具有可区别性且独立存在的某种事物。如某一个人、某一个城市、某一种植物等、某一种商品等等。世界万物有具体事物组成，此指实体。如图1的“中国”、“美国”、“日本”等。，实体是知识图谱中的最基本元素，不同的实体间存在不同的关系。
语义类（概念）：具有同种特性的实体构成的集合，如国家、民族、书籍、电脑等。 概念主要指集合、类别、对象类型、事物的种类，例如人物、地理等。
内容: 通常作为实体和语义类的名字、描述、解释等，可以由文本、图像、音视频等来表达。
属性(值): 从一个实体指向它的属性值。不同的属性类型对应于不同类型属性的边。属性值主要指对象指定属性的值。如图1所示的“面积”、“人口”、“首都”是几种不同的属性。属性值主要指对象指定属性的值，例如960万平方公里等。
关系: 形式化为一个函数，它把kk个点映射到一个布尔值。在知识图谱上，关系则是一个把kk个图节点(实体、语义类、属性值)映射到布尔值的函数。
基于上述定义。基于三元组是知识图谱的一种通用表示方式，即,其中，是知识库中的实体集合，共包含|E|种不同实体； 是知识库中的关系集合，共包含|R|种不同关系；代表知识库中的三元组集合。三元组的基本形式主要包括(实体1-关系-实体2)和(实体-属性-属性值)等。每个实体(概念的外延)可用一个全局唯一确定的ID来标识，每个属性-属性值对(attribute-value pair，AVP)可用来刻画实体的内在特性，而关系可用来连接两个实体，刻画它们之间的关联。如下图1的知识图谱例子所示，中国是一个实体，北京是一个实体，中国-首都-北京 是一个（实体-关系-实体）的三元组样例北京是一个实体 ，人口是一种属性2069.3万是属性值。北京-人口-2069.3万构成一个（实体-属性-属性值）的三元组样例。
图1 知识图谱示例
3、知识图谱的架构
知识图谱的架构包括自身的逻辑结构以及构建知识图谱所采用的技术（体系）架构。
3.1 知识图谱的逻辑结构
知识图谱在逻辑上可分为模式层与数据层两个层次，数据层主要是由一系列的事实组成，而知识将以事实为单位进行存储。如果用(实体1，关系，实体2)、(实体、属性，属性值)这样的三元组来表达事实，可选择图数据库作为存储介质，例如开源的Neo4j[7]、Twitter的FlockDB[8]、sones的GraphDB[9]等。模式层构建在数据层之上，是知识图谱的核心，通常采用本体库来管理知识图谱的模式层。本体是结构化知识库的概念模板，通过本体库而形成的知识库不仅层次结构较强，并且冗余程度较小。
3.2 知识图谱的体系架构
图2 知识图谱的技术架构
知识图谱的体系架构是其指构建模式结构，如图2所示。其中虚线框内的部分为知识图谱的构建过程，也包含知识图谱的更新过程。知识图谱构建从最原始的数据（包括结构化、半结构化、非结构化数据）出发，采用一系列自动或者半自动的技术手段，从原始数据库和第三方数据库中提取知识事实，并将其存入知识库的数据层和模式层，这一过程包含：信息抽取、知识表示、知识融合、知识推理四个过程，每一次更新迭代均包含这四个阶段。知识图谱主要有自顶向下(top-down)与自底向上(bottom-up)两种构建方式。自顶向下指的是先为知识图谱定义好本体与数据模式，再将实体加入到知识库。该构建方式需要利用一些现有的结构化知识库作为其基础知识库，例如Freebase项目就是采用这种方式，它的绝大部分数据是从维基百科中得到的。自底向上指的是从一些开放链接数据中提取出实体，选择其中置信度较高的加入到知识库，再构建顶层的本体模式[10]。目前，大多数知识图谱都采用自底向上的方式进行构建，其中最典型就是Google的Knowledge Vault[11]和微软的Satori知识库。现在也符合互联网数据内容知识产生的特点。
4、代表性知识图谱库
根据覆盖范围而言，知识图谱也可分为开放域通用知识图谱和垂直行业知识图谱[12]。开放通用知识图谱注重广度，强调融合更多的实体，较垂直行业知识图谱而言，其准确度不够高，并且受概念范围的影响，很难借助本体库对公理、规则以及约束条件的支持能力规范其实体、属性、实体间的关系等。通用知识图谱主要应用于智能搜索等领域。行业知识图谱通常需要依靠特定行业的数据来构建，具有特定的行业意义。行业知识图谱中，实体的属性与数据模式往往比较丰富，需要考虑到不同的业务场景与使用人员。下图展示了现在知名度较高的大规模知识库。
图3 代表性知识图谱库概览
5、知识图谱构建的关键技术
大规模知识库的构建与应用需要多种技术的支持。通过知识提取技术，可以从一些公开的半结构化、非结构化和第三方结构化数据库的数据中提取出实体、关系、属性等知识要素。知识表示则通过一定有效手段对知识要素表示，便于进一步处理使用。然后通过知识融合，可消除实体、关系、属性等指称项与事实对象之间的歧义，形成高质量的知识库。知识推理则是在已有的知识库基础上进一步挖掘隐含的知识，从而丰富、扩展知识库。分布式的知识表示形成的综合向量对知识库的构建、推理、融合以及应用均具有重要的意义。接下来，本文将以知识抽取、知识表示、知识融合以及知识推理技术为重点，选取代表性的方法，说明其中的相关研究进展和实用技术手段 。
5.1 知识提取
知识抽取主要是面向开放的链接数据，通常典型的输入是自然语言文本或者多媒体内容文档（图像或者视频）等。然后通过自动化或者半自动化的技术抽取出可用的知识单元，知识单元主要包括实体(概念的外延)、关系以及属性3个知识要素，并以此为基础，形成一系列高质量的事实表达，为上层模式层的构建奠定基础。
1.1 实体抽取
实体抽取也称为命名实体学习(named entity learning) 或命名实体识别 (named entity recognition)，指的是从原始数据语料中自动识别出命名实体。由于实体是知识图谱中的最基本元素，其抽取的完整性、准确率、召回率等将直接影响到知识图谱构建的质量。因此，实体抽取是知识抽取中最为基础与关键的一步。参照文献[13]，我们可以将实体抽取的方法分为4种：基于百科站点或垂直站点提取、基于规则与词典的方法、基于统计机器学习的方法以及面向开放域的抽取方法。基于百科站点或垂直站点提取则是一种很常规基本的提取方法；基于规则的方法通常需要为目标实体编写模板，然后在原始语料中进行匹配；基于统计机器学习的方法主要是通过机器学习的方法对原始语料进行训练，然后再利用训练好的模型去识别实体；面向开放域的抽取将是面向海量的Web语料[14]。
1) 基于百科或垂直站点提取
基于百科站点或垂直站点提取这种方法是从百科类站点（如维基百科、百度百科、互动百科等）的标题和链接中提取实体名。这种方法的优点是可以得到开放互联网中最常见的实体名，其缺点是对于中低频的覆盖率低。与一般性通用的网站相比，垂直类站点的实体提取可以获取特定领域的实体。例如从豆瓣各频道(音乐、读书、电影等)获取各种实体列表。这种方法主要是基于爬取技术来实现和获取。基于百科类站点或垂直站点是一种最常规和基本的方法。
2) 基于规则与词典的实体提取方法
早期的实体抽取是在限定文本领域、限定语义单元类型的条件下进行的，主要采用的是基于规则与词典的方法，例如使用已定义的规则，抽取出文本中的人名、地名、组织机构名、特定时间等实体[15]。文献[16]首次实现了一套能够抽取公司名称的实体抽取系统，其中主要用到了启发式算法与规则模板相结合的方法。然而，基于规则模板的方法不仅需要依靠大量的专家来编写规则或模板，覆盖的领域范围有限，而且很难适应数据变化的新需求。
3) 基于统计机器学习的实体抽取方法
鉴于基于规则与词典实体的局限性，为具更有可扩展性，相关研究人员将机器学习中的监督学习算法用于命名实体的抽取问题上。例如文献[17]利用KNN算法与条件随机场模型，实现了对Twitter文本数据中实体的识别。单纯的监督学习算法在性能上不仅受到训练集合的限制，并且算法的准确率与召回率都不够理想。相关研究者认识到监督学习算法的制约性后，尝试将监督学习算法与规则相互结合，取得了一定的成果。例如文献[18]基于字典，使用最大熵算法在Medline论文摘要的GENIA数据集上进行了实体抽取实验，实验的准确率与召回率都在70%以上。近年来随着深度学习的兴起应用，基于深度学习的命名实体识别得到广泛应用。在文献[19]，介绍了一种基于双向LSTM深度神经网络和条件随机场的识别方法，在测试数据上取得的最好的表现结果。
图4 基于BI-LSTM和CRF的架构
4) 面向开放域的实体抽取方法
针对如何从少量实体实例中自动发现具有区分力的模式，进而扩展到海量文本去给实体做分类与聚类的问题，文献[20]提出了一种通过迭代方式扩展实体语料库的解决方案，其基本思想是通过少量的实体实例建立特征模型，再通过该模型应用于新的数据集得到新的命名实体。文献[21]提出了一种基于无监督学习的开放域聚类算法，其基本思想是基于已知实体的语义特征去搜索日志中识别出命名的实体，然后进行聚类。
1.2 语义类抽取
语义类抽取是指从文本中自动抽取信息来构造语义类并建立实体和语义类的关联, 作为实体层面上的规整和抽象。以下介绍一种行之有效的语义类抽取方法，包含三个模块：并列度相似计算、上下位关系提取以及语义类生成 [22]。
1) 并列相似度计算
并列相似度计算其结果是词和词之间的相似性信息，例如三元组（苹果，梨，s1）表示苹果和梨的相似度是s1。两个词有较高的并列相似度的条件是它们具有并列关系（即同属于一个语义类），并且有较大的关联度。按照这样的标准，北京和上海具有较高的并列相似度，而北京和汽车的并列相似度很低（因为它们不属于同一个语义类）。对于海淀、朝阳、闵行三个市辖区来说，海淀和朝阳的并列相似度大于海淀和闵行的并列相似度（因为前两者的关联度更高）。
当前主流的并列相似度计算方法有分布相似度法（distributional similarity） 和模式匹配法（pattern Matching）。分布相似度方法[23-24]基于哈里斯（Harris）的分布假设（distributional hypothesis）[25]，即经常出现在类似的上下文环境中的两个词具有语义上的相似性。分布相似度方法的实现分三个步骤：第一步，定义上下文；第二步，把每个词表示成一个特征向量，向量每一维代表一个不同的上下文，向量的值表示本词相对于上下文的权重；第三步，计算两个特征向量之间的相似度，将其作为它们所代表的词之间的相似度。 模式匹配法的基本思路是把一些模式作用于源数据，得到一些词和词之间共同出现的信息，然后把这些信息聚集起来生成单词之间的相似度。模式可以是手工定义的，也可以是根据一些种子数据而自动生成的。分布相似度法和模式匹配法都可以用来在数以百亿计的句子中或者数以十亿计的网页中抽取词的相似性信息。有关分布相似度法和模式匹配法所生成的相似度信息的质量比较参见文献。
2) 上下位关系提取
该该模块从文档中抽取词的上下位关系信息，生成（下义词，上义词）数据对，例如（狗，动物）、（悉尼，城市）。提取上下位关系最简单的方法是解析百科类站点的分类信息（如维基百科的“分类”和百度百科的“开放分类”）。这种方法的主要缺点包括：并不是所有的分类词条都代表上位词，例如百度百科中“狗”的开放分类“养殖”就不是其上位词；生成的关系图中没有权重信息，因此不能区分同一个实体所对应的不同上位词的重要性；覆盖率偏低，即很多上下位关系并没有包含在百科站点的分类信息中。
在英文数据上用Hearst 模式和IsA 模式进行模式匹配被认为是比较有效的上下位关系抽取方法。下面是这些模式的中文版本（其中NPC 表示上位词，NP 表示下位词）：
NPC { 包括| 包含| 有} {NP、}* [ 等| 等等]
NPC { 如| 比如| 像| 象} {NP、}*
{NP、}* [{ 以及| 和| 与} NP] 等 NPC
{NP、}* { 以及| 和| 与} { 其它| 其他} NPC
NP 是 { 一个| 一种| 一类} NPC此外，一些网页表格中包含有上下位关系信息，例如在带有表头的表格中，表头行的文本是其它行的上位词。
3) 语义类生成
该模块包括聚类和语义类标定两个子模块。聚类的结果决定了要生成哪些语义类以及每个语义类包含哪些实体，而语义类标定的任务是给一个语义类附加一个或者多个上位词作为其成员的公共上位词。此模块依赖于并列相似性和上下位关系信息来进行聚类和标定。有些研究工作只根据上下位关系图来生成语义类，但经验表明并列相似性信息对于提高最终生成的语义类的精度和覆盖率都至关重要。
1.3 属性和属性值抽取
属性提取的任务是为每个本体语义类构造属性列表（如城市的属性包括面积、人口、所在国家、地理位置等），而属性值提取则为一个语义类的实体附加属性值。属性和属性值的抽取能够形成完整的实体概念的知识图谱维度。常见的属性和属性值抽取方法包括从百科类站点中提取，从垂直网站中进行包装器归纳，从网页表格中提取，以及利用手工定义或自动生成的模式从句子和查询日志中提取。
常见的语义类/ 实体的常见属性/ 属性值可以通过解析百科类站点中的半结构化信息（如维基百科的信息盒和百度百科的属性表格）而获得。尽管通过这种简单手段能够得到高质量的属性，但同时需要采用其它方法来增加覆盖率（即为语义类增加更多属性以及为更多的实体添加属性值）。
图5 爱因斯坦信息页
由于垂直网站（如电子产品网站、图书网站、电影网站、音乐网站）包含有大量实体的属性信息。例如上图的网页中包含了图书的作者、出版社、出版时间、评分等信息。通过基于一定规则模板建立，便可以从垂直站点中生成包装器（或称为模版），并根据包装器来提取属性信息。从包装器生成的自动化程度来看，这些方法可以分为手工法（即手工编写包装器）、监督方法、半监督法以及无监督法。考虑到需要从大量不同的网站中提取信息，并且网站模版可能会更新等因素，无监督包装器归纳方法显得更加重要和现实。无监督包装器归纳的基本思路是利用对同一个网站下面多个网页的超文本标签树的对比来生成模版。简单来看，不同网页的公共部分往往对应于模版或者属性名，不同的部分则可能是属性值，而同一个网页中重复的标签块则预示着重复的记录。
属性抽取的另一个信息源是网页表格。表格的内容对于人来说一目了然，而对于机器而言，情况则要复杂得多。由于表格类型千差万别，很多表格制作得不规则，加上机器缺乏人所具有的背景知识等原因，从网页表格中提取高质量的属性信息成为挑战。
上述三种方法的共同点是通过挖掘原始数据中的半结构化信息来获取属性和属性值。与通过“阅读”句子来进行信息抽取的方法相比，这些方法绕开了自然语言理解这样一个“硬骨头”而试图达到以柔克刚的效果。在现阶段，计算机知识库中的大多数属性值确实是通过上述方法获得的。但现实情况是只有一部分的人类知识是以半结构化形式体现的，而更多的知识则隐藏在自然语言句子中，因此直接从句子中抽取信息成为进一步提高知识库覆盖率的关键。当前从句子和查询日志中提取属性和属性值的基本手段是模式匹配和对自然语言的浅层处理。图6 描绘了为语义类抽取属性名的主框架（同样的过程也适用于为实体抽取属性值）。图中虚线左边的部分是输入，它包括一些手工定义的模式和一个作为种子的（词，属性）列表。模式的例子参见表3，（词，属性）的例子如（北京，面积）。在只有语义类无关的模式作为输入的情况下，整个方法是一个在句子中进行模式匹配而生成（语义类，属性）关系图的无监督的知识提取过程。此过程分两个步骤，第一个步骤通过将输入的模式作用到句子上而生成一些（词，属性）元组，这些数据元组在第二个步骤中根据语义类进行合并而生成（语义类，属性）关系图。在输入中包含种子列表或者语义类相关模式的情况下，整个方法是一个半监督的自举过程，分三个步骤：
模式生成：在句子中匹配种子列表中的词和属性从而生成模式。模式通常由词和属性的环境信息而生成。
模式匹配。
模式评价与选择：通过生成的（语义类，属性）关系图对自动生成的模式的质量进行自动评价并选择高分值的模式作为下一轮匹配的输入。
1.3 关系抽取
关系抽取的目标是解决实体语义链接的问题。关系的基本信息包括参数类型、满足此关系的元组模式等。例如关系BeCapitalOf（表示一个国家的首都）的基本信息如下：
参数类型：（Capital， Country）
模式：元组：（北京，中国）；（华盛顿，美国）；Capital 和 Country表示首都和国家两个语义类。
早期的关系抽取主要是通过人工构造语义规则以及模板的方法识别实体关系。随后，实体间的关系模型逐渐替代了人工预定义的语法与规则。但是仍需要提前定义实体间的关系类型。 文献[26]提出了面向开放域的信息抽取框架 (open information extraction,OIE)，这是抽取模式上的一个巨大进步。但OIE方法在对实体的隐含关系抽取方面性能低下，因此部分研究者提出了基于马尔可夫逻辑网、基于本体推理的深层隐含关系抽取方法[27]。
开放式实体关系抽取
开放式实体关系抽取可分为二元开放式关系抽取和n元开放式关系抽取。在二元开放式关系抽取中，早期的研究有KnowItAll[28]与TextRunner[27]系统，在准确率与召回率上表现一般。文献[29]提出了一种基于Wikipedia的OIE方法WOE，经自监督学习得到抽取器，准确率较TextRunner有明显的提高。针对WOE的缺点，文献[30]提出了第二代OIE ReVerb系统，以动词关系抽取为主。文献[31]提出了第三代OIE系统OLLIE(open language learning for information extraction)，尝试弥补并扩展OIE的模型及相应的系统，抽取结果的准确度得到了增强。
然而，基于语义角色标注的OIE分析显示：英文语句中40%的实体关系是n元的[32]，如处理不当，可能会影响整体抽取的完整性。文献[33]提出了一种可抽取任意英文语句中n元实体关系的方法KPAKEN，弥补了ReVerb的不足。但是由于算法对语句深层语法特征的提取导致其效率显著下降，并不适用于大规模开放域语料的情况。
基于联合推理的实体关系抽取
联合推理的关系抽取中的典型方法是马尔可夫逻辑网MLN(Markov logic network)[34]，它是一种将马尔可夫网络与一阶逻辑相结合的统计关系学习框架，同时也是在OIE中融入推理的一种重要实体关系抽取模型。基于该模型，文献[35]提出了一种无监督学习模型StatSnowball，不同于传统的OIE，该方法可自动产生或选择模板生成抽取器。在StatSnowball的基础上，文献[27,36]提出了一种实体识别与关系抽取相结合的模型EntSum，主要由扩展的CRF命名实体识别模块与基于StatSnowball的关系抽取模块组成，在保证准确率的同时也提高了召回率。文献[27,37]提出了一种简易的Markov逻辑TML(tractable Markov logic)，TML将领域知识分解为若干部分，各部分主要来源于事物类的层次化结构，并依据此结构，将各大部分进一步分解为若干个子部分，以此类推。TML具有较强的表示能力，能够较为简洁地表示概念以及关系的本体结构。
5.2 知识表示
传统的知识表示方法主要是以RDF(Resource Description Framework资源描述框架)的三元组SPO(subject,property,object)来符号性描述实体之间的关系。这种表示方法通用简单，受到广泛认可，但是其在计算效率、数据稀疏性等方面面临诸多问题。近年来，以深度学习为代表的以深度学习为代表的表示学习技术取得了重要的进展，可以将实体的语义信息表示为稠密低维实值向量，进而在低维空间中高效计算实体、关系及其之间的复杂语义关联，对知识库的构建、推理、融合以及应用均具有重要的意义[38-40]。
2.1 代表模型
知识表示学习的代表模型有距离模型、单层神经网络模型、双线性模型、神经张量模型、矩阵分解模型、翻译模型等。详细可参见清华大学刘知远的知识表示学习研究进展。相关实现也可参见 [39]。
1）距离模型
距离模型在文献[41] 提出了知识库中实体以及关系的结构化表示方法(structured embedding，SE)，其基本思想是：首先将实体用向量进行表示，然后通过关系矩阵将实体投影到与实体关系对的向量空间中，最后通过计算投影向量之间的距离来判断实体间已存在的关系的置信度。由于距离模型中的关系矩阵是两个不同的矩阵，使得协同性较差。
2）单层神经网络模型
文献[42]针对上述提到的距离模型中的缺陷，提出了采用单层神经网络的非线性模型(single layer model，SLM)，模型为知识库中每个三元组（h,r,t) 定义了以下形式的评价函数：
式中， ut的T次幂∈R的k次幂为关系 r 的向量化表示；g()为tanh函数； Mr,1×Mr,2∈R的k次幂是通过关系r定义的两个矩阵。单层神经网络模型的非线性操作虽然能够进一步刻画实体在关系下的语义相关性，但在计算开销上却大大增加。
3）双线性模型
双 线 性 模 型 又 叫 隐 变 量 模 型 (latent factor model，LFM)，由文献[43-44]首先提出。模型为知识库中每个三元组 定义的评价函数具有如下形式：
式中,Mr∈R的d×d次幂是通过关系r 定义的双线性变换矩阵；
lh×lt∈R的d次幂是三元组中头实体与尾实体的向量化表示。双线性模型主要是通过基于实体间关系的双线性变换来刻画实体在关系下的语义相关性。模型不仅形式简单、易于计算，而且还能够有效刻画实体间的协同性。基于上述工作，文献[45]尝试将双线性变换矩阵r M 变换为对角矩阵， 提出了DISTMULT模型，不仅简化了计算的复杂度，并且实验效果得到了显著提升。4）神经张量模型
文献[45]提出的神经张量模型，其基本思想是：在不同的维度下，将实体联系起来，表示实体间复杂的语义联系。模型为知识库中的每个三元组(h,r,t)定义了以下形式的评价函数：
式中， ut的T次幂∈R的k次幂为关系 r 的向量化表示；g()为tanh函数； Mr∈d×k×k是一个三阶张量；Mr,1×Mr,2∈R的k次幂是通过关系r定义的两个矩阵。
神经张量模型在构建实体的向量表示时，是将该实体中的所有单词的向量取平均值，这样一方面可以重复使用单词向量构建实体，另一方面将有利于增强低维向量的稠密程度以及实体与关系的语义计算。
5）矩阵分解模型
通过矩阵分解的方式可得到低维的向量表示，故不少研究者提出可采用该方式进行知识表示学习，其中的典型代表是文献[46]提出的RESACL模型。在RESCAL模型中，知识库中的三元组集合被表示为一个三阶张量，如果该三元组存在，张量中对应位置的元素被置1，否则置为0。通过张量分解算法，可将张量中每个三元组（h,r,t)对应的张量值解为双线性模型中的知识表示形式lh的T次幂×Mr×lt并使|Xhrt-lh的T次幂×Mr×l|尽量小。
6）翻译模型
文献[47]受到平移不变现象的启发，提出了TransE模型，即将知识库中实体之间的关系看成是从实体间的某种平移，并用向量表示。关系lr可以看作是从头实体向量到尾实体向量lt的翻译。对于知识库中的每个三元组(h,r,t),TransE都希望满足以下关系|lh+lt≈lt|：，其损失函数为：fr(h,t)=|lh+lr-lt|L1/L2, 该模型的参数较少，计算的复杂度显著降低。与此同时，TransE模型在大规模稀疏知识库上也同样具有较好的性能和可扩展性。
2.2 复杂关系模型
知识库中的实体关系类型也可分为1-to-1、1-to-N、N-to-1、N-to-N4种类型[47]，而复杂关系主要指的是1-to-N、N-to-1、N-to-N的3种关系类型。由于TransE模型不能用在处理复杂关系上[39]，一系列基于它的扩展模型纷纷被提出，下面将着重介绍其中的几项代表性工作。
1）TransH模型
文献[48]提出的TransH模型尝试通过不同的形式表示不同关系中的实体结构，对于同一个实体而言，它在不同的关系下也扮演着不同的角色。模型首先通过关系向量lr与其正交的法向量wr选取某一个超平面F， 然后将头实体向量lh和尾实体向量lt法向量wr的方向投影到F, 最后计算损失函数。TransH使不同的实体在不同的关系下拥有了不同的表示形式，但由于实体向量被投影到了关系的语义空间中，故它们具有相同的维度。
2）TransR模型
由于实体、关系是不同的对象，不同的关系所关注的实体的属性也不尽相同，将它们映射到同一个语义空间，在一定程度上就限制了模型的表达能力。所以，文献[49]提出了TransR模型。模型首先将知识库中的每个三元组(h, r,t)的头实体与尾实体向关系空间中投影，然后希望满足|lh+lt≈lt|的关系，最后计算损失函数。
文献[49]提出的CTransR模型认为关系还可做更细致的划分，这将有利于提高实体与关系的语义联系。在CTransR模型中，通过对关系r 对应的头实体、尾实体向量的差值lh-lt进行聚类，可将r分为若干个子关系rc 。
3）TransD模型
考虑到在知识库的三元组中，头实体和尾实体表示的含义、类型以及属性可能有较大差异，之前的TransR模型使它们被同一个投影矩阵进行映射，在一定程度上就限制了模型的表达能力。除此之外，将实体映射到关系空间体现的是从实体到关系的语 义联系，而TransR模型中提出的投影矩阵仅考虑了不同的关系类型，而忽视了实体与关系之间的交互。因此，文献[50]提出了TransD模型，模型分别定义了头实体与尾实体在关系空间上的投影矩阵。
4）TransG模型
文献[51]提出的TransG模型认为一种关系可能会对应多种语义，而每一种语义都可以用一个高斯分布表示。TransG模型考虑到了关系r 的不同语义，使用高斯混合模型来描述知识库中每个三元组(h,r,t)头实体与尾实体之间的关系，具有较高的实体区分度。
5）KG2E模型
考虑到知识库中的实体以及关系的不确定性，文献[52]提出了KG2E模型，其中同样是用高斯分布来刻画实体与关系。模型使用高斯分布的均值表示实体或关系在语义空间中的中心位置，协方差则表示实体或关系的不确定度。
知识库中，每个三元组(h,r,t)的头实体向量与尾实体向量间的
关系r可表示为：
5.3 知识融合
通过知识提取，实现了从非结构化和半结构化数据中获取实体、关系以及实体属性信息的目标。但是由于知识来源广泛，存在知识质量良莠不齐、来自不同数据源的知识重复、层次结构缺失等问题，所以必须要进行知识的融合。知识融合是高层次的知识组织[53]，使来自不同知识源的知识在同一框架规范下进行异构数据整合、消歧、加工、推理验证、更新等步骤[54]，达到数据、信息、方法、经验以及人的思想的融合，形成高质量的知识库。
3.1 实体对齐
实体对齐 (entity alignment) 也称为实体匹配 (entity matching)或实体解析(entity resolution)或者实体链接（entity linking），主要是用于消除异构数据中实体冲突、指向不明等不一致性问题，可以从顶层创建一个大规模的统一知识库，从而帮助机器理解多源异质的数据，形成高质量的知识。
在大数据的环境下，受知识库规模的影响，在进行知识库实体对齐时，主要会面临以下3个方面的挑战[55]：1) 计算复杂度。匹配算法的计算复杂度会随知识库的规模呈二次增长，难以接受；2) 数据质量。由于不同知识库的构建目的与方式有所不同，可能存在知识质量良莠不齐、相似重复数据、孤立数据、数据时间粒度不一致等问题[56]；3) 先验训练数据。在大规模知识库中想要获得这种先验数据却非常困难。通常情况下，需要研究者手工构造先验训练数据。
基于上述，知识库实体对齐的主要流程将包括[55]：1) 将待对齐数据进行分区索引，以降低计算的复杂度；2) 利用相似度函数或相似性算法查找匹配实例；3) 使用实体对齐算法进行实例融合；4) 将步骤2)与步骤3)的结果结合起来，形成最终的对齐结果。对齐算法可分为成对实体对齐与集体实体对齐两大类，而集体实体对齐又可分为局部集体实体对齐与全局集体实体对齐。
1）成对实体对齐方法
① 基于传统概率模型的实体对齐方法
基于传统概率模型的实体对齐方法主要就是考虑两个实体各自属性的相似性，而并不考虑实体间的关系。文献[57]将基于属性相似度评分来判断实体是否匹配的问题转化为一个分类问题，建立了该问题的概率模型，缺点是没有体现重要属性对于实体相似度的影响。文献[58]基于概率实体链接模型，为每个匹配的属性对分配了不同的权重，匹配准确度有所提高。文献[59]还结合贝叶斯网络对属性的相关性进行建模，并使用最大似然估计方法对模型中的参数进行估计。
② 基于机器学习的实体对齐方法
基于机器学习的实体对齐方法主要是将实体对齐问题转化为二分类问题。根据是否使用标注数据可分为有监督学习与无监督学习两类，基于监督学习的实体对齐方法主要可分为成对实体对齐、基于聚类的对齐、主动学习。
通过属性比较向量来判断实体对匹配与否可称为成对实体对齐。这类方法中的典型代表有决策树 [60]、支持向量机[61]、集成学习[62]等。文献[63]使用分类回归树、线性分析判别等方法完成了实体辨析。文献[64]基于二阶段实体链接分析模型，提出了一种新的SVM分类方法，匹配准确率远高于TAILOR中的混合算法。
基于聚类的实体对齐算法，其主要思想是将相似的实体尽量聚集到一起，再进行实体对齐。文献[65]提出了一种扩展性较强的自适应实体名称匹配与聚类算法，可通过训练样本生成一个自适应的距离函数。文献[66]采用类似的方法，在条件随机场实体对齐模型中使用监督学习的方法训练产生距离函数，然后调整权重，使特征函数与学习参数的积最大。
在主动学习中，可通过与人员的不断交互来解决很难获得足够的训练数据问题，文献[67]构建的ALIAS系统可通过人机交互的方式完成实体链接与去重的任务。文献[68]采用相似的方法构建了ActiveAtlas系统。
2）局部集体实体对齐方法
局部集体实体对齐方法为实体本身的属性以及与它有关联的实体的属性分别设置不同的权重，并通过加权求和计算总体的相似度，还可使用向量空间模型以及余弦相似性来判别大规模知识库中的实体的相似程度[69]，算法为每个实体建立了名称向量与虚拟文档向量，名称向量用于标识实体的属性，虚拟文档向量则用于表示实体的属性值以及其邻居节点的属性值的加权和值[55]。为了评价向量中每个分量的重要性，算法主要使用TF-IDF为每个分量设置权重，并为分量向量建立倒排索引，最后选择余弦相似性函数计算它们的相似程度[55]。该算法的召回率较高，执行速度快，但准确率不足。其根本原因在于没有真正从语义方面进行考虑。
3）全局集体实体对齐方法
① 基于相似性传播的集体实体对齐方法
基于相似性传播的方法是一种典型的集体实体对齐方法，匹配的两个实体与它们产生直接关联的其他实体也会具有较高的相似性，而这种相似性又会影响关联的其他实体[55]。
相似性传播集体实体对齐方法最早来源于文献[70-71]提出的集合关系聚类算法，该算法主要通过一种改进的层次凝聚算法迭代产生匹配对象。文献[72]在以上算法的基础上提出了适用于大规模知识库实体对齐的算法SiGMa，该算法将实体对齐问题看成是一个全局匹配评分目标函数的优化问题进行建模，属于二次分配问题，可通过贪婪优化算法求得其近似解。SiGMa方法[55]能够综合考虑实体对的属性与关系，通过集体实体的领域，不断迭代发现所有的匹配对。
② 基于概率模型的集体实体对齐方法基于概率模型的集体实体对齐方法主要采用统计关系学习进行计算与推理，常用的方法有LDA模型[73]、CRF模型[74]、Markov逻辑网[75]等。
文献[73]将LDA模型应用于实体的解析过程中，通过其中的隐含变量获取实体之间的关系。但在大规模的数据集上效果一般。文献[74]提出了一种基于图划分技术的CRF实体辨析模型，该模型以观察值为条件产生实体判别的决策，有利于处理属性间具有依赖关系的数据。文献[66]在CRF实体辨析模型的基础上提出了一种基于条件随机场模型的多关系的实体链接算法，引入了基于canopy的索引，提高了大规模知识库环境下的集体实体对齐效率。文献[75]提出了一种基于Markov逻辑网的实体解析方法。通过Markov逻辑网，可构建一个Markov网，将概率图模型中的最大可能性计算问题转化为典型的最大化加权可满足性问题，但基于Markov网进行实体辨析时，需要定义一系列的等价谓词公理，通过它们完成知识库的集体实体对齐。
3.2 知识加工
通过实体对齐，可以得到一系列的基本事实表达或初步的本体雏形，然而事实并不等于知识，它只是知识的基本单位。要形成高质量的知识，还需要经过知识加工的过程，从层次上形成一个大规模的知识体系，统一对知识进行管理。知识加工主要包括本体构建与质量评估两方面的内容。
1）本体构建
本体是同一领域内不同主体之间进行交流、连通的语义基础，其主要呈现树状结构，相邻的层次节点或概念之间具有严格的“IsA”关系，有利于进行约束、推理等，却不利于表达概念的多样性。本体在知识图谱中的地位相当于知识库的模具，通过本体库而形成的知识库不仅层次结构较强，并且冗余程度较小。
-
小甲鱼零基础入门学习python笔记
2019-08-14 11:06:30") temp = input("请重新输入吧：") print("游戏结束，不玩啦~~") 005 闲聊之Python的数据类型 Python的一些数值类型：整型、布尔类型（True与False）、浮点型、e记法、复数类型等 e记法（e4相当于10的四次方，e-10...展开全文小甲鱼老师零基础入门学习Python全套资料百度云(包括小甲鱼零基础入门学习Python全套视频+全套源码+全套PPT课件+全套课后题及Python常用工具包链接、电子书籍等）请往我的资源（https://download.csdn.net/download/qq_32809093/13099592）查看
目录：
000 愉快的开始
001 我和Python的第一次亲密接触
002 用Python设计第一个游戏
003 小插曲之变量和字符串
004 改进我们的小游戏
005 闲聊之Python的数据类型
006 Pyhon之常用操作符
007 了不起的分支和循环
008 了不起的分支和循环2
009 了不起的分支和循环3
010 列表：一个打了激素的数组
011列表：一个打了激素的数组2
012列表：一个打了激素的数组3
013元组：戴上了枷锁的列表
014字符串：各种奇葩的内置方法
015字符串：格式化
016 序列！序列！
017函数：Python的乐高积木
018 函数：灵活即强大
019函数：我的地盘听我的（局部变量与全局变量）
020函数：内嵌函数和闭包
021函数：lambda表达式
022 函数：递归是神马
023 递归：这帮小兔崽子
024 递归：汉诺塔
025 字典：当索引不好用时
026 字典：当索引不好用时2
027 集合：在我的世界里，你就是唯一
028 文件：因为懂你，所以永恒
029 文件：一个任务
030 文件系统：介绍一个高大上的东西
031 永久存储：腌制一缸美味的泡菜(pickle)
032 异常处理：你不可能总是对的
033 异常处理：你不可能总是对的2
034 丰富的else语句及简洁的with语句
035 图形用户界面入门：EasyGui
036 类和对象：给大家介绍对象
037 类和对象：面向对象编程
038 类和对象：继承
039 类和对象：拾遗
040 类和对象：一些相关的BIF
041 魔法方法：构造和析构
042 魔法方法：算术运算
043 魔法方法：算术运算2
044 魔法方法：简单定制
045 魔法方法：属性访问
046 魔法方法：描述符（Property的原理）
047 魔法方法：定制序列
048 魔法方法：迭代器
049 乱入：生成器
050 模块：模块就是程序
051 模块：__name__='__main__'、搜索路径和包
052 模块：像个极客一样去思考
053 论一只爬虫的自我修养
054 论一只爬虫的自我修养2：实战
055 论一只爬虫的自我修养3：隐藏064 GUI的终极选择：Tkinter
065 GUI的终极选择：Tkinter2
066 GUI的终极选择：Tkinter3
067 GUI的终极选择：Tkinter4
068 GUI的终极选择：Tkinter5
069 GUI的终极选择：Tkinter6
070 GUI的终极选择：Tkinter7
071 GUI的终极选择：Tkinter8
073 GUI的终极选择：Tkinter10
074 GUI的终极选择：Tkinter11
075 GUI的终极选择：Tkinter12
076 GUI的终极选择：Tkinter13
077 GUI的终极选择：Tkinter14078 Pygame：初次见面，请大家多多关照
000 愉快的开始
python跨平台。
应用范围：操作系统、WEB、3D动画、企业应用、云计算
大家可以学到什么：Python3的所有常用语法、面向对象编程思维、运用模块进行编程、游戏编程、计算机仿真Python 是脚本语言
脚本语言(Scripting language)是电脑编程语言，因此也能让开发者藉以编写出让电脑听命行事的程序。以简单的方式快速完成某些复杂的事情通常是创造脚本语言的重要原则，基于这项原则，使得脚本语言通常比 C 语言、C++语言 或 Java 之类的系统编程语言要简单容易。也让脚本语言另有一些属于脚本语言的特性：
• 语法和结构通常比较简单
• 学习和使用通常比较简单
• 通常以容易修改程序的“解释”作为运行方式，而不需要“编译”
• 程序的开发产能优于运行性能
一个脚本可以使得本来要用键盘进行的相互式操作自动化。一个 Shell 脚本主要由原本需要在命令行输入的命令组成，或在一个文本编辑器中，用户可以使用脚本来把一些常用的操作组合成一组串行。主要用来书写这种脚本的语言叫做脚本语言。很多脚本
语言实际上已经超过简单的用户命令串行的指令，还可以编写更复杂的程序。IDLE 是一个 Python Shell，shell 的意思就是“外壳”，基本上来说，就是一个通过键入文本与程序交互的途径！像我们 Windows 那个 cmd 窗口，像 Linux 那个黑乎乎的命令窗口，他们都是 shell，利用他们，我们就可以给操作系统下达命令。同样的，我们可以利用 IDLE 这个 shell 与 Python 进行互动。
注：在 Python 中不能把两个完全不同的东西加在一起，比如说数字和文本
如果我需要在一个字符串中嵌入一个双引号，正确的做法是：你可以利用反斜杠（\）对双引号转义：\"，或者用单引号引起这个字符串
001 我和Python的第一次亲密接触
从IDLE启动Python
•IDLE是一个Python Shell，shell的意思就是“外壳”，基本上来说，就是一个通过键入文本与程序交互的途径！
•我们看到>>>这个提示符，Ta的含义是告诉你，Python已经准备好了，在等着你键入Python指令呢。
•好了，大家试试在IDLE里输入：
>>>print (“I love fishc.com”)
•我们尝试点儿新的东西，我们输入
>>>print(5+3)
•或者直接输入
>>>5+3
•不妨在试试计算
>>>1234567890987654321*987654321012345678
•还有我们可以将两个字符串“相加”在一起，这种做法叫做拼接字符串
>>>print("well water"+"river")
•先试试
>>> print("I love fishc.com"*2)
•和
>>> print("I love fishc.com\n"* 2)
002 用Python设计第一个游戏
实例1：
print("---------我爱鱼C工作室----------")
temp = input("不妨猜一下小甲鱼现在心里想的是哪个数字:")
guess = int(temp)
if guess == 8:
print("我草，你是小甲鱼心里的蛔虫嘛？！")
print("哼，猜中了也没有奖励！")
else:
print("猜错了，小甲鱼现在心里想的是8！")
print("游戏结束，不玩啦")
BIF 就是 Built-in Functions，内置函数。为了方便程序员快速编写脚本程序（脚本就是要编程速度快快快！！！），Python 提供了非常丰富的内置函数，我们只需要直接调用即可，例如 print() 的功能是“打印到屏幕”，input() 的作用是接收用户输入。
在 Python 或 IDLE 中，输入 dir(__builtins__) 可以看到 Python 提供的内置方法列表（注意，builtins 前后是两个下划线哦）其中小写的就是 BIF。如果想具体查看某个BIF 的功能，比如 input()，可以在 shell 中输入 help(input)，就会得到这个 BIF 的功能描述。哦，答案应该是 68 个
>>> dir(__builtins__) 查看 Python 提供的内置方法列表
>>> help(input) 查看input的具体使用说明
注：
只有当标识符已经赋值后（ Python 的变量是不用先声明的）才能在代码中使用，未赋值的标识符直接使用会导致运行时错误
缩进是 Python 的灵魂
Python 不允许 if 条件中赋值，所以 if c = 1: 会报错！
003 小插曲之变量和字符串
插曲之变量
•变量名就像我们现实社会的名字，把一个值赋值给一个名字时，Ta会存储在内存中，称之为变量（variable），在大多数语言中，都把这种行为称为“给变量赋值”或“把值存储在变量中”。
•不过Python与大多数其他计算机语言的做法稍有不同，Ta并不是把值存储在变量中，而更像是把名字贴在值的上边。
•所以有些Python程序员会说“Python”没有“变量”，只有“名字”。
需要注意的地方
•在使用变量之前，需要对其先赋值。
•变量名可以包括字母、数字、下划线，但变量名不能以数字开头。
•字母可以是大写或小写，但大小写是不同的。也就是说fishc和FishC对于Python来说是完全不同的两个名字
•等号（=）是赋值的意思，左边是名字，右边是值，不可写反咯。
插曲之字符串
•到目前为止，我们所认知的字符串就是引号内的一切东西，我们也把字符串叫做文本，文本和数字是截然不同的，咱看例子：>>>5+8
>>> '5'+'8'
•要告诉Python你在创建一个字符串，就要在字符两边加上引号，可以是单引号或者双引号，Python女士表示不挑剔。但必须成对，你不能一边单引号，另一边却花心的用上双引号结尾。
•如果字符串中需要出现单引号或双引号怎么办？
–例如我想打印字符串：Let’s go!
•有两种方法，第一种比较常用，就是使用我们的转义符号（\）对字符串中的引号进行转义：
>>> 'Let\'s go!'
原始字符串
•好像反斜杠是一个好东西，但不妨试试打印：
>>> str = 'C:\now'
•我们可以用反斜杠对自身进行转义：
>>> str = 'C:\\now'
•原始字符串的使用非常简单，只需要在字符串前边加一个英文字母r即可(则都会以原始字符串输出)：
>>>str = r'C:\now'
长字符串
•如果希望得到一个跨越多行的字符串，例如：
我爱鱼C，
正如我爱小甲鱼，
久久不肯散去……
这我们就需要使用到三重引号字符串！
004 改进我们的小游戏
•第一个改进要求：猜错的时候程序提示用户当前的输入比答案大了还是小了
与操作and
•第二个改进要求：程序应该提供多次机会给用户猜测，专业点来讲就是程序需要重复运行某些代码。
条件分支
while循环
实例1：找8
temp = input("请输入一个数据：")
guess = int(temp)
i=0
while guess != 8 and i < 3:
i = i + 1
temp = input("哎呀，猜错了，请重新输入吧：")
guess = int(temp)
if guess == 8:
print("我草，你是小甲鱼心里的蛔虫嘛？")
print("哼，猜对了也没有奖励")
else:
if guess > 8:
print("哥，大了大了~~")
else:
print("嘿，小了！小了！！")
print("游戏结束，不玩啦~~")
•random模块里边有一个函数叫做：randint()，Ta会返回一个随机的整数。
实例2：找随机数
import random#导入随机数函数
secret = random.randint(1,5)#随机生成1到5的一个随机数
temp = input("请输入一个1-5的数据：")
guess = int(temp)
i=0
while guess != secret and i < 6:
i = i + 1
guess = int(temp)
if guess == secret:
print("我草，你是小甲鱼心里的蛔虫嘛？")
print("哼，猜对了也没有奖励")
else:
if guess > secret:
print("哥，大了大了~~")
else:
print("嘿，小了！小了！！")
temp = input("请重新输入吧：")
print("游戏结束，不玩啦~~")
005 闲聊之Python的数据类型
Python的一些数值类型：整型、布尔类型（True与False）、浮点型、e记法、复数类型等
e记法（e4相当于10的四次方，e-10相当于10的-10次方）
类型转换
字符型转换为整型
其它同上
type()函数(可查看变量类型)
isinstance()函数（用来判断两个输入参数类型是否一致）
006 Pyhon之常用操作符
算术操作符
注：python中 \ 为除法， \\ 为整除 ，% 为取余幂运算（3的二次方）
3的二次方后取负
注：先幂运算、然后乘除、后加减、后逻辑3的负二次方
比较操作符
逻辑操作符
优先级问题
007 了不起的分支和循环
打飞机游戏框架：
加载背景音乐
播放背景音乐（设置单曲循环）
我方飞机诞生
while True:
if 用户是否点击了关闭按钮：
推出程序
interval += 1;
if interval == 50:
interval = 0;
小飞机诞生
小飞机移动一个位置
屏幕刷新
if 用户鼠标产生移动：
我方飞机中心位置 = 用户鼠标位置
屏幕刷新
if 我方飞机与小飞机发生肢体冲突：
我方挂，播放撞机音乐
修改我方飞机图案
打印“Game over"
停止背景音乐，最好淡出008 了不起的分支和循环2
•现在小甲鱼来考考大家：
–按照100分制，90分以上成绩为A，80到90为B，60到80为C，60以下为D，写一个程序，当用户输入分数，自动转换为ABCD的形式打印。
score = int(input('请输入一个分数：'))
if 100 >= score >= 90:
print('A')
elif 90 > score >= 80:
print('B')
elif 80 > score >= 60:
print('C')
elif 60 > score >= 0:
print('D')
else:
print('输入错误！')条件表达式（三元操作符）
有了这个三元操作符的条件表达式，你可以使用一条语句来完成以下的条件判断和赋值操作：
x, y = 4, 5
if x < y:
small = x
else:
small = y
例子可以改进为
small = x if x < y else y #如果x小于y，则small等于x，否则等于y
断言（assert）
•assert这个关键字我们称之为“断言”，当这个关键字后边的条件为假的时候，程序自动崩溃并抛出AssertionError的异常。
•举个例子：
>>> assert 3 > 4
•一般来说我们可以用Ta再程序中置入检查点，当需要确保程序中的某个条件一定为真才能让程序正常工作的话，assert关键字就非常有用了。
009 了不起的分支和循环3
while循环
while 条件：
循环体
for循环
•虽然说Python是由C语言编写而来的，但是Ta的for循环跟C语言的for循环不太一样，Python的for循环显得更为智能和强大！
•语法：
for 目标 in 表达式：
循环体
每次取FishC中一个字符及空格输出
range()函数
•语法：range( [strat],[stop],[step] )
–这个BIF有三个参数，其中用中括号括起来的两个表示这两个参数是可选的。
–step=1表示第三个参数的值默认值是1。setp为每步距离
–range这个BIF的作用是生成一个从start参数的值开始到stop参数的值结束的数字序列。
break语句（结束本层循环）
实例：
bingo = '小甲鱼是帅哥'
answer = input('请输入小甲鱼最想听的一句话：')while True:
if answer == bingo:
break
answer = input('抱歉，错了，请重新输入（答案正确才能退出游戏）：')print('哎哟，帅哦~')
print('您真是小甲鱼肚子里的蛔虫啊^_^')
continue语句（当前位置结束本次循环，重新开始下次循环）
实例：
for i in range(10):
if i%2 != 0:
print(i)
continue
i += 2
print(i)
010 列表：一个打了激素的数组
列表：一个打了激素的数组
创建列表
•创建一个普通列表
•创建一个混合列表
•创建一个空列表
向列表添加元素
append()函数向列表末尾添加一个元素
extend()函数向列表末尾添加多个元素
insert(n,xxx)函数向列表中第n个元素前插入一个元素
注：0表示第一个元素
011列表：一个打了激素的数组2
从列表中获取元素
•跟数组一样，我们可以通过元素的索引值（index）从列表获取单个元素，注意，列表索引值是从 0 开始的。
从列表删除元素
remove()函数表示从列表中删除某个元素
del()函数也表示从列表中删除某个元素
pop()函数从列表中取出最后一个元素
列表分片（Slice）
•利用索引值，每次我们可以从列表获取一个元素，但是我们总是贪心的，如果一次性需要获取多个元素，有没有办法实现呢？利用列表分片，我们可以简单的实现这个要求。
member[0:2]表示从第1个元素开始拷贝，一共拷贝两个元素，即member[0]和member[1]列表的拷贝
012列表：一个打了激素的数组3
列表的一些常用操作符
•比较操作符
•逻辑操作符
•连接操作符
•重复操作符
•成员关系操作符
关于分片“拷贝”概念的补充
>>> dir(list)可查看所有列表的操作函数
count()函数可计算列表中相同元素个数
index()函数可索引列表元素
reverse()将列表中元素倒序
sort()将列表中元素从小到大排序
关于分片“拷贝”概念的补充
注：list13=list11相当于多了个指向列表的标签，list12 = list[:]是实实在在的拷贝013元组：戴上了枷锁的列表
•由于和列表是近亲关系，所以元组和列表在实际使用上是非常相似的。
•我们这节课主要通过讨论元组和列表到底有什么不同来学习元组，酱紫大家就不会觉得老是重复一样的内容。
•我们主要从以下几个点来讨论学习：
–创键和访问一个元组
创建元组（括号可以没有，但逗号一定要有）
访问元组前两个元素
–更新和删除一个元组
更新一个元组
注：其并未对原元组进行修改，而是生成了一个新的元组，并贴上temp名字标签而已。原元组由于标签没有了，则会被自动回收。删除一个元组
–元组相关的操作符
注：元组不允许修改和删除。014字符串：各种奇葩的内置方法
015字符串：格式化
由于花括号被解释掉，所以不打印后面中文
字符串格式化符号含义
将ASCII码97对应的字符输出
格式化整数
格式化操作符辅助命令
5表示输出为五位数Python 的转义字符及其含义
016 序列！序列！
•列表、元组和字符串的共同点
–都可以通过索引得到每一个元素
–默认索引值总是从0开始
–可以通过分片的方法得到一个范围内的元素的集合
–有很多共同的操作符（重复操作符、拼接操作符、成员关系操作符）
使用list方法
元组转换为列表
注：元组为小括号，列表为中括号。max() 返回序列或者参数集合中的最大值
min() 返回序列或者参数集合中的最小值
sum(iterable[,start=0]) 返回序列iterable和可选参数start的总和
sorted()将元素从小到大重新排列
reversed()将元素倒序排列
注：元组是不可以修改和删除的，所以不可以直接对元组使用sorted与reversed命令enumerate()将每个元素插入枚举
zip()返回由各个参数的序列组成的元组
017函数：Python的乐高积木
定义一个函数和调用
018 函数：灵活即强大
形参和实参
>>> def MyFirstFunction(name):
'函数定义过程中的name是叫形参'
#因为Ta只是一个形式，表示占据一个参数位置
print('传递进来的' + name + '叫做实参，因为Ta是具体的参数值！')
>>> MyFirstFunction('小甲鱼')
传递进来的小甲鱼叫做实参，因为Ta是具体的参数值！
关键字参数
默认参数(即形参中给定默认值，则在未给实参时会以默认值输出)
收集参数
019函数：我的地盘听我的
函数与过程
再谈谈返回值
如果有返回值，函数则返回对应值；如果没有，则返回None
可以返回多个值
019函数：我的地盘听我的（局部变量与全局变量）
def discounts(price, rate):
final_price = price * rate
old_price = 88 #这里试图修改全局变量
print('修改后old_price的值是：', old_price)
return final_priceold_price = float(input('请输入原价：'))
rate = float(input('请输入折扣率：'))
new_price = discounts(old_price, rate)
print('修改后old_price的值是：', old_price)
print('打折后价格是：', new_price)
global可将局部变量声明为全局变量
020函数：内嵌函数和闭包
内嵌函数
闭包（closure）
注：使用nonlocal语句将x强制为不是局部变量021函数：lambda表达式
lambda表达式的作用
•Python写一些执行脚本时，使用lambda就可以省下定义函数过程，比如说我们只是需要写个简单的脚本来管理服务器时间，我们就不需要专门定义一个函数然后再写调用，使用lambda就可以使得代码更加精简。
•对于一些比较抽象并且整个程序执行下来只需要调用一两次的函数，有时候给函数起个名字也是比较头疼的问题，使用lambda就不需要考虑命名的问题了。
•简化代码的可读性，由于普通的屌丝函数阅读经常要跳到开头def定义部分，使用lambda函数可以省去这样的步骤。
过滤函数filter可筛选出非零元素
筛选出奇数
注：lambda x:x%2用来判断是否为奇，x为奇则输出1，否则输出0；range(10)可生成0-9的10个整数，filter用来筛选非零元素；如果为偶数，则被筛选掉；如果为奇数，则保留，但输出的是rang(10)产生的原始数，因为lambda只是用来判断是否为奇偶
range生成的0-9给了x，x经过2倍运算后再赋值给x022 函数：递归是神马
汉诺塔游戏
树结构的定义
谢尔宾斯基三角形
递归求阶乘
•写一个求阶乘的函数
–正整数阶乘指从1乘以2乘以3乘以4一直乘到所要求的数。
–例如所给的数是5，则阶乘式是1×2×3×4×5，得到的积是120，所以120就是4的阶乘。
•假设我们n的值传入是5，那么：
实例：求阶乘
def factorial(n):
result = n
for i in range(1, n):
result *= ireturn result
number = int(input('请输入一个正整数：'))
result = factorial(number)
print("%d 的阶乘是：%d" % (number, result))#格式化为整数类型
实例2：递归求阶乘
def factorial(n):
if n == 1:
return 1
else:
return n * factorial(n-1)number = int(input('请输入一个正整数：'))
result = factorial(number)
print("%d 的阶乘是：%d" % (number, result))
023 递归：这帮小兔崽子
坑爹的兔子
斐波那契数列的迭代实现
我们都知道兔子繁殖能力是惊人的，如下图：
我们可以用数学函数来定义：
课间练习：假设我们需要求出经历了20个月后，总共有多少对小兔崽子？（迭代 vs 递归）
def fab(n):
n1 = 1
n2 = 1
n3 = 1if n < 1:
print('输入有误！')
return -1while (n-2) > 0:
n3 = n2 + n1
n1 = n2
n2 = n3
n -= 1
return n3result = fab(20)
if result != -1:
print('总共有%d对小兔崽子诞生！' % result)
斐波那契数列的递归实现
递归实现（递归计算时间将拉长）
def fab(n):
if n < 1:
print('输入有误！')
return -1if n == 1 or n == 2:
return 1
else:
return fab(n-1) + fab(n-2)result = fab(35)
if result != -1:
print('总共有%d对小兔崽子诞生！' % result)
注：迭代计算时间远比递归少，因为递归要循环出入栈024 递归：汉诺塔
递归求解汉诺塔
•对于游戏的玩法，我们可以简单分解为三个步骤
–将前63个盘子从X移动到Y上。
–将最底下的第64个盘子从X移动到Z上。
–将Y上的63个盘子移动到Z上。
•问题一：将X上的63个盘子借助Z移到Y上；
•问题二：将Y上的63个盘子借助X移到Z上。
•对于游戏的玩法，我们可以简单分解为三个步骤
–将前63个盘子从X移动到Y上。
–将最底下的第64个盘子从X移动到Z上。
–将Y上的63个盘子移动到Z上。
•问题一：将X上的63个盘子借助Z移到Y上；
•问题二：将Y上的63个盘子借助X移到Z上。
实例：
def hanoi(n, x, y, z):
if n == 1:
print(x, ' --> ', z)
else:
hanoi(n-1, x, z, y) # 将前n-1个盘子从x移动到y上
print(x, ' --> ', z) # 将最底下的最后一个盘子从x移动到z上
hanoi(n-1, y, x, z) # 将y上的n-1个盘子移动到z上n = int(input('请输入汉诺塔的层数：'))
hanoi(n, 'X', 'Y', 'Z')
025 字典：当索引不好用时
映射
创建和访问字典
>>> dict4 = dict(小甲鱼='让编程改变世界',李宁='一切皆有可能')
>>> dict4
{'小甲鱼': '让编程改变世界', '李宁': '一切皆有可能'}>>> dict4['爱迪生'] = '天才是99%的汗水加1%的灵感'
>>> dict4
{'小甲鱼': '让编程改变世界', '李宁': '一切皆有可能', '爱迪生': '天才是99%的汗水加1%的灵感'}026 字典：当索引不好用时2
fromkey()方法用于创建并返回一个新的字典。它有两个参数，第一个参数是字典的键；第二个参数是可选的，是传入键的值。如果不提供，默认是None
>>> dict1 = {}
>>> dict1.fromkeys((1,2,3))
{1: None, 2: None, 3: None}
>>> dict2 = {}
>>> dict2.fromkeys((1,2,3),"Number")
{1: 'Number', 2: 'Number', 3: 'Number'}
>>> dict3 = {}
>>> dict3.fromkeys((1,2,3),('one','two','three'))
{1: ('one', 'two', 'three'), 2: ('one', 'two', 'three'), 3: ('one', 'two', 'three')}访问字典的方法有key()、values()和items()
key()用于返回字典中的键，value()用于返回字典中所有的值，item()当然就是返回字典中所有的键值对（也就是项）
>>> dict1 = dict1.fromkeys(range(5),'赞')
>>> dict1.keys()
dict_keys([0, 1, 2, 3, 4])
>>> dict1.values()
dict_values(['赞', '赞', '赞', '赞', '赞'])
>>> dict1.items()
dict_items([(0, '赞'), (1, '赞'), (2, '赞'), (3, '赞'), (4, '赞')])get()方法提供了更宽松的方式去访问字典项，当键不存在的时候，get()方法并不会报错，只是默默第返回一个None，表示啥都没找到：
>>> dict1.get(10)
>>> dict1.get(4)
'赞'如果希望找不到数据时返回指定的值，可以在第二个参数设置对应的默认返回值：
>>> dict1.get(32,'木有')
'木有'如果不知道一个键是否在字典中，可以使用成员资格操作符（in 或 not in）来判断
>>> 31 in dict1
False
>>> 4 in dict1clear()可清空一个字典
>>> dict1
{0: '赞', 1: '赞', 2: '赞', 3: '赞', 4: '赞'}
>>> dict1.clear()
>>> dict1
{}copy()方法是复制字典（全拷贝）
>>> a = {1:'one',2:'two',3:'three'}
>>> b = a.copy()
>>> id(a)
52448840
>>> id(b)
52503624
>>> a[1] = 'four'
>>> a
{1: 'four', 2: 'two', 3: 'three'}
>>> b
{1: 'one', 2: 'two', 3: 'three'}pop()是给定键弹出对应的值，popitem()是随机弹出一个项
>>> a.pop(2)
'two'
>>> a
{1: 'four', 3: 'three'}
>>> a.popitem()
(1, 'four')
>>> a
{3: 'three'}setdefault()方法与get()方法相似，但setdefault()在字典中找不到相应的键值时会自动添加
>>> a = {1:'one',2:'two',3:'three'}
>>> a.setdefault(2)
'two'
>>> a.setdefault(4)
>>> a
{1: 'one', 2: 'two', 3: 'three', 4: None}update()方法可以更新字典
>>> a = {1:'one','小白':None}
>>> b = {'小白':'狗'}
>>> a.update(b)
>>> a
{1: 'one', '小白': '狗'}027 集合：在我的世界里，你就是唯一
字典的表亲--集合（在python3中，如果用大括号括起一堆数字但没有体现映射关系，那么就会认为这堆玩意儿就是个集合）
>>> num1 = {}
>>> type(num1)
<class 'dict'>
>>> num2 = {1,3,4}
>>> type(num2)
<class 'set'>集合中的元素都是唯一的（集合会自动帮我们把重复的数据清理掉，集合是无序的，所以不能试图去索引集合中的某一个元素）
>>> num = {1,2,3,4,5,5,4,3,2,1}
>>> num
{1, 2, 3, 4, 5}如何创建一个集合有两种方法：1、直接把一堆元素用大括号括起来；2、用set()
•一种是直接把一堆元素用花括号括起来
>>> set1 = {'小甲鱼','小鱿鱼','小甲鱼'}
•一种是使用set()工厂函数
>>> set2 = set(['小甲鱼','小鱿鱼','小甲鱼'])
>>> set1 == set2
True课堂搞搞看
要求：去掉列表中重复的元素
[0, 1, 2, 3, 4, 5, 5, 3, 1]
方法一、
>>> list1 = [1,2,3,4,5,5,3,1,0]
>>> temp = list1[:]
>>> list1.clear()
>>> list1
[]
>>> for each in temp:
if each not in list1:
list1.append(each) #append()表示向列表中添加元素方法二、
>>> list1 = list(set(list1))
>>> list1
[0, 1, 2, 3, 4, 5]#set(list1)先将list1列表转变为集合， list(set(list1))再讲集合转变为列表
如何访问集合中的值
由于集合中的元素是无序的，所以并不能像序列那样用下标来进行访问，但是可以使用迭代把集合中的数据一个个读取出来
•可以使用for把集合中的数据一个个读取出来
>>> set1 = {1,2,3,4,5,4,3,2,1,0}
>>> for each in set1:
print(each,end = ' ')
0 1 2 3 4 5•也可以通过in和not in判断一个元素是否在集合中已经存在
>>> 0 in set1
True
>>> 8 in set1
False使用add()方法可以为集合添加元素，使用remove()方法可以删除集合中已知的元素：
>>> set1.add(6)
>>> set1
{0, 1, 2, 3, 4, 5, 6}
>>> set1.remove(5)
>>> set1
{0, 1, 2, 3, 4, 6}不可变集合（把元素给froze冰冻起来）(像元组一样不能随意地增加或删除集合中的元素)
028 文件：因为懂你，所以永恒
大多数u程序都是：首先接收输入数据，然后按照要求进行处理，最后输出数据
虽然当前数据放在内存中存取的速度要比硬盘中快，但一旦断电则会丢失，所以尽量ctrl+s保持到硬盘中
什么是文件
打开文件
open(file, mode='r', buffering=-1, encoding=None,errors=None, newline=None, closefd=True, opener=None)
open()的第一个参数是传入的文件名，第二个参数是指定文件的打开模式
文件对象方法
>>> f = open("D:\\python3.3.2\Hello.txt")
>>> f
<_io.TextIOWrapper name='D:\\python3.3.2\\Hello.txt' mode='r' encoding='cp936'>
>>> f.read()
"A. HISTORY OF THE SOFTWARE\n==========================\n\nPython was created in the early 1990s by Guido van Rossum at Stichting\nMathematisch Centrum (CWI, see http://www.cwi.nl) in the Netherlands\nas a successor of a language called ABC. Guido remains Python's\nprincipal author, although it includes many contributions from others.\n\nIn 1995, Guido continued his work on Python at the Corporation for\nNational Research Initiatives (CNRI, see http://www.cnri.reston.va.us)\nin Reston, Virginia where he released several versions of the\nsoftware."
>>> f.close()
>>> f = open("D:\\python3.3.2\Hello.txt")
>>> f.read(5)
'A. HI'
>>> f.tell() #返回当前光标所在文件的位置
5
>>> f.readline()
'STORY OF THE SOFTWARE\n'
将f放入到列表>>> f = open("D:\\python3.3.2\Hello.txt",'w')#w模式写入会覆盖已存在的文件（即原文件内容全部被删除），a模式则在末尾追加写入
>>> f.write('who are you') #返回的是写入的字符数
11
>>> f.close()
029 文件：一个任务
•任务：将文件（record.txt）中的数据进行分割并按照以下规律保存起来：
–小甲鱼的对话单独保存为boy_*.txt的文件（去掉“小甲鱼:”）
–小客服的对话单独保存为girl_*.txt的文件（去掉“小客服:”）
–文件中总共有三段对话，分别保存为boy_1.txt, girl_1.txt，boy_2.txt, girl_2.txt, boy_3.txt, gril_3.txt共6个文件（提示：文件中不同的对话间已经使用“==========”分割）
test1：
f = open("record.txt")
boy = []
girl = []
count = 1for each_line in f:
if each_line[:6] != '======':#判断是否连续读到六个=
(role,line_spoken) = each_line.split(':',1)#split以:进行字符切割，
#将切得到的两部分内容依次存放在role与line_spoken中
if role == '小甲鱼':
boy.append(line_spoken)#将小甲鱼说的内容添加到列表boy中
if role == '小客服':
girl.append(line_spoken)#将小客服说的内容添加到列表girl中
else:
file_name_boy = 'boy_' + str(count) + '.txt'
file_name_girl = 'girl_' + str(count) + '.txt'boy_file = open(file_name_boy,'w')#以w模式新建一个以file_name_boy命名的txt文件
girl_file = open(file_name_girl,'w')#并贴上boy_file的标签boy_file.writelines(boy)#将列表boy中的内容写入到boy_file文件中
girl_file.writelines(girl)boy_file.close()#关闭boy_file文件
girl_file.close()boy = []#清空列表boy
girl = []
count += 1file_name_boy = 'boy_' + str(count) + '.txt'
file_name_girl = 'girl_' + str(count) + '.txt'boy_file = open(file_name_boy,'w')
girl_file = open(file_name_girl,'w')boy_file.writelines(boy)
girl_file.writelines(girl)boy_file.close()
girl_file.close()#记得关闭文件
test2：
def save_file(boy,girl,count):
file_name_boy = 'boy_' + str(count) + '.txt'
file_name_girl = 'girl_' + str(count) + '.txt'boy_file = open(file_name_boy,'w')
girl_file = open(file_name_girl,'w')boy_file.writelines(boy)
girl_file.writelines(girl)boy_file.close()
girl_file.close()def split_file(file_name):
f = open(file_name)boy = []
girl = []
count = 1for each_line in f:
if each_line[:6] != '======':
(role,line_spoken) = each_line.split(':',1)#split以:进行字符切割，
#将切得到的两部分内容依次存放在role与line_spoken中
if role == '小甲鱼':
boy.append(line_spoken)
if role == '小客服':
girl.append(line_spoken)
else:
save_file(boy,girl,count)boy = []
girl = []
count += 1
save_file(boy,girl,count)
f.close()split_file('record.txt')
030 文件系统：介绍一个高大上的东西
os模块中关于文件/目录常用的函数使用方法
>>> import os
>>> os.getcwd()
'D:\\python3.3.2\\小甲鱼python\\python程序\\第二十九课'>>> os.listdir('D:\\python3.3.2\\小甲鱼python\\python程序\\第二十九课')
['boy_1.txt', 'boy_2.txt', 'boy_3.txt', 'girl_1.txt', 'girl_2.txt', 'girl_3.txt', 'record.txt', 'test.py', 'test2.py']
os.path模块中关于路径常用的函数使用方法
>>> os.path.getsize('python.exe') #获取文件的尺寸，返回值以字节为单位
031 永久存储：腌制一缸美味的泡菜(pickle)python提供了一个标准的模块pickle，可以非常容易地将列表、字典这类复杂的数据类型存储为文件。它几乎可以把所有python的对象都转化为二进制的形式存放，这个过程称为pickling，从二进制转换回对象的过程称为unpickling
pickling过程
>>> import pickle
>>> my_list = [123,3,14,'小甲鱼',['another list']]>>> pickle_file = open('D:\\python3.3.2\小甲鱼python\python程序\第三十节课\my_list.pkl','wb') #二进制写形式打开文件
>>> pickle.dump(my_list,pickle_file)
>>> pickle_file.close()
unpickling过程
>>> import pickle
>>> pickle_file = open('D:\\python3.3.2\小甲鱼python\python程序\第三十节课\my_list.pkl','rb')#以二进制读形式打开文件
>>> my_list = pickle.load(pickle_file)
>>> print(my_list)
[123, 3, 14, '小甲鱼', ['another list']]实例：城市天气打包
>>> pickle_file = open('D:\\python3.3.2\小甲鱼python\python程序\第三十一节课\city_data.pkl','wb')
>>> pickle.dump(city,pickle_file)
>>> pickle_file.close()
032 异常处理：你不可能总是对的
实例1：
file_name = input('请输入需要打开的文件名:')
file = open(file_name)
print('文件的内容是：')
for each_line in file:
print(each_line)
file.close()
注：py文件与要打开的文件在同一个文件下则不需要加路径Python标准异常总结
以下是 Python 内置异常类的层次结构：
033 异常处理：你不可能总是对的2
try-except语句
try:
检测范围
except Exception[as reason]:
出现异常（Exception）后的处理代码
实例1：
try:
f = open('TE.txt')
print(f.read())
f.close()
except OSError:
print('文件打开过程中出错了！！！')
实例2：
try:
f = open('TE.txt')
print(f.read())
f.close()
except OSError as reason:
print('文件打开出错原因是:\n' + str(reason))
实例3：
try:
sum = 1 + '1'
f = open('TE.txt')
print(f.read())
f.close()
except OSError as reason:
print('文件打开出错原因是:\n' + str(reason))
except TypeError as reason:
print('类型出错原因是:\n' + str(reason))
实例4（多个异常统一处理）：
try:
sum = 1 + '1'
f = open('TE.txt')
print(f.read())
f.close()
except(OSError, TypeError):
print('出错了')
注：try语句一旦检测到异常，剩下的语句将不会被执行
try-finally语句
try:
检测范围
except Exception[as reason]:
出现异常（Exception）后的处理代码
finally:
无论如何都会被执行的代码
实例5：
try:
f = open('test.txt')
print(f.read())
sum = 1 + '1'
except (OSError,TypeError)as reason:
print('出错了\n原因是:' + str(reason))
finally:
f.close()
raise语句可以自己抛出一个异常
034 丰富的else语句及简洁的with语句
丰富的else语句
•要么怎样，要么不怎样
if 条件：
条件为真执行
else：
条件为假执行•干完了能怎样，干不完就别想怎样
实例1：
def showMaxFactor(num):
count = num // 2#//为整除，判断是素数，只需依次判断当前数num除以1到（num // 2）都不能整除即可
while count > 1:
if num % count == 0:#判断是否整除
print('%d最大的约数是%d' % (num, count))
break#跳出循环后else并不执行
count -= 1
else:#当while循环不成立时，或者理解为while循环完全被执行完了，没有给中途跳出（即break）
print('%d是素数！' % num)num = int(input('请输入一个数：'))
showMaxFactor(num)
注：else与for语句搭配与while语句相同没有问题？那就干
只要try语句块里没有出现任何异常，那么就会执行else语句块里的内容啦
实例2：
try:#尝试运行以下程序
print(int('abc'))
except ValueError as reason:#如果程序有异常时
print('出错了：' + str(reason))
else:#程序无异常时
print('没有任何异常！')
实例3：
try:
print(int('123'))
except ValueError as reason:
print('出错了：' + str(reason))
else:
print('没有任何异常！')
简洁的with语句（with会自动帮你关闭文件）
实例4：
try:
with open('test.txt','w') as f:
for each_line in f:
print(each_line)
except (OSError,TypeError) as reason:
print('出错了\n原因是:' + str(reason))
035 图形用户界面入门：EasyGui
图形用户界面编程，也就是平时常说的GUI（Graphical User Interface）,python有一个非常简单的GUI工具包：EasyGui
GUI的安装
导入方法一：
>>> import easygui #导入EasyGui
>>> easygui.msgbox('嗨，亦我飞也')
导入方法二：
>>> from easygui import *
>>> msgbox('嗨，亦我飞也')导入方法三（推荐使用）：
>>> import easygui as g
>>> g.msgbox('嗨，亦我飞也')显示图片（注：图片需要为GIF格式，且存放在python.exe通目录）
>>> easygui.buttonbox(msg='你喜欢以下哪种水果',title='亦我飞也',choices=('草莓','西瓜','芒果'),image='aa.gif')
实例1：
import easygui as g
import sys
while 1:
g.msgbox("嗨，欢迎进入第一个界面小游戏")
msg = "请问你希望在鱼C工作室学习到什么知识呢"
title="小游戏互动"
choices=["谈恋爱","编程","OOXX","琴棋书画"]
choice=g.choicebox(msg,title,choices)
#note that we convert choice to string,in case
#the user cancelled the choice,and we got None
g.msgbox("你的选择是:"+str(choice),"结果")
msg="你希望重新开始小游戏吗?"
title=" 请选择"
if g.ccbox(msg,title): #show a Contiue/Cancel dialog
pass #user chose Contonue
else:
sys.exit(0) #user chose Cancel
修改窗口大小（choicebox）
修改文字大小（PROPORTIONAL_FONT）
036 类和对象：给大家介绍对象
给大家介绍对象
把乱七八糟的数据扔进列表里，称数据层面的封装
把常用的代码段打包成一个函数，称语句层面的封装
把数据和代码都封装在一起，称对象层面的封装
对象 = 属性 + 方法
对象可以从静态（属性）与动态（方法）两个特征来描述
OO（面向对象）的特征
继承
class Turtle: # Python 中的类名约定以大写字母开头
"""关于类的一个简单例子"""
# 属性
color = 'green'
weight = 10
legs = 4
shell = True
mouth = '大嘴'# 方法
def climb(self):
print("我正在很努力的向前爬......")def run(self):
print("我正在飞快的向前跑......")def bite(self):
print("咬死你咬死你！！")def eat(self):
print("有得吃，真满足^_^")def sleep(self):
print("困了，睡了，晚安，Zzzz")调用类中的方法：
>>> tt = Turtle() #声明tt对象继承Turtle()
>>> tt.climb()
我正在很努力的向前爬......
>>> tt.bite()
咬死你咬死你！！定义一个带列表类MyList，将list2对象继承于它，则列表的功能继承它的对象都可以使用
>>> class MyList(list):
pass>>> list2 = MyList()
>>> list2.append(5)
>>> list2.append(6)>>> list2.append(1)
>>> list2
[5, 6, 1]
>>> list2.sort()
>>> list2
[1, 5, 6]多态（下例中都调用的名字相同的方法，但实现不一样）
>>> class A:
def fun(self):
print('我是小A。。。')
>>> class B:
def fun(self):
print('我是小B。。。')
>>> a = A()
>>> b = B()
>>> a.fun()
我是小A。。。
>>> b.fun()
我是小B。。。037 类和对象：面向对象编程
self是什么？
Python的self其实就相当于C++的this指针。由同一个类可以生产无数对象，当一个对象的方法被调用的时候，对象会将自身的引用作为第一个参数传给该方法，那么python就知道需要操作哪个对象的方法了。
>>> class Ball:
def setName(self,name):
self.name = name
def kick(self):
print('我叫%s,该死的，谁踢我。。。' % self.name)
>>> a = Ball()>>> a.setName('球A')
>>> b = Ball()>>> b.setName('球B')
>>> a.kick()
我叫球A,该死的，谁踢我。。。
>>> b.kick()
我叫球B,该死的，谁踢我。。。你听说过Python的魔法方法吗？
python的这些具有魔法的方法，总是被双下划线所包围，例如__init__()，即构造方法，也称构造函数，这个方法会在对象被创建时自动调用。其实，实例化对象时是可以传入参数的，这些参数会自动传入__init__()方法中，可以通过重写这个方法来自定义对象的初始化操作
实例：
>>> class Ball():
def __init__(self,name):
self.name = name
def kick(self):
print('我叫%s,该死的，谁踢我。。。' % self.name)
>>> b = Ball('小土豆')
>>> b.kick()
我叫小土豆,该死的，谁踢我。。。公有和私有？python内部采用了一种叫 name mangling(名字改编)的技术
默认上对象的属性和方法都是公开的，可以直接通过点操作符（.）进行访问：
>>> class Person:
name = '亦我飞也'
>>> p = Person()
>>> p.name
'亦我飞也'为了实现定义私有变量，只需要在变量名或函数名前加上"__"两个下划线，那么这个函数或变量就会变成私有的了：
私有变量不可以直接由外部访问
>>> class Person:
__name = '亦我飞也'
>>> p = Person()
>>> p.__name
Traceback (most recent call last):
File "<pyshell#65>", line 1, in <module>
p.__name
AttributeError: 'Person' object has no attribute '__name'室友变量可以由内部（内部函数）进行访问
>>> class Person:
__name = '亦我飞也'
def getName(self):
return self.__name
>>> p = Person()
>>> p.__name
Traceback (most recent call last):
File "<pyshell#72>", line 1, in <module>
p.__name
AttributeError: 'Person' object has no attribute '__name'
>>> p.getName()
'亦我飞也'其实，name mangling(名字改编)技术，只是把双下划线开头的变量进行了改名而已。实际上在外部使用“_类名__变量名“即可访问双下划线开头的私有变量了：
>>> p._Person__name
'亦我飞也'038 类和对象：继承
继承
子类 父类
class DerivedClassName(BaseClassName):
……
实例：一个子类可以继承它的父类的所有属性和方法
>>> class Parent:
def hello(self):
print('正在调用父类的方法。。。')
>>> class Child(Parent): #子类继承父类
pass #直接往下执行>>> p = Parent()
>>> p.hello()
正在调用父类的方法。。。
>>> c = Child()
>>> c.hello()
正在调用父类的方法。。。如果子类中定义与父类同名的方法或属性，则会自动覆盖父类对应的方法和属性（即子类方法属性改变，父类是不变的）
>>> class Child(Parent):
def hello(self):
print('正在调用子类的方法')
>>> c = Child()
>>> c.hello()
正在调用子类的方法
>>> p.hello()
正在调用父类的方法。。。实例2：
import random as r
class Fish:
def __init__(self):
self.x = r.randint(0,10)
self.y = r.randint(0,10)def move(self):
self.x -= 1
print('我的位置是：',self.x,self.y)
class Goldfish(Fish):
passclass Garp(Fish):
passclass Shark(Fish):
def __init__(self):
self.hungry = Truedef eat(self):
if self.hungry:
print('吃货的梦想就是天天有的吃')
self.hungry = False
else:
print('太撑了，吃不下了！')>>> fish = Fish()
>>> fish.move()
我的位置是： -1 10
>>> fish.move()
我的位置是： -2 10
>>> goldfish = Goldfish()
>>> goldfish.move()
我的位置是： 2 3
>>> goldfish.move()
我的位置是： 1 3
>>> shark = Shark()
>>> shark.eat()
吃货的梦想就是天天有的吃
>>> shark.eat()
太撑了，吃不下了！
>>> shark.move() #报错原因时因为子类重写构造函数，覆盖了父类D的构造函数
Traceback (most recent call last):
File "<pyshell#9>", line 1, in <module>
shark.move()
File "D:\python3.3.2\小甲鱼python\python程序\第三十八节课\fish.py", line 8, in move
self.x -= 1
AttributeError: 'Shark' object has no attribute 'x'注：继承父类属性的子类，其变量值只属于当前子类，是子类的局部变量
报错修改部分解决方法一：调用未绑定的父类方法
>>> shark = Shark()
>>> shark.move()
我的位置是： 2 1
>>> shark.move()
我的位置是： 1 1报错修改部分解决方法二：使用super函数（super函数会帮我们自动找到基类的方法，而且还自动为我们传入self参数）
>>> shark = Shark()
>>> shark.move()
我的位置是： 1 1
>>> shark.move()
我的位置是： 0 1多重继承
class DerivedClassName(Base1, Base2, Base3):
……
实例：子类c同时继承基类Base1和基类Base2
>>> class Base1:
def fool1(self):
print('我是fool1,我为Base1代言。。。')
>>> class Base2:
def fool2(self):
print('我是fool2,我为Base2代言。。。')
>>> class C(Base1,Base2):
pass>>> c = C()
>>> c.fool1()
我是fool1,我为Base1代言。。。
>>> c.fool2()
我是fool2,我为Base2代言。。。039 类和对象：拾遗
组合（将需要的类一起进行实例化并放入新的类中）
实例：
class Turtle:
def __init__(self,x):
self.num = xclass Fish:
def __init__(self,x):
self.num = xclass Pool:
def __init__(self,x,y):
self.turtle = Turtle(x)
self.fish = Fish(y)def print_num(self):
print('水池里一共有乌龟 %d 条,鱼 %d 条' % (self.turtle.num,self.fish.num))>>> pool = Pool(5,2)
>>> pool.print_num()
水池里一共有乌龟 5 条,鱼 2 条•现在要求定义一个类，叫水池，水池里要有乌龟和鱼。
类、类对象和实例对象
以下例子可见，对实例对象c的count属性赋值后，就相当于覆盖了类对象C的count属性。如果没有赋值覆盖，那么引用的是类对象的count属性
>>> a = C()
>>> b = C()
>>> c = C()
>>> print(a.count,b.count,c.count)
0 0 0
>>> c.count += 10
>>> print(a.count,b.count,c.count)
0 0 10
>>> C.count += 100
>>> print(a.count,b.count,c.count)
100 100 10
另外，如果属性的名字跟方法名相同，属性会覆盖方法：
>>> class C:
def x(self):
print('X-man')
>>> c = C()
>>> c.x()
X-man
>>> c.x = 1 #新定义对象c的一个x属性，并赋值为1
>>> c.x
1
>>> c.x() #可见，方法x()已经被属性x给覆盖了
Traceback (most recent call last):
File "<pyshell#8>", line 1, in <module>
c.x()
TypeError: 'int' object is not callable结论：不要试图在一个类里边定义出所有能想到的特性和方法，应该利用继承和组合机制来进行扩展；用不同的词性命名，如属性名用名词、方法名用动词，并使用骆驼命名法等。
到底什么是绑定？
实例1：（python严格要求需要有实例才能被调用，即绑定概念）
>>> class BB:
def printBB(): #缺少self，导致无法绑定具体对象
print('no zuo no die')
>>> BB.printBB()
no zuo no die
>>> bb = BB()
>>> bb.printBB() #出现错误原因是由于绑定机制，自动把bb对象作为第一个参数传入
Traceback (most recent call last):
File "<pyshell#15>", line 1, in <module>
bb.printBB()
TypeError: printBB() takes 0 positional arguments but 1 was given
•Python严格要求方法需要有实例才能被调用，这种限制其实就是Python所谓的绑定概念。
040 类和对象：一些相关的BIF
一些相关的BIF
issubclass(class, classinfo) 如果第一个参数（class）是第二个参数（classinfo）的一个子类，则返回True，否则返回False
>>> class A:
pass>>> class B(A):
pass>>> issubclass(B,A)
True
>>> issubclass(B,B) #一个类被认为是其自身的子类
True
>>> issubclass(B,object) # object是所有类的基类
True
>>> class C:
pass>>> issubclass(B,C)
Falseisinstance(object, classinfo) 如果第一个参数（object）是第二个参数（classinfo）的实例对象，则返回True，否则返回False
>>> issubclass(B,C) 注：第一个参数如果不是对象，则永远返回False
False
>>> b1 = B()
>>> isinstance(b1,B)
True
>>> isinstance(b1,C)
False
>>> isinstance(b1,A)
True
>>> isinstance(b1,(A,B,C))
Truehasattr(object, name) 用来测试一个对象里是否有指定的属性，第一个参数（object）是对象，第二个参数（name）是属性名（属性的字符串名字）
>>> class C:
def __init__(self,x=0):
self.x = x
>>> c1 = C()
>>> hasattr(c1,'x') #注意，属性名要用引号括起来
Truegetattr(object, name[, default]) 返回对象指定的属性值，如果指定的属性不存在，则返回default(可选参数);若没有设置default参数，则抛出异常
>>> getattr(c1,'x')
0
>>> getattr(c1,'y')
Traceback (most recent call last):
File "<pyshell#25>", line 1, in <module>
getattr(c1,'y')
AttributeError: 'C' object has no attribute 'y'setattr(object, name, value) 可以设置对象中指定属性的值，如果指定的属性不存在，则会新建属性并赋值
>>> setattr(c1,'y','FishC')
>>> getattr(c1,'y')
'FishC'delattr(object, name) 用于删除对象中指定的属性，如果属性不存在，抛出异常。
>>> delattr(c1,'y')
>>> delattr(c1,'Z')
Traceback (most recent call last):
File "<pyshell#30>", line 1, in <module>
delattr(c1,'Z')
AttributeError: Zproperty(fget=None, fset=None, fdel=None, doc=None) 用来通过属性设置属性，第一个参数是获取属性的方法名，第二个参数是设置属性的方法名，第三个参数是删除属性的方法名
>>> class C:
def __init__(self,size =10):
self.size = size
def getSize(self):
return self.size
def setSize(self,value):
self.size = value
def delSize(self):
del self.size
x=property(getSize,setSize,delSize)>>> c = C()
>>> c.x #调用getSize()
10
>>> c.x = 12 #调用SetSize()
>>> c.x
12
>>> c.size
12
>>> del c.x #调用DelSize()
>>> c.size
Traceback (most recent call last):
File "<pyshell#53>", line 1, in <module>
c.size
AttributeError: 'C' object has no attribute 'size'041 魔法方法：构造和析构
__init__(self[, ...]) 方法是类在实例化成对象的时候首先会调用的一个方法
>>> class Rectangle:
def __init__(self,x,y):
self.x = x
self.y = y
def getPeri(self):
return (self.x + self.y) * 2
def getArea(self):
return self.x * self.y
>>> rect = Rectangle(5,2)
>>> rect.getPeri()
14
>>> rect.getArea()
10注：__init__()方法的返回值一定是None
其实，__new__()才是在一个对象实例化时候所调用的第一个方法，它的第一个参数是这个类（cla）,而其他的参数会直接传递给__init__()方法
__new__(cls[, ...])
>>> class CapStr(str):
def __new__(cls,string):
string = string.upper()
return str.__new__(cls,string)
>>> a = CapStr('hello world')
>>> a
'HELLO WORLD__del__(self) 当对象将要被销毁的时候，这个方法就会被调用。但要注意，并非del x就相当于调用x.__del__()，__del__()方法是当垃圾回收机制回收这个对象的时候才调用的。
>>> class C:
def __init__(self):
print('我是__init__方法，我被调用了...')
def __del__(self):
print('我是__del__方法，我被调用l...')
>>> c1 = C() #创建对象c1
我是__init__方法，我被调用了...
>>> c2 = c1
>>> c3 = c2
>>> del c1
>>> del c2
>>> del c3 #删除c3时，对象c1才会彻底被删除（即没有标签指向对象c1时，其才会被回收）
我是__del__方法，我被调用l...042 魔法方法：算术运算
python2.2以后，对类和类型进行了统一，做法就是讲int()、float()、str()、list()、tuple()这些BIF转换为工厂函数（类对象）：
>>> type(len)
<class 'builtin_function_or_method'> #普通的BIF
>>> type(int)
<class 'type'> #工厂函数（类对象），当调用它们的时候，其实就是创建了一个相应的实例对象
>>> type(dir)
<class 'builtin_function_or_method'>
>>> type(list)
<class 'type'>>>> a = int('123') #创建一个相应的实例对象a
>>> b = int('345')
>>> a + b #python在两个对象进行相加操作
468
举个例子，下面定义一个比较特立独行的类：
>>> class New_int(int):
def __add__(self,other):
return int.__sub__(self,other)
def __sub__(self,other):
return int.__add__(self,other)
>>> a = New_int(3)
>>> b = New_int(5)
>>> a + b #两个对象相加，触发 __add__(self,other)方法
-2
>>> a - b
8
>>>实例2：
>>> class New_int(int):
def __add__(self,other):
return (int(self) + int(other)) #将self与other强制转换为整型，所以不会出现两个对象相加触发__add__()方法
def __sub__(self,other):
return (int(self) - int(other))
>>> a = New_int(3)
>>> b = New_int(5)
>>> a + b
8043 魔法方法：算术运算2
实例1：
>>> class int(int):
def __add__(self,other):
return int.__sub__(self,other)
>>> a = int(3)
>>> b = int(2)
>>> a + b
1反运算：
反运算与算术运算符的不同之处是，反运算多了一个'r'，例如 __add__()的反运算对应为 __radd__()
>>> a + b
这里a是加数，b是被加数，如果a对象的__add__()方法没有实现或者不支持相应的操作，那么python就会自动调用b的__radd__()方法
实例：
>>> class Nint(int):
def __radd__(self,other):
return int.__sub__(self,other)
>>> a = Nint(5)
>>> b = Nint(3)
>>> a + b #由于a对象默认有__add__()方法，所以b的__radd__()没有执行
8实例2：
>>> class Nint(int):
def __radd__(self,other):
return int.__sub__(self,other)
>>> b = Nint(5)
>>> 3 + b #由于3无__add__()方法，所以执行b的反运算__radd__(self,other)方法，其中self是b对象
2注：在重写反运算魔法方法时，一定要注意顺序问题。
增量赋值运算：
比较操作符：
其它操作符：
044 魔法方法：简单定制
简单定制
•基本要求：
–定制一个计时器的类
–start和stop方法代表启动计时和停止计时
–假设计时器对象t1，print(t1)和直接调用t1均显示结果
–当计时器未启动或已经停止计时，调用stop方法会给予温馨的提示
–两个计时器对象可以进行相加：t1 + t2
–只能使用提供的有限资源完成
你需要这些资源
•使用time模块的localtime方法获取时间
–扩展阅读：time 模块详解（时间获取和转换）
有关time模块的localtime方法获取时间（参考：
•time.localtime返回struct_time的时间格式
•表现你的类：__str__ 和 __repr__
实例：
import time as t #导入时间模块，调用对象t
class Mytimer():
def __init__(self):
self.unit = ['年','月','天','小时','分钟','秒']
self.prompt = "未开始计时"
self.lasted = []
self.begin = 0 #属性
self.end = 0
def __str__(self):
return self.prompt__repr__ = __str__
def __add__(self,other): #重写加法操作符，运行时间相加
prompt = "总共运行了"
result = []
for index in range(6):
result.append(self.lasted[index] + other.lasted[index])
if result[index]:
prompt += (str(result[index]) + self.unit[index])
return prompt
#开始计时
def start(self): #方法，属性名和方法名不能相同
if not self.stop:
self.prompt = ("提示：请先调用stop()停止计时！")
else:
self.begin = t.localtime()
print('计时开始...')#停止计时
def stop(self):
if not self.begin:
print('提示：请先调用start()进行计时！')
else:
self.end = t.localtime()
self._calc()
print('计时结束！')#内部方法，计算运行时间
def _calc(self):
self.prompt = "总共运行了"
for index in range(6):
self.lasted.append(self.end[index] - self.begin[index])
if self.lasted[index]:
self.prompt += (str(self.lasted[index]) + self.unit[index])
#为下一轮计时初始化变量
self.begin = 0
self.end = 0>>> t1 = Mytimer()
>>> t1.stop()
提示：请先调用start()进行计时！
>>> t1.start()
计时开始...
>>> t1.stop()
计时结束！
>>> t1
总共运行了4秒
>>> t2 = Mytimer()
>>> t2.start()
计时开始...
>>> t2.stop()
计时结束！
>>> t2
总共运行了4秒
>>> t1 + t2
'总共运行了8秒'进阶定制
•如果开始计时的时间是（2022年2月22日16:30:30），停止时间是（2025年1月23日15:30:30），那按照我们用停止时间减开始时间的计算方式就会出现负数（3年-1月1天-1小时），你应该对此做一些转换。
•现在的计算机速度都非常快，而我们这个程序最小的计算单位却只是秒，精度是远远不够的。
045 魔法方法：属性访问
属性访问
•__getattr__(self, name)
–定义当用户试图获取一个不存在的属性时的行为
•__getattribute__(self, name)
–定义当该类的属性被访问时的行为
•__setattr__(self, name, value)
–定义当一个属性被设置时的行为
•__delattr__(self, name)
–定义当一个属性被删除时的行为
实例1：
class C:
def __getattribute__(self, name):
print('getattribute')
# 使用 super() 调用 object 基类的 __getattribute__ 方法
return super().__getattribute__(name)def __setattr__(self, name, value):
print('setattr')
super().__setattr__(name, value)def __delattr__(self, name):
print('delattr')
super().__delattr__(name)def __getattr__(self, name):
print('getattr')>>> c = C()
>>> c.x
getattribute
getattr
>>> c.x = 1
setattr
>>> c.x
getattribute
1
>>> del c.x
delattr
>>> setattr(c,'y','Yellow')
setattr练习要求
•写一个矩形类，默认有宽和高两个属性；
•如果为一个叫square的属性赋值，那么说明这是一个正方形，值就是正方形的边长，此时宽和高都应该等于边长。
实例2：
class Rectangle:
def __init__(self, width=0, height=0):
self.width = width
self.height = heightdef __setattr__(self, name, value):#一发生赋值操作，则会触发__setattr__()魔法方法
if name == 'square':#判断name属性是否为正方形
self.width = value
self.height = value
else:
self.__dict__[name] = valuedef getArea(self):
return self.width * self.height>>> r1 = Rectangle(4,5)
>>> r1.getArea()
20
>>> r1.square = 10
>>> r1.getArea()
100046 魔法方法：描述符（Property的原理）
描述符
•描述符就是将某种特殊类型的类的实例指派给另一个类的属性。
•__get__(self, instance, owner)
–用于访问属性，它返回属性的值
•__set__(self, instance, value)
–将在属性分配操作中调用，不返回任何内容
•__delete__(self, instance)
–控制删除操作，不返回任何内容
实例：
>>> class MyDecriptor:
def __get__(self,instance,owner):
print("getting...",self,instance,owner)
def __set__(self,instance,value):
print("setting...",self,instance,value)
def __delete__(self,instance):
print("deleting...",self,instance)>>> class Test:
x = MyDecriptor() #取Mydecriptor类的实例指派给Test类的属性x>>> test = Test()
>>> test.x
getting... <__main__.MyDecriptor object at 0x00000000033467F0> <__main__.Test object at 0x000000000335EF98> <class '__main__.Test'>
>>> test
<__main__.Test object at 0x000000000335EF98>
>>> test.x = "X-man"
setting... <__main__.MyDecriptor object at 0x00000000033467F0> <__main__.Test object at 0x000000000335EF98> X-man
>>> del test.x
deleting... <__main__.MyDecriptor object at 0x00000000033467F0> <__main__.Test object at 0x000000000335EF98>实例2：
>>> class MyProperty:
def __init__(self,fget = None,fset = None,fdel = None):
self.fget = fget
self.fset = fset
self.fdel = fdel
def __get__(self,instance,owner):
return self.fget(instance)
def __set__(self,instance,value):
self.fset(instance,value)
def __delete__(self,instance):
self.fdel(instance)
>>> class C:
def __init__(self):
self._x = None
def getX(self):
return self._x
def setX(self,value):
self._x = value
def delX(self):
del self._x
x = MyProperty(getX,setX,delX)
>>> c = C()
>>> c.x = "HELLOW"
>>> c.x
'HELLOW'
>>> c._x
'HELLOW'
>>> del c.x
>>> c._x
Traceback (most recent call last):
File "<pyshell#70>", line 1, in <module>
c._x
AttributeError: 'C' object has no attribute '_x'练习要求
•先定义一个温度类，然后定义两个描述符类用于描述摄氏度和华氏度两个属性。
•要求两个属性会自动进行转换，也就是说你可以给摄氏度这个属性赋值，然后打印的华氏度属性是自动转换后的结果。
实例3：
ss Celsius: #摄氏度描述符类
def __init__(self,value = 26.0):#self为描述符类自身(此为摄氏度描述符类)的实例（此为cel)
self.value = float(value)
def __get__(self,instance,owner):#instance是这个描述符的拥有者所在的类的实例（此为temp)
return self.value
def __set__(self,instance,value):#owner是这个描述符的拥有者所在的类本身(此为温度类）
self.value = float(value)class Fahrenheit: #华氏度描述符类
def __get__(self,instance,owner):
return instance.cel * 1.8 +32 #摄氏度转华氏度
def __set__(self,instance,value):
instance.cel = ((float)(value)- 32)/ 1.8 #华氏度转摄氏度
class Temperature: #温度类
cel = Celsius() #设置摄氏度属性（描述符类的实例指派给了温度类的属性）
fah = Fahrenheit()#设置华氏度属性>>> temp = Temperature()
>>> temp.cel
26.0
>>> temp.fah
78.80000000000001
>>> temp.fah = 78.8
>>> temp.cel
25.999999999999996047 魔法方法：定制序列
协议是什么？
•协议（Protocols）与其他编程语言中的接口很相似，它规定你哪些方法必须要定义。然而，在Python中的协议就显得不那么正式。事实上，在Python中，协议更像是一种指南。
容器类型的协议
•如果说你希望定制的容器是不可变的话，你只需要定义__len__()和__getitem__()方法。
•如果你希望定制的容器是可变的话，除了__len__()和__getitem__()方法，你还需要定义__setitem__()和__delitem__()两个方法。
练习要求
•编写一个不可改变的自定义列表，要求记录列表中每个元素被访问的次数。
class CountList: #定义记录列表中每个元素访问次数类
def __init__(self,*args): #参数是可变类型的
self.values = [x for x in args]#将args的数据存入列表self.values中
self.count = {}.fromkeys(range(len(self.values)),0)#创建字典，初试化为0def __len__(self): #返回容器中元素的个数
return len(self.values)#len方法用于返回参数的长度
def __getitem__(self,key): #获取容器中指定元素的行为，key为访问对应的键
self.count[key] += 1#每访问一次，字典键对应的键值加1
return self.values[key]>>> c1 = CountList(1,3,5,7,9)
>>> c2 = CountList(2,4,6,8,10)
>>> c1[1] #c1[1]第一次访问
3
>>> c2[2]
6
>>> c1[1] + c2[2] #c1[1]第二次访问
9
>>> c1.count
{0: 0, 1: 2, 2: 0, 3: 0, 4: 0}
>>> c2.count
{0: 0, 1: 0, 2: 2, 3: 0, 4: 0}048 魔法方法：迭代器
迭代的意思类似于循环，每一次重复的过程被称为一次迭代的过程，而每一次迭代得到的结果会被用来作为下一次迭代的初始值。提供迭代方法的容器称为迭代器（如序列（列表、元组、字符串）、字典等）。
对一个容器对象调用iter()就得到它的迭代器，调用next()迭代器就会返回下一个值。入托迭代器没有值可以返回了，就会抛出异常。
•iter()
–__iter__()
•next()
–__next__()
实例1：
>>> string = "FishC"
>>> it = iter(string)
>>> next(it)
'F'
>>> next(it)
'i'
>>> next(it)
's'
>>> next(it)
'h'
>>> next(it)
'C'
>>> next(it)
Traceback (most recent call last):
File "<pyshell#8>", line 1, in <module>
next(it)
StopIteration一个容器如果是迭代器，那就必须实现__iter__()魔法方法，这个方法实际上就是返回迭代器本身。重点要实现的是__next__()魔法方法，因为它决定了迭代的规则。
实例2：
>>> class Fibs:
def __init__(self):
self.a = 0
self.b = 1
def __iter__(self):
return self
def __next__(self):
self.a,self.b = self.b,self.a + self.b
return self.a
>>> fibs = Fibs()
>>> for each in fibs:
if each < 20:
print(each)
else:
break
1
1
2
3
5
8
13实例3：
>>> class Fibs:
def __init__(self,n =20):
self.a = 0
self.b = 1
self.n = n
def __iter__(self):
return self
def __next__(self):
self.a,self.b = self.b,self.a + self.b
if self.a > self.n:
raise StopIteration
return self.a
>>> fibs = Fibs()
>>> for each in fibs:
print(each)
1
1
2
3
5
8
13>>> fibs = Fibs(10)
>>> for each in fibs:
print(each)
1
1
2
3
5
8049 乱入：生成器
所谓协同程序，就是可以运行的独立函数调用，函数可以暂停或者挂起，并在需要的时候从程序离开的地方继续或者重新开始。
生成器可以暂时挂起函数，并保留函数的局部变量等数据，然后在再次调用它的时候，从上次暂停的位置继续执行下去。
一个函数中如果有yield语句，则被定义为生成器。
实例1：
>>> def myGen():
print("生成器被执行了！")
yield 1 #暂停一次，相当于return，返回1
yield 2 #暂停一次，相当于return，返回2
>>> myG = myGen()
>>> next(myG)
生成器被执行了！
1
>>> next(myG)
2像前面介绍的斐波那契的例子，也可以用生成器来实现：
>>> def fibs():
a = 0
b = 1
while True:
a,b = b,a + b
yield a
>>> for each in fibs():
if each > 100:
break
print(each)
1
1
2
3
5
8
13
21
34
55
89列表推导式表达：
100以内，能被2整除，但不能被3整除的所有整数
>>> a = [i for i in range(100) if not (i % 2) and (i % 3 )]
>>> a
[2, 4, 8, 10, 14, 16, 20, 22, 26, 28, 32, 34, 38, 40, 44, 46, 50, 52, 56, 58, 62, 64, 68, 70, 74, 76, 80, 82, 86, 88, 92, 94, 98]字典推导式：
10以内是否为偶数
>>> a = {i:i % 2 == 0 for i in range(10)}
>>> a
{0: True, 1: False, 2: True, 3: False, 4: True, 5: False, 6: True, 7: False, 8: True, 9: False}集合推导式：
>>> a = {i for i in [1,2,3,3,4,5,5,5,6,7,7,8]}
>>> a
{1, 2, 3, 4, 5, 6, 7, 8}元组生成器推导式：
>>> e = (i for i in range(5))
>>> next(e)
0
>>> next(e)
1
>>> next(e)
2050 模块：模块就是程序
什么是模块
•容器 -> 数据的封装
•函数 -> 语句的封装
•类 -> 方法和属性的封装
•模块 -> 模块就是程序
命名空间
爱的宣言：世界上只有一个名字，使我这样牵肠挂肚，像有一根看不见的线，一头牢牢系在我心尖上，一头攥在你手中，这个名字就叫做鱼C工作室计算机一班的小花……
导入模块
•第一种：import 模块名
实例1：import导入模块
实例2：import导入模块
•第二种：from 模块名 import 函数名(不推荐使用)
•第三种：import 模块名 as 新名字（推荐使用）
TemperatureConversion文件：
def c2f(cal):
return cal * 1.8 + 32
def f2c(fah):
return (fah - 32)/1.8calc文件：
import TemperatureConversion as tc #tc为取得新名字
print("32摄氏度 = %.2f 华氏度\n" % tc.c2f(32))
print("99华氏度 = %.2f 摄氏度" % tc.f2c(99))
051 模块：__name__='__main__'、搜索路径和包
模块！模块！
实例1：为TemperatureConversion添加测试程序（TemperatureConversion被作为程序运行）
def c2f(cal):
return cal * 1.8 + 32def f2c(fah):
return (fah - 32)/1.8def test():
print("0摄氏度 = %.2f 华氏度\n" % c2f(0))
print("0华氏度 = %.2f 摄氏度" % f2c(0))test()
运行calc文
当希望TemperatureConversion被调用时作为模块导入时
def c2f(cal):
return cal * 1.8 + 32def f2c(fah):
return (fah - 32)/1.8def test():
print("0摄氏度 = %.2f 华氏度" % c2f(0))
print("0华氏度 = %.2f 摄氏度" % f2c(0))if __name__ == "__main__":#当此文件当做程序运行时，执行test()，否则不执行
test()运行calc文件
•if __name__ == ‘__main__’
•搜索路径（系统会首先搜索的路径）
>>> import sys
>>> sys.path
['D:\\python3.3.2\\小甲鱼python\\python程序\\第五十节课\\Temperature', 'D:\\python3.3.2\\Lib\\idlelib', 'C:\\windows\\system32\\python33.zip', 'D:\\python3.3.2\\DLLs', 'D:\\python3.3.2\\lib', 'D:\\python3.3.2', 'D:\\python3.3.2\\lib\\site-packages']添加搜索路径：
>>> import TemperatureConversion
Traceback (most recent call last):
File "<pyshell#0>", line 1, in <module>
import TemperatureConversion
ImportError: No module named 'TemperatureConversion'>>> import sys
>>> sys.path.append("D:\\python3.3.2\WODE\Temperature")
>>> sys.path
['', 'D:\\python3.3.2\\Lib\\idlelib', 'C:\\windows\\system32\\python33.zip', 'D:\\python3.3.2\\DLLs', 'D:\\python3.3.2\\lib', 'D:\\python3.3.2', 'D:\\python3.3.2\\lib\\site-packages', 'D:\\python3.3.2\\WODE\\Temperature']
>>> import TemperatureConversion
>>> TemperatureConversion.f2c(59)
15.0•包（package）
1.创建一个文件夹，用于存放相关的模块，文件夹的名字即包的名字；
2.在文件夹中创建一个__init__.py的模块文件，内容可以为空；
3.将相关的模块放入文件夹中
052 模块：像个极客一样去思考
使用print调用__doc__属性，可以带格式查看这个模块的简介
使用dir()可以查询到该模块定义了哪些变量、函数和类
053 论一只爬虫的自我修养
Python如何访问互联网？
•URL的一般格式为（带方括号[]的为可选项）：
protocol :// hostname[:port] / path / [;parameters][?query]#fragment
•URL由三部分组成：
–第一部分是协议：http，https，ftp，file，ed2k…
–第二部分是存放资源的服务器的域名系统或IP地址（有时候要包含端口号，各种传输协议都有默认的端口号，如http的默认端口为80）。
–第三部分是资源的具体地址，如目录或文件名等。
054 论一只爬虫的自我修养2：实战
import urllib.request
response = urllib.request.urlopen('http://placekitten.com/g/500/600')# 返回文件对象response
cat_imag = response.read()with open('cat_500_600.jpg','wb') as f:
f.write(cat_imag)
>>> response.geturl()
'http://placekitten.com/g/500/600'
>>> response.info()
<http.client.HTTPMessage object at 0x00000000034EAA20>
>>> print(response.info())
Date: Sat, 27 Jul 2019 02:44:18 GMT
Content-Type: image/jpeg
Transfer-Encoding: chunked
Connection: close
Set-Cookie: __cfduid=d3cd08233581619b9ef8464ae93f7d5ff1564195458; expires=Sun, 26-Jul-20 02:44:18 GMT; path=/; domain=.placekitten.com; HttpOnly
Access-Control-Allow-Origin: *
Cache-Control: public, max-age=86400
Expires: Sun, 28 Jul 2019 02:44:18 GMT
CF-Cache-Status: HIT
Age: 66459
Vary: Accept-Encoding
Server: cloudflare
CF-RAY: 4fcb454ecc35ce6b-LHR
>>> response.getcode()
200055 论一只爬虫的自我修养3：隐藏
修改 headers
•通过Request的headers参数修改
•
•通过Request.add_header()方法修改
代理
•步骤：
1. 参数是一个字典 {‘类型’:‘代理ip:端口号’}
proxy_support = urllib.request.ProxyHandler({})
2. 定制、创建一个 opener
opener = urllib.request.build_opener(proxy_support)
3a. 安装 opener
urllib.request.install_opener(opener)
3b. 调用 opener
opener.open(url)
064 GUI的终极选择：Tkinter
>>> import tkinter #Tkinter是python默认的GUI库，导入Tkinter模块
>>>实例1：
import tkinter as tk
root = tk.Tk()#创建一个主窗口，用于容纳整个GUI程序
root.title("FishC Demo")#设置主窗口对象的标题栏#添加一个Label组件，可以显示文本、图标或者图片（此处显示文本）
theLabel = tk.Label(root,text = "我的第二个窗口程序")
theLabel.pack()#调用Label组件的pack方法，用于自动调节组件自身尺寸root.mainloop()#执行此语句后，窗口才会显示，程序进入主事件循环
实例2：
import tkinter as tk
class App:#创建类App
def __init__(self,root):#self为指向App类的指针
#创建一个框架，然后在里面添加一个Button按钮组件，框架用来将复杂布局中按钮分组
frame = tk.Frame(root)
frame.pack(side = tk.RIGHT,padx = 10,pady = 10)#调节框架自身尺寸,此处设置为右对齐（右上角为原点），偏移（10,10)
#创建一个按钮组件，fg(foreground)，设置前景色
#创建一个Button按钮,属性为self.hi_there，属于frame框架，按钮按下时调用self.say_hi方法
#设置前景色为黑色，背景色为白色
self.hi_there = tk.Button(frame,text = "打招呼",bg = "black",fg = "white",command = self.say_hi)
self.hi_there.pack()#自动调节自身尺寸
#say_hi()方法定义实现
def say_hi(self):
print("互联网广大朋友们好，我是亦我飞也！")
root = tk.Tk()#创建一个主窗口(toplever的根窗口)，并把它作为参数实例化app对象，用于容纳整个GUI程序,
app = App(root)#创建类App的一个实例对象app，传入参数为rootapp.mainloop()#执行此语句后，窗口才会显示，程序进入主事件循环
065 GUI的终极选择：Tkinter2
实例1：Label组件显示文字与gif图片
#导入tkinter模块的所有内容
from tkinter import *#创建主窗口
root = Tk()
#创建一个文本Label对象,文字为左对齐，离左边边框距离为10
textLabel = Label(root,
text = "您下载的影片含有未成年人限制内容，\n请满18周岁后再点击观看！",
justify = LEFT,padx = 10)
#Label组件为左对齐
textLabel.pack(side = LEFT)#创建一个图像Label对象
#用PhotoImage实例化一个图片对象（支持gif格式的图片）
photo = PhotoImage(file = "18.gif")
imgLabel = Label(root,image = photo)
imgLabel.pack(side = RIGHT)mainloop()
实例2：
例2：文字显示在图片上
#导入tkinter模块的所有内容
from tkinter import *#创建主窗口
root = Tk()#创建一个图像Label对象
photo = PhotoImage(file = "bg.gif")
#创建一个文本Label对象
textLabel = Label(root,
text = "学Python\n到FishC！",
font = ("宋体",20),
fg = "white",
justify = LEFT, #文字左对齐
image = photo,
compound = CENTER, #设置文本和图像的混合模式
)
#文本Label对象偏移，离左窗口与上窗口都为10
textLabel.pack(side = LEFT,padx =10,pady =10)mainloop()
实例2：Button组件
#导入tkinter模块的所有内容
from tkinter import *def callback():
var.set("吹吧你，我才不信呢~")#创建主窗口
root = Tk()
#设置主窗口对象的标题栏
root.title("TK")frame1 = Frame(root)#框架1
frame2 = Frame(root)#框架2#创建一个文本Label对象,文字为左对齐
var = StringVar()
var.set("您下载的影片含有未成年人限制内容，\n请满18周岁后再点击观看！")
textLabel = Label(frame1,
textvariable = var, #Button显示一个StringVar的变量
justify = LEFT)
#Label组件为左对齐
textLabel.pack(side = LEFT)#创建一个图像Label对象
#用PhotoImage实例化一个图片对象（支持gif格式的图片）
photo = PhotoImage(file = "18.gif")
imgLabel = Label(root,image = photo)
imgLabel.pack(side = RIGHT)#加一个按钮
theButton = Button(frame2,text = "已满18周岁",command = callback)
theButton.pack()
frame1.pack(padx = 10,pady = 10)
frame2.pack(padx = 10,pady = 10)mainloop()
066 GUI的终极选择：Tkinter3
实例1：Checkbutton 组件
from tkinter import *
root = Tk()
#需要一个Tkinter变量，用于表示该按钮是否被选中
v = IntVar()
c = Checkbutton(root,text="测试一下",variable = v)c.pack()
#如果被选中，那么变量v被赋值为1，否则为0
#可以用个Label标签动态地给大家展示：
lable = Label(root,textvariable = v)
lable.pack()mainloop()
实例2：
from tkinter import *
root = Tk()
GIRLS = ["貂蝉","王昭君","西施","杨玉环"]
v = []
for girl in GIRLS:
v.append(girl)
c = Checkbutton(root,text = girl,variable = v[-1])#-1表示每次取v列表中最后一个元素，即刚加入的那个元素
c.pack(anchor = W)#W(western)向左对齐mainloop()
实例3：Radiobutton 组件
from tkinter import *
root = Tk()
v = IntVar()#如果被选中，v被赋值为1，否则为0
Radiobutton(root,text = "One",variable = v,value = 1).pack(anchor = W)
#value表示第一个按钮被选中时，v的值赋值给variableRadiobutton(root,text = "Two",variable = v,value = 2).pack(anchor = W)
Radiobutton(root,text = "Three",variable = v,value = 3).pack(anchor = W)
Radiobutton(root,text = "Four",variable = v,value = 4).pack(anchor = W)
mainloop()
实例4：循环处理
from tkinter import *
root = Tk()
LANGS = [
("Python",1),
("Perl",2),
("Ruby",3),
("Lua",4)]
v = IntVar()#如果被选中，v被赋值为1，否则为0
v.set(1)#将1设置为默认值
for lang,num in LANGS:
b= Radiobutton(root,text = lang,variable = v,value = num)
b.pack(anchor = W)
#value表示第一个按钮被选中时，v的值赋值给variablemainloop()
实例5：改成按钮形式
from tkinter import *
root = Tk()
LANGS = [
("Python",1),
("Perl",2),
("Ruby",3),
("Lua",4)]
v = IntVar()#如果被选中，v被赋值为1，否则为0
v.set(1)#将1设置为默认值
for lang,num in LANGS:
b= Radiobutton(root,text = lang,variable = v,value = num,indicatoron = False)
b.pack(fill = X)#表示横向填充
#value表示第一个按钮被选中时，v的值赋值给variablemainloop()
实例6：LabelFrame 组件
from tkinter import *
root = Tk()
group = LabelFrame(root,text = "最好的脚本语言是？",padx = 10,pady = 10)#按钮相对边框的偏移
group.pack(padx = 10,pady = 10)#框架相对边框的偏移LANGS = [
("Python",1),
("Perl",2),
("Ruby",3),
("Lua",4)]
v = IntVar()#如果被选中，v被赋值为1，否则为0
v.set(1)#将1设置为默认值
for lang,num in LANGS:
b= Radiobutton(group,text = lang,variable = v,value = num,indicatoron = False)
b.pack(fill = X)
#value表示第一个按钮被选中时，v的值赋值给variablemainloop()
067 GUI的终极选择：Tkinter4
实例1：
from tkinter import *
root = Tk()#创建主窗口
e = Entry(root)#在主窗口中插入输入框
e.pack(padx = 20,pady = 20)e.delete(0,END)#清空输入框
e.insert(0,"默认文本...")#设置输入框内容mainloop()
实例2：
from tkinter import *
def button1_show():
print("作品：《%s》" % e1.get())#将e1.get()中得到的输入框1的内容格式化为字符串
print("作者：%s" % e2.get())root = Tk()#创建主窗口
Label(root,text = "作品:",padx = 20,pady = 10).grid(row=0,column=0)#第1行第1列,偏移是相对于当前操作组件的相邻x轴或y轴的偏移距离
Label(root,text = "小甲鱼:").grid(row=1,column=0)#第1行第0列
e1 = Entry(root)#在主窗口中插入输入框,文本框的内容通过e1调用
e2 = Entry(root)#在主窗口中插入输入框
e1.grid(row=0,column=1,padx=10)#x方向偏移是相对于"作品"的x方向偏移的；y方向偏移表示此输入框与y方向相邻物体或边框之间偏移的距离(y方向偏移)
e2.grid(row=1,column=1,padx=10,pady=20)#x方向偏移是相对于"小甲鱼"的x方向偏移的；y方向偏移表示此输入框与y方向相邻上下物体或边框偏移的距离(y方向偏移)
#加两个按钮
Button1 = Button(root,text = "获取信息",command = button1_show)\
.grid(row = 2,column = 0,sticky = W,padx = 10,pady=10)#加入反斜杠可实现分行编辑,方位设置为最西边(即靠左)
Button2 = Button(root,text = "退出",command = root.quit).grid(row = 2,column = 1,sticky = E,padx=10)#方位设置为最东边(即靠右)#注：双击打开文件时退出才有效
e1.delete(0,END)#清空输入框
e1.insert(0,"零基础入门学习Python")#设置输入框内容e2.delete(1,END)#清空输入框
e2.insert(1,"小甲鱼")#设置输入框内容mainloop()
按下获取信息
更改输入框数据，然后按下获取信息
实例2：账号密码设置
from tkinter import *
def show():
print("作品：《%s》" % e1.get())#将e1.get()中得到的输入框1的内容格式化为字符串
print("作者：%s" % e2.get())
e1.delete(0,END)#清空输入框1
e2.delete(0,END)#清空输入框2root = Tk()#创建主窗口
#Tkinter总共提供了三种布局组件的方法：pack()、grid()和place()
#grid()方法允许你用表格的形式来管理组件的位置
#row选项代表行，coulumn选项代表列
#row = 1,column = 2表示第二行第三列（0表示第一行）Label(root,text = "账号:").grid(row=0)#第1行
Label(root,text = "密码:").grid(row=1)#第2行
v1 = StringVar()
v2 = StringVar()e1 = Entry(root,textvariable = v1)#在主窗口中插入输入框,文本框的内容通过e1调用
e2 = Entry(root,textvariable = v2,show="*")#在主窗口中插入输入框
e1.grid(row=0,column=1,padx=10,pady=5)#x方向偏移是相对于"作品"的x方向偏移的；y方向偏移表示此输入框与y方向相邻物体或边框之间偏移的距离(y方向偏移)
e2.grid(row=1,column=1,padx=10,pady=5)#x方向偏移是相对于"小甲鱼"的x方向偏移的；y方向偏移表示此输入框与y方向相邻上下物体或边框偏移的距离(y方向偏移)
#可以使用sticky选项来设置组件的位置
#使用N、E、S、W以及他们的组合NE、SE、SW、NW来表示方位#加两个按钮
Button(root,text = "芝麻开门",command = show)\
.grid(row = 2,column = 0,sticky = W,padx = 10,pady=5)#加入反斜杠可实现分行编辑,方位设置为最西边(即靠左)
Button(root,text = "退出",command = root.quit).grid(row = 2,column = 1,sticky = E,padx=10)#方位设置为最东边(即靠右)mainloop()
实例3：验证函数validatecommand
from tkinter import *
master = Tk()
def test():
if e1.get() == "小甲鱼":
print("正确！")
return True
else:
print("错误！")
e1.delete(0, END)
return Falsev = StringVar()
#focusout表示Entry组件失去焦点的时候验证，调用validatecommand的test函数
e1 = Entry(master, textvariable=v, validate="focusout", validatecommand=test)
e2 = Entry(master)
e1.pack(padx=10, pady=10)
e2.pack(padx=10, pady=10)mainloop()
实例4：invalidcommand函数
from tkinter import *
master = Tk()
def test():
if e1.get() == "小甲鱼":
print("正确！")
return True
else:
print("错误！")
e1.delete(0, END)
return Falsedef test2():
print("我被调用了...")v = StringVar()
#focusout表示Entry组件失去焦点的时候验证，调用validatecommand的test函数
#invalidcommand选项指定的函数只有在validatecommand的返回值为False的时候才被调用
e1 = Entry(master, textvariable=v, validate="focusout", validatecommand=test,\
invalidcommand=test2)
e2 = Entry(master)
e1.pack(padx=10, pady=10)
e2.pack(padx=10, pady=10)mainloop()
实例5：验证函数提供一些额外的选项
validatecommand(f,s1,s2,...)
其中，f是验证函数名，s1,s2,s3是额外的选项，这些选项会作为参数一次传给f函数。在此之前，需要调用register()方法将验证函数包装起来。
from tkinter import *
master = Tk()
v = StringVar()
def test(content, reason, name):
if content == "小甲鱼":
print("正确！")
print(content, reason, name)
return True
else:
print("错误！")
print(content, reason, name)
return FalsetestCMD = master.register(test)
e1 = Entry(master, textvariable=v, validate="focusout", \
validat
ecommand=(testCMD, '%P', '%v', '%W'))
e2 = Entry(master)
e1.pack(padx=10, pady=10)
e2.pack(padx=10, pady=10)mainloop()
实例6：设计一个 计算器
from tkinter import *
#计算函数
def calc():
result = int(v1.get())+int(v2.get())#强制转换为整型
v3.set(result)#将result中的内容放到v3中#创建窗口
root = Tk()
#创建窗口中的一个frame框架
frame = Frame(root)
#设置框架位置并显示
frame.pack(padx = 10,pady = 10)v1 = StringVar()
v2 = StringVar()
v3 = StringVar()#注意，这里不能使用e1.get()或者v1.get()来获取输入的内容，因为validate选项
#指定为“key"的时候，有任何输入操作都会被拦截到这个函数中
#也就是说先拦截，只有这个函数返回True,那么输入的内容才会到变量里去
#所以要用%P来获取最新的输入框内容
def test(content):
if content.isdigit():
return True
else:
return False#创建三个Entry组件
testCMD = frame.register(test)
#创建2个输入组件,输入的数据赋值给v1、v2
e1 = Entry(frame, textvariable=v1,width=10, validate="key",\
validatecommand=(testCMD, '%P'))
e2 = Entry(frame, textvariable=v2,width=10, validate="key",\
validatecommand=(testCMD, '%P'))
#一个输出组件,设置为只读模式(readonly),v3的数据赋值给textvariable进行输出显示
e3 = Entry(frame, textvariable=v3,width=10, validate="key",\
validatecommand=(testCMD, '%P'),state="readonly")
#位置设置
e1.grid(row=0,column=0,padx=10,pady=10)
e2.grid(row=0,column=2,padx=10)
e3.grid(row=0,column=4,padx=10)#创建两个Label组件
Label(frame,text="+").grid(row=0,column=1)
Label(frame,text="=").grid(row=0,column=3)#创建一个按钮，宽度为10
button=Button(frame,text="计算结果",width=10,command=calc)
button.grid(row=1,column=2,pady=10)mainloop()
068 GUI的终极选择：Tkinter5
Listbox组件
如果需要提供选项给用户选择，单选可以用Radiobutton组件，多选可以用Checkbutton，如果提供的选项非常多，可以考虑使用Listbox组件。Listbox是以列表的形式显示出来，并支持滚动条操作。
实例1：
from tkinter import *
root = Tk()#创建主窗口
theLB = Listbox(root,setgrid = True,selectmode=EXTENDED)#创建一个空列表
theLB.pack()#往列表里添加数据
for item in ["鸡蛋","鸭蛋","鹅蛋","李狗蛋"]:
theLB.insert(END,item)#每次在列表最后插入一个数据#创建一个按钮,ACTIVE表示当前选中的数据
theButton = Button(root,text="删除",command = lambda x = theLB:x.delete(ACTIVE))
theButton.pack()#theLB.delete(0,END)删除所有列表数据
mainloop()
注：listbox.delete(0,END)可以删除列表中所有项目实例2：添加height选项
from tkinter import *
root = Tk()#创建主窗口
#height=11表示可以显示11个项目
theLB = Listbox(root,setgrid = True,\
selectmode=BROWSE,height=11)#创建一个空列表,选择模式为单选
theLB.pack()#往列表里添加数据
for item in range(11):
theLB.insert(END,item)#每次在列表最后插入一个数据#创建一个按钮,ACTIVE表示当前选中的数据
theButton = Button(root,text="删除",command = lambda x = theLB:x.delete(ACTIVE))
theButton.pack()#theLB.delete(0,END)删除所有列表数据
mainloop()
Scrollbar组件
实例1：
from tkinter import *
root = Tk()#创建主窗口
sb = Scrollbar(root)
sb.pack(side=RIGHT,fill=Y)lb = Listbox(root,yscrollcommand=sb.set)#创建一个空列表
for i in range(1000):
lb.insert(END,i)
lb.pack(side=LEFT,fill=BOTH)sb.config(command = lb.yview)
mainloop()
事实上，这是一个互联互通的过程。当用户操作滚动条时，滚动条响应滚动并同时通过Listbox组件的yview()方法滚动列表框里的内容；同样，当列表框中可视范围发生改变的时候，Listbox组件通过调用Scrollbar组件的set()方法设置滚动条的最新位置。
Scale组件
Scale组件主要是通过滑块来表示某个范围内的一个数字，可以通过修改选项设置范围以及分辨率（精度）
实例1：
from tkinter import *
root = Tk()#创建主窗口
Scale(root,from_=0,to=42).pack()#创建铅锤方向滚动条
Scale(root,from_=0,to=200,orient=HORIZONTAL).pack()#创建水平方向滚动条mainloop()
实例2：打印当前位置
from tkinter import *
def show():
print(s1.get(),s2.get())#使用get()方法获取当前滑块的位置root = Tk()#创建主窗口
s1 = Scale(root,from_=0,to=42)#创建铅锤方向滚动条
s1.pack()
s2 = Scale(root,from_=0,to=200,orient=HORIZONTAL)#创建水平方向滚动条
s2.pack()#创建一个按钮
Button(root,text="获取位置",command=show).pack()mainloop()
实例3：通过resolution选项控制分辨率（步长），通过tickinterval选项设置刻度
from tkinter import *
def show():
print(s1.get(),s2.get())#使用get()方法获取当前滑块的位置root = Tk()#创建主窗口
#tickinterval表示设置刻度，即每隔多少显示一个刻度
#length表示滚动条的长度所占的像素数
#resolution用来控制分辨率（步长）
s1 = Scale(root,from_=0,to=42,tickinterval=5,length=200,\
resolution=5,orient=VERTICAL)#创建铅锤方向滚动条
s1.pack()
s2 = Scale(root,from_=0,to=200,tickinterval=10,\
length=600,orient=HORIZONTAL)#创建水平方向滚动条
s2.pack()#创建一个按钮
Button(root,text="获取位置",command=show).pack()mainloop()
069 GUI的终极选择：Tkinter6
Text组件
Text(文本)组件用于显示和处理多种任务。虽然该组件的主要目的是显示多行文本，但它常常也被用于作为简单的文本编辑器和网页浏览器使用。
实例1：插入内容
from tkinter import *
root = Tk()
text = Text(root,width=30,height=2)
text.pack()
#INSERT索引表示插入光标当前的位置
text.insert(INSERT,"I love\n")#光标当前的位置插入#END，对应Text组件的文本缓存区最后一个字符的下一个位置
text.insert(END,"FishC.com!")mainloop()
实例2：插入image对象windows组件
from tkinter import *
def show():
print("哟，我被点了一下~")root = Tk()
text = Text(root,width=30,height=5)
text.pack()#INSERT索引表示插入光标当前的位置
text.insert(INSERT,"I love FishC.com!")#光标当前的位置插入#创建一个按钮
b1=Button(root,text="点我点我",command=show)
text.window_create(INSERT,window=b1)mainloop()
实例3：单击按钮显示一张图片
from tkinter import *
def show():
text.image_create(INSERT,image=photo)root = Tk()
text = Text(root,width=30,height=50)
text.pack()#INSERT索引表示插入光标当前的位置
text.insert(INSERT,"I love FishC.com!")#光标当前的位置插入photo = PhotoImage(file='fishc.gif')
#创建一个按钮
b1=Button(root,text="点我点我",command=show)
text.window_create(INSERT,window=b1)mainloop()
Indexer用法
实例1：“line.column”
from tkinter import *
root = Tk()
text = Text(root,width=30,height=5)
text.pack()#INSERT索引表示插入光标当前的位置
text.insert(INSERT,"I love FishC.com!")#光标当前的位置插入
#注意，行号从1开始，列号则从0开始
print(text.get(1.2,1.6))#获取第一行第2列到第一行第六列的数据mainloop()
实例2：“line.end”
行号加上字符串".end"格式表示为该行最后一个字符的位置
实例：
from tkinter import *
root = Tk()
text = Text(root,width=30,height=5)
text.pack()#INSERT索引表示插入光标当前的位置
text.insert(INSERT,"I love FishC.com!")#光标当前的位置插入
#注意，行号从1开始，列号则从0开始
print(text.get("1.2","1.end"))#获取第一行第2列到第一行第六列的数据mainloop()
Mask用法
mask（标记）通常是嵌入到Text组件文本中的不可见对象。事实上，Marks是指定字符间的位置，并跟随相应的字符一起移动。
实例：Mark事实上就是索引，用于表示位置
from tkinter import *
root = Tk()
text = Text(root,width=30,height=5)
text.pack()#INSERT索引表示插入光标当前的位置
text.insert(INSERT,"I love FishC.com!")#光标当前的位置插入
#注意，行号从1开始，列号则从0开始
text.mark_set("here","1.2")#设置光标位置为1.2
text.insert("here","插")mainloop()
实例2：如果Mark前面的内容发生改变，Mark的位置也会跟着移动
from tkinter import *
root = Tk()
text = Text(root,width=30,height=5)
text.pack()#INSERT索引表示插入光标当前的位置
text.insert(INSERT,"I love FishC.com!")#光标当前的位置插入
#注意，行号从1开始，列号则从0开始
text.mark_set("here","1.2")#设置当前光标位置为1.2
text.insert("here","插")#执行后当前光标位置（Mark位置）变成了1.3
text.insert("here","入")
#text.insert("1.3","入")mainloop()
实例3：如果Mark周围的文本被删除了，Mark仍然存在
from tkinter import *
root = Tk()
text = Text(root,width=30,height=5)
text.pack()#INSERT索引表示插入光标当前的位置
text.insert(INSERT,"I love FishC.com!")#光标当前的位置插入
#注意，行号从1开始，列号则从0开始
text.mark_set("here","1.2")#设置当前光标位置为1.2
text.insert("here","插")#执行后当前光标位置变成了1.3
text.delete("1.0",END)
text.insert("here","入")#here表示当前Mark的位置,如果Mark左边并没有数据则会插入到最左边mainloop()
例4：只有mark_unset()方法可以解除Mark的封印
from tkinter import *
root = Tk()
text = Text(root,width=30,height=5)
text.pack()#INSERT索引表示插入光标当前的位置
text.insert(INSERT,"I love FishC.com!")#光标当前的位置插入
#注意，行号从1开始，列号则从0开始
text.mark_set("here","1.2")#设置当前光标位置为1.2
text.insert("here","插")#执行后当前光标位置变成了1.3
text.mark_unset("here")text.delete("1.0",END)
text.insert("here","入")#here表示当前Mark的位置mainloop()
默认插入内容是插入到Mark左侧（就是说插入一个字符后，Mark向后移动了一个字符的位置）
实例5：插入内容到Mark的右侧
from tkinter import *
root = Tk()
text = Text(root,width=30,height=5)
text.pack()#INSERT索引表示插入光标当前的位置
text.insert(INSERT,"I love FishC.com!")#光标当前的位置插入
#注意，行号从1开始，列号则从0开始
text.mark_set("here","1.2")#设置当前Mark位置为1.2
text.mark_gravity("here",LEFT)text.insert("here","插")#执行后当前Mark位置变成了1.3
text.insert("here","入")#here表示当前Mark的位置mainloop()
070 GUI的终极选择：Tkinter7
实例1：添加Tags
from tkinter import *
root = Tk()
text = Text(root,width=30,height=5)
text.pack()#INSERT索引表示插入光标当前的位置
text.insert(INSERT,"I love FishC.com!")#光标当前的位置插入
#注意，行号从1开始，列号则从0开始
text.tag_add("tag1","1.7","1.12","1.14")#1.7(第一行第八列)到1.12,，与1.14设置Tag样式
text.tag_config("tag1",background ="yellow",foreground="red")mainloop()
实例2：Tags覆盖
from tkinter import *
root = Tk()
text = Text(root,width=30,height=5)
text.pack()#INSERT索引表示插入光标当前的位置
text.insert(INSERT,"I love FishC.com!")#光标当前的位置插入
#注意，行号从1开始，列号则从0开始
text.tag_add("tag1","1.7","1.12","1.14")#1.7(第一行第八列)到1.12,，与1.14设置Tag样式
text.tag_add("tag2","1.7","1.12","1.14")#1.7(第一行第八列)到1.12,，与1.14设置Tag样式text.tag_config("tag1",background ="yellow",foreground="red")
text.tag_config("tag2",background ="blue")mainloop()
实例2：降低Tag优先级
from tkinter import *
root = Tk()
text = Text(root,width=30,height=5)
text.pack()#INSERT索引表示插入光标当前的位置
text.insert(INSERT,"I love FishC.com!")#光标当前的位置插入
#注意，行号从1开始，列号则从0开始
text.tag_add("tag1","1.7","1.12","1.14")#1.7(第一行第八列)到1.12,，与1.14设置Tag样式
text.tag_add("tag2","1.7","1.12","1.14")#1.7(第一行第八列)到1.12,，与1.14设置Tag样式text.tag_config("tag1",background ="yellow",foreground="red")
text.tag_config("tag2",background ="blue")text.tag_lower("tag2")#降低tag2的优先级
mainloop()
实例3：Tags事件绑定
from tkinter import *
import webbrowser#导入网页模块def show_hand_cursor(event):
text.config(cursor="arrow")def show_arrow_cursor(event):
text.config(cursor="xterm")def click(event):
webbrowser.open("http://www.fishc.com")
root = Tk()
text = Text(root,width=30,height=5)
text.pack()#INSERT索引表示插入光标当前的位置
text.insert(INSERT,"I love FishC.com!")#光标当前的位置插入
#注意，行号从1开始，列号则从0开始
text.tag_add("link","1.7","1.16")#1.7(第一行第八列)到1.16
#设置蓝色前景色并底部划线
text.tag_config("link",foreground="blue",underline=True)#当进入绑定文本段时，鼠标样式切换为“arrow"形态
text.tag_bind("link","<Enter>",show_hand_cursor)
#当离开绑定文本段时，鼠标样式切换为“xterm"形态
text.tag_bind("link","<Leave>",show_arrow_cursor)
#当触发鼠标“左键单击”时，使用默认浏览器打开鱼C网址
text.tag_bind("link","<Button-1>",click)mainloop()
实例4：判断内容是否发生改变
from tkinter import *
import hashlibdef getSig(contents):
m = hashlib.md5(contents.encode())
return m.digest()def check():#检查
contents = text.get(1.0,END)
if sig!=getSig(contents):
print("警报，内容发生变动")
else:
print("风平浪静")
root = Tk()
text = Text(root,width=30,height=5)
text.pack()#INSERT索引表示插入光标当前的位置
text.insert(INSERT,"I love FishC.com!")#光标当前的位置插入
#注意，行号从1开始，列号则从0开始
#获取文本内容
contents=text.get(1.0,END)sig = getSig(contents)
Button(root,text="检查",command=check).pack()
mainloop()
实例5：查找操作（使用search()方法可以搜索Text组件中的内容）
from tkinter import *
import hashlib#将任何格式的索引号统一为元组（行，列）的格式输出
def getIndex(text,index):
#split这里以"."拆分字符串，将1.3拆分为字符1和3，然后通过map将字符转换为整型
return tuple(map(int,str.split(text.index(index),".")))
root = Tk()
text = Text(root,width=30,height=5)
text.pack()#INSERT索引表示插入光标当前的位置
text.insert(INSERT,"I love FishC.com!")#光标当前的位置插入#将任何格式的索引号统一为元组（行、列）的格式输出
start = 1.0
while True:
pos = text.search("o",start,stopindex=END)#从开始到结束全文搜索
if not pos:
break
print("找到了，位置是：",getIndex(text,pos))
start = pos + "+1c"#将start指向找到的字符位置的下一个字符，以便进行下一次搜索mainloop()
Text组件内部有一个栈专门用于记录内容的每次变动，所以每次“撤销”操作就是一次弹栈操作，“恢复”就是再次压栈。
实例6：撤销
from tkinter import *
#将任何格式的索引号统一为元组（行，列）的格式输出
def show():
text.edit_undo()
root = Tk()
text = Text(root,width=30,height=5,undo=True)
text.pack()
text.insert(INSERT,"I love FishC")Button(root,text="撤销",command=show).pack()
mainloop()
实例7：每次撤销一个字符
from tkinter import *
def callback(event):
text.edit_separator()def show():
text.edit_undo()#执行撤回操作
root = Tk()#autoseparators表示一次完整的操作结束后自动插入“分隔符”，此处设置为False
text = Text(root,width=30,height=5,autoseparators=False,undo=True,maxundo=10)
text.pack()text.insert(INSERT,"I love FishC!")
text.bind('<Key>',callback)#每次有输入就插入一个“分隔符”Button(root,text="撤销",command=show).pack()
mainloop()
071 GUI的终极选择：Tkinter8
Canvas（画布）组件
一个可以让你随心所欲绘制界面的组件。通常用于显示和编辑图形，可以用它来绘制直线、图形、多边形，甚至是绘制其他组件。
实例1：
from tkinter import *
root = Tk()
#创建canvas对象框，设置其宽度、高度与背景色
w = Canvas(root,width=200,height=100,background="black")
w.pack()#画一条黄色的线
w.create_line(0,50,200,50,fill="yellow")
#画一条红色的竖线（虚线）
w.create_line(100,0,100,100,fill="red")
#中间画一个蓝色的矩形
w.create_rectangle(50,25,150,75,fill="blue")mainloop()
实例2：
from tkinter import *
root = Tk()
#创建canvas对象框，设置其宽度、高度与背景色
w = Canvas(root,width=200,height=100,background="black")
w.pack()#画一条黄色的线（参数为其x、y轴坐标）
line1 = w.create_line(0,50,200,50,fill="yellow")
#画一条红色的竖线（虚线）
line2 = w.create_line(100,0,100,100,fill="red")
#中间画一个蓝色的矩形
rect1 = w.create_rectangle(50,25,150,75,fill="blue")w.coords(line1,0,25,200,25)#将line1移动到新的坐标
w.itemconfig(rect1,fill="red")#重新设置矩形的填充色为红色
w.delete(line2)#删除线2#创建一个按钮，按下时删除所有图形
Button(root,text="删除全部",command=(lambda x=ALL:w.delete(x))).pack()mainloop()
实例3：在Canvas上显示文本
from tkinter import *
root = Tk()
#创建canvas对象框，设置其宽度、高度与背景色
w = Canvas(root,width=200,height=100,background="black")
w.pack()#画一条绿色的斜线（参数为其x、y轴坐标），宽度为三个像素点
line1 = w.create_line(0,0,200,100,fill="green",width=3)
#画一条绿色的斜线
line2 = w.create_line(200,0,0,100,fill="green",width=3)
#中间画两个矩形
rect1 = w.create_rectangle(40,20,160,80,fill="blue")
rect2 = w.create_rectangle(60,30,140,70,fill="yellow")
#在矩形正中（默认）显示文本，坐标为文本正中坐标
w.create_text(100,50,text="Hadley")#创建一个按钮，按下时删除所有图形
Button(root,text="删除全部",command=(lambda x=ALL:w.delete(x))).pack()mainloop()
实例4：绘制椭圆
from tkinter import *
root = Tk()
#创建canvas对象框，设置其宽度、高度与背景色
w = Canvas(root,width=200,height=100,background="white")
w.pack()#绘制一个虚线的矩形
w.create_rectangle(40,20,160,80,dash=(4,4))
#绘制椭圆，粉色填充
w.create_oval(40,20,160,80,fill="pink")
#在矩形正中(默认)显示文本，坐标为文本正中坐标
w.create_text(100,50,text="Hadley")mainloop()
实例5：绘制圆形from tkinter import *
root = Tk()
#创建canvas对象框，设置其宽度、高度与背景色
w = Canvas(root,width=200,height=100,background="white")
w.pack()#绘制一个虚线的矩形
w.create_rectangle(40,20,160,80,dash=(4,4))
#绘制圆形，粉色填充
#w.create_oval(40,20,160,80,fill="pink")
w.create_oval(70,20,130,80,fill="pink")
#在矩形正中(默认)显示文本，坐标为文本正中坐标
w.create_text(100,50,text="Hadley")mainloop()
实例6：绘制多边形
from tkinter import *
import math as mroot = Tk()
w=Canvas(root,width=200,height=150,background="red")
w.pack()
center_x = 100
center_y = 80
r = 70
points = [
#左上角A
center_x - int(r*m.sin(2*m.pi/5)),
center_y - int(r*m.cos(2*m.pi/5)),
#右上角C
center_x + int(r*m.sin(2*m.pi/5)),
center_y - int(r*m.cos(2*m.pi/5)),
#左下角E
center_x - int(r*m.sin(m.pi/5)),
center_y + int(r*m.cos(m.pi/5)),
#顶点D
center_x,
center_y - r,
#右下角B
center_x + int(r*m.sin(m.pi/5)),
center_y + int(r*m.cos(m.pi/5)),
]
#创建多边形方法，会自动按ACEDBA的形式连线，如果构成闭环，则会自动填充
w.create_polygon(points,outline="green",fill="yellow")w.create_text(100,80,text="Hadley")
mainloop()
实例7：
from tkinter import *
root = Tk()
w=Canvas(root,width=400,height=200,background="white")
w.pack()def paint(event):#画小圆
x1,y1 = (event.x - 1),(event.y -1)
x2,y2 = (event.x + 1),(event.y +1)
w.create_oval(x1,y1,x2,y2,fill="red")w.bind("<B1 - Motion>",paint)#画布与鼠标进行绑定
Label(root,text="按住鼠标左键并移动，开始绘制你的理想蓝图吧。。。").pack(side=BOTTOM)mainloop()
073 GUI的终极选择：Tkinter10
Munu组件
Tkinter提供了一个Menu组件，用于实现顶级菜单、下拉菜单和弹出菜单。
实例1：创建一个顶级菜单（或称窗口主菜单）
from tkinter import *
def callback():
print("被调用了")
root = Tk()
menubar = Menu(root)#创建一个顶级菜单
menubar.add_command(label="Hello",command=callback)#创建一个顶级菜单对象
menubar.add_command(label="Quit",command=root.quit)#显示菜单
root.config(menu=menubar)mainloop()
实例2：创建添加到主菜单上的下拉菜单
from tkinter import *
def callback():
print("被调用了")
root = Tk()#创建一个顶级菜单
menubar = Menu(root)#创建下拉菜单filemenu包含内容
filemenu=Menu(menubar,tearoff=False)#创建一个从属于menubar的子菜单(下拉菜单)filemenu
filemenu.add_command(label="打开",command=callback)#创建一个下拉菜单对象
filemenu.add_command(label="保存",command=callback)
filemenu.add_separator()#插入分隔线
filemenu.add_command(label="退出",command=root.quit)
#创建一个顶级菜单对象“文件”,filemenu从属于这个对象（或称将filemenu添加到顶级菜单“文件”中）
menubar.add_cascade(label="文件",menu=filemenu)#创建另一个下拉菜单editmenu包含内容
editmenu=Menu(menubar,tearoff=False)#创建一个从属于menubar的子菜单（下拉菜单）editmenu
editmenu.add_command(label="剪切",command=callback)
editmenu.add_command(label="拷贝",command=callback)
editmenu.add_separator()#插入分隔线
editmenu.add_command(label="粘贴",command=callback)
#创建一个顶级菜单对象“编辑”,editmenu从属于这个对象（或称将editmenu添加到顶级菜单“编辑”中）
menubar.add_cascade(label="编辑",menu=editmenu)#显示菜单
root.config(menu=menubar)mainloop()
实例3：创建一个弹出菜单方法
from tkinter import *
def callback():
print("被调用了")
root = Tk()def popup(event):
menu.post(event.x_root,event.y_root)#在此时鼠标位置弹出显示窗口
#创建一个顶级菜单menu
menu = Menu(root,tearoff=False)#创建顶级菜单menu包含内容
menu.add_command(label="撤销",command=callback)#创建一个顶级菜单对象
menu.add_command(label="重做",command=callback)
#创建一个框架
frame = Frame(root,width=100,height=100)
frame.pack()#将鼠标右键与popup方法绑定
frame.bind("<Button-3>",popup)#显示菜单
#root.config(menu=menu)mainloop()
实例4：菜单弹出
from tkinter import *
def callback():
print("被调用了")
root = Tk()def popup(event):
menu.post(event.x_root,event.y_root)#在此时鼠标位置弹出显示窗口
#创建一个顶级菜单menu
menu = Menu(root,tearoff=True)#创建顶级菜单menu包含内容
menu.add_command(label="撤销",command=callback)#创建一个顶级菜单对象
menu.add_command(label="重做",command=callback)
#创建一个框架
frame = Frame(root,width=500,height=500)
frame.pack()#将鼠标右键与popup方法绑定
frame.bind("<Button-3>",popup)#显示菜单
#root.config(menu=menu)mainloop()
实例5：添加单选组件radiobutton和多选按钮checkbutton
from tkinter import *
def callback():
print("被调用了")
root = Tk()#创建一个顶级菜单
menubar = Menu(root)
#创建checkbutton关联变量
openVar = IntVar()
saveVar = IntVar()
exitVar = IntVar()
#创建下拉菜单filemenu包含内容
filemenu=Menu(menubar,tearoff=True)#创建一个从属于menubar的子菜单(下拉菜单)filemenu
filemenu.add_checkbutton(label="打开",command=callback,variable=openVar)#创建一个下拉菜单对象
filemenu.add_checkbutton(label="保存",command=callback,variable=saveVar)
filemenu.add_separator()#插入分隔线
filemenu.add_checkbutton(label="退出",command=root.quit,variable=exitVar)
#创建一个顶级菜单对象“文件”,filemenu从属于这个对象（或称将filemenu添加到顶级菜单“文件”中）
menubar.add_cascade(label="文件",menu=filemenu)#创建radiobutton关联变量
editVar = IntVar()
editVar.set(1)#创建另一个下拉菜单editmenu包含内容
editmenu=Menu(menubar,tearoff=True)#创建一个从属于menubar的子菜单（下拉菜单）editmenu
editmenu.add_radiobutton(label="剪切",command=callback,variable=editVar,value=1)
editmenu.add_radiobutton(label="拷贝",command=callback,variable=editVar,value=2)
editmenu.add_separator()#插入分隔线
editmenu.add_radiobutton(label="粘贴",command=callback,variable=editVar,value=3)
#创建一个顶级菜单对象“编辑”,editmenu从属于这个对象（或称将editmenu添加到顶级菜单“编辑”中）
menubar.add_cascade(label="编辑",menu=editmenu)#显示菜单
root.config(menu=menubar)mainloop()
Menubutton组件（希望菜单按钮出现在其它位置时）
Menubutton组件是一个与Menu组件相关联的按钮，它可以放在窗口中的任意位置，并且在被按下时弹出下拉菜单
实例1：
from tkinter import *
def callback():
print("被调用了")
root = Tk()#创建一个顶级菜单Menubutton按钮，设置为浮起显示（RAISED）
mb = Menubutton(root,text="点我",relief=RAISED)mb.pack(side=RIGHT)#设置为右中显示
#创建下拉菜单filemenu包含内容
filemenu = Menu(mb,tearoff=False)#创建一个从属于mb的下拉菜单filemenu
filemenu.add_checkbutton(label="打开",command=callback,selectcolor="yellow")
filemenu.add_command(label="保存",command=callback)#创建一个下拉菜单对象"保存“
filemenu.add_separator()
filemenu.add_command(label="退出",command=root.quit)
#显示菜单
mb.config(menu=filemenu)mainloop()
OptionMenu（选项菜单）组件
选项菜单的发明弥补了Listbox组件无法实现下拉列表框的遗憾
实例1：
from tkinter import *
def callback():
print("被调用了")
root = Tk()variable = StringVar()#创建字符串变量variable
variable.set("one")#初始值设置为"one"
w = OptionMenu(root,variable,"one","two","three")
w.pack()mainloop()
实例2：多个选项添加到选项菜单中
from tkinter import *
def callback():
print("被调用了")
root = Tk()OPTIONS = [
"Hadley",
"小土豆",
"yiwofeiye",
"RAN"
]variable = StringVar()#创建字符串变量variable
variable.set(OPTIONS[0])#初始值设置为"one"
w = OptionMenu(root,variable,*OPTIONS)
w.pack()def callback():
print(variable.get())Button(root,text="点我",command=callback).pack()
mainloop()
074 GUI的终极选择：Tkinter11
事件绑定
对于每个组件来说，可以通过bind()方法将函数或方法绑定到具体的事件上。当被触发的事件满足该组件绑定的事件时，Tkinter就会带着事件描述去调用handler()方法
实例1：捕获单击鼠标位置
from tkinter import*
root = Tk()
def callback(event):
print("点击位置：",event.x,event.y)frame = Frame(root,width=200,height=200)
#Button表示鼠标点击事件
#1代表左键 2代表中间滚轮点击 3代表右键
frame.bind("<Button-1>",callback)#按键按下时，调用callback方法
frame.pack()mainloop()
实例2：捕获键盘事件
#捕获单击鼠标的位置
from tkinter import*root = Tk()
def callback(event):
print("敲击位置：",repr(event.char))#打印当前按下按键的字符
print(event.char)frame = Frame(root,width=200,height=200)
#Key为键盘事件
frame.bind("<Key>",callback)#按键按下时，调用callback方法
frame.focus_set()#获得焦点
frame.pack()mainloop()
实例3：捕获鼠标在组件上的运动轨迹
#当鼠标在组件内移动的整个过程均触发该事件
from tkinter import*
root = Tk()
def callback(event):
print("当前位置：",event.x,event.y)#打印当前按下按键的字符frame = Frame(root,width=200,height=200)
frame.bind("<Motion>",callback)#按键按下时，调用callback方法
frame.pack()mainloop()
事件序列
Tkinter使用一种称为事件序列的机制来允许用户定义事件，用户需要使用bind()方法将具体的事件序列与自定义的方法绑定
Event对象（按键名keysym和按键码keycode）
实例1：打印当前按下按键的按键名
from tkinter import*
root = Tk()
def callback(event):
print(event.keysym)#打印当前按下按键的按键名
print(event.char)frame = Frame(root,width=200,height=200)
#Key为键盘事件
frame.bind("<Key>",callback)#按键按下时，调用callback方法
frame.focus_set()#获得焦点
frame.pack()mainloop()
075 GUI的终极选择：Tkinter12
Message组件
Message(消息)组件是Label组件的变体，用于显示多行文本信息。Message组件能够自动换行，并调整文本的尺寸使其适应给定得尺寸。
实例1：
from tkinter import *
root = Tk()
w1 = Message(root,text="这是一则消息",width=100)
w1.pack()
w2 = Message(root,text="这是一条骇人听闻的长消息！",width=100)
w2.pack()mainloop()
Spinbox组件
Entry组件的变体，用于从一些固定的值中选取一个。使用Spinbox组件，可以通过返回或者元组指定允许用户输入的内容。
实例1：
from tkinter import *
root = Tk()
#w = Spinbox(root,from_=0,to=10)#指定输入值为0-10
w = Spinbox(root,value=("Hadley","小土豆","雅馨"))#指定输入
w.pack()mainloop()
PanedWindow组件
与Frame类似，都是为组件提供一个框架，但其还允许让用户调整应用程序的空间划分
实例1：两窗格
from tkinter import *
root = Tk()
m = PanedWindow(orient = VERTICAL)#设置为上下分布
m.pack(fill=BOTH,expand=1)#设置为框架覆盖全局top = Label(m,text="top pane")#顶窗格
m.add(top)bottom = Label(m,text="bottom pane")#底窗格
m.add(bottom)mainloop()
实例2：三窗格
from tkinter import *
root = Tk()
m1 = PanedWindow()#默认为左右分布
m1.pack(fill=BOTH,expand=1)
left = Label(m1,text="left pane")#左窗格
m1.add(left)m2 = PanedWindow(orient=VERTICAL)
m1.add(m2)
top=Label(m2,text="top pane")#顶窗格
m2.add(top)
bottom = Label(m2,text="bottom pane")#底窗格
m2.add(bottom)mainloop()
实例3：显示“分割线”
from tkinter import *
root = Tk()
#showhandle=True表示显示“手柄”
#sashrelief=SUNKEN表示分隔线的样式设置为向下凹
m1 = PanedWindow(showhandle=True,sashrelief=SUNKEN)
m1.pack(fill=BOTH,expand=1)
left = Label(m1,text="left pane")
m1.add(left)m2 = PanedWindow(orient=VERTICAL,showhandle=True,sashrelief=SUNKEN)
m1.add(m2)
top=Label(m2,text="top pane")
m2.add(top)
bottom = Label(m2,text="bottom pane")
m2.add(bottom)mainloop()
Toplevel组件
Topleve（顶级窗口）l组件类似于Frame组件，但其是一个独立的顶级窗口，通常拥有标题栏、边框等部件。通常用在显示额外的窗口、对话框和其他弹出窗口中。
实例1：按钮按下创建一个顶级窗口
from tkinter import *
def create():
top = Toplevel()#创建一个独立的顶级窗口
top.title("FishC Demo")
msg = Message(top,text="I love FishC.com")
msg.pack()
root = Tk()
Button(root,text="创建顶级窗口",command=create).pack()mainloop()
实例2：Toplevel的窗口设置为50%透明
from tkinter import *
def create():
top = Toplevel()
top.title("FishC Demo")
top.attributes("-alpha",0.5)#设置为50%透明度
msg = Message(top,text="I love FishC.com")
msg.pack()
root = Tk()
Button(root,text="创建顶级窗口",command=create).pack()mainloop()
076 GUI的终极选择：Tkinter13
布局管理器
布局管理器就是管理你的那些组件如何排列的家伙。Tkinter有三个布局管理器，分别是pack、grid和place
pack:按添加顺序排列组件
grid:按行/列形式排列组件
place:允许程序员指定组件的大小和位置
pack实例1：生成一个Listbox组件并将它填充到root窗口
from tkinter import *
root = Tk()
listbox = Listbox(root)
#fill选项是告诉窗口管理器该组件将怎样填充整个分配给它的空间
#BOTH表示同时横向和纵向扩展；X表示横向；Y表示纵向
#expand选项是告诉窗口管理器是否将父组件的额外空间也填满（任意拉伸窗口依旧会填满）#默认情况下pack是将添加的组件依次纵向排列
listbox.pack(fill=BOTH,expand=True)
for i in range(10):
listbox.insert(END,str(i))mainloop()
实例2：纵向排列，横向填充
from tkinter import *
root = Tk()
#fill选项是告诉窗口管理器该组件将怎样填充整个分配给它的空间
#BOTH表示同时横向和纵向扩展；X表示横向；Y表示纵向
#expand选项是告诉窗口管理器是否将父组件的额外空间也填满#默认情况下pack的side属性是将添加的组件依次纵向排列
Label(root, text="red", bg="red", fg="white").pack(fill=X)
Label(root, text="green", bg="green", fg="black").pack(fill=X)
Label(root, text="blue", bg="blue", fg="white").pack(fill=X)mainloop()
实例3：横向排列，纵向填充
from tkinter import *
root = Tk()
#fill选项是告诉窗口管理器该组件将怎样填充整个分配给它的空间
#BOTH表示同时横向和纵向扩展；X表示横向；Y表示纵向
#expand选项是告诉窗口管理器是否将父组件的额外空间也填满#将pack设置为横向排列
Label(root, text="red", bg="red", fg="white").pack(side=LEFT)
Label(root, text="green", bg="green", fg="black").pack(side=LEFT)
Label(root, text="blue", bg="blue", fg="white").pack(side=LEFT)mainloop()
grid
使用一个grid就可以简单地实现你用很多个框架和pack搭建起来的效果。使用grid排列组件，只需告诉它你想要将组件放置的位置（行row/列column）。
实例1：
from tkinter import *
root = Tk()
#column默认值是0
#默认情况下组件会居中显示在对应的网格里
#Label(root,text="用户名").grid(row=0)
#Label(root,text="密码").grid(row=1)
#设置sticky=W使Label左对齐
Label(root,text="用户名").grid(row=0,sticky=W)#左对齐
Label(root,text="密码").grid(row=1,sticky=W)Entry(root).grid(row=0,column=1)
Entry(root,show="*").grid(row=1,column=1)mainloop()
实例2：设置rowspan与columnspan实现跨行和跨列功能
from tkinter import *
root = Tk()
#column默认值是0
#默认情况下组件会居中显示在对应的网格里
#Label(root,text="用户名").grid(row=0)
#Label(root,text="密码").grid(row=1)
#设置sticky=W使Label左对齐
#创建Label文本
Label(root,text="用户名").grid(row=0,sticky=W)
Label(root,text="密码").grid(row=1,sticky=W)
#创建输入
Entry(root).grid(row=0,column=1)
Entry(root,show="*").grid(row=1,column=1)
#插入Label图像
photo = PhotoImage(file="logo.gif")
#rowspan=2跨两行，边距5
Label(root,image=photo).grid(row=0,column=2,rowspan=2,padx=5,pady=5)
#columnspan=3跨三列（默认为居中显示），边距5
Button(text="提交",width=10).grid(row=2,columnspan=3,pady=5)mainloop()
place
通常情况下不建议使用place布局管理器
实例1：将子组件显示在父组件的正中间
from tkinter import *
def callback():
print("正中靶心")
root = Tk()
#relx和rely指定的是子组件相对于父组件的位置，范围是(00`1.0),0.5则表示一半，正中间
#anchor=CENTER表示正中显示
Button(root,text="点我",command=callback).place(relx=0.5,rely=0.5,anchor=CENTER)mainloop()
实例2：Button组件覆盖Label组件
from tkinter import *
def callback():
print("正中靶心")
root = Tk()photo = PhotoImage(file="logo_big.gif")
Label(root,image=photo).pack()
#relx和rely指定的是子组件相对于父组件的位置，范围是(00`1.0),0.5则表示一半，正中间
Button(root,text="点我",command=callback).place(relx=0.5,rely=0.5,anchor=CENTER)mainloop()
实例3：
from tkinter import *
root = Tk()
#relx和rely指定的是子组件相对于父组件的位置，范围是(00`1.0),0.5则表示一半，正中间
#relwidth和relheight选项指定相对父组件的尺寸
Label(root,bg="red").place(relx=0.5,rely=0.5,relheight=0.75,relwidth=0.75,anchor=CENTER)
Label(root,bg="yellow").place(relx=0.5,rely=0.5,relheight=0.5,relwidth=0.5,anchor=CENTER)
Label(root,bg="green").place(relx=0.5,rely=0.5,relheight=0.25,relwidth=0.25,anchor=CENTER)mainloop()
077 GUI的终极选择：Tkinter14
Tkinter提供了三种标准对话框模块，分别是：messagebox、filedialog、colorchooser
messagebox(消息对话框)
实例1：askokcancel函数
from tkinter import *
print(messagebox.askokcancel("FishC Demo","发射核弹?"))
mainloop()
实例2：askquestion函数
实例3：asiretrycancel函数
实例4：askyesno函数
实例5：showerror函数
from tkinter import *
#print(messagebox.askokcancel("FishC Demo","发射核弹?"))
#print(messagebox.askquestion("FishC Demo","买个U盘?"))
#print(messagebox.askretrycancel("FishC Demo","启动失败，重启?"))
#print(messagebox.askyesno("FishC Demo","你确定要格式化硬盘吗?"))
print(messagebox.showerror("FishC Demo","Error!!!"))mainloop()
实例6：showinfo函数
from tkinter import *
#options参数可设置为default、icon与parent
#print(messagebox.askokcancel("FishC Demo","发射核弹?"))
#print(messagebox.askquestion("FishC Demo","买个U盘?"))
#print(messagebox.askretrycancel("FishC Demo","启动失败，重启?"))
#print(messagebox.askyesno("FishC Demo","你确定要格式化硬盘吗?"))
#print(messagebox.showerror("FishC Demo","Error!!!"))
messagebox.showinfo("Hadley","Great!!!",icon="info")mainloop()
实例7：showwarning函数
from tkinter import *
#options参数可设置为default、icon与parent
#print(messagebox.askokcancel("FishC Demo","发射核弹?"))
#print(messagebox.askquestion("FishC Demo","买个U盘?"))
#print(messagebox.askretrycancel("FishC Demo","启动失败，重启?"))
#print(messagebox.askyesno("FishC Demo","你确定要格式化硬盘吗?"))
#print(messagebox.showerror("FishC Demo","Error!!!"))
#messagebox.showinfo("Hadley","Great!!!",icon="info")
messagebox.showwarning("Hadley","Warning!!!",icon="warning")mainloop()
filedialog(文本对话框)
当应用程序需要使用打开文件或保存文件的功能时
实例1：
from tkinter import *
root = Tk()
def callback():
#askopenfilename函数用来打开文件
#asksaveasfilename函数用来保存文件
fileName = filedialog.askopenfilename()
print(fileName)Button(root,text="打开文件夹",command=callback).pack()
mainloop()
实例2：限制打开文件类型
from tkinter import *
root = Tk()
def callback():
#askopenfilename函数用来打开文件
#asksaveasfilename函数用来保存文件
#fileName = filedialog.askopenfilename()
#限制打开文件类型
fileName = filedialog.askopenfilename(filetypes=[("PNG",".png"),("GIF",".gif")])
print(fileName)Button(root,text="打开文件夹",command=callback).pack()
mainloop()
colorchooser(颜色选择对话框)
颜色对话框提供一个让用户选择颜色的界面
实例1：
from tkinter import *
root = Tk()
def callback():
#colorchooser函数用于打开颜色选择对话框
fileName = colorchooser.askcolor()
print(fileName)Button(root,text="打开文件夹",command=callback).pack()
mainloop()
对应的RGB值及其对应的16进制值
078 Pygame：初次见面，请大家多多关照
-
UML概述及UML图详解
2020-01-17 19:34:04 UML概述 一、UML简介 ...(二)UML的定义包括UML语义和UML表示法两个部分。 1.UML语义:UML对语义的描述使开发者能在语义上取得一致认识，消除了因人而异的表达方法所造成的影响； 2.UML表...展开全文
UML概述
一、UML简介
(一)UML (Unified Modeling Language)为面向对象软件设计提供统一的、标准的、可视化的建模语言。适用于 描述以用例为驱动，以体系结构为中心的软件设计的全过程。 (二)UML的定义包括UML语义和UML表示法两个部分。 1.UML语义:UML对语义的描述使开发者能在语义上取得一致认识，消除了因人而异的表达方法所造成的影响； 2.UML表示法:UML表示法定义UML符号的表示法，为开发者或开发工具使用这些图形符号和文本语法为系统建 模提供了标准二、UML模型图的构成
（一）事物[Things] (4种)：UML模型中最基本的构成元素，是具有代表性的成分的抽象
1.构件事物：UML模型的静态部分，描述概念或物理元素
类:具有相同属性相同操作相同关系相同语义的对象的描述 接口:描述元素的外部可见行为，即服务集合的定义说明 协作:描述了一组事物间的相互作用的集合 用例:代表一个系统或系统的一部分行为，是一组动作序列的集合 构件:系统中物理存在，可替换的部件 节点:运行时存在的物理元素 另外，参与者、信号应用、文档库、页表等都是上述基本事物的变体 2.行为事物：UML模型图的动态部分，描述跨越空间和时间的行为
交互:实现某功能的一组构件事物之间的消息的集合，涉及消息、动作序列、链接 状态机:描述事物或交互在生命周期内响应事件所经历的状态序列 3.分组事物：UML模型图的组织部分，描述事物的组织结构
包:把元素组织成组的机制 4.注释事物：UML模型的解释部分，用来对模型中的元素进行说明、解释
注解:对元素进行约束或解释的简单符号 （二）关系[Relationships]：关系把事物紧密联系在一起
1.依赖[depedency]是两个事物之间的语义关系，其中一个事物(独立事物)发生变化，会影响到 另一个事物(依赖事物)的语义 2.关联[association]是一种结构关系，它指明一个事物的对象与另一个事物的对象间的联系 3.泛化[generalization]是一种特殊/一般的关系。也可以看作是常说的继承关系 4.实现[realization]是类元之间的语义关系，其中的一个类元指定了由另一个类元保证执行的契约 （三）图[Diagrams]：图是事物和关系的可视化表示
1.用例图[Use Case Diagram]:用例图是从用户角度描述系统功能， 是用户所能观察到的系统功能的模型图， 用例是系统中的一个功能单元
2.类图[Class Diagram]:(1)类图描述系统中类的静态结构。不仅定义系统中的类，表示类之间的联系如关联、 依赖、聚合等，也包括类的内部结构(类的属性和操作);(2)类图是以类为中心类组织的，类图中的其他元素 或属于某个类或与类相关联
3.对象图[Object Diagram]:对象图是类图的实例，几乎使用与类图完全相同的标识。 他们的不同点在于对象图显示类的多个对象实例，而不是实际的类
4.顺序图[Sequence Diagram]:(1)顺序图显示对象之间的动态合作关系,他强调对象之间消息发送的顺序， 同时显示对象之间的交互;(2)顺序图的一个用途是用来表示用例中的行为顺序。当执行一个用例行为时， 顺序图中的每条消息对应了一个类操作或引起状态转换的触发事件![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NKFjtLMz-1579259958177)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\image-20200117191156185.png)]](https://img-blog.csdnimg.cn/20200117193048432.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMzMyMDQ1,size_16,color_FFFFFF,t_70)
5.协作图[Collaboration Diagram]:(1)协作图描述对象间的协作关系，协作图跟顺序图相似， 显示对象间的动态合作关系。除显示信息交换外，协作图还显示对象以及他们之间的关系 (2)协作图的一个用途是表示一个类操作的实现
6.状态图[State Chart Diagram]:状态图是一个类对象所可能经历的所有历程的模型图。 状态图由对象的各个状态和连接这些状态的转换组成
7.活动图[Activity Diagram]:(1)活动图是状态图的一个变体，用来描述执行算法的工作流程中涉及的活动 (2)活动图描述了一组顺序的或并发的活动
8.构件图[Component Diagram]:构件图为系统的构件建模型——构件即构造应用的软件单元——还包括 各构件之间的依赖关系，以便通过这些依赖关系来估计对系统构件的修改给系统可能带来的影响
9.部署图[Deployment Diagram]:部署视图描述位于节点实例上的运行构件实例的安排。 节点是一组运行资源，如计算机、设备或存储器。这个视图允许评估分配结果和资源分配
（四）各UML图的关系
三、UML语法描述
文章内容深入学习链接
用例图详解
类图详解
顺序图详解
协作图详解
状态图详解
活动图详解
构件图详解
部署图详解
-
入门学习Linux常用必会60个命令实例详解doc/txt
2011-06-09 00:08:45文件为doc版，可自行转成txt，在手机上看挺好的。 本资源来自网络，如有纰漏还请告知，如觉得还不错，请留言告知后来人，谢谢！！！！！ ...入门学习Linux常用必会60个命令实例详解 ...Linux提供了大量的命令，利用它... -
图像分割综述
2019-07-09 22:03:48参数主动轮廓模型的特点是将初始曲线置于目标区域附近，无需人为设定曲线的的演化是收缩或膨胀，其优点是能够与模型直接进行交互，且模型表达紧凑，实现速度快；其缺点是难以处理模型拓扑结构的变化。比如曲线的合并...展开全文本文作者净浩泽，公众号：计算机视觉life，编辑成员
图像分割是计算机视觉研究中的一个经典难题，已经成为图像理解领域关注的一个热点，图像分割是图像分析的第一步，是计算机视觉的基础，是图像理解的重要组成部分，同时也是图像处理中最困难的问题之一。所谓图像分割是指根据灰度、彩色、空间纹理、几何形状等特征把图像划分成若干个互不相交的区域，使得这些特征在同一区域内表现出一致性或相似性，而在不同区域间表现出明显的不同。简单的说就是在一副图像中，把目标从背景中分离出来。对于灰度图像来说，区域内部的像素一般具有灰度相似性，而在区域的边界上一般具有灰度不连续性。 关于图像分割技术，由于问题本身的重要性和困难性，从20世纪70年代起图像分割问题就吸引了很多研究人员为之付出了巨大的努力。虽然到目前为止，还不存在一个通用的完美的图像分割的方法，但是对于图像分割的一般性规律则基本上已经达成的共识，已经产生了相当多的研究成果和方法。
本文对于目前正在使用的各种图像分割方法进行了一定的归纳总结，由于笔者对于图像分割的了解也是初窥门径，所以难免会有一些错误，还望各位读者多多指正，共同学习进步。
传统分割方法
这一大部分我们将要介绍的是深度学习大火之前人们利用数字图像处理、拓扑学、数学等方面的只是来进行图像分割的方法。当然现在随着算力的增加以及深度学习的不断发展，一些传统的分割方法在效果上已经不能与基于深度学习的分割方法相比较了，但是有些天才的思想还是非常值得我们去学习的。
1.基于阈值的分割方法
阈值法的基本思想是基于图像的灰度特征来计算一个或多个灰度阈值，并将图像中每个像素的灰度值与阈值作比较，最后将像素根据比较结果分到合适的类别中。因此，该方法最为关键的一步就是按照某个准则函数来求解最佳灰度阈值。
阈值法特别适用于目标和背景占据不同灰度级范围的图。
图像若只有目标和背景两大类，那么只需要选取一个阈值进行分割，此方法成为单阈值分割；但是如果图像中有多个目标需要提取，单一阈值的分割就会出现作物，在这种情况下就需要选取多个阈值将每个目标分隔开，这种分割方法相应的成为多阈值分割。
如图所示即为对数字的一种阈值分割方法。
阀值分割方法的优缺点：- 计算简单，效率较高；
- 只考虑像素点灰度值本身的特征，一般不考虑空间特征，因此对噪声比较敏感，鲁棒性不高。
从前面的介绍里我们可以看出，阈值分割方法的最关键就在于阈值的选择。若将智能遗传算法应用在阀值筛选上，选取能最优分割图像的阀值，这可能是基于阀值分割的图像分割法的发展趋势。
2.基于区域的图像分割方法
基于区域的分割方法是以直接寻找区域为基础的分割技术，基于区域提取方法有两种基本形式：一种是区域生长，从单个像素出发，逐步合并以形成所需要的分割区域；另一种是从全局出发，逐步切割至所需的分割区域。
区域生长
区域生长是从一组代表不同生长区域的种子像素开始，接下来将种子像素邻域里符合条件的像素合并到种子像素所代表的生长区域中，并将新添加的像素作为新的种子像素继续合并过程，知道找不到符合条件的新像素为止（小编研一第一学期的机器学习期末考试就是手写该算法 T.T），该方法的关键是选择合适的初始种子像素以及合理的生长准则。
区域生长算法需要解决的三个问题：
（1）选择或确定一组能正确代表所需区域的种子像素；
（2）确定在生长过程中能将相邻像素包括进来的准则；
（3）指定让生长过程停止的条件或规则。
区域分裂合并
区域生长是从某个或者某些像素点出发，最终得到整个区域，进而实现目标的提取。而分裂合并可以说是区域生长的逆过程，从整幅图像出发，不断的分裂得到各个子区域，然后再把前景区域合并，得到需要分割的前景目标，进而实现目标的提取。其实如果理解了上面的区域生长算法这个区域分裂合并算法就比较好理解啦。
四叉树分解法就是一种典型的区域分裂合并法，基本算法如下：
（1）对于任一区域，如果H(Ri)=FALSE就将其分裂成不重叠的四等分；
（2）对相邻的两个区域Ri和Rj，它们也可以大小不同（即不在同一层），如果条件H(RiURj)=TURE满足，就将它们合并起来；
（3）如果进一步的分裂或合并都不可能，则结束。
其中R代表整个正方形图像区域，P代表逻辑词。
区域分裂合并算法优缺点：
（1）对复杂图像分割效果好；
（2）算法复杂，计算量大；
（3）分裂有可能破怪区域的边界。
在实际应用当中通常将区域生长算法和区域分裂合并算法结合使用，该类算法对某些复杂物体定义的复杂场景的分割或者对某些自然景物的分割等类似先验知识不足的图像分割效果较为理想。
分水岭算法
分水岭算法是一个非常好理解的算法，它根据分水岭的构成来考虑图像的分割，现实中我们可以想象成有山和湖的景象，那么一定是如下图的，水绕山山围水的景象。
分水岭分割方法，是一种基于拓扑理论的数学形态学的分割方法，其基本思想是把图像看作是测地学上的拓扑地貌，图像中每一点像素的灰度值表示该点的海拔高度，每一个局部极小值及其影响区域称为集水盆，而集水盆的边界则形成分水岭。分水岭的概念和形成可以通过模拟浸入过程来说明。在每一个局部极小值表面，刺穿一个小孔，然后把整个模型慢慢浸入水中，随着浸入的加深，每一个局部极小值的影响域慢慢向外扩展，在两个集水盆汇合处构筑大坝，即形成分水岭。
分水岭对微弱边缘具有良好的响应，图像中的噪声、物体表面细微的灰度变化都有可能产生过度分割的现象，但是这也同时能够保证得到封闭连续边缘。同时，分水岭算法得到的封闭的集水盆也为分析图像的区域特征提供了可能。
3.基于边缘检测的分割方法
基于边缘检测的图像分割算法试图通过检测包含不同区域的边缘来解决分割问题。它可以说是人们最先想到也是研究最多的方法之一。通常不同区域的边界上像素的灰度值变化比较剧烈，如果将图片从空间域通过傅里叶变换到频率域，边缘就对应着高频部分，这是一种非常简单的边缘检测算法。
边缘检测技术通常可以按照处理的技术分为串行边缘检测和并行边缘检测。串行边缘检测是要想确定当前像素点是否属于检测边缘上的一点，取决于先前像素的验证结果。并行边缘检测是一个像素点是否属于检测边缘高尚的一点取决于当前正在检测的像素点以及与该像素点的一些临近像素点。
最简单的边缘检测方法是并行微分算子法，它利用相邻区域的像素值不连续的性质，采用一阶或者二阶导数来检测边缘点。近年来还提出了基于曲面拟合的方法、基于边界曲线拟合的方法、基于反应-扩散方程的方法、串行边界查找、基于变形模型的方法。
边缘检测的优缺点：
（1）边缘定位准确；
（2）速度快；
（3）不能保证边缘的连续性和封闭性；
（4）在高细节区域存在大量的碎边缘，难以形成一个大区域，但是又不宜将高细节区域分成小碎片；
由于上述的（3）（4）两个难点，边缘检测只能产生边缘点，而非完整意义上的图像分割过程。这也就是说，在边缘点信息获取到之后还需要后续的处理或者其他相关算法相结合才能完成分割任务。
在以后的研究当中，用于提取初始边缘点的自适应阈值选取、用于图像的层次分割的更大区域的选取以及如何确认重要边缘以去除假边缘将变得非常重要。结合特定工具的图像分割算法
基于小波分析和小波变换的图像分割方法
小波变换是近年来得到的广泛应用的数学工具，也是现在数字图像处理必学部分，它在时间域和频率域上都有量高的局部化性质，能将时域和频域统一于一体来研究信号。而且小波变换具有多尺度特性，能够在不同尺度上对信号进行分析，因此在图像分割方面的得到了应用，
二进小波变换具有检测二元函数的局部突变能力，因此可作为图像边缘检测工具。图像的边缘出现在图像局部灰度不连续处，对应于二进小波变换的模极大值点。通过检测小波变换模极大值点可以确定图像的边缘小波变换位于各个尺度上，而每个尺度上的小波变换都能提供一定的边缘信息，因此可进行多尺度边缘检测来得到比较理想的图像边缘。
上图左图是传统的阈值分割方法，右边的图像就是利用小波变换的图像分割。可以看出右图分割得到的边缘更加准确和清晰
另外，将小波和其他方法结合起来处理图像分割的问题也得到了广泛研究，比如一种局部自适应阈值法就是将Hilbert图像扫描和小波相结合，从而获得了连续光滑的阈值曲线。基于遗传算法的图像分割
遗传算法（Genetic Algorithms，简称GA）是1973年由美国教授Holland提出的，是一种借鉴生物界自然选择和自然遗传机制的随机化搜索算法。是仿生学在数学领域的应用。其基本思想是，模拟由一些基因串控制的生物群体的进化过程，把该过程的原理应用到搜索算法中，以提高寻优的速度和质量。此算法的搜索过程不直接作用在变量上，而是在参数集进行了编码的个体，这使得遗传算法可直接对结构对象（图像）进行操作。整个搜索过程是从一组解迭代到另一组解，采用同时处理群体中多个个体的方法，降低了陷入局部最优解的可能性，并易于并行化。搜索过程采用概率的变迁规则来指导搜索方向，而不采用确定性搜索规则，而且对搜索空间没有任何特殊要求（如连通性、凸性等），只利用适应性信息，不需要导数等其他辅助信息，适应范围广。
遗传算法擅长于全局搜索，但局部搜索能力不足，所以常把遗传算法和其他算法结合起来应用。将遗传算法运用到图像处理主要是考虑到遗传算法具有与问题领域无关且快速随机的搜索能力。其搜索从群体出发，具有潜在的并行性，可以进行多个个体的同时比较，能有效的加快图像处理的速度。但是遗传算法也有其缺点：搜索所使用的评价函数的设计、初始种群的选择有一定的依赖性等。要是能够结合一些启发算法进行改进且遗传算法的并行机制的潜力得到充分的利用，这是当前遗传算法在图像处理中的一个研究热点。基于主动轮廓模型的分割方法
主动轮廓模型（active contours）是图像分割的一种重要方法，具有统一的开放式的描述形式，为图像分割技术的研究和创新提供了理想的框架。在实现主动轮廓模型时，可以灵活的选择约束力、初始轮廓和作用域等，以得到更佳的分割效果，所以主动轮廓模型方法受到越来越多的关注。
该方法是在给定图像中利用曲线演化来检测目标的一类方法，基于此可以得到精确的边缘信息。其基本思想是，先定义初始曲线C，然后根据图像数据得到能量函数，通过最小化能量函数来引发曲线变化，使其向目标边缘逐渐逼近，最终找到目标边缘。这种动态逼近方法所求得的边缘曲线具有封闭、光滑等优点。
传统的主动轮廓模型大致分为参数主动轮廓模型和几何主动轮廓模型。参数主动轮廓模型将曲线或曲面的形变以参数化形式表达，Kass等人提出了经典的参数活动轮廓模型即“Snake”模型，其中Snake定义为能量极小化的样条曲线，它在来自曲线自身的内力和来自图像数据的外力的共同作用下移动到感兴趣的边缘，内力用于约束曲线形状，而外力则引导曲线到特征此边缘。参数主动轮廓模型的特点是将初始曲线置于目标区域附近，无需人为设定曲线的的演化是收缩或膨胀，其优点是能够与模型直接进行交互，且模型表达紧凑，实现速度快；其缺点是难以处理模型拓扑结构的变化。比如曲线的合并或分裂等。而使用水平集（level set）的几何活动轮廓方法恰好解决了这一问题。基于深度学习的分割
1.基于特征编码（feature encoder based）
在特征提取领域中VGGnet和ResNet是两个非常有统治力的方法，接下来的一些篇幅会对这两个方法进行简短的介绍
a.VGGNet
由牛津大学计算机视觉组合和Google DeepMind公司研究员一起研发的深度卷积神经网络。它探索了卷积神经网络的深度和其性能之间的关系，通过反复的堆叠33的小型卷积核和22的最大池化层，成功的构建了16~19层深的卷积神经网络。VGGNet获得了ILSVRC 2014年比赛的亚军和定位项目的冠军，在top5上的错误率为7.5%。目前为止，VGGNet依然被用来提取图像的特征。
VGGNet的优缺点- 由于参数量主要集中在最后的三个FC当中，所以网络加深并不会带来参数爆炸的问题；
- 多个小核卷积层的感受野等同于一个大核卷积层（三个3x3等同于一个7x7）但是参数量远少于大核卷积层而且非线性操作也多于后者，使得其学习能力较强
- VGG由于层数多而且最后的三个全连接层参数众多，导致其占用了更多的内存（140M）
b.ResNet
随着深度学习的应用，各种深度学习模型随之出现，虽然在每年都会出现性能更好的新模型，但是对于前人工作的提升却不是那么明显，其中有重要问题就是深度学习网络在堆叠到一定深度的时候会出现梯度消失的现象，导致误差升高效果变差，后向传播时无法将梯度反馈到前面的网络层，使得前方的网络层的参数难以更新，训练效果变差。这个时候ResNet恰好站出来，成为深度学习发展历程中一个重要的转折点。
ResNet是由微软研究院的Kaiming He等四名华人提出，他们通过自己提出的ResNet Unit成功训练出来152层的神经网络并在ILSVRC2015比赛中斩获冠军。ResNet语义分割领域最受欢迎且最广泛运用的神经网络.ResNet的核心思想就是在网络中引入恒等映射，允许原始输入信息直接传到后面的层中，在学习过程中可以只学习上一个网络输出的残差（F(x)），因此ResNet又叫做残差网络。、
使用到ResNet的分割模型：- Efficient Neural Network（ENet）：该网络类似于ResNet的bottleNeck方法；
- ResNet-38：该网络在训练or测试阶段增加并移除了一些层，是一种浅层网络，它的结构是ResNet+FCN；
- full-resolution residual network(FRRN)：FRRN网络具有和ResNet相同优越的训练特性，它由残差流和池化流两个处理流组成；
- AdapNey：根据ResNet-50的网络进行改进，让原本的ResNet网络能够在更短的时间内学习到更多高分辨率的特征；
……
ResNet的优缺点：
1）引入了全新的网络结构（残差学习模块），形成了新的网络结构，可以使网络尽可能地加深；
2）使得前馈/反馈传播算法能够顺利进行，结构更加简单；
3）恒等映射地增加基本上不会降低网络的性能；
4）建设性地解决了网络训练的越深，误差升高，梯度消失越明显的问题；
5）由于ResNet搭建的层数众多，所以需要的训练时间也比平常网络要长。
2.基于区域选择（regional proposal based）
Regional proposal 在计算机视觉领域是一个非常常用的算法，尤其是在目标检测领域。其核心思想就是检测颜色空间和相似矩阵，根据这些来检测待检测的区域。然后根据检测结果可以进行分类预测。
在语义分割领域，基于区域选择的几个算法主要是由前人的有关于目标检测的工作渐渐延伸到语义分割的领域的，接下来小编将逐步介绍其个中关系。Stage Ⅰ： R-CNN
伯克利大学的Girshick教授等人共同提出了首个在目标检测方向应用的深度学习模型：Region-based Convolutional Neural Network（R-CNN）。该网络模型如下图所示，其主要流程为：先使用selective search算法提取2000个候选框，然后通过卷积网络对候选框进行串行的特征提取，再根据提取的特征使用SVM对候选框进行分类预测，最后使用回归方法对区域框进行修正。
R-CNN的优缺点：- 是首个开创性地将深度神经网络应用到目标检测的算法；
- 使用Bounding Box Regression对目标检测的框进行调整；
- 由于进行特征提取时是串行，处理耗时过长；
- Selective search算法在提取每一个region时需要2s的时间，浪费大量时间
Stage Ⅱ：Fast R-CNN
由于R-CNN的效率太低，2015年由Ross等学者提出了它的改进版本：Fast R-CNN。其网络结构图如下图所示（从提取特征开始，略掉了region的选择）Fast R-CNN在传统的R-CNN模型上有所改进的地方是它是直接使用一个神经网络对整个图像进行特征提取，就省去了串行提取特征的时间；接着使用一个RoI Pooling Layer在全图的特征图上摘取每一个RoI对应的特征，再通过FC进行分类和包围框的修正。
Fast R-CNN的优缺点- 节省了串行提取特征的时间；
- 除了selective search以外的其它所有模块都可以合在一起训练；
- 最耗时间的selective search算法依然存在。
Stage Ⅲ：Faster R-CNN
2016年提出的Faster R-CNN可以说有了突破性的进展（虽然还是目标检测哈哈哈），因为它改变了它的前辈们最耗时最致命的部位：selective search算法。它将selective search算法替换成为RPN，使用RPN网络进行region的选取，将2s的时间降低到10ms，其网络结构如下图所示：
Faster R-CNN优缺点：- 使用RPN替换了耗时的selective search算法，对整个网络结构有了突破性的优化；
- Faster R-CNN中使用的RPN和selective search比起来虽然速度更快，但是精度和selective search相比稍有不及，如果更注重速度而不是精度的话完全可以只使用RPN；
Stage Ⅳ：Mask R-CNN
Mask R-CNN（终于到分割了！）是何恺明大神团队提出的一个基于Faster R-CNN模型的一种新型的分割模型，此论文斩获ICCV 2017的最佳论文，在Mask R-CNN的工作中，它主要完成了三件事情：目标检测，目标分类，像素级分割。
恺明大神是在Faster R-CNN的结构基础上加上了Mask预测分支，并且改良了ROI Pooling，提出了ROI Align。其网络结构真容就如下图所示啦：
Mask R-CNN的优缺点：- 引入了预测用的Mask-Head，以像素到像素的方式来预测分割掩膜，并且效果很好；
- 用ROI Align替代了ROI Pooling，去除了RoI Pooling的粗量化，使得提取的特征与输入良好对齐；
- 分类框与预测掩膜共享评价函数，虽然大多数时间影响不大，但是有的时候会对分割结果有所干扰。
Stage Ⅴ：Mask Scoring R-CNN
最后要提出的是2019年CVPR的oral，来自华中科技大学的研究生黄钊金同学提出的
MS R-CNN，这篇文章的提出主要是对上文所说的Mask R-CNN的一点点缺点进行了修正。他的网络结构也是在Mask R-CNN的网络基础上做了一点小小的改进，添加了Mask-IoU。
黄同学在文章中提到：恺明大神的Mask R-CNN已经很好啦！但是有个小毛病，就是评价函数只对目标检测的候选框进行打分，而不是分割模板（就是上文提到的优缺点中最后一点），所以会出现分割模板效果很差但是打分很高的情况。所以黄同学增加了对模板进行打分的MaskIoU Head，并且最终的分割结果在COCO数据集上超越了恺明大神，下面就是MS R-CNN的网络结构啦~
MS R-CNN的优缺点：- 优化了Mask R-CNN中的信息传播，提高了生成预测模板的质量；
- 未经大批量训练的情况下，就拿下了COCO 2017挑战赛实例分割任务冠军；
- 要说缺点的话。。应该就是整个网络有些庞大，一方面需要ResNet当作主干网络，另一方面需要其它各种Head共同承担各种任务。
3.基于RNN的图像分割
Recurrent neural networks（RNNs）除了在手写和语音识别上表现出色外，在解决计算机视觉的任务上也表现不俗，在本篇文章中我们就将要介绍RNN在2D图像处理上的一些应用，其中也包括介绍使用到它的结构或者思想的一些模型。
RNN是由Long-Short-Term Memory（LSTM）块组成的网络，RNN来自序列数据的长期学习的能力以及随着序列保存记忆的能力使其在许多计算机视觉的任务中游刃有余，其中也包括语义分割以及数据标注的任务。接下来的部分我们将介绍几个使用到RNN结构的用于分割的网络结构模型：1.ReSeg模型
ReSeg可能不被许多人所熟知，在百度上搜索出的相关说明与解析也不多，但是这是一个很有效的语义分割方法。众所周知，FCN可谓是图像分割领域的开山作，而RegNet的作者则在自己的文章中大胆的提出了FCN的不足：没有考虑到局部或者全局的上下文依赖关系，而在语义分割中这种依赖关系是非常有用的。所以在ReSeg中作者使用RNN去检索上下文信息，以此作为分割的一部分依据。
该结构的核心就是Recurrent Layer，它由多个RNN组合在一起，捕获输入数据的局部和全局空间结构。
优缺点：- 充分考虑了上下文信息关系；
- 使用了中值频率平衡，它通过类的中位数(在训练集上计算)和每个类的频率之间的比值来重新加权类的预测。这就增加了低频率类的分数，这是一个更有噪声的分割掩码的代价，因为被低估的类的概率被高估了，并且可能导致在输出分割掩码中错误分类的像素增加。
2.MDRNNs（Multi-Dimensional Recurrent Neural Networks）模型
传统的RNN在一维序列学习问题上有着很好的表现，比如演讲（speech）和在线手写识别。但是 在多为问题中应用却并不到位。MDRNNs在一定程度上将RNN拓展到多维空间领域，使之在图像处理、视频处理等领域上也能有所表现。
该论文的基本思想是：将单个递归连接替换为多个递归连接，相应可以在一定程度上解决时间随数据样本的增加呈指数增长的问题。以下就是该论文提出的两个前向反馈和反向反馈的算法。
4.基于上采样/反卷积的分割方法
卷积神经网络在进行采样的时候会丢失部分细节信息，这样的目的是得到更具特征的价值。但是这个过程是不可逆的，有的时候会导致后面进行操作的时候图像的分辨率太低，出现细节丢失等问题。因此我们通过上采样在一定程度上可以不全一些丢失的信息，从而得到更加准确的分割边界。
接下来介绍几个非常著名的分割模型：a.FCN(Fully Convolutional Network)
是的！讲来讲去终于讲到这位大佬了，FCN！在图像分割领域已然成为一个业界标杆，大多数的分割方法多多少少都会利用到FCN或者其中的一部分，比如前面我们讲过的Mask R-CNN。
在FCN当中的反卷积-升采样结构中，图片会先进性上采样（扩大像素）；再进行卷积——通过学习获得权值。FCN的网络结构如下图所示：
当然最后我们还是需要分析一下FCN，不能无脑吹啦~
优缺点：- FCN对图像进行了像素级的分类，从而解决了语义级别的图像分割问题；
- FCN可以接受任意尺寸的输入图像，可以保留下原始输入图像中的空间信息；
- 得到的结果由于上采样的原因比较模糊和平滑，对图像中的细节不敏感；
- 对各个像素分别进行分类，没有充分考虑像素与像素的关系，缺乏空间一致性。
2.SetNet
SegNet是剑桥提出的旨在解决自动驾驶或者智能机器人的图像语义分割深度网络，SegNet基于FCN，与FCN的思路十分相似，只是其编码-解码器和FCN的稍有不同，其解码器中使用去池化对特征图进行上采样，并在分各种保持高频细节的完整性；而编码器不使用全连接层，因此是拥有较少参数的轻量级网络：
图像分割是计算机视觉研究中的一个经典难题，已经成为图像理解领域关注的一个热点，图像分割是图像分析的第一步，是计算机视觉的基础，是图像理解的重要组成部分，同时也是图像处理中最困难的问题之一。所谓图像分割是指根据灰度、彩色、空间纹理、几何形状等特征把图像划分成若干个互不相交的区域，使得这些特征在同一区域内表现出一致性或相似性，而在不同区域间表现出明显的不同。简单的说就是在一副图像中，把目标从背景中分离出来。对于灰度图像来说，区域内部的像素一般具有灰度相似性，而在区域的边界上一般具有灰度不连续性。 关于图像分割技术，由于问题本身的重要性和困难性，从20世纪70年代起图像分割问题就吸引了很多研究人员为之付出了巨大的努力。虽然到目前为止，还不存在一个通用的完美的图像分割的方法，但是对于图像分割的一般性规律则基本上已经达成的共识，已经产生了相当多的研究成果和方法。
本文对于目前正在使用的各种图像分割方法进行了一定的归纳总结，由于笔者对于图像分割的了解也是初窥门径，所以难免会有一些错误，还望各位读者多多指正，共同学习进步。
SetNet的优缺点：
- 保存了高频部分的完整性；
- 网络不笨重，参数少，较为轻便；
- 对于分类的边界位置置信度较低；
- 对于难以分辨的类别，例如人与自行车，两者如果有相互重叠，不确定性会增加。
以上两种网络结构就是基于反卷积/上采样的分割方法，当然其中最最最重要的就是FCN了，哪怕是后面大名鼎鼎的SegNet也是基于FCN架构的，而且FCN可谓是语义分割领域中开创级别的网络结构，所以虽然这个部分虽然只有两个网络结构，但是这两位可都是重量级嘉宾，希望各位能够深刻理解~
5.基于提高特征分辨率的分割方法
在这一个模块中我们主要给大家介绍一下基于提升特征分辨率的图像分割的方法。换一种说法其实可以说是恢复在深度卷积神经网络中下降的分辨率，从而获取更多的上下文信息。这一系列我将给大家介绍的是Google提出的DeepLab 。
DeepLab是结合了深度卷积神经网络和概率图模型的方法，应用在语义分割的任务上，目的是做逐像素分类，其先进性体现在DenseCRFs（概率图模型）和DCNN的结合。是将每个像素视为CRF节点，利用远程依赖关系并使用CRF推理直接优化DCNN的损失函数。
在图像分割领域，FCN的一个众所周知的操作就是平滑以后再填充，就是先进行卷积再进行pooling,这样在降低图像尺寸的同时增大感受野，但是在先减小图片尺寸（卷积）再增大尺寸（上采样）的过程中一定有一些信息损失掉了，所以这里就有可以提高的空间。
接下来我要介绍的是DeepLab网络的一大亮点：Dilated/Atrous Convolution，它使用的采样方式是带有空洞的采样。在VGG16中使用不同采样率的空洞卷积，可以明确控制网络的感受野。
图a对应3x3的1-dilated conv，它和普通的卷积操作是相同的；图b对应3x3的2-dilated conv，事迹卷积核的尺寸还是3x3（红点），但是空洞为1，其感受野能够达到7x7；图c对应3x3的4-dilated conv，其感受野已经达到了15x15.写到这里相信大家已经明白，在使用空洞卷积的情况下，加大了感受野，使每个卷积输出都包含了较大范围的信息。
这样就解决了DCNN的几个关于分辨率的问题：
1）内部数据结构丢失；空间曾计划信息丢失；
2）小物体信息无法重建；
当然空洞卷积也存在一定的问题，它的问题主要体现在以下两方面：
1）网格效应
加入我们仅仅多次叠加dilation rate 2的 3x3 的卷积核则会出现以下问题
我们发现卷积核并不连续，也就是说并不是所有的像素都用来计算了，这样会丧失信息的连续性；
2）小物体信息处理不当
我们从空洞卷积的设计背景来看可以推测出它是设计来获取long-ranged information。然而空洞步频选取得大获取只有利于大物体得分割，而对于小物体的分割可能并没有好处。所以如何处理好不同大小物体之间的关系也是设计好空洞卷积网络的关键。6.基于特征增强的分割方法
基于特征增强的分割方法包括：提取多尺度特征或者从一系列嵌套的区域中提取特征。在图像分割的深度网络中，CNN经常应用在图像的小方块上，通常称为以每个像素为中心的固定大小的卷积核，通过观察其周围的小区域来标记每个像素的分类。在图像分割领域，能够覆盖到更大部分的上下文信息的深度网络通常在分割的结果上更加出色，当然这也伴随着更高的计算代价。多尺度特征提取的方法就由此引进。
在这一模块中我先给大家介绍一个叫做SLIC，全称为simple linear iterative cluster的生成超像素的算法。
首先我们要明确一个概念：啥是超像素？其实这个比较容易理解，就像上面说的“小方块”一样，我们平常处理图像的最小单位就是像素了，这就是像素级（pixel-level）；而把像素级的图像划分成为区域级（district-level）的图像，把区域当成是最基本的处理单元，这就是超像素啦。
算法大致思想是这样的，将图像从RGB颜色空间转换到CIE-Lab颜色空间，对应每个像素的（L，a，b）颜色值和（x，y）坐标组成一个5维向量V[l, a, b, x, y],两个像素的相似性即可由它们的向量距离来度量，距离越大，相似性越小。
算法首先生成K个种子点，然后在每个种子点的周围空间里搜索距离该种子点最近的若干像素，将他们归为与该种子点一类，直到所有像素点都归类完毕。然后计算这K个超像素里所有像素点的平均向量值，重新得到K个聚类中心，然后再以这K个中心去搜索其周围与其最为相似的若干像素，所有像素都归类完后重新得到K个超像素，更新聚类中心，再次迭代，如此反复直到收敛。
有点像聚类的K-Means算法，最终会得到K个超像素。
Mostahabi等人提出的一种前向传播的分类方法叫做Zoom-Out就使用了SLIC的算法，它从多个不同的级别提取特征：局部级别：超像素本身；远距离级别：能够包好整个目标的区域；全局级别：整个场景。这样综合考虑多尺度的特征对于像素或者超像素的分类以及分割来说都是很有意义的。
接下来的部分我将给大家介绍另一种完整的分割网络：PSPNet：Pyramid Scene Parsing Network
论文提出在场景分割是，大多数的模型会使用FCN的架构，但是FCN在场景之间的关系和全局信息的处理能力存在问题，其典型问题有：1.上下文推断能力不强；2.标签之间的关系处理不好；3.模型可能会忽略小的东西。
本文提出了一个具有层次全局优先级，包含不同子区域时间的不同尺度的信息，称之为金字塔池化模块。
该模块融合了4种不同金字塔尺度的特征，第一行红色是最粗糙的特征–全局池化生成单个bin输出，后面三行是不同尺度的池化特征。为了保证全局特征的权重，如果金字塔共有N个级别，则在每个级别后使用1×1 1×11×1的卷积将对于级别通道降为原本的1/N。再通过双线性插值获得未池化前的大小，最终concat到一起。其结构如下图：
最终结果就是，在融合不同尺度的feature后，达到了语义和细节的融合，模型的性能表现提升很大，作者在很多数据集上都做过训练，最终结果是在MS-COCO数据集上预训练过的效果最好。
为了捕捉多尺度特征，高层特征包含了更多的语义和更少的位置信息。结合多分辨率图像和多尺度特征描述符的优点，在不丢失分辨率的情况下提取图像中的全局和局部信息，这样就能在一定程度上提升网络的性能。7.使用CRF/MRF的方法
首先让我们熟悉熟悉到底啥是MRF的CRF的。
MRF全称是Marcov Random Field，马尔可夫随机场，其实说起来笔者在刚读硕士的时候有一次就有同学在汇报中提到了隐马尔可夫、马尔可夫链啥的，当时还啥都不懂，小白一枚（现在是准小白hiahia），觉得马尔可夫这个名字贼帅，后来才慢慢了解什么马尔科夫链呀，马尔可夫随机场，并且在接触到图像分割了以后就对马尔科夫随机场有了更多的了解。
MRF其实是一种基于统计的图像分割算法，马尔可夫模型是指一组事件的集合，在这个集合中，事件逐个发生，并且下一刻事件的发生只由当前发生的事件决定，而与再之前的状态没有关系。而马尔可夫随机场，就是具有马尔可夫模型特性的随机场，就是场中任何区域都只与其临近区域相关，与其他地方的区域无关，那么这些区域里元素（图像中可以是像素）的集合就是一个马尔可夫随机场。
CRF的全称是Conditional Random Field，条件随机场其实是一种特殊的马尔可夫随机场，只不过是它是一种给定了一组输入随机变量X的条件下另一组输出随机变量Y的马尔可夫随机场，它的特点是埃及设输出随机变量构成马尔可夫随机场，可以看作是最大熵马尔可夫模型在标注问题上的推广。
在图像分割领域，运用CRF比较出名的一个模型就是全连接条件随机场（DenseCRF），接下来我们将花费一些篇幅来简单介绍一下。
CRF在运行中会有一个问题就是它只对相邻节点进行操作，这样会损失一些上下文信息，而全连接条件随机场是对所有节点进行操作，这样就能获取尽可能多的临近点信息，从而获得更加精准的分割结果。
在Fully connected CRF中，吉布斯能量可以写作：
我们重点关注二元部分：
其中k(m)为高斯核，写作：
该模型的一元势能包含了图像的形状，纹理，颜色和位置，二元势能使用了对比度敏感的的双核势能，CRF的二元势函数一般是描述像素点与像素点之间的关系，鼓励相似像素分配相同的标签，而相差较大的像素分配不同标签，而这个“距离”的定义与颜色值和实际相对距离有关，这样CRF能够使图像尽量在边界处分割。全连接CRF模型的不同就在于其二元势函数描述的是每一个像素与其他所有像素的关系，使用该模型在图像中的所有像素对上建立点对势能从而实现极大地细化和分割。
在分割结果上我们可以看看如下的结果图：
可以看到它在精细边缘的分割比平常的分割方法要出色得多，而且文章中使用了另一种优化算法，使得本来需要及其大量运算的全连接条件随机场也能在很短的时间里给出不错的分割结果。
至于其优缺点，我觉得可以总结为以下几方面：- 在精细部位的分割非常优秀；
- 充分考虑了像素点或者图片区域之间的上下文关系；
- 在粗略的分割中可能会消耗不必要的算力；
- 可以用来恢复细致的局部结构，但是相应的需要较高的代价。
OK，那么本次的推送就到这里结束啦，本文的主要内容是对图像分割的算法进行一个简单的分类和介绍。综述对于各位想要深入研究的看官是非常非常重要的资源：大佬们经常看综述一方面可以了解算法的不足并在此基础上做出改进；萌新们可以通过阅读一篇好的综述入门某一个学科，比如今天的内容就是图像分割。
谢谢各位朋友们的观看！
推荐阅读
如何从零开始系统化学习视觉SLAM？
从零开始一起学习SLAM | 为什么要学SLAM？
从零开始一起学习SLAM | 学习SLAM到底需要学什么？
从零开始一起学习SLAM | SLAM有什么用？
从零开始一起学习SLAM | C++新特性要不要学？
从零开始一起学习SLAM | 为什么要用齐次坐标？
从零开始一起学习SLAM | 三维空间刚体的旋转
从零开始一起学习SLAM | 为啥需要李群与李代数？
从零开始一起学习SLAM | 相机成像模型
从零开始一起学习SLAM | 不推公式，如何真正理解对极约束?
从零开始一起学习SLAM | 神奇的单应矩阵
从零开始一起学习SLAM | 你好，点云
从零开始一起学习SLAM | 给点云加个滤网
从零开始一起学习SLAM | 点云平滑法线估计
从零开始一起学习SLAM | 点云到网格的进化
从零开始一起学习SLAM | 理解图优化，一步步带你看懂g2o代码
从零开始一起学习SLAM | 掌握g2o顶点编程套路
从零开始一起学习SLAM | 掌握g2o边的代码套路
零基础小白，如何入门计算机视觉？
SLAM领域牛人、牛实验室、牛研究成果梳理
我用MATLAB撸了一个2D LiDAR SLAM
可视化理解四元数，愿你不再掉头发
最近一年语义SLAM有哪些代表性工作？
视觉SLAM技术综述
汇总 | VIO、激光SLAM相关论文分类集锦
研究SLAM，对编程的要求有多高？
2018年SLAM、三维视觉方向求职经验分享
2018年SLAM、三维视觉方向求职经验分享
深度学习遇到SLAM | 如何评价基于深度学习的DeepVO，VINet，VidLoc？
视觉SLAM关键方法总结
SLAM方向公众号、知乎、博客上有哪些大V可以关注？
SLAM实验室
SLAM方向国内有哪些优秀公司？
SLAM面试常见问题
SLAM相关领域数据集调研
从零开始一起学习SALM-ICP原理及应用
解放双手——相机与IMU外参的在线标定
目标检测
-
MySQL 面试题
2019-09-02 16:03:33MySQL 面试题 MySQL 涉及的内容非常非常非常多，所以面试题也容易写的杂乱。当年，我们记着几个一定要掌握的重心： 重点的题目添加了【重点】前缀。 索引。 ...因为 MySQL 还会有部分内容和运维相关度比较高，所以... -
测试开发笔记
2019-11-14 17:11:58★需求的跟踪 78 需求跟踪矩阵的作用： 78 需求的特点： 79 需求工程 79 变更控制流程图 82 第九章 缺陷管理 83 缺陷相关概念 83 缺陷管理相关概念 83 BUG管理基本流程： 84 BUG单 84 第十章 测试需求分析 86 概念：... -
js面试题
2019-04-09 19:42:32JavaScript 的组成 JavaScript 由以下三部分...BOM（浏览器对象模型）：提供了浏览器窗口之间进行交互的对象和方法 JS 的基本数据类型和引用数据类型 基本数据类型：undefined、null、boolean、number、string、s... -
【数据库学习】数据库总结
2018-07-26 13:26:411）概念 数据库是长期存储在计算机内、有组织的、可共享的大量数据的集合。 常见数据库管理系统有：Access、mysql、sql server 2）特点 ①数据库数据特点 永久存储、有组织、可共享。 ... -
TensorFlow入门
2019-04-23 10:09:29它还与计算机的其他单元（例如存储器，输入和输出）交互，用于执行来自存储器的指令，这是接口也是CPU的关键部分的原因。I / O接口有时包含在控制单元中。 它提供地址、数据和控制信号，同时接收在系统总线的帮助... -
软件测试面试题汇总
2018-09-27 12:31:09转载自： ... 软件测试面试题汇总 测试技术面试题 ........................................................................................................... -
C#基础教程-c#实例教程，适合初学者
2016-08-22 11:13:24面向对象程序设计方法提出了一个全新的概念：类，它的主要思想是将数据（数据成员）及处理这些数据的相应方法（函数成员）封装到类中，类的实例则称为对象。这就是我们常说的封装性。 类的基本概念 类可以认为是对... -
【MATLAB】MATLAB的基础知识
2017-04-12 11:52:00和其它高级语言不同的是，MATLAB使用变量时不需要先对变量类型进行说明，MATLAB会自动根据所输入的数据来决定变量的数据类型和分配存贮空间。 2.数值 在MATLAB内部，每一个数据元素都是用双精度来表示和... -
WPF开发教程
2019-07-02 23:13:20本主题提供 Windows Presentation Foundation (WPF) 类层次结构的指导教程，涵盖了 WPF 的大部分主要子系统，并描述它们是如何交互的。本主题还详细介绍了 WPF 架构师所做的一些选择。 System.Object WPF 主要... -
【JAVA面试】java面试题整理（3）
2018-10-28 12:50:13在使用MySQL的过程中对MyISAM和InnoDB这两个概念存在了些疑问，到底两者引擎有何分别一直是存在我心中的疑问。为了解开这个谜题，搜寻了网络，找到了如下信息： MyISAM是MySQL的默认数据库引擎（5.5版之前... -
《人机交互：软件工程视角》期末复习提纲
2021-01-18 15:16:59人机交互的目的：从尊重用户的角度来改善用户和计算机之间的交互，从而使计算机系统更加容易使用。 人机交互的研究内容 人机交互界面的表示模型与方法 可用性分析与评价 多通道交互技术 认知与智能用户界面 群件 ... -
无线传感器网络复习大纲
2019-04-30 10:31:40无线传感器网络组成部分，概念、特点（了解） 分布式特点（了解） 实时性、时效性（了解） 常见拓扑结构（了解） WSN几个分层、分层的功能（了解） 自组织网络多跳传输特点（了解） 1、1无线传感器网络... -
Linux实用教程(第三版)
2019-08-27 22:55:59丰富的软件包 安全性能好 方便的系统管理界面 详细而完整的在线文档 1.4.2 RHEL 7新特点（1） 包含Kernel 3.10版本，支持swap内存压缩可保证显著减少I/O并提高性能，采用 NUMA（统一内存访问）的调度和内存分配，... -
《人机交互技术》第二章 感知和认知基础
2018-06-17 22:40:05人的感知:通过人体器官和组织进行人与外部世界的信息的交流和传递，人机交互主要通过人的感知来完成，主要包括视觉感知（80%）、听觉感知和触觉感知。 1.视觉（第二版 P10） （1）视觉是人类最重要的感觉通道，... -
《人机交互的软件工程视角》知识点总结
2020-01-08 13:08:41人机交互学：是一门研究人、计算机以及他们之间相互联系的方式（交互）的科学。 交互：人与计算机之间的直接或间接的通讯 人机交互的目的：从尊重用户的角度来改善用户和计算机之间的交互，从而使计算机系统更加容易... -
成本归集与分配
2019-04-23 20:32:42一、归集与分配概念 1、成本归集：通过一定的会计制度以有序的方式进行成本数据的收集或汇总。例如制造费用按车间归集。 2、成本分配：将归集的间接成本分配给成本对象，也叫间接费用的分摊。 3、成本的核算... -
前后台交互加密方式
2019-04-29 18:03:36一、登录机制 粗略地分析， 登录机制主要分为登录验证、登录保持、登出三个部分。... 登录认保持是指客户端登录后， 服务器能够...容易想到的方案是，客户端登录成功后， 服务器为其分配sessionId, 客户端随后每次请... -
深入理解Java虚拟机-垃圾回收器与内存分配策略
2020-01-04 13:08:32Java与C++之间有一堵由内存动态分配和垃圾收集技术所围成的"高墙"，墙外面的人想进去，墙里面的人却想出来。 文章目录概述对象已死吗引用计数法可达性分析算法再谈引用生存还是死亡回收方法区垃圾收集算法标记-清除... -
人物交互（human object interaction）论文汇总-2020年
2020-11-08 11:39:051. Learning Human-Object Interaction Detection using Interaction Points 1.1 总述 大多数现有的HOI检测... 网络会预测交互点，这些交互点可以直接对交互进行定位和分类。与密集预测的交互向量配对，这些交互与人 -
OpenCV—Python 分水岭算法图像分割
2019-08-28 14:33:53分水岭算法是一种图像区域分割法，在分割的过程中，它会把跟临近像素间的相似性作为重要的参考依据，从而将在空间位置上相近并且灰度值相近的像素点互相连接起来构成一个封闭的轮廓，封闭性是分水岭算法的一个重要... -
C++ 面试题大全
2017-05-31 09:42:54简单来说，用new分配的内存用delete删除，用new[]分配的内存用delete[]删除。delete[]会调用数组元素的析构函数。内部数据类型没有析构函数，所以问题不大。如果你在用delete时没用括号，delete就会认为指向的是单个... -
功能安全专题之功能安全概念阶段
2020-06-30 16:42:53但这种识别方法不够精确，需要使用以下方法进行提炼： 相关项使用哪些途径与外界交换信息 已识别出的交互点是概念上的还是物理上的 是否有哪些交互的路径可以合并的 需要注意的是，在功能安全概念阶段，系统的交互点... -
操作系统概念第五章部分作业题答案
2019-11-04 10:23:08Solaris按照优先级排序有4种调度类型：实时、系统、分时和交互，每种类型有不同的priority和调度算法。 Scheduler将特定类的priority转换为全局priority，再选择全局priority最高的线程来执行，直到该线程阻塞、用... -
UML 交互图
2012-07-14 09:53:03UML 交互图 （顺序图、通信图、鲁棒图、定时图） ... 交互的概念 一次交互就是指在特定语境中，为了实现某一个目标，而在一组对象之间进行交换的一组消息所表示的行为 消息 UML中的4种交互图 顺序图 -
《操作系统》_考研复试_概念篇
2020-04-25 17:55:12前言： 本文作为本人的考研复试收尾笔记，先梳理全面精炼的基本知识，文末会附加我自己整理加搜集的重点面试概念题，大家可以用来自测，看是否真正掌握，如果对大家有帮助，希望大家点赞哦~(^▽ ^)
