软件使用基础¶

Mixly 简介¶

Mixly（米思齐）是一款图形化编程软件。用户可以通过拼接积木块的方式来编写程序。目前为止，Mixly已经支持Arduino，micropython，python等编程语言。

简介¶

Mixly（米思齐）是在北京师范大学傅骞博士团队组织开发的一款国内自主研发，且免费开源的图形化编程工具。在国内外都掀起创客教育的浪潮中，傅骞老师认真分析了当前电子领域内的创客教育，并认为“如果不能给学生提供一个足够简单的、不能给教师提供一个容易上手的，不能给各大生产厂商提供一个足够自主的编程工具，所谓的“创”也只能是停留在表面的浮云，风一吹便散。”为了大力贯彻落实创客实验室“自主实践，分享快乐”的教育理念，傅骞老师带领其团队，开发出具有易用性、简单性、功能性、普适性、延续性及生态性等特点的Mixly。

特点¶

易用性¶

当前多数中小学机房安装了硬盘保护卡，频繁的软件安装与更新工作，给机房的管理工作造成极大的不便。为此，Mixly在设计上做到了完全绿色使用。用户直接从网上下载Mixly软件包，解压后即可在Windows XP及以上的操作系统运行。软件无需额外安装浏览器，也不用安装Java运行环境，极大方便了师生的使用。

简单性¶

Mixly采用了Blockly图形化编程引擎，使用图形化的积木块代替了复杂的文本操作，为学生的快速入门奠定了良好的基础。另外，Mixly的开发团队使用以下方式来帮助师生快速熟悉软件：第一，用不同颜色的示意图标代表不同类型的功能块，方便用户归类区分；第二，在复合功能块中提供默认选项，有效减少用户的拖动次数；第三，在同一个界面整合软件的所有功能；第四，提供参考教程及代码示例。

功能性¶

当前，很多学校将组织或参与创客类比赛作为创客教育的一种途径，比赛的竞技性对软件的功能提出了更高的要求。因此，Mixly在功能的设计上力求和Arduino IDE的文本编程保持一致，目前最新发布的Mixly 0.97版已经实现Arduino的所有官方功能（包括中断处理），并加入了大量的第三方扩展库功能，如红外遥控、超声波等，可以保证课程开设和各类创客比赛的双重需求。

普适性¶

Mixly在设计上考虑了绝对的普适性。首先，对于Arduino官方支持的所有开发板，Mixly都提供了完美的支持：Mixly会根据开发板的类型自动改变模块中的管脚号、中断号、模拟输出管脚等；其次，对于Arduino支持的第三方开发板，Mixly同样支持，用户只要把相应开发板的定义复制到Mixly中即可。如国内大量的ESP8266开发板、各类用户修改后的开发板等等，以保证用户在开发板选择上的最大自由度。

延续性¶

图形化编程系统的目标绝对不是替换原有的文本编程方式，而是希望学生通过图形化编程更好更快地理解编程的原理和程序的思维，并为未来的文本编程打好基础。Mixly的设计理念也是如此。在软件的设计上加入了更多的可延续性内容，从而保护用户的学习成果。具体来说，包括引入变量类型、在模块的设计上尽量保持和文本编程的一致、支持图形编程和文本编程的对照等。

生态性¶

生态性是Mixly最重要的设计理念，也是它区别于其它Arduino图形化编程的最重要特征。为了实现Mixly可持续发展，Mixly在设计上既允许厂商开发自己的特有模块（当前已经支持DfRobot、StartLab、MakeBlock、Sense、Seeed、Lubot，Microduino、Ruilong、NodeMcu，Nova，用户需要有JavaScript编程基础才能制作这部分模块），也允许用户直接利用Mixly的图形化编程功能生成通用模块（如数码管显示、蜂鸣音播报等，用户只需会使用Mixly即可制作这部分模块）。以上两类模块均可通过“导入库”功能导入Mixly系统，从而在Mixly软件的普及中实现用户自身的价值。

软件安装与更新¶

目前最新版本为1.0.0，支持Windows 7/8/10、MacOS、Linux(非arm框架)。

下载软件¶

【Window系统地址1】 Mixly For Win7or10
【Window系统地址2】 Mixly For Win7or10
【Mac系统】 Mixly For Mac

Windows版本安装¶

安装软件¶

下载Mixly_WIN.7z压缩包，右键解压到本地磁盘。

注解

建议解压到硬盘根目录，路径不能包含中文及特殊字符(如:. _ ( ) 等)。
建议安装路径如E:Mixly

解压后目录如图所示。

第一次解压的软件只含有最基础的文件，不能直接运行。需要先运行一键更新.bat 或 update.bat下载最新版的Mixly软件。

等待片刻后，会显示更新进度。

当看到提示“Mixly更新完成”时，说明软件下载完毕。

更新完成后，软件目录如图所示，可以双击Mixly.exe打开Mixly软件。

更新软件¶

Mixly软件的更新是基于git设计的，每次更新会自动对比最新版与用户使用的版本的差异，只更新差异文件，避免重复下载造成版本混乱。

先关闭Mixly软件，再运行一键更新.bat或update.bat 启动更新程序。

稍等片刻后，更新完成。

驱动安装¶

开发板与电脑连接通讯需要安装相应的串口芯片驱动，常用的串口芯片驱动有CH340和CP2102。在arduino/drivers目录中可以找到这两种串口芯片驱动。

根据使用的开发板的串口芯片选择相应的驱动，如果不确定是哪种串口芯片，也可以将两个驱动都安装上。

启动软件¶

双击Mixly.exe即可启动Mixly软件。

Mac版本安装¶

解压软件¶

下载jre-8u221-macosx-x64.dmg Java 安装包，根据提示默认安装。

下载Mixly1.0_MAC.zip压缩包，右键解压到本地磁盘。

解压后目录如图所示。

1.MAC必须安装JDK8,而且只能安装JDK8,高版本JAVA不行，可以直接使用云盘目录自带的JDK 2.需要安装相应的开源硬件驱动，常用的就是云盘自带的cp210x驱动和ch34x驱动 3.需要自行安装 python3(安装包在云盘) 4.安装完python3之后，运行以下命令行操作

sudo xcode-select --install
ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
brew install portaudio
pip3 install pyaudio
brew install opencv
pip3 install opencv-python
pip3 install baidu-aip matplotlib pandas numpy

5.解压Mixy后双击Mixly.jar即可使用

驱动安装¶

开发板与电脑连接通讯需要安装相应的串口芯片驱动，常用的串口芯片驱动有CH340和CP2102。 Mixly/drivers目录中可以找到这两种串口芯片驱动。

根据使用的开发板的串口芯片选择相应的驱动，如果不确定是哪种串口芯片，也可以将两个驱动都安装上。

启动软件¶

双击Mixly.jar即可启动Mixly软件。

更新软件¶

Mixly软件的更新是基于git设计的，每次更新会自动对比最新版与用户使用的版本的差异，只更新差异文件，避免重复下载造成版本混乱。

先关闭Mixly软件。打开终端并通过 cd 命令进入mixly软件所在目录（输入 cd后可以将mixly文件夹拖入终端窗口）。

依次输入输入更新命令：

git add *
git stash
git pull origin master

稍等片刻，就可以看到更新文件完成。

界面介绍¶

Mixly软件主要分成图形化程序选择区、图形化程序编辑区、代码预览区、系统功能区、消息提示区。

图形化程序选择区¶

图形化程序选择区中包含了各类图形化程序，每一个类别中都包含多个图形化。通过将这些图形块拖动到图形化程序编辑区就可以完成编程。

程序编写区¶

程序编写¶

我们通常把能完成一定功能的代码块拖动到该区域处进行连接。

程序删除¶

将不需要的代码拖到右下方的垃圾桶。
将不用的代码拖到最左侧的图形化程序选择区。
选中不用的代码后点击键盘Delete或者Backspace键。

程序缩放¶

在右下角垃圾桶上方有缩放按钮。

第一个按钮是图形块大小正常化并居中。
第二个是放大图形块。
第三个是缩小图形块。

当然也可以直接使用鼠标滚轮进行缩放。

程序整理¶

当编写的程序比较多时，需要对程序进行整理。

在空白区右击，选择清理块。

注意

只有当有多个分离块时，才能进行整理。

程序复制¶

在图形块上右击，选择复制，会产生一个一样的块，但该方式只能复制一个块。

先用鼠标拖住多个块，再按下Ctrl+C，Ctrl+V可以复制多块。

切换语言¶

在该区域的右上角，还可以选取语言的种类。

截止目前为止，Mixly可支持英语、西班牙语、简体中文及繁体中文。

撤销及重做¶

在选择语言的左边还有两个箭头，分别是撤销（undo，Ctrl + Z）及重做（redo，Ctrl + Y）。

撤销功能是当我们编写代码时误删代码后，便可点击左箭头或直接按Ctrl + Z来恢复误删代码。

而重做则是和Ctrl + Z相反，它是恢复上一步操作，该功能也可通过点击右箭头或直接键入Ctrl + Y 来实现。

帮助文档¶

在选择语言的左侧?图标是帮助文档的链接，点击该图标可以打开帮助文档。

代码预览区¶

该区域可通过点击右侧深灰色箭头来显示或隐藏。

在图形化程序选择区拖拽图形块后，在代码编辑区会生成对应的代码。可以帮助用户掌握代码的学习。

注意

在该区域无法直接对代码进行编辑，需要点击图形化程序选择区左上角的代码按钮才能进行编辑。

消息提示区¶

消息提示区通常是给学生予以信息反馈的场所。比如编译或上传进程中，编译或上传是否成功，如果失败原因是什么；或者是导入库是否成功等消息。

系统功能区¶

系统功能区主要执行的功能有新建、打开、保存、另存为、导出库、导入库、管理库、编译、上传、选择主控板型号及端口、串口监视器及软件界面放大缩小等功能。

一般功能¶

Mixly的一般功能包括新建、打开、保存、另存为，其中代码保存或另存为的格式为.mix或者.ino。

当用户需要打开已保存的文件时，可以先打开Mixly软件，再点击“打开”，找到*.mix文件。也可以直接双击*.mix文件打开。

库功能¶

为了方便用户使用及代码分享，Mixly特增加了库功能。库功能分别包括：导出库，导入库以及管理库。当用户编写完一段代码后（比如语音播报），可这个代码集成在一个函数中（假设该函数为sayNum）。之后只需要点击导出库并给该库起个名字便能使用。

保存后就可以将该库上传至平台，供他人下载使用、学习。

当有人下载该代码后，可直接将该库进行导入并使用。点击导入库找到该文件的位置。

导入后界面会刷新，耐心等待1-2秒，便可在模块选择区见到新导入的库，同时，在消息提示区也会提示“导入自定义库成功！”接着可直接点击sayNum库，将指令拖入程序构建区，调用该函数即可。

管理库的功能是可以对已导入的库进行重命名、删除和打开目录。

编译&上传¶

当用户编写完代码后，如果想要检查代码逻辑是否有误，可点击编译。

如果显示“编译失败”，则需要根据提示检查自己的代码，如显示“编译成功”则证明代码逻辑上无误，可上传。

如果出现“上传失败”，大多数情况插拔USB线即可解决该问题。

如果出现“上传成功”，则证明代码已上传至板子上。当然，如果用户对于代码逻辑信心十足，可直接点击上传按钮。

板卡&端口¶

当用户点击主控板下拉三角时即可看到有众多主控板型号可供选择。用户需按照当前手中主控板型号予以选择。

注意

开始编程前就要先选择板卡，编写好程序再切换板卡将导致程序丢失。

选择好板卡后，还需要选择该板卡对应的端口号，端口号是计算机与板卡通信的通道。

串口监视器¶

串口监视器与模块选择区的通信模块中的串口通信指令一起使用。可以用于输出变量、传感器数值等。

界面缩放¶

在串口监视器右侧有一个左右可拉的按钮，该按钮可放大或缩小Mixly整个界面的大小。

与程序构建区内的放大、缩小不同（该按钮只可放大或缩小程序构建区代码的大小），拖动缩放界面可放大除消息提示区外所有区域的大小。

支持板卡¶

从语言上来说，Mixly目前支持Arduino、MicroPython、Python三种语言。当我们开始使用Mixly编写程序时，需要先在Mixly软件右下角选择正确的板卡

Arduino板卡¶

该类别下采用Arduino编程，支持板卡如下：

Arduino/Genuino Uno

Arduino Nano

Arduino/Genuino Mega or Mega 2560

Arduino Leonardo

Generic ESP8266 Module
NodeMCU 1.0 (ESP-12E Module)

LOLIN(WEMOS) D1 R2 & mini

WeMos D1 R1

ESP32 Dev Module

Arduino MixGo

Arduino HandBit

Arduino MixePi

MicroPython板卡¶

该类别下采用MicroPython编程，支持板卡如下。

MicroPython[ESP32_Generic]

MicroPython[ESP32_HandBit]

MicroPython[ESP32_MixGo]

MicroPython[NRF51822_microbit]

Python¶

纯python编程，不需要任何板卡。

mixpy

范例¶

创客教育的核心不是知识的重复复制或复杂功能的底层实现，而是激发学生的创新并享受分享所带来的快乐。基于Mixly的创意电子课程也要遵循这样的理念。遂从Mixly的技术特点出发，将Mixly的应用模式分为以下几类：

模仿延展类¶

该模式主要用于Mixly初学者学习创意电子的基础知识，其具体步骤如下：

由教师创设情境，并提出本次课（活动）的具体任务；
启发学生思考，得出实现本任务的基本思路并鼓励学生尝试实现；
教师给出参考实例，学生基于教师的代码模仿完成；
教师给出扩展任务方向，引导学生修改原有的代码实现。

下面以《两只老虎》为例描述这一过程。本课的目标是让学生学会使用蜂鸣器播放简单的音乐。首先，教师需要讲解基本乐理知识及Mixly中声音的播放方法，然后引导学生思考并鼓励学生尝试实现。在实际教学中，学生最初的实现过于浅显，与目标任务相差甚远。在给出合适的鼓励后再给出如图4-1所示的实现方式（使用四个数组分别用来表示基本音阶、音乐的音高、变调和时长），并引导学生进行模仿。模仿成功后，教师需要讲解实现的基本原理并给出延伸任务，让学生设计更复杂的音乐。事实上，学生只需简单地修改数组就可以播放出不同的音乐。

创意整合类¶

该模式主要用于具有一定Mixly基础的学生针对某一技术的创意整合应用，其具体步骤如下：

由教师创设情境，并提出一个特定的功能需求；
启发学生思考，得出实现功能的基本思路；
教师给出功能的具体实现模块，学生导入并体验；
激发学生创新，结合本模块和先前知识给出创意应用。

下面以《语音温度计》为例描述这一过程。本课的目标是实现低成本的人机交互。首先，教师抛出问题：如何才能让用户知道Arduino中的结果数据?学生一般会给出各种各样的答案，教师在给出合理的正向反馈后分析各种答案的可行性，并引导学生提出通过蜂鸣器播报数据的方案。在此基础上，给出相应的扩展库让学生尝试使用（一般不建议让学生理解该库的实现原理，只需会用即可）。然后，教师需要激发学生思考如何利用该库完成创新应用。图4-2给出了一个语音温度计的Mixly实现（LM35和A0相连，蜂鸣器和10号管脚相连），图4-3则是语音播报库的具体实现。

协同合作类¶

该模式主要用于Mixly专业学习者协同完成综合性任务，其具体步骤如下： * 学生以小组为单位，通过协商得出要做的综合任务目标； * 教师在听取学生的汇报后，给出项目的可行性评估及实现建议； * 学生在教师的帮助下完成基于模块的任务分工并实现最初的设计； * 小组汇总程序、进行调试，并完成最终成果的展示。

下面以在中学讲授《创意电子》课程的一个小组综合项目为例，描述这一过程。本课的目标是使学生综合运用元件和所学知识开发出一个创意作品。此前，教师应讲解在复杂的程序设计中代码模块化的意义，并给出一些具体的例子。在此基础上，学生自愿结为两人小组，提出创意。此处仅以其中一组学生设计并实现的温控报警散热器为例，描述后续过程。小组成员提出，使用温度传感器、蜂鸣器、LED灯、数码管等元件制作一个具有显示温度和报警功能的散热器。学生描述功能并进一步对其进行分解，除了使用到教师提供的一位共阳数码管库外，还构建了呈现彩色灯（colorRGB）、电扇开关控制（fan）、声光报警（ring）、获取温度（getTem）四个函数。开发过程灵活使用了Mixly的导入/导出库功能：一位同学负责物理连接和四个子函数的编写并使用“导出库”功能将其导出成库文件，另一位同学负责基于功能描述设计整体逻辑并在导入该文件后完成主函数的编写。图4-4、图4-5分别是该作品的库文件代码和主程序代码，图4-6是该作品的实物图。

自定义公司库¶

Mixly方便各大硬件厂商技术人员编写自己公司产品的库以供用户使用。编写库的人员只需具备最基础的程序设计知识，了解公司库编写的规则，即可完成公司库的编写。 ### 一个完整的公司库的目录下面是一个名为xxx的公司库的完整目录： .. image:: images/26/26-1.png

该目录下不是所有的文件都是必须的，视公司库的具体情况而定。下面就对每一个目录进行说明。

block和generator¶

block和generator文件夹下分别有一个JS文件，一般是同名的，比如xxx.js。block/xxx.js文件定义了你定制的图形化模块的样子。 generator/xxx.js文件定义了每一个图形化模块对应的Arduino代码。比如下图就是“延时”的图形化模块的样子及其对应的Arduino代码：

block和generator目录通常是必不可少的，因此保证block/xxx.js和generator/xxx.js的正确性是成功定制公司库的关键。比如“延时”模块的两部分JS代码分别如下：

对于这两个JS文件如何书写，在软件的blockly/blocks和blockly/generators/arduino目录下有大量的例子，基本包含了全部类型的图形化模块的定制方法。如果您想更深入的了解这些代码，您可以访问Google的blockly源码进行更加深入的研究。

hardware目录¶

hardware目录不是必需的目录，通常在公司使用了自己的Arduino板子（即官方的Arduino IDE没有我们所需要的板子）时，才需要hardware目录，该目录包含了一些跟硬件相关的信息，比如板子信息，管脚信息等等。因此，需要比较专业的技术人员进行定制此目录。最后是一个以公司名（比如xxx）命名的文件夹形式存在，直接拷贝至hardware目录下即可。

xxx目录¶

xxx目录是自己的Arduino库，xxx一般以公司名命名，里面包含一些.cpp和.h文件，这个目录也不是必需的，一般在生成的代码中有#include <xxx.h>时需要。

companypin目录¶

companypin目录定义了公司所需板子的管脚对应关系，该目录也是非必需的，通常在公司使用了全新的Arduino板子时才需要。下面以lubot的新板子Lubot MK为例：

我们想为这块板子定义新的管脚对应关系，先在companypin目录下建立子文件夹lubot（通常以公司名命名），再建立pin.js文件，打开pin.js文件，管脚定义如下图所示（包括数字管脚、模拟管脚、PWM管脚、中断管脚以及Serial选择和默认波特率）：

language目录¶

![]如果想让公司库支持多国语言，就需要language目录，这个也是非必需的。先在language目录下建立子文件夹xxx（通常以公司名命名），再在xxx文件夹下建立多国语言文件。如下图所示：分别是英语、西班牙语、简体中文、繁体中文。在这些多国语言的js文件中定义了一些JS常量。

下面讲解如何定义这些JS文件，还是以“延时”模块为例，下面分别是英语、西班牙语、简体中文、繁体中文对应的样子：

再来看如何在语言文件中定义对应的文字。

最后在block/xxx.js文件中引用即可： .. image:: images/26/26-16.png

media目录¶

media目录下是一些媒体文件，主要是图片，这个目录是非必需的。只有当模块需要使用图片时才需要该文件夹。比如下面这个模块里面就嵌入了一张图片： .. image:: images/26/26-17.png

所有的媒体文件放在media/xxx下即可，xxx是子文件夹，通常以公司名命名 xxx.xml文件 ————— xxx.xml文件是一个非常重要的文件，它是必不可少，通常以公司名命名。在这个文件中定义了所有需要呈现的模块，以及整个库中相关文件的路径（即前面提过的这些文件目录）。下面是一个空例子，可以基于这个例子进行修改。

把写好的库导入Mixly¶

当我们把整个库写好之后，就可以把写好的库导入到Mixly中去了。打开Mixly软件（版本要求0.964及以上）。点击“导入库” 找到xxx.xml文件。 .. image:: images/26/26-19.png

点击打开就完成整个公司库的导入（前提是公司库必须正确）。

第三方库开发¶

Mixly特设了第三方拓展功能。方便各大硬件厂商技术人员编写自己公司产品的库以供用户使用。截止Mixly0.97版本，现第三方扩展有：DFROBOT、SEEEDSTUDIO、MAKEBLOCK、MBOT机器人、SENSE盒子、SENSE机器人、LuBot、Micoduino、Nova。

FAQ¶

下面是用户常见的一些问题及解决方案。

同一个库在0.995上可以使用，但在0.996上使用不了

注解

解决方法：这是由于blockly核心升级导致的，新版的blockly不再向前兼容。

可采用如下两种方法：

方法1：采用1.0以上版本。
方法2：将旧版库里block/XX.js中全局替换appendTitle为appendField，将generator/XX.js中全局替换getTitleValue为getFieldValue

arduino系列板子，点击上传后出现`avrdude: stk500v2_ReceiveMessage(): timeout`

注解

解决方法：按下列可能方法依次检查。

方法1：板子下拉框中选的板子型号和实际计算机连接的板子型号不对；
方法2：串口下拉框选择不对，可通过设备管理器查看板子对应的是哪个串口；
方法3：板子与电脑接口松动。可尝试拔了板子，再重新插上；
方法4：数据线坏了，可尝试换数据线；
方法5：板子损坏，可尝试换新板子；

Mixly 支持在哪些操作系统编程？

注解

目前Mixly软件支持在WIN7/10,MacOS上运行。
早期版本 Mixly0.995支持在Windows XP上运行。
Mixly软件不支持在安卓手机、安卓平板、苹果手机、苹果平板等移动设备上运行。
Mixly软件也不支持在树莓派上运行。

Mixly 支持给哪些硬件进行编程？

注解

参考支持板卡章节。

Mixly 支持使用哪些语言进行编程？

注解

Mixly本身采用图形化编程，但实际是将图形化程序转化为代码后再上传到开发板。
因此，从代码上来说，Mixly支持Arduino C语言, microPython 语言编程以及Pyhton。

Arduino AVR 编程¶

Arduino AVR编程¶

输入/输出¶

输入/输出所包含的指令主要分为四部分：控制管脚的输入输出（按信号类型可分为数字信号和模拟信号）、中断、脉冲长度及ShiftOut。

输入输出：数字输入、数字输出、模拟输入、模拟输出
中断控制：定义中断，取消中断
脉冲长度
移位输出

数字输出¶

digitalWrite(0,HIGH);//输出高电平
digitalWrite(0,LOW);//输出低电平

描述¶

给一个数字引脚写入HIGH或者LOW。

参数¶

管脚: 引脚编号（如1,5,10，A0，A3）
值: 高或低

范例¶

将13号端口设置为高电平，延迟一秒，然后设置为低电平，再延迟一秒，如此往复。

void setup(){
  pinMode(13, OUTPUT);
}
void loop(){
  digitalWrite(13,HIGH);
  delay(1000);
  digitalWrite(13,LOW);
  delay(1000);
}

注意

数字13号引脚难以作为数字输入使用，因为大部分的控制板上使用了一颗LED与一个电阻连接到他。如果启动了内部的20K上拉电阻，他的电压将在1.7V左右，而不是正常的5V，因为板载LED串联的电阻把他使他降了下来，这意味着他返回的值总是LOW。如果必须使用数字13号引脚的输入模式，需要使用外部上拉下拉电阻。

注意

模拟引脚也可以当做数字引脚使用，使用方法是管脚设置为A0，A1，A2等。

数字输入¶

digitalRead(0);

描述¶

读取指定引脚的值，HIGH或LOW。

参数¶

管脚: 引脚编号（如1,5,10,A0,A3）

返回¶

HIGH 或 LOW

范例¶

读取数字0号引脚的值，并通过串口打印出来。

void setup(){
  Serial.begin(9600);
  pinMode(0, INPUT);
}
void loop(){
  Serial.println(digitalRead(0));
}

注意

如果引脚悬空，digitalRead()会返回HIGH或LOW（随机变化）。

模拟输入¶

analogRead(A0);

描述¶

从指定的模拟引脚读取数据值。

Arduino板包含一个6通道（Mini和Nano有8个通道，Mega有16个通道），10位模拟数字转换器。这意味着它将0至5伏特之间的输入电压映射到0至1023之间的整数值。

参数¶

管脚: 引脚编号（如A0,A1,A2,A3）不同的开发板模拟输入引脚数量不一样。

返回¶

从0到1023的整数值

范例¶

读取模拟A0引脚的值，并通过串口打印出来。

void setup(){
  Serial.begin(9600);
}
void loop(){
  Serial.println(analogRead(A0));
}

注意

如果模拟输入引脚没有连入电路，由analogRead()返回的值将根据多项因素（例如其他模拟输入引脚，你的手靠近板子等）产生波动。

模拟输出¶

analogWrite(3,100);

描述¶

从一个引脚输出模拟值（PWM）。可用于让LED以不同的亮度点亮或驱动电机以不同的速度旋转。

参数¶

管脚:引脚编号（如3,5,6,9,10,11）不同的开发板模拟输入引脚数量不一样。
赋值:0（完全关闭）到255（完全打开）之间。

范例¶

控制LED实现呼吸灯效果。

void setup(){
}
void loop(){
  for (int i = 0; i <= 255; i = i + (1)) {
    analogWrite(10,i);
    delay(10);
  }
  for (int i = 255; i >= 0; i = i + (-1)) {
    analogWrite(10,i);
    delay(10);
  }
}

注意

analogWrite函数与模拟引脚、analogRead函数没有直接关系。在大多数Arduino板（ATmega168或ATmega328），只有引脚3，5，6，9，10和11可以实现该功能。在Arduino Mega上，引脚2到13可以实现该功能。

中断指令¶

void attachInterrupt_fun_2() {
}
void setup(){
  pinMode(2, INPUT);
}
void loop(){
  attachInterrupt(digitalPinToInterrupt(2),attachInterrupt_fun_2,RISING);
}

描述¶

当发生外部中断时，调用一个指定函数。当中断发生时，该函数会取代正在执行的程序。

大多数的Arduino板有两个外部中断：0（数字引脚2）和1（数字引脚3）。

Arduino Mege有四个外部中断：数字2（引脚21），3（20针），4（引脚19），5（引脚18）。

ESP8266 、ESP32系列有更多中断。

参数¶

管脚: 引脚编号（如2,3）不同的开发板中断引脚不一样。
模式：

改变：当引脚电平发生改变时，触发中断

上升：当引脚由低电平变为高电平时，触发中断

下降：当引脚由高电平变为低电平时，触发中断

范例¶

利用2号引脚中断，控制13号引脚的LED亮灭。

volatile boolean state;
void attachInterrupt_fun_2() {
  state = !state;
  digitalWrite(13,state);
}
void setup(){
  state = false;
  pinMode(2, INPUT);
  pinMode(13, OUTPUT);
  attachInterrupt(digitalPinToInterrupt(2),attachInterrupt_fun_2,RISING);
}
void loop(){
}

注意

当中断函数发生时，delay()和millis()的数值将不会继续变化。当中断发生时，串口收到的数据可能会丢失。你应该声明一个变量来在未发生中断时储存变量。

取消中断¶

detachInterrupt(digitalPinToInterrupt(2));

描述¶

关闭给定的中断。

参数¶

管脚: 引脚编号（如2,3）不同的开发板中断引脚不一样。

脉冲长度¶

pulseIn(0, HIGH);
pulseIn(0, HIGH, 1000000);

描述¶

读取一个引脚的脉冲（HIGH或LOW）。

例如，如果value是HIGH，pulseIn()会等待引脚变为HIGH，开始计时，再等待引脚变为LOW并停止计时。返回脉冲的长度，单位微秒。如果在指定的时间内无脉冲，函数返回。此函数的计时功能由经验决定，长时间的脉冲计时可能会出错。计时范围从10微秒至3分钟。（1秒=1000毫秒=1000000微秒）

参数¶

