穹灵科技

背景
2020 年 4 月，我们开始尝试实现 go 语言的分布式事务框架 Seata-Golang。众所周知，Seata AT 模式以无业务代码侵入的特点，被广大开发者推崇。Java 版 Seata AT 模式通过对 DataSource 数据源进行代理，在 sql 语句执行时，对 sql 拦截解析，获取数据库对应数据在 sql 语句执行前后的副本，序列化后保存起来，在 TC 协调回滚时用来回滚对应数据。实现 go 版本 client 的 AT 模式时，怎样对业务开发者更友好，入侵更少，成了首要考虑的目标。

使用 go 操作数据库时，我们会使用到 go 语言的官方库 database/sql，通过 sql.Open(“mysql”, ${dsn}) 获取一个数据源操作对象 db。开启事务时，使用 db.Begin() 或 db.BeginTx(ctx, &sql.TxOptions{}) 获得事务操作对象 tx，执行 sql 查询使用 tx.Query；执行 sql 新增、修改、删除，使用 tx.Exec；*后使用 tx.Commit() 提交或使用 tx.Rollback() 回滚。

go 语言官方库 database/sql 提供了一个标准抽象层，通过实现不同的 driver 一套标准的抽象 API 可以操作不同的数据库。开发 Go 版本的 AT 模式，必然要兼容 database/sql。通过研究 database/sql 的 api，创建数据源操作对象，数据库有关的配置必须通过 Data Source Name (DSN) 抽象传递进去，下面是 DSN 的定义：

[username[:password]@][protocol[(address)]]/dbname[?param1=value1&…&paramN=valueN]

实现 AT 模式对数据源代理是需要和事务协调器 TC 进行交互的，如果将 AT 模式实现在 driver 层，那么和 TC 交互的一些参数必须要通过 DSN 传递到 driver，这样有些破坏它的设计。所以，*后采取了一种折中方案，在 database/sql 层之上实现 AT 模式，代理 database/sql 创建出来的数据源操作对象。数据源代理对象实现 database/sql 库定义的 Tx 接口，另外再提供一个开启事务的方法：Begin()，虽然没有完全兼容 database/sql 的 api，但是关键接口和它的定义成一样，勉强还能接受。到此，Seata-Golang 项目核心功能的开发已完成。

转折
Seata-Golang  开源后，逐渐被一些开发者了解和接触，社区也对 Seata-Golang 发出了一些反馈的声音，不少开发者并不习惯写原生 sql，他们希望将 Seata-Golang 集成到 ORM 框架，因为当时的设计没有完全兼容 database/sql 导致集成上遇到一些困难。随着社区的热切呼唤，且得益于前期对 driver 的一些研究，念念不忘必有回响，今年 3 月突然灵感迸发：为什么参数一定要通过 DSN 传递？Seata-Golang Client 初始化后，在需要时通过 Client 端的 API config.GetATConfig() 直接获取使用不就可以了。

于是工作之余，历时 2 周开发，*个集成 Seata-Golang 的完全兼容 database/sql 的 mysql driver 被开发出来，项目开源在 https://github.com/opentrx/mysql，现处于 beta 状态，希望社区开发者使用后能有一些反馈，可通过例子：https://github.com/opentrx/seata-go-samples，查看使用方式并进行测试。

driver 的一些细节
使用该 driver 进行分布式事务操作时，不能在 dsn 中设置 interpolateParams 参数为 true。
这涉及到 mysql 的两个协议：Text 协议和 Binary 协议。有关两个协议的区别，可以在文末参考文档找到资料。实现该 driver 只对 binary 协议进行了处理，开启 interpolateParams 会使用 text 协议执行 sql。

使用该 driver 在需要加入全局事务组和 tc 进行交互时，需要使用 db.BeginTx(ctx context.Context, opts driver.TxOptions) 方法，并在 ctx 中加入 XID 全局事务 id 的值。

XID 传递到 driver 层，会保存在 &mysqlConn 连接对象中，在和 TC 交互时用到。

• 使用该 driver 的分布式事务功能前需要先初始化 seata-golang client 和 mysql driver：
• 

前几天无意间注意到一个可以在安卓机器上使用chroot容器技术运行arm或者x86的Linux系统（目前有些手机可能支持x64了），本文就来亲自体验下，还有后续会使用该技术搭建个人服务器、部署个人博客系统等。

一、前言

该技术的验证是在安卓系统上进行的，因此大家先要有一台安卓手机或者安卓平板。该技术的原理就是在安卓机上搁置一个chroot容器，来运行linux系统，那为啥别的系统不行呢，因为安卓的系统内核也是Linux的。我自使用小米4（系统安卓6.0）先后试验了debian、Ubuntu、CentOS都是成功的，本文将以CentOS为例进行验证。

二、准备工作

1.一台安卓设备（手机过着平板）

设备硬件要求：建议RAM在1G及以上，手机ROM空闲容量4G左右

设备软件要求：建议安卓版本4.0以上，系统必须是拥有ROOT系统权限的

2.Linux Deploy安卓软件

软件简介：安卓平台虚拟机（chroot运行linux的容器）

