从〇到一

搭建Vue开发环境

星辉 — Tue, 30 Aug 2022 13:28:10 +0800

机房搭建Vue开发环境说明

1、JS运行环境Node.js https://nodejs.org/zh-cn/ 下载安装长期维护版16.17.0
输入终端命令确认安装成功

node -v

2、Git https://git-scm.com/ 下载安装最新版
输入终端命令确认安装成功

git --version

3、Visual Studio Code https://visualstudio.microsoft.com/zh-hans/ 下载安装最新版
打开扩展面板搜索并安装Prettier、Volar、ESLint
打开设置面板点击右上角按钮编辑settings.json

{
  "editor.tabSize": 2,
  "editor.defaultFormatter": "esbenp.prettier-vscode",
  "editor.formatOnSave": true,
  "prettier.semi": false,
  "prettier.singleQuote": true,
  "prettier.trailingComma": "none",
  "update.enableWindowsBackgroundUpdates": false,
  "update.mode": "none",
}

4、浏览器安装Vue开发工具
Win10自带Edge浏览器点击“扩展”>“打开 Microsoft Edge 加载项”搜索并安装Vue Devtools
Chrome浏览器下载扩展包解压，在扩展管理中启用开发模式后即可安装 https://github.com/vuejs/devtools/releases/download/v6.1.3/devtools-chrome.zip

5、配置npm镜像并安装全局包
输入终端命令

Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
npm config set registry https://registry.npmmirror.com
npm install -g http-server
npm install -g eslint
npm install -g vue-eslint-parser
npm install -g @vue/cli
npm install -g webpack

Python 网络爬虫：批量下载图片

星辉 — Fri, 25 Oct 2019 08:51:39 +0800

网络爬虫即通过编写程序来自动化访问互联网，快速地获取海量的有价值信息，这是Python语言的又一个重要应用领域。Python网络爬虫程序通常使用Requests软件包来发送HTTP请求，数据科学发行版Anaconda已经直接附带了Requests，对于Python官方版则可以使用以下pip命令安装Requests：

pip install requests

这里将在Jupyter笔记本中演示一个批量下载图片的网络爬虫，它会根据指定的搜索词在百度搜索相应的图片——例如想要搜索“国画”，用户可以在浏览器中输入以下网址打开相应的结果页面： http://image.baidu.com/search/flip?tn=baiduimage&word=国画

网络爬虫程序则可以代替浏览器来访问相同的网址，再找出其中所有原图片的网址，发送相应的HTTP请求去获取并保存图片文件。以下代码块首先导入requests模块，调用其中的get函数向指定网址发送HTTP请求，得到包含结果页面的响应对象：

import requests
url = "http://image.baidu.com/search/flip?tn=baiduimage&word=国画"
r = requests.get(url)

以下代码块使用了标准库的re模块，通过正则表达式从结果页面中找出所有原图片的网址：

import re
po = re.compile(r'"objURL":"(.+?)"')
po.findall(r.text)

以下代码块实际执行批量下载图片操作，首先使用标准库os模块中的函数创建保存目录，然后逐一请求每个图片网址，并将返回的数据写入文件——图片文件名是根据网址生成的，这样可以避免重复下载：

import os
imgdir = "img"
if not os.path.exists(imgdir):
    os.mkdir(imgdir)

po = re.compile(r'"objURL":"(.+?)"')
urls = po.findall(r.text)
for url in urls:
    imgpath=os.path.join(imgdir, requests.utils.quote(url,""))
    if os.path.exists(imgpath):  # 如果图片文件已存在则提示已下载
        print(url,"已下载")
    else:  # 否则发送请求获取图片数据
        r = requests.get(url)
        if r.status_code == 200:  # 如果请求成功则将响应内容写入文件
            print("开始下载:", url)
            with open(imgpath, 'wb') as f:
                f.write(r.content)
        else:
            print("无法下载:", url)

下载的图片可在Jupyter页面中点击显示，或是在系统资源管理器中打开相应文件夹来查看（Windows中的Jupyter根目录即C盘用户目录下的当前用户主目录）。

你可能会发现对于某些图片链接爬虫程序将提示“无法下载”，实际编写爬虫程序时将会涉及到计算机网络的许多技术细节，还需要花费更多的时间才能熟练掌握。

有关Requests的详细使用方法可参阅官方中文文档 http://cn.python-requests.org/zh_CN/latest/

Python 数据可视化示例

星辉 — Thu, 24 Oct 2019 08:56:05 +0800

数据处理与分析的结果可以通过图形工具包展示为生动直观的图表，Python中最常用的图表工具软件包是数学绘图库Matplotlib，Anaconda发行版已经直接附带了Matplotlib，对于Python官方版则可以使用以下pip命令安装Matplotlib：

pip install matplotlib

以下代码导入绘图子模块matplotlib.pyplot（按惯例以plt作为别名）并创建了必要的中文字体属性对象：

import matplotlib.pyplot as plt
%matplotlib inline
from matplotlib.font_manager import FontProperties
cfont = FontProperties(fname=r"C:\Windows\Fonts\simhei.ttf")  # 创建中文字体属性，自带字库不支持中文

接下来的语句块将基于之前皇帝寿命DataFrame中的数据绘制一个直方图：

plt.style.use("seaborn")
plt.title("皇帝的寿命：区间分布", fontproperties=cfont, fontsize=18)
plt.hist(df.寿命, range=(0, 100), edgecolor="blue")

可以看到数据值是呈正态分布的，占比最高的是30到40岁区间——总共有62位皇帝的寿命处在这个范围之内。

下面的继续尝试绘制不同类型的图表，以便研究一下皇帝寿命的变化趋势，首先使用以下语句块对DataFrame进行修改：

df["出生年份"] = df.生卒.apply(
    lambda x: int(x.split("年", 1)[0].replace("前", "-")))
df = df.sort_values("出生年份")
df["平均寿命"] =df.寿命.rolling(20).mean()
df.head()

以上语句块先添加了一个“出生年份”列，即通过对生卒列处理得到的整数（公元前为负值）；再按出生年份排序；最后再添加一个“平均寿命”列，即连续20位皇帝寿命的移动平均值。可以看到现在数据将按出生年份排序，平均寿命列的前19行为空值（Pandas以NaN表示空值，即Not a Number）。

现在可以使用以下语句块绘制新的图表：plot方法用于绘制折线图，第一行根据出生年份和寿命值绘图，第三个参数为表示绿色圆点的样式字符串，相当于画散点图；第二行根据出生年份和平均寿命值绘图，样式为红色实线：

plt.plot(df.出生年份, df.寿命, "go")
plt.plot(df.出生年份, df.平均寿命, "r-")
plt.title("皇帝寿命：变化趋势", fontproperties=cfont, fontsize=18);

你可以从这张图中一眼看出皇帝寿命与朝代兴衰的显著关联，一图胜千言。

Matplotlib支持绘制各种类型的图表，实际工作中应当根据数据的特点选择最能说明问题的图表类型。有关Matplotlib的更多信息请访问项目官网 https://matplotlib.org/

Python 数据分析示例

星辉 — Wed, 23 Oct 2019 22:50:19 +0800

数据分析处理是Python语言的一个重要应用领域，对于此类需求通常使用的软件包是Pandas，数据科学发行版Anaconda已经直接附带了Pandas，对于Python官方版则可以使用以下pip命令安装Pandas：

pip install pandas

下面的示例是使用Jupyter笔记本对中国历史上皇帝们的寿命数据进行简单的统计分析，练习所用的数据文件为emperor.csv（这是一种以逗号作为分隔符的通用纯文本数据格式）： http://study.ywicc.edu.cn/x/07ltKL

# 导入pandas模块，按惯例以pd作为别名
import pandas as pd
# 读取CSV格式的数据返回一个数据网格DataFrame
df = pd.read_csv("http://study.ywicc.edu.cn/x/07ltKL")
df.shape  # 数据网格的形状即行数与列数

以上语句块读取CSV文件返回一个数据网格（DataFrame）对象，即302行乘5列的二维表。

使用DataFrame对象的head方法则可以预览前几行的内容（默认5行）：