管脚:你要进行脉冲计时的引脚号（int）。
状态:要读取的脉冲类型，HIGH或LOW（int）。
超时 (可选）:指定脉冲计数的等待时间，单位为微秒，默认值是1秒（unsigned long）。

返回¶

脉冲长度（微秒），如果等待超时返回0（unsigned long）

范例¶

读取6号引脚脉冲时长。

void setup(){
  Serial.begin(9600);
  pinMode(6, INPUT);
}
void loop(){
  Serial.println(pulseIn(6, HIGH));
}

管脚模式¶

pinMode(0, INPUT);

描述¶

设置指定管脚的模式。

参数¶

管脚: 引脚编号（如2,3）不同的开发板中断引脚不一样。
模式: 要将管脚设置成的模式，包括输入、输出、上拉输入。

ShiftOut¶

shiftOut(0,0,MSBFIRST,0);//高位先入
shiftOut(0,0,LSBFIRST,0);//低位先入

描述¶

将一个数据的一个字节一位一位的移出。从最高有效位（最左边）或最低有效位（最右边）开始。依次向数据脚写入每一位，之后时钟脚被拉高或拉低，指示刚才的数据有效。

参数¶

数据管脚：输出每一位数据的引脚(int)
时钟管脚：时钟脚，当数据管脚有值时此引脚电平变化(int)
顺序：输出位的顺序，最高位优先或最低位优先
数值: 要移位输出的数据(byte)

管脚中断¶

PCintPort::attachInterrupt(0,attachPinInterrupt_fun_0,RISING);

描述¶

当发生外部中断时，调用一个指定函数。当中断发生时，该函数会取代正在执行的程序。

本模块为模拟中断，支持所有管脚使用。

参数¶

管脚: 引脚编号（如2,3）不同的开发板中断引脚不一样。
模式：

改变：当引脚电平发生改变时，触发中断

上升：当引脚由低电平变为高电平时，触发中断

下降：当引脚由高电平变为低电平时，触发中断

范例¶

利用中断，控制13号引脚的LED亮灭。

注意

当中断函数发生时，delay()和millis()的数值将不会继续变化。当中断发生时，串口收到的数据可能会丢失。你应该声明一个变量来在未发生中断时储存变量。

取消管脚中断¶

detachInterrupt(digitalPinToInterrupt(2));

描述¶

关闭给定的中断。

参数¶

管脚: 引脚编号（如2,3）不同的开发板中断引脚不一样。

多功能按键¶

OneButton button0(0,true);
void attachClick0() {
}
void setup(){
  button0.attachClick(attachClick0);
}
void loop(){
  button0.tick();
}

描述¶

设置特定管脚连接的按钮为多功能按钮，并确定不同模式下执行不同的程序。

参数¶

多功能按键: 引脚编号（如1,5,10，A0，A3）
模式: 单击双击长按开始长按中长按结束

范例¶

将2号端口连接的按钮设置为多功能按钮，单击时串口提示“one Click”

OneButton button2(2,true);
void attachClick2() {
  Serial.println("one Click");
}
void setup(){
  button2.attachClick(attachClick2);
  Serial.begin(9600);
}
void loop(){
  button2.tick();
}

控制¶

控制类别中包括了时间延迟、条件执行、循环执行、获取运行时间、初始化、Switch执行等控制模块中主要执行的内容是对程序结构进行的相应控制。

1.初始化¶

pinMode(3, OUTPUT);
  digitalWrite(3,HIGH);

1.1 描述¶

在Arduino中程序运行时将首先调用 setup()函数。用于初始化变量、设置针脚的输出输入类型、配置串口、引入类库文件等等。

1.2 范例1¶

初始化时声明变量。

volatile int item;
void setup(){
  item = 0;
}
void loop(){
}

1.3 范例2¶

在初始化时定义中断函数。

void attachInterrupt_fun_2() {
  digitalWrite(13,HIGH);
}
void setup(){
  pinMode(2, INPUT);
  pinMode(13, OUTPUT);
  attachInterrupt(digitalPinToInterrupt(2),attachInterrupt_fun_2,RISING);
}
void loop(){
}

注意

每次 Arduino 上电或重启后，setup 函数只运行一次。

2.while 循环¶

2.1 描述¶

while循环会无限的循环，直到括号内的判断语句变为假。必须要有能改变判断语句的东西，要不然while循环将永远不会结束。你可以使用一个传感器的值，或者一个变量来控制什么时候停止该循环。

2.2 参数¶

满足条件：为真或为假的一个条件。

2.3 范例¶

当温度高于30度时，亮灯，否则灭灯。

void setup(){
  pinMode(13, OUTPUT);
}
void loop(){
  while (analogRead(A0)*0.488 > 30) {
digitalWrite(13,HIGH);
  }
  digitalWrite(13,LOW);
}

3.延时¶

delay(1000);

3.1 描述¶

使程序暂定设定的时间（单位毫秒）。（一秒等于1000毫秒）。

3.2 参数¶

毫秒：暂停的毫秒数。

3.3 范例¶

13号引脚灯亮1秒，灭1秒，往复循环。

void setup(){
  pinMode(13, OUTPUT);
}
void loop(){
  digitalWrite(13,HIGH);
  delay(1000);
  digitalWrite(13,LOW);
  delay(1000);
}

注意

虽然创建一个使用delay()的闪烁LED很简单，并且许多例子将很短的delay用于消除开关抖动。

但delay()确实拥有很多显著的缺点。在delay函数使用的过程中，读取传感器值、计算、引脚操作均无法执行，因此，它所带来的后果就是使其他大多数活动暂停。大多数熟练的程序员通常避免超过10毫秒的delay(),除非arduino程序非常简单。

利用定时器，就可以解决这个问题，可以避免由于delay()带来的CPU暂停，也能很好地实现每隔一定时间执行动作。

4.如果(if)¶

if (false) {
  }

4.1 描述¶

if 语句与比较运算符一起用于检测某个条件是否达成，如某个传感器的值是否等于某个值。

4.2 参数¶

条件：比较表达式

4.3 用法¶

增加条件：如果需要增加条件，可以点开齿轮，然后将左侧的“否则如果”或者“否则”模块拖到右侧的“如果”之中。

4.4 范例1¶

当连接在2号引脚的按键按下时，点亮13号引脚的灯。

void setup(){
  pinMode(2, INPUT);
  pinMode(13, OUTPUT);
}
void loop(){
  if (digitalRead(2) == 1) {
    digitalWrite(13,HIGH);
  }
}

如果判断的条件大于等于1时，可以省略等于判断，因为只要该表达式的结果不为0，则为真。

所以，上面的写法与下面的写法等效。

void setup(){
  pinMode(2, INPUT);
  pinMode(13, OUTPUT);
}
void loop(){
  if (digitalRead(2)) {
    digitalWrite(13,HIGH);
  }
}

4.5 范例2¶

当连接在2号引脚的按键按下时，点亮13号引脚的灯;当按键松开时，灯灭。

void setup(){
  pinMode(2, INPUT);
  pinMode(13, OUTPUT);
}
void loop(){
  if (digitalRead(2)) {
    digitalWrite(13,HIGH);
} else {
  digitalWrite(13,LOW);
  }
}

注意

另外一种进行多种条件分支判断的语句是switch case语句。

5.如果(switch)¶

switch (NULL) {
  }

5.1 描述¶

和if语句相同，switch…case通过设定的在不同条件下执行的代码控制程序的流程。

特别地，switch语句将变量值和case语句中设定的值进行比较。当一个case语句中的设定值与变量值相同时，这条case语句将被执行。

关键字break可用于退出switch语句，通常每条case语句都以break结尾。如果没有break语句，switch语句将会一直执行接下来的语句（一直向下）直到遇见一个break，或者直到switch语句结尾。

5.2 参数¶

var: 用于与下面的case中的标签进行比较的变量值
label: 与变量进行比较的值

5.3 用法¶

增加case：如果需要增加条件，可以点开齿轮，然后将左侧的“case”或者“default”模块拖到右侧的“switch”之中。

5.4 范例¶

当连接在2号引脚的按键按下时，点亮13号引脚的灯，否则13号引脚的灯灭

void setup(){
  pinMode(2, INPUT);
  pinMode(13, OUTPUT);
}
void loop(){
  switch (true) {
    case digitalRead(2):
    digitalWrite(13,HIGH);
    break;
  }
}

注意

每个switch可以有多个case，但是最多不超过一个default，当不满足任何一个case时，执行default中的程序。

6.for循环¶

for (int i = 1; i <= 10; i = i + (1)) {
  }

6.1 描述¶

for循环用于重复执行一段的程序。通常使用一个增量计数器计数并终止循环。

for循环用于重复性的操作非常有效，通常与数组结合起来使用来操作数据、引脚。

6.2 参数¶

变量名：用于记录for循环次数的变量名。
起始值：循环的计数起始值，一般从0开头，也可以从其他数值开始。
终点值：循环的计数终点值。
步长：每次循环的步长，一般为1，也可以是其他整数。

6.3 用法¶

可自行设置循环的变量名称，并确定循环的开始和终止以及循环方向，最后一个数字可以为负数。

6.4 范例¶

将连接在3号引脚的灯制作成呼吸灯，每一次亮度变化之间间隔50毫秒

void setup(){
}
void loop(){
  for (int i = 0; i <= 255; i = i + (1)) {
    analogWrite(3,i);
    delay(50);
}
  for (int i = 255; i >= 0; i = i + (-1)) {
    analogWrite(3,i);
    delay(50);
  }
}

注意

for循环中定义的变量有名字，可以用字母i,j,k或单词red,state等有意义的词语表示。

7.跳出循环¶

break;

7.1 描述¶

跳出循环用于终止一段重复的程序，一般使用时作为条件语句的执行部分，当循环中的变量满足某个条件时，执行跳出循环语句。

跳出循环在处理循环中的特殊情况时十分有用。

7.2 参数¶

操作：可以选择跳出循环和跳到下一个循环两种操作，结果不同。

7.3 范例¶

引脚3上的数字从0到255逐一增加，每一次增加之间间隔50毫秒，当数字增加到150时停止增加

void setup(){
  pinMode(3, INPUT);
  }
void loop(){
  for (int i = 0; i <= 255; i = i + (1)) {
    if (digitalRead(3) == 150) {
      break;
    }
    analogWrite(3,i);
    delay(50);
  }
}

注意

注意跳到下一个循环的使用，可以方便的将循环中不需要的步骤跳过。

8.系统运行时间¶

millis();
micros();

8.1 描述¶

返回自硬件启动或重启以来的时间值。

8.2 返回¶

自硬件启动或重启以来的时间，毫秒数或者微秒数。

8.3 范例¶

自动换行打印系统运行时间

void setup(){
  Serial.begin(9600);
  pinMode(2, INPUT);
}
void loop(){
  if (digitalRead(2)) {
    Serial.println(millis());
  }
}

9.MsTimer2 定时器¶

MsTimer2::set(500, msTimer2_func);

9.1 描述¶

每隔设置的毫秒数执行相应的程序

9.2 范例¶

利用定时器控制13号引脚LED每隔1秒亮灭一次。

#include <MsTimer2.h>
volatile boolean state;
void msTimer2_func() {
  state = !state;
  digitalWrite(13,state);
}
void setup(){
  state = false;
  pinMode(13, OUTPUT);
  MsTimer2::set(1000, msTimer2_func);
  MsTimer2::start();
}
void loop(){
}

注意

利用定时器可以提高硬件的工作效率。

但在一个程序中只能使用一个MsTimer2定时器，如果要实现多个时间的定时，可以配合变量计数来完成。

10.MsTimer2 定时器启动¶

MsTimer2::start();

10.1 描述¶

MsTimer2定时器开始计时

11.MsTimer2 定时器停止¶

MsTimer2::stop();

11.1 描述¶

MsTimer2定时器停止计时

12.简单定时器¶

SimpleTimer timer;
void Simple_timer_1() {
}
void setup(){
  timer.setInterval(1000L, Simple_timer_1);
}
void loop(){
  timer.run();
}

12.1 描述¶

设置不同的简单定时器，每隔指定秒数执行相应的程序常用于多任务处理。

12.2 范例¶

D12,D13分别连接LED灯，每隔200ms，D12引脚LED灯切换亮灭；每隔300ms,D13引脚LED灯切换亮灭；

SimpleTimer timer;
void Simple_timer_1() {
digitalWrite(12,(!digitalRead(12)));
}
void Simple_timer_2() {
digitalWrite(13,(!digitalRead(13)));
}
void setup(){
  pinMode(12, OUTPUT);
  timer.setInterval(200L, Simple_timer_1);
  pinMode(13, OUTPUT);
  timer.setInterval(300L, Simple_timer_2);
}
void loop(){
  timer.run();
}

13.允许中断¶

interrupts();

13.1 描述¶

允许输入/输出模块中管脚中断的运行

13.2 范例¶

使用按钮模拟开关，每次按下，LED灯切换亮灭

void attachInterrupt_fun_2() {
  digitalWrite(10,(!digitalRead(10)));
}
void setup(){
  pinMode(2, INPUT);
  pinMode(10, OUTPUT);
  interrupts();
  attachInterrupt(digitalPinToInterrupt(2),attachInterrupt_fun_2,RISING);
}
void loop(){
}

14.禁止中断¶

noInterrupts();

14.1 描述¶

禁止输入/输出模块中管脚中断的运行

14.2 范例¶

在允许中断范例的基础上，尝试禁止中断

void attachInterrupt_fun_2() {
  digitalWrite(10,(!digitalRead(10)));
}
void setup(){
  pinMode(2, INPUT);
  pinMode(10, OUTPUT);
  noInterrupts();
  attachInterrupt(digitalPinToInterrupt(2),attachInterrupt_fun_2,RISING);
}
void loop(){
}

15.SCoop Task¶

defineTask(scoopTask1)
void scoopTask1::setup()
{
}
void scoopTask1::loop()
{
}
void setup(){
  mySCoop.start();
}
void loop(){
  yield();
  sleep(1000);
}

15.1 描述¶

SCoop模块用于执行多线程任务，最多支持8个任务。

15.2 范例¶

利用SCoop，控制13号引脚LED灯以2秒的频率闪烁，同时控制12号引脚的LED灯以200毫秒的频率闪烁。

#include "SCoop.h"
defineTask(scoopTask1)
void scoopTask1::setup()
{
  pinMode(13, OUTPUT);
}
void scoopTask1::loop()
{
  digitalWrite(13,HIGH);
  sleep(1000);
  digitalWrite(13,LOW);
  sleep(1000);
}
defineTask(scoopTask2)
void scoopTask2::setup()
{
  pinMode(12, OUTPUT);
}
void scoopTask2::loop()
{
  digitalWrite(12,HIGH);
  sleep(100);
  digitalWrite(12,LOW);
  sleep(100);
}
void setup(){
  pinMode(13, OUTPUT);
  mySCoop.start();
  pinMode(12, OUTPUT);
}
void loop(){
  yield();
}

数学¶

该部分主要完成数学变换功能，具体包括数字映射、数字约束、数学运算、取整、随机、三角函数。

$_images/math.png$

1.数字常量¶

0;

1.1 描述¶

数字常量包括整数常量和浮点常量。

注意

整数常量是直接在程序中使用的数字，如123。默认情况下，这些数字被视为int类型。通常情况下，整数常量默认为十进制，但可以加上特殊前缀表示为其他进制。如：B0111，表示二进制；0173,表示八进制；0x7B，表示十六进制。

浮点常量也可以直接中程序中使用，如12.3。默认情况下，这些数字被视为float类型。也可以使用科学计数法表示浮点数。如：2.34E5代表2.34 * 10^5，其实际值为234000；67E-12代表67.0 * 10^-12，其实际值为0.000000000067。

数学运算¶

描述¶

数学运算中包括加、减、乘、除、取模、幂运算。这些运算将会返回两个操作数的和,差,乘积,商，取模、幂。

2.2 参数¶

常量或变量

2.3 返回值¶

两个操作数的和,差,乘积,商,取模,幂。

注意

这些运算是根据操作数的数据类型来计算的,比如 9和4都是int类型,所以9/4结果是2。
如果想要两个整数相除得到小数，就需要将整数转换成小数。如9.0/2.0=4.5 。
这也就代表如果运算结果比数据类型所能容纳的范围要大的话，就会出现溢出。例如. 1加上一个整数 int类型 32,767 结果变成-32,768。
如果操作数是不同类型的,结果是“更大”的那种数据类型。如果操作数中的其中一个是 float类型或者double类型, 就变成了浮点数运算。

3.位运算¶

(0&0);

3.1 描述¶

按位操作符对变量进行位级别的计算。

3.2按位与(&)¶

按位与操作符一个&符，用在两个整型变量之间。按位与运算符对两侧的变量的每一位都进行运算。

3.2.1 描述¶

如果两个运算元都是1，则结果为1，否则输出0。

3.2.2 范例¶

在Arduino中，int类型为16位，所以在两个int表达式之间使用&会进行16个并行按位与计算。

3.3 按位或(|)¶

按位或操作符是|。

和&操作符类似,|操作符对两个变量的为一位都进行运算,只是运算规则不同。

3.3.1 描述¶

只要两个位有一个为1则结果为1，否则为0。如：0011|0101=0111

3.3.2 范例¶

在Arduino中，int类型为16位，所以在两个int表达式之间使用&会进行16个并行按位或计算。

volatile int a;
volatile int b;
volatile int c;

void setup(){
  a = 92;
  b = 101;
  c = (a|b);
}

void loop(){

}

3.4 按位异或(^)¶

按位异或是一个不常见的操作符，也叫做XOR（通常读作”eks-or“）。

按位异或操作符用 ^ 表示。

3.4.1 描述¶

按位异或是如果两个位值相同则结果为0，否则为1。如：0011^0101=0110

3.5 左移位运算(<<)¶

左移位运算可使左运算元中的某些位移动右运算元中指定的位数。

3.5.1 范例¶

volatile int a;
volatile int b;
void setup(){
  a = 5;
  b = (a<<3);
}
void loop(){
}

volatile int a;
volatile int b;
void setup(){
  a = 5;
  b = (a<<14);
}
void loop(){
}

如果你确定位移不会引起数据溢出，你可以简单的把左移运算当做对左运算元进行2的右运算元次方的操作。

3.6 右移位运算(>>)¶

右移位运算与左移位运算类似。

4.三角函数及其他¶

4.1 sin函数¶

计算角度的正弦（弧度）。其结果在-1和1之间。

4.1.1 参数¶

弧度制的角度（float）

4.1.2 返回值¶

角度的正弦值（double）

4.2 cos函数¶

计算一个角度的余弦值（用弧度表示）。返回值在 -1 和 1 之间。

4.2.1 参数¶

弧度制的角度（float）

4.2.2 返回值¶

角度的正弦值（double）

4.2.3 范例¶

绘制SIN-COS的函数图像,程序上传后，打开串口监视器,并切换到绘图模式

void setup(){
  Serial.begin(9600);
}
void loop(){
  for (int i = 0; i <= 360; i = i + (1)) {
    Serial.print((sin(i / 180.0 * 3.14159) * 256 + 512));
    Serial.print(",");
    Serial.println((cos(i / 180.0 * 3.14159) * 256 + 512));
    delay(200);
  }
}

4.3 tan函数¶

计算角度的正切（弧度）。结果在负无穷大和无穷大之间。

4.3.1 参数¶

弧度制的角度（float）

4.3.2 返回值¶

角度的正切值

4.4 asin函数¶

反正弦函数为正弦函数sin的反函数。

4.4.1 参数¶

[-1,1]

4.4.2 返回值¶

[-π/2,π/2]

4.5 acos函数¶

反余弦函数为余弦函数cos的反函数。

4.5.1 参数¶

[-1,1]

4.5.2 返回值¶

[0,π]

4.6 atan函数¶

反正切函数为正切函数tan的反函数。

4.6.1 参数¶

[-∞,∞]

4.6.2 返回值¶

(-π/2,π/2)

5.数学运算2¶

5.1 取整（四舍五入）(round)¶

返回给定值的四舍五入取整值。如round(4.1)=4;round(5.6)=6。

5.1.1 参数¶

数值或变量。

5.1.2 返回值¶

给定值的四舍五入取整值

5.2 取整（取上限）(ceil)¶

返回给定值的下一个整数，如果输入的本身就是整数，则返回自身。如ceil(4.1)=5;ceil(5.6)=6,ceil(7)=7。

5.2.1 参数¶

数值或变量。

5.2.2 返回值¶

给定值的下一个整数或自身。

5.3 取整（取下限）(floor)¶

返回给定值的前一个整数，如果输入的本身就是整数，则返回自身。如 floor(4.1)=4;floor(5.6)=5,floor(7)=7。

5.3.1 参数¶

数值或变量。

5.3.2 返回值¶

给定值的前一个整数或自身。

5.4 取绝对值(abs)¶

返回给定值的绝对值。如abs(4.1)=4;abs(-5.6)=5,abs(7)=7。

5.4.1 参数¶

数值或变量。

5.4.2 返回值¶

给定值的绝对值。

5.5 平方(sq)¶

返回给定值的平方。如 sq(4)=16;sq(-5)=25,sq(7)=49。

5.5.1 参数¶

数值或变量。

5.5.2 返回值¶

给定值的平方。

5.6 平方根(sqrt)¶

返回给定值的正平方根。如 sqrt(4)=2;sqrt(25)=5。

5.6.1 参数¶

数值或变量。

5.6.2 返回值¶

给定值的正平方根。

6.取最大(小)值(min/max)¶

描述¶

返回两个数值或变量中最大或最小值。

参数¶

数值或者变量

返回值¶

最大值或最小值

7.初始化随机数(randomseed)¶

描述¶

使用randomSeed()初始化伪随机数生成器，使生成器在随机序列中的任意点开始。

使用随机数之前，需要先使用初始化随机数模块。

8.随机数(random)¶

描述¶

使用随机数模块可以产生一个给定范围之间的随机数。

参数¶

min - 随机数的最小值，随机数将包含此值。（此参数可选）

max - 随机数的最大值，随机数不包含此值。

返回¶

min和max-1之间的随机数（数据类型为long ）

范例¶

随机数不包括最大数，如 1—7 随机数只有 1、2、3、4、5、6。

void setup(){
  Serial.begin(9600);
  randomSeed(997);
}
void loop(){
  Serial.println((random(1, 100)));
  delay(100);
}

9.约束(constrain)¶

描述¶

约束是将数值限制在最小值与最大值之间，所有小于最小值的数值被赋值为最小值，同理，所有大于最大值的数被赋值为最大值。

参数¶

x：要被约束的数字，所有的数据类型适用。

a：该范围的最小值，所有的数据类型适用。

b：该范围的最大值，所有的数据类型适用。

返回值¶

x：如果 x是介于 a 和 b之间

a：如果 x小于a

b：如果 x大于b

范例¶

A0连接电位器，将看到LED亮灭随电位器的旋转约束在0-255之间不同的亮度

void setup(){
}
void loop(){
  analogWrite(11,(constrain(((long) (analogRead(A0)) % (long) (3)) * 50, 0, 255)));
}

10.映射(map)¶

描述¶

约束是将数值限制在最小值与最大值之间，所有小于最小值的数值被赋值为最小值，同理，所有大于最大值的数被赋值为最大值。

参数¶

x：要被约束的数字，所有的数据类型适用。

a：该范围的最小值，所有的数据类型适用。

b：该范围的最大值，所有的数据类型适用。

返回值¶

x：如果 x是介于 a 和 b之间

a：如果 x小于a

b：如果 x大于b

范例¶

A0接电位器,串口输出20-180区间的数值

void setup(){
  Serial.begin(9600);
}
void loop(){
  Serial.println((map(analogRead(A0), 0, 1023, 20, 180)));
  delay(500);
}

逻辑¶

逻辑模块中的指令大多是逻辑运算处理内容，具体可分为：条件判断、逻辑运算、？运算。

比较运算符¶

0 == 0;

描述¶

注解

比较运算符适用于比较两个值的运算符号，用比较运算符比较两个值时，结果是一个逻辑值，不是TRUE就是FALSE。

等于(=)¶

等于用在变量之间、变量和自变量之间以及其他类型的信息之间的比较，判断符号两侧的数据值是否相等，要求两侧数据类型相同时才能比较。

规则是：如果两个数据值相等，数据类型相同，则结果为TRUE，否则输出FALSE。

范例¶

1=1，返回True；1=“1”，不成立

void setup(){
  Serial.begin(9600);
  if (1 == 1) {
    Serial.print("True");
  }
}
void loop(){
  0 == "1";
  1;
}

不相等(≠)¶

不等于是等于符号的相反判断。

规则：符号两边的数据值相等时，返回FALSE，否则返回TRUE。

小于(＜)¶

小于符号进行有顺序的比较，如果符号左边的数据值小于右边的数据值，则返回TRUE，否则返回FALSE。

小于等于(≤)¶

小于等于符号与小于符号类似，多出一种返回TRUE的情况，如果符号左边的数据值小于等于右边的数据值，则返回TRUE，否则返回FALSE。

大于(>)¶

大于符号进行有顺序的比较，如果符号左边的数据值大于右边的数据值，则返回TRUE，否则返回FALSE。

大于等于(≥)¶

大于等于符号与大于符号类似，多出一种返回TRUE的情况，如果符号左边的数据值大于等于右边的数据值，则返回TRUE，否则返回FALSE。

范例¶

在A0连接电位器，D9连接LED。转动电位器，大于600灯一直亮，在400和600之间，灯灭，小于400灯闪。

void setup(){
  Serial.begin(9600);
  pinMode(9, OUTPUT);
}
void loop(){
  Serial.println(analogRead(A0));
  delay(1000);
  if (analogRead(A0) >= 600) {
digitalWrite(9,HIGH);
  } else if (analogRead(A0) <= 400) {
    digitalWrite(9,HIGH);
    delay(200);
    digitalWrite(9,LOW);
    delay(200);
  } else {
    digitalWrite(9,LOW);
  }
}

逻辑运算符¶

false && false;

描述¶

注解

逻辑运算符用于判定变量或值之间的逻辑。

且¶

且的含义同逻辑运算符与，只有当符号两边的表达式均为真时，才被判断为真，否则为假。

或¶

或也是逻辑运算符的一种，只有当两边的表达式均为假时，才被判断为假，否则为真。

范例¶

光控按钮灯:A0连接光线传感器，D4连接LED，D3连接按钮,当A0<50光线暗）并按钮被被下时，LED为高电平;否则，LED为低电电平

void setup(){
  pinMode(3, INPUT);
  pinMode(4, OUTPUT);
}
void loop(){
  if (analogRead(A0) < 50 && digitalRead(3)) {
    digitalWrite(4,HIGH);
  } else {
    digitalWrite(4,LOW);
  }
}

？：语句¶

(0 > 0)?false:false;

描述¶

注解

对于条件表达式b ? x : y，先计算条件b，然后进行判断。如果b的值为true，计算x的值，运算结果为x的值；否则，计算y的值，运算结果为y的值。一个条件表达式绝不会既计算x，又计算y。条件运算符是右结合的，也就是说，从右向左分组计算。例如，a ? b : c ? d : e将按a ? b : (c ? d : e)执行。

参数¶

判断条件：先计算判断条件的值
x：当判断条件的值为true，运算结果为x的值
y：当判断条件的值为false，运算结果为y的值

范例¶

声控灯：A0连接声音传感器，D2连接LED，当A0>50时，LED为高电平；否则，LED为低电平

void setup(){
  Serial.begin(9600);
  pinMode(2, OUTPUT);
}
void loop(){
  Serial.println(analogRead(A0));
  digitalWrite(2,(analogRead(A0) > 50)?HIGH:LOW);
}

文本¶

文本的具体内容为代码的文本输出功能，具体包括：文本连接、文本转数字、数字转文本。

所有文本内容可通过串口监视器或外接显示屏打印。

字符串¶

"hello";

描述¶

字符串常量。

参数¶

字符串: 需要输入的字符串内容。

字符¶

'a';

描述¶

字符常量。

参数¶

字符: 需要输入的字符。

范例¶

只执行一次串口输出积木块。

    void setup(){
      Serial.begin(9600);
    }
    void loop(){
      Serial.println(analogRead(A0));
    }

注意

只能输入一个字符，输入超过一个字符时会自动选择第一个字符进行输入，空格也可以作为字符输入。

字符串连接¶

String("Hello") + String("Mixly");

描述¶

字符串连接，可以将两个或者多个字符串连接成一个。

范例¶

连接多个字符串。

void loop(){
  String("Hello") + String(String("Hello") + String("Mixly"));
}

字符串转数字(toInt()/toFloat())¶

String("123").toInt();

描述¶

将字符串中的数字转成整数或者小数。

获取字符串中的一部分¶

String("substring").substring(0,3);

描述¶

获取字符串第x到y的字符串。

范例¶

截取字符串中的一部分。

void setup(){
  Serial.begin(9600);
}
void loop(){
  Serial.println(String("I Love Mixly").substring(7,12));
  while(true);
}

小数位数保留¶

    String(6.666, 2);

描述¶

将小数按照指定位数进行化简。

参数¶

小数:需要化简的小数。
位数:需要保留的位数。

转化大小写¶

    String.toUpperCase();

描述¶

将指定的字符串变量的小写字母全部转化为大写字母或将大写字母全部转化为小写字母.

参数¶

第一个字符串:需要转化的字符串变量。
转化方向：确定是将小写字母转化为大写字母还是将大写字母转化为小写字母。

范例¶

将字符串变量里的小写字母全部转化为大写字母。

String wenzi;
void setup(){
  Serial.begin(9600);
  wenzi = " ";
}
void loop(){
  wenzi = " I like Mixly! ";
  Serial.println(wenzi);
  wenzi.toUpperCase();
  while(true);
}

字符串变量替换¶

    String.replace("s", "Q");

描述¶

将指定的字符或字符串替换为指定的字符或字符串.

参数¶

第一个字符串:原有的字符串。
第二个字符串:需要进行替换的字符或字符串。
第三个字符串:用来进行替换的字符或字符串。

范例¶

将字符串变量a中的“l”全部替换为“a”。

String a;
void setup(){
  a = "hello";
  Serial.begin(9600);
}
void loop(){
  a.replace("l", "a");
  Serial.println(a);
  while(true);
}

消除非可视字符¶

    String.trim();

描述¶

截取字符串中间的非空白字符.

参数¶

字符串变量

范例¶

消除非可视字符将删除字符串首尾的非可视字符。

String wenzi;
void setup(){
  Serial.begin(9600);
  wenzi = " ";
}
void loop(){
  wenzi = " I like Mixly! ";
  Serial.println(wenzi);
  wenzi.trim();
  Serial.println(wenzi);
  while(true);
}

判断字符串的开头或结尾¶

    String("substring").startWith("substring");

描述¶

判断第一个字符串是否以第二个字符串为开头或结尾，若是则返回1，否则返回0.

参数¶

第一个字符串:需要进行判断的字符串。
第二个字符串:用来进行判断的字符串。

范例¶

substring以sub开头而不以ub开头。

void setup(){
  Serial.begin(9600);
}
void loop(){
  Serial.println(String("substring").startsWith("sub"));
  Serial.println(String("substring").startsWith("ub"));
  while(true);
}

转ASCII字符(char())¶

char(223);

描述¶

将数字转成ASCII字符。

参数¶

数字: ASCII字符对应的数字。

返回¶

数字所对应的ASCII字符。

范例¶

用转ASCII字符积木块加空格。

    void setup(){
      Serial.begin(9600);
    }
    void loop(){
      Serial.println(analogRead(A0));
    }

转ASCII数值(toascii)¶

toascii('a');

描述¶

将字符转成ASCII码。

参数¶

ASCII字符: ASCII码对应的字符。

返回¶

ASCII码

进制转字符串¶

String(0, BIN);

描述¶

将一个数字转化为字符串，支持二进制、八进制、十进制、十六进制数字。

参数¶

数字: 对应进制的数字。

返回¶

字符串类型的数字。

注意

在某些需要将不同进制的整数类型转换为字符串类型的情况下进行使用。

获取字符串长度(String().length())¶

String("hello").length();

描述¶

通过String().length()方法获得字符串的长度，值为组成字符串的字母数。

参数¶

字符串: 需要获取长度的字符串。

返回¶

字符串的字符个数，一个中文算三个字符。

获取字符串第N个字符¶

String("hello").charAt(0);

描述¶

获取到字符串的第N个字符。

参数¶

N: 获取的字符排位

字符串比较1¶

String("").equals(String(""));

描述¶

比较两个字符串是否相同；第一个字符串从左往右是否包含第二个字符串；第一个字符串从右往左是否包含第二个字符串。

参数¶

第一个字符串
第二个字符串

字符串比较2¶

String("").compareTo(String(""));

描述¶

运用compareTo方法对两个字符串进行比较，从第一位开始比较，如果遇到不同的字符，则马上返回这两个字符的ASCII值的差值，返回值是int类型。

参数¶

第一个字符串
第二个字符串

数组¶

数组是为了便于代码编写时所采用的一种数字块。具体包括：定义数组、取数组值、改数组值。

数组像一个大盒子，可以储存一定个数的数字（第一个指令）或字符串（第二个指令）。在课程中的音乐盒一课，我们就用到了数组。

如上图，tonelist, musiclist, highlist, rhythmlist分别储存了歌曲《两只老虎》的基本频率（即哆来咪等七音的对应频率），频率变化（即两只老虎的简谱数字），每个音的音名CDEFGAB以及每个音的时值（长短）。《两只老虎》共有三十二个音，因此使用了一个从1到32的循环语句以此读取第一个音的频率变化（简谱，并通过.. image:: images/06Lists/array3.png语句可读取简谱的基本频率），随后与获取highlist里的对应音高并按thythmlist里的时值进行相应延时。该代码将《两只老虎》的指令放到了一个名为playmusic的函数内，并通过执行 playmusic调用该函数。关于函数的内容，我们将在下面函数部分具体详解。

创建mylist数组1¶

int mylist[]={0, 0, 0};

描述¶

初始化一个数组。

参数¶

数组类型: 选择创建的数组类型，包括整数、长整数、小数、字符、字节、char、字符串。
数组名称：为创建的数组输入一个名字。

范例¶

创建一个CHINA字符串数组。

char CHINA[]={'C', 'H', 'I', 'N', 'A'};
void setup(){
}
void loop(){
}

创建mylist数组2¶

int mylist[3]={0,0,0};

描述¶

初始化一个数组。

参数¶

数组类型: 选择创建的数组类型，包括整数、长整数、小数、字符、字节、char、字符串。
数组名称：为创建的数组输入一个名字。
数组长度：指定数组的长度。

获取数组mylist长度¶

sizeof(mylist)/sizeof(mylist[0]);

描述¶

获取数组的长度。

参数¶

数组名称: 需要获取长度的数组名称。

范例¶

获取CHINA数组的长度。

int CHINA[]={'C', 'H', 'I', 'N', 'A'};
void setup(){
  Serial.begin(9600);
}
void loop(){
  Serial.println(sizeof(CHINA)/sizeof(CHINA[0]));
  while(true);
}

获取数组mylist第N项¶

mylist[(int)(N - 1)];

描述¶

获取指定数组的第N项。

参数¶

数组名称: 需要获取内容的数组名称。
变量N: 需要获取数组的第N项。

范例¶

串口输出字符型数组元素。

char CHINA[]={'C', 'H', 'I', 'N', 'A'};
void setup(){
   Serial.begin(9600);
}
void loop(){
  for (int i = (1); i <= (sizeof(CHINA)/sizeof(CHINA[0])); i = i + (1)) {
    Serial.print(CHINA[(int)(i - 1)]);
  }
  while(true);
}

数组mylist第N项赋值¶

mylist[(int)(N - 1)] = 0;

描述¶

为指定数组的第N项赋予特定的值。

参数¶

数组名称: 需要获取内容的数组名称。
变量N: 需要赋值数组的第N项。
赋值内容: 需要替换的内容。

范例¶

串口输出字符型数组元素。

char CHINA[]={'C', 'H', 'I', 'N', 'A'};
volatile int N;
void setup(){
  N = 2;
  Serial.begin(9600);
}
void loop(){
  CHINA[(int)(N - 1)] = 'C';
  Serial.print(CHINA[(int)(N - 1)]);
  while(true);
}

创建二维数组array¶

int array[2][2]={{0,0},{0,0}};

描述¶

初始化一个二维数组。

参数¶

数组类型: 选择创建的数组类型，包括整数、长整数、小数、字符、字节、char、字符串。
数组名称：为创建的数组输入一个名字。
数组行数
数组列数
字符串：创建二维数组的来源。

给二维数组第M行N列赋值¶

array[M-1][N-1]=0;

描述¶

为数组第M行第N列赋值。

参数¶

数组名称：为创建的数组输入一个名字。
数组行数
数组列数
赋值：要赋予的值。

获取数组array第M行第N列¶

array[M-1][N-1];

描述¶

获取数组array第M行第N列的内容。

参数¶

数组名称：为创建的数组输入一个名字。
数组行数
数组列数

范例¶

串口输出二维数组元素。

int array[3][3]={{1,2,3},{4,5,6},{7,8,9}};
void setup(){
  Serial.begin(9600);
}
void loop(){
  for (int i = 1; i <= 3; i = i + (1)) {
    for (int j = 1; j <= 3; j = j + (1)) {
      Serial.print(String(array[i-1][j-1]) + String(","));
      if ((long) (j) % (long) (3) == 0) {
        Serial.println("");
      }
    }
  }
  while(true);
}

变量¶

依据变量类型可分为：浮点变量、整型变量、布尔变量、字符串变量。根据变量的值又可分为高或低、真或假。

在运算中，变量是一个使用非常频繁的指令。比如在2.1.7.2使用红外接收管和遥控器的相关代码中，ir_item就是一个变量。在使用变量时，如果用户在程序建构区内已新建了一个变量（例如使用循环语句i变量），变量模块将自动生成了一个相对应的系统变量i，用户直接使用即可。

函数¶

在函数部分，主要分为定义函数和执行函数，需注意，当用户自定义一个函数时，执行函数的代码是系统生成的。

比如让LED点亮这个代码，当我把它放到函数blink中后，系统会自动生成执行 blink代码。

另外需要注意，如果使用函数指令，必须运行执行 blink才可以。如果只自定义函数blink而不执行，LED是不会有任何反应的。

串口¶

传感器¶

传感模块：超声波、DHT11、DS18B20（新增）

在传感器部分，我们将一些最常见的传感器相关指令进行编库，比如超声波测距模块，学生在使用超声波进行测距时，可直接运用该模块，只需将Trig与Echo管脚填好即可，这大大节省了学生的编程时间，这将更有助于使学生将更多的精力集中在创意实践上而非抓耳挠腮地编程。

执行器¶

执行模块：声音播放、舵机控制、I2C液晶模块

显示器¶

通信¶

通信是为了方便人与计算机交互而采用的一种特殊通信方式。具体包括：串口通信(新增串口选择和波特率设置)、红外通信、I2C通信、SPI通信（新增）。

串口通信¶

串口通信功能学生可在串口监视器中查看。这一功能对于学生检查自己代码以及监视传感器数据提供了便利条件。假设学生将LM35的温度传感器接到模拟管脚A0口，学生可通过 .. image:: images/13Communicate/commu4.png 指令观察当前室温。随后可能会提出疑问：当前室温怎么可能是58？这将引发学生进一步的思考造成该数据的可能性。

红外通信¶

上图指令主要运用的是红外接收管与遥控器之间的数据发射与接收功能。学生掌握了红外通信的相关内容，便可以制作遥控风扇、遥控汽车等自主设计更强的创意电子产品。

I2C通信¶

I2C（Inter－Integrated Circuit）是同步通信的一种特殊形式，具有接口线少，控制方式简单，器件封装形式小，通信速率较高等优点。Mixly支持I2C的读取和写入，并且支持基于I2C协议的执行器。

SPI通信¶

SPI是串行外设接口（Serial Peripheral Interface）的缩写。SPI，是一种高速的，全双工，同步的通信总线，并且在芯片的管脚上只占用四根线，节约了芯片的管脚，同时为PCB的布局上节省空间，提供方便，拥有简单易用的特性。用户可以使用Mixly向SPI传输数据。

存储¶

存储模块：EEPROM读写，SD卡写入

网络¶

Factory¶

Factory中的模块可以方便用户编写Mixly中不支持的传感器功能。 .. image:: images/16Factory/factory.png

将以RTC1307库为例，介绍利用factory中的模块，在Mixly快速使用Arduino标准库。

准备工作¶

1.从github.com等网站下载ds1307RTC Arduino库。 2.将库文件解压到Mixly/arduino-1.x.x/portable/sketchbook/libraries目录中。 3.打开Mixly自带的arduino IDE（路径Mixlyarduino-1.x.xarduino.exe），在软件中打开库目录下的example范例，编译并上传，测试能否正常使用。如果不能正常使用，则需要更换库或者检查硬件问题。

重写程序¶

打开范例程序Mixly/arduino-1.x.x/portable/sketchbook/libraries/DS1307RTC/examples/ReadTime/ReadTest/ReadTest.ino，先分析程序，并适当简化程序。

源程序如下：

    #include <Wire.h>
    #include "TimeLib.h"
    #include "DS1307RTC.h"

    void setup() {
      Serial.begin(9600);
      while (!Serial) ; // wait for serial
      delay(200);
      Serial.println("DS1307RTC Read Test");
      Serial.println("-------------------");
    }

    void loop() {
      tmElements_t tm;

      if (RTC.read(tm)) {
        Serial.print("Ok, Time = ");
        print2digits(tm.Hour);
        Serial.write(':');
        print2digits(tm.Minute);
        Serial.write(':');
        print2digits(tm.Second);
        Serial.print(", Date (D/M/Y) = ");
        Serial.print(tm.Day);
        Serial.write('/');
        Serial.print(tm.Month);
        Serial.write('/');
        Serial.print(tmYearToCalendar(tm.Year));
        Serial.println();
      } else {
        if (RTC.chipPresent()) {
          Serial.println("The DS1307 is stopped.  Please run the SetTime");
          Serial.println("example to initialize the time and begin running.");
          Serial.println();
        } else {
          Serial.println("DS1307 read error!  Please check the circuitry.");
          Serial.println();
        }
        delay(9000);
      }
      delay(1000);
    }

    void print2digits(int number) {
      if (number >= 0 && number < 10) {
        Serial.write('0');
      }
      Serial.print(number);
    }

简化程序如下：

    #include <Wire.h>
    #include "TimeLib.h"
    #include "DS1307RTC.h"

    void setup() {
      Serial.begin(9600);
    }

    void loop() {
      tmElements_t tm;
      if (RTC.read(tm)) {
        Serial.print(tm.Hour);
        Serial.print(':');
        Serial.print(tm.Minute);
        Serial.print(':');
        Serial.print(tm.Second);
        Serial.print(tm.Day);
        Serial.print('/');
        Serial.print(tm.Month);
        Serial.print('/');
        Serial.print(tmYearToCalendar(tm.Year));
      }
      delay(1000);
    }

Factory模式下模块：

编写完成后，编译并上传，进行测试。测试利用factroy编写的程序效果是否与arduino IDE编写相同。

工具¶

Arduino ESP8266编程¶

Arduino ESP32编程¶

掌控板¶

MixGo¶

MicroPython 编程¶

输入/输出¶

输入/输出所包含的指令主要分为四部分：初始化管脚、控制管脚的输入输出、获取输入值、中断管脚。

管脚的输入输出按信号类型可分为数字信号和模拟信号，在MicroPython中，模拟输出有PWM（脉冲宽度调制）和DAC（数模转换器）两种输出方式。

获取输入值可获取数字输入、模拟输入和触摸传感器的值。

初始化：数字输出
输入输出：数字输入、数字输出、模拟输入、PWM模拟输出、DAC模拟输出
中断控制：定义中断
【待完善】

控制¶

数学¶

该部分主要完成数学运算相关的功能，具体包括数字、常数、三角函数、各种数学、位和逻辑计算、取整、取最大值、随机数、进制转换、约束和映射模块。

1.数字常量¶

1.1描述¶

数字常量包括：整数常量和浮点常量。

注意

整数常量是直接在程序中使用的数字，如123。默认情况下，这些数字被视为int类型。通常情况下，整数常量默认为十进制，但可以加上特殊前缀表示为其他进制。如：0b111，表示二进制；0o73,表示八进制；0x7B，表示十六进制。

浮点常量也可以直接中程序中使用，如12.3。默认情况下，这些数字被视为float类型。也可以使用科学计数法表示浮点数。如：2.34E5代表2.34 * 10^5，其实际值为234000；67E-12代表67.0 * 10^-12，其实际值为0.000000000067。

2.常数¶

2.1 描述¶

常数模块里包括：圆周率常数π和自然常数e

注意

常数也可以直接在程序中使用。默认情况下，它们被视为int类型，而且默认为十进制。

3.三角函数及其他¶

3.1 sin¶

3.1.1 描述¶

计算角度的正弦（单位为°）。其结果在-1和1之间。

3.1.2 参数¶

角度（float）

3.1.3 返回值¶

角度的正弦值（double）

3.2 cos¶

3.2.1 描述¶

计算一个角度的余弦值（单位为°）。返回值在 -1 和 1 之间。

3.2.2 参数¶

角度（float）

3.2.3 返回值¶

角度的余弦值（double）

3.3 tan¶

3.3.1 描述¶

计算角度的正切（单位为°）。结果在负无穷大和无穷大之间。

3.3.2 参数¶

角度（float）

3.3.3 返回值¶

角度的正切值（double)