软件地址：https://github.com/meefik/linuxdeploy/releases  （本文使用*新版）

三、安装工作

注意：如果安卓设备没有拥有ROOT系统权限，得先ROOT设备（自行百度）

安装Linux Deploy

安装完成后打开Linux Deploy可以看到主界面如下：

然后我们点击左上角三个横杠然后点击设置：

这里是一些显示相关的设置，前面三个中的锁定wifi一定要打钩、保持CPU唤醒也要打钩、屏幕常亮一定关闭避免耗电

下面这些看自己的需求设置、开机启动建议打开，防止手机某些问题重启后，容易没打开这样服务就断开了

这里*重要的就是PATH变量，就是前面说的不要改的，填进去就好了（改了就填写改了的路径）设置的部分就先到这，下面是*重要的部分，进行系统安装的设置工作：

<1>在主界面点击左上角的三个横杠然后点击点击配置文件、然后新建文件的名称，可以随意定义，本文是安装CentOS系统就用其命名了

<2>点击手机右下角的设置图标，设置系统相关信息

这里的容器选择chroot（proot很不稳定）发行版本文选择CentOS，大家可以选择其他的发行版本安装架构这里一定要选对，不然安装会出错，或者安装完成后不能正常使用，这里一定要知道自己手机cpu的架构，我的小米4是晓龙801处理器，理论上是可以用x86的，但是我安装总是出错，所以选择向下兼容的armhfp，这架构大部分手机都是支持的；源地址默认或者可以切换成国内源，国内源安装的速度比较快，阿里的源地址是http://mirrors.aliyun.com/centos/ ，还有很多国内的比如网易等大家自己百度；安装类型选择镜像安装，安装地址可以默认，这里是改过的，/linux是指手机sdcard根目录的linux文件夹下的地址；

设置镜像大小2000mb往上（如果是用来做服务器，建议使用分区安装，这样可以使用整个手机所有的空间），文件系统建议选择ext4，其他的自定义信息大家自己填写，用户名和密码是待会进入系统需要的；DNS自动就好

这里的设置也很重要，一定要勾启用SSH，不然待会登陆不到系统，挂载点也勾选并设置，本文设置将sdcard整个挂载到Linux系统的/mnt/sdcard下，如下所示：

下面是一些桌面化的设置，本文是没有安装桌面的，因此没勾选某些项，大家需要桌面版可以自行勾选

<3>开始安装系统

设置完成返回主界面点击右上角三个点中的安装选项，开始系统的安装操作，然后等待安装，下面是系统安装的截图：

看到如下输出<<<deploy 时说明安装完成

<4>启动linux系统

在启动系统之前先点击一次停止按钮：看到如上停止信息时，再点击确定系统按钮：

看到如上启动信息，说明系统么启动成功

四、安装配置验证

在上面安装启动工作完成后，我们来验证安装是否成功，用电脑打开系统终端，开始连接测试：

我们使用root用户登陆正常，和正常的Linux系统是一样的，不过因为是运行在chroot下，有些命令是不支持的，具体请百度chroot了解

注意：本文使用的是Linux系统，可以直接在终端使用SSH命令测试连接，大家的要是window可以使用xshell或者putty等软件连接测试，若果没有电脑可以使用手机安装程序员工具这个软件或者ConnectBox连接验证

五、总结

经过前面的实验，已经成功的在安卓设备上安装了Debian GNU/Linux 8发行版，而且是正常的连接使用，后面我们实验在改系统上架设tomcat等服务，并且使用花生壳或者花生棒硬件映射服务到公网作为个人云主机使用。

1.安装linux Deploy与配置

这里要注意的是发行版和架构的设置，如上图一样

这里要注意的是安装路径，注意与你后面linux.img文件要拷贝到的地方，对应起来。

安装路径部分一定要改，我们不去等五六个小时下载，直接拷贝文件linux.img到存储卡里，大约是4G。所以linux.img拷贝到哪里，路径就设置成哪里，尤其是一些带内置存储卡的手机，要分清scard0和scard1。

注意记住用户名和密码

这里要注意桌面环境，建议使用LXDE（比较稳定）

2.安装VNC连接器

3.安装SSH连接器

4.将linux.img拷贝到存储卡下，存储卡要有足够的空间，大约5G。要注意与安装路径对应起来。

5.在Linux Deploy下START。

会显示

SSH :22 … done

VNC:5900 … done

<<<end: start

6.打开SSH，按照软件的要求输入，一般是[email protected]:22

IP:127.0.0.1  PORT:22 PASSWORD:changeme USERr:android

打开VNC Viewer :

账号及密码：VNC  IP:127.0.0.1  PORT:5900  PASSWORD::changeme

7.全部设置完后，打开VNC Viewer就能使用kali了，不过很多功能需要自己安装。

这么配置的原理是，linux Deploy运行一台主机，我们可以用ssh访问它，那样就会在命令行下操作，如果用vnc，那么就在图形界面中操作。

一、为什么需要 Knative