df.head()

对于已生成的 DataFrame，还可以进行种调整和查询操作，以下语句块对列标签进行了修改，然后列出寿命达到80岁的皇帝：

df.columns = ["序号", "名号", "寿命", "生卒", "朝代"]
df[df.寿命 >= 80]

以下语句块筛选出明清两朝的皇帝，调用tail方法预览最后10行：

mingqing = df[df.朝代.isin(["明", "清"])]
mingqing.tail(10)

以下语句块比较明清两朝的皇帝寿命——聚合输出分组总计数、最低值、最高值、平均值、中位数：

compare = mingqing.groupby("朝代").寿命.agg(["count", "min", "max", "mean", "median"])
compare

可以看到使用Pandas进行数据分析是相当方便快捷的，这个示例只对Pandas的功能进行了非常简要的介绍，学习者可以查阅官方文档了解更多使用技巧 https://pandas.pydata.org/pandas-docs/stable/

Python GUI 程序：记事本

星辉 — Wed, 23 Oct 2019 08:21:58 +0800

本示例程序 mynote.pyw 实现了一个简易的记事本，可以像 Windows 系统自带的记事本一样编辑文本文件。程序使用的可视化部件有菜单（Menu）、带滚动条的文本区（ScrolledText）以及多种对话框和消息框等，它们放在tkinter之下不同的子模块中，用法都相当简单，学习者可以查看帮助信息自行理解。

"""简易记事本"""
import tkinter as tk
from tkinter.scrolledtext import ScrolledText
from tkinter.filedialog import askopenfilename, asksaveasfilename
from tkinter.messagebox import askokcancel, showinfo
appname = "简易记事本"


def main():
    def c_new():  # 新建文件
        var_filename.set("")
        root.title(f"未命名 - {appname}")
        text.delete(1.0, "end")

    def c_open():  # 打开文件
        filename = askopenfilename()
        if filename:
            var_filename.set(filename)
            root.title(f"{filename} - {appname}")
            with open(filename) as f:
                text.delete(1.0, "end")
                text.insert(1.0, f.read())

    def c_save():  # 保存文件
        filename = var_filename.get()
        if not filename:
            filename = asksaveasfilename()
        if filename:
            var_filename.set(filename)
            root.title(f"{filename} - {appname}")
            with open(filename, "w") as f:
                content = text.get(1.0, "end-1c")
                f.write(content)

    def c_exit():  # 退出
        if askokcancel("退出", "你确定要退出吗？"):
            root.destroy()

    root = tk.Tk()
    root.title(f"未命名 - {appname}")
    root.protocol("WM_DELETE_WINDOW", c_exit)  # 关闭根窗口时执行c_exit函数
    var_filename = tk.StringVar(root)  # 字符串变量
    menu = tk.Menu(root)  # 创建根窗口下属的主菜单
    root["menu"] = menu
    m_file = tk.Menu(menu)  # 创建主菜单下属的文件菜单
    menu.add_cascade(label="文件", menu=m_file)
    m_file.add_command(label="新建", command=c_new)  # 文件菜单添加菜单命令项
    m_file.add_command(label="打开...", command=c_open)
    m_file.add_command(label="保存", command=c_save)
    m_file.add_separator()  # 添加分隔线
    m_file.add_command(label="退出", command=c_exit)
    text = ScrolledText(root, width=100, height=40)  # 创建滚动文本区
    text.pack()
    text.focus()
    root.mainloop()


if __name__ == "__main__":
    main()

Python GUI 程序：数字时钟

星辉 — Tue, 22 Oct 2019 22:02:59 +0800

计算机用户日常接触的大部分应用程序都是“图形用户界面”（GUI）程序。与 GUI 相对的概念是“命令行界面”（CLI），GUI 程序比 CLI 程序要复杂许多，通常人们会使用专门的 GUI 工具包来进行 GUI 程序的开发。Python 标准库自带了 GUI 工具包 tkinter，学习者常用的 IDLE 和 turtle 实际上都是基于 tkinter 实现的。tkinter 的特点是简单轻便，可以用于在不同系统平台上快速开发风格一致的基本 GUI 程序。GUI 的各种构成元素统称为“可视化部件”（Widget），每一种部件都对应某一种特定类型，编程时首先需要生成特定类型的部件对象，然后调用对象的方法即可任意控制图形界面的外观和行为了。

运行以下示例程序 myclock.pyw 将显示一个简易的数字时钟：

"""简易数字时钟"""
import tkinter as tk  # 图形用户界面模块tkinter
import time  # 时间模块time


def tick():
    """走时函数"""
    now = time.strftime("%H:%M:%S")  # 根据当前时间值格式化字符串
    label.config(text=now)  # 根据时间字符串更新标签文本
    label.after(200, tick)  # 200毫秒后再次调用tick函数


if __name__ == "__main__":
    root = tk.Tk()  # 创建根窗口
    root.title("简易数字时钟")  # 窗口标题
    root.geometry("400x160")   # 窗口尺寸
    root.resizable(0, 0)  # 窗口大小不可调整
    label = tk.Label(root, fg="blue", font=("Courier", 30, "bold"))  # 创建标签
    label.place(relx=0.5, rely=0.5, anchor=tk.CENTER)  # 放置标签到居中位置
    tick()  # 调用tick函数
    root.mainloop()  # 启动窗口主事件循环接收所有事件

Python 与 Jupyter 工具库 Calysto

星辉 — Sun, 20 Oct 2019 11:08:23 +0800

Calysto 是一个小巧的 Python 工具库，用它可以简单方便地通过 Jupyter 笔记本页面进行图形绘制和模拟演示。 Calysto 项目发布页面为 https://pypi.org/project/calysto/

你可以在系统终端窗口输入以下命令来安装 Calysto 软件包：

pip install calysto
conda install cairo  # Windows下还需要安装cairo

安装完成后导入包内的图形模块 calysto.graphics 中的所有对象和显示模块 calysto.display 中的两个函数：

from calysto.graphics import *
from calysto.display import display, clear_output

下面是一个绘制图形对象的示例，首先创建一个 Canvas 画布对象以及任意多个图形对象例如 Circle 圆形，Text 文本，Polygon 多边形等，然后调用画布对象的 draw 方法在画布上绘制图形对象，最后调用 display 函数在 Jupyter 笔记本页面中显示画布：

canvas = Canvas((500, 200))  # 创建画布，位置参数指定大小是多少个像素
# 创建圆形，位置参数指定圆心，半径，关键字参数有填充颜色，线条颜色等
circle = Circle((100, 100), 30, fill="red", stroke="green")
circle.stroke_width(3)  # 也可调用对象的方法，例如stroke_width()改变线条宽度
canvas.draw(circle)
# 创建文本，位置参数指定文本，起点，可以使用style关键字参数设置任意CSS样式
text = Text("画布上的文本", (180, 100), fill="blue", stroke="red", style="font-weight:bold;font-size:30px;font-style:italic")
canvas.draw(text)
# 创建多边形，位置参数指定所有顶点
polygon = Polygon([(400, 100), (430, 100), (480, 130), (460, 150), (420, 150)])
canvas.draw(polygon)
display(canvas)  # 显示画布

图形模块中还定义了 Turtle 海龟对象，可以在 Jupyter 笔记本页面中控制海龟进行绘图，但具体实现上与标准库的 turlte 模块有所差别，例如并不能填充海龟画出的封闭区域，也不会显示海龟的移动过程（不过通过刷新画布也是可以生成动效的）。

import time  # 导入标准库time模块用于定时操作
canvas = Canvas((400, 200))
tt = Turtle(canvas, (0, 100))  # 创建海龟，位置参数指定所在画布，起始点
tt.stroke = "red"  # 绘制红色36芒星
tt.stroke_width = 2
for _ in range(36):
    tt.forward(180)
    tt.right(170)
tt.penup()
tt.goto(220, 100)  # 动态绘制蓝色36芒星
tt.stroke = "blue"
tt.pendown()
for _ in range(36):
    tt.forward(180)
    tt.right(170)
    clear_output(wait=True)  # 添加刷新画布的代码
    display(canvas)
    time.sleep(.25)