3.4 asin¶

3.4.1 描述¶

反正弦函数为正弦函数sin的反函数。

3.4.1 参数范围¶

[-1,1]

3.4.2 返回值范围¶

[-π/2,π/2]

3.5 acos¶

3.5.1 描述¶

反余弦函数为余弦函数cos的反函数。

3.5.2 参数范围¶

[-1,1]

3.5.3 返回值范围¶

[0,π]

3.6 atan¶

3.6.1 描述¶

反正切函数为正切函数tan的反函数。

3.6.2 参数范围¶

[-∞,∞]

3.6.3 返回值范围¶

(-π/2,π/2)

4.相反数¶

4.1 描述¶

计算一个参数的相反数。

4.2 参数范围¶

[-∞,∞]

4.3 返回值范围¶

-([-∞,∞])

5.对数函数与幂函数¶

5.1 ln¶

5.1.1 描述¶

计算一个参数的自然对数值，自然对数是以自然常数e为底数的对数。

5.1.2 参数范围¶

(0,∞]

5.1.3 返回值范围¶

[-∞,∞]

5.2 log10¶

5.2.1 描述¶

计算一个参数的常用对数值，常用对数是以10为底数的对数。

5.2.2 参数范围¶

(0,∞]

5.2.3 返回值范围¶

[-∞,∞]

5.3 e^¶

5.3.1 描述¶

计算以参数为指数，e为底数的幂运算值，e为自然常数。

5.3.2 参数范围¶

[-∞,∞]

5.3.3 返回值范围¶

(0,∞]

5.4 10^¶

5.4.1 描述¶

计算以参数为指数，10为底数的幂运算值。

5.4.2 参数范围¶

[-∞,∞]

5.4.3 返回值范围¶

(0,∞]

6.算术运算¶

6.1 描述¶