K8s 目前已成为云原生市场上的主流操作系统，K8s 对上通过数据抽象暴露基础设施能力，比如 Service、Ingress、Pod、Deployment 等，这些都是通过 K8s 原生 API 给用户暴露出来的能力；而对下 K8s 提供了基础设施接入的一些标准接口，比如 CNI、CRI、CRD，让云资源以一个标准化的方式进入到 K8s 的体系中。

K8s 处在一个承上启下的位置，云原生用户使用 K8s 的目的是为了交付和管理应用，也包括灰度发布、扩容缩容等。但是对用户来说，实现这些能力，通过直接操作 K8s API 难免有些复杂。另外节省资源成本和弹性对于用户来说也越来越重要。

那么，如何才能简单地使用 K8s 的技术，并且实现按需使用，*终实现降本增效的目的呢？答案就是 Knative。

二、Knative简介
1. Knative 是什么
定义

Knative 是一款基于 Kubernetes 的 Serverless 编排引擎，Knative 一个很重要的目标是制定云原生跨平台的编排标准，它通过整合容器构建、工作负载以及事件驱动来实现这一目的。

Knative 社区当前贡献者主要有 Google、Pivotal、IBM、Red Hat，可见其阵容强大，另外还有 CloudFoundry、OpenShift 这些 PAAS 提供商也都在积*地参与 Knative 的建设。

核心模块

Knative 核心模块主要包括两部分：事件驱动框架 Eventing 和提供工作负载的 Serving，接下来本文主要介绍 Serving 相关的一些内容。

2. 流量灰度发布
以一个简单的场景为例：

在 K8s 中实现基于流量的灰度发布

如果要在 K8s 中实现基于流量的灰度发布，需要创建对应的 Service 与 Deployment，弹性相关的需要 HPA 来做，然后在流量灰度发布时，要创建新的版本。

以上图为例，创始版本是 v1，要想实现流量灰度发布，我们需要创建一个新的版本 v2。创建 v2 时，要创建对应的 Service、Deployment、HPA。创建完之后通过 Ingress 设置对应的流量比例，*终实现流量灰度发布的功能。

在 Knative 中实现基于流量的灰度发布

如上图所示，在 Knative 中想要实现基于流量的灰度发布，只需要创建一个 Knative Service，然后基于不同的版本进行灰度流量，可以用 Revision1 和 Revision2 来表示。在不同的版本里面，已经包含了自动弹性。

从上面简单的两个图例，我们可以看到在 Knative 中实现流量灰度发布时，需要直接操作的资源明显较少。

3. Knative Serving 架构

**Service **
Service 对应 Serverless 编排的抽象，通过 Service 管理应用的生命周期。Service 下又包含两大部分：Route 和 Configuration。

Route
Route 对应路由策略。将请求路由到 Revision，并可以向不同的 Revision 转发不同比例的流量。

Configuration
Configuration 配置的是相应的资源信息。当前期望状态的配置。每次更新 Service 就会更新 Configuration。

Revision
每次更新 Configuration 都会相应得到一个快照，这个快照就是 Revision，通过 Revision 实现多版本管理以及灰度发布。

我们可以这样理解：Knative Service ≈ Ingress + Service + Deployment + 弹性（HPA）。

4. 丰富的弹性策略
当然，Serverless 框架离不开弹性， Knative 中提供了以下丰富的弹性策略：

基于流量请求的自动扩缩容：KPA；
基于 CPU、Memory 的自动扩缩容：HPA；
支持定时 + HPA 的自动扩缩容策略；
事件网关（基于流量请求的精准弹性）。
三、Knative 和 ASK 融合
1. ASK：Serverless Kubernetes

如果要准备 ECI 资源的话，需要提前进行容量规划，这无疑违背了 Serverless 的初衷。为摆脱 ECI 资源的束缚，不必提前进行 ECI 资源规划，阿里云提出了无服务器 Serverless——ASK。用户无需购买节点，即可直接部署容器应用，无需对节点进行维护和容量规划。ASK 提供了 K8s 兼容的能力，同时*大地降低了 K8s 的使用门槛，让用户专注于应用程序，而不是底层基础设施。

ASK 提供了以下能力：

免运维
开箱即用，无节点管理和运维，无节点安全维护，无节点 NotReady，简化 K8s 集群管理。

*致的弹性扩容
无容量规划，秒级扩容，30s 500pod。

低成本
按需创建 Pod，支持 Spot，预留实例券。

兼容 K8s
支持 Deployment/statfulset/job/service/ingress/crd 等。

存储挂载
支持挂载云盘、NAS、OSS 存储券。

Knative on ASK
基于应用流量的自动弹性，开箱即用，缩容到*小规格。

Elastic Workload
支持 ECI 按量和 Spot 混合调度。

集成 ARMS/SLS 等云产品
2. Knative 运维复杂度
Knative 运维主要存在三个方面的问题：Gateway、Knative 管控组件和冷启动问题。

如上图所示，在 Knative 中管控组件会涉及到相应的 Activator，它是从 0 到 1 的一个组件；Autoscaler 是扩缩容相关的组件；Controller 是自身的管控组件以及网关。对于这些组件的运维，如果放在用户层面做，无疑会加重负担，同时这些组件还会占用成本。