Calysto 没有提供很完善的文档，学习者可以自行研究，例如它的绘图模块是通过另一个第三方包 svgwtrite 在网页中输出 SVG 图形来实现的，因此可以参看相应文档了解详情 https://svgwrite.readthedocs.io

经济学人：Python 开启编程大众化的新时代

星辉 — Thu, 2 Aug 2018 21:14:06 +0800

Python 创造者 Guido van Rossum 宣布退位是信息科技圈近期的重要事件，《经济学人》杂志也为此发表了一篇专题文章，以下是我的翻译版……

Python 开启编程大众化的新时代

原文链接 Python has brought computer programming to a vast new audience

1989年12月，一位荷兰计算机科学家 Guido van Rossum 决定利用圣诞假期进行一项计划——因为对其他编程语言的缺点感到不满，他想自己再创造一个。他的原则很简单：首先，它要流畅易读，每行语句意义完整，不是以花括号嵌套而是以强制空格缩进来确保结构清晰；其次，它要让用户能够自建功能模块并组成软件包，以便他人重复利用；第三，它还要有一个“简短、独特又略显神秘的”名字。最终，他以自己喜欢的英国喜剧组合 Monty Python 为其命名，并将软件包仓库称为“奶酪商店”。

自他完成这个圣诞假期小发明至今已过去将近30年，Van Rossum 就如同电影《万世魔星》（Monty Python and the Life of Brian）中那个意外当上弥赛亚的角色一样，成为被众人所拥戴的科技时代英雄。“我当初完全没打算创造一个会被广泛应用的编程语言，”他解释道。但在最近一年里，美国人在 Google 上搜索 Python 的次数比搜索电视明星金·卡戴珊的次数还要多，这个数值自2010年以来已经翻了三倍，而其他编程语言的搜索频率都趋于平缓或是下降（见图表）。

Python 语言不仅在专业开发者中越来越受欢迎——据知名的编程技术论坛 Stack Overflow 统计，有近40%的开发者已经在使用它，还有另外25%准备要使用它——另据已向4500万人提供编程语言教学的网站 Codecademy 统计，学习需求增长幅度最大的语言同样是 Python，许多过去对编程感到无从入手的人开始有机会初窥门径了。在被称为“Pythonistas”的狂热爱好者们共同努力下，加入“奶酪商店”的软件包已超过14.5万个，涵盖了从天文观测到游戏开发等等无数的领域。

虽然支持者的热情令 Van Rossum 感到高兴，然而担任如此庞大开源项目的“终身仁慈独裁者”带来的压力也令他感到疲倦，他害怕自己变成一个偶像。“我为名声所累，” 他说，像《万世魔星》中的 Brian 那样想要赶走追随自己的崇拜者，“有时我感觉自己说的每句话都被当成了金科玉律。”所以他在7月12日宣布放弃决策权，让 Python 社区自行决定未来之路。

意外崛起的数据大师

Python 并非完美无缺。其他一些语言或是有更高的性能，或是更适合特定的领域。C 和 C++ 是“底层开发”的不二之选，允许用户更灵活地控制计算机处理器内部的运行过程。Java 在构建庞大而复杂的企业级应用方面广受欢迎。JavaScript 则是开发 Web 浏览器端应用的首选语言。还有许多其他语言为了特定目的被创造出来。但是 Python 独有的杀手级特性——简洁自然的语法，便于学习和分享，从而积累起不计其数的第三方包——使它成为出色的通用编程语言。众多的使用者和广泛的使用领域突显了它的多才多艺——CIA 用它编写黑客工具，Pixar 用它创作动画电影，Google 用它爬取网页信息，Spotify 用它生成推荐歌单……

对于 Python 爱好者来说最具吸引力的是那些实现“人工智能”（AI）的软件包。使用者可以构建模拟大脑结构的神经网络，从海量数据中提炼出特定的模式。Van Rossum 称 Python 已成为 AI 研究者的首选语言，在这一领域开发出不计其数的第三方包。

当然并非所有 Python 爱好者都有这样的雄心。Codecademy 的老板 Zach Sims 认为许多用户访问他的网站学习编程技能是为他们在传统上被视为“非技术性的”工作提供助力。例如营销人员可以编程构建统计模型来衡量促销活动的有效性。大学教师可以编程检查学生成绩分布情况。（甚至也包括《经济学人》的记者——他们在网上搜集数据通常也会使用 Python 编程来实现。）

对于长久以来一直依赖电子表格处理数据的从业者而言，Python 更是具有特殊价值。美国花旗银行（Citigroup）已经为实习分析师引入 Python 速成培训。据就业网站 eFinancialCareers 的报告，近三年来 Python 被职业技能清单提及的次数增长了四倍。

对这些技能的渴求并非没有风险。投顾公司 Bain & Company 的合伙人 Cesar Brea 警告称，在他的行业中最可怕的事情就是“某人掌握了一种新工具，但并不清楚其内部原理”。如果没有适当的监督，一个胡乱摆弄 AI 库的新手可能做出完全错误的决策。波士顿投顾集团的合伙人 Bernd Ziegler 则声称，他的公司会将此类分析工作保留给专门的数据团队来进行。

Rossum 的万能机器人

要解决技能不足的问题，必须要有更全面完整的编程教育。Python 在2014年就已成为美国大学最流行的入门编程语言，但其教学还仅限于科学/技术/工程/数学专业（STEM）。一个更激进的提议是更早地普及编程教学——从小学就开始！公益性编程教育机构 Code.org 的负责人 Hadi Partovi 指出已有40%的美国学校开设了编程课，在2013年还只有10%。美国10至12岁的孩子约有三分之二已在 Code.org 开通账号，美国90%的父母希望自己的孩子能学习计算机科学知识。

所有人都在猜测 Python 的兴盛还会持续多久。有好几种编程语言也曾辉煌一时，后来却销声匿迹——当然并非“如尼尼微和推罗一般”彻底消亡，只是退居幕后。1960年代 Fortran 语言曾统治世界。Basic 和 Pascal 作为新手的入门语言也一度广受欢迎。Partovi 本人则将 JavaScript 作为 Code.org 的主打课程，因为它仍然是开发交互式网页的业界标准。

没有哪一种编程语言能真正做到“万能”。保持专业化仍然很重要。但无论如何，在多年之前的那个圣诞节，Van Rossum 开创了值得纪念的事业。他不是弥赛亚，但他确实是一个非常聪明的人。

Python 3.6.5 版本发布

星辉 — Fri, 30 Mar 2018 17:09:16 +0800

Python 3.6.5 版本于2018年3月28日发布了，可以在官方发布页面下载 https://www.python.org/downloads/release/python-365/

小版本号“5”表示它是 Python 3.6 这个主要版本的第 5 个“维护版本”，安装后会取代之前的 3.6.4 版本。维护版本主要是对已发现的各种问题进行修正，并不增加新的语言特性——对于学习者而言，不更新也没有关系——虽然 3.6.5 这个版本号还是挺酷的……

Python 3.6.5 的详细修正记录可以查看以下页面 https://docs.python.org/3.6/whatsnew/changelog.html#python-3-6-5-final

Python 3.6 版本的后续发布日程参见以下页面 http://www.python.org/dev/peps/pep-0494

下一个主要版本 Python 3.7 的发布计划参见以下页面 https://www.python.org/dev/peps/pep-0537

如果你想要在程序中获取 Python 版本号，可以使用标准库 platform 模块的 python_version 函数：

In [1]: from platform import python_version

In [2]: python_version()
Out[2]: '3.6.5'

编程入门07：Python函数定义

星辉 — Tue, 20 Mar 2018 21:01:52 +0800

你己经接触过很多的函数，现在让我们尝试定义自己的函数——这需要使用def关键字。函数定义好后即可调用，以下是在交互模式中定义并调用了一个非常简单的函数：

In [1]: def welcome():
   ...:     """输出欢迎信息"""
   ...:     print("欢迎光临！")
   ...:     

In [2]: welcome()
欢迎光临！