算术运算中包括加(+)、减(-)、乘(×)、除(÷)、取模(%)、取整除(//)和幂运算(**)。这些运算将会返回两个操作数的和，差，积，商，模、商的整数部分和幂值。

注意

这些运算是根据操作数的数据类型来计算的,比如 9和4都是int类型,所以9/4结果是2。
如果想要两个整数相除得到小数，就需要将整数转换成小数。如9.0/2.0=4.5 。
这也就代表如果运算结果比数据类型所能容纳的范围要大的话，就会出现溢出。例如： 1加上一个整数 int类型 32,767 结果变成-32,768。
如果操作数是不同类型的,结果是“更大”的那种数据类型。如果操作数中的其中一个是 float类型或者double类型, 就变成了浮点数运算。
取整除运算将会返回商的整数部分，向下取整。

6.2 参数¶

常量或变量

6.3 返回值¶

两个操作数的和，差，积，商，模、商的整数部分和幂值。

7.位运算¶

注解

按位运算符是把数字看作二进制来进行计算。

7.1 按位与(&)¶

7.1.1 描述¶

按位与操作符为一个&符，用在两个整型变量之间。按位与运算符对两侧的变量的每一位都进行运算。

规则是：如果两个运算元都是1，则结果为1，否则输出0。

提示

如： 0011&0101=0001

7.1.2 范例¶

    a = 0b0011
    b = 0b0101
    c = (a&b)

7.2 按位或(|)¶

7.2.1 描述¶

按位或操作符是|。

和&操作符类似,|操作符对两个变量的为一位都进行运算,只是运算规则不同。

按位或规则：只要两个位有一个为1则结果为1，否则为0。

提示

如：0011|0101=0111

7.2.2 范例¶

    a = 0b0011
    b = 0b0101
    c = (a|b)

7.3 右移位运算(>>)¶

7.3.1 描述¶

把”>>”左边的运算数的各二进制位全部右移若干位，>> 右边的数字指定了移动的位数。

提示

如：00111100>>2输出结果15，二进制解释：00001111

7.3.2 范例¶

    a = 0b00111100
    b = (a>>2)

7.4 左移位运算(<<)¶

7.4.1 描述¶

运算数的各二进位全部左移若干位，由 << 右边的数字指定了移动的位数，高位丢弃，低位补0。

提示

如：00111100<<2输出结果240，二进制解释：11110000

7.4.2 范例¶

    a = 0b00111100
    b = (a<<2)

8.赋值运算¶

8.1 描述¶

赋值运算中包括赋值加(+=)、赋值减(-=)、赋值乘(×=)、赋值除(÷=)、赋值取模(%=)、赋值取整除(//=)和赋值幂运算(**=)。

赋值运算符的左边为变量，右边为操作数。赋值运算符将左边的变量本身和右边的操作数分别作为算术运算的操作数，返回两个操作数的和，差，积，商，模、商的整数部分和幂值，并将返回值赋值给左边的变量。

注意

这些运算是根据操作数的数据类型来计算的,比如 9和4都是int类型,所以9/4结果是2。
如果想要两个整数相除得到小数，就需要将整数转换成小数。如9.0/2.0=4.5 。
这也就代表如果运算结果比数据类型所能容纳的范围要大的话，就会出现溢出。例如： 1加上一个整数 int类型 32,767 结果变成-32,768。
如果操作数是不同类型的,结果是“更大”的那种数据类型。如果操作数中的其中一个是 float类型或者double类型, 就变成了浮点数运算。
取整除运算将会返回商的整数部分，向下取整。

8.2 参数¶

赋值运算符左边的参数为变量，右边的参数可以为常亮或者变量。

9.近似运算¶

9.1 取整（四舍五入）(round)¶

9.1.1 描述¶

返回给定值的四舍五入取整值。

9.1.2 参数¶

数值或变量。

9.1.3 返回值¶

参数的四舍五入取整值

提示

如：round(4.1)=4;round(5.6)=6。

9.2 取整（取上限）(ceil)¶

9.2.1 描述¶

返回给定值的下一个整数，如果输入的本身就是整数，则返回自身。

9.2.3 参数¶

数值或变量。

9.2.4 返回值¶

参数的下一个整数或自身。

提示

如：ceil(4.1)=5;ceil(5.6)=6,ceil(7)=7。

9.3 取整（取下限）(floor)¶

9.3.1 描述¶

返回给定值的前一个整数，如果输入的本身就是整数，则返回自身。

9.3.2 参数¶

数值或变量。

9.3.3 返回值¶

参数的前一个整数或自身。

提示

如：floor(4.1)=4;floor(5.6)=5,floor(7)=7。

10.取绝对值(fabs)¶

10.1 描述¶

返回给定值的绝对值。

10.2 参数¶

数值或变量。

10.3 返回值¶

参数的绝对值。

提示

如：fabs(0)=0;fabs(-5)=5,fabs(7)=7。

11.平方根(sqrt)¶

11.1 描述¶

返回给定值的正平方根。

11.2 参数¶

数值或变量。

11.3 返回值¶

给定值的正平方根。

提示

如 sqrt(4)=2;sqrt(25)=5。

12.取最大/小值(min/max)¶

12.1 描述¶

返回两个数值或变量中最大或最小值。

12.2 参数¶

数值或者变量

12.3 返回值¶

最大值或最小值

13.初始化随机数(randint)¶

13.1 描述¶

在给定的范围中返回随机的整数或小数。

注意

返回的随机数在前一个参数和后一个参数之间，包含两个参数。

14.进制转换¶

14.1 描述¶

将指定进制的参数转换为另一指定进制。

14.2 参数¶

变量或常量

14.3 返回¶

变量或常量其他进制的值

15.约束(constrain)¶

15.1 描述¶

约束是将数值限制在最小值与最大值之间，所有小于最小值的数值被赋值为最小值，同理，所有大于最大值的数被赋值为最大值。

15.2 参数¶

参数一：要被约束的数字，所有的数据类型适用。

参数二：该范围的最小值，所有的数据类型适用。

参数三：该范围的最大值，所有的数据类型适用。

15.3 返回值¶

如果参数一介于参数二和参数三之间，返回参数一；

如果参数一大于参数三，返回参数三；

如果参数一小于参数二，返回参数二；

16.映射(map)¶

提示

映射指两个元素的集之间元素相互“对应”的关系。

就像把一张地图幻灯片（尺寸255）投影到大屏幕上（尺寸1023）一样，虽然两者尺寸大小不同，但不改变地图内部的比例和相对位置。

两者之间数据形成一一对应的关系。

16.1 描述¶

映射运算将参数值在前一个元素集中的位置按照两个元素集的映射方式，得出在后一个元素集中对应位置的值。

16.2 参数¶

参数一：需要求映射的值；

参数二和参数三：映射的起始元素集范围；

参数四和参数五：映射的终点元素范围。

16.3 返回值¶

返回参数一从起始元素集映射到终点元素集的值。

    def mixly_mapping(v, al, ah, bl, bh):
            return bl +  (bh - bl) * (v - al) / (ah - al)  //Mixly中的映射函数

    mixly_mapping(50, 0, 100, 0, 1000)    //调用映射函数，返回值为500.0

提示

参考上述代码举例，可以了解到：起始集合为[0,100]，终点集合为[0,1000]，两个集合的右边界减去左边界，再用终点集合的边界差除以起始集合的边界差，得到10，即起始集合到终点集合的映射为放大10倍。

参数一50在起始集合中的位置位于左边界加50，则在终点集合中的位置应当位于左边界加500，而经过乘除运算后数据类型变为float，所以上述举例中的返回值为500.0。

请再结合以下举例理解映射运算。

    mixly_mapping(65, 50, 100, 50, 1000)    //调用映射函数，返回值为335.0

    mixly_mapping(35, 50, 100, 50, 1000)    //调用映射函数，返回值为-235.0

    mixly_mapping(50, 0, 1000, 0, 100)    //调用映射函数，返回值为5.0

    mixly_mapping(60, 50, 80, 56, 74)    //调用映射函数，返回值为62.0

逻辑¶

注解

逻辑模块中的指令大多是逻辑运算处理内容，具体可分为：比较运算、范围判断、逻辑运算、代表非、真、假、空的块、？运算、列表存在判断和列表相等判断。

1.比较运算符¶

注解

在Python中，比较运算符是用于比较两个对象的运算符号，结果是一个Boolean逻辑值，为True或者False。

1.1 等于(=)¶

1.1.1 描述¶

等于符号用两个对象之间的比较，判断符号两侧的对象的数据值和数据类型是否相等。

1.1.2 规则¶

如果两个数据值相等，且数据类型相同，则结果为True，否则结果为False。

注意

Python中的对象有三个属性：

1.id:身份标识，是对象在内存中的地址，python中用函数id(x)返回对象 x 在内存中的地址

2.type:数据类型，python中用函数type(x)返回对象 x 的数据类型

3.value:值
Python中，比较运算符除”==”外还有”is”，他们的区别是：

“==” 是对两个对象的 value 和 type 进行比较，比较两个对象的值和数据类型是否相等

“is” 是对两个对象的 id 进行比较，比较两个对象的内存地址是否相等
Mixly中比较运算符模块中的”=”，使用的是Python中的”==”，可以从代码中查看：

1.1.3 示例¶

返回结果：
True
False
False

1.2 不等于(≠)¶

1.2.1 描述¶

不等于符号使用方法与等于符号相同，返回与等于符号相反的结果。

1.2.2 规则¶

符号两边的对象值和数据类型相等时，结果False，否则结果为True。

1.2.3 示例¶

返回结果：
False
True
True

1.3 小于(＜)¶

1.3.1 描述¶

小于符号进行大小比较。

1.3.2 规则¶

如果符号左边的数值小于右边的数值，则返回True，否则返回False。

注意

在MicroPython中，只有number类型的值（int, float, complex, boolean）可以进行大小比较。

1.3.3 示例¶

返回结果：

False
True
False
True
False

注意

在实际的比较中，布尔值True等价于int值1，布尔值False等价于int值0。

1.4 小于等于(≤)¶

1.4.1 描述¶

小于等于符号与小于符号类似。

1.4.2 规则¶

如果符号左边的数值小于等于右边的数值，则返回True，否则返回False。

1.5 大于(>)¶

1.5.1 描述¶

大于符号进行大小比较。

1.5.2 规则¶

如果符号左边的数值大于右边的数值，则返回True，否则返回False。

1.6 大于等于(≥)¶

1.6.1 描述¶

大于等于符号与大于符号类似。

1.6.2 规则¶

如果符号左边的数值大于等于右边的数值，则返回True，否则返回False。

2.范围判断¶

2.1 描述¶

如果中间项同时满足左右两个不等式，则返回True，否则返回False。

2.2 示例¶

返回结果：
True
False
False
True

3.逻辑运算符¶

3.1 且¶

3.1.1 描述¶

且（and）运算符两边为对象或者逻辑表达式，只有当符号两边的表达式结果均为真时，结果才为真，否则为假。

3.1.2 示例¶

返回结果：
True
False

3.2 或¶

3.2.1 描述¶

或（or）运算符两边为对象或者逻辑表达式，只有当符号两边的表达式结果均为假时，结果才为为假，否则为真。

3.2.2 示例¶

返回结果：
True
False

4.否定运算符¶

4.1 描述¶

否定运算符（非）(not)用于对象或表达式前面，结果与原对象或表达式逻辑值相反。即原逻辑值为True，则结果为False；若原逻辑值为False，则结果为True。

4.2 示例¶

返回结果：
True
True
False

5.逻辑值¶

5.1 描述¶

MicroPython中的逻辑值包含真(True)，假(False)。逻辑值可以直接参与逻辑运算，得出的运算结果也是逻辑值。

5.2 示例¶

返回结果：
False
True
False

6.空值(None)¶

6.1 描述¶

None是一个特殊的常量。

None和False不同。

None不是0。

None不是空字符串。

None和任何其他的数据类型比较永远返回False。

6.2 示例¶

返回结果：

True
False
False
False
False
False

7. ？：模块¶

7.1 描述¶

对于条件表达式模块 a ? x : y，先计算条件 a 的逻辑结果，然后进行判断。如果 a 的值为True，则计算表达式 x 的值，模块的值即为 x 的值；否则，计算表达式 y 的值，模块的值即为 y 的值。

7.2 参数¶

a: 判断条件，先计算判断条件的值

x: 当判断条件的值为True，模块的值即为x的值

y: 当判断条件的值为False，模块的值即为y的值

提示

一个条件表达式不会既计算 x ，又计算 y 。
条件运算符是右结合的，也就是说，从右向左分组计算。例如，a ? b : c ? d : e 将按 a ? b : (c ? d : e) 执行。

实际上，MicroPython中没有 ? : 语句，这实际上是通过 if 条件语句实现的。

7.3 示例¶

这一段代码可以在 a 和 b 中选择出较大数字。

返回结果：
5

8.元素存在判断¶

8.1 参数¶

元素：可以是各种常量和变量对象，包括数列。

数列：需要被判断是否存在某元素的数列；是多维数列时要求前一参数是对应维度的数列。

此模块的值为逻辑值，当参数元素存在于数列中时，此模块值为True；当参数元素不存在于数列中时，此模块值为False。

8.2 示例¶

返回结果：
True
False

9.数列相等判断¶

9.1 描述¶

此模块的两个参数均为数列对象，模块的值为逻辑值，当前后两数列相等时，此模块值为True；当前后两数列不相等时，此模块值为False。

注意

此模块使用的是”is”进行相等判断。还记得之前讲过的Python对象的三个属性和”==”与”is”判断的区别吗？
Python中的对象有三个属性：

1.id:身份标识，是对象在内存中的地址，python中用函数id(x)返回对象 x 在内存中的地址

2.type:数据类型，python中用函数type(x)返回对象 x 的数据类型

3.value:值
Python中，比较运算符除”==”外还有”is”，他们的区别是：

“==” 是对两个对象的 value 和 type 进行比较，比较两个对象的值和数据类型是否相等

“is” 是对两个对象的 id 进行比较，比较两个对象的内存地址是否相等
所以此模块判断的也是判断前后两个数列的内存地址是否相等，请结合一下示例进一步了解。

9.2 示例¶

返回结果：
False
True

文本¶

注解

文本分类下的模块主要包含文本输出、文本处理和字符串内容检索等功能。具体包括：文本连接、文本转换、获取长度、格式化字符串等。

所有文本内容都可通过串口打印或外接显示屏输出。

1.字符串¶

1.1 描述¶

Mixly中包含单行文本和多行文本。单行文本内容可以是一个字符、单词也可以是一行文本。多行文本内容会保留输入的换行。

1.2 示例¶

Python中的单行文本由双引号或者单引号包围，多行文本由连续使用的三个单引号包围。
1
2
3
"Mixly"
'''Hello
Mixly'''

2.字符串连接¶

2.1 描述¶

字符串连接模块可以连接单行文本和多行文本，也可以嵌套使用。此模块在连接的文本之间不会添加任何分隔符号。

2.2 示例¶

你也可以在单行文本或者多行文本中使用转义字符 “\n” 来进行换行。

源代码：

print("Hello" + "Mixly\n")
print("Hello\n" + "Mixly\n")
print("Hello" + "Mixly" + "Love" + "Mixly\n")
print("Hello" + '''Mixly
1.0\n''')
print('''Hello
World''' + "Mixly\n")
print('''Hello
World\n''' + "Mixly\n")

输出结果：

HelloMixly

Hello
Mixly

HelloMixlyLoveMixly

HelloMixly
1.0

Hello
WorldMixly

Hello
World
Mixly

3.字符串转换¶

3.1 字符串转换为其他类型¶

3.1.1 描述¶

此模块可以将字符串转换为小数、整数和字节。转为字节实际上是使用utf-8来对字符串进行编码。

注意

如果字符串的内容不是数字，则使用此模块将其转换为数字会报错。

3.1.2 示例¶

源代码：

a = "123"
b = "1.23"
c = "Mixly"
print(int(a))
print(float(b))
print(a.encode("utf-8"))
print(b.encode("utf-8"))
print(c.encode("utf-8"))

输出结果：

123
1.23
b'123'
b'1.23'
b'Mixly'

3.2 数字转换为字符串¶

3.2.1 描述¶

此模块可以将数字转换为字符串。

3.2.2 示例¶

源代码：

a = 123
b = 1.23
print(str(a))
print(str(b))
print(str(100))

输出结果：

123
1.23
100

3.3 转ASCII字符¶

3.3.1 描述¶

此模块可以返回一个ASCII编码对应的文本符号。

3.3.2 示例¶

源代码：
1
2
print(chr(38))
print(chr(65))
输出结果：
&
A

提示

ASCII码表:

3.4 转ASCII数值¶

3.4.1 描述¶

此模块可以返回一个字符对应的ASCII编码。

3.4.2 示例¶

源代码：
1
2
print(ord("&"))
print(ord("A"))
输出结果：
38
65

4.获取字符串长度¶

4.1 描述¶

此模块可以返回一个字符串的长度或者列表、元组、集合的元素数量。对于字符串，一个英文字母、一个符号（比如空格）、一个汉字长度均为1。

4.2 返回值¶

此模块返回的长度为int类型的数据格式。

4.3 示例¶

源代码：

print(len("Mixly"))
print(len("北京师范大学米思齐团队"))
print(len("I Love Mixly!"))
print(len([1,2,3]))
print(len((1,2,3,4)))
print(len({1,2,3,4,5}))

输出结果：

5.字符串判断¶

5.1 描述¶

此模块可以判断前后两个字符串是否相等，也可以判断某字符串是否以某字符或字符串开始或结尾。若相等或以指定字符串开始或结尾，则返回True，否则返回False。

注意

此模块的判断都是严格区分大小写的。
可以判断某字符串是否以另一字符串开始或结尾。

5.2 示例¶

源代码：

print("Mixly" == "Mixly")
print("Mixly" == "mixly")
print("米思齐" == "米思皮")
print("Mixly".startswith("m"))
print("Mixly".endswith("y"))
print("Mixly".endswith("ly"))

输出结果：

True
False
False
False
True
True

6.字符串截取¶

6.1 根据索引截取字符¶

6.1.1 描述¶

此模块可以在字符串中根据索引返回对应的字符。

注意

点击了解附录：字符串索引方向。
在字符串中截取字符，索引的范围为字符串长度的相反数到字符串的长度减1，如五个字符的字符串索引范围为[-5, 4]，超出此范围的索引会报错。

6.1.2 示例¶

源代码：

print("Mixly"[0])
print("Mixly"[2])
print("Mixly"[4])
print("Mixly"[(-5)])
print("Mixly"[(-3)])
print("Mixly"[(-1)])

输出结果：

M
x
y
M
x
y

6.2 根据索引范围截取字符串¶

6.2.1 描述¶

此模块可以在字符串中根据索引返回对应的字符串。

注意

所截取出的字符串中，包含前一个索引对应的字符，但不包含后一个索引对应的字符。
点击了解附录：字符串索引方向。
在字符串中截取字符串，索引的范围为字符串长度的相反数到字符串的长度（因为不包含后一索引对应的字符，所以不用减1），如五个字符的字符串索引范围为[-5, 5]，超出此范围的索引会报错。

6.2.2 示例¶

源代码：

str = "北京师范大学米思齐团队"
print(str[0 : 6])       #截取第一个到第六个字符
print(str[-5 : -1])     #截取倒数第五个到倒数第二个字符

输出结果：

北京师范大学
米思齐团

6.3 截取随机字符¶

6.3.1 描述¶

此模块将返回给定字符串中随机的一个字符。

6.3.2 示例¶

源代码：
1
2
3
4
import random
print(random.choice("Mixly"))
print(random.choice("Mixly"))
print(random.choice("Mixly"))
输出结果（每次输出结果是随机的）：
l
M
y

7.字符串编/解码¶

7.1 描述¶

此模块可以对指定字符串进行指定类型的编码和解码，并返回编码和解码的结果。

注意

使用错误的类型进行解码可能会获得乱码，或者报错。

7.2 示例¶

_images/string_decode_encode_example1.png

源代码：

print("Mixly".encode("ASCII"))
print("Mixly".encode("ASCII").decode("ASCII"))
print("米思齐".encode("utf-8"))
print("米思齐".encode("utf-8").decode("utf-8"))
print("米思齐".encode("gbk"))
print("米思齐".encode("gbk").decode("gbk"))

输出结果：

b'Mixly'
Mixly
b'\xe7\xb1\xb3\xe6\x80\x9d\xe9\xbd\x90'
米思齐
b'\xc3\xd7\xcb\xbc\xc6\xeb'
米思齐

提示

了解更多关于字符编码的知识：

8.字符串内容转换¶

8.1 描述¶

此模块可以对指定字符串进行指定类型的转换。转换类型包括将各单词首字母转换为大写，将句子首字母转换为大写，将字符串中所有字母的大小写对调，以及将所有字母转换为小写字母。

注意

将各单词首字母转换为大写功能需要各个单词间有分隔符（空格，逗号均可），若没有分隔符则视为同一个单词。
将句子首字母转换为大写实际上是将整个字符串第一个字母转换为大写，后面的句子并不会转换。

8.2 示例¶

源代码：

print("hello mixly!".title())
print("hello mixly! i love mixly!".capitalize())
print("hello mixly!".title().swapcase())
print("hello mixly!".title().swapcase().lower())

输出结果：

Hello Mixly!
Hello mixly! i love mixly!
hELLO mIXLY!
hello mixly!

9.字符串填充对齐¶

9.1 描述¶

此模块可以在指定宽度中对字符串进行左对齐、居中和右对齐，并使用指定的符号填充空白部分。

注意

指定的符号可以为空格，但不可以为空，否则会报错。

9.2 示例¶

源代码：

print("Hello,mixly".ljust(50,"*"))
print("I love mixly!".center(50,"*"))
print("Happy mixly!".rjust(50,"*"))
print("Hello,mixly".ljust(50," "))
print("I love mixly!".center(50," "))
print("Happy mixly!".rjust(50," "))

输出结果：

Hello,mixly***************************************
******************I love mixly!*******************
**************************************Happy mixly!
Hello,mixly
                  I love mixly!
                                      Happy mixly!

10.字符串搜索¶

10.1 描述¶

此模块可以检查字符串中是否包含指定字符或者字符串，如果包含则返回字符或字符串首字符的索引值，否则返回-1。

注意

如果有多个检索结果，则返回第一个检索结果的索引。
字符串各个字符的索引从0开始，也就是说第一个字符的索引为0，第九个字符的索引为8，以此类推。
可以在字符串中检索字符和字符串。
检索时是严格匹配大小写的。

10.2 示例¶

源代码：

print("Hello,mixly".find("l"))
print("Hello,mixly".find("ll"))
print("Hello,mixly".find("mix"))
print("Hello,mixly".find("h"))

输出结果：

11.序列连接成字符串¶

11.1 描述¶

此模块可以使用指定的连接字符或字符串将序列（列表、元组、集合等）的各个元素连接起来形成并返回一个字符串。

注意

需要连接的序列（列表、元组、集合等）的每一个元素必须是字符串的数据类型。
集合（{}）是无序序列，所以每次对集合进行连接返回的字符串是随机的。

11.2 示例¶

源代码：

print(" ".join(["Beijing", "Normal", "University"]))
print("-".join(("Mixly", "Mixpy", "MixGo")))
print("--".join({"Mixly", "Mixpy", "MixGo"}))

输出结果：

Beijing Normal University
Mixly-Mixpy-MixGo
MixGo--Mixly--Mixpy     # 此项由于是连接集合，所以每一次输出的结果是随机的

12.字符串内容替换¶

12.1 描述¶

此模块可以将字符串中的某一字符串替换为另一字符串，返回替换后的字符串。

注意

此模块的替换操作并不会改变原字符串。
此模块在替换时会替换所有符合条件的字符串。

12.2 示例¶

源代码：

str = "Hello,mixly"
print(str.replace("mixly","mixpy"))
print(str)
print("北京师范大学米思齐团队".replace("米思齐","Mixly"))
print("Hello,mixly".replace("l","A"))

输出结果：

Hello,mixpy
Hello,mixly
北京师范大学Mixly团队
HeAAo,mixAy

13.字符串分割¶

13.1 描述¶

此模块通过指定分隔符对字符串进行分割（切片），返回一个列表。

注意

分隔符将会被删除，不会存在于结果列表中。
分隔符是严格区分大小写的。

13.2 示例¶

源代码：

print("I love mixly!".split(" "))
print("Hello mixly!".split("l"))
print("Hello mixly!".split("L"))
print("北京师范大学米思齐团队".split("米思"))

输出结果：

['I', 'love', 'mixly!']
['He', '', 'o mix', 'y!']
['Hello mixly!']
['北京师范大学', '齐团队']

14.字符串消除空格¶

14.1 描述¶

此模块可以消除字符串两侧或者单独删除左、右侧的空格，返回处理后的字符串。

14.2 示例¶

_images/string_delete_space_example1.png

源代码：

print(" I love mixly ".strip())
print(" I love mixly ".lstrip())
print(" I love mixly ".rstrip())

输出结果：

I love mixly
I love mixly
 I love mixly

15.字符串格式化¶

15.1 描述¶

此模块可以在字符串中格式化传递参数。需要传递参数的地方使用”{}”标记，你可以点击模块上的蓝色齿轮添加多个参数。

注意

传递的参数可以是各种数据类型。
后面参数排列的顺序对应”{}”标记的顺序。

15.2 示例¶

源代码：

import random
place = ["北京", "重庆", "广东", "浙江", "福建"]
MixGroup = ["Mixly", "Mixpy", "MixGo"]
print("Random No. is {}".format(random.randint(1, 100)))
print("我在{}，我爱{}！".format(random.choice(place), random.choice(MixGroup)))

输出结果：

Random No. is 62
我在重庆，我爱Mixly！

16.字符串表达式执行¶

16.1 描述¶

此模块可以执行一个字符串表达式，并返回表达式的值。

注意

表达式指的是加减乘除、数学函数运算、逻辑运算等

16.2 示例¶

源代码：

a = True
b = False
c = 3
d = 5
print(eval("1+1"))
print(eval("pow(2,2)"))     # 2的2次方
print(eval("int('1') * 3"))
print(eval("a and b"))
print(eval("c * d"))
print(eval("d > c"))

输出结果：

2
4
3
False
15
True

附录：字符串索引方向¶

注意

有正反两种索引方式。
正向索引中，字符串各个字符的索引从0开始，也就是说第一个字符的索引为0，第九个字符的索引为8，以此类推。
反向索引中，字符串各个字符的索引从字符串长度的相反数开始，也就是说，对于一个长度为5的字符串，第一个（倒数第五个）字符的索引为-5，倒数第一个（最后一个）字符的索引为-1，倒数第二个字符的索引为-2，以此类推。
阅读完毕后，在浏览器中后退可回到之前的浏览位置。

注解

序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字——它的位置，也称为索引：第一个索引是0，第二个索引是1，依此类推。

Python有多种内置的序列类型，但最常见的是列表、元组、字典和集合。

序列都可以进行的操作包括索引，切片，加，乘，检查成员等。

此外，Python已经内置确定序列的长度以及确定最大和最小的元素等方法。

列表¶

注解

列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。

列表的数据项不需要具有相同的数据类型。

Mixly中有很多用于列表操作的模块，如下：

1.列表初始化¶

1.1 描述¶

Mixly中有两种初始化列表的方式：

第一种，你需要输入列表名称，将代表各种数据的模块连接到初始化模块上，你也可以点击蓝色齿轮增加元素数量。

第二种，你也需要输入列表名称，然后直接在方括号中输入各种数据，各个元素使用英文逗号分隔即可。

在使用列表初始化模块后，你可以在”变量”模块分类中根据你输入的列表名称找到代表此列表的模块。

注意

列表的各个元素类型不要求相同，可以是数字、布尔值和字符串，也可以是另一个列表。
列表中的字符串元素都是由引号包围的，若其他数据类型使用引号包围也将会被视为字符串类型。

1.2 示例¶

源代码：

mylist = ["Mixly", 1.0, True, [1,2,3,4,5]]
print(mylist)

输出结果：

['Mixly', 1.0, True, [1, 2, 3, 4, 5]]

2.列表元素获取¶

2.1根据索引获取元素¶

2.1.1 描述¶

此模块可以在列表中根据索引返回对应的元素。

注意

字符串其实也是一种序列，所以列表获取元素和字符串截取字符是同理的。
点击查看附录1：序列索引方向。
在列表中获取单个元素，索引的范围为列表元素数量的相反数到列表元素数量减1，如五个元素的列表索引范围为[-5, 4]，超出此范围的索引会报错。

2.1.2 示例¶

_images/list_get_element_by_index_example1.png

源代码：

mylist = ["Mixly", "Mixpy", "MixGo", "Mixly Group"]
print(mylist[0])
print(mylist[2])

输出结果：

Mixly
MixGo

2.2 根据索引范围获取多个元素¶

2.2.1 描述¶

此模块可以在列表中根据索引返回对应的多个元素组成的子列表。

注意

所截取出的子列表中，包含前一个索引对应的元素，但不包含后一个索引对应的元素。
点击查看附录1：序列索引方向。
在列表中获取多个元素，索引的范围为列表元素数量的相反数到列表元素数量（因为不包含后一索引对应的元素，所以不用减1），如五个元素的列表索引范围为[-5, 5]，超出此范围的索引会报错。

2.2.2 示例¶

_images/list_get_elements_by_index_example1.png

源代码：

mylist = ["Mixly", "Mixpy", "MixGo", "Mixly Group"]
print(mylist[0 : 2])
print(mylist[2 : 4])

输出结果：

['Mixly', 'Mixpy']
['MixGo', 'Mixly Group']

2.3 随机获取元素¶

2.3.1 描述¶

此模块将返回给定列表中随机的一个元素。

2.3.2 示例¶

_images/list_get_random_element_example1.png

源代码：

import random
mylist = ["Mixly", "Mixpy", "MixGo", "Mixly Group"]
print(random.choice(mylist))
print(random.choice(mylist))
print(random.choice(mylist))

输出结果（每次输出结果是随机的）：

MixGo
Mixly Group
Mixpy

3.获取列表信息¶

3.1 描述¶

此模块可以返回一个列表的长度（元素数量）。还可以返回数字列表的总和、最大值、最小值、平均数、中位数、众数和标准差。

注意

此模块返回的长度为int类型的数据格式。
此模块只能返回数字列表的总和、最大值、最小值、平均数、中位数、众数和标准差，若列表中包含其他数据类型的元素，则会报错。
此模块返回的平均数和标准差因为经过除法运算，所以返回的是float类型的数据格式。
当给定的数字列表中有多个众数时，将会返回由这多个众数组成的列表。
由于Mixly中此模块使用的math包中不包含计算平均数、中位数、众数和标准差的方法，所以会定义计算这几种数据的方法并调用。

3.2 示例¶

源代码：

import math
def math_standard_deviation(numbers):       # 定义计算标准差的方法
    n = len(numbers)
    if n == 0: return
    mean = float(sum(numbers)) / n
    variance = sum((x - mean) ** 2 for x in numbers) / n
    return math.sqrt(variance)
def math_modes(some_list):      # 定义计算众数的方法
    modes = []
    counts = []
    maxCount = 1
    for item in some_list:
        found = False
        for count in counts:
            if count[0] == item:
                count[1] += 1
                maxCount = max(maxCount, count[1])
                found = True
        if not found:
            counts.append([item, 1])
    for counted_item, item_count in counts:
        if item_count == maxCount:
            modes.append(counted_item)
    return modes
def math_median(myList):    # 定义计算中位数的方法
    localList = sorted([e for e in myList if type(e) == int or type(e) == float])
    if not localList: return
    if len(localList) % 2 == 0:
        return (localList[len(localList) // 2 - 1] + localList[len(localList) // 2]) / 2.0
    else:
        return localList[(len(localList) - 1) // 2]
def math_mean(myList):      # 定义计算平均数的方法
    localList = [e for e in myList if type(e) == int or type(e) == float]
    if not localList: return
    return float(sum(localList)) / len(localList)


num_list = [1,3,5,7,9]
str_list = ["Mixly", "Mixpy", "MixGo", "Mixly Group"]
print(len(str_list))
print(len(num_list))
print(sum(num_list))
print(max(num_list))
print(min(num_list))
print(math_mean(num_list))
print(math_median(num_list))
print(math_modes(num_list))
print(math_standard_deviation(num_list))

输出结果：

4
5
25
9
1
5.0
5
[1, 3, 5, 7, 9]
2.8284271247461903

4.列表元素查询¶

4.1 描述¶

此模块可以在给定的列表中查询某个值，选择”位置”将返回第一个匹配元素的索引，选择”个数”将返回匹配元素的数量。

注意

查询的值可以是任意的数据类型
在查询匹配元素的索引时，若列表中无匹配元素，则会报错。
在查询匹配元素的数量时，若列表中无匹配元素，则会返回0。

4.2 示例¶

源代码：

num_list = [1,2,2,2,3,3,4,5]
str_list = ["MixGo", "米思齐", "米思齐", "米思齐", "Mixpy", "北京师范大学"]
print(num_list.index(3))
print(num_list.count(2))
print(str_list.count("米思齐"))

输出结果：

4
3
3

5.列表元素赋值¶

5.1 描述¶

此模块可以在给定的列表中根据索引为对应的元素赋值。

注意

此模块没有返回值。
索引必须在列表长度范围内，否则会报错。

5.2 示例¶

源代码：

mylist = [1,2,3,4,5]
mylist[2] = "Mixly"
print(mylist)

输出结果：

[1, 2, 'Mixly', 4, 5]

6.列表插入元素¶

6.1 描述¶

此模块可以在给定的列表中给定的索引位置插入元素。

注意

此模块没有返回值。
插入元素之后的所有元素将会依次往后移动一个位置。
若插入时给定的索引超出了原列表的长度，则会默认添加到列表的末尾。
给定的索引可以为负值，规则参考附录1：序列索引方向。

6.2 示例¶

源代码：

mylist = [1,2,3,4,5]
mylist.insert(1, "目的索引为1")
mylist.insert(10, "目的索引为10")
mylist.insert(-3, "目的索引为-3")
print(mylist)

输出结果：

[1, '目的索引为1', 2, 3, '目的索引为-3', 4, 5, '目的索引为10']

7.列表添加元素¶

7.1 描述¶

此模块可以在给定的列表后添加一个或者一组元素。

“增加”会将添加的对象视为一个元素，”扩展增加”会将添加的对象视为一个序列，将序列的元素分别添加到给定列表的末尾。

注意

此模块没有返回值。
增加使用的是append()方法，会将参数视为一个元素添加到末尾。
扩展增加使用的是extend()方法，参数必须是序列（包括列表、元组、集合、字符串等）对象，如果是非序列对象，则会报错。

7.2 示例¶

源代码：

mylist = [1,2,3,4,5]
mylist.append("Mixly")
print(mylist)
mylist = [1,2,3,4,5]
mylist.extend("Mixly")
print(mylist)
mylist = [1,2,3,4,5]
mylist.append([1,2,3,4,5])
print(mylist)
mylist = [1,2,3,4,5]
mylist.extend([1,2,3,4,5])
print(mylist)

输出结果：

[1, 2, 3, 4, 5, 'Mixly']        # 在序列后增加"Mixly"
[1, 2, 3, 4, 5, 'M', 'i', 'x', 'l', 'y']        # 在序列后扩展增加"Mixly"
[1, 2, 3, 4, 5, [1, 2, 3, 4, 5]]        # 在序列后增加[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5, 1, 2, 3, 4, 5]      # 在序列后扩展增加[1, 2, 3, 4, 5]

8.列表删除元素¶

8.1 描述¶

此模块可以在给定的列表中删除给定索引位置或者给定值的元素。

注意

此模块没有返回值。
根据给定的值删除元素只会删除列表中匹配的第一个元素。
给定索引位置超出列表长度以及给定值在列表中无匹配元素都会触发报错。
给定的索引可以为负值，规则参考附录1：序列索引方向。

8.2 示例¶

源代码：

mylist = [1,2,3,4,5]
del mylist[2]
print(mylist)
mylist = [1,2,3,4,5]
mylist.remove(3)
print(mylist)
mylist = [1,2,2,2,5]
mylist.remove(2)
print(mylist)

输出结果：

[1, 2, 4, 5]
[1, 2, 4, 5]
[1, 2, 2, 5]

9.列表删除并获取元素¶

9.1 描述¶

此模块可以在给定的列表中删除给定索引位置的元素，并返回被删除的元素值。

注意

给定的索引可以为负值，规则参考附录1：序列索引方向。

9.2 示例¶

源代码：

mylist = [1,2,3,4,5]
print(mylist.pop(-2))
print(mylist)

输出结果：

4
[1, 2, 3, 5]

10.列表元素排序¶

10.1 描述¶

此模块可以将给定的列表按照数字或首字母进行升序或者降序排列，并返回排好序的列表。

注意

Mixly中定义了新的方法来对列表进行排序。
此模块并不会改变原序列元素的顺序。
此模块可以将各种数字类型的元素混合排列。
此模块按照首字母区分大小写排列会分别对大写和小写进行给定顺序排列，且小写总在大写后，即升序排列小写在大写后，降序排列小写在大写前。
此模块还可以对同时含有数字和字符串的列表进行排序。若按照数字排序，则只会对列表内的数字排序，字符串会按照原来的顺序，在所有数字后；若按照字母排序，则同时会对数字和字符串进行排序，对字符串的排序规则与上一条相同，且所有字符串在所有数字后。
此模块还可以对多维列表进行排序，由于很少使用，感兴趣的读者可以自行探究，也可以直接探究Mixly中排序方法的定义。

10.2 示例¶

源代码：

def lists_sort(my_list, type, reverse):
    def try_float(s):
        try:
            return float(s)
        except:
            return 0
    key_funcs = {
        "NUMERIC": try_float,
        "TEXT": str,
        "IGNORE_CASE": lambda s: str(s).lower()
    }
    key_func = key_funcs[type]
    list_cpy = list(my_list)
    return sorted(list_cpy, key=key_func, reverse=reverse)


num_list = [1.2,2.5,3,4.3,6.1]
str_list = ["Aplle", "apple", "Cat", "Dog", "fox"]
mix_list = ["book", 2.5,1.2,3,5.2,"Door",4.3,"cat"]
print(lists_sort(num_list, "NUMERIC", True))
print(num_list)
print(lists_sort(str_list, "TEXT", False))
print(lists_sort(str_list, "TEXT", True))
print(lists_sort(str_list, "IGNORE_CASE", True))
print(str_list)
print(lists_sort(mix_list, "NUMERIC", True))
print(lists_sort(mix_list, "TEXT", False))
print(lists_sort(mix_list, "IGNORE_CASE", False))
print(mix_list)

输出结果：

[6.1, 4.3, 3, 2.5, 1.2]     # 按照数字降序排列
[1.2, 2.5, 3, 4.3, 6.1]     # 原列表
['Aplle', 'Cat', 'Dog', 'apple', 'fox']     # 按照首字母升序排列，区分大小写
['fox', 'apple', 'Dog', 'Cat', 'Aplle']     # 按照首字母降序排列，区分大小写
['fox', 'Dog', 'Cat', 'apple', 'Aplle']     # 按照首字母降序排列，忽略大小写
['Aplle', 'apple', 'Cat', 'Dog', 'fox']     # 原列表
[5.2, 4.3, 3, 2.5, 1.2, 'book', 'Door', 'cat']      # 按照数字降序排列
[1.2, 2.5, 3, 4.3, 5.2, 'Door', 'book', 'cat']      # 按照首字母升序排列，区分大小写
[1.2, 2.5, 3, 4.3, 5.2, 'book', 'cat', 'Door']      # 按照首字母升序排列，忽略大小写
['book', 2.5, 1.2, 3, 5.2, 'Door', 4.3, 'cat']      # 原列表

11.列表逆序¶

11.1 描述¶

此模块可以将给定的列表反向。

注意

此模块没有返回值。
此模块会改变原列表的顺序。

11.2 示例¶

源代码：

mylist = [1,2,3,4,5]
mylist.reverse()
print(mylist)
mylist = ["Mixly", "Mixpy", "MixGo", "Mixly Group"]
mylist.reverse()
print(mylist)

输出结果：

[5, 4, 3, 2, 1]
['Mixly Group', 'MixGo', 'Mixpy', 'Mixly']

12.列表清空¶

12.1 描述¶

此模块可以清空给定列表的元素。

注意

列表被清空后，只是变成了不包含元素的空列表，此列表对象仍然存在，可以使用列表名调用。
此模块没有返回值。

12.2 示例¶

源代码：

mylist = ["Mixly", "Mixpy", "MixGo", "Mixly Group"]
mylist.clear()
print(mylist)

输出结果：

[]

13.列表转换¶

13.1 描述¶

此模块可以将给定列表转换为元组或集合并返回。

13.2 示例¶

源代码：

mylist = ["Mixly", "Mixpy", "MixGo", "Mixly Group"]
print(tuple(mylist))
print(set(mylist))

输出结果：

('Mixly', 'Mixpy', 'MixGo', 'Mixly Group')
{'Mixly Group', 'Mixpy', 'MixGo', 'Mixly'}      # 因为集合是无序序列，所以每一次输出是随机的

14.列表迭代打包¶

14.1 描述¶

此模块可以将给定的迭代列表中的对应元素打包成一个个元组，然后返回由这一个个元组组成的对象。

注意

如果各个迭代的列表元素数量不一致，则按照元素数量最少的列表进行打包。
此模块返回的是一个对象，需要将此对象转换为想要的序列格式。
若打包迭代的列表数量超过2个，则无法转换为字典，否则会报错。

14.2 示例¶

源代码：

print(zip([0,1,2], [0,1,2,3,4]))
print(list(zip([0,1,2], [0,1,2,3,4])))

输出结果：

<zip object at 0x10c45e580>     # 返回的是一个zip对象
[(0, 0), (1, 1), (2, 2)]

示例2：

源代码：

print(zip([0,1,2,3], [0,1,2,3]))
print(list(zip([0,1,2,3], [0,1,2,3])))
print(tuple(zip([0,1,2,3], [0,1,2,3])))
print(dict(zip([0,1,2,3], [0,1,2,3])))
print(set(zip([0,1,2,3], [0,1,2,3])))
print(zip(["Name", "Age", "Country"], ["Fred", "19", "China"], ["Tom", "18", "Australia"], ["Sam", "20", "America"]))
print(list(zip(["Name", "Age", "Country"], ["Fred", "19", "China"], ["Tom", "18", "Australia"], ["Sam", "20", "America"])))
print(tuple(zip(["Name", "Age", "Country"], ["Fred", "19", "China"], ["Tom", "18", "Australia"], ["Sam", "20", "America"])))
print(set(zip(["Name", "Age", "Country"], ["Fred", "19", "China"], ["Tom", "18", "Australia"], ["Sam", "20", "America"])))

输出结果：

<zip object at 0x102e92400>     # 返回的是一个zip对象
[(0, 0), (1, 1), (2, 2), (3, 3)]
((0, 0), (1, 1), (2, 2), (3, 3))
{0: 0, 1: 1, 2: 2, 3: 3}
{(1, 1), (3, 3), (2, 2), (0, 0)}
<zip object at 0x102e92400>     # 返回的是一个zip对象
[('Name', 'Fred', 'Tom', 'Sam'), ('Age', '19', '18', '20'), ('Country', 'China', 'Australia', 'America')]
(('Name', 'Fred', 'Tom', 'Sam'), ('Age', '19', '18', '20'), ('Country', 'China', 'Australia', 'America'))
{('Country', 'China', 'Australia', 'America'), ('Age', '19', '18', '20'), ('Name', 'Fred', 'Tom', 'Sam')}

附录1：序列索引方向¶

注意

有正反两种索引方式。
正向索引中，各个元素的索引从0开始，也就是说第一个元素的索引为0，第九个元素的索引为8，以此类推。
反向索引中，各个元素的索引从列表元素数量的相反数开始，也就是说，对于一个元素数量为5的列表，第一个（倒数第五个）元素的索引为-5，倒数第一个（最后一个）元素的索引为-1，倒数第二个元素的索引为-2，以此类推。

注解

序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字——它的位置，也称为索引：第一个索引是0，第二个索引是1，依此类推。

Python有多种内置的序列类型，但最常见的是列表、元组、字典和集合。

序列都可以进行的操作包括索引，切片，加，乘，检查成员等。

此外，Python已经内置确定序列的长度以及确定最大和最小的元素等方法。

元组¶

注解

Python的元组与列表类似，不同之处在于元组的元素不能修改。

元组使用小括号，列表使用方括号。

Mixly中有很多用于元组操作的模块，如下：

1.元组初始化¶

1.1 描述¶

Mixly中有两种初始化元组的方式：

第一种，你需要输入元组名称，将代表各种数据的模块连接到初始化模块上，你也可以点击蓝色齿轮增加元素数量。

第二种，你也需要输入元组名称，然后直接在小括号中输入各种数据，各个元素使用英文逗号分隔即可。

在使用元组初始化模块后，你可以在”变量”模块分类中根据你输入的元组名称找到代表此元组的模块。

注意

元组的各个元素类型不要求相同，可以是数字、布尔值和字符串，也可以是另一个元组。
元组中的字符串元素都是由引号包围的，若其他数据类型使用引号包围也将会被视为字符串类型。

1.2 示例¶

源代码：

mytup= ("Mixly", 1.0, True, [1,2,3,4,5], (1,2,3,4,5))
print(mytup)
mytup2 = ("Mixly", 1.0, True, [1,2,3,4,5], (1,2,3,4,5))
print(mytup2)

输出结果：

('Mixly', 1.0, True, [1, 2, 3, 4, 5], (1, 2, 3, 4, 5))
('Mixly', 1.0, True, [1, 2, 3, 4, 5], (1, 2, 3, 4, 5))

2.元组元素获取¶

2.1 根据索引获取元素¶

2.1.1 描述¶

此模块可以在元组中根据索引返回对应的元素。

注意

字符串其实也是一种序列，所以元组获取元素和字符串截取字符也是同理的。
点击查看附录1：序列索引方向。
在元组中获取单个元素，索引的范围为元组元素数量的相反数到元组元素数量减1，如五个元素的元组索引范围为[-5, 4]，超出此范围的索引会报错。

2.1.2 示例¶

源代码：

输出结果：
Mixly
MixGo

2.2 根据索引范围获取多个元素¶

_images/tuple_get_elements_by_index1.png

2.2.1 描述¶

此模块可以在元组中根据索引返回对应的多个元素组成的子元组。

注意

所截取出的子元组中，包含前一个索引对应的元素，但不包含后一个索引对应的元素。
点击查看附录1：序列索引方向。
在元组中获取多个元素，索引的范围为元组元素数量的相反数到元组元素数量（因为不包含后一索引对应的元素，所以不用减1），如五个元素的元组索引范围为[-5, 5]，超出此范围的索引会报错。

2.2.2 示例¶

_images/tuple_get_elements_by_index_example1.png

源代码：

mytup = ("Mixly", "Mixpy", "MixGo", "Mixly Group")
print(mytup[0 : 2])
print(mytup[2 : 4])

输出结果：

('Mixly', 'Mixpy')
('MixGo', 'Mixly Group')

2.3 随机获取元素¶

2.3.1 描述¶

此模块将返回给定元组中随机的一个元素。

2.3.2 示例¶

_images/tuple_get_random_element_example1.png

源代码：

import random
mytup = ("Mixly", "Mixpy", "MixGo", "Mixly Group")
print(random.choice(mytup))
print(random.choice(mytup))
print(random.choice(mytup))

输出结果（每次输出结果是随机的）：

Mixly Group
MixGo
Mixpy

3.获取元组信息¶

3.1 描述¶

此模块可以返回一个元组的长度（元素数量）。还可以返回数字元组的总和、最大值、最小值。

注意

此模块返回的长度为int类型的数据格式。
此模块只能返回数字元组的总和、最大值、最小值，若元组中包含其他数据类型的元素，则会报错。

3.2 示例¶

源代码：

num_tup = (1,3,5,7,9)
str_tup = ("Mixly", "Mixpy", "MixGo", "Mixly Group")
print(len(num_tup))
print(len(str_tup))
print(max(num_tup))
print(min(num_tup))
print(sum(num_tup))

输出结果：

4.删除元组¶

4.1 描述¶

此模块可以删除指定的元组。

注意

此模块没有返回值。
删除元组后，无法再使用已被删除的元组名称调用元组，否则会报错。

4.2 示例¶

源代码：

mytup = ("Mixly", "Mixpy", "MixGo", "Mixly Group")
print(mytup)
del mytup

输出结果：

('Mixly', 'Mixpy', 'MixGo', 'Mixly Group')

5.元组连接¶

5.1 描述¶

虽然我们无法对元组进行修改，但是我们可以连接元组。

此模块可以连接两个指定的元组。

注意

此模块不会对原元组进行修改。

5.2 示例¶

源代码：

num_tup = (1,3,5,7,9)
str_tup = ("Mixly", "Mixpy", "MixGo", "Mixly Group")
print(num_tup + str_tup + num_tup)
print(num_tup)
print(str_tup)

输出结果：

(1, 3, 5, 7, 9, 'Mixly', 'Mixpy', 'MixGo', 'Mixly Group', 1, 3, 5, 7, 9)
(1, 3, 5, 7, 9)
('Mixly', 'Mixpy', 'MixGo', 'Mixly Group')

6.元组转换¶

6.1 描述¶

此模块可以将给定元组转换为列表或集合并返回。

6.2 示例¶

源代码：

str_tup = ("Mixly", "Mixpy", "MixGo", "Mixly Group")
print(list(str_tup))
print(set(str_tup))
print(str_tup)

输出结果：

['Mixly', 'Mixpy', 'MixGo', 'Mixly Group']
{'Mixpy', 'MixGo', 'Mixly Group', 'Mixly'}      # 因为集合是无序序列，所以每一次输出是随机的
('Mixly', 'Mixpy', 'MixGo', 'Mixly Group')

附录1：序列索引方向¶

注意

有正反两种索引方式。
正向索引中，各个元素的索引从0开始，也就是说第一个元素的索引为0，第九个元素的索引为8，以此类推。
反向索引中，各个元素的索引从列表元素数量的相反数开始，也就是说，对于一个元素数量为5的列表，第一个（倒数第五个）元素的索引为-5，倒数第一个（最后一个）元素的索引为-1，倒数第二个元素的索引为-2，以此类推。

字典¶

注解

字典是另一种可变容器模型，且可存储任意类型对象。

字典的每个键值对(key=>value)用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中，格式如下所示：

d = {key1 : value1, key2 : value2 }

键必须是唯一的，但值则不必。

值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。

Mixly中有很多用于元组操作的模块，如下：

1.字典初始化¶

1.1 描述¶

在初始化字典时，你需要输入字典和各个键的名称，然后将代表各种数据的模块对应地连接到初始化模块上与键对应的地方，你也可以点击蓝色齿轮增加键值对数量。

在初始化字典后，你可以在”变量”模块分类中根据你输入的字典名称找到代表此字典的模块。

注意

键必须是唯一且不可变的。

1.2 示例¶

源代码：

mydict= {"Name":"Fred", "Age":18, "Country":"China", "ID":1}
print(mydict)

输出结果：

{'Name': 'Fred', 'Age': 18, 'Country': 'China', 'ID': 1}

2.字典获取所有键¶

2.1 描述¶

此模块可以返回一个字典所有的键的名称。

注意

此模块返回的是一个名叫 ‘dict_keys’ 类的对象，你可以将其转换为列表对象。

2.2 示例¶

源代码：

mydict= {"Name":"Fred", "Age":18, "Country":"China", "ID":1}
print(mydict.keys())
print(type(mydict.keys()))
print(list(mydict.keys()))

输出结果：

dict_keys(['Name', 'Age', 'Country', 'ID'])     # 'dict_keys' 类对象
<class 'dict_keys'>     # 对象的类别
['Name', 'Age', 'Country', 'ID']        # 转换为列表后

3.字典获取键值¶

3.1 描述¶

此模块可以返回字典中指定键的键值。

注意

若指定的键不存在于字典中，则会报错。
字典键的名称是严格区分大小写的。

3.2 示例¶

源代码：

mydict= {"Name":"Fred", "Age":18, "Country":"China", "ID":1}
print(mydict["Name"])
print(mydict["Age"])

输出结果：

Fred
18

4.字典添加或修改键值¶

4.1 描述¶

此模块可以对字典中给定的键对应的值进行修改，若给定的键不存在于字典中，则此键值对将会被添加到字典中。

注意

此模块没有返回值。

4.2 示例¶

源代码：

mydict= {"Name":"Fred", "Age":18, "Country":"China", "ID":1}
print(mydict["Name"])
mydict["Name"] = "Sam"
print(mydict["Name"])
mydict["Gender"] = "Male"
print(mydict["Gender"])
print(mydict)

输出结果：

Fred
Sam
Male
{'Name': 'Sam', 'Age': 18, 'Country': 'China', 'ID': 1, 'Gender': 'Male'}

5.字典删除键值¶

5.1 描述¶

此模块可以在字典中根据所给键删除键值对。

注意

若所给键值不存在于字典中，则会报错。
此模块没有返回值。

5.2 示例¶

源代码：

mydict= {"Name":"Fred", "Age":18, "Country":"China", "ID":1}
print(mydict)
del mydict["ID"]
print(mydict)

输出结果：

{'Name': 'Fred', 'Age': 18, 'Country': 'China', 'ID': 1}
{'Name': 'Fred', 'Age': 18, 'Country': 'China'}

6.字典删除并返回键值¶

6.1 描述¶

此模块可以在字典中根据所给键返回键值，并删除键值对。

注意

若所给键值不存在于字典中，则会报错。
此模块没有返回值。

6.2 示例¶

源代码：

mydict= {"Name":"Fred", "Age":18, "Country":"China", "ID":1}
print(mydict.pop("ID"))
print(mydict)

输出结果：

1
{'Name': 'Fred', 'Age': 18, 'Country': 'China'}

7.字典设置键默认值¶

7.1 描述¶

此模块可以为字典中给定的键设定默认值。若给定的键存在于字典中，则对应的值不会改变；若给定的键不存在于字典中，则键值对将会被添加到字典中，且键值为所给的默认值。

注意

此模块没有返回值。

7.2 示例¶

源代码：

mydict= {"Name":"Fred", "Age":18, "Country":"China", "ID":1}
print(mydict)
mydict.setdefault("Class",1)
print(mydict)
mydict= {"Name":"Fred", "Age":18, "Country":"China", "ID":1}
print(mydict)
mydict.setdefault("ID",0)
print(mydict)

输出结果：

{'Name': 'Fred', 'Age': 18, 'Country': 'China', 'ID': 1}
{'Name': 'Fred', 'Age': 18, 'Country': 'China', 'ID': 1, 'Class': 1}
{'Name': 'Fred', 'Age': 18, 'Country': 'China', 'ID': 1}
{'Name': 'Fred', 'Age': 18, 'Country': 'China', 'ID': 1}

8.字典清空条目¶

8.1 描述¶

此模块可以清空给定字典的条目。

注意

字典被清空后，只是变成了不包含条目的空字典，此字典对象仍然存在，可以使用字典名调用。
此模块没有返回值。

8.2 示例¶

源代码：

mydict= {"Name":"Fred", "Age":18, "Country":"China", "ID":1}
print(mydict)
mydict.clear()
print(mydict)

输出结果：

{'Name': 'Fred', 'Age': 18, 'Country': 'China', 'ID': 1}
{}

9.字典转换为列表¶

9.1 描述¶

此模块可以将字典转换为键值对元组作为元素的 ‘dict_items’ 类对象，你可以将其转换为列表对象。

注意

此模块返回的是一个名叫 ‘dict_items’ 类的对象，你可以将其转换为列表对象。

9.2 示例¶

源代码：

mydict= {"Name":"Fred", "Age":18, "Country":"China", "ID":1}
print(mydict)
print(mydict.items())
print(type(mydict.items()))
print(list(mydict.items()))

输出结果：

{'Name': 'Fred', 'Age': 18, 'Country': 'China', 'ID': 1}
dict_items([('Name', 'Fred'), ('Age', 18), ('Country', 'China'), ('ID', 1)])        # 'dict_items' 类对象
<class 'dict_items'>        # 'dict_items' 类对象名
[('Name', 'Fred'), ('Age', 18), ('Country', 'China'), ('ID', 1)]

10.字典获取所有键值¶

10.1 描述¶

此模块可以返回一个字典所有的键值。

注意

此模块返回的是一个名叫 ‘dict_values’ 类的对象，你可以将其转换为列表对象。

10.2 示例¶

源代码：

mydict= {"Name":"Fred", "Age":18, "Country":"China", "ID":1}
print(mydict)
print(mydict.values())
print(type(mydict.values()))
print(list(mydict.values()))

输出结果：

{'Name': 'Fred', 'Age': 18, 'Country': 'China', 'ID': 1}
dict_values(['Fred', 18, 'China', 1])       # 'dict_values' 类对象
<class 'dict_values'>       # 对象的类别
['Fred', 18, 'China', 1]        # 转换为列表后

11.字典获取长度¶

11.1 描述¶

此模块可以返回一个字典的长度（条目数量）。

注意

此模块返回的长度是int类型的值。

11.2 示例¶

源代码：

mydict= {"Name":"Fred", "Age":18, "Country":"China", "ID":1}
print(mydict)
print(len(mydict))

输出结果：

{'Name': 'Fred', 'Age': 18, 'Country': 'China', 'ID': 1}
4

12.删除字典¶

12.1 描述¶

此模块可以删除指定的字典。

注意

此模块没有返回值。
删除字典后，无法再使用已被删除的字典名称调用字典，否则会报错。

12.2 示例¶

源代码：

mydict= {"Name":"Fred", "Age":18, "Country":"China", "ID":1}
print(mydict)
del mydict

输出结果：

{'Name': 'Fred', 'Age': 18, 'Country': 'China', 'ID': 1}

集合¶

注解

集合（set）是一个无序的不重复元素序列。

Mixly中有很多用于集合操作的模块，如下：

1.集合初始化¶

1.1 描述¶

Mixly中有两种初始化集合的方式：

第一种，你需要输入集合名称，将代表各种数据的模块连接到初始化模块上，你也可以点击蓝色齿轮增加元素数量。

第二种，你也需要输入集合名称，然后直接在花括号中输入各种数据，各个元素使用英文逗号分隔即可。

在使用集合初始化模块后，你可以在”变量”模块分类中根据你输入的集合名称找到代表此集合的模块。

注意

集合内部的各个元素是没有顺序的，所以直接输出集合，每一次的输出结果都是随机的。
集合的各个元素类型不要求相同，可以是数字、布尔值和字符串。
集合中不能存在相同元素，且集合中的元素必须是不可变类型（列表、集合等为可变类型）。
集合中的字符串元素都是由引号包围的，若其他数据类型使用引号包围也将会被视为字符串类型。

1.2 示例¶

源代码：

s1= {"Mixly", 1, True}
s2= {"Mixly", 1.5, True}
s3 = {"Mixly", 0, False}
s4 = {"Mixly", 1, False}
print(s1)
print(s2)
print(s3)
print(s4)

输出结果：

{1, 'Mixly'}        # 因为在Python中1 = 1.0 = True，所以仅保留了1这个元素
{1.5, True, 'Mixly'}
{0, 'Mixly'}        # 因为在Python中0 = False，所以仅保留了0这个元素
{False, 1, 'Mixly'}

2.获取集合长度¶

2.1 描述¶

此模块可以返回一个集合的长度（元素数量）。

注意

此模块返回的长度为int类型的数据格式。

2.2 示例¶

源代码：

s1= {"Mixly", 1, True}
print(s1)
print(len(s1))

输出结果：

{1, 'Mixly'}
2

3.集合删除并获取元素¶

3.1 描述¶

此模块可以在给定的集合中删除随机元素，并返回被删除的元素值。

3.2 示例¶

源代码：

s1= {"Mixly", 1, "Mixpy", 2}
print(s1)
print(s1.pop())
print(s1)

输出结果：

{'Mixly', 1, 2, 'Mixpy'}
Mixly
{1, 2, 'Mixpy'}

4.集合运算¶

4.1 描述¶

此模块可以将给定的两个集合进行并集、交集、差集运算，并返回运算结果的集合。

注意

此模块并不会对原集合进行修改。
并集是将两个集合的元素在删除重复元素后组成的集合。
交集是两个集合中都包含的元素组成的集合。
差集是包含在第一个集合中，但不包含在第二个集合(方法的参数)中的元素组成的集合。

4.2 示例¶

源代码：

s1= {"Mixly", 1, "Mixpy", 2}
s2= {"Mixly", 2, "MixGo", 3}
print(s1)
print(s2)
print(s1.union(s2))
print(s1.intersection(s2))
print(s1.difference(s2))
print(s1)
print(s2)

输出结果：

{'Mixly', 1, 2, 'Mixpy'}
{'Mixly', 2, 3, 'MixGo'}
{1, 2, 3, 'MixGo', 'Mixly', 'Mixpy'}
{'Mixly', 2}
{1, 'Mixpy'}
{'Mixly', 1, 2, 'Mixpy'}        # 此模块并不会对原集合进行修改
{'Mixly', 2, 3, 'MixGo'}

5.集合运算并更新¶

5.1 描述¶

此模块可以将给定的两个集合进行并集、交集、差集运算，并将运算结果的集合赋值给第一个参数集合。

注意

此模块没有返回值。
此模块只会改变第一个参数集合，不会改变第二个参数集合。

5.2 示例1¶

_images/set_operator_refresh_example1.png

源代码：

s1= {"Mixly", 1, "Mixpy", 2}
s2= {"Mixly", 2, "MixGo", 3}
print(s1)
print(s2)
s1.update(s2)
print(s1)
print(s2)

输出结果：

{'Mixpy', 1, 'Mixly', 2}
{3, 'MixGo', 'Mixly', 2}
{1, 2, 3, 'MixGo', 'Mixly', 'Mixpy'}        # 更新后的第一个参数集合
{3, 'MixGo', 'Mixly', 2}

5.3 示例2¶

_images/set_operator_refresh_example21.png

源代码：

输出结果：

{1, 2, 'Mixpy', 'Mixly'}
{'MixGo', 2, 3, 'Mixly'}
{2, 'Mixly'}        # 更新后的第一个参数集合
{'MixGo', 2, 3, 'Mixly'}

5.4 示例3¶

_images/set_operator_refresh_example31.png

源代码：

s1= {"Mixly", 1, "Mixpy", 2}
s2= {"Mixly", 2, "MixGo", 3}
print(s1)
print(s2)
s1.difference_update(s2)
print(s1)
print(s2)

输出结果：

{1, 'Mixpy', 2, 'Mixly'}
{'MixGo', 2, 3, 'Mixly'}
{1, 'Mixpy'}        # 更新后的第一个参数集合
{'MixGo', 2, 3, 'Mixly'}

6.集合增加和删除元素¶

6.1 描述¶

此模块可以根据所给值在集合中增加或删除元素。

注意

Mixly中，此模块仅能够在集合中增加或删除数字元素。
如果添加的元素在集合中已存在，则不执行任何操作。
此模块没有返回值。

6.2 示例¶

源代码：

s1= {"Mixly", 1, "Mixpy", 2}
print(s1)
s1.add(3)
print(s1)
s1.add(2)
print(s1)
s1.discard(1)
print(s1)

输出结果：

{'Mixpy', 1, 2, 'Mixly'}
{'Mixpy', 1, 2, 3, 'Mixly'}     # 添加元素3
{'Mixpy', 1, 2, 3, 'Mixly'}     # 添加元素2，因为集合中已包含元素2，所以没有执行任何操作
{'Mixpy', 2, 3, 'Mixly'}        # 删除元素1

7.集合拆分增加序列元素¶

7.1 描述¶

此模块可以将给定的字符串、列表、元组、集合等拆分增加到集合中。

注意

若是字符串，则将会把字符串拆分为一个一个字符作为元素添加进集合中。
在添加时，如果添加的元素在集合中已存在，则该元素只会出现一次，重复的会忽略。
此模块没有返回值。

7.2 示例¶

源代码：

s1= {"Mixly", 1, "Mixpy", 2}
print(s1)
s1.update([1,2,3,4,5])
print(s1)
s1.update("MixGo")
print(s1)
s1.update((6,7,8,9,0))
print(s1)
s1.update({"A","B","C"})
print(s1)

输出结果：

{1, 2, 'Mixpy', 'Mixly'}
# 添加列表[1,2,3,4,5]，因为1，2已存在，所以并未添加
{1, 2, 3, 4, 5, 'Mixpy', 'Mixly'}
# 添加字符串"MixGo"，字符被拆分后添加到集合里
{1, 2, 3, 4, 5, 'i', 'x', 'Mixpy', 'Mixly', 'G', 'M', 'o'}
# 添加元组(6,7,8,9,0)
{0, 1, 2, 3, 4, 5, 'i', 'x', 6, 7, 8, 9, 'Mixpy', 'Mixly', 'G', 'M', 'o'}
# 添加集合{"A","B","C"}
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 'C', 'B', 'Mixpy', 'A', 'x', 'M', 'i', 'Mixly', 'G', 'o'}

8.集合子集超集判断¶

8.1 描述¶

此模块可以判断两个集合的子集和超集关系，并返回判断的逻辑值。

若前一集合是后一集合的子集或超集，则将返回True；否则将返回False。

8.2 示例¶

源代码：

s1= {"Mixly", 1, "Mixpy", 2}
s2= {1, 2}
s3= {2, 3}
print(s1)
print(s2)
print(s3)
print(s2.issubset(s1))
print(s3.issubset(s1))
print(s1.issuperset(s2))
print(s1.issuperset(s3))
print(s2.issubset(s3))
print(s2.issuperset(s3))

输出结果：

{1, 'Mixly', 2, 'Mixpy'}
{1, 2}
{2, 3}
True        # s2是否是s1的子集
False       # s3是否是s1的子集
True        # s1是否是s2的超集
False       # s1是否是s3的超集
False       # s2是否是s3的子集
False       # s2是否是s3的超集

变量¶

注解

变量是存储在内存中的值，变量可以指定不同的数据类型，存储各种不同类型的数据。

Python中，有五种标准的数据类型：Numbers（数字），String（字符串），List（列表），Tuple（元组），Dictionary（字典）。

Numbers（数字）又包含四种类型：int（有符号整型），long（长整型[也可以代表八进制和十六进制]），float（浮点型），complex（复数）。

Mixly中有很多用于变量操作的模块，如下：

提示

当你使用其他模块创建变量之后，变量分类下会增加为此变量赋值和调用此变量的模块。

1.使用全局变量¶

1.1 描述¶

Python中定义函数时，若想在函数内部对函数外的变量进行操作，就需要声明其为global（全局变量）。

提示

全局变量实际上是为了提示 python 解释器，表明被其修饰的变量是全局变量。这样解释器就可以从当前空间中读写相应变量了。

Python 的全局变量是模块 (module) 级别的

每个 python 函数拥有对应的 __globals__ 字典，该字典与函数所属模块的 __dict__ 字典完全相同。函数的全局变量也会从这个字典中获取

即：python 解释器发现函数中的某个变量被 global （全局变量）关键字修饰，就去函数的 __globals__ 字典变量中寻找（因为 python 中函数也是一等对象）；同时，一个模块中每个函数的 __globals__ 字典变量都是模块 __dict__ 字典变量的引用，二者值完全相同。

1.2 返回值¶

注意

此模块没有返回值。

1.3 示例1¶

源代码：

x = 1
def function1():
    x = 2
function1()
print(x)

输出结果：

1   # 在函数中并未使用全局变量，所以函数无法将x赋为2，无法改变x的值

1.4 示例2¶

源代码：

x = 1
def function1():
    global x
    x = 2
function1()
print(x)

输出结果：

2   # 在函数中使用全局变量，函数将x赋为2

1.5 示例3¶

源代码：

global x
x = 1
def function1():
    x = 2
function1()
print(x)

输出结果：

1   # 使用全局变量需要在函数内部声明，在外部声明函数依然无法将x赋为2

2.初始化变量¶

2.1 描述¶

此模块对变量进行初始化，或者为其赋值。

你需要在模块中输入变量名称，如果不存在此变量，则将会创建此变量并赋值；如果存在此变量，则将会为此变量赋新值。

使用此模块创建变量之后，变量分类下会增加为此变量赋值和调用此变量的模块。

2.2 返回值¶

注意

此模块没有返回值。

2.3 示例¶

源代码：

x = 1
mytext = "Mixly"
mylist = [1,2,3,4,5]
mytup = (1,2,3,4,5)
myset = {1,2,3,4,5}

输出结果：

# 没有输出结果

3.数据类型转换¶

注解

在Python中，各种类型的数据变量可以灵活便捷地进行转换。

但需要注意的是，数据类型转换需要建立在有意义的基础上，你不能够在非数字字符串和数字类型的变量之间转换等等。

3.1 转换为整数¶

3.1.1 描述¶

你可以将小数（float）、布尔值和字符串转换为整数。

注意

将小数转换为整数时，将会直接取小数的整数部分；
布尔值转换为整数，True将转换为1，False将转换为0；
字符串转换为整数时，字符串的内容必须是整数，字符串类型的小数无法转换为整数，会触发报错。

3.1.2 示例¶

_images/variable_transform_int_example1.png

源代码：

print(int('7'))
print(int(6.6))
print(int(7.4))
print(int(True))
print(int(False))

输出结果：

 # '7'
 # 6.6
 # 7.4
 # True
 # False

3.2 转换为小数¶

3.2.1 描述¶

你可以将整数、布尔值和字符串转换为小数。

注意

将整数转换为小数时，将会直接在整数后面添加小数点和0；
布尔值转换为小数，True将转换为1.0，False将转换为0.0；
字符串转换为小数时，字符串的内容可以是整数也可以是小数，字符串类型的整数转换为小数时将会在整数后添加小数点和0。

3.2.2 示例¶

_images/variable_transform_float_example1.png

源代码：

print(float('7'))
print(float('7.3'))
print(float(6))
print(float(True))
print(float(False))

输出结果：

0     # '7'
3     # '7.3'
0     # 6
0     # True
0     # False

3.3 转换为布尔值¶

3.3.1 描述¶

你可以将所有类型的变量转换为布尔值。

注意

将所有非空序列（列表、元组、字典、集合、字符串）转换为布尔值时，都会转换为True，空序列将转换为False；
将整数和小数转换为布尔值时，1和1.0将转换为True，0和0.0将转换为False；
空对象（None）转换为布尔值为False；

3.3.2 示例¶

_images/variable_transform_bool_example1.png

源代码：

print(bool("7.3"))
print(bool("0"))
print(bool(""))
print(bool(6))
print(bool(0))
print(bool(None))
print(bool([1,2,3,4,5]))
print(bool((1,2,3,4,5)))
print(bool({'Name': 'Tom', 'Age': 18}))
print(bool({1,2,3,4,5}))

输出结果：

True    # "7.3"
True    # "0"
False   # ""
True    # 6
False   # 0
False   # None
True    # [1,2,3,4,5]
True    # (1,2,3,4,5)
True    # {'Name': 'Tom', 'Age': 18}
True    # {1,2,3,4,5}

3.4 转换为字符串¶

3.4.1 描述¶

你可以将所有类型的变量转换为字符串。

3.4.2 示例¶

_images/variable_transform_str_example1.png

源代码：

print(str(6))
print(str(7.3))
print(str(False))
print(str(None))
print(str([1,2,3,4,5]))
print(str((1,2,3,4,5)))
print(str({'Name': 'Tom', 'Age': 18}))
print(str({1,2,3,4,5}))

输出结果：

# 以下输出的变量类型都是str，可以使用type()方法查看
6
7.3
False
None
[1, 2, 3, 4, 5]
(1, 2, 3, 4, 5)
{'Name': 'Tom', 'Age': 18}
{1, 2, 3, 4, 5}

3.5 转换为非字典序列¶

3.5.1 描述¶

非字典序列类型（列表、元组、集合、字符串）变量可以相互转换，字典也可以转换为非字典序列类型。

数字、布尔值等类型的变量无法转换为序列类型的变量。

注意

将字典转换为其他非字典序列类型时，会将字典中的键作为序列的元素添加到序列中。

3.5.2 示例¶

_images/variable_transform_line_example1.png

源代码：

print(list("Mixly"))
print(list((1,2,3,4,5)))
print(list({'Name':"Tom", 'Age':18, 'Country':"China"}))
print(list({1,2,3,4,5}))

print(tuple("Mixly"))
print(tuple([1,2,3,4,5]))
print(tuple({'Name':"Tom", 'Age':18, 'Country':"China"}))
print(tuple({1,2,3,4,5}))

print(set("Mixly"))
print(set([1,2,3,4,5]))
print(set((1,2,3,4,5)))
print(set({'Name':"Tom", 'Age':18, 'Country':"China"}))

输出结果：

['M', 'i', 'x', 'l', 'y']
[1, 2, 3, 4, 5]
['Name', 'Age', 'Country']
[1, 2, 3, 4, 5]
('M', 'i', 'x', 'l', 'y')
(1, 2, 3, 4, 5)
('Name', 'Age', 'Country')
(1, 2, 3, 4, 5)
{'l', 'x', 'y', 'M', 'i'}
{1, 2, 3, 4, 5}
{1, 2, 3, 4, 5}
{'Name', 'Country', 'Age'}      # 集合是无序的

3.6 转换为字典¶

3.6.1 描述¶

你可以将元素为二元序列的序列转换为字典，转换后，每个二元序列的第一个元素为字典的键，第二个元素为对应的键值。

注意

你可以使用 14.列表迭代打包的方式将两个序列打包成为元素为二元序列的序列。

3.6.2 示例¶

_images/variable_transform_dict_example1.png

源代码：

keys = ["Name", "Age", "Country"]
values = ["Fred", "19", "China"]
print(dict(zip(keys, values)))

输出结果：

{'Name': 'Fred', 'Age': '19', 'Country': 'China'}

4.获取变量数据类型¶

4.1 描述¶

此模块可以获取各种变量的数据类型并返回。

你可以使用此模块获取一些模块返回的未知的对象的数据类型。

4.2 示例¶

源代码：

print(type(7))
print(type(7.3))
print(type("Mixly"))
print(type([1,2,3,4,5]))
print(type((1,2,3,4,5)))
print(type(dict(zip(["Name", "Age", "Country"], ["Fred", "19", "China"]))))
print(type({1,2,3,4,5}))
print(type(False))
print(type(None))
print(type(zip(["Name", "Age", "Country"], ["Fred", "19", "China"])))
print(type(dict(zip(["Name", "Age", "Country"], ["Fred", "19", "China"])).keys()))
print(type(dict(zip(["Name", "Age", "Country"], ["Fred", "19", "China"])).items()))
print(type(dict(zip(["Name", "Age", "Country"], ["Fred", "19", "China"])).values()))

输出结果：

<class 'int'>
<class 'float'>
<class 'str'>
<class 'list'>
<class 'tuple'>
<class 'dict'>
<class 'set'>
<class 'bool'>
<class 'NoneType'>      # None的数据类型
<class 'zip'>           # 迭代打包返回的数据类型
<class 'dict_keys'>     # 获取字典所有键的模块返回的数据类型
<class 'dict_items'>    # 字典转换为列表的模块返回的数据类型
<class 'dict_values'>   # 获取字典所有键值的模块返回的数据类型

5.变量类型模块¶

5.1 描述¶

此模块用于在变量类型判断中作为代表各种变量类型的模块。

5.2 示例¶

在第一个条件语句中，若变量a是字符串类型，则打印输出a，否则输出”变量a不是字符串类型。”；在第二个条件语句中，若变量a是整数类型，则打印输出a，否则输出”变量a不是整数类型。”

源代码：
1
2
3
4
5
6
7
8
9
a = "Mixly"
if type(a) == str:
    print(a)
else:
    print("变量a不是字符串类型。")
if type(a) == int:
    print(a)
else:
    print("变量a不是整数类型。")
输出结果：
Mixly
变量a不是整数类型。

函数¶

注解

Mixly中，函数是组织好的、可重复使用的、用来实现单一或相关联功能的一组模块。

函数能提高应用的模块性和模块的重复利用率。

你已经知道Mixly提供了许多内建模块，比如”打印（自动换行）”。

你可以自己创建函数，这被叫做自定义函数。

Mixly中有如下用于函数操作的模块：

1.函数定义（无返回值）¶

1.1 描述¶

Mixly中，你需要在函数定义模块中输入函数的名称，然后将实现函数功能的各种其他模块连接到函数定义模块中。

注意

函数定义模块默认没有参数，你可以点击蓝色齿轮为函数增加参数；
请尽量不要为函数命名为无意义的名称，函数的名称最好能够清楚地体现函数的功能；
当你创建有参数的函数后，你可以在变量分类下找到调用该参数的模块；
当你创建函数后，你可以在函数分类下找到调用函数的模块。

1.2 示例¶

源代码：

def welcome(name):
    print("你好，" + str(name) + "！\n欢迎使用Mixly！")
welcome("Fred")

输出结果：

你好，Fred！
欢迎使用Mixly！

2.函数定义（有返回值）¶

2.1 描述¶

在定义有返回值的函数时，你需要在返回值旁边连接变量模块。

有返回值的函数调用模块可以作为变量连接到其他模块上。

注意

函数定义模块默认没有参数，你可以点击蓝色齿轮为函数增加参数；
请尽量不要为函数命名为无意义的名称，函数的名称最好能够清楚地体现函数的功能；
当你创建有参数的函数后，你可以在变量分类下找到调用该参数的模块；
当你创建函数后，你可以在函数分类下找到调用函数的模块。

2.2 示例¶

定义了两个有返回值的函数，square用于计算参数的平方值，calcu_1-2k在给定一元二次方程的参数a, b, c 后可以直接计算出方程的解，并返回一个解组成的列表。

源代码：
1
2
3
4
5
6
7
8
9
import math
def square(x):
    z = x * x
    return z
def calcu_1_2k(a, b, c):
    x1 = (-(b) + math.sqrt(square(b) - 4 * (a * c))) / (2 * a)
    x2 = (-(b) - math.sqrt(square(b) - 4 * (a * c))) / (2 * a)
    return [x1, x2]
print((calcu_1_2k(5, -4, -1)))
输出结果：
[1.0, -0.2]     # 一元二次方程 5x²-4x-1=0 的解

3.返回（条件返回）¶

3.1 描述¶

返回语句会将程序或者函数的处理结果返回到原来调用的地方，并把程序的控制权一起交回。

Mixly中的返回模块在有返回值的函数中可以连接返回值，在无返回值的函数中不可以。

注意

函数执行中遇到第一个返回语句时，就会结束函数的执行，不会运行其他的返回语句；
条件返回让你可以直接将条件语句连接在返回模块中，仅适用于条件返回的情况。

3.2 示例¶

下面定义了一个函数welcome，如果传入的参数name的名字在bad_guys列表里，则直接返回，不会再执行输出”欢迎使用Mixly！”的语句。

源代码：
1
2
3
4
5
6
7
8
def welcome(name):
    bad_guys = ["Sam", "Tom", "Mike"]
    print(("你好，" + name))
    if name in bad_guys:
        return None
    print("欢迎使用Mixly！")
welcome("Fred")
welcome("Tom")
输出结果：
你好，Fred
欢迎使用Mixly！
你好，Tom

串口¶

传感器¶

传感模块：超声波、DHT11、DS18B20（新增）

在传感器部分，我们将一些最常见的传感器相关指令进行编库，比如超声波测距模块，学生在使用超声波进行测距时，可直接运用该模块，只需将Trig与Echo管脚填好即可，这大大节省了学生的编程时间，这将更有助于使学生将更多的精力集中在创意实践上而非抓耳挠腮地编程。

执行器¶

执行模块：声音播放、舵机控制、I2C液晶模块

MicroPython/images/11Actuator/actuator1.png

MicroPython/images/11Actuator/actuator2.png

显示器¶

文件¶

存储模块：EEPROM读写，SD卡写入

MicroPython/images/14Storage/storage1.png

通信¶

通信是为了方便人与计算机交互而采用的一种特殊通信方式。具体包括：串口通信(新增串口选择和波特率设置)、红外通信、I2C通信、SPI通信（新增）。

MicroPython/images/13Communicate/commu1.png

MicroPython/images/13Communicate/commu2.png

串口通信¶

MicroPython/images/13Communicate/commu3.png

串口通信功能学生可在串口监视器中查看。这一功能对于学生检查自己代码以及监视传感器数据提供了便利条件。假设学生将LM35的温度传感器接到模拟管脚A0口，学生可通过 .. image:: images/13Communicate/commu4.png 指令观察当前室温。随后可能会提出疑问：当前室温怎么可能是58？这将引发学生进一步的思考造成该数据的可能性。

红外通信¶

MicroPython/images/13Communicate/commu5.png

上图指令主要运用的是红外接收管与遥控器之间的数据发射与接收功能。学生掌握了红外通信的相关内容，便可以制作遥控风扇、遥控汽车等自主设计更强的创意电子产品。

I2C通信¶

I2C（Inter－Integrated Circuit）是同步通信的一种特殊形式，具有接口线少，控制方式简单，器件封装形式小，通信速率较高等优点。Mixly支持I2C的读取和写入，并且支持基于I2C协议的执行器。

SPI通信¶

SPI是串行外设接口（Serial Peripheral Interface）的缩写。SPI，是一种高速的，全双工，同步的通信总线，并且在芯片的管脚上只占用四根线，节约了芯片的管脚，同时为PCB的布局上节省空间，提供方便，拥有简单易用的特性。用户可以使用Mixly向SPI传输数据。

网络¶

物联网¶

自定义模块¶

Factory中的模块可以方便用户编写Mixly中不支持的传感器功能。 .. image:: images/16Factory/factory.png

将以RTC1307库为例，介绍利用factory中的模块，在Mixly快速使用Arduino标准库。

准备工作¶

1.从github.com等网站下载ds1307RTC Arduino库。 2.将库文件解压到Mixly/arduino-1.x.x/portable/sketchbook/libraries目录中。 3.打开Mixly自带的arduino IDE（路径Mixlyarduino-1.x.xarduino.exe），在软件中打开库目录下的example范例，编译并上传，测试能否正常使用。如果不能正常使用，则需要更换库或者检查硬件问题。

重写程序¶

打开范例程序Mixly/arduino-1.x.x/portable/sketchbook/libraries/DS1307RTC/examples/ReadTime/ReadTest/ReadTest.ino，先分析程序，并适当简化程序。

源程序如下：

    #include <Wire.h>
    #include "TimeLib.h"
    #include "DS1307RTC.h"

    void setup() {
      Serial.begin(9600);
      while (!Serial) ; // wait for serial
      delay(200);
      Serial.println("DS1307RTC Read Test");
      Serial.println("-------------------");
    }

    void loop() {
      tmElements_t tm;

      if (RTC.read(tm)) {
        Serial.print("Ok, Time = ");
        print2digits(tm.Hour);
        Serial.write(':');
        print2digits(tm.Minute);
        Serial.write(':');
        print2digits(tm.Second);
        Serial.print(", Date (D/M/Y) = ");
        Serial.print(tm.Day);
        Serial.write('/');
        Serial.print(tm.Month);
        Serial.write('/');
        Serial.print(tmYearToCalendar(tm.Year));
        Serial.println();
      } else {
        if (RTC.chipPresent()) {
          Serial.println("The DS1307 is stopped.  Please run the SetTime");
          Serial.println("example to initialize the time and begin running.");
          Serial.println();
        } else {
          Serial.println("DS1307 read error!  Please check the circuitry.");
          Serial.println();
        }
        delay(9000);
      }
      delay(1000);
    }

    void print2digits(int number) {
      if (number >= 0 && number < 10) {
        Serial.write('0');
      }
      Serial.print(number);
    }

简化程序如下：

    #include <Wire.h>
    #include "TimeLib.h"
    #include "DS1307RTC.h"

    void setup() {
      Serial.begin(9600);
    }

    void loop() {
      tmElements_t tm;
      if (RTC.read(tm)) {
        Serial.print(tm.Hour);
        Serial.print(':');
        Serial.print(tm.Minute);
        Serial.print(':');
        Serial.print(tm.Second);
        Serial.print(tm.Day);
        Serial.print('/');
        Serial.print(tm.Month);
        Serial.print('/');
        Serial.print(tmYearToCalendar(tm.Year));
      }
      delay(1000);
    }

Factory模式下模块：

MicroPython/images/16Factory/DS1307RTC_example.png

编写完成后，编译并上传，进行测试。测试利用factroy编写的程序效果是否与arduino IDE编写相同。

掌控板¶

MixGo¶

Python 编程¶

CircuitPython 编程¶

MixGo CE 编程¶

输入/输出¶

输入/输出所包含的指令主要分为四部分：初始化管脚、控制管脚的输入输出、获取输入值。

管脚的输入输出按信号类型可分为数字信号和模拟信号，在CircuitPython中，模拟输出有PWM（脉冲宽度调制）和DAC（数模转换器）两种输出方式。

获取输入值可获取数字输入、模拟输入和触摸传感器的值。

初始化：数字输出
输入输出：数字输入、数字输出、模拟输入、PWM模拟输出、DAC模拟输出
【其他待完善】

1. HIGH¶

数字量，在时间上和数量上都是离散的物理量称为数字量.把表示数字量的信号叫数字信号.把工作在数字信号下的电子电路叫数字电路。有两种状态即：1或0

2. 初始化为数字管脚¶

引脚，又叫管脚，英文叫Pin。就是从集成电路（芯片）内部电路引出与外围电路的接线，所有的引脚就构成了这块芯片的接口。结合1.中数字信号介绍，该指令关于数字引脚初始化，而数字引脚又有多种模式，例如，数字输出、开漏输出、数字输入、上拉输入、下拉输入，具体见3.介绍。

3.数字管脚模式¶

将数字引脚进一步设置为具体的使用模式，其中数字输出为较为常用的数字输出模式，有两种状态分别为0和1，可用于驱动LED灯等外设；开漏输出：开漏输出就是不输出电压，控制输出低电平时引脚接地，控制输出高电平时引脚既不输出高电平，也不输出低电平，为高阻态。如果外接上拉电阻，则在输出高电平时电压会拉到上拉电阻的电源电压。这种方式适合在连接的外设电压比单片机电压低的时候；数字输入：指作为数字信号读取模式，读取到高电平返回1，读取到低电平返回0；关于上拉输入与下拉输入：通过使能芯片内部的上拉电阻可以保证在无信号输入时输入端的电平为高电平。而在信号输入为低电平是输入端的电平应该也为低电平。如果没有上拉电阻，在没有外界输入的情况下输入端是悬空的，它的电平是未知的无法保证的，上拉电阻就是为了保证无信号输入时输入端的电平为高电平，同样还有下拉电阻它是为了保证无信号输入时输入端的电平为低电平。

4. 数字输出¶

给一个数字引脚写入HIGH或者LOW。

4.1 范例¶

通过扩展接口U1（IO9、IO10）连接红蓝双色灯，然后通过数字输出模式，循环交替出现红、蓝色及熄灭状态，可类比用于直流电机的驱动，在用于马达驱动时避免两个引脚同时输出高电平。

5. 数字输入¶

读取指定引脚的状态值，返回0或1。

5.1 范例¶

通过扩展接口U1（IO9、IO10）连接按钮指示灯模块，以获取按钮引脚的状态值，并通过串口打印。

7. 初始化PWM模拟输出¶

PWM，英文名Pulse Width Modulation，是脉冲宽度调制缩写，它是通过对一系列脉冲的宽度进行调制，等效出所需要的波形（包含形状以及幅值），对模拟信号电平进行数字编码，也就是说通过调节占空比的变化来调节信号、能量等的变化，占空比就是指在一个周期内，信号处于高电平的时间占据整个信号周期的百分比，例如方波的占空比就是50%。

8. PWM模拟输出¶

待确认赋值具体含义

9. PWM模拟输出2¶

是指1秒钟内信号从高电平到低电平再回到高电平的次数(一个周期)；也就是说一秒钟PWM有多少个周期。单位：Hz

10. ADC模拟输入初始化¶

模拟输入是指输入模拟信号（模拟量）。可以说，模拟输入就是输入连续信号。

11. ADC模拟输入参考电压¶

在ADC也就是模数转换的时候需要由一个标准的稳定的电压提供参考才能精确的采样，更多信息，自行网搜。 * 该指令暂不可使用。

12. 获取ADC模拟输入¶

根据adc具体位数返回对应范围的连续数值，返回0-65535。

12.1 范例¶

通过串口打印连接在U1的旋转电位器数值。

13. 初始化触摸传感器¶

外接触摸传感器初始化。

14. 获取触摸传感器的值¶

读取外接触摸传感器的值，返回内容待测试。

14.1 范例待完善

控制¶

控制类别中包括了作为主程序运行、当型重复执行、延时函数、如果判断、序列循环、直到型循环执行、占位语句、跳出循环、尝试执行、系统运行时间、获取格式化时间、NTP获取当前时间等对程序结构进行相应的控制语句。

1.作为主程序运行¶

if __name__ == '__main__':
    pass

1.1 描述¶

if __name__==”__main__”:就相当于是 Python 模拟的程序入口。由于模块之间相互引用，不同模块可能都有这样的定义，而入口程序只能有一个，选中哪个入口程序取决于 __name__ 的值。

1.2 范例1¶

只要你创建了一个模块（一个.py文件），这个模块就有一个内置属性name生成，该模块的 name 的值取决于如何应用这个模块。也就是，如果你直接运行该模块，那么__name__ == “__main__”；如果你 import 一个模块，那么模块name 的值通常为模块文件名。

如，创建一个test1.py:

源代码：

def func():
    print('hello, world!')

if __name__ == "__main__":
    func()

模块中，首先定义了函数func()，用来打印出hello, world!，然后判断__name__ 是否等于 __main__，如果等于，有打印，反之则反，现在运行该模块，结果为：hello, world! 说明__name__ 等于 __main__。

这时，再创建一个test2.py:

import test1
print('good world!')

模块中，首先import test1，然后打印good world!做测试用，运行该模块，结果为:good world! 运行结果仅有good world!，说明__name__ 不等于 __main__。

注意

通过上面test1.py和test2.py两个模块，可以得出一个结论: 如果模块是被直接运行的，则if __name__ == “__main__”:后的代码块被运行，如果模块被import，则代码块不被运行。

2.当型重复执行¶

源代码:

while True:
    pass

2.1 描述¶

while循环会无限的循环，直到括号内的判断语句变为假。: 必须要有能改变判断语句的东西，要不然while循环将永远不会结束。你可以使用一个传感器的值，或者一个变量来控制什么时候停止该循环。

2.2 参数¶

满足条件:为真或为假的一个条件。

2.3 范例¶

当板载温度低于30度时，亮灯，否则灭灯。

import sensor
from led import led_L1

while sensor.get_temperature() < 0:
    led_L1.setonoff(1)
    led_L1.setonoff(0)

3.延时¶

源代码:

import time

time.sleep(1)

3.1 描述¶

使程序暂在该处暂停等待设定的时间（单位秒）。（一秒等于1000毫秒）。

3.2 参数¶

秒:暂停的秒数。

3.3 范例¶

板载L1灯亮1秒，灭1秒，往复循环。

from led import led_L1
import time


while True:
    led_L1.setonoff(1)
    time.sleep(1)
    led_L1.setonoff(1)
    time.sleep(1)

注意

虽然创建一个使用time.sleep()的闪烁LED很简单，并且许多例子将很短的延时用于消除开关抖动。但延时函数确实拥有很多显著的缺点。在time.sleep()函数使用的过程中，读取传感器值、计算、引脚操作均无法执行，因此，它所带来的后果就是使其他大多数活动暂停。大多数熟练的程序员通常避免超过10毫秒的延时,除非程序非常简单。

4.如果(if)¶

if False:
    pass

4.1 描述¶

if 语句与比较运算符一起用于检测某个条件是否达成，如某个传感器的值是否等于某个值。

4.2 参数¶

条件：比较表达式

4.3 用法¶

增加条件：如果需要增加条件，可以点开齿轮，然后将左侧的“否则如果”或者“否则”模块拖到右侧的“如果”之中。

4.4 范例1¶

当连接在B1引脚的按键按下时，点亮板载L1灯。

from button import button_B1
from led import led_L1


while True:
    if button_B1.was_pressed():
        led_L1.setonoff(1)

如果判断的结果，只要该表达式的结果不为0，则为真。

4.5 范例2¶

当连接在B1引脚的按键按下时，点亮板载L1灯;当按键松开时，灯灭。

from button import button_B1
from led import led_L1


while True:
    if button_B1.was_pressed():
        led_L1.setonoff(1)
    else:
        led_L1.setonoff(0)

5.序列循环(for)¶

for i in range(0, 5, 1):
    pass

5.1 描述¶

代表从0到5，间隔1,不包括5，即左闭右开[0, 5);间隔1可以是负数，有时这也叫做’步长’。

5.2 参数¶

变量名：用于记录for循环次数的变量名。
起始值：循环的计数起始值，一般从0开头，也可以从其他数值开始。
终点值：循环的计数终点值。
步长：每次循环的步长，一般为1，也可以是其他整数。

5.4 范例¶

串口输出i

for i in range(0, 5, 1):
    print(i)

串口输出结果：0，1，2，3，4

6.直到型循环¶

while True:
    if (False):
        break

6.1 描述¶

该循环语句与当型循环唯一区别在于多了条件判断，也就是当条件满足为真时，则停止该循环运行。

6.2 范例¶

定义一个变量状态，实现一个循环5次点亮熄灭板载LED灯的测试程序，其中每执行一次循环状态值增加1，直至状态变量的值等于5则停止运行该循环。

from led import led_L1
import time

状态 = False
while True:
    led_L1.setonoff(1)
    time.sleep(1)
    led_L1.setonoff(0)
    time.sleep(1)
    if (状态 == True):
        break

注意

直到型循环，中内嵌了一个if条件判断，仅当表达式返回为真时，则跳出该循环的运行。

7.占位语句¶

pass

7.1 描述¶

pass 是一个空操作，当它被执行时，什么都不发生。它适合当语法上需要一条语句但并不需要执行任何代码时用来临时占位在编写代码时只写框架思路，具体实现还未编写就可以用pass进行占位，使程序不报错，不会进行任何操作。

7.2 范例¶

pass在循环程序中占位。

while True:
    pass

8.跳出循环¶

break

8.1 描述¶

跳出循环用于终止一段重复的程序，一般使用时作为条件语句的执行部分，当循环中的变量满足某个条件时，执行跳出循环语句。

跳出循环在处理循环中的特殊情况时十分有用。

8.2 参数¶

操作：可以选择跳出循环和跳到下一个循环两种操作，结果不同。

8.3 范例¶

在序列for循环中，当i为500时，串口输出“500”，并停止增加

for i in range(0, 1000, 1):
    if i == 500:
        print('500')
        break

注意

注意跳到下一个循环的使用，可以方便的将循环中不需要的步骤跳过。

9.尝试执行¶

try:
    pass
except:
    pass

9.1 描述¶

捕捉异常可以使用try/except语句。try/except语句用来检测try语句块中的错误，从而让except语句捕获异常信息并处理。如果你不想在异常发生时结束你的程序，只需在try里捕获它。

9.2 范例¶

在物联网WIFI连接过程中，容易出现连接异常而导致程序无法正常向下运行，为让程序更加稳定，现在通过try-except进行实现，为清晰看到该捕获异常的具体效果，现要连接到一无线网中，wifi信息为：用户名1234，密码12345678，通过程序可以看到在try中的密码为错误的，except为正确的，此时当程序运行到第一条wifi连接指令时，便出错，导致下面的一条串口指令无法打印，若未使用try-except情况下，程序将直接崩溃，而现在将继续运行except中程序。好好体会下有无try-except的区别。

import wifi


try:
    wifi.radio.connect('1234','123456789')
    print('WOK')
except:
    wifi.radio.connect('1234','12345678')
while True:
    pass

10.系统运行时间¶

import time

time.monotonic()

10.1 描述¶

返回自硬件启动或重启以来的时间值。

10.2 返回¶

自硬件启动或重启以来的时间，毫秒数。

10.3 范例¶

自动换行打印系统运行时间

import time


while True:
    time.sleep(1)
    print(time.monotonic())

11.获取格式化时间¶

import time

time.localtime()

11.1 描述¶

获取本地当前时间信息。

11.2 范例¶

获取当前年份信息

import time

print(time.localtime()[0])

数学¶

该部分主要完成数学运算相关的功能，具体包括数字、常数、三角函数、各种数学、位和逻辑计算、取整、取最大值、随机数、进制转换、约束和映射模块。

1.数字常量¶

1.1描述¶

数字常量包括：整数常量和浮点常量。

注意

整数常量是直接在程序中使用的数字，如123。默认情况下，这些数字被视为int类型。通常情况下，整数常量默认为十进制，但可以加上特殊前缀表示为其他进制。如：0b111，表示二进制；0o73,表示八进制；0x7B，表示十六进制。

浮点常量也可以直接中程序中使用，如12.3。默认情况下，这些数字被视为float类型。也可以使用科学计数法表示浮点数。如：2.34E5代表2.34 * 10^5，其实际值为234000；67E-12代表67.0 * 10^-12，其实际值为0.000000000067。

2.常数¶

2.1 描述¶

常数模块里包括：圆周率常数π和自然常数e

注意

常数也可以直接在程序中使用。默认情况下，它们被视为int类型，而且默认为十进制。

3.三角函数及其他¶

3.1 sin¶

3.1.1 描述¶

计算角度的正弦（单位为°）。其结果在-1和1之间。

3.1.2 参数¶

角度（float）

3.1.3 返回值¶

角度的正弦值（double）

3.2 cos¶

3.2.1 描述¶

计算一个角度的余弦值（单位为°）。返回值在 -1 和 1 之间。

3.2.2 参数¶

角度（float）

3.2.3 返回值¶

角度的余弦值（double）

3.3 tan¶

3.3.1 描述¶

计算角度的正切（单位为°）。结果在负无穷大和无穷大之间。

3.3.2 参数¶

角度（float）

3.3.3 返回值¶

角度的正切值（double)

3.4 asin¶

3.4.1 描述¶

反正弦函数为正弦函数sin的反函数。

3.4.1 参数范围¶

[-1,1]

3.4.2 返回值范围¶

[-π/2,π/2]

3.5 acos¶

3.5.1 描述¶

反余弦函数为余弦函数cos的反函数。

3.5.2 参数范围¶

[-1,1]

3.5.3 返回值范围¶

[0,π]

3.6 atan¶

3.6.1 描述¶

反正切函数为正切函数tan的反函数。

3.6.2 参数范围¶

[-∞,∞]

3.6.3 返回值范围¶

(-π/2,π/2)

4.相反数¶

4.1 描述¶

计算一个参数的相反数。

4.2 参数范围¶

[-∞,∞]

4.3 返回值范围¶

-([-∞,∞])

5.对数函数与幂函数¶

5.1 ln¶

5.1.1 描述¶

计算一个参数的自然对数值，自然对数是以自然常数e为底数的对数。

5.1.2 参数范围¶

(0,∞]

5.1.3 返回值范围¶

[-∞,∞]

5.2 log10¶

5.2.1 描述¶

计算一个参数的常用对数值，常用对数是以10为底数的对数。

5.2.2 参数范围¶

(0,∞]

5.2.3 返回值范围¶

[-∞,∞]

5.3 e^¶

5.3.1 描述¶

计算以参数为指数，e为底数的幂运算值，e为自然常数。

5.3.2 参数范围¶

[-∞,∞]

5.3.3 返回值范围¶

(0,∞]

5.4 10^¶

5.4.1 描述¶

计算以参数为指数，10为底数的幂运算值。

5.4.2 参数范围¶

[-∞,∞]

5.4.3 返回值范围¶

(0,∞]

6.算术运算¶

6.1 描述¶

算术运算中包括加(+)、减(-)、乘(×)、除(÷)、取模(%)、取整除(//)和幂运算(**)。这些运算将会返回两个操作数的和，差，积，商，模、商的整数部分和幂值。

注意

这些运算是根据操作数的数据类型来计算的,比如 9和4都是int类型,所以9/4结果是2。
如果想要两个整数相除得到小数，就需要将整数转换成小数。如9.0/2.0=4.5 。
这也就代表如果运算结果比数据类型所能容纳的范围要大的话，就会出现溢出。例如： 1加上一个整数 int类型 32,767 结果变成-32,768。
如果操作数是不同类型的,结果是“更大”的那种数据类型。如果操作数中的其中一个是 float类型或者double类型, 就变成了浮点数运算。
取整除运算将会返回商的整数部分，向下取整。

6.2 参数¶

常量或变量

6.3 返回值¶

两个操作数的和，差，积，商，模、商的整数部分和幂值。

7.位运算¶

注解

按位运算符是把数字看作二进制来进行计算。

7.1 按位与(&)¶

7.1.1 描述¶

按位与操作符为一个&符，用在两个整型变量之间。按位与运算符对两侧的变量的每一位都进行运算。

规则是：如果两个运算元都是1，则结果为1，否则输出0。

提示

如： 0011&0101=0001

7.1.2 范例¶

    a = 0b0011
    b = 0b0101
    c = (a&b)

7.2 按位或(|)¶

7.2.1 描述¶

按位或操作符是|。

和&操作符类似,|操作符对两个变量的为一位都进行运算,只是运算规则不同。

按位或规则：只要两个位有一个为1则结果为1，否则为0。

提示

如：0011|0101=0111

7.2.2 范例¶

    a = 0b0011
    b = 0b0101
    c = (a|b)

7.3 右移位运算(>>)¶

7.3.1 描述¶

把”>>”左边的运算数的各二进制位全部右移若干位，>> 右边的数字指定了移动的位数。

提示

如：00111100>>2输出结果15，二进制解释：00001111

7.3.2 范例¶

    a = 0b00111100
    b = (a>>2)

7.4 左移位运算(<<)¶

7.4.1 描述¶

运算数的各二进位全部左移若干位，由 << 右边的数字指定了移动的位数，高位丢弃，低位补0。

提示

如：00111100<<2输出结果240，二进制解释：11110000

7.4.2 范例¶

    a = 0b00111100
    b = (a<<2)

8.赋值运算¶

8.1 描述¶

赋值运算中包括赋值加(+=)、赋值减(-=)、赋值乘(×=)、赋值除(÷=)、赋值取模(%=)、赋值取整除(//=)和赋值幂运算(**=)。

赋值运算符的左边为变量，右边为操作数。赋值运算符将左边的变量本身和右边的操作数分别作为算术运算的操作数，返回两个操作数的和，差，积，商，模、商的整数部分和幂值，并将返回值赋值给左边的变量。

注意

这些运算是根据操作数的数据类型来计算的,比如 9和4都是int类型,所以9/4结果是2。
如果想要两个整数相除得到小数，就需要将整数转换成小数。如9.0/2.0=4.5 。
这也就代表如果运算结果比数据类型所能容纳的范围要大的话，就会出现溢出。例如： 1加上一个整数 int类型 32,767 结果变成-32,768。
如果操作数是不同类型的,结果是“更大”的那种数据类型。如果操作数中的其中一个是 float类型或者double类型, 就变成了浮点数运算。
取整除运算将会返回商的整数部分，向下取整。

8.2 参数¶

赋值运算符左边的参数为变量，右边的参数可以为常亮或者变量。

9.近似运算¶

9.1 取整（四舍五入）(round)¶

9.1.1 描述¶

返回给定值的四舍五入取整值。

9.1.2 参数¶

数值或变量。

9.1.3 返回值¶

参数的四舍五入取整值

提示

如：round(4.1)=4;round(5.6)=6。

9.2 取整（取上限）(ceil)¶

9.2.1 描述¶

返回给定值的下一个整数，如果输入的本身就是整数，则返回自身。

9.2.3 参数¶

数值或变量。

9.2.4 返回值¶

参数的下一个整数或自身。

提示

如：ceil(4.1)=5;ceil(5.6)=6,ceil(7)=7。

9.3 取整（取下限）(floor)¶

9.3.1 描述¶

返回给定值的前一个整数，如果输入的本身就是整数，则返回自身。

9.3.2 参数¶

数值或变量。

9.3.3 返回值¶

参数的前一个整数或自身。

提示

如：floor(4.1)=4;floor(5.6)=5,floor(7)=7。

10.取绝对值(fabs)¶

10.1 描述¶

返回给定值的绝对值。

10.2 参数¶

数值或变量。

10.3 返回值¶

参数的绝对值。

提示

如：fabs(0)=0;fabs(-5)=5,fabs(7)=7。

11.平方根(sqrt)¶

11.1 描述¶

返回给定值的正平方根。

11.2 参数¶

数值或变量。

11.3 返回值¶

给定值的正平方根。

提示

如 sqrt(4)=2;sqrt(25)=5。

12.取最大/小值(min/max)¶

12.1 描述¶

返回两个数值或变量中最大或最小值。

12.2 参数¶

数值或者变量

12.3 返回值¶

最大值或最小值

13.初始化随机数(randint)¶

13.1 描述¶

在给定的范围中返回随机的整数或小数。

注意

返回的随机数在前一个参数和后一个参数之间，包含两个参数。

14.进制转换¶

14.1 描述¶

将指定进制的参数转换为另一指定进制。

14.2 参数¶

变量或常量

14.3 返回¶

变量或常量其他进制的值

15.约束(constrain)¶

15.1 描述¶

约束是将数值限制在最小值与最大值之间，所有小于最小值的数值被赋值为最小值，同理，所有大于最大值的数被赋值为最大值。

15.2 参数¶

参数一：要被约束的数字，所有的数据类型适用。

参数二：该范围的最小值，所有的数据类型适用。

参数三：该范围的最大值，所有的数据类型适用。

15.3 返回值¶

如果参数一介于参数二和参数三之间，返回参数一；

如果参数一大于参数三，返回参数三；

如果参数一小于参数二，返回参数二；

16.映射(map)¶

提示

映射指两个元素的集之间元素相互“对应”的关系。

就像把一张地图幻灯片（尺寸255）投影到大屏幕上（尺寸1023）一样，虽然两者尺寸大小不同，但不改变地图内部的比例和相对位置。

两者之间数据形成一一对应的关系。

16.1 描述¶

映射运算将参数值在前一个元素集中的位置按照两个元素集的映射方式，得出在后一个元素集中对应位置的值。

16.2 参数¶

参数一：需要求映射的值；

参数二和参数三：映射的起始元素集范围；

参数四和参数五：映射的终点元素范围。

16.3 返回值¶

返回参数一从起始元素集映射到终点元素集的值。

    def mixly_mapping(v, al, ah, bl, bh):
            return bl +  (bh - bl) * (v - al) / (ah - al)  //Mixly中的映射函数

    mixly_mapping(50, 0, 100, 0, 1000)    //调用映射函数，返回值为500.0

提示

参考上述代码举例，可以了解到：起始集合为[0,100]，终点集合为[0,1000]，两个集合的右边界减去左边界，再用终点集合的边界差除以起始集合的边界差，得到10，即起始集合到终点集合的映射为放大10倍。

参数一50在起始集合中的位置位于左边界加50，则在终点集合中的位置应当位于左边界加500，而经过乘除运算后数据类型变为float，所以上述举例中的返回值为500.0。

请再结合以下举例理解映射运算。

    mixly_mapping(65, 50, 100, 50, 1000)    //调用映射函数，返回值为335.0

    mixly_mapping(35, 50, 100, 50, 1000)    //调用映射函数，返回值为-235.0

    mixly_mapping(50, 0, 1000, 0, 100)    //调用映射函数，返回值为5.0

    mixly_mapping(60, 50, 80, 56, 74)    //调用映射函数，返回值为62.0

逻辑¶

注解

逻辑模块中的指令大多是逻辑运算处理内容，具体可分为：比较运算、范围判断、逻辑运算、代表非、真、假、空的块、？运算、列表存在判断和列表相等判断。

1.比较运算符¶

注解

在Python中，比较运算符是用于比较两个对象的运算符号，结果是一个Boolean逻辑值，为True或者False。

1.1 等于(=)¶

1.1.1 描述¶

等于符号用两个对象之间的比较，判断符号两侧的对象的数据值和数据类型是否相等。

1.1.2 规则¶

如果两个数据值相等，且数据类型相同，则结果为True，否则结果为False。

注意

Python中的对象有三个属性：

1.id:身份标识，是对象在内存中的地址，python中用函数id(x)返回对象 x 在内存中的地址

2.type:数据类型，python中用函数type(x)返回对象 x 的数据类型

3.value:值
Python中，比较运算符除”==”外还有”is”，他们的区别是：

“==” 是对两个对象的 value 和 type 进行比较，比较两个对象的值和数据类型是否相等

“is” 是对两个对象的 id 进行比较，比较两个对象的内存地址是否相等
Mixly中比较运算符模块中的”=”，使用的是Python中的”==”，可以从代码中查看：

1.1.3 示例¶

返回结果：
True
False
False

1.2 不等于(≠)¶

1.2.1 描述¶

不等于符号使用方法与等于符号相同，返回与等于符号相反的结果。

1.2.2 规则¶

符号两边的对象值和数据类型相等时，结果False，否则结果为True。

1.2.3 示例¶

返回结果：
False
True
True

1.3 小于(＜)¶

1.3.1 描述¶

小于符号进行大小比较。

1.3.2 规则¶

如果符号左边的数值小于右边的数值，则返回True，否则返回False。

注意

在MicroPython中，只有number类型的值（int, float, complex, boolean）可以进行大小比较。

1.3.3 示例¶

返回结果：

False
True
False
True
False

注意

在实际的比较中，布尔值True等价于int值1，布尔值False等价于int值0。

1.4 小于等于(≤)¶

1.4.1 描述¶

小于等于符号与小于符号类似。

1.4.2 规则¶

如果符号左边的数值小于等于右边的数值，则返回True，否则返回False。

1.5 大于(>)¶

1.5.1 描述¶

大于符号进行大小比较。

1.5.2 规则¶

如果符号左边的数值大于右边的数值，则返回True，否则返回False。

1.6 大于等于(≥)¶

1.6.1 描述¶

大于等于符号与大于符号类似。

1.6.2 规则¶

如果符号左边的数值大于等于右边的数值，则返回True，否则返回False。

2.范围判断¶

2.1 描述¶

如果中间项同时满足左右两个不等式，则返回True，否则返回False。

2.2 示例¶

返回结果：
True
False
False
True

3.逻辑运算符¶

3.1 且¶

3.1.1 描述¶

且（and）运算符两边为对象或者逻辑表达式，只有当符号两边的表达式结果均为真时，结果才为真，否则为假。

3.1.2 示例¶

返回结果：
True
False

3.2 或¶

3.2.1 描述¶

或（or）运算符两边为对象或者逻辑表达式，只有当符号两边的表达式结果均为假时，结果才为为假，否则为真。

3.2.2 示例¶

返回结果：
True
False

4.否定运算符¶

4.1 描述¶

否定运算符（非）(not)用于对象或表达式前面，结果与原对象或表达式逻辑值相反。即原逻辑值为True，则结果为False；若原逻辑值为False，则结果为True。

4.2 示例¶

返回结果：
True
True
False

5.逻辑值¶

5.1 描述¶

MicroPython中的逻辑值包含真(True)，假(False)。逻辑值可以直接参与逻辑运算，得出的运算结果也是逻辑值。

5.2 示例¶

返回结果：
False
True
False

6.空值(None)¶

6.1 描述¶

None是一个特殊的常量。

None和False不同。

None不是0。

None不是空字符串。

None和任何其他的数据类型比较永远返回False。

6.2 示例¶

返回结果：

True
False
False
False
False
False

7. ？：模块¶

7.1 描述¶

对于条件表达式模块 a ? x : y，先计算条件 a 的逻辑结果，然后进行判断。如果 a 的值为True，则计算表达式 x 的值，模块的值即为 x 的值；否则，计算表达式 y 的值，模块的值即为 y 的值。

7.2 参数¶

a: 判断条件，先计算判断条件的值

x: 当判断条件的值为True，模块的值即为x的值

y: 当判断条件的值为False，模块的值即为y的值

提示

一个条件表达式不会既计算 x ，又计算 y 。
条件运算符是右结合的，也就是说，从右向左分组计算。例如，a ? b : c ? d : e 将按 a ? b : (c ? d : e) 执行。

实际上，MicroPython中没有 ? : 语句，这实际上是通过 if 条件语句实现的。

7.3 示例¶

这一段代码可以在 a 和 b 中选择出较大数字。

返回结果：
5

8.元素存在判断¶

8.1 参数¶

元素：可以是各种常量和变量对象，包括数列。

数列：需要被判断是否存在某元素的数列；是多维数列时要求前一参数是对应维度的数列。

此模块的值为逻辑值，当参数元素存在于数列中时，此模块值为True；当参数元素不存在于数列中时，此模块值为False。

8.2 示例¶

返回结果：
True
False

9.数列相等判断¶

9.1 描述¶

此模块的两个参数均为数列对象，模块的值为逻辑值，当前后两数列相等时，此模块值为True；当前后两数列不相等时，此模块值为False。

注意

此模块使用的是”is”进行相等判断。还记得之前讲过的Python对象的三个属性和”==”与”is”判断的区别吗？
Python中的对象有三个属性：

1.id:身份标识，是对象在内存中的地址，python中用函数id(x)返回对象 x 在内存中的地址

2.type:数据类型，python中用函数type(x)返回对象 x 的数据类型

3.value:值
Python中，比较运算符除”==”外还有”is”，他们的区别是：

“==” 是对两个对象的 value 和 type 进行比较，比较两个对象的值和数据类型是否相等

“is” 是对两个对象的 id 进行比较，比较两个对象的内存地址是否相等
所以此模块判断的也是判断前后两个数列的内存地址是否相等，请结合一下示例进一步了解。

9.2 示例¶

返回结果：
False
True

文本¶

注解

文本分类下的模块主要包含文本输出、文本处理和字符串内容检索等功能。具体包括：文本连接、文本转换、获取长度、格式化字符串等。

所有文本内容都可通过串口打印或外接显示屏输出。

1.字符串¶

1.1 描述¶

Mixly中包含单行文本和多行文本。单行文本内容可以是一个字符、单词也可以是一行文本。多行文本内容会保留输入的换行。

1.2 示例¶

Python中的单行文本由双引号或者单引号包围，多行文本由连续使用的三个单引号包围。
1
2
3
"Mixly"
'''Hello
Mixly'''

2.字符串连接¶

2.1 描述¶

字符串连接模块可以连接单行文本和多行文本，也可以嵌套使用。此模块在连接的文本之间不会添加任何分隔符号。

2.2 示例¶

你也可以在单行文本或者多行文本中使用转义字符 “\n” 来进行换行。

源代码：

print("Hello" + "Mixly\n")
print("Hello\n" + "Mixly\n")
print("Hello" + "Mixly" + "Love" + "Mixly\n")
print("Hello" + '''Mixly
1.0\n''')
print('''Hello
World''' + "Mixly\n")
print('''Hello
World\n''' + "Mixly\n")

输出结果：

HelloMixly

Hello
Mixly

HelloMixlyLoveMixly

HelloMixly
1.0

Hello
WorldMixly

Hello
World
Mixly

3.字符串转换¶

3.1 字符串转换为其他类型¶

3.1.1 描述¶

此模块可以将字符串转换为小数、整数和字节。转为字节实际上是使用utf-8来对字符串进行编码。

注意

如果字符串的内容不是数字，则使用此模块将其转换为数字会报错。

3.1.2 示例¶

源代码：

a = "123"
b = "1.23"
c = "Mixly"
print(int(a))
print(float(b))
print(a.encode("utf-8"))
print(b.encode("utf-8"))
print(c.encode("utf-8"))

输出结果：

123
1.23
b'123'
b'1.23'
b'Mixly'

3.2 数字转换为字符串¶

3.2.1 描述¶

此模块可以将数字转换为字符串。

3.2.2 示例¶

源代码：

a = 123
b = 1.23
print(str(a))
print(str(b))
print(str(100))

输出结果：

123
1.23
100

3.3 转ASCII字符¶

3.3.1 描述¶

此模块可以返回一个ASCII编码对应的文本符号。

3.3.2 示例¶

源代码：
1
2
print(chr(38))
print(chr(65))
输出结果：
&
A

提示

ASCII码表:

3.4 转ASCII数值¶

3.4.1 描述¶

此模块可以返回一个字符对应的ASCII编码。

3.4.2 示例¶

源代码：
1
2
print(ord("&"))
print(ord("A"))
输出结果：
38
65

4.获取字符串长度¶

4.1 描述¶

此模块可以返回一个字符串的长度或者列表、元组、集合的元素数量。对于字符串，一个英文字母、一个符号（比如空格）、一个汉字长度均为1。

4.2 返回值¶

此模块返回的长度为int类型的数据格式。

4.3 示例¶

源代码：

print(len("Mixly"))
print(len("北京师范大学米思齐团队"))
print(len("I Love Mixly!"))
print(len([1,2,3]))
print(len((1,2,3,4)))
print(len({1,2,3,4,5}))

输出结果：

5.字符串判断¶

5.1 描述¶

此模块可以判断前后两个字符串是否相等，也可以判断某字符串是否以某字符或字符串开始或结尾。若相等或以指定字符串开始或结尾，则返回True，否则返回False。

注意

此模块的判断都是严格区分大小写的。
可以判断某字符串是否以另一字符串开始或结尾。

5.2 示例¶

源代码：

print("Mixly" == "Mixly")
print("Mixly" == "mixly")
print("米思齐" == "米思皮")
print("Mixly".startswith("m"))
print("Mixly".endswith("y"))
print("Mixly".endswith("ly"))

输出结果：

True
False
False
False
True
True

6.字符串截取¶

6.1 根据索引截取字符¶

6.1.1 描述¶

此模块可以在字符串中根据索引返回对应的字符。

注意

点击了解附录：字符串索引方向。
在字符串中截取字符，索引的范围为字符串长度的相反数到字符串的长度减1，如五个字符的字符串索引范围为[-5, 4]，超出此范围的索引会报错。

6.1.2 示例¶

源代码：

print("Mixly"[0])
print("Mixly"[2])
print("Mixly"[4])
print("Mixly"[(-5)])
print("Mixly"[(-3)])
print("Mixly"[(-1)])

输出结果：

M
x
y
M
x
y

6.2 根据索引范围截取字符串¶

6.2.1 描述¶

此模块可以在字符串中根据索引返回对应的字符串。

注意

所截取出的字符串中，包含前一个索引对应的字符，但不包含后一个索引对应的字符。
点击了解附录：字符串索引方向。
在字符串中截取字符串，索引的范围为字符串长度的相反数到字符串的长度（因为不包含后一索引对应的字符，所以不用减1），如五个字符的字符串索引范围为[-5, 5]，超出此范围的索引会报错。

6.2.2 示例¶

源代码：

str = "北京师范大学米思齐团队"
print(str[0 : 6])       #截取第一个到第六个字符
print(str[-5 : -1])     #截取倒数第五个到倒数第二个字符

输出结果：

北京师范大学
米思齐团

6.3 截取随机字符¶

6.3.1 描述¶

此模块将返回给定字符串中随机的一个字符。

6.3.2 示例¶

源代码：
1
2
3
4
import random
print(random.choice("Mixly"))
print(random.choice("Mixly"))
print(random.choice("Mixly"))
输出结果（每次输出结果是随机的）：
l
M
y

7.字符串编/解码¶

7.1 描述¶

此模块可以对指定字符串进行指定类型的编码和解码，并返回编码和解码的结果。

注意

使用错误的类型进行解码可能会获得乱码，或者报错。

7.2 示例¶

_images/string_decode_encode_example.png

源代码：

print("Mixly".encode("ASCII"))
print("Mixly".encode("ASCII").decode("ASCII"))
print("米思齐".encode("utf-8"))
print("米思齐".encode("utf-8").decode("utf-8"))
print("米思齐".encode("gbk"))
print("米思齐".encode("gbk").decode("gbk"))

输出结果：

b'Mixly'
Mixly
b'\xe7\xb1\xb3\xe6\x80\x9d\xe9\xbd\x90'
米思齐
b'\xc3\xd7\xcb\xbc\xc6\xeb'
米思齐

提示

了解更多关于字符编码的知识：

8.字符串内容转换¶

8.1 描述¶

此模块可以对指定字符串进行指定类型的转换。转换类型包括将各单词首字母转换为大写，将句子首字母转换为大写，将字符串中所有字母的大小写对调，以及将所有字母转换为小写字母。

注意

将各单词首字母转换为大写功能需要各个单词间有分隔符（空格，逗号均可），若没有分隔符则视为同一个单词。
将句子首字母转换为大写实际上是将整个字符串第一个字母转换为大写，后面的句子并不会转换。

8.2 示例¶

源代码：

print("hello mixly!".title())
print("hello mixly! i love mixly!".capitalize())
print("hello mixly!".title().swapcase())
print("hello mixly!".title().swapcase().lower())

输出结果：

Hello Mixly!
Hello mixly! i love mixly!
hELLO mIXLY!
hello mixly!

9.字符串填充对齐¶

9.1 描述¶

此模块可以在指定宽度中对字符串进行左对齐、居中和右对齐，并使用指定的符号填充空白部分。

注意

指定的符号可以为空格，但不可以为空，否则会报错。

9.2 示例¶

源代码：

print("Hello,mixly".ljust(50,"*"))
print("I love mixly!".center(50,"*"))
print("Happy mixly!".rjust(50,"*"))
print("Hello,mixly".ljust(50," "))
print("I love mixly!".center(50," "))
print("Happy mixly!".rjust(50," "))

输出结果：

Hello,mixly***************************************
******************I love mixly!*******************
**************************************Happy mixly!
Hello,mixly
                  I love mixly!
                                      Happy mixly!

10.字符串搜索¶

10.1 描述¶

此模块可以检查字符串中是否包含指定字符或者字符串，如果包含则返回字符或字符串首字符的索引值，否则返回-1。

注意

如果有多个检索结果，则返回第一个检索结果的索引。
字符串各个字符的索引从0开始，也就是说第一个字符的索引为0，第九个字符的索引为8，以此类推。
可以在字符串中检索字符和字符串。
检索时是严格匹配大小写的。

10.2 示例¶

源代码：

print("Hello,mixly".find("l"))
print("Hello,mixly".find("ll"))
print("Hello,mixly".find("mix"))
print("Hello,mixly".find("h"))

输出结果：

11.序列连接成字符串¶

11.1 描述¶

此模块可以使用指定的连接字符或字符串将序列（列表、元组、集合等）的各个元素连接起来形成并返回一个字符串。

注意

需要连接的序列（列表、元组、集合等）的每一个元素必须是字符串的数据类型。
集合（{}）是无序序列，所以每次对集合进行连接返回的字符串是随机的。

11.2 示例¶

源代码：

print(" ".join(["Beijing", "Normal", "University"]))
print("-".join(("Mixly", "Mixpy", "MixGo")))
print("--".join({"Mixly", "Mixpy", "MixGo"}))

输出结果：

Beijing Normal University
Mixly-Mixpy-MixGo
MixGo--Mixly--Mixpy     # 此项由于是连接集合，所以每一次输出的结果是随机的

12.字符串内容替换¶

12.1 描述¶

此模块可以将字符串中的某一字符串替换为另一字符串，返回替换后的字符串。

注意

此模块的替换操作并不会改变原字符串。
此模块在替换时会替换所有符合条件的字符串。

12.2 示例¶

源代码：

str = "Hello,mixly"
print(str.replace("mixly","mixpy"))
print(str)
print("北京师范大学米思齐团队".replace("米思齐","Mixly"))
print("Hello,mixly".replace("l","A"))

输出结果：

Hello,mixpy
Hello,mixly
北京师范大学Mixly团队
HeAAo,mixAy

13.字符串分割¶

13.1 描述¶

此模块通过指定分隔符对字符串进行分割（切片），返回一个列表。

注意

分隔符将会被删除，不会存在于结果列表中。
分隔符是严格区分大小写的。

13.2 示例¶

源代码：

print("I love mixly!".split(" "))
print("Hello mixly!".split("l"))
print("Hello mixly!".split("L"))
print("北京师范大学米思齐团队".split("米思"))

输出结果：

['I', 'love', 'mixly!']
['He', '', 'o mix', 'y!']
['Hello mixly!']
['北京师范大学', '齐团队']

14.字符串消除空格¶

14.1 描述¶

此模块可以消除字符串两侧或者单独删除左、右侧的空格，返回处理后的字符串。

14.2 示例¶

源代码：

print(" I love mixly ".strip())
print(" I love mixly ".lstrip())
print(" I love mixly ".rstrip())

输出结果：

I love mixly
I love mixly
 I love mixly

15.字符串格式化¶

15.1 描述¶

此模块可以在字符串中格式化传递参数。需要传递参数的地方使用”{}”标记，你可以点击模块上的蓝色齿轮添加多个参数。

注意

传递的参数可以是各种数据类型。
后面参数排列的顺序对应”{}”标记的顺序。

15.2 示例¶

源代码：

import random
place = ["北京", "重庆", "广东", "浙江", "福建"]
MixGroup = ["Mixly", "Mixpy", "MixGo"]
print("Random No. is {}".format(random.randint(1, 100)))
print("我在{}，我爱{}！".format(random.choice(place), random.choice(MixGroup)))

输出结果：

Random No. is 62
我在重庆，我爱Mixly！

16.字符串表达式执行¶

16.1 描述¶

此模块可以执行一个字符串表达式，并返回表达式的值。

注意

表达式指的是加减乘除、数学函数运算、逻辑运算等

16.2 示例¶

源代码：

a = True
b = False
c = 3
d = 5
print(eval("1+1"))
print(eval("pow(2,2)"))     # 2的2次方
print(eval("int('1') * 3"))
print(eval("a and b"))
print(eval("c * d"))
print(eval("d > c"))

输出结果：

2
4
3
False
15
True

附录：字符串索引方向¶

注意

有正反两种索引方式。
正向索引中，字符串各个字符的索引从0开始，也就是说第一个字符的索引为0，第九个字符的索引为8，以此类推。
反向索引中，字符串各个字符的索引从字符串长度的相反数开始，也就是说，对于一个长度为5的字符串，第一个（倒数第五个）字符的索引为-5，倒数第一个（最后一个）字符的索引为-1，倒数第二个字符的索引为-2，以此类推。
阅读完毕后，在浏览器中后退可回到之前的浏览位置。

注解

序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字——它的位置，也称为索引：第一个索引是0，第二个索引是1，依此类推。

Python有多种内置的序列类型，但最常见的是列表、元组、字典和集合。

序列都可以进行的操作包括索引，切片，加，乘，检查成员等。

此外，Python已经内置确定序列的长度以及确定最大和最小的元素等方法。

列表¶

注解

列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。

列表的数据项不需要具有相同的数据类型。

Mixly中有很多用于列表操作的模块，如下：

1.列表初始化¶

1.1 描述¶

Mixly中有两种初始化列表的方式：

第一种，你需要输入列表名称，将代表各种数据的模块连接到初始化模块上，你也可以点击蓝色齿轮增加元素数量。

第二种，你也需要输入列表名称，然后直接在方括号中输入各种数据，各个元素使用英文逗号分隔即可。

在使用列表初始化模块后，你可以在”变量”模块分类中根据你输入的列表名称找到代表此列表的模块。

注意

列表的各个元素类型不要求相同，可以是数字、布尔值和字符串，也可以是另一个列表。
列表中的字符串元素都是由引号包围的，若其他数据类型使用引号包围也将会被视为字符串类型。

1.2 示例¶

源代码：

mylist = ["Mixly", 1.0, True, [1,2,3,4,5]]
print(mylist)

输出结果：

['Mixly', 1.0, True, [1, 2, 3, 4, 5]]

2.列表元素获取¶

2.1根据索引获取元素¶

2.1.1 描述¶

此模块可以在列表中根据索引返回对应的元素。

注意

字符串其实也是一种序列，所以列表获取元素和字符串截取字符是同理的。
点击查看附录1：序列索引方向。
在列表中获取单个元素，索引的范围为列表元素数量的相反数到列表元素数量减1，如五个元素的列表索引范围为[-5, 4]，超出此范围的索引会报错。

2.1.2 示例¶

_images/list_get_element_by_index_example.png

源代码：

mylist = ["Mixly", "Mixpy", "MixGo", "Mixly Group"]
print(mylist[0])
print(mylist[2])

输出结果：

Mixly
MixGo

2.2 根据索引范围获取多个元素¶

2.2.1 描述¶

此模块可以在列表中根据索引返回对应的多个元素组成的子列表。

注意

所截取出的子列表中，包含前一个索引对应的元素，但不包含后一个索引对应的元素。
点击查看附录1：序列索引方向。
在列表中获取多个元素，索引的范围为列表元素数量的相反数到列表元素数量（因为不包含后一索引对应的元素，所以不用减1），如五个元素的列表索引范围为[-5, 5]，超出此范围的索引会报错。

2.2.2 示例¶

_images/list_get_elements_by_index_example.png

源代码：

mylist = ["Mixly", "Mixpy", "MixGo", "Mixly Group"]
print(mylist[0 : 2])
print(mylist[2 : 4])

输出结果：

['Mixly', 'Mixpy']
['MixGo', 'Mixly Group']

2.3 随机获取元素¶

2.3.1 描述¶

此模块将返回给定列表中随机的一个元素。

2.3.2 示例¶

_images/list_get_random_element_example.png

源代码：

import random
mylist = ["Mixly", "Mixpy", "MixGo", "Mixly Group"]
print(random.choice(mylist))
print(random.choice(mylist))
print(random.choice(mylist))

输出结果（每次输出结果是随机的）：

MixGo
Mixly Group
Mixpy

3.获取列表信息¶

3.1 描述¶

此模块可以返回一个列表的长度（元素数量）。还可以返回数字列表的总和、最大值、最小值、平均数、中位数、众数和标准差。

注意

此模块返回的长度为int类型的数据格式。
此模块只能返回数字列表的总和、最大值、最小值、平均数、中位数、众数和标准差，若列表中包含其他数据类型的元素，则会报错。
此模块返回的平均数和标准差因为经过除法运算，所以返回的是float类型的数据格式。
当给定的数字列表中有多个众数时，将会返回由这多个众数组成的列表。
由于Mixly中此模块使用的math包中不包含计算平均数、中位数、众数和标准差的方法，所以会定义计算这几种数据的方法并调用。

3.2 示例¶

源代码：

import math
def math_standard_deviation(numbers):       # 定义计算标准差的方法
    n = len(numbers)
    if n == 0: return
    mean = float(sum(numbers)) / n
    variance = sum((x - mean) ** 2 for x in numbers) / n
    return math.sqrt(variance)
def math_modes(some_list):      # 定义计算众数的方法
    modes = []
    counts = []
    maxCount = 1
    for item in some_list:
        found = False
        for count in counts:
            if count[0] == item:
                count[1] += 1
                maxCount = max(maxCount, count[1])
                found = True
        if not found:
            counts.append([item, 1])
    for counted_item, item_count in counts:
        if item_count == maxCount:
            modes.append(counted_item)
    return modes
def math_median(myList):    # 定义计算中位数的方法
    localList = sorted([e for e in myList if type(e) == int or type(e) == float])
    if not localList: return
    if len(localList) % 2 == 0:
        return (localList[len(localList) // 2 - 1] + localList[len(localList) // 2]) / 2.0
    else:
        return localList[(len(localList) - 1) // 2]
def math_mean(myList):      # 定义计算平均数的方法
    localList = [e for e in myList if type(e) == int or type(e) == float]
    if not localList: return
    return float(sum(localList)) / len(localList)


num_list = [1,3,5,7,9]
str_list = ["Mixly", "Mixpy", "MixGo", "Mixly Group"]
print(len(str_list))
print(len(num_list))
print(sum(num_list))
print(max(num_list))
print(min(num_list))
print(math_mean(num_list))
print(math_median(num_list))
print(math_modes(num_list))
print(math_standard_deviation(num_list))

输出结果：

4
5
25
9
1
5.0
5
[1, 3, 5, 7, 9]
2.8284271247461903

4.列表元素查询¶

4.1 描述¶

此模块可以在给定的列表中查询某个值，选择”位置”将返回第一个匹配元素的索引，选择”个数”将返回匹配元素的数量。

注意

查询的值可以是任意的数据类型
在查询匹配元素的索引时，若列表中无匹配元素，则会报错。
在查询匹配元素的数量时，若列表中无匹配元素，则会返回0。

4.2 示例¶

源代码：

num_list = [1,2,2,2,3,3,4,5]
str_list = ["MixGo", "米思齐", "米思齐", "米思齐", "Mixpy", "北京师范大学"]
print(num_list.index(3))
print(num_list.count(2))
print(str_list.count("米思齐"))

输出结果：

4
3
3

5.列表元素赋值¶

5.1 描述¶

此模块可以在给定的列表中根据索引为对应的元素赋值。

注意

此模块没有返回值。
索引必须在列表长度范围内，否则会报错。

5.2 示例¶

源代码：

mylist = [1,2,3,4,5]
mylist[2] = "Mixly"
print(mylist)

输出结果：

[1, 2, 'Mixly', 4, 5]

6.列表插入元素¶

6.1 描述¶

此模块可以在给定的列表中给定的索引位置插入元素。

注意

此模块没有返回值。
插入元素之后的所有元素将会依次往后移动一个位置。
若插入时给定的索引超出了原列表的长度，则会默认添加到列表的末尾。
给定的索引可以为负值，规则参考附录1：序列索引方向。

6.2 示例¶

源代码：

mylist = [1,2,3,4,5]
mylist.insert(1, "目的索引为1")
mylist.insert(10, "目的索引为10")
mylist.insert(-3, "目的索引为-3")
print(mylist)

输出结果：

[1, '目的索引为1', 2, 3, '目的索引为-3', 4, 5, '目的索引为10']

7.列表添加元素¶

7.1 描述¶

此模块可以在给定的列表后添加一个或者一组元素。

“增加”会将添加的对象视为一个元素，”扩展增加”会将添加的对象视为一个序列，将序列的元素分别添加到给定列表的末尾。

注意

此模块没有返回值。
增加使用的是append()方法，会将参数视为一个元素添加到末尾。
扩展增加使用的是extend()方法，参数必须是序列（包括列表、元组、集合、字符串等）对象，如果是非序列对象，则会报错。

7.2 示例¶

源代码：

mylist = [1,2,3,4,5]
mylist.append("Mixly")
print(mylist)
mylist = [1,2,3,4,5]
mylist.extend("Mixly")
print(mylist)
mylist = [1,2,3,4,5]
mylist.append([1,2,3,4,5])
print(mylist)
mylist = [1,2,3,4,5]
mylist.extend([1,2,3,4,5])
print(mylist)

输出结果：

[1, 2, 3, 4, 5, 'Mixly']        # 在序列后增加"Mixly"
[1, 2, 3, 4, 5, 'M', 'i', 'x', 'l', 'y']        # 在序列后扩展增加"Mixly"
[1, 2, 3, 4, 5, [1, 2, 3, 4, 5]]        # 在序列后增加[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5, 1, 2, 3, 4, 5]      # 在序列后扩展增加[1, 2, 3, 4, 5]

8.列表删除元素¶

8.1 描述¶

此模块可以在给定的列表中删除给定索引位置或者给定值的元素。

注意

此模块没有返回值。
根据给定的值删除元素只会删除列表中匹配的第一个元素。
给定索引位置超出列表长度以及给定值在列表中无匹配元素都会触发报错。
给定的索引可以为负值，规则参考附录1：序列索引方向。

8.2 示例¶

源代码：

mylist = [1,2,3,4,5]
del mylist[2]
print(mylist)
mylist = [1,2,3,4,5]
mylist.remove(3)
print(mylist)
mylist = [1,2,2,2,5]
mylist.remove(2)
print(mylist)

输出结果：

[1, 2, 4, 5]
[1, 2, 4, 5]
[1, 2, 2, 5]

9.列表删除并获取元素¶

9.1 描述¶

此模块可以在给定的列表中删除给定索引位置的元素，并返回被删除的元素值。

注意

给定的索引可以为负值，规则参考附录1：序列索引方向。

9.2 示例¶

源代码：

mylist = [1,2,3,4,5]
print(mylist.pop(-2))
print(mylist)

输出结果：

4
[1, 2, 3, 5]

10.列表元素排序¶

10.1 描述¶

此模块可以将给定的列表按照数字或首字母进行升序或者降序排列，并返回排好序的列表。

注意

Mixly中定义了新的方法来对列表进行排序。
此模块并不会改变原序列元素的顺序。
此模块可以将各种数字类型的元素混合排列。
此模块按照首字母区分大小写排列会分别对大写和小写进行给定顺序排列，且小写总在大写后，即升序排列小写在大写后，降序排列小写在大写前。
此模块还可以对同时含有数字和字符串的列表进行排序。若按照数字排序，则只会对列表内的数字排序，字符串会按照原来的顺序，在所有数字后；若按照字母排序，则同时会对数字和字符串进行排序，对字符串的排序规则与上一条相同，且所有字符串在所有数字后。
此模块还可以对多维列表进行排序，由于很少使用，感兴趣的读者可以自行探究，也可以直接探究Mixly中排序方法的定义。

10.2 示例¶

源代码：

def lists_sort(my_list, type, reverse):
    def try_float(s):
        try:
            return float(s)
        except:
            return 0
    key_funcs = {
        "NUMERIC": try_float,
        "TEXT": str,
        "IGNORE_CASE": lambda s: str(s).lower()
    }
    key_func = key_funcs[type]
    list_cpy = list(my_list)
    return sorted(list_cpy, key=key_func, reverse=reverse)


num_list = [1.2,2.5,3,4.3,6.1]
str_list = ["Aplle", "apple", "Cat", "Dog", "fox"]
mix_list = ["book", 2.5,1.2,3,5.2,"Door",4.3,"cat"]
print(lists_sort(num_list, "NUMERIC", True))
print(num_list)
print(lists_sort(str_list, "TEXT", False))
print(lists_sort(str_list, "TEXT", True))
print(lists_sort(str_list, "IGNORE_CASE", True))
print(str_list)
print(lists_sort(mix_list, "NUMERIC", True))
print(lists_sort(mix_list, "TEXT", False))
print(lists_sort(mix_list, "IGNORE_CASE", False))
print(mix_list)

输出结果：

[6.1, 4.3, 3, 2.5, 1.2]     # 按照数字降序排列
[1.2, 2.5, 3, 4.3, 6.1]     # 原列表
['Aplle', 'Cat', 'Dog', 'apple', 'fox']     # 按照首字母升序排列，区分大小写
['fox', 'apple', 'Dog', 'Cat', 'Aplle']     # 按照首字母降序排列，区分大小写
['fox', 'Dog', 'Cat', 'apple', 'Aplle']     # 按照首字母降序排列，忽略大小写
['Aplle', 'apple', 'Cat', 'Dog', 'fox']     # 原列表
[5.2, 4.3, 3, 2.5, 1.2, 'book', 'Door', 'cat']      # 按照数字降序排列
[1.2, 2.5, 3, 4.3, 5.2, 'Door', 'book', 'cat']      # 按照首字母升序排列，区分大小写
[1.2, 2.5, 3, 4.3, 5.2, 'book', 'cat', 'Door']      # 按照首字母升序排列，忽略大小写
['book', 2.5, 1.2, 3, 5.2, 'Door', 4.3, 'cat']      # 原列表

11.列表逆序¶

11.1 描述¶

此模块可以将给定的列表反向。

注意

此模块没有返回值。
此模块会改变原列表的顺序。

11.2 示例¶

源代码：

mylist = [1,2,3,4,5]
mylist.reverse()
print(mylist)
mylist = ["Mixly", "Mixpy", "MixGo", "Mixly Group"]
mylist.reverse()
print(mylist)

输出结果：

[5, 4, 3, 2, 1]
['Mixly Group', 'MixGo', 'Mixpy', 'Mixly']

12.列表清空¶

12.1 描述¶

此模块可以清空给定列表的元素。

注意

列表被清空后，只是变成了不包含元素的空列表，此列表对象仍然存在，可以使用列表名调用。
此模块没有返回值。

12.2 示例¶

源代码：

mylist = ["Mixly", "Mixpy", "MixGo", "Mixly Group"]
mylist.clear()
print(mylist)

输出结果：

[]

13.列表转换¶

13.1 描述¶

此模块可以将给定列表转换为元组或集合并返回。

13.2 示例¶

源代码：

mylist = ["Mixly", "Mixpy", "MixGo", "Mixly Group"]
print(tuple(mylist))
print(set(mylist))

输出结果：

('Mixly', 'Mixpy', 'MixGo', 'Mixly Group')
{'Mixly Group', 'Mixpy', 'MixGo', 'Mixly'}      # 因为集合是无序序列，所以每一次输出是随机的

14.列表迭代打包¶

14.1 描述¶

此模块可以将给定的迭代列表中的对应元素打包成一个个元组，然后返回由这一个个元组组成的对象。

注意

如果各个迭代的列表元素数量不一致，则按照元素数量最少的列表进行打包。
此模块返回的是一个对象，需要将此对象转换为想要的序列格式。
若打包迭代的列表数量超过2个，则无法转换为字典，否则会报错。

14.2 示例¶

源代码：

print(zip([0,1,2], [0,1,2,3,4]))
print(list(zip([0,1,2], [0,1,2,3,4])))

输出结果：

<zip object at 0x10c45e580>     # 返回的是一个zip对象
[(0, 0), (1, 1), (2, 2)]

示例2：

源代码：

print(zip([0,1,2,3], [0,1,2,3]))
print(list(zip([0,1,2,3], [0,1,2,3])))
print(tuple(zip([0,1,2,3], [0,1,2,3])))
print(dict(zip([0,1,2,3], [0,1,2,3])))
print(set(zip([0,1,2,3], [0,1,2,3])))
print(zip(["Name", "Age", "Country"], ["Fred", "19", "China"], ["Tom", "18", "Australia"], ["Sam", "20", "America"]))
print(list(zip(["Name", "Age", "Country"], ["Fred", "19", "China"], ["Tom", "18", "Australia"], ["Sam", "20", "America"])))
print(tuple(zip(["Name", "Age", "Country"], ["Fred", "19", "China"], ["Tom", "18", "Australia"], ["Sam", "20", "America"])))
print(set(zip(["Name", "Age", "Country"], ["Fred", "19", "China"], ["Tom", "18", "Australia"], ["Sam", "20", "America"])))

输出结果：

<zip object at 0x102e92400>     # 返回的是一个zip对象
[(0, 0), (1, 1), (2, 2), (3, 3)]
((0, 0), (1, 1), (2, 2), (3, 3))
{0: 0, 1: 1, 2: 2, 3: 3}
{(1, 1), (3, 3), (2, 2), (0, 0)}
<zip object at 0x102e92400>     # 返回的是一个zip对象
[('Name', 'Fred', 'Tom', 'Sam'), ('Age', '19', '18', '20'), ('Country', 'China', 'Australia', 'America')]
(('Name', 'Fred', 'Tom', 'Sam'), ('Age', '19', '18', '20'), ('Country', 'China', 'Australia', 'America'))
{('Country', 'China', 'Australia', 'America'), ('Age', '19', '18', '20'), ('Name', 'Fred', 'Tom', 'Sam')}

附录1：序列索引方向¶

注意

有正反两种索引方式。
正向索引中，各个元素的索引从0开始，也就是说第一个元素的索引为0，第九个元素的索引为8，以此类推。
反向索引中，各个元素的索引从列表元素数量的相反数开始，也就是说，对于一个元素数量为5的列表，第一个（倒数第五个）元素的索引为-5，倒数第一个（最后一个）元素的索引为-1，倒数第二个元素的索引为-2，以此类推。

注解

序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字——它的位置，也称为索引：第一个索引是0，第二个索引是1，依此类推。

Python有多种内置的序列类型，但最常见的是列表、元组、字典和集合。

序列都可以进行的操作包括索引，切片，加，乘，检查成员等。

此外，Python已经内置确定序列的长度以及确定最大和最小的元素等方法。

元组¶

注解

Python的元组与列表类似，不同之处在于元组的元素不能修改。

元组使用小括号，列表使用方括号。

Mixly中有很多用于元组操作的模块，如下：

1.元组初始化¶

1.1 描述¶

Mixly中有两种初始化元组的方式：

第一种，你需要输入元组名称，将代表各种数据的模块连接到初始化模块上，你也可以点击蓝色齿轮增加元素数量。

第二种，你也需要输入元组名称，然后直接在小括号中输入各种数据，各个元素使用英文逗号分隔即可。

在使用元组初始化模块后，你可以在”变量”模块分类中根据你输入的元组名称找到代表此元组的模块。

注意

元组的各个元素类型不要求相同，可以是数字、布尔值和字符串，也可以是另一个元组。
元组中的字符串元素都是由引号包围的，若其他数据类型使用引号包围也将会被视为字符串类型。

1.2 示例¶

源代码：

mytup= ("Mixly", 1.0, True, [1,2,3,4,5], (1,2,3,4,5))
print(mytup)
mytup2 = ("Mixly", 1.0, True, [1,2,3,4,5], (1,2,3,4,5))
print(mytup2)

输出结果：

('Mixly', 1.0, True, [1, 2, 3, 4, 5], (1, 2, 3, 4, 5))
('Mixly', 1.0, True, [1, 2, 3, 4, 5], (1, 2, 3, 4, 5))

2.元组元素获取¶

2.1 根据索引获取元素¶

2.1.1 描述¶

此模块可以在元组中根据索引返回对应的元素。

注意

字符串其实也是一种序列，所以元组获取元素和字符串截取字符也是同理的。
点击查看附录1：序列索引方向。
在元组中获取单个元素，索引的范围为元组元素数量的相反数到元组元素数量减1，如五个元素的元组索引范围为[-5, 4]，超出此范围的索引会报错。

2.1.2 示例¶

源代码：

输出结果：
Mixly
MixGo

2.2 根据索引范围获取多个元素¶

2.2.1 描述¶

此模块可以在元组中根据索引返回对应的多个元素组成的子元组。

注意

所截取出的子元组中，包含前一个索引对应的元素，但不包含后一个索引对应的元素。
点击查看附录1：序列索引方向。
在元组中获取多个元素，索引的范围为元组元素数量的相反数到元组元素数量（因为不包含后一索引对应的元素，所以不用减1），如五个元素的元组索引范围为[-5, 5]，超出此范围的索引会报错。

2.2.2 示例¶

_images/tuple_get_elements_by_index_example.png

源代码：

mytup = ("Mixly", "Mixpy", "MixGo", "Mixly Group")
print(mytup[0 : 2])
print(mytup[2 : 4])

输出结果：

('Mixly', 'Mixpy')
('MixGo', 'Mixly Group')

2.3 随机获取元素¶

2.3.1 描述¶

此模块将返回给定元组中随机的一个元素。

2.3.2 示例¶

_images/tuple_get_random_element_example.png

源代码：

import random
mytup = ("Mixly", "Mixpy", "MixGo", "Mixly Group")
print(random.choice(mytup))
print(random.choice(mytup))
print(random.choice(mytup))

输出结果（每次输出结果是随机的）：

Mixly Group
MixGo
Mixpy

3.获取元组信息¶

3.1 描述¶

此模块可以返回一个元组的长度（元素数量）。还可以返回数字元组的总和、最大值、最小值。

注意

此模块返回的长度为int类型的数据格式。
此模块只能返回数字元组的总和、最大值、最小值，若元组中包含其他数据类型的元素，则会报错。

3.2 示例¶

源代码：

num_tup = (1,3,5,7,9)
str_tup = ("Mixly", "Mixpy", "MixGo", "Mixly Group")
print(len(num_tup))
print(len(str_tup))
print(max(num_tup))
print(min(num_tup))
print(sum(num_tup))

输出结果：

4.删除元组¶

4.1 描述¶

此模块可以删除指定的元组。

注意

此模块没有返回值。
删除元组后，无法再使用已被删除的元组名称调用元组，否则会报错。

4.2 示例¶

源代码：

mytup = ("Mixly", "Mixpy", "MixGo", "Mixly Group")
print(mytup)
del mytup

输出结果：

('Mixly', 'Mixpy', 'MixGo', 'Mixly Group')

5.元组连接¶

5.1 描述¶

虽然我们无法对元组进行修改，但是我们可以连接元组。

此模块可以连接两个指定的元组。

注意

此模块不会对原元组进行修改。

5.2 示例¶

源代码：

num_tup = (1,3,5,7,9)
str_tup = ("Mixly", "Mixpy", "MixGo", "Mixly Group")
print(num_tup + str_tup + num_tup)
print(num_tup)
print(str_tup)

输出结果：

(1, 3, 5, 7, 9, 'Mixly', 'Mixpy', 'MixGo', 'Mixly Group', 1, 3, 5, 7, 9)
(1, 3, 5, 7, 9)
('Mixly', 'Mixpy', 'MixGo', 'Mixly Group')

6.元组转换¶

6.1 描述¶

此模块可以将给定元组转换为列表或集合并返回。

6.2 示例¶

源代码：

str_tup = ("Mixly", "Mixpy", "MixGo", "Mixly Group")
print(list(str_tup))
print(set(str_tup))
print(str_tup)

输出结果：

['Mixly', 'Mixpy', 'MixGo', 'Mixly Group']
{'Mixpy', 'MixGo', 'Mixly Group', 'Mixly'}      # 因为集合是无序序列，所以每一次输出是随机的
('Mixly', 'Mixpy', 'MixGo', 'Mixly Group')

附录1：序列索引方向¶

注意

有正反两种索引方式。
正向索引中，各个元素的索引从0开始，也就是说第一个元素的索引为0，第九个元素的索引为8，以此类推。
反向索引中，各个元素的索引从列表元素数量的相反数开始，也就是说，对于一个元素数量为5的列表，第一个（倒数第五个）元素的索引为-5，倒数第一个（最后一个）元素的索引为-1，倒数第二个元素的索引为-2，以此类推。

字典¶

注解

字典是另一种可变容器模型，且可存储任意类型对象。

字典的每个键值对(key=>value)用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中，格式如下所示：

d = {key1 : value1, key2 : value2 }

键必须是唯一的，但值则不必。

值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。

Mixly中有很多用于元组操作的模块，如下：

1.字典初始化¶

1.1 描述¶

在初始化字典时，你需要输入字典和各个键的名称，然后将代表各种数据的模块对应地连接到初始化模块上与键对应的地方，你也可以点击蓝色齿轮增加键值对数量。

在初始化字典后，你可以在”变量”模块分类中根据你输入的字典名称找到代表此字典的模块。

注意

键必须是唯一且不可变的。

1.2 示例¶

源代码：

mydict= {"Name":"Fred", "Age":18, "Country":"China", "ID":1}
print(mydict)

输出结果：

{'Name': 'Fred', 'Age': 18, 'Country': 'China', 'ID': 1}

2.字典获取所有键¶

2.1 描述¶

此模块可以返回一个字典所有的键的名称。

注意

此模块返回的是一个名叫 ‘dict_keys’ 类的对象，你可以将其转换为列表对象。

2.2 示例¶

源代码：

mydict= {"Name":"Fred", "Age":18, "Country":"China", "ID":1}
print(mydict.keys())
print(type(mydict.keys()))
print(list(mydict.keys()))

输出结果：

dict_keys(['Name', 'Age', 'Country', 'ID'])     # 'dict_keys' 类对象
<class 'dict_keys'>     # 对象的类别
['Name', 'Age', 'Country', 'ID']        # 转换为列表后

3.字典获取键值¶

3.1 描述¶

此模块可以返回字典中指定键的键值。

注意

若指定的键不存在于字典中，则会报错。
字典键的名称是严格区分大小写的。

3.2 示例¶

源代码：

mydict= {"Name":"Fred", "Age":18, "Country":"China", "ID":1}
print(mydict["Name"])
print(mydict["Age"])

输出结果：

Fred
18

4.字典添加或修改键值¶

4.1 描述¶

此模块可以对字典中给定的键对应的值进行修改，若给定的键不存在于字典中，则此键值对将会被添加到字典中。

注意

此模块没有返回值。

4.2 示例¶

源代码：

mydict= {"Name":"Fred", "Age":18, "Country":"China", "ID":1}
print(mydict["Name"])
mydict["Name"] = "Sam"
print(mydict["Name"])
mydict["Gender"] = "Male"
print(mydict["Gender"])
print(mydict)

输出结果：

Fred
Sam
Male
{'Name': 'Sam', 'Age': 18, 'Country': 'China', 'ID': 1, 'Gender': 'Male'}

5.字典删除键值¶

5.1 描述¶

此模块可以在字典中根据所给键删除键值对。

注意

若所给键值不存在于字典中，则会报错。
此模块没有返回值。

5.2 示例¶

源代码：

mydict= {"Name":"Fred", "Age":18, "Country":"China", "ID":1}
print(mydict)
del mydict["ID"]
print(mydict)

输出结果：

{'Name': 'Fred', 'Age': 18, 'Country': 'China', 'ID': 1}
{'Name': 'Fred', 'Age': 18, 'Country': 'China'}

6.字典删除并返回键值¶

6.1 描述¶

此模块可以在字典中根据所给键返回键值，并删除键值对。

注意

若所给键值不存在于字典中，则会报错。
此模块没有返回值。

6.2 示例¶

源代码：

mydict= {"Name":"Fred", "Age":18, "Country":"China", "ID":1}
print(mydict.pop("ID"))
print(mydict)

输出结果：

1
{'Name': 'Fred', 'Age': 18, 'Country': 'China'}

7.字典设置键默认值¶

7.1 描述¶

此模块可以为字典中给定的键设定默认值。若给定的键存在于字典中，则对应的值不会改变；若给定的键不存在于字典中，则键值对将会被添加到字典中，且键值为所给的默认值。

注意

此模块没有返回值。

7.2 示例¶

源代码：

mydict= {"Name":"Fred", "Age":18, "Country":"China", "ID":1}
print(mydict)
mydict.setdefault("Class",1)
print(mydict)
mydict= {"Name":"Fred", "Age":18, "Country":"China", "ID":1}
print(mydict)
mydict.setdefault("ID",0)
print(mydict)

输出结果：

{'Name': 'Fred', 'Age': 18, 'Country': 'China', 'ID': 1}
{'Name': 'Fred', 'Age': 18, 'Country': 'China', 'ID': 1, 'Class': 1}
{'Name': 'Fred', 'Age': 18, 'Country': 'China', 'ID': 1}
{'Name': 'Fred', 'Age': 18, 'Country': 'China', 'ID': 1}

8.字典清空条目¶

8.1 描述¶

此模块可以清空给定字典的条目。

注意

字典被清空后，只是变成了不包含条目的空字典，此字典对象仍然存在，可以使用字典名调用。
此模块没有返回值。

8.2 示例¶

源代码：

mydict= {"Name":"Fred", "Age":18, "Country":"China", "ID":1}
print(mydict)
mydict.clear()
print(mydict)

输出结果：

{'Name': 'Fred', 'Age': 18, 'Country': 'China', 'ID': 1}
{}

9.字典转换为列表¶

9.1 描述¶

此模块可以将字典转换为键值对元组作为元素的 ‘dict_items’ 类对象，你可以将其转换为列表对象。

注意

此模块返回的是一个名叫 ‘dict_items’ 类的对象，你可以将其转换为列表对象。

9.2 示例¶

源代码：

mydict= {"Name":"Fred", "Age":18, "Country":"China", "ID":1}
print(mydict)
print(mydict.items())
print(type(mydict.items()))
print(list(mydict.items()))

输出结果：

{'Name': 'Fred', 'Age': 18, 'Country': 'China', 'ID': 1}
dict_items([('Name', 'Fred'), ('Age', 18), ('Country', 'China'), ('ID', 1)])        # 'dict_items' 类对象
<class 'dict_items'>        # 'dict_items' 类对象名
[('Name', 'Fred'), ('Age', 18), ('Country', 'China'), ('ID', 1)]

10.字典获取所有键值¶

10.1 描述¶

此模块可以返回一个字典所有的键值。

注意

此模块返回的是一个名叫 ‘dict_values’ 类的对象，你可以将其转换为列表对象。

10.2 示例¶

源代码：

mydict= {"Name":"Fred", "Age":18, "Country":"China", "ID":1}
print(mydict)
print(mydict.values())
print(type(mydict.values()))
print(list(mydict.values()))

输出结果：

{'Name': 'Fred', 'Age': 18, 'Country': 'China', 'ID': 1}
dict_values(['Fred', 18, 'China', 1])       # 'dict_values' 类对象
<class 'dict_values'>       # 对象的类别
['Fred', 18, 'China', 1]        # 转换为列表后

11.字典获取长度¶

11.1 描述¶

此模块可以返回一个字典的长度（条目数量）。

注意

此模块返回的长度是int类型的值。

11.2 示例¶

源代码：

mydict= {"Name":"Fred", "Age":18, "Country":"China", "ID":1}
print(mydict)
print(len(mydict))

输出结果：

{'Name': 'Fred', 'Age': 18, 'Country': 'China', 'ID': 1}
4

12.删除字典¶

12.1 描述¶

此模块可以删除指定的字典。

注意

此模块没有返回值。
删除字典后，无法再使用已被删除的字典名称调用字典，否则会报错。

12.2 示例¶

源代码：

mydict= {"Name":"Fred", "Age":18, "Country":"China", "ID":1}
print(mydict)
del mydict

输出结果：

{'Name': 'Fred', 'Age': 18, 'Country': 'China', 'ID': 1}

集合¶

注解

集合（set）是一个无序的不重复元素序列。

Mixly中有很多用于集合操作的模块，如下：

1.集合初始化¶

1.1 描述¶

Mixly中有两种初始化集合的方式：

第一种，你需要输入集合名称，将代表各种数据的模块连接到初始化模块上，你也可以点击蓝色齿轮增加元素数量。

第二种，你也需要输入集合名称，然后直接在花括号中输入各种数据，各个元素使用英文逗号分隔即可。

在使用集合初始化模块后，你可以在”变量”模块分类中根据你输入的集合名称找到代表此集合的模块。

注意

集合内部的各个元素是没有顺序的，所以直接输出集合，每一次的输出结果都是随机的。
集合的各个元素类型不要求相同，可以是数字、布尔值和字符串。
集合中不能存在相同元素，且集合中的元素必须是不可变类型（列表、集合等为可变类型）。
集合中的字符串元素都是由引号包围的，若其他数据类型使用引号包围也将会被视为字符串类型。

1.2 示例¶

源代码：

s1= {"Mixly", 1, True}
s2= {"Mixly", 1.5, True}
s3 = {"Mixly", 0, False}
s4 = {"Mixly", 1, False}
print(s1)
print(s2)
print(s3)
print(s4)

输出结果：

{1, 'Mixly'}        # 因为在Python中1 = 1.0 = True，所以仅保留了1这个元素
{1.5, True, 'Mixly'}
{0, 'Mixly'}        # 因为在Python中0 = False，所以仅保留了0这个元素
{False, 1, 'Mixly'}

2.获取集合长度¶

2.1 描述¶

此模块可以返回一个集合的长度（元素数量）。

注意

此模块返回的长度为int类型的数据格式。

2.2 示例¶

源代码：

s1= {"Mixly", 1, True}
print(s1)
print(len(s1))

输出结果：

{1, 'Mixly'}
2

3.集合删除并获取元素¶

3.1 描述¶

此模块可以在给定的集合中删除随机元素，并返回被删除的元素值。

3.2 示例¶

源代码：

s1= {"Mixly", 1, "Mixpy", 2}
print(s1)
print(s1.pop())
print(s1)

输出结果：

{'Mixly', 1, 2, 'Mixpy'}
Mixly
{1, 2, 'Mixpy'}

4.集合运算¶

4.1 描述¶

此模块可以将给定的两个集合进行并集、交集、差集运算，并返回运算结果的集合。

注意

此模块并不会对原集合进行修改。
并集是将两个集合的元素在删除重复元素后组成的集合。
交集是两个集合中都包含的元素组成的集合。
差集是包含在第一个集合中，但不包含在第二个集合(方法的参数)中的元素组成的集合。

4.2 示例¶

源代码：

s1= {"Mixly", 1, "Mixpy", 2}
s2= {"Mixly", 2, "MixGo", 3}
print(s1)
print(s2)
print(s1.union(s2))
print(s1.intersection(s2))
print(s1.difference(s2))
print(s1)
print(s2)

输出结果：

{'Mixly', 1, 2, 'Mixpy'}
{'Mixly', 2, 3, 'MixGo'}
{1, 2, 3, 'MixGo', 'Mixly', 'Mixpy'}
{'Mixly', 2}
{1, 'Mixpy'}
{'Mixly', 1, 2, 'Mixpy'}        # 此模块并不会对原集合进行修改
{'Mixly', 2, 3, 'MixGo'}

5.集合运算并更新¶

5.1 描述¶

此模块可以将给定的两个集合进行并集、交集、差集运算，并将运算结果的集合赋值给第一个参数集合。

注意

此模块没有返回值。
此模块只会改变第一个参数集合，不会改变第二个参数集合。

5.2 示例1¶

_images/set_operator_refresh_example.png

源代码：

s1= {"Mixly", 1, "Mixpy", 2}
s2= {"Mixly", 2, "MixGo", 3}
print(s1)
print(s2)
s1.update(s2)
print(s1)
print(s2)

输出结果：

{'Mixpy', 1, 'Mixly', 2}
{3, 'MixGo', 'Mixly', 2}
{1, 2, 3, 'MixGo', 'Mixly', 'Mixpy'}        # 更新后的第一个参数集合
{3, 'MixGo', 'Mixly', 2}

5.3 示例2¶

_images/set_operator_refresh_example2.png

源代码：

输出结果：

{1, 2, 'Mixpy', 'Mixly'}
{'MixGo', 2, 3, 'Mixly'}
{2, 'Mixly'}        # 更新后的第一个参数集合
{'MixGo', 2, 3, 'Mixly'}

5.4 示例3¶

_images/set_operator_refresh_example3.png

源代码：

s1= {"Mixly", 1, "Mixpy", 2}
s2= {"Mixly", 2, "MixGo", 3}
print(s1)
print(s2)
s1.difference_update(s2)
print(s1)
print(s2)

输出结果：

{1, 'Mixpy', 2, 'Mixly'}
{'MixGo', 2, 3, 'Mixly'}
{1, 'Mixpy'}        # 更新后的第一个参数集合
{'MixGo', 2, 3, 'Mixly'}

6.集合增加和删除元素¶

6.1 描述¶

此模块可以根据所给值在集合中增加或删除元素。

注意

Mixly中，此模块仅能够在集合中增加或删除数字元素。
如果添加的元素在集合中已存在，则不执行任何操作。
此模块没有返回值。

6.2 示例¶

源代码：

s1= {"Mixly", 1, "Mixpy", 2}
print(s1)
s1.add(3)
print(s1)
s1.add(2)
print(s1)
s1.discard(1)
print(s1)

输出结果：

{'Mixpy', 1, 2, 'Mixly'}
{'Mixpy', 1, 2, 3, 'Mixly'}     # 添加元素3
{'Mixpy', 1, 2, 3, 'Mixly'}     # 添加元素2，因为集合中已包含元素2，所以没有执行任何操作
{'Mixpy', 2, 3, 'Mixly'}        # 删除元素1

7.集合拆分增加序列元素¶

7.1 描述¶

此模块可以将给定的字符串、列表、元组、集合等拆分增加到集合中。

注意

若是字符串，则将会把字符串拆分为一个一个字符作为元素添加进集合中。
在添加时，如果添加的元素在集合中已存在，则该元素只会出现一次，重复的会忽略。
此模块没有返回值。

7.2 示例¶

源代码：

s1= {"Mixly", 1, "Mixpy", 2}
print(s1)
s1.update([1,2,3,4,5])
print(s1)
s1.update("MixGo")
print(s1)
s1.update((6,7,8,9,0))
print(s1)
s1.update({"A","B","C"})
print(s1)

输出结果：

{1, 2, 'Mixpy', 'Mixly'}
# 添加列表[1,2,3,4,5]，因为1，2已存在，所以并未添加
{1, 2, 3, 4, 5, 'Mixpy', 'Mixly'}
# 添加字符串"MixGo"，字符被拆分后添加到集合里
{1, 2, 3, 4, 5, 'i', 'x', 'Mixpy', 'Mixly', 'G', 'M', 'o'}
# 添加元组(6,7,8,9,0)
{0, 1, 2, 3, 4, 5, 'i', 'x', 6, 7, 8, 9, 'Mixpy', 'Mixly', 'G', 'M', 'o'}
# 添加集合{"A","B","C"}
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 'C', 'B', 'Mixpy', 'A', 'x', 'M', 'i', 'Mixly', 'G', 'o'}

8.集合子集超集判断¶

8.1 描述¶

此模块可以判断两个集合的子集和超集关系，并返回判断的逻辑值。

若前一集合是后一集合的子集或超集，则将返回True；否则将返回False。

8.2 示例¶

源代码：

s1= {"Mixly", 1, "Mixpy", 2}
s2= {1, 2}
s3= {2, 3}
print(s1)
print(s2)
print(s3)
print(s2.issubset(s1))
print(s3.issubset(s1))
print(s1.issuperset(s2))
print(s1.issuperset(s3))
print(s2.issubset(s3))
print(s2.issuperset(s3))

输出结果：

{1, 'Mixly', 2, 'Mixpy'}
{1, 2}
{2, 3}
True        # s2是否是s1的子集
False       # s3是否是s1的子集
True        # s1是否是s2的超集
False       # s1是否是s3的超集
False       # s2是否是s3的子集
False       # s2是否是s3的超集

变量¶

注解

变量是存储在内存中的值，变量可以指定不同的数据类型，存储各种不同类型的数据。

Python中，有五种标准的数据类型：Numbers（数字），String（字符串），List（列表），Tuple（元组），Dictionary（字典）。

Numbers（数字）又包含四种类型：int（有符号整型），long（长整型[也可以代表八进制和十六进制]），float（浮点型），complex（复数）。

Mixly中有很多用于变量操作的模块，如下：

提示

当你使用其他模块创建变量之后，变量分类下会增加为此变量赋值和调用此变量的模块。

1.使用全局变量¶

1.1 描述¶

Python中定义函数时，若想在函数内部对函数外的变量进行操作，就需要声明其为global（全局变量）。

提示

全局变量实际上是为了提示 python 解释器，表明被其修饰的变量是全局变量。这样解释器就可以从当前空间中读写相应变量了。

Python 的全局变量是模块 (module) 级别的

每个 python 函数拥有对应的 __globals__ 字典，该字典与函数所属模块的 __dict__ 字典完全相同。函数的全局变量也会从这个字典中获取

即：python 解释器发现函数中的某个变量被 global （全局变量）关键字修饰，就去函数的 __globals__ 字典变量中寻找（因为 python 中函数也是一等对象）；同时，一个模块中每个函数的 __globals__ 字典变量都是模块 __dict__ 字典变量的引用，二者值完全相同。

1.2 返回值¶

注意

此模块没有返回值。

1.3 示例1¶

源代码：

x = 1
def function1():
    x = 2
function1()
print(x)

输出结果：

1   # 在函数中并未使用全局变量，所以函数无法将x赋为2，无法改变x的值

1.4 示例2¶

源代码：

x = 1
def function1():
    global x
    x = 2
function1()
print(x)

输出结果：

2   # 在函数中使用全局变量，函数将x赋为2

1.5 示例3¶

源代码：

global x
x = 1
def function1():
    x = 2
function1()
print(x)

输出结果：

1   # 使用全局变量需要在函数内部声明，在外部声明函数依然无法将x赋为2

2.初始化变量¶

2.1 描述¶

此模块对变量进行初始化，或者为其赋值。

你需要在模块中输入变量名称，如果不存在此变量，则将会创建此变量并赋值；如果存在此变量，则将会为此变量赋新值。

使用此模块创建变量之后，变量分类下会增加为此变量赋值和调用此变量的模块。

2.2 返回值¶

注意

此模块没有返回值。

2.3 示例¶

源代码：

x = 1
mytext = "Mixly"
mylist = [1,2,3,4,5]
mytup = (1,2,3,4,5)
myset = {1,2,3,4,5}

输出结果：

# 没有输出结果

3.数据类型转换¶

注解

在Python中，各种类型的数据变量可以灵活便捷地进行转换。

但需要注意的是，数据类型转换需要建立在有意义的基础上，你不能够在非数字字符串和数字类型的变量之间转换等等。

3.1 转换为整数¶

3.1.1 描述¶

你可以将小数（float）、布尔值和字符串转换为整数。

注意

将小数转换为整数时，将会直接取小数的整数部分；
布尔值转换为整数，True将转换为1，False将转换为0；
字符串转换为整数时，字符串的内容必须是整数，字符串类型的小数无法转换为整数，会触发报错。

3.1.2 示例¶

_images/variable_transform_int_example.png

源代码：

print(int('7'))
print(int(6.6))
print(int(7.4))
print(int(True))
print(int(False))

输出结果：

 # '7'
 # 6.6
 # 7.4
 # True
 # False

3.2 转换为小数¶

3.2.1 描述¶

你可以将整数、布尔值和字符串转换为小数。

注意

将整数转换为小数时，将会直接在整数后面添加小数点和0；
布尔值转换为小数，True将转换为1.0，False将转换为0.0；
字符串转换为小数时，字符串的内容可以是整数也可以是小数，字符串类型的整数转换为小数时将会在整数后添加小数点和0。

3.2.2 示例¶

_images/variable_transform_float_example.png

源代码：

print(float('7'))
print(float('7.3'))
print(float(6))
print(float(True))
print(float(False))

输出结果：

0     # '7'
3     # '7.3'
0     # 6
0     # True
0     # False

3.3 转换为布尔值¶

3.3.1 描述¶

你可以将所有类型的变量转换为布尔值。

注意

将所有非空序列（列表、元组、字典、集合、字符串）转换为布尔值时，都会转换为True，空序列将转换为False；
将整数和小数转换为布尔值时，1和1.0将转换为True，0和0.0将转换为False；
空对象（None）转换为布尔值为False；

3.3.2 示例¶

_images/variable_transform_bool_example.png

源代码：

print(bool("7.3"))
print(bool("0"))
print(bool(""))
print(bool(6))
print(bool(0))
print(bool(None))
print(bool([1,2,3,4,5]))
print(bool((1,2,3,4,5)))
print(bool({'Name': 'Tom', 'Age': 18}))
print(bool({1,2,3,4,5}))

输出结果：

True    # "7.3"
True    # "0"
False   # ""
True    # 6
False   # 0
False   # None
True    # [1,2,3,4,5]
True    # (1,2,3,4,5)
True    # {'Name': 'Tom', 'Age': 18}
True    # {1,2,3,4,5}

3.4 转换为字符串¶

3.4.1 描述¶

你可以将所有类型的变量转换为字符串。

3.4.2 示例¶

_images/variable_transform_str_example.png

源代码：

print(str(6))
print(str(7.3))
print(str(False))
print(str(None))
print(str([1,2,3,4,5]))
print(str((1,2,3,4,5)))
print(str({'Name': 'Tom', 'Age': 18}))
print(str({1,2,3,4,5}))

输出结果：

# 以下输出的变量类型都是str，可以使用type()方法查看
6
7.3
False
None
[1, 2, 3, 4, 5]
(1, 2, 3, 4, 5)
{'Name': 'Tom', 'Age': 18}
{1, 2, 3, 4, 5}

3.5 转换为非字典序列¶

3.5.1 描述¶

非字典序列类型（列表、元组、集合、字符串）变量可以相互转换，字典也可以转换为非字典序列类型。

数字、布尔值等类型的变量无法转换为序列类型的变量。

注意

将字典转换为其他非字典序列类型时，会将字典中的键作为序列的元素添加到序列中。

3.5.2 示例¶

_images/variable_transform_line_example.png

源代码：

print(list("Mixly"))
print(list((1,2,3,4,5)))
print(list({'Name':"Tom", 'Age':18, 'Country':"China"}))
print(list({1,2,3,4,5}))

print(tuple("Mixly"))
print(tuple([1,2,3,4,5]))
print(tuple({'Name':"Tom", 'Age':18, 'Country':"China"}))
print(tuple({1,2,3,4,5}))

print(set("Mixly"))
print(set([1,2,3,4,5]))
print(set((1,2,3,4,5)))
print(set({'Name':"Tom", 'Age':18, 'Country':"China"}))

输出结果：

['M', 'i', 'x', 'l', 'y']
[1, 2, 3, 4, 5]
['Name', 'Age', 'Country']
[1, 2, 3, 4, 5]
('M', 'i', 'x', 'l', 'y')
(1, 2, 3, 4, 5)
('Name', 'Age', 'Country')
(1, 2, 3, 4, 5)
{'l', 'x', 'y', 'M', 'i'}
{1, 2, 3, 4, 5}
{1, 2, 3, 4, 5}
{'Name', 'Country', 'Age'}      # 集合是无序的

3.6 转换为字典¶

3.6.1 描述¶

你可以将元素为二元序列的序列转换为字典，转换后，每个二元序列的第一个元素为字典的键，第二个元素为对应的键值。

注意

你可以使用 14.列表迭代打包的方式将两个序列打包成为元素为二元序列的序列。

3.6.2 示例¶

_images/variable_transform_dict_example.png

源代码：

keys = ["Name", "Age", "Country"]
values = ["Fred", "19", "China"]
print(dict(zip(keys, values)))

输出结果：

{'Name': 'Fred', 'Age': '19', 'Country': 'China'}

4.获取变量数据类型¶

4.1 描述¶

此模块可以获取各种变量的数据类型并返回。

你可以使用此模块获取一些模块返回的未知的对象的数据类型。

4.2 示例¶

源代码：

print(type(7))
print(type(7.3))
print(type("Mixly"))
print(type([1,2,3,4,5]))
print(type((1,2,3,4,5)))
print(type(dict(zip(["Name", "Age", "Country"], ["Fred", "19", "China"]))))
print(type({1,2,3,4,5}))
print(type(False))
print(type(None))
print(type(zip(["Name", "Age", "Country"], ["Fred", "19", "China"])))
print(type(dict(zip(["Name", "Age", "Country"], ["Fred", "19", "China"])).keys()))
print(type(dict(zip(["Name", "Age", "Country"], ["Fred", "19", "China"])).items()))
print(type(dict(zip(["Name", "Age", "Country"], ["Fred", "19", "China"])).values()))

输出结果：

<class 'int'>
<class 'float'>
<class 'str'>
<class 'list'>
<class 'tuple'>
<class 'dict'>
<class 'set'>
<class 'bool'>
<class 'NoneType'>      # None的数据类型
<class 'zip'>           # 迭代打包返回的数据类型
<class 'dict_keys'>     # 获取字典所有键的模块返回的数据类型
<class 'dict_items'>    # 字典转换为列表的模块返回的数据类型
<class 'dict_values'>   # 获取字典所有键值的模块返回的数据类型

5.变量类型模块¶

5.1 描述¶

此模块用于在变量类型判断中作为代表各种变量类型的模块。

5.2 示例¶

在第一个条件语句中，若变量a是字符串类型，则打印输出a，否则输出”变量a不是字符串类型。”；在第二个条件语句中，若变量a是整数类型，则打印输出a，否则输出”变量a不是整数类型。”

源代码：
1
2
3
4
5
6
7
8
9
a = "Mixly"
if type(a) == str:
    print(a)
else:
    print("变量a不是字符串类型。")
if type(a) == int:
    print(a)
else:
    print("变量a不是整数类型。")
输出结果：
Mixly
变量a不是整数类型。

函数¶

注解

Mixly中，函数是组织好的、可重复使用的、用来实现单一或相关联功能的一组模块。

函数能提高应用的模块性和模块的重复利用率。

你已经知道Mixly提供了许多内建模块，比如”打印（自动换行）”。

你可以自己创建函数，这被叫做自定义函数。

Mixly中有如下用于函数操作的模块：

1.函数定义（无返回值）¶

1.1 描述¶

Mixly中，你需要在函数定义模块中输入函数的名称，然后将实现函数功能的各种其他模块连接到函数定义模块中。

注意

函数定义模块默认没有参数，你可以点击蓝色齿轮为函数增加参数；
请尽量不要为函数命名为无意义的名称，函数的名称最好能够清楚地体现函数的功能；
当你创建有参数的函数后，你可以在变量分类下找到调用该参数的模块；
当你创建函数后，你可以在函数分类下找到调用函数的模块。

1.2 示例¶

源代码：

def welcome(name):
    print("你好，" + str(name) + "！\n欢迎使用Mixly！")
welcome("Fred")

输出结果：

你好，Fred！
欢迎使用Mixly！

2.函数定义（有返回值）¶

2.1 描述¶

在定义有返回值的函数时，你需要在返回值旁边连接变量模块。

有返回值的函数调用模块可以作为变量连接到其他模块上。

注意

函数定义模块默认没有参数，你可以点击蓝色齿轮为函数增加参数；
请尽量不要为函数命名为无意义的名称，函数的名称最好能够清楚地体现函数的功能；
当你创建有参数的函数后，你可以在变量分类下找到调用该参数的模块；
当你创建函数后，你可以在函数分类下找到调用函数的模块。

2.2 示例¶

定义了两个有返回值的函数，square用于计算参数的平方值，calcu_1-2k在给定一元二次方程的参数a, b, c 后可以直接计算出方程的解，并返回一个解组成的列表。

源代码：
1
2
3
4
5
6
7
8
9
import math
def square(x):
    z = x * x
    return z
def calcu_1_2k(a, b, c):
    x1 = (-(b) + math.sqrt(square(b) - 4 * (a * c))) / (2 * a)
    x2 = (-(b) - math.sqrt(square(b) - 4 * (a * c))) / (2 * a)
    return [x1, x2]
print((calcu_1_2k(5, -4, -1)))
输出结果：
[1.0, -0.2]     # 一元二次方程 5x²-4x-1=0 的解

3.返回（条件返回）¶

3.1 描述¶

返回语句会将程序或者函数的处理结果返回到原来调用的地方，并把程序的控制权一起交回。

Mixly中的返回模块在有返回值的函数中可以连接返回值，在无返回值的函数中不可以。

注意

函数执行中遇到第一个返回语句时，就会结束函数的执行，不会运行其他的返回语句；
条件返回让你可以直接将条件语句连接在返回模块中，仅适用于条件返回的情况。

3.2 示例¶

下面定义了一个函数welcome，如果传入的参数name的名字在bad_guys列表里，则直接返回，不会再执行输出”欢迎使用Mixly！”的语句。

源代码：
1
2
3
4
5
6
7
8
def welcome(name):
    bad_guys = ["Sam", "Tom", "Mike"]
    print(("你好，" + name))
    if name in bad_guys:
        return None
    print("欢迎使用Mixly！")
welcome("Fred")
welcome("Tom")
输出结果：
你好，Fred
欢迎使用Mixly！
你好，Tom

串口¶

串行接口是一种可以将接收来自CPU的并行数据字符转换为连续的串行数据流发送出去，同时可将接收的串行数据流转换为并行的数据字符供给CPU的器件。一般完成这种功能的电路，我们称为串行接口电路。串口模块类别中包括了输出函数print()、获取键盘输入函数input()、硬件串口输入输出函数ai_com.uart_rx()、uart1.write()、ai_com.uart_tx()等相应调试接口函数控制语句。

1.打印自动换行¶

print('Mixly')

1.1 描述¶

print() 方法用于打印输出，最常见的一个函数。

1.2 范例1¶

打印输出“Hello Mixly!”，并自动换行。

如:

源代码：
1
print('Hello Mixly!')

2.打印¶

源代码:

print('Mixly',end ="")

2.1 描述¶

打印，不换行。

2.2 参数¶

end为空时，打印内容不自动换行。

2.3 范例¶

多次打印内容时会显示在同一行。

print('Hello',end ="")
print('Mixly',end ="")

3.打印结尾于¶

源代码:

print('Mixly',end =',')

3.1 描述¶

打印某项内容，统一以xxx结尾。

3.2 参数¶

，：结尾内容，可自定义。

3.3 范例¶

统一以字符串“end”结尾。

print('Mixly',end ='end')

4.打印（自动换行）2¶

print('Hello', 'Mixly')

4.1 描述¶

将两个字符串连接后进行打印并换行，此处输出结果为“Hello Mixly”。

5.接收字符串输入¶

1	input('请输入:')

5.1 描述¶

input() 内置函数从标准输入读入一行文本，默认的标准输入是键盘。

5.2 范例¶

输入测试

strr = input('请输入:')
print('输入的内容为:', strr)

程序正常运行情况下

请输入:Mixly
输入的内容为:Mixly

PS:目前程序好像无法正常输入并接收数据，待完善

6.初始化串口¶

import busio
from board import *


uart1 = busio.UART(IO9, IO10, baudrate=115200)
uart1.write(bytearray('Mixly'))

6.1 描述¶

MixGo CE可初始化出三个串口进行串口通信，分别为：UART1、UART2和 UART3。

6.2 参数¶

IO9, IO10, baudrate=115200 ：IO9, IO10分别对应为TX,RX；baudrate是指波特率，表示单位时间内传送的码元符号的个数，它是对符号传输速率的一种度量，常用的值为9600和115200。uart1.write(bytearray(‘’))为串口打印输出函数。
注：TX是发送（transport），RX是接收(receive)。

7.uart1串口打印自动换行¶

import busio
from board import *


uart1.write(bytearray('Mixly')+'\r\n')

7.1 描述¶

uart1.write(bytearray(‘’)+’rn’)方法用于uart1打印输出与其他硬件间进行串口通信，此函数需配合6.串口初始化进行使用；另外这条串口输出内容将不在软件状态栏显示。

7.2 范例¶

通信打印输出“Hello World”

import busio
from board import *


uart1.write(bytearray(oct(0XFF00FF))+'\r\n')

uart1 = busio.UART(IO9, IO10, baudrate=115200)
uart1.write(bytearray('Hello World')+'\r\n')

8. uart1串口打印自动换行2¶

import busio
from board import *


uart1.write(bytearray(hex(0XFF00FF))+'\r\n')

8.1 描述¶

uart1根据实际应用需要打印输出二、八、十、十六进制数据。

8.2 参数¶

hex()此处为16进制数据转换方法，可替换为bin()二进制数据转换、oct()八进制数据转换、int()十进制数据转换;uart1.write(bytearray(hex())+’rn’)函数同样需要配合6.串口初始化进行使用，范例参见7.2。

9.uart1发送数据至MixGo AI¶

import busio
from board import *
import ai_com


uart1 = busio.UART(IO9, IO10, baudrate=115200)
ai_com.uart_tx(uart1, code, repeat=1)

9.1 描述¶

uart1串口发送数据至MixGo AI板专用函数。

9.2 参数¶

uart1为串口实例化对象，code为要发送的数据存储变量名，repeat为是否重复发送某一数据的标记变量，当该值等于1时会重复发送code中的变量值，当为0时，仅当code中数据发生改变时才会被发送一次。
尤其注意code是要发送的数据变量名，需要遵循先定义后使用原则。

9.2 范例¶

通过uart持续发送数据1至MixGo AI板。

MixGo CE端程序:

import busio
from board import *
import ai_com


code = 1
uart1 = busio.UART(IO9, IO10, baudrate=115200)
ai_com.uart_tx(uart1, code, repeat=1)

MixGo AI端程序:

from machine import UART
import board
import machine
import ce_com


board.register(7,board.FPIOA.UART1_TX)
board.register(6,board.FPIOA.UART1_RX)
uart1=UART(UART.UART1, 115200, timeout=1000, read_buf_len=4096)
while True:
    接收 = ce_com.uart_rx(uart1)
    if 接收 != None:
        print('接收到：', 接收)

10.读取MixGo AI数据¶

import busio
from board import *
import ai_com


uart1 = busio.UART(IO9, IO10, baudrate=115200)
res = ai_com.uart_rx(uart1)

10.1 描述¶

MixGo CE从串口1读取MixGo AI数据。

10.2 返回¶

返回MixGo AI传输过来的数据。

10.3 范例¶

接收MixGo AI发送过来的数据。

MixGo CE端代码

import busio
from board import *
import ai_com


uart1 = busio.UART(IO9, IO10, baudrate=115200)
while True:
    res = ai_com.uart_rx(uart1)
    if res != None:
        print('收到:', res)

MixGo AI端代码

from machine import UART
import board
import time
import machine
import ce_com


board.register(7,board.FPIOA.UART1_TX)
board.register(6,board.FPIOA.UART1_RX)
uart1=UART(UART.UART1, 115200, timeout=1000, read_buf_len=4096)
code = 0
while True:
    time.sleep_ms(1000)
    ce_com.uart_tx(uart1, code, repeat=1)

11.待验证¶

板载传感¶

传感模块：按钮、触摸传感器、红外接近传感器、光线传感器、声音传感器、板载温度和CPU温度、加速度、RTC时钟等

在传感器部分，我们将一些最常见的传感器相关指令进行封装，这大大节省了学生的编程时间，这将更有助于使学生将更多的精力集中在创意实践上。

1.按钮¶

from button import button_B1


button_B1.is_pressed()
button_B1.was_pressed()
button_B1.get_presses(1)

1.1 描述¶

按钮状态监测的三种情况：①按钮被按着？只要按着则返回True,一直按着则一直返回True,不按就返回False;②按钮被按下？是一个完整动作，也就是按下后被检测到了返回True,若不松开，则在此期间返回None，仅当松开后返回一次False，之后一直返回None;③至于按钮在某个时长内被按下的次数，某个时间段内一次不按则返回0，按几次返回数值几。

1.2 范例¶

通过串口打印输出三种按钮检测情况的返回值（若实际测试中看着不方便，可以逐一测试）。

如:

源代码：

import time
from button import button_B1
from button import button_B2
from button import button_A1


while True:
    time.sleep(1)
    print('被按下返回：', button_B1.was_pressed())
    print('被按着返回：', button_B2.is_pressed())
    print('被按下的次数返回：', button_A1.get_presses(1))

2.触摸传感器¶

from touchpad import touch_T1

touch_T1.is_touched()

2.1 描述¶

MixGo CE板载4个触摸按键，返回值为布尔值，即当触摸按键时返回True,否则返回False。

2.2范例¶

通过串口返回触摸传感器的状态。

使用串口输出测试时，一般加个延时缓冲下，否则打印输出太快不利观察，也易卡顿。

3.红外接近传感器¶

from infrared import near

near("left")

3.1 描述¶

MixGo CE 3.0版本以上，带有两对红外接近传感器，用于检测是否有人体靠近；返回值为布尔值，当人体靠近传感器时返回True,否则返回为False。

3.2范例¶

通过串口返回左侧的红外接近传感器的状态。

4.光线传感器¶

import sensor

sensor.get_brightness()

4.1 描述¶

MixGo CE 板载光线传感器，用于检测当前所在环境的光照强度，返回值为模拟量，范围0-65535。

4.2范例¶

通过串口返回当前环境的光照强度值。

5.声音传感器¶

import sensor

sensor.get_soundlevel()

5.1 描述¶

MixGo CE 板载声音传感器，用于检测当前所在环境的声音强度，返回值为模拟量，范围0-65535。

5.2范例¶

通过串口返回当前环境的声音强度值。

6.温度传感器¶

import sensor

sensor.get_temperature()

6.1 描述¶

MixGo CE 板载温度传感器，用于检测当前所在环境的温度及CPU温度，CPU温度获取可通过点击该图形指令右下角三角按钮切换，返回值为模拟量，范围0-65535。

6.2范例¶

通过串口返回当前环境的温度值。

7.加速度传感器¶

from mixgoce import acc

acc.acceleration[0]

7.1 描述¶

MixGo CE 板载三轴加速度传感器，用于检测控制板当前的状态，具体可细分为x轴、y轴、z轴，返回值为浮点数。

7.2范例¶

通过串口返回控制板x轴加速度值。

8.设置RTC时钟¶

from mixgoce import rtc_clock
import time

rtc_clock.datetime = time.struct_time((2020,12,26,14,20,45,6,361,-1))

rtc_clock.datetime

8.1 描述¶

实时时钟的缩写是RTC(Real_Time Clock)，其中time.struct_time((2020,12,26,14,20,45,6,361,-1))为初始化操作，之后通过rtc_clock.datetime指令获取当前时间。

8.2范例¶

通过串口每隔1秒打印一次当前时间。

板载执行¶

执行模块：内嵌LED灯状态设置获取及亮度控制指令、播放声音、结束声音、播放音符列表、设音频节奏、获取音频节奏、恢复音乐初始设置、RGB等颜色模式设置、RGB灯整体控制、RGB灯独立控制、RGB跑马灯、RGB灯彩虹效果控制、RGB灯生效等。总体来说该部分指令可分为内嵌LED灯控制、蜂鸣器声音控制及RGB灯控制等三个部分指令。

1.内嵌LED灯控制¶

内嵌LED灯控制指令主要包括：状态设置、状态获取、亮度设置三个功能指令。

1.1内嵌LED灯状态控制¶

from led import led_L1

led_L1.setonoff(1)

1.2 描述¶

内嵌LED灯状态控制，用于初始化并设置内嵌LED灯状态控制，其中包含两个参数，一个是L1与L2可选，对应控制板载L1和L2灯状态，另外就是LED灯具体状态控制，包括：亮、灭和反转三种状态，前两者字面意思不再解释，反转这里是指基于上一次状态进行非运算点亮或熄灭LED灯的状态，也就是上一次状态为亮，则运行反转则为灭，否则反之。

1.3 范例¶

设置点亮或熄灭内嵌LED灯L1,并通过串口打印所获取L1灯的状态。

如:

源代码：

from led import led_L1


led_L1.setonoff(-1)
print(led_L1.getonoff())

led_L1.getonoff()函数返回数字量，0或1

1.4 设置内嵌LED灯亮度¶

from led import led_L1

led_L1.setbrightness(65535)

2.1 描述¶

通过占空比控制LED灯的亮度变化，16位精度，即取值范围为0-65535。

2.2范例¶

借助for循环实现呼吸灯效果。

注意步长一正一负。

3.播放声音¶

from music import buzzer

buzzer.play(440)

3.1 描述¶

MixGo CE板载蜂鸣器，buzzer.play()进行驱动，其中频率参数软件中给的设定范围为262-1796，可根据使用场景自行设置测试具体数值。

注意该函数执行后，蜂鸣器会一直发出最后执行频率的声音，若要暂定该声音，需执行结束声音指令。

3.2范例¶

通过蜂鸣器循环顺序发出do re mi fa so la xi。

3.3播放声音持续时间¶

from music import buzzer

buzzer.play(440, 1000)

3.4 播放音符列表¶

MixGo CE固件内置了一些音频效果，Mixly软件里即可快速调用。

3.5 待测完善¶

待测。

4.RGB灯控制指令¶

4.1 设置颜色模式¶

为兼容版本间差异，这里有两种模式，RGB和GRB,当发现RGB灯的红色和绿色两种颜色无法按程序正常显示时，使用该句进行初始化即可。

from pixels import rgb

rgb.change_mod("RGB")

4.2 范例¶

循环顺序变化RGB灯颜色，依次为红、绿、蓝。

注意RGB生效指令的使用，否则就无法看到效果。

4.3 RGB独立控制指令¶

该指令通过灯号独立控制4颗RGB灯的点亮效果，注意仍需RGB生效指令，否则效果无法显示。

4.4 范例¶

通过灯号独立控制4颗RGB灯，1-4逐一点亮。

4.5 RGB跑马灯¶

from pixels import rgb

rgb.color_chase(0, 0, 0, 1000)

4.6 描述¶

该指令根据设定的RGB灯颜色，从1-4号逐一变换效果，间隔时间参数为跑马灯延时时长，注意此函数无需RGB生效指令，即可正常显示。

4.7 范例¶

红蓝跑马灯效果。

4.8 RGB 彩虹效果¶

from pixels import rgb


rgb.change_mod("GRB")
rgb.rainbow_cycle(1000)

无需RGB生效指令，4颗RGB灯出现类似彩虹的效果显示，持续时间内，是动态变化的。

板载显示¶

板载显示模块：显示(图像/字符串/动画)、滚动显示字符串、显示(图像/字符串/动画)间隔、滚动显示字符串、创建图像、内置图像、整体移动、判断某个位置的LED灯是否亮着、设置某个坐标的LED灯状态、设置LED点阵屏亮度、获取点阵屏亮度、清楚显示内容等指令。

1.1 显示(图像/字符串/动画)¶

通过板载LED点阵屏显示内置图像/字符串/动画

from mmatrix import display
import Image


display.show_dynamic(Image.HEART)

字符串这里是动态跳动逐一字符显示，具体可自行测试查看，不支持中文字符显示。

1.2 滚动显示字符串¶

从左至右滚动显示字符串。

from mmatrix import display

display.scroll('Mixly')

1.3 静态显示字符串¶

静态显示字符串，注意和1.1显示字符串的效果相区别。

from mmatrix import display

display.show_static('abc')

1.4 显示(图像/字符串/动画) 间隔x毫秒¶

由于所显示的内容为一次性显示出来，所以与1.1的区别并不显著。

from mmatrix import display
import Image


display.show_dynamic(Image.HEART,120)

1.5 滚动显示字符串间隔x毫秒¶

间隔x毫秒，这里的间隔指字符串每向左移动一次所间隔的时间。

from mmatrix import display

display.scroll('Mixly',1000)

1.6 创建图像¶

通过点击黑色矩形块，该指令可以快速创建出非内置图像，创建出的内容可以用于1.1和1.4指令。

bytearray(b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')

1.6.1 范例¶

创建图像并显示。

from mmatrix import display

display.show_dynamic(bytearray(b'\x00\x00\x00\x00\x00\x18\x18\xfe\x01\xfe\x18\x18\x00\x00\x00\x00'))

1.7 内置图像¶

供1.1和1.4指令使用，使用范例略。

import Image

Image.HEART

1.8 向(上/下/左/右)移动¶

该指令主要用于LED点阵屏当前所显示的内容的整体移动操作。

from mmatrix import display

display.up(1)

1.8.1 范例¶

通过1.1中的显示图像指令显示一个心形，后通过移动指令借助for循环，每隔1秒向上移动1次，8次后将心形移出显示屏。

1.9 检测某坐标LED灯是否亮着¶

from mmatrix import display

display.get_pixel(int(0), int(0))

1.9.1 返回¶

当所检测的坐标对应的LED状态为亮，则返回1，否则返回0，范例略。

1.10 设置亮灭¶

点亮或熄灭某坐标的LED灯。

from mmatrix import display

print(display.get_pixel(int(0), int(0)))

display.set_pixel(int(0), int(0), 1)

1.11 设置亮度¶

from mmatrix import display

display.set_brightness(0)

在LED点阵屏有显示内容的情况下，再使用该指令可进行设置点阵屏的亮度。

1.11.1 范例¶

点阵屏在显示内容情况下，设置显示亮度（目前测试的效果是仅0会变暗，其他选项区别不大，待进一步核实）。

注意是先有显示内容，再设置亮度。

该指令用于返回当前点阵屏亮度

1.12 清除显示内容¶

from mmatrix import display

display.clear()

清空点阵屏当前的显示内容，范例略。

外接元件¶

传感器¶

外接传感器类别中包括了I2C初始化、光线传感器LTR308、气压传感器HP203B、温湿度传感器SHTC3、温湿度传感器AHT21、激光测距仪VL53L0X、SPI初始化、RFID读卡读取卡号、RFID读卡读取内容、RFID写卡写入数据为、风火轮触摸传感器、风火轮触摸传感器获取角度、超声波测距、初始化天气传感器、天气传感器获取风向、天气传感器获取风速、天气传感器获取x秒内的降雨量等指令。

1. IIC初始化¶

import board
import busio
import ltr308al


i2c_extend = busio.I2C(scl=board.IO1, sda=board.IO2, frequency=100000)
xsensor1 = ltr308al.LTR_308ALS(i2c_extend)

1.1 描述¶

IIC（Inter-Integrated Circuit）其实是IICBus简称，所以中文应该叫集成电路总线，它是一种串行通信总线。I2C串行总线一般有两根信号线，一根是双向的数据线SDA，另一根是时钟线SCL，所有接到I2C总线设备上的串行数据SDA都接到总线的SDA上，各设备的时钟线SCL接到总线的SCL上。

使用IIC通信协议时可在通信线路上同时挂载多个设备，因此这里介绍的I2C指令即用于多个设备与主控器间的数据传输，关于IIC更多信息，请自行网上搜索下。 I2C初始化及使用I2C条指令需同时使用，首先，I2C初始化在实际使用中须关注SCL和SDA的两个参数的设置需要根据所连接的扩展口进行设置，例如，这里连接U1口时，SCL设置为1，SDA设置为2,注意顺序，先小后大；至于初始化后的实例名及频率一般默认即可。其次，使用I2C时将上面初始化的实例名，并根据实际使用自定义改变“xsensor”这个字符串初始化为对应的传感器型号，以防冲突。

综上，需要注意的点有：①SCL、SDA的设置顺序，②xsensor重新命名尤其使用多种传感器时，③选对目标传感器型号
以上三点错一个地方，程序都无法正常运行

以上光线传感器LTR308、气压传感器HP203B、温湿度传感器SHTC3、温湿度传感器AHT21、激光测距仪VL53L0X五种传感器的使用方式相同，都是在IIC初始化为对应的传感器后进行使用。对于气压传感器HP203B、温湿度传感器SHTC3、温湿度传感器AHT21三种传感器，可根据使用需要进行进一步参数设置，直接单击三角按钮选择即可，此处不再赘述。

1.2 范例1¶

使用IIC通信连接外接一个光线传感器，以获取当前环境光照强度并通过串口每隔1秒打印一次，光线传感器连接至U4,IO11和IO12扩展接口上。

根据上面图形代码示例可以看到，②和③所设置及选定的字符，在获取光线传感器数值指令中是对应一致才能正常使用。
此外，该范例将xsensor自定义为ltr1,也就是说可在同一主控上接多个相同的传感器。

1.3 范例2¶

使用IIC通信连接外接两个光线传感器，以获取当前环境光照强度并通过串口每隔1秒打印一次，其中一个光线传感器连接至U4,IO11和IO12扩展接口上、另一个光线传感器连接至U1,IO1和IO2扩展接口上。

1.3 范例3¶

使用IIC通信连接外接一个光线传感器和一个气压传感器，以获取当前环境光照强度及气压强度值并通过串口每隔1秒打印一次，其中一个光线传感器连接至U4,IO11和IO12扩展接口上、另一个气压传感器连接至U1,IO1和IO2扩展接口上。

温湿度传感器SHTC3、温湿度传感器AHT21、激光测距仪VL53L0X三种传感器的用法与上相同，此处不再多述。

2. SPI初始化¶

SPI是串行外设接口（Serial Peripheral Interface）的缩写，是一种高速的，全双工，同步的通信总线，并且在芯片的管脚上只占用四根线，分别为：SCK、MOSI、MISO、CS,更多信息请网上自查。 * 在使用时，这里着重关注SCK、MOSI、MISO、CS四个管脚的设置即可，下面将以RFID外接传感器为例进一步说明SPI的使用。射频识别（RFID）是 Radio Frequency Identification 的缩写，无线射频识别即射频识别技术（Radio Frequency Identification，RFID），是自动识别技术的一种，通过无线射频方式进行非接触双向数据通信，利用无线射频方式对记录媒体（电子标签或射频卡）进行读写，从而达到识别目标和数据交换的目的，更多信息自行网搜。

2.1 范例1¶

通过串口打印RFID所读取到的卡号。将RFID连接至U1扩展口，此时将SCK、MOSI、MISO、CS四个脚对应设置为1、2、4、5即可，亦可连接至U2（6、7、9、10）。 * 以上内容针对MixGo CE v3.5及以上版本，对于V3.5版本以下的RFID使用直接基于图形块上的管脚使用即可，无需修改管脚即可直接使用5、6、7、35。

from board import *
import busio
import rc522
import digitalio
import time


spi = busio.SPI(clock=IO1, MOSI=IO2, MISO=IO4)
rfid = rc522.RC522(spi,digitalio.DigitalInOut(IO5))
while True:
    print('rfid:', rfid.read_card(0, x="id"))
    time.sleep(1)

2.2 范例1¶

读取并打印RFC卡某个位置的内容，一般情况下，新买的卡是空卡，所以读取内容之前需要先写入内容，内容存储位置大小，不同卡存在一定差异，根据需要从0位置逐步往上累积存储即可，当状态栏出现“Out of address range”内容时，即已超出可用最大位置。

写入和读取到的内容格式都为字符串格式，需要注意这点。

注意

超出存储位置报错详情：: File “rc522.py”, line 247, in write_card

IndexError: Out of address range

3. 风火轮触摸传感器¶

该传感器位于3.5版本以下的扩展板上（待测试）。

3. 超声波测距¶

由于超声波指向性强，能量消耗缓慢，在介质中传播的距离较远，因而超声波经常用于距离的测量，更多信息自行网搜。

3.1 范例¶

将超声波模块连接至U4扩展口，通过串口每秒打印输出一次超声波测量到的距离数据。

import hcsr04
from board import *
import time

sonar = hcsr04.HCSR04(trigger_pin=IO11, echo_pin=IO12)


while True:
    print('distance:', sonar.distance())
    time.sleep(1)

这里连接的是U4扩展口，因此设置tri为IO11、echo为IO12，连接至其他口时，自行修改即可。

4.天气信息获取¶

该模块指令待测试完善~

执行器¶

这里主要包括外接扬声器和舵机的驱动指令。

1.初始化扬声器¶

描述¶

“audio”为实例化对象，具体命名可根据需要自定义，SCLK、WS、DATA三个引脚，根据所连接的扩展口具有的引脚从小至大设置即可正常使用。例如，U3扩展口时，则引脚依次设置为17、18、44。

1.1扬声器播放波形声音¶

描述¶

在1.初始化扬声器后，就可以使用该语句播放某个打开为二进制的文件对象内容，具体使用参见示例。

1.2扬声器波形声音在播放吗？¶

描述¶

该指令都要用于判断1.1指令中播放的音频是否结束，若结束则返回False,否则返回True。

范例¶

使用上述指令播放一段.wav音频，并通过串口判断该音频是否播放结束。

需要注意的是，此处的wav音频文件有一定格式要求，具体格式要求标准待完善。

2.初始化舵机¶

描述¶

当外接舵机至扩展口时，根据所连接的具体引脚，选择对应的管脚即可，其中myservo为实例化对象。

2.1舵机角度控制¶

描述¶

在2.完成舵机管脚初始化后，即可使用该指令控制舵机的旋转角度（0-180度）。

2.2 360度舵机设置旋转速度¶

描述¶

360度舵机旋转速度设置，范围（-10~10），范例略。

显示器¶

待完善~

1. IIC初始化¶

import board
import busio
import tm1650


i2c_extend = busio.I2C(scl=board.IO1, sda=board.IO2, frequency=100000)
disp = tm1650.TM1650(i2c_extend)

1.1 描述¶

IIC（Inter-Integrated Circuit）其实是IICBus简称，所以中文应该叫集成电路总线，它是一种串行通信总线。I2C串行总线一般有两根信号线，一根是双向的数据线SDA，另一根是时钟线SCL，所有接到I2C总线设备上的串行数据SDA都接到总线的SDA上，各设备的时钟线SCL接到总线的SCL上。

使用IIC通信协议时可在通信线路上同时挂载多个设备，因此这里介绍的I2C指令即用于多个设备与主控器间的数据传输，关于IIC更多信息，请自行网上搜索下。 I2C初始化及使用I2C条指令需同时使用，首先，I2C初始化在实际使用中须关注SCL和SDA的两个参数的设置需要根据所连接的扩展口进行设置，例如，这里连接U1口时，SCL设置为1，SDA设置为2,注意顺序，先小后大；至于初始化后的实例名及频率一般默认即可。其次，使用I2C时将上面初始化的实例名，并根据实际使用自定义改变“i2c_extend”这个字符串初始化为对应的传感器型号，以防冲突。

综上，需要注意的点有：①SCL、SDA的设置顺序，②i2c_extend重新命名尤其使用多个数码管模块时
以上两点错一个地方，程序都无法正常运行

2. 四位数码管状态¶

2.1描述¶

根据使用需要，选择开、关、清屏等相关操作参数。

3. 四位数码管显示数字¶

3.1 描述¶

用于显示数字

4. 四位数码管某个小数点状态控制¶

4.1 描述¶

设置某个位置的小数点点亮或熄灭

5. 四位数码管亮度控制¶

5.1 描述¶

设置数码管亮度

范例¶

将四位数码管连接至U1（SCL:1,SDA:2）,显示888.8

文件¶

文件处理

1. 打开文件¶

1.1描述¶

用于打开文件，根据使用需要，选择模式（读、写、二进制读、二进制写），其中”f”为打开文件对象。 * 注意所打开的文件必须存在，当前文件系统仅可读。

2. 将字符串写入文件¶

2.1描述¶

将某个长度的字符串写入”f”文件对象。 * 此指令暂不可用。

3. 从文件f读取内容¶

3.1描述¶

从”f”文件对象读取内容，根据需要可选参数有“读取内容、读取一行内容、读取所有行内容”。

4. 从文件f读取内容——限定字符长度¶

4.1描述¶

从”f”文件对象读取内容，根据需要可选参数有“读取内容、读取一行内容、读取所有行内容”，与3.区别在于可对所读取的字符长度作限制。

5. sd卡引脚初始化¶

5.1描述¶

SPI是串行外设接口（Serial Peripheral Interface）的缩写，是一种高速的，全双工，同步的通信总线，并且在芯片的管脚上只占用四根线，分别为：SCK、MOSI、MISO、CS,更多信息请网上自查。 * 在使用时，根据所连接的扩展口引脚从小至大逐一分配至SCK、MOSI、MISO、CS四个管脚即可。

6. sd卡文件系统挂载¶

6.1描述¶

sd卡文件系统挂载在“/sd”路径上。

7. 文件对象是否可写¶

7.1描述¶

判断文件对象是否可以写入内容，可写返回Ture，不可写返回False。 * 当前该指令不可用

8. 获取当前文件对象的文件名¶

9. 关闭打开的文件对象¶

10. 返回文件对象的当前读取的位置¶

11. 设置文件当前读取位置¶

11.1描述¶

根据需要，设置文件当前的读取位置，可选参数“从文件开头算起、从文件当前位置算起、从文件结尾位置算起”。

12. 列出所有文件¶

12.1描述¶

以列表形式返回当前硬件文件系统所有文件名称。

13. 获取当前工作目录¶

13.1描述¶

以字符串形式返回当前工作目录。

14. 改变当前工作目录¶

14.1描述¶

改变当前工作目录。

15.根据目录创建文件夹¶

15.1描述¶

创建文件夹。

16.删除文件¶

16.1描述¶

删除某个文件。

17.重命名文件¶

18.获取某个文件或目录的状态¶

18.1描述¶

返回元组。

18.2范例¶

以二进制读取.wav音乐文件用于音频播放，并通过串口判断该音频是否播放结束。

需要注意的是，此处的wav音频文件有一定格式要求，具体格式要求标准待完善。

通信¶

通信是为了方便人与计算机交互而采用的一种特殊通信方式。具体包括：串口通信(新增串口选择和波特率设置)、红外通信、I2C通信、SPI通信（新增）。

1.板载IIC¶

1.1描述¶

返回IIC对象，具体功能待验证

2.获取红外接收值¶

2.1描述¶

以十六进制或原始输出获取红外接收值。

3.红外发射¶

3.1描述¶

以十六进制或原始输出格式发送数据。

4.无线插座初始化¶

5.无线插座状态改变¶

6.创建某长度缓冲器¶

7.IIC初始化¶

7.1描述¶

使用IIC通信协议时可在通信线路上同时挂载多个设备，因此这里介绍的I2C指令即用于多个设备与主控器间的数据传输，关于IIC更多信息，请自行网上搜索下。 I2C初始化及使用I2C条指令需同时使用，首先，I2C初始化在实际使用中须关注SCL和SDA的两个参数的设置需要根据所连接的扩展口进行设置，例如，这里连接U1口时，SCL设置为1，SDA设置为2,注意顺序，先小后大；至于初始化后的实例名及频率一般默认即可。其次，使用I2C时将上面初始化的实例名，并根据实际使用自定义改变“xsensor”实例化对象名，频率默认即可。

8.IIC占用总线¶

8.1描述¶

在起始信号开始后，总线就处于被占用状态，在终止信号产生后，总线就处于空闲状态。

9.搜索IIC总线上的设备¶

10.向某个地址传输数据¶

11.从某个地址读取数据至buf¶

12.向某个地址写入并保存读到的数据¶

13.SPI释放总线¶

14.IIC释放总线¶

15.SPI初始化¶

15.1描述¶

SPI是串行外设接口（Serial Peripheral Interface）的缩写。SPI，是一种高速的，全双工，同步的通信总线，并且在芯片的管脚上只占用四根线，节约了芯片的管脚，同时为PCB的布局上节省空间，提供方便，拥有简单易用的特性。用户可以使用Mixly向SPI传输数据。

16.SPI波特率相关设置¶

17.SPI占用总线¶

18.SPI写入数据¶

19.SPI读取数据至buf¶

20.SPI写入数据同时读取数据至buf¶

21.SPI释放总线¶

22.OneWire初始化¶

23.OneWire读取比特数据¶

24.OneWire写入比特数据¶

25.OneWire重置¶

物联网¶

网络¶

待完善

MixIO¶

MQTT是一个基于客户端-服务器的消息发布/订阅传输协议。MQTT协议是轻量、简单、开放和易于实现的，这些特点使它适用范围非常广泛。在很多情况下，包括受限的环境中，如：机器与机器（M2M）通信和物联网（IoT）。更多信息自行网搜。 Mixio中包含了众多MQTT操作指令，其中较为常用的有：wifi连接、使用Mixly Key连接至MixIO平台、使用授权码连接至MixIO平台、创建MQTT客户端并连接、订阅主题、发送消息、循环接收订阅、函数方法等等。

1. 连接WIFI¶

该指令用于连接无线网络，其中参数名称为无线网账号，密码为无线网密码，该条指令的正常执行是物联网编程的重要编程步骤之一。

注意wifi账号密码尽量简洁，以英文数字为主,同时避免使用需要二次验证的网络和5G网络。

2. 三种方式连接到 MixIO平台¶

推荐使用谷歌浏览器打开该网址：mixio.mixly.org

2.1使用 Mixly Key¶ _images/mixlykey.png

每台安装Mixly软件的电脑会有独立的Mixly Key，借助Mixly Key即可无需注册账号快速登录MixIO平台。

这里需要注意的是，Mixly Key登录后对应的是独立的单物联网项目工程，与2.3账号密码登录相区别。

2.2使用项目授权码¶ _images/a1b2c3.png

使用授权码登录，避免从零开始搭建物联网云端组件，有利于提升教学效率。授权码的获取分以下两个步骤：①在2.3账号密码登录的情况下，②点击新建项目

2.3使用账号密码¶ _images/mclient.png

参数1服务器地址：mixio.mixly.org 无需修改，复制该网址至浏览器打开即可
参数2代理网口：1883 无需修改
参数3用户名：需要至上述网址用邮箱注册一个账号填到这里
参数4密码：此处密码非注册账号时所填写的密码，需要在以账号密码登录后至下图左侧①箭头处，点击小眼睛获取
参数5项目：项目名称需要根据实际情况，填入在以账号密码登录后至下图②箭头处，新建项目时自定义的名称

账号密码登录可创建多个不同的物联网项目工程，同时还支持项目工程的共享及导入等操作。

3. MQTT发送数据¶

该指令用于将字符串数据上传至物联网云端，主要包含两个参数，分别为主题和消息，其中主题一般推荐用英文命名，消息内容需自行转化为字符串以免出错，上传至云端后查看方式，可以在数据视图下（组件视图见后面范例），点击左上角监听主题进行切换查看上传内容。

该指令只能在wifi连接和mixio平台连接成功之后正常运行。

关于主题更多信息，参见：https://blog.csdn.net/weixin_43025071/article/details/82464661

4. MQTT订阅主题¶

该指令用于获取物联网云端下发的数据，主要包含两个参数，分别为主题和消息，其中主题填入物联网端发送数据所定义的名称，设置回调函数见5.，“method”需根据具体情况自定义，当所订阅的主题有数据下发时，会调用该函数执行相关功能。

5. MQTT回调函数¶

该方法函数每次被调用都会传过来三个参数，分别对应于client(客户端)、topic(主题)、msg(下发的内容，字符串格式)，在变量区块可找到对应变量名图形代码块。关于函数及其参数相关概念，自行网搜了解。

6. MQTT循环接收订阅超时¶

若想让4.中订阅的主题内容可以正常调用回调函数，就需在编写的程序主循环中加入这句指令，每次执行该句指令都会询查所订阅的主题是否有数据发送过来。

超时1秒，会在这里耗时较长导致程序运行卡顿，通常改为0.3秒较为适宜。

7. 范例1——Mixly Key的使用¶

通过Mixly Key连接至MixIO平台，每隔1秒上传随机数至MixIO平台，通过数据视图查看。

7.1 Mixly 软件端图形代码：¶ _images/m_1.png

Python代码略。

浏览器端使用Mixly Key登录(网址：mixio.mixly.org)

推荐使用谷歌浏览器，其他浏览器可能存在中文兼容性问题！

7.2 浏览器端数据效果：¶ _images/ex_l1.png

注意①点击数据视图，②在MixGo CE端代码正常运行且点阵屏显示了Mok，基本上浏览器②箭头处会显示有设备连接平台，③选择对应的主题即可看到上传的数据。

注意

上述范例中，需要注意上传的数据格式为字符串格式，同时注意加延时，否则浏览器端会出现响应卡顿现象。

8. 范例2——Mixly账号密码登录¶

根据2.3中步骤，登录mixio平台后，将账号及平台生成的密码填至MQTT创建客户端指令中相应位置，并点击Mixio平台的右上角新建一个工程项目，将名称填至项目处。

下面将通过在数据页面定义一个主题下发数据至MixGo CE端，CE端将收到的数据打印出来。

8.1 Mixly 软件端图形代码：¶ _images/re_1.png

Python代码略。

当MixGo CE点阵屏上显示MOK，即表示wifi和云端均正常连接，若未正常出现MOK，自行检查wifi信息、mixio平台账号、密码及项目名等，所填信息避免出现空格。

正常情况下，云端发送数据后，本地mixly软件端即可看到打印出的数据内容。

注意

上述范例中，需要注意收到的数据格式为字符串格式，在做逻辑判断时尤其需要注意。

根据以上两个示例可知，物联网基础编程步骤大致为：①连接平台、②数据上传、③数据下发，关于云端组件和逻辑的使用案例见以往培训视频及PPT。

9. 使用授权码的登录方式待完善¶

10. 格式化位置信息¶

该指令可以用于组件中地图组件位置标定，例如，圆明园的坐标大致为（116.3100，40.0156），通过该指令进行定位并标记“圆明园”。因此三个参数分别对应为“116.3100、40.0156、圆明园”

10.1 组件使用范例¶

组件的使用大致分四步，先点击组件按钮、然后点击加号、之后点击数据地图加号，注意此时会出现新的弹窗，组件名称可命名为地图定位，消息主题这里直接默认为“map”不修改，点击对号确认，最后点击右上角的三角按钮运行该工程！！！！这点很重要，否则看不到效果。

10.2新建组件后效果¶ _images/location3.png

10.3程序示例¶

10.4程序上传后，云端定位效果¶ _images/location_result.png

11. 格式化字符串JSON¶

将字符串格式化为json格式，然后进行上传至云端，可通过串口直接打印该指令格式后的内容，关于json数据格式内容见网络。

以下指令增加了物联网编程的灵活性，学有余力可多多尝试。

Blynk IOT¶

Blynk是一项物联网（IoT）服务，旨在使远程控制和从您的设备中读取传感器数据的速度尽可能快和容易。

1.Blynk准备工作¶

1.1下载blynk APP¶

若手机为安卓系统，通过浏览器扫描下图二维码下载app（不要通过微信扫描！），苹果手机通过其商店搜索下载即可。

1.2 blynk账号注册¶

按下图5个步骤注册账号，尤其注意切换使用blynk.mixly.org服务器，否则将出现访问缓慢问题。

1.3 blynk账号登录¶

按下图2个步骤登录账号

1.4 创建项目并获取授权码¶

按下图根据下面步骤完成项目创建并将复制到的授权码发至电脑端。

2.blynk编程设置¶

在完成1.中相关操作后，现在就可以通过Mixly软件进行编程，在下面这条指令三个参数中，前两个无需修改，仅需将1.4中获取的授权码放至第三个参数位置即可。

3.当从Blynk app收到虚拟引脚数据时触发该指令¶

该指令用于获取从Blynk app发送过来的虚拟模拟量数值，其中有两个参数，0处具体数值需根据APP端选定的管脚号进行设置；”value”为传参变量名可自定义，定义后出现在变量区块中。 * 注意该指令需要将6.中指令放在循环中运行方可触发，具体使用见后面范例。

4.Blynk定时器¶

该指令通过硬件自带的定时器模提供执行多进程任务的功能，其中有三个参数可设置，0处为定时器名称，可默认不变；“多次触发”选项意指一旦该定时器功能启动将会执行多次所包含指令，当选择单次触发时，仅执行一次包含的指令；周期意指每隔多久执行一次该指令相应功能。 * 注意此指令需要将7中指令放在循环中运行方可触发，具体使用见后面范例。