除此之外，从 0 到 1 的冷启动问题也需要考虑。当应用请求过来时，*个资源从开始到启动完成需要一段时间，这段时间内的请求如果响应不及时的话，会造成请求超时，进而带来冷启动问题。

对于上面说到的这些问题，我们可以通过 ASK 来解决。下面看下 ASK 是如何做的？

3. Gateway 和 SLB 融合

相比于之前 Istio 提供的能力，我们需要运营管控 Istio 相关的组件，这无疑加大了管控成本。实际上对于大部分场景来说，我们更关心网关的能力，Istio 本身的一些服务（比如服务网格）我们其实并不需要。

在 ASK 中，我们将网关这一层通过 SLB 进行了替换：

降成本：减少了十几个组件，大大降低运维成本和 IaaS 成本；
更稳定：SLB 云产品服务更稳定，可靠性更高，易用性也更好。
4. 管控组件下沉

对于 Knative 管控组件，ASK 做了一些托管：

开箱即用：用户直接使用 Serverless Framework，不需要自己安装；
免运维、低成本：Knative 组件和 K8s 集群进行融合，用户没有运维负担，也无需承担额外的资源成本；
高管控：所有组件都在管控端部署，升级和迭代更容易。
5. 优雅的保留实例
在 ASK 平台中，我们提供了优雅保留实例的能力，其作用是免冷启动。通过保留实例，消除了从 0 到 1 的冷启动时间。当我们缩容到 0 的时候，并没有把实例真正缩容到 0，而是缩容到一个低规格的保留实例上，目的是降低成本。

免冷启动：通过保留规格消除了从 0 到 1 的 30 秒冷启动时间；
成本可控：突发性能实例成本比标准规格实例降低 40% 的成本，如果和 Spot 实例结合还能再进一步降低成本。
四、实操演示
*后进行动手实践演示，以一家咖啡店（cafe）为例，演示内容主要有：

在 ASK 集群中安装 Knative；
部署 coffee 服务；
访问 coffee 服务；
保留实例。
————————————————
版权声明：本文为CSDN博主「阿里巴巴云原生」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/alisystemsoftware/article/details/115331140

随着企业的不断发展，企业产生大量的数据，这些数据既要保存下来，又要它们产生相应的价值。事实上，如何将数据存储并产生价值是每个企业不容忽视的问题。而在数字化和云端数据库蓬勃发展的今天，数据上云成为了众多企业数据库的首选。

在2019年HC大会上，华为重磅推出*新一代高扩展海量存储分布式数据库——TaurusDB，它拥有一个*大的特点就是将存储和计算以一种分离的架构形式运行。很多人就会问到，华为云为什么会设计这款产品？核心竞争力是什么？对比原生MySQL的优势有哪些？借此时机，CSDN记者有幸采访到了华为云TaurusDB数据库资深技术专家，现在就请他来为我们一一解答。

源起：TaurusDB数据库的设计初衷
当前，中国有近70% 新型企业的业务因数据挑战而受影响。现在随着互联网的飞速发展，所产生的数据量是以几何的模式在增长。数据量大、数据种类多对数据库的性能、可靠性等要求也越来越高。像金融行业，不仅需要高可靠的存储设备性能，更要保障数据的安全。

“传统的数据库及数据库上云模式，越来越不能满足客户业务的快速扩展和智能运维需求，客户需要的是一套能够灵活扩展、智能诊断、支持跨云融合的新一代云端原生数据库系统。与大数据相辅相成的云数据库，尤其是基于云场景架构设计的云原生分布式数据库，成为了企业的*佳选择。“华为云数据库专家在谈及TaurusDB设计初衷时讲到，分布式数据库现在是一个大的新趋势，而TaurusDB的定位是企业级分布式数据库，针对企业的高并发、海量吞吐等需求，有着非常优异的表现。

华为云数据库专家介绍到，TaurusDB是*个基于MySQL 8.0开发的高性能新一代企业级分布式数据库，设计目标是利用云原生设计解决传统的关系型数据库问题。它支持并行查询，DDL操作的原子性，异步写日志等优化。业界同类型的数据库都是基于MySQL 5.6、5.7开发的，而TaurusDB的设计研发充分发挥了华为公司的全栈优势，利用数据库软件与底层硬件、CPU、网络、存储芯片等垂直产品技术的整合，发挥出华为软硬件结合后的整体*大优势，并且使用了自研Hi1822芯片，以及下一代高性能DFV存储服务器、RDMA网络。

蝶变：左手计算，右手存储
TaurusDB 作为一个分布式集群架构，采用计算与存储分离、日志即数据的架构设计，支持1写15读的模式，性能可达到原生MySQL的7倍。此外，TaurusDB是构建在共享分布式存储上，存储空间*高达128T，能跨AZ部署。

TaurusDB利用计算存储分离架构，可以把数据库逻辑下推到存储层进行计算，充分发挥存储层的分布式计算能力，进一步提升数据库的性能，减少网络开销。针对TaurusDB的架构优势，华为云数据库专家分别就计算和存储两个层面做了阐述：