In [3]: type(welcome)
Out[3]: function

In [4]: help(welcome)
Help on function welcome in module __main__:

welcome()
    输出欢迎信息


In [5]:

你可以发现函数并不神秘，只是把一段程序定义为一个对象以便重复使用而已——另外请注意用三个引号引起来的字符串，这样的字符串允许分行，当放在函数体最前面时则会成为这个函数的“文档字符串”（Docstring），help函数所显示的帮助信息就来自相应对象的文档字符串。至于函数返回值的功能则是使用return关键字实现的，如果函数没有return语句，则默认没有返回值。

接下来让我们再用海龟绘图来练习复杂一些的函数：新建文件turtledraw.pyw，定义一个五角星函数star5p，并在之后的代码中调用这个函数：

"""自定义的海龟绘图函数集
"""
import turtle as tt


def star5p():
    """画一颗五角星
    """
    t = tt.Turtle()  # 生成一个单独的海龟对象
    t.hideturtle()
    t.speed(0)
    t.color("purple")
    t.penup()
    t.begin_fill()  # 启用填充区域
    cnt = 0
    while cnt < 5:
        t.forward(20)
        t.left(72)
        t.forward(20)
        t.right(144)
        cnt += 1
    t.end_fill()


tt.TurtleScreen._RUNNING = True  # 画一个五边形
tt.color("pink")
tt.penup()
tt.begin_fill()
tt.setpos(-25, -75)
tt.pendown()
cnt = 0
while cnt < 5:
    tt.forward(100)
    tt.left(72)
    cnt += 1
tt.end_fill()
star5p()  # 调用函数画一颗五角星
tt.done()

函数在所属模块空间内分隔出一个子空间——例如star5p函数生成了一个单独的海龟对象变量t。这个变量t只在star5p函数中存在，离开这个函数就不能再使用了，而star5p函数内则可以使用在外面定义的海龟对象变量tt——变量存在并发挥作用的范围称为变量的“作用域”（Scope）。

上面程序中定义的star5p函数很不灵活，不管调用多少次都只从原点开始画一颗同样的五角星，让我们来加以改进——定义函数时加上参数变量列表：x和y变量指定五角星的坐标位置；size变量指定五角星的边长，angle变量指定五角星的倾角，在函数调用时作为参数传入的值将赋给这些变量，参数变量作用域限于函数内部：

"""自定义的海龟绘图函数集
"""
import turtle as tt

def star5p(x, y, size=20, angle=0):
    """在指定位置画一颗五角星
    """
    t = tt.Turtle()  # 生成一个单独的海龟对象
    t.hideturtle()
    t.speed(0)
    t.color("white")
    t.penup()
    t.setpos(x, y)
    t.right(angle)
    t.begin_fill()  # 启用填充区域
    cnt = 0
    while cnt < 5:
        t.forward(size)
        t.left(72)
        t.forward(size)
        t.right(144)
        cnt += 1
    t.end_fill()


def test():
    """测试绘图函数：随机画十颗五角星
    """
    from random import randint
    tt.TurtleScreen._RUNNING = True
    tt.setup(width=720, height=480, startx=None, starty=None)
    tt.hideturtle()
    tt.speed(0)
    tt.bgcolor("purple")
    tt.penup()
    cnt = 0
    while cnt < 10:
        x = randint(-300, 300)
        y = randint(-200, 200)
        s = randint(10, 30)
        a = randint(0, 72)
        star5p(x, y, s, a)  # 带参数调用五角星函数
        cnt += 1
    tt.done()


if __name__ == "__main__":  # 运行模块时调用测试绘图函数
    test()

现在的star5p函数有4个参数，前两个参数在调用时是必须传入的，后两个参数在定义时赋了默认值，在调用时如果不传入就会使用默认值——如果只传入三个参数，则第三个参数必须使用“变量名=值”的形式例如“angle=10”以避免歧义。上面的程序还定义了一个test函数，实现随机绘制十颗五角星：

程序文件turtledraw.pyw实际上就是一个自定义模块，可以使用import语句引入。模块在主名称空间中运行时__name__变量的取值是默认的"__main__"，被引入时__name__变量的取值则是模块名"turtledraw"，模块就可以据此判断自己是被运行还是被引入，从而决定是否执行test函数——推荐大家今后也都使用这样的模式，整个程序由独立的函数构成，并在最后调用一个作为入口的“主函数”。

In [1]: import turtledraw as td

In [2]: help(td)
Help on module turtledraw:

NAME
    turtledraw - 自定义的海龟绘图函数集

FUNCTIONS
    star5p(x, y, size=20, angle=0)
        在指定位置画一颗五角星
    
    test()
        测试绘图函数

FILE
    d:\test\pystudy\turtledraw.pyw



In [3]: td.__name__
Out[3]: 'turtledraw'

In [4]:

编程小提示：程序项目

任何IDE都有“工程”或“项目”（Project）的概念，实际上就是建立专门的文件夹来组织相关的程序文件。例如Spyder中创建项目是在主菜单中选择Projects > New Project...，你可以创建一个名为pyStudy的项目，把你编写的所有程序文件都放进去。以后Spyder启动时会自动打开最近的项目并将“工作目录”设为项目所在的文件夹，而不再使用默认的用户文件夹。

编程入门06：Python海龟绘图

星辉 — Thu, 15 Mar 2018 09:23:47 +0800

现在让我们开始尝试“图形用户界面”（GUI）程序的编写——Python标准库中有个turtle模块，可以生成标准的应用程序窗口进行图形绘制。turtle的绘图方式非常简单直观——想象有一只尾巴上蘸着颜料的小海龟在电脑屏幕上爬行，随着它的移动就能画出线条来，turtle程序窗口的绘图区域使用直角坐标系，海龟的初始位置在窗口绘图区正中的(0,0)点，头朝x轴的正方向。你可以先在交互模式中引入模块并练习其中的函数：

In [1]: import turtle as tt

In [2]: tt.setup()  # 设置画布，这将立即显示绘图窗口

In [3]: tt.forward(100)  # 前进100像素，这将画出一条横向线段

In [4]: tt.right(90)  # 右转90度，这将改变海龟的朝向

In [5]: tt.forward(100)  # 这将画出一条纵向线段

In [6]: tt.goto(0,0)  # 前往原点，这将完成一个等腰直角三角形

In [7]: tt.bye()  # 关闭绘图窗口

利用tutle模块能够更生动地学习流程控制概念，以下程序可以画出一个五角星——画一条线段并右转144度，如此重复五次：

import turtle as tt
tt.TurtleScreen._RUNNING = True  # 启动绘图，在IDE中运行加这句可避免报错
cnt = 0
while cnt < 5:
    tt.forward(200)
    tt.right(144)
    cnt += 1
tt.done()  # 结束绘图，这将不会关闭窗口

以下程序连续画了500条线段，每一条线段的颜色都随机，每一条线段都比前一条长1个像素，每画一条线段之后都向右转91度——于是我们得到了一个繁复的彩色螺旋图案：

import turtle as tt
from random import randint
tt.TurtleScreen._RUNNING = True
tt.speed(0)  # 绘图速度为最快
tt.bgcolor("black")  # 背景色为黑色
tt.setpos(-25, 25)  # 改变初始位置，这可以让图案居中
tt.colormode(255)  # 颜色模式为真彩色
cnt = 0
while cnt < 500:
    r = randint(0, 255)
    g = randint(0, 255)
    b = randint(0, 255)
    tt.pencolor(r, g, b)  # 画笔颜色每次随机
    tt.forward(50 + cnt)
    tt.right(91)
    cnt += 1
tt.done()

接下来让我们灵活运用turtle模块的交互功能，把上次编写的命令行式猜数游戏改造成图形界面的——请把程序文件命名为guessnum.pyw，这样当你在操作系统中直接双击时就不会再打开黑色的命令行窗口。获取用户输入可以使用对话框，反馈信息则可以直接显示在窗口绘图区域中：

from random import randint
import turtle as tt