计算层

在计算层，TaurusDB采用了无锁优化，异步提交，主备机同步不再使用Binlog的模式。这个模式的好处就是大大释放了主机的压力，主机只管做“自己”的事情，无需和备机进行交互。相比传统的MySQL数据库，TaurusDB只需要5分钟就可以增加一个备机，即使增加到15个备机也不会有任何影响，而MySQL*多可加到5个左右的备机。

华为云数据库专家在采访中举例，Binlog的缺点是需要同步给所有的备机，相当于有多少备机就要同步到多少台机器中，这样做的后果就是直接拉低了主机的正常工作性能。因此，传统架构*多可以增加到5台备机，再增加备机就会导致无法正常工作。

存储层

TaurusDB存储层实现数据分片存储，保证故障快速恢复。例如：一共有1TB数据，即使只有1个字节的内容损坏，也需要恢复1TB的数据，且恢复时间非常长。但是如果实现分片存储，我们只需要恢复被破坏数据所在的分片即可。比如1TB数据，TaurusDB把它分成100个10GB的数据分片，如果只是某个分片坏了，就只需要恢复这10GB的数据即可。

“存储池化带来的好处就是，用户不需要担心存储空间不够用，存储层会根据当前容量进行自动扩容。”专家表示，客户无需担心存储容量的问题，TaurusDB自动在后台进行扩容。“按需收费，自动扩容”为客户带来非常人性化的产品体验服务。

谈及数据，“安全”就是不得不提的一个话题。在安全方面，TaurusDB的安全性能比原生MySQL更高。首先，数据分布式存储，并且是跨可用区的多副本，确保数据0丢失。其次，存储层本身就有一套成熟的数据隔离和加密机制。再次，MySQL8.0相对比原生MySQL 5.6、MySQL 5.7，在安全性方面也做了很多的优化和提升。*后， TaurusDB通过与DBSS(数据库安全服务)的透明化集成，不用修改应用，只需在界面配置即可享受智能化的安全保障，可以防御各种网络攻击，防护数据泄露。当前，华为云数据库已通过可信云认证，可提供国际级的隐私和数据保护。

目前，关系型数据库的场景都可以使用TaurusDB，尤其像读写负载*高的场景，例如社交应用，大型网站等。这些系统的数据量很大，并且增长较快，数据库并发访问量很高。传统的做法是使用分库表中间件，但是中间件对应用的开发有较高的要求，而且有比较多的使用限制。而TaurusDB本身就支持128TB的容量，在使用上和MySQL也没有任何区别，不需要客户自己做分库分表。另外，对性能和数据可靠性上有较高要求的业务，TaurusDB也是一个很好的选择。

升华：探索技术高峰，赋能行业发展
现在的企业都在走向信息化、互联网化，既要保存海量数据，还要使用和分析这些海量数据，那么未来OLTP和OLAP的混合型数据库也是一个重要的发展趋势，客户能够在一个数据库上快速完成交易和分析业务。未来云上的分布式数据库，计算存储分离是一个大趋势，在此架构之下，可以做很多的优化和提供更多的新功能。

现在TaurusDB产品即将公测上线，明年正式对外商用。华为云数据库专家表示，在接下来的产品研发中，会结合华为硬件优势，软硬件结合，进一步优化和提升性能。同时基于计算存储分离的架构，在多写、HTAP、算子下推等方面做进一步的研发。

不仅如此，华为云也将同步更新社区，让用户同时享受商业级的技术服务和开源软件的生态红利。华为云数据库专家表示，现在的MySQL用户可以零门槛地切换到TaurusDB，只要对SQL有所了解，就能操作TaurusDB。华为云数据库团队还在今年组织了TaurusDB性能挑战赛，希望吸引更多开发者关注TaurusDB产品，使其能够在不同的场景下产生价值。
————————————————

原文链接：https://blog.csdn.net/sch881226/article/details/103324306

Python3 基础语法

文章目录
Python3 基础语法
1.注释
2.行与缩进
3.多行语句
4.数字(Number)类型
5.字符串(String)
6.List（列表）
7.Tuple（元组）
7.Set（集合）
8.Dictionary（字典）
Python3 基础语法
1.注释
可以用多个 # 号，还有 ‘’’ 和 “””：

# *个注释
# 第二个注释
”’
第三注释
第四注释
”’

2.行与缩进
使用缩进代替大括号 {} ，同一个代码块，必须包含相同的缩进空格数。否则，会导致运行错误。

if True:
print (“True”)
else:
print (“False”)

3.多行语句
Python 通常是一行写完一条语句，但如果语句很长，我们可以使用反斜杠()来实现多行语句，例如：

total = item_one + \
item_two + \
item_three

在 [], {}, 或 () 中的多行语句，不需要使用反斜杠()，例如：

total = [‘item_one’, ‘item_two’, ‘item_three’,
‘item_four’, ‘item_five’]

4.数字(Number)类型
python中数字有四种类型：整数、布尔型、浮点数和复数。

float (浮点数), 如 1.23、3E-2
complex (复数), 如 1 + 2j、 1.1 + 2.2j