tt.TurtleScreen._RUNNING = True
tt.setup(width=800, height=450, startx=None, starty=None)  # 设置自定义的窗口大小
tt.hideturtle()  # 隐藏画笔图标
tt.color("blue")  # 画笔颜色为蓝色
tt.penup()  # 抬起画笔，移动时不画线
tt.setpos(-300, 0)  # 设置初始位置
myfont = ("黑体", 16, "normal")  # 定义字体

target = randint(1, 100)
tt.write("我想了一个1到100之间的整数，请你猜猜看吧：", font=myfont)  # 输出文本
guess = 0
answer = ""
while guess != target:
    # 使用对话框获取用户输入
    guess = tt.simpledialog.askinteger("猜数游戏", "请输入一个整数：")
    if guess == target:
        answer = "你猜对了！游戏结束。"
    elif not guess:  # 用户没有输入数字则中断循环
        tt.clear()  # 清空画布以便输出新文本
        tt.write("你放弃了，游戏结束。", font=myfont)
        break
    elif guess > target:
        answer = "你猜大了，再猜一次："
    else:
        answer = "你猜小了，再猜一次："
    tt.clear()
    tt.write(answer, font=myfont)
tt.done()

海龟绘图很有趣，你可以查看官方在线文档以了解turtle模块的更多细节 https://docs.python.org/zh-cn/3/library/turtle.html

编程小提示：模块的运行

Python标准库中还有一个turtledemo模块，这是turtle绘图功能演示程序，输入以下系统命令即可运行turtledemo模块：

python -m turtledemo

只要模块中定义了可运行对象（实现功能或用于测试），模块就是可运行的。实际上，你也可以输入以下系统命令来运行turtle模块：

python -m turtle

编程入门05：Python流程控制

星辉 — Fri, 9 Mar 2018 12:45:49 +0800

编程时可以使用三种流程结构：按照先后顺序执行全部指令，是最普通的“顺序结构”；根据特定条件选择执行部分指令，称为“选择结构”；根据特定条件循环执行部分指令，叫做“循环结构”——流程控制语句就是用于判断条件并实现特殊流程结构的语句，而条件的判断需要进行逻辑运算或者叫“布尔运算”（得名于乔治·布尔，十九世纪英国数学家，数理逻辑学的创立者），这种运算的结果只有两种：“真”和“假”，Python有专门的关键词来表示这两个值：True和False，属于布尔类型（bool）。返回值为布尔类型的表达式就称为布尔表达式。布尔表达式中可以使用比较运算符：等于（==）、不等于（!=）、大于（>）、小于（<）、大于等于（>=）和小于等于（<=）。

In [1]: 1+1==2
Out[1]: True

In [2]: 1+1>2
Out[2]: False

In [3]: "hello"=="Hello"  # 字符串比较是基于字符的编码值
Out[3]: False

In [4]: "hello">"Hello"  # 小写字母排在大写字母后面，所以编码值更大
Out[4]: True

In [5]: "猫">"狗"  # 使用ord函数可以查看字符的编码值
Out[5]: True

布尔表达式中还可以使用布尔运算符：“与”（and）“或”（or）和“非”（not），以及成员运算符“在……之内”（in）——这两种运算都非常简单直观（如果你想知道更多细节，就输入help("and")、help("in")）：

In [6]: 1==1 and 2==2
Out[6]: True

In [7]: 1==1 and 2<1
Out[7]: False

In [8]: 1==1 or 2<1
Out[8]: True

In [9]: not 1==1
Out[9]: False

In [10]: "o" in "Hello"
Out[10]: True

In [11]: "h" in "Hello"
Out[11]: False

In [12]: "h" not in "Hello"
Out[12]: True

此外，True和False其实就是1和0，如果你输入True+True，会发现返回值是2……深入学习下去你就会知道，任何对象其实都可以拿来判断真假……

了解布尔运算之后，我们来编写一个包含条件判断和特殊流程结构的程序：猜数游戏——电脑随机生成一个1到100之间的整数，然后根据用户的猜测输出反馈信息。

新建文件并保存为 guess_number.py，开始编写程序：用random模块的randint函数随机生成整数；用input函数接收用户输入字符串并用int函数转成整数；然后进行条件判断——“如果”猜对就输出“猜对了”，if语句就是用来实现这种选择结构的；if语句中还可以加上else关键词实现所谓双分支选择结构——“如果”猜对就输出“猜对了”，“否则”就输出“猜错了”；你还可以再加上elif关键词——“如果”猜对就输出“猜对了”，“否则如果”猜大了就输出“猜大了”，“否则”就输出“猜小了”——你可以使用多个elif来实现更多分支，每个分支都可以包含多行子语句。程序写出来是这样的：

from random import randint
target = randint(1, 100)
answer = ""
guess = int(input("我想了一个1到100之间的整数，请你猜猜看吧："))
if guess == target:
    answer = "你猜对了！"
elif guess > target:
    answer = "你猜大了。"
else:
    answer = "你猜小了。"
print(answer)

这个程序等你输入一个数字并输出反馈后就立即结束了，接下来让我们加以改进：允许用户多次输入直到猜对为止，while语句就是用来实现这种循环结构的——“只要”还没猜对，就接收用户输入并输出反馈。在input语句之前添加while语句，然后选定之后的所有语句按Tab键缩进将它们变成while语句的子语句，每次判断条件成立都会执行一遍这些语句（想要了解while语句的更多细节，当然还是用老办法：help("while")）。改进后的程序是这样的：

from random import randint
target = randint(1, 100)
print("我想了一个1到100之间的整数，请你猜猜看吧：", end="")
guess = 0
answer = ""
while guess != target:
    guess = int(input())
    if guess == target:
        answer = "你猜对了！游戏结束。"
    elif guess > target:
        answer = "你猜大了，再猜一次："
    else:
        answer = "你猜小了，再猜一次："
    print(answer, end="")

这个程序就能实现猜测任意次数直到猜对为止了。

你可能会注意到Spyder右上方面板中有一个变量浏览器选项卡，其中会显示程序中变量当前的取值。如果在左边编辑器面板特定语句的行号上双击添加一个“中断点”（Breakpoint）然后选择“调试”（Debug），程序将会开始运行并在这一行暂停，这时你就可以“单步”（Step）执行，详细查看语句的整个执行流程——当程序运行结果不符合预期时，开发者就会进行这种调试工作来寻找其中的原因。

编程小提示：代码格式规范

“Python增强建议”（PEP）是面向开发者的一系列官方指导文档，其中的PEP8 https://www.python.org/dev/peps/pep-0008/ 描述了Python程序的代码格式规范（每级缩进应为四个空格，逗号之后应加空格，变量名应使用小写字母等等），遵循这个规范可以使你写的代码更专业、更美观、可读性也更强。正如PEP20即“Python之禅”所言：“Readability counts” https://www.python.org/dev/peps/pep-0020/

所有这些规范其实并不需要强记——你可以让Spyder自动检查代码格式：在主菜单中点击Tools > Preferences > Editor > Code Introspection/Analysis，勾选其中的Real-time code style analysis并确定。这时打开的程序文件中如果存在不规范的格式，语句左侧就会出现黄色感叹号图标，你可以移动鼠标到图标上查看浮动提示，遵照提示修改就可以得到完全符合PEP8规范的程序代码了。

编程入门04：Python第三方包

星辉 — Mon, 5 Mar 2018 08:39:10 +0800

从概念上说，Python中的“包”（Package）是模块的容器，其中可以包含一个或多个相关的模块。世界各地开发者基于Python编写的各种软件也是以一种标准的包形式进行分享的，称为“第三方包”。官方专门建立了“Python包索引”（PyPI） https://pypi.python.org/ 用来统一发布第三方包，相当于是Python软件的免费应用市场。于是在Python标准库之上又积累起浩如烟海的“第三方库”，形成了充满活力的开源软件生态系统。如果想利用Python进行真正的编程工作，你应当根据不同的任务选择安装适合的第三方包。

官方推荐使用pip命令来管理Python包，pip其实也是一个软件包，Python 3.4以上已经附带，不必再单独安装。pip包的发布页 https://pypi.python.org/pypi/pip

有些Python包的体积很大，从位于境外的官方源下载需要较长时间。你可以设置从中国大陆的镜像源（例如阿里云）下载软件包，这样速度会快上许多。如果你用的操作系统是Win7-10，请在资源管理器地址栏输入C:\ProgramData打开这个隐藏目录，在其中创建pip文件夹，再在其中创建pip.ini文件并复制粘贴以下内容，即配置好了镜像源：

[global]
index-url = https://mirrors.aliyun.com/pypi/simple/

[list]
format = columns

以上配置还指定了包列表的显示格式，pip详细配置说明可以在文档中查看 https://pip.pypa.io/en/stable/user_guide/#configuration

现在让我们打开命令提示符窗口（注意打开方式：右击命令提示符图标，选择以管理员身份运行，否则安装包时可能提示没有足够权限）输入以下pip命令查看已安装的包名称及版本：

pip list

你可以看到默认已有两个包：pip和setuptools，它们是用来安装和管理其他第三方包的。

接下来再尝试输入以下pip命令，安装之前提到过的Spyder：

pip install spyder

包的下载和安装需要花费一段时间，当提示完成后你可以再次查看已安装包，会发现实际上增加了几十个包——因为Spyder需要其他几十个第三方包的支持，pip会自动下载并安装所有需要的包。

现在你就可以输入spyder3命令启动Spyder了，启动时请选择允许访问网络（Spyder会联网检查版本更新），这个命令对应的可执行文件是Python安装目录下Scripts\spyder3.exe，你可以将其发送到桌面快捷方式，点击桌面图标即可启动。今后我们将会抛弃简陋的IDLE，改用Spyder这个很好很强大的开源IDE继续学习进程。

如果Spyder发布了新版本，使用加-U参数的pip install命令即可安装新版——不过镜像源同步新版本需要一些时间，如果你想第一时间安装新版，可以再用-i参数临时指定从官方源下载：

pip install -U spyder -i https://pypi.python.org/simple

以上演示了pip命令的基本操作，你可以随时使用这个工具来获取Python生态圈中数以万计的第三方包，令编程像搭积木一样方便快捷。

编程小提示：IPython

你可能已注意到Spyder默认布局右下角的交互模式面板（使用主工具栏的面板最大化按钮可以让某个面板占满整个工作区），其中的提示符和官方版的并不一样，因为Spyder集成了一个提供增强版交互模式的第三方包——IPython。你可以输入“?”来查看IPython的帮助信息（或是在“?”之后再输入特定变量名查看具体帮助信息），可以按上下方向键切换输入过的命令，还可以在任何时候按Tab键启用代码自动补全并根据输入更新代码提示，操作比IDLE省力很多。

IPython还提供了一些“魔法”命令，如清除屏幕内容命令cls、重置名称空间命令reset等都很好用。

此外你只要先输入一个“!”，就可以直接运行任何可执行程序例如pip，不必再打开操作系统的命令提示符窗口了。

In [3]: !pip list
Package                  Version  
------------------------ ---------
alabaster                0.7.10   
astroid                  1.6.1    
Babel                    2.5.3    
bleach                   2.1.2    
certifi                  2018.1.18
chardet                  3.0.4    
cloudpickle              0.5.2    
colorama                 0.3.9    
decorator                4.2.1    
docutils                 0.14     
entrypoints              0.2.3    
html5lib                 1.0.1    
idna                     2.6      
imagesize                1.0.0    
ipykernel                4.8.2    
ipython                  6.2.1    
ipython-genutils         0.2.0    
isort                    4.3.4    
jedi                     0.11.1   
Jinja2                   2.10     
jsonschema               2.6.0    
jupyter-client           5.2.2    
jupyter-core             4.4.0    
lazy-object-proxy        1.3.1    
MarkupSafe               1.0      
mccabe                   0.6.1    
mistune                  0.8.3    
nbconvert                5.3.1    
nbformat                 4.4.0    
numpydoc                 0.7.0    
packaging                17.1     
pandocfilters            1.4.2    
parso                    0.1.1    
pickleshare              0.7.4    
pip                      9.0.1    
prompt-toolkit           1.0.15   
psutil                   5.4.3    
pycodestyle              2.3.1    
pyflakes                 1.6.0    
Pygments                 2.2.0    
pylint                   1.8.2    
pyparsing                2.2.0    
PyQt5                    5.9.2    
python-dateutil          2.6.1    
pytz                     2018.3   
pyzmq                    17.0.0   
QtAwesome                0.4.4    
qtconsole                4.3.1    
QtPy                     1.3.1    
requests                 2.18.4   
rope                     0.10.7   
setuptools               28.8.0   
simplegeneric            0.8.1    
sip                      4.19.8   
six                      1.11.0   
snowballstemmer          1.2.1    
Sphinx                   1.7.1    
sphinxcontrib-websupport 1.0.1    
spyder                   3.2.7    
testpath                 0.3.1    
tornado                  4.5.3    
traitlets                4.3.2    
urllib3                  1.22     
wcwidth                  0.1.7    
webencodings             0.5.1    
wrapt                    1.10.11  

In [4]:

想要详细了解IPython的增强功能，请查看在线文档 http://ipython.readthedocs.io/en/stable/

编程入门03：Python模块与库

星辉 — Sun, 25 Feb 2018 19:32:29 +0800

现在我们已经用过id()、input()、print()等多个函数，这些都是默认可用的对象。Python官方还提供了更多的可重用对象，它们分门别类地放在不同的“模块”（Module）之中，你可以在需要的时候“引入”（Import）特定的模块。引入模块之后，默认的主“名称空间”（Namespace）中就会增加指向模块对象的变量，可以使用“模块变量.成员变量”的形式对模块中的对象进行“引用”（Reference）——“.”称为引用运算符，可以读作“的”。

现在我们尝试引入数学模块math，以使用其中的数学工具：

>>> dir()  # dir函数查看主名称空间中的变量列表，默认已存在7个变量
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__']
>>> import math  # 引入math模块，也可以同时引入多个模块（用逗号分隔）
>>> dir()  # 主名称空间中增加了math变量
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'math']
>>> math  # math变量指向math模块
<module 'math' (built-in)>
>>> math.sqrt(4)  # 平方根函数
2.0
>>> math.exp(2)  # 自然常数幂函数
7.38905609893065
>>> math.pi  # 圆周率常数
3.141592653589793
>>> math.e  # 自然常数
2.718281828459045
>>> dir(math)  # dir函数查看math模块的成员
['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc']

每个模块都拥有自己的名称空间，这样变量名只需在本名称空间中不重复即可。用模块名称作为dir函数的参数，就可以查看模块名称空间中的变量列表。如果想要知道每个函数如何使用，则可以使用help函数：

>>> help(math.exp)
Help on built-in function exp in module math:

exp(...)
    exp(x)
    
    Return e raised to the power of x.

接下来尝试引入用于子进程管理的模块subprocess，这次增加了as关键词，可以指定变量名称而不使用默认名称：

>>> import subprocess as sp  # 引入subprocess模块，自定义变量名sp（模块名太长引用起来不方便）
>>> sp.call("cmd")  # call函数调用命令提示符程序cmd.exe（可以调用任何可执行程序）

再来尝试用于生成随机数的模块random，这次再换一种写法——直接将其中的某个变量引入主名称空间（也可以同时引入用逗号分隔的多个变量）：

>>> from random import randint  # 从random模块引入randint方法
>>> help(randint)  # 查看randint的说明：随机返回指定开区间内的整数
Help on method randint in module random:

randint(a, b) method of random.Random instance
    Return random integer in range [a, b], including both end points.

>>> randint(1,6)  # 随机生成1到6之间的整数，即模拟掷骰子
5
>>> randint(1,6)
2

这样引入的变量就能象input、print那样直接使用了，如果写成“from random import *”则会将模块中的所有成员引入主名称空间，不过实际编程中不建议这样做。