在 [], {}, 或 () 中的多行语句，不需要使用反斜杠()，例如：

total = [‘item_one’, ‘item_two’, ‘item_three’,
‘item_four’, ‘item_five’]

数值的除法包含两个运算符：/ 返回一个浮点数，// 返回一个整数。
>>> 2 / 4 # 除法，得到一个浮点数
0.5
>>> 2 // 4 # 除法，得到一个整数
0
>>> 17 % 3 # 取余
2
>>> 2 ** 5 # 乘方
32

5.字符串(String)
1.字符串用单引号 ‘ 或双引号 ” 括起来， ‘’，”“使用完全相同。同时使用反斜杠 \ 转义特殊字符。 2. 三引号(”’或”””)——多行字符串。
索引值以 0 为开始值，-1 为从末尾的开始位置。

word = ‘字符串’
sentence = “这是一个句子。”
paragraph = “””这是一个段落，
可以由多行组成”””

反斜杠()可以作为续行符。在 [], {}, 或 () 中的多行语句，不需要使用反斜杠()，例如：

total = [‘item_one’, ‘item_two’, ‘item_three’,
‘item_four’, ‘item_five’]

6.List（列表）
支持数字，字符串甚至可以包含列表（所谓嵌套）
注意：
1、List写在方括号之间，元素用逗号隔开。
2、和字符串一样，list可以被索引和切片。
3、List可以使用+操作符进行拼接。
4、List中的元素是可以改变的。

>>> a = [1, 2, 3, 4, 5, 6]
>>> a[0] = 9
>>> a[2:5] = [13, 14, 15]
>>> a
[9, 2, 13, 14, 15, 6]
>>> a[2:5] = [] # 将对应的元素值设置为 []
>>> a
[9, 2, 6]

7.Tuple（元组）
元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。

构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：
tup1 = () # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号
1
2
3
7.Set（集合）
基本功能是进行成员关系测试和删除重复元素。
使用 { } 或者 set() 函数创建，注意：空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
创建格式：

`parame = {value01,value02,…}
或者
set(value)`

sites = {‘Google’, ‘Taobao’, ‘Runoob’, ‘Facebook’, ‘Zhihu’, ‘Baidu’}

print(sites) # 输出集合，重复的元素被自动去掉

# 成员测试
if ‘Runoob’ in sites :
print(‘Runoob 在集合中’)
else :
print(‘Runoob 不在集合中’)

# set可以进行集合运算
a = set(‘abracadabra’)
b = set(‘alacazam’)

print(a)

print(a – b) # a 和 b 的差集

print(a | b) # a 和 b 的并集

print(a & b) # a 和 b 的交集

print(a ^ b) # a 和 b 中不同时存在的元素

8.Dictionary（字典）
字典用 { } ,是一个无序的 键(key) : 值(value) 的集合。

dict = {}
dict[‘one’] = “1 – 菜鸟教程”
dict[2] = “2 – 菜鸟工具”

tinydict = {‘name’: ‘runoob’,’code’:1, ‘site’: ‘www.runoob.com’}

print (dict[‘one’]) # 输出键为 ‘one’ 的值
print (dict[2]) # 输出键为 2 的值
print (tinydict) # 输出完整的字典
print (tinydict.keys()) # 输出所有键
print (tinydict.values()) # 输出所有值

以上实例输出结果：