模块的集合被称为“库”（Library），Python官方提供的所有模块共同组成了庞大的“Python标准库”。在IDLE主菜单中点击 Help > Python Docs > The Python Standard Library 查看Python标准库的详细说明，官网也提供了在线版本 https://docs.python.org/3/library/index.html 你可以先通读该页面建立起对Python标准库的大致印象，今后有需要时就能知道可以引入什么模块，再用dir函数配合help函数查看具体用法。

你可能注意到了主名称空间默认存在的7个变量中有一个“__builtins__”，它指向一个名为builtins的模块，只要你dir一下就会找到input、print等等熟悉的名字——这些函数之所以默认可用，就是因为Python解释器自动引入了builtins这个模块：

>>> __builtins__
<module 'builtins' (built-in)>
>>> import builtins
>>> id(__builtins__)
2723238745656
>>> id(builtins)
2723238745656

编程小提示：Python之禅

Python标准库中有一个小彩蛋，只要你引入this这个模块，就能看到一段“Python之禅”，这是一位Python核心开发者对于程序设计的心得感悟，文笔饶有趣味，让我们在学习Python的过程中慢慢体会其中蕴含的丰富哲理吧……

>>> import this
The Zen of Python, by Tim Peters
蟒宗之禅语，提姆彼得斯（中文是我加的，参考了几种网上的译文）

Beautiful is better than ugly.
优美胜于丑陋
Explicit is better than implicit.
明白胜于晦暗
Simple is better than complex.
简洁胜于繁复
Complex is better than complicated.
繁复胜于艰深
Flat is better than nested.
扁平胜于嵌套
Sparse is better than dense.
松散胜于聚集
Readability counts.
代码确保易读
Special cases aren't special enough to break the rules.
规则拒绝特例
Although practicality beats purity.
实用不求纯净
Errors should never pass silently.
错误不可放过
Unless explicitly silenced.
除非明确理由
In the face of ambiguity, refuse the temptation to guess.
模棱两可之间，不要随意猜测
There should be one-- and preferably only one --obvious way to do it.
必有唯一选择，明显胜过其余
Although that way may not be obvious at first unless you're Dutch.
起初无法分辨，只因你非大神
Now is better than never.
尝试好过放弃
Although never is often better than *right* now.
但须谋定而动
If the implementation is hard to explain, it's a bad idea.
实现难以解释，定是糟糕方案
If the implementation is easy to explain, it may be a good idea.
实现易于解释，或为良好方案
Namespaces are one honking great idea -- let's do more of those!
名称空间极好，诸君多加使用！

编程入门02：Python基础语法

星辉 — Tue, 20 Feb 2018 08:07:41 +0800

现在让我们从基础概念开始逐步探索Python的语法，编程语言包含多种指令，其中最基本的是“表达式”（Expression），表达式有特定的“值”（Value），例如：1就是一个最简单的表达式，它的值就是1，当你在交互模式下输入1，计算机会返回这个表达式的值1。使用“运算符”（Operator）可以将多个单一表达式组成复合表达式，例如：1+1，Python中的数学运算符除了加减乘除（+-*/）外还有整除（//）取余（%）和乘方（**），运算顺序遵循数学规则，括号可以改变运算顺序，但注意一律使用小括号。通过这样的层层组合，你可以输入任意数学运算式所对应的表达式，计算机总是会自动计算并返回单一的值。

这个单一的值被称为“物件”或“对象”（Object），对象是一个非常关键的概念，你很快就会发现在Python中“一切皆对象”。每个对象都存在于计算机的内存空间，拥有唯一的编号和确定的类型，你可以用id(对象)来查看它的编号（所在的内存地址），用type(对象)来查看它的类型（所属的“类”名称）：

>>> id(1)
1756786144
>>> id(5%2)
1756786144
>>> id(2)
1756786176
>>> type(1)
<class 'int'>
>>> type(2)
<class 'int'>
>>> id(1.0)
2705425373944
>>> type(1.0)
<class 'float'>

你可以看到1是整数类型（int），带有小数点的1.0则是浮点类型（float），浮点类型用于表示实数。其实我们还接触过字符串类型（str），在任意长度的字符序列前后加上引号就定义了一个字符串，字符串支持加法（通过连接生成新字符串）和乘法（通过重复生成新字符串）：

>>> "你好"
'你好'
>>> "你好"+"世界！"
'你好世界！'
>>> "你好世界！"*3
'你好世界！你好世界！你好世界！'
>>> type("你好世界！"*3)
<class 'str'>

和数学中一样，你可以用“变量”（Variable）来代表某个数值，这称为变量“赋值”（Assign），变量名可以使用字母（区分大小写）、数字（但不能以数字开头）和下划线，也可以使用任何全角字符包括所有汉字（但建议不要用全角字符）。变量不能和Python语言的关键词重名，否则执行时会报语法错误，你可以输入help("keywords")查看关键词列表。变量赋值语句的基本写法是：变量名=表达式，注意“=”应该读作“赋值”（Python中的等于号是==），一个变量也就是一个单一表达式：

>>> x=1
>>> x+2
3
>>> x,y=1,100  # 同时给多个变量赋值
>>> x
1
>>> y
100
>>> x=x+1  # x原值加1再赋值给x
>>> x
2
>>> x+=1  # x原值加1再赋值给x的简洁写法
>>> x
3
>>> x,y=y,x  # 对调两个变量所指的对象，其他编程语言基本都需要三条指令才能实现这个操作……
>>> x
100
>>> y
3
>>> type(x)
<class 'int'>
>>> x="你好世界！"
>>> x*2
'你好世界！你好世界！'
>>> y=x  # 两个变量指向了同一个对象
>>> id(x)
2565766974768
>>> id(y)
2565766974768
>>> 类型=type
>>> 类型(y)
<class 'str'>
>>> 类型(id)
<class 'builtin_function_or_method'>
>>> 类型(类型)
<class 'type'>

现在你可能会猜到了，这些id(1)、type(1)，还有我们已经接触过的print("Hello World!")也属于复合表达式，id、type、print也是指向某个对象的变量，这种对象是可以做“调用”（Call）运算的，在Python中分为“函数”（function）、“方法”（method）和“类型”（type）等类型，相当于数学中函数的概念。函数名就相当于运算符，参加运算的表达式放在函数名之后的括号里，称为“参数”（Parameter），如果有多个参数就用逗号分隔，而运算的结果就是函数的返回值。例如max函数可以从多个数中找出最大值：

>>> max
<built-in function max>
>>> max(1,3,9,2)
9
>>> type(max)
<class 'builtin_function_or_method'>
>>> type(max(1,3,9,2))
<class 'int'>

函数能完成各种复杂的功能。例如之前看到的input函数，可以接受一个字符串参数，执行时会显示此字符串作为提示，然后将用户在按回车键之前输入的全部内容作为字符串返回，也可以写成不带参数的input()，执行时就不显示任何提示。print函数同样可以不带参数，这将输出一个空行；也可以带任意多个参数，这将输出以空格分隔的多个值。注意：print函数输出的内容并不是它的返回值，print函数无返回值——或者可以说print函数返回值为“空”，Python专门定义了一个关键词None来代表空值（类型为NoneType），当返回值为空时不显示任何东西，如果你想强制输出空值，可以print(None)：

>>> None
>>> print(None)
None
>>> print(1,2,3)
1 2 3
>>> print(print(1,2,3))  # 内层print输出三个参数的值，外层print输出内层print返回的空值
1 2 3
None

总而言之，Python语言中的变量就是贴在对象上的标签，所以它还有一个更笼统的叫法——标识符（Identifier）。变量没有确定的类型，它所指向的对象有确定的类型。在Python关键词以外的任何名称例如print也就是一个指向具体对象的变量而已，你完全可以把它指向别的对象（当然不建议这样做）：

>>> p=print  # p和print都指向同一个函数对象
>>> p(x)
你好世界！
>>> print=10  # print指向一个整数对象了
>>> print(x)  # 如果尝试调用运算，会提示类型错误“int对象是不能调用的”
Traceback (most recent call last):
  File "<pyshell#26>", line 1, in <module>
    print(x)
TypeError: 'int' object is not callable

* 编程小提示：Python解释器的源码