1 – 菜鸟教程
2 – 菜鸟工具
{‘name’: ‘runoob’, ‘code’: 1, ‘site’: ‘www.runoob.com’}
dict_keys([‘name’, ‘code’, ‘site’])
dict_values([‘runoob’, 1, ‘www.runoob.com’])`

构造函数 dict() 可以直接从键值对序列中构建字典如下：

>>> dict([(‘Runoob’, 1), (‘Google’, 2), (‘Taobao’, 3)])
{‘Runoob’: 1, ‘Google’: 2, ‘Taobao’: 3}
>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}
>>> dict(Runoob=1, Google=2, Taobao=3)
{‘Runoob’: 1, ‘Google’: 2, ‘Taobao’: 3}
>>>

聚合、更新、循环
举例：输入一个简单的图结构

GNN

• 聚合操作
• 更新操作
• 循环操作（多层更新操作）
• 目的

GCN

• 修改的聚合部分
• • 平均法
  • 平均法存在的问题
  • GCN提出的方法

简单粗暴快速理解GNN
Graph-Unets
GCN中的拉普拉斯矩阵如何归一化？

举例：输入一个简单的图结构

GNN
聚合操作
经过一次聚合后：聚合到的信息：
邻 居 信 息 N = a ∗ ( 2 , 2 , 2 , 2 , 2 ) + b ∗ ( 3 , 3 , 3 , 3 , 3 ) + c ∗ ( 4 , 4 , 4 , 4 , 4 ) 邻居信息N = a*(2,2,2,2,2)+b*(3,3,3,3,3)+c*(4,4,4,4,4)
邻居信息N=a∗(2,2,2,2,2)+b∗(3,3,3,3,3)+c∗(4,4,4,4,4)

a 、 b 、 c a、b、c a、b、c ：自行设置或进行训练学习。
简单的说：就是将其他相邻节点的信息聚合，作为当前节点信息的一个补足。
更新操作
A的信息  = σ ( W ( ( 1 , 1 , 1 , 1 , 1 ) + α ∗   N ) ) \text { A的信息 }=\sigma\left(\mathrm{W}\left((1,1,1,1,1)+\alpha^{*} \mathrm{~N}\right)\right)
A的信息 =σ(W((1,1,1,1,1)+α
∗
N))

简单地说：将得到的邻居节点信息乘以系数加到当前节点，再乘以学习的权重和激活函数，从而获得聚合后的A的信息（一层GNN后的A的*终信息）。

α \alpha α ：自行设置或attention机制选出或进行训练学习。
W W W ：模型需要训练的权值参数。
σ \sigma σ ：激活函数。
循环操作（多层更新操作）
【n层的GNN可以得到n层的邻居信息】
经过一次聚合后:

A中有B,C,D的信息
B中有A,C的信息
C中有A,B,D,E的信息
D中有A,C的信息
E中有C的信息
那么第二次聚合之后以此类推

以A结点为例，此时A聚合C的时候，C中有上一层聚合到的E的信息，所以这时A获得了二阶邻居E的特征。
目的
通过聚合更新，到*后，我们能够得到每个结点的表达，也就是特征feature,此时:

结点分类就可以直接拿去分类，算loss, 优化前面提到的W
关联预测就*简单的方法两个节点的特征一拼,拿去做分类，一样的算loss, 优化。
归根到底，GNN就是个提取特征的方法! ! ! ! !
黑盒子表示：
输入的是节点特征与图的结构
输出的是包含结构与特征的节点的*终特征
用*终特征去进行分类、预测、回归等操作。
GCN
修改的聚合部分
修改了GNN的聚合部分，提出解决 a 、 b 、 c a、b、c a、b、c值的设定问题。

平均法

首先：提出将邻居的特征加起来作为特征求和。
之后又需要添加闭环：添加一个自环加上自身的特征。
然后：又将求和的特征平均一下的得到当前节点*终的特征。

平均法存在的问题

 

马云-我的例子。

GCN提出的方法

 

A ~ \tilde{A}
A
~
：邻接矩阵A+单位矩阵I（表示邻居的信息加上自己的信息）。
D ~ \tilde{D}
D
~
： A ~ \tilde{A}
A
~
的度矩阵。

使用了对称归一化的拉普拉斯矩阵方法解决了这个问题。

Python实现自定义队列

项目中需要读取一个pickle数据文件，pickle文件存储的是按行保存的文本，需要调用编码模型分别对每一条文本进行编码，然后使用numpy数组保存编码后的向量。由于模型每次只能输入一定batch size大小的数据，所以需要对数据继续分割后再输入模型编码向量，可以直接加载整个文件，通过batch size来分割整个文件数组。但是如果文件很大，这样的加载方式可能会导致内存溢出。因此考虑对文件进行单行读取，使用一个队列来接受读取的数据，当读取的行数等于batch size时，就将这个批次的数据送入模型进行编码。

于是自己写了一个简单的队列实现批量数据进入队列，队列满了之后清空队列，但与一般的队列不同，只使用一个index的指针来表示队尾巴，并实时返回队列是否已满（此处可以优化）。

队列代码

class data_queue(object):

def __init__(self,size,init_v = “”):
self.init_v = init_v
self.size = size
self.data = [init_v]*size
self.index = -1
self.isFull = False
self.over_v = init_v

def put(self,value):
self.index += 1
self.data[self.index] = value

if self.index == self.size-1:
self.isFull = True
self.over_v = value

return self.isFull

def pop(self):
if self.index < 0:
raise ValueError(“队列为空不能删除”)

# 从队首删除元素，后面的数据往前移
remain_data = self.data[1:self.index+1]
self.data[self.index] = self.init_v
self.data[:self.index] = remain_data

self.index -= 1

def pop_all(self):
if self.index < 0:
raise ValueError(“队列为空不能删除”)

for i in range(self.index,-1,-1):
self.data[i] = self.init_v
self.index -=1

self.isFull = False

def show_data(self):
print(self.index,self.data)

调用测试代码
#测试队列
data_list = [x*3 for x in “abcdefghijklmn”]
# 初始化队列
ds_q = data_queue(10)
tmp = []
for ele in data_list:
is_full = ds_q.put(ele)
ds_q.show_data()

if ele == “f”*3 or ele == “l”*3:
ds_q.pop()
print(“出队一个元素”)

if is_full:
print(“队列已满,返回队列中的值并清空队列”)
tmp = ds_q.data
ds_q.pop_all()

从调用结果来看，实现了队列的功能，在队列满队时就触发pop_all的操作，将所有的队列元素全部弹出去消费，将整个队列清空。因为我在实际使用时不使用pop单个元素的情况，所以编写出队操作的代码比较简单，直接将队头元素出队，整体移动后面的队列元素。但如果需要频繁出队就需要考虑性能，一般会设置队头指针，出队时对头指针往后移动，只有当队尾指针满队时再整体移动队列元素，或者使用循环队列,这个需要根据自己的需求来编写代码。

#测试结果
0 [‘aaa’, ”, ”, ”, ”, ”, ”, ”, ”, ”]
1 [‘aaa’, ‘bbb’, ”, ”, ”, ”, ”, ”, ”, ”]
2 [‘aaa’, ‘bbb’, ‘ccc’, ”, ”, ”, ”, ”, ”, ”]
3 [‘aaa’, ‘bbb’, ‘ccc’, ‘ddd’, ”, ”, ”, ”, ”, ”]
4 [‘aaa’, ‘bbb’, ‘ccc’, ‘ddd’, ‘eee’, ”, ”, ”, ”, ”]
5 [‘aaa’, ‘bbb’, ‘ccc’, ‘ddd’, ‘eee’, ‘fff’, ”, ”, ”, ”]
出队一个元素
5 [‘bbb’, ‘ccc’, ‘ddd’, ‘eee’, ‘fff’, ‘ggg’, ”, ”, ”, ”]
6 [‘bbb’, ‘ccc’, ‘ddd’, ‘eee’, ‘fff’, ‘ggg’, ‘hhh’, ”, ”, ”]
7 [‘bbb’, ‘ccc’, ‘ddd’, ‘eee’, ‘fff’, ‘ggg’, ‘hhh’, ‘iii’, ”, ”]
8 [‘bbb’, ‘ccc’, ‘ddd’, ‘eee’, ‘fff’, ‘ggg’, ‘hhh’, ‘iii’, ‘jjj’, ”]
9 [‘bbb’, ‘ccc’, ‘ddd’, ‘eee’, ‘fff’, ‘ggg’, ‘hhh’, ‘iii’, ‘jjj’, ‘kkk’]
队列已满,返回队列中的值并清空队列
0 [‘lll’, ”, ”, ”, ”, ”, ”, ”, ”, ”]
出队一个元素
0 [‘mmm’, ”, ”, ”, ”, ”, ”, ”, ”, ”]
1 [‘mmm’, ‘nnn’, ”, ”, ”, ”, ”, ”, ”, ”]

多线程与多进程

多线程与进程
进程（Process）

是计算机中的程序关于某数据集合上的一次运动活动，是系统进行资源分配
和调度的基本单位，是操作系统结构的基础。

线程（Thread）

有时被称为轻量级进程（Lightweight Process，LWP），是程序执行流的*
小单位。线程是进程中的一个实体，是被系统独立调度和分配的基本单位，
一个进程可以包含多个线程，但是线程不能包含多个进程。线程自己不拥有
系统资源，在单个程序中同时运行多个线程完成不同的工作，称为多线程。

线程与进程的区别

线程和进程的区别在于，子进程和父进程有不同的代码和数据空间，
而多个线程则共享数据空间，每个线程有自己的执行堆栈和程序计算器
为其执行上下文。

单线程实战

from time import ctime,sleep

def talk():
print(“start talk :%r”%ctime())
sleep(2)

def write():
print(“start write:%r”%ctime())
sleep(3)

if __name__ == ‘__main__’ :
talk()
write()
print(“All end !%r” %ctime())

多线程实战

# -*- coding: utf-8 -*-
from time import sleep,ctime
import threading

# 定义说和写
def talk(content,loop):
for i in range(loop):
print(“start talk:%s %s”%(content,ctime()))
sleep(2)

def write(content,loop):
for i in range(loop):
print(“start write:%s %s”%(content,ctime()))
sleep(3)
# 定义和加载说和写的线程
threads = []

t1 = threading.Thread(target=talk,args=(“hello”,2))
threads.append(t1)

t2 = threading.Thread(target=write,args=(“人生苦短，我用python！”,2))
threads.append(t2)
# 执行多线程
if __name__ == ‘__main__’:
for t in threads:
t.start()
for t in threads:
t.join()
print(“线程全部执行完成！%s”%ctime())

多进程实战

# -*- coding: utf-8 -*-
from time import ctime,sleep
# 导入multiprocessing进程模块
import multiprocessing

# 定义两个方法 说和写
def talk(content,loop):
for i in range(loop):
print(“Tlak: %s %s”%(content,ctime))
sleep(2)

def write(content, loop):
for i in range (loop):
print (“write: %s %s” % (content, ctime))
sleep (3)

# 定义两个进程
process = []
p1 = multiprocessing.Process(target=talk,args=(“hello”,2))
process.append(p1)

p2 = multiprocessing.Process(target=write,args=(“人生苦短，我用python”,2))
process.append(p2)

# 调用进程
if __name__ == “__main”:
for p in process:
p.start()
for p in process:
p.join()
print(“调用进程结束 %s”%ctime())

撸的 azure 天天得换 ip，流量也不够用。
良心云和套路云的轻量经常坚持不了两天。
现在就用 GHelper，晚上速度很差，youtube 看 720p 能费死劲。
不知道蓝灯怎么样有人用过嘛？
还有啥好的推荐么？