官方Python解释器是用C语言编写的，称为CPython，你可以在这里查看CPython的源代码 https://github.com/python/cpython

如果你想知道所有内建函数是怎样实现的，可以打开这个C文件，例如其中的builtin_print函数就对应Python中的print函数 https://github.com/python/cpython/blob/master/Python/bltinmodule.c

编程入门01：Python程序运行

星辉 — Thu, 15 Feb 2018 13:40:13 +0800

你已尝试过使用Python解释器，这是一个命令行程序，必须通过键盘输入完成所有操作。人们通常都会使用某种“集成开发环境”（Integrated Development Environment，简称IDE），在更方便的图形用户界面中编写、运行和调试程序。Python官方发行版带有一个简单的IDE叫做IDLE，意思是“集成开发与学习环境” （Integrated Development and Learning Environment），打开方法是点击Python 3.6程序组中的IDLE菜单项。IDLE窗体带有标准的菜单栏，在基本的命令行操作之外还提供编辑器等增强功能，它会调用下层的Python解释器来具体执行指令。

我们使用IDLE来编写一段由7行语句组成的程序，计算1累加至n的结果。它的结构更为完整：首先接收用户的“输入”，然后进行特定的“处理”，最终将处理结果“输出”（注意#后的文本是注释，用来对语句进行说明，可以不必输入）

n = int(input("计算1累加至n，请输入n："))    # 获取输入的字符串，转换为整数，赋值给变量n
x = 1    # 变量x赋值1
result = 0    # 变量result赋值0
while x <= n:    # 当x小于等于n时循环执行子语句
    result += x    # result原值加x
    x += 1    # x原值加1
print("1累加至{}的结果是{}".format(n, result))    # 输出包含n和result的字符串

用户在>>>提示符后输入语句，系统即时反馈结果，这叫“交互模式”。交互模式下必须执行完一条语句再输入下一条语句，如果以复制粘贴的方式输入了多条语句，执行时就会提示语法错误“存在多条语句”（SyntaxError: multiple statements found while compiling a single statement）

交互模式下输入的语句会临时保存，你可以按Alt-P和Alt-N前后切换已输入的语句，在回车执行之前可以修改当前语句。交互模式可以用于查看信息，例如输入help()打开帮助界面，输入dir()列出当前空间所有对象的名称；交互模式也适合用来进行测试，它会自动输出语句的“返回值”，例如你想知道2的20次方是多少，输入2**20就好了，不需要输入print(2**20)。

首行末尾带冒号，后面跟多行缩进子句的算一条“复合语句”，在交互模式下，复合语句要按两次回车键才会执行，例如累加程序中从while开始的三行语句就是一条复合语句，如果不按两次回车结束复合语句而继续输入后面的语句，执行时也会提示语法错误。（注意：缩进的统一规范为4个空格）

如果你的程序需要保留并重复使用，应该按Ctrl+N（或点菜单栏“File”>“New File”）新建一个.py文件来编写程序代码并保存到指定的文件夹，例如D:\Test\accumulate.py，然后按F5（或点菜单栏“Run”>“Run Module"）执行这个文件，这是Python程序运行的标准模式。

你的程序也能直接在操作系统中运行：要运行已保存的accumulate.py文件，就打开系统命令行窗口切换到accumulate.py文件所在目录再输入python accumulate.py（如果文件不在当前目录，就要加上路径）；或者在文件夹窗口中双击accumulate.py文件（在这种方式下程序结束时会自动关闭命令行窗口，所以如果你想看清输出内容，可以在末尾再加一行语句input("按回车键退出程序")）

* 编程小提示：Python的IDE介绍

IDLE其实就是一个用Python写的程序，你可以在Python安装目录的Lib\idlelib的文件夹下找到idle.pyw文件，双击一下试试看（.pyw是指窗口模式Python文件，系统执行此类文件时将不会打开黑色的命令行窗口） https://docs.python.org/3/library/idle.html

你还可以使用更专业的IDE，例如同样用Python写的Spyder（上次提到的Anaconda就集成了这个IDE） https://github.com/spyder-ide/spyder

以及用Java写的PyCharm，也有很多人在使用 https://www.jetbrains.com/pycharm/download

个人觉得对新人最友好的IDE是Visual Studio，2017版正式加入了Python语言支持 https://www.visualstudio.com/zh-hans/vs/

编程入门00：Python软件安装

星辉 — Sat, 10 Feb 2018 19:59:34 +0800

“轻松学编程”系列教程从今天开始更新，欢迎加入计算机编程学习之旅——“程序”（Program）是指控制计算机运行的指令序列，“编程”（Programming）就是针对特定的任务而编写特定的程序。在信息化社会中，编程已成为一项基本技能，不论你从事何种工作，只要用得着计算机，学会编程都能带来很大的帮助。编程需要使用某种编程语言，例如Python——这是一种被广泛使用的编程语言，在科学计算、数据处理和人工智能等许多领域都发挥着重要的作用，并且其语法简洁、自然而优雅，非常适合作为初学者的入门语言。Python的创造者是荷兰人 Guido van Rossum，Python的官方网站是 https://www.python.org/

使用Python首先需要安装Python软件，最基本的Python软件是Python语言解释器——它能把Python语言翻译为底层的机器语言。Python软件可以在官方网站下载，现在推荐学习Python 3，请不要下载Python 2，两者的语法有不少差异。

当前（2018年2月）最新正式稳定版本是3.6.4，官方下载页面提供了适用于不同操作系统的安装程序 https://www.python.org/downloads/release/python-364/
Python 3.6.4 Windows 64位安装程序 https://www.python.org/ftp/python/3.6.4/python-3.6.4-amd64.exe
Python 3.6.4 Windows 32位安装程序 https://www.python.org/ftp/python/3.6.4/python-3.6.4.exe

注意：Windows XP系统无法使用最新版本，只能安装3.4.4 https://www.python.org/downloads/release/python-344/
Python 3.4.4 Windows 64位安装程序 https://www.python.org/ftp/python/3.4.4/python-3.4.4.amd64.msi
Python 3.4.4 Windows 32位安装程序 https://www.python.org/ftp/python/3.4.4/python-3.4.4.msi

Python的下一个主要版本3.7正在开发中，已于2017年9月发布第一个预览版，预计于2018年6月发布正式版。

Python还有其他发行版，主要是在官方版之上集成了许多第三方软件包省得一个个单独安装，例如Anaconda https://www.anaconda.com/download/，如果你安装其他发行版就不需再装官方版。

下图显示的是在Windows 10系统中运行Python 3.6.4安装程序，请注意要选择添加环境变量（Add Python 3.6 to PATH）再开始安装（Install Now）——这个选项默认并没有勾选，如果你不添加环境变量，将来你在Windows命令提示符窗口输入python、pip等命令时会提示找不到这些命令，除非你切换路径到这些命令文件所在的目录（或是在命令前面加上路径）。

为了方便使用，推荐你选择自定义安装（Customize installation），在高级选项窗口中勾选为所有用户安装（Install for all users）、添加环境变量（Add Python to environment variables）以及预编译标准库（Precompile standard library），如有必要还可以自定义安装位置（Customize install location）再开始安装（Install）。

安装完成后，你就可以在开始菜单找到并点击Python 3.6程序组的Python 3.6菜单项（Win10系统在开始菜单输入python即可筛选出此菜单项）打开Python解释器窗口编写程序了，你可以看到Python解释器就是一个可执行文件（python.exe）。按照惯例，请输入下面的语句并按回车键执行：

print("Hello World!")

这行语句的字面意思很容易理解：打印“Hello World!”，我们看到计算机立即准确地执行了这行语句：在屏幕上输出“Hello World!”

祝贺你，你完成了Hello World程序的编写，迈出了编程之路的第一步！

* 编程小提示：Hello World 程序

“Hello World 程序”是指在计算机屏幕上输出“Hello World”这行字符串的计算机程序。这通常是每一种计算机语言中最基本最简单的程序，亦通常是初学者尝试编写的第一个程序。

The Hello World Collection 是一个专门收集 Hello World 程序的因特网页面，目前已有571种程序语言和76种人类语言。