信息管理专业Python教程

Transcription

1

2 目 錄 1. 介 i. 者 序 ii. 作 者 序 2. 什 么 要 学 程 3. 量 表 式 与 句 4. 条 件 行 5. 函 数 6. 迭 代 7. 字 符 串 8. 文 件 9. 列 表 10. 字 典 11. 元 12. 正 表 式 13. 网 程 14. Web Services 15. 数 据 与 化 言 SQL 16. 数 据 可 化 17. 常 任 自 化 理 18. 附 A 19. 附 B 20. 附 C 2

3 介 Python for Informatics( 中 文 版 ) 信 息 管 理 Python 教 程 程 初 学 者, 介 如 何 程, 使 用 Python 行 数 据 理 与 数 据 可 化 本 旨 在 透 数 据 探 索 的, 向 学 生 介 程 与 算 思 Python 可 比 子 表 格 强 大 的 解 决 工 具 Python 是 一 种 易 于 使 用 与 学 的 程 言, 在 Windows Mac 与 Linux 算 机 上 都 可 以 免 取 本 采 用 署 名 - 非 商 性 使 用 - 相 同 方 式 共 享 可 形 式, 提 供 各 种 子 格 式 的 免 下 外, 本 配 套 一 免 在 自 学 程 ( 中 所 有 内 容 材 料 是 开 放 的, 可 用 于 改 翻 明 得 益 于 开 源 与 共 享 精 神, 根 据 知 共 享 CC-BY-SA, 由 作 者 授, 本 的 体 中 文 版 翻 与 开 放 出 版 得 以 利 完 成 翻 工 作 由 范, 得 到 四 川 大 学 公 共 管 理 学 院 信 息 管 理 合 室 的 大 力 支 持, 胡 康 林 校 了 本 并 提 出 宝 意, 信 息 管 理 与 信 息 系 位 本 科 生 参 与 了 部 分 章 的 翻 与 校 功 翻 第 章 及 附 王 翻 第 章 范 翻 第 章, 稿 与 定 稿 由 于 精 力 与 水 平 有 限, 中 翻 在 所 免 迎 各 位 者 批 指 正, 我 会 汲 取 建, 及 行 修 勘 献 感 志 暹 正 了 文 中 的 一 些 和 提 出 Gitbook Markdown 法 解 析 介 3

4 者 序 翻 普 遍 被 出 力 不 好, 次 我 把 翻 当 成 一 件 情 的 活 来 干 了 本 序 由 4 个 和 1 个 明 成, 希 望 能 引 起 相 关 者 的 共 什 么 要 冠 以 信 息 管 理 之 名? Informatics 在 中 文 境 下 是 个 神 秘 的, 有 情 学 信 息 学 等 法, 但 个 名 称 都 不 合 适 国 内 的 情 学 不 是 搞 的, 信 息 学 是 搞 通 的 在 信 息 的 世 界 里, 美 的 会 无 不 在 通 俗,Informatics 属 于 信 息 管 理 大 范 畴, 是 信 息 管 理 活 的 高 段, 通 数 据 分 析 与 掘, 提 供 管 理 与 决 策 有 价 的 信 息 ( 即 情 ) 信 息 管 理 听 起 来 非 常 有 魅 惑 力 从 早 期 一 波 波 的 数 字 化 浪 潮 到 当 代 的 大 数 据, 信 息 管 理 无 可 争 地 在 信 息 化 代 革 的 先, 一 直 与 各 型 数 据 ( 里 可 信 息 的 体 ) 打 交 道 个 的 主 是 数 据 ( 信 息 ) 的 建 采 集 加 工 与 分 析 利 用 等 什 么 信 息 管 理 要 学 程? 信 息 管 理 离 不 开 信 息 技, 倒 不 如 各 信 息 技 是 解 决 信 息 管 理 中 的 而 被 明 的 依 据 此 理, 学 程 是 用 技 方 法 与 工 具 来 解 决 信 息 管 理 中 的 具 体 和 提 高 工 作 效 率 看 似 有 道 理, 但 中 程 个 的 学 生 感 到 困 惑 和 畏 惧, 常 常 与 算 机 的 程 混 淆 重, 学 起 来 既 无 趣 又 痛 苦 什 么 是 Python? C 言 是 大 多 数 信 息 管 理 开 的 第 一 程 毋 庸 置 疑, 学 C 言 首 先 从 程 思 想 上 武 装 了 初 学 者 然 而, 信 息 管 理 的 学 生 未 来 并 不 打 算 从 事 程 言 本 身 的 研 究, 更 多 想 要 用 程 工 具 来 解 决 外, 信 息 管 理 程 体 系 里 并 没 有 多 的 程 深 入 程, 程 入 与 用 接 比 薄 弱 或 直 接 偏 向 了 信 息 系 开 ( 管 理 信 息 系 方 向 ), 学 生 从 C 言 向 其 他 眼 花 乱 的 高 程 言 感 到 困, 致 学 的 成 就 感 普 遍 不 高 学 了 程, 拿 着 一 全 国 算 机 等 考 C 言, 没 有 什 么 意, 用 不 起 来 是 最 大 的 所 在 Python 言 的 功 能 全 面 性 与 易 于 学 等 特 点 在 程 言 入 广 泛 流 行, 近 些 年 可 以 是 深 得 民 心 除 了 言 本 身 的 点 之 外,Python 言 非 常 适 合 信 息 管 理, 原 因 在 于 它 的 功 能 性 全 面 渗 透 到 信 息 管 理 的 各 个, 如 中 介 的 文 本 理 数 据 采 集 数 据 存 与 用 Web Services 等 主 由 Python 做 到 了 很 好 的 知 串 可 以,Python 提 供 了 程 学 与 技 用 通 的 一 化 平 台 本 将 Python 言 的 解 与 具 体 数 据 管 理 相 合, 在 一 定 程 度 做 到 了 学 会 即 用, 是 目 前 比 少 的 适 合 信 息 管 理 的 程 入 教 材 什 么 要 翻 本? 开 篇 也 提 到 是 有 情 的 事 儿 去, 我 曾 是 国 内 最 早 一 批 信 息 管 理 与 信 息 系 的 学 生, 在, 我 是 个 的 一 名 教 十 多 年 来 与 个 共 同 成, 自 身 也 了 程 的 种 种 迷 茫 与 困 惑 随 着 信 息 技 的 快 速 化, 教 学 内 容 与 手 段 的 与 俱 也 得 非 常 必 要 工 作 之 后, 我 看 到 了 Python 来 打 通 信 息 管 理 程 学 症 的 可 能 性, 开 始 翻 各 Python 籍 眼 前 的 本 人 眼 前 一 亮, 我 非 常 同 本 作 者 的 教 学 理 念, 他 的 努 力 信 息 管 理 学 生 能 松 愉 悦 地 学 一 功 能 强 大 的 用 型 高 程 言 通 翻 本, 希 望 更 多 信 息 管 理 的 学 生 能 找 到 程 入 的 匙, 将 Python 作 通 向 数 据 管 理 与 分 析 技 能 养 成 的 一 座 梁, 少 走 一 些 弯 路 我 而 言, 更 多 是 在 未 来 的 教 学 中 引 入 Python 内 容, 出 适 合 国 内 信 息 管 理 的 数 据 技 能 用 型 程 如 何 本? 者 序 4

5 然 本 不 需 要 什 么 技 基, 但 最 好 具 操 作 系 数 据 与 互 网 的 一 些 基 知 本 内 容 分 大 部 分 : 第 1-10 章 涵 盖 Python 言 的 基 知 ; 第 章 是 Python 在 数 据 管 理 与 分 析 中 的 用 中 的 所 有 示 例 与 代 均 可 免 下, 建 操 作, 手 并 用 收 才 会 更 多 章 的 程 序 代 相 复, 如 果 感 到 自 学 度 大, 可 先 按 照 中 解, 行 源 代, 出 果 看 效 果, 走 通 之 后 再 回 来 慢 慢 研 究 代 工 欲 善 其 事 必 先 利 其 器 正 如 本 的 副, 希 望 Python 能 成 你 学 道 路 上 探 索 信 息 世 界 的 一 把 利 器 致 首 先 要 感 美 国 密 西 根 大 学 信 息 学 院 Charles Severance 教 授 的 慷 慨 支 持, 使 得 本 得 以 利 自 由 出 版 技 翻 不 是 的 文 字 工 作, 心 力, 事 无 巨 也 以 做 到 不 出 从 目 到 完 成 近 3 个 月 感 段 以 来 目 提 供 支 持 和 关 心 我 的 所 有 人, 没 有 你 的 鼓 励 与 帮 助, 凭 我 个 人 无 法 完 成 工 作, 段 令 人 忘 感 一 路 有 你! 范 四 川 大 学 信 息 管 理 技 系 2015 年 6 月 于 雪 城 者 序 5

6 作 者 序 信 息 管 理 Python 教 程 : 一 本 混 的 开 源 在 学 界, 科 研 人 不 断 被 洗 的 是 表 或 消 亡, 从 开 始 造, 做 出 原 始 新 本 不 是 原 始 新, 而 是 像 算 机 科 学 家 一 思 考 Python ( 以 下 称 思 考 Python )(Allen B. Downey, Jeff Elkner 等 著 ) 本 的 一 次 混 2009 年 12 月, 我 在 密 西 根 大 学 准 授 SI502- 网 程 ( 第 五 学 期 开 ), 决 定 开 始 写 一 本 重 于 数 据 探 索, 而 不 是 理 解 算 法 与 抽 象 理 的 Python 教 材 我 的 SI502 程 目 是 培 养 学 生 使 用 Python 的 生 数 据 理 技 能 我 的 学 生 中 很 少 有 人 打 算 成 算 机 程 序 相 反, 他 的 划 是 理 律 生 物 学 家 学 家 等 他 希 望 在 所 从 事 的 行 中 能 熟 用 技 我 似 乎 找 不 到 适 合 的 Python 教 材, 重 以 数 据 中 心 的, 因 此 我 决 定 要 写 一 本 我 打 算 利 用 假 期 从 写 本, 所 幸, 在 放 假 前 三 周 的 教 工 会 上,Atul Prakash 博 士 我 一 本 思 考 Python, 他 在 那 个 学 期 使 用 本 授 Python 程 是 一 本 很 棒 的 算 机 教 材, 特 点 在 于 篇 幅 短 直 白 的 解 以 及 易 于 学 本 的 整 体 已 整 尽 可 能 快 速 地 解 决 数 据 分 析, 包 括 一 系 列 从 基 到 高 的 可 行 的 数 据 分 析 示 例 与 第 2-10 章 与 思 考 Python 内 容 似, 主 要 区 如 下 : 面 向 数 的 示 例 与 被 面 向 数 据 的 取 代 ; 主 的 序 按 照 循 序 原, 从 数 据 理 到 复 的 数 据 分 析 解 决 方 案 ; 一 些 主, 例 如 try 与 except 整 到 前 面, 作 第 3 章 条 件 的 部 分 内 容 由 于 函 数 比 抽 象, 没 有 早 出, 当 需 要 理 程 序 的 复 性 才 予 以 介 几 乎 所 有 用 定 的 函 数 都 从 第 4 章 的 例 代 与 中 移 除 了 本 不 会 出 1 个 第 1 章 和 第 章 的 内 容 都 是 全 新 的, 主 要 介 Python 的 用, 包 括 一 些 用 于 数 据 分 析 的 Python 示 例, 例 如, 搜 索 与 解 析 的 正 表 式, 算 机 上 任 的 自 化 行, 通 网 索 数 据, 采 集 网 数 据,Web Services 的 使 用, 解 析 XML 与 JSON 数 据, 使 用 化 言 SQL 行 数 据 的 建 与 使 用 等 本 做 出 些 整 的 最 目 是, 从 算 机 角 向 信 息 管 理 角, 涵 盖 技 入 程 必 需 的 主, 即 使 的 学 生 并 不 打 算 成 的 程 序 也 会 感 到 有 用 本 感 趣 的 学 生 想 要 一 步 探 索 的, Alle B. Downey 的 思 考 Python 由 于 本 的 内 容 存 在 多 重, 学 生 能 从 那 本 中 快 速 掌 握 更 多 技 程 技 能 与 提 升 算 法 思 考 能 力 外, 本 的 写 作 格 相 似, 完 本 之 后 能 很 容 易 通 思 考 Python 思 考 Python 本 的 版 所 有 者 Allen 授 我 中 内 容 的 版 做 了 修 改, 将 本 中 保 留 的 他 中 的 内 容 可 从 GNU 自 由 文 档 可 更 最 近 流 行 的 知 共 享 以 相 同 方 式 共 享 (CC-BY-SA) 一 做 法 符 合 开 放 文 档 可 从 GFDJ 到 CC- BY-SA 的 ( 如, 基 百 科 的 授 方 式 ) CC-BY-SA 可 保 留 了 最 著 的 版, 同 又 允 新 作 者 直 接 重 用 中 他 得 合 适 的 内 容 我 得 本 是 教 学 料 开 放 的 一 个 典 范, 未 来 的 教 育 而 言 非 常 重 要 感 Alleb B. Downey 和 大 学 出 版 社 做 出 的 前 瞻 决 定, 本 可 以 在 开 放 版 下 出 版 希 望 他 我 努 力 的 果 感 到 欣 慰, 我 也 希 望 者 我 的 集 体 努 力 感 到 高 我 要 感 Allen B. Downey 与 Lauren Cowles 在 解 决 本 版 提 供 的 帮 助 耐 心 与 指 Charles Severance Ann Arbor, MI, USA 2013 年 9 月 9 号 Charles Severance 博 士 是 密 西 根 大 学 信 息 学 院 的 床 副 教 授 1. 当 然, 里 出 的 除 外 作 者 序 6

7 作 者 序 7

8 第 1 章 什 么 要 学 程 程 是 一 极 具 造 性 和 有 益 的 活 程 的 原 因 很 多, 大 到 生 去 解 决 一 个 困 的 数 据 分 析, 小 到 因 帮 助 人 解 决 一 个 而 得 快 本 假 定 每 个 人 都 需 要 知 道 怎 程, 一 旦 学 会 程, 你 就 会 想 要 用 个 新 技 能 做 些 什 么 了 我 的 日 常 生 活 中 算 机 无 不 在, 大 到 本, 小 到 手 机 些 算 机 可 帮 助 我 打 理 很 多 事 情 的 私 人 助 理 如 今 的 算 机 硬 件 从 根 本 上 是 建 在 不 断 回 答 我 提 的 基 上, 即 下 一 步 想 要 做 什 么? 程 序 在 硬 件 之 上 添 加 了 操 作 系 和 用 程 序, 我 手 中 拿 到 的 成 品 是 一 个 很 有 用 的 个 人 数 字 助 理 (PDA,Personal Digital Assistant), 它 能 帮 我 理 很 多 不 同 的 事 情 算 机 行 速 度 很 快 并 有 大 量 的 内 存, 如 果 我 知 道 了 如 何 与 算 机 通, 告 算 机 想 要 它 接 下 来 做 什 么, 更 好 地 使 用 算 机 很 有 帮 助 如 果 掌 握 了 算 机 通 言, 就 能 算 机 根 据 我 的 意 愿 完 成 一 些 重 复 性 工 作 有 趣 的 是, 算 机 能 任 并 且 做 得 很 好 的 工 作 就 是 那 些 常 我 人 感 到 无 聊 令 人 麻 木 的 事 情 例 如, 本 章 的 前 三 段, 找 出 出 率 最 高 的 是 一 个, 以 及 个 共 出 了 多 少 次 尽 管 你 能 在 短 内 和 理 解 些 文 字, 但 要 它 行 就 很 痛 苦 了 不 是 人 的 大 擅 解 决 的 算 机 恰 好 相 反, 很 像 人 一 和 理 解 一 段 文 字, 但 是 行 文 字 并 告 你 出 率 最 高 的 及 其 出 次 数, 算 机 而 言 却 是 非 常 容 易 的 : python words.py Enter file:words.txt to 16 个 人 信 息 分 析 助 理 很 快 告 我, to 在 本 章 前 三 段 中 一 共 出 了 16 次 事 上, 算 机 擅 做 人 不 擅 做 的 事, 就 是 什 么 你 需 要 熟 掌 握 一 与 算 机 的 言 一 旦 学 会 新 言, 你 就 可 以 将 枯 燥 的 工 作 指 派 你 的 算 机 搭 档 了, 留 出 更 多 的 去 做 适 合 你 自 己 的 事 在 种 合 作 关 系 中, 你 的 献 是 才 思 直 力 和 造 力 1.1 新 与 机 本 不 是 程 序 准 的, 程 是 份 非 常 有 前 途 的 工 作, 可 算 是 物 与 精 神 双 丰 收 他 人 造 有 用 的 的 与 智 能 的 程 序 是 一 新 性 很 强 的 活 你 的 算 机 或 PDA 通 常 安 装 了 来 自 多 不 同 程 序 开 的 各 种 件, 每 一 款 件 都 想 要 吸 引 你 的 注 意 力 和 趣 它 尽 其 所 能 来 足 你 的 需 求, 在 使 用 程 中 你 得 的 用 体 在 某 些 情 况 下, 当 你 了 一 个 件, 个 件 的 开 者 就 会 因 你 的 而 直 接 得 收 益 如 果 将 程 序 看 作 是 程 序 的 新 性 出, 那 么 下 就 是 一 个 更 形 象 的 PDA 模 型 : 什 么 要 学 程 8

9 本 的 写 作 初 衷 不 是 了 或 者 取 悦 最 用, 而 是 我 能 更 好 地 理 生 活 中 的 数 据 与 信 息 开 始 学 程, 你 既 是 程 序, 也 是 你 所 写 程 序 的 最 用 当 你 得 了 程 序 的 技 能, 如 果 程 你 感 到 有 新 活 力 的, 到 你 的 想 法 也 会 生 改, 向 他 人 开 程 序 也 不 定 1.2 算 机 硬 件 架 学 种 向 算 机 指 令 来 开 件 的 言 之 前, 我 需 要 了 解 一 下 算 机 的 成 如 果 拆 开 你 的 算 机 或 者 手 机, 仔 察 就 会 以 下 些 件 : 些 件 的 一 般 定 如 下 : 中 央 理 器 (Central Processing Unit,CPU) 是 解 决 下 一 步 做 什 么 而 存 在 的 件 如 果 算 机 理 速 度 到 3.0 GHz, 就 意 味 着 CPU 每 秒 会 提 30 次 下 一 步 做 什 么? 你 不 得 不 学 会 如 何 跟 CPU 如 此 快 速 地 交 与 保 持 同 步 主 存 器 (Main Memory) 用 来 存 CPU 即 刻 需 要 的 信 息 主 存 器 的 速 度 几 乎 与 CPU 不 相 上 下 但 是, 关 算 机 之 后 主 存 器 里 的 信 息 也 就 消 失 了 助 存 器 (Secondary Memory) 也 是 用 来 存 信 息 的, 但 是 它 比 主 存 器 速 度 慢 很 多 助 存 器 的 点 是, 它 可 以 在 算 机 不 情 况 下 存 信 息 常 助 存 器 包 括 磁 和 存 存 通 常 用 在 U 和 便 携 式 音 播 放 器 上 入 出 (Input and Output Devices) 包 括 屏 幕 鼠 麦 克 声 器 以 及 触 摸 板 等 些 都 是 用 来 与 算 机 行 交 互 的 如 今 大 多 数 算 机 之 建 立 了 网 接, 通 网 取 信 息 我 可 以 将 网 看 成 信 息 存 与 索 速 度 很 慢 的 一 个 空, 而 且 不 是 那 么 定 从 某 种 意 上, 网 是 速 度 很 慢 且 并 不 是 那 么 可 靠 的 助 存 器 些 件 的 工 作 原 理 最 好 是 交 算 机 厂 商 吧 里 只 是 了 掌 握 一 些, 在 程 方 便 提 及 些 件 作 一 名 程 序, 你 的 工 作 就 是 利 用 并 些 源 来 解 决 和 分 析 数 据 作 程 序, 你 主 要 与 CPU 打 交 道, 告 它 下 一 步 做 什 么 有, 你 要 告 CPU 用 主 存 器 助 存 器 网 或 入 出 什 么 要 学 程 9

10 你 需 要 成 回 答 CPU 下 一 步 做 什 么 的 人 但 把 你 到 5 毫 米 高, 塞 入 算 机, 你 每 秒 出 3 次 命 令, 想 必 会 很 不 舒 服 所 以, 你 必 提 前 写 好 你 的 指 令 我 把 些 存 下 来 的 指 令 称 程 序, 写 指 令 并 行 的 活 称 之 程 1.3 理 解 程 在 本 其 他 章 中, 我 把 你 培 养 成 一 名 理 解 程 并 具 一 定 程 能 力 的 人 最 后, 你 会 成 一 个 程 序, 也 不 是 的 但 至 少 你 掌 握 了 如 何 看 待 数 据 ( 信 息 ) 分 析, 并 开 出 解 决 的 程 序 从 某 种 意 上 来, 程 序 的 养 成 需 要 种 技 能 : 首 先, 需 要 掌 握 程 言 (Python) 本 身 熟 悉 和 法 能 准 确 地 拼 写 新 言 中 的, 并 且 掌 握 如 何 使 用 新 言 正 确 地 造 句 其 次, 学 会 故 事 在 写 故 事 的 程 中, 通 文 字 和 句 式 的 合, 向 者 思 想 故 事 的 与 能 力 通 写 作 与 反 得 以 提 高 在 程 中, 程 序 即 故 事, 待 解 决 的 即 的 想 法 当 掌 握 一 种 程 言 ( 如 Python) 之 后, 你 会 学 其 他 程 言, 如 JavaScript 或 者 C++, 就 会 容 易 多 然 新 的 程 言 有 很 多 不 同 的 和 法, 但 你 已 学 会 解 决 的 技 能, 所 有 程 言 本 上 都 是 相 通 的 Python 的 和 句 式 上 手 很 快, 但 要 能 写 出 一 些 的 程 序 来 解 决 一 个 全 新 的, 尚 需 日 磨 授 程 就 像 授 写 作 一 先 程 序 行 和 解, 然 后 写 的 程 序, 接 着 逐 步 写 更 复 的 程 序 当 到 一 定 水 平, 你 就 形 成 了 自 己 的 程 格, 自 然 而 然 地 去, 通 写 程 序 解 决 它 一 旦 修 到 个 程 度, 程 就 成 一 个 愉 悦 且 富 有 造 力 的 程 了 我 从 Python 程 序 的 和 起 第 一 次, 一 定 要 耐 心 学 那 些 的 例 子 1.4 与 句 子 与 人 言 不 同 的 是,Python 的 数 量 上 相 当 少 我 称 些 保 留 字, 它 是 Python 中 具 有 特 殊 意 的 于 Python 来, 程 序 中 出 的 些, 它 有 且 有 一 个 含 等 下 你 在 程, 你 自 己 定 的 称 量 量 命 名 非 常 自 由, 但 有 一 点, 你 不 能 使 用 Python 的 保 留 字 作 量 名 从 某 种 意 上, 我 一 只 狗 会 使 用 一 些 特 殊 的, 比 如 坐 下 停 下 和 拿 来 跟 狗 不 用 些 保 留 字 的, 它 就 会 傻 傻 地 看 着 你, 直 到 你 它 出 保 留 字 例 来, 我 希 望 更 多 的 人 通 散 步 来 促 健 康, 而 大 多 数 狗 听 到 的 可 能 是, 吧 吧 散 步 吧 吧 是 因 在 狗 的 言 中 散 步 是 保 留 字 很 多 人 可 能 得 人 和 猫 之 的 言 没 有 保 留 字 1 Python 的 保 留 字 如 下 : 什 么 要 学 程 10

11 and del from not while as elif global or with assert else if pass yield break except import print class exec in raise continue finally is return def for lambda try 就 么 多 Python 比 狗 有 素 多 了 当 你 try,python 会 毫 无 差 地 行 try 后 章 会 介 些 保 留 字 及 它 的 适 用 合 在, 我 只 关 注 怎 么 与 Python ( 就 像 人 跟 狗 ) 教 Python 是 件 有 意 思 的 事 情, 把 想 要 的 用 引 号 括 起 来 就 可 以 了 print 'Hello world!' 就 是 我 写 出 的 第 一 个 法 正 确 的 Python 句 以 保 留 字 print 开, 后 面 跟 一 个 文 本 字 符 串, 用 引 号 括 起 来 1.5 与 Python 我 已 掌 握 了 Python 的 一 个 与 一 个 句, 接 下 来 需 要 了 解 如 何 与 Python, 我 的 新 言 技 能 与 Python 之 前, 必 先 在 算 机 上 安 装 Python 件, 学 会 如 何 Python 本 章 包 含 多, 建 看 网 站 上 有 Python 在 Mac 和 Windows 系 上 配 置 和 的 明 和 演 示 当 打 开 端 或 者 命 令 行 窗 口, 入 python,python 解 析 器 会 以 交 互 模 式, 如 下 所 示 : Python (r261:67515, Jun , 21:47:49) [GCC (Apple Inc. build 5646)] on darwin Type "help", "copyright", "credits" or "license" for more information. >>> >>> 提 示 符 表 示 Python 解 析 器 在, 你 希 望 我 下 一 步 做 什 么? Python 已 准 好 与 你 你 需 要 掌 握 的 是 怎 Python 言, 起 一 个 个 例 子, 你 Python 言 最 的 或 句 子 一 无 所 知, 想 要 使 用 宇 航 的 准 用 ( 喊 ) 宇 航 在 一 个 遥 的 星 球 登, 着 和 个 星 球 的 居 民 用 以 下 句 : >>> I come in peace, please take me to your leader File "<stdin>", line 1 I come in peace, please take me to your leader ^ SyntaxError: invalid syntax >>> 事 情 展 好 像 并 不 利 除 非 你 反 迅 速, 否 个 星 球 的 居 民 可 能 会 拿 矛 刺 向 你, 向 你 吐 口 水, 然 后 把 你 放 在 火 上 烤, 当 成 晚 吃 掉 幸 的 是, 旅 行 你 了 本, 及 翻 到 了 一, 再 一 次 : >>> print 'Hello world!' Hello world! 次 看 起 来 效 果 不, 着 与 他 : 什 么 要 学 程 11

12 >>> print 'You must be the legendary god that comes from the sky' You must be the legendary god that comes from the sky >>> print 'We have been waiting for you for a long time' We have been waiting for you for a long time >>> print 'Our legend says you will be very tasty with mustard' Our legend says you will be very tasty with mustard >>> print 'We will have a feast tonight unless you say File "<stdin>", line 1 print 'We will have a feast tonight unless you say ^ SyntaxError: EOL while scanning string literal >>> 此, 你 意 到,Python 然 非 常 复 与 强 大, 但 在 法 上 非 常 挑 剔, 并 不 那 么 智 能 中 必 使 用 正 确 的 法 在 某 种 意 上, 当 你 使 用 人 写 的 程 序,Python 就 在 你 和 其 他 程 序 之 充 当 中 人 Python 是 程 序 写 者 将 行 下 去 的 一 种 方 式 在 完 短 短 几 章 之 后, 你 将 成 Python 程 序 中 的 一, 与 你 的 程 序 使 用 者 行 束 与 Python 解 析 器 的 第 一 次 之 前, 你 可 能 要 知 道 如 何 正 确 地 与 个 星 球 的 居 民 再 : >>> good-bye Traceback (most recent call last): File "<stdin>", line 1, in <module> NameError: name 'good' is not defined >>> if you don't mind, I need to leave File "<stdin>", line 1 if you don't mind, I need to leave ^ SyntaxError: invalid syntax >>> quit() 你 会 前 个 提 示 是 不 同 的 由 于 if 是 保 留 字,Python 看 到 保 留 字 会 我 想 些 什 么, 但 句 子 的 法 是 的 跟 Python 再 的 正 确 方 法 是, 在 交 互 模 式 的 提 示 符 >>> 后 入 quit() 猜 出 个 命 令 可 能 会 花 一 些, 所 以 手 本 可 能 会 派 上 用 1.6 : 解 器 与 器 Python 是 一 种 高 言, 旨 在 方 便 地 人 行 写, 算 行 取 与 理 其 他 高 言 包 括 :Java C++ PHP Ruby Basic Perl 以 及 JavaScript 等 CPU 里 的 硬 件 并 不 能 理 解 任 何 一 种 高 言 CPU 能 理 解 的 言 称 之 机 器 言 机 器 言 非 常, 坦 白, 写 起 来 非 常 无 聊 它 全 部 由 0 和 1 成 : 然 机 器 言 表 面 看 起 来 很, 只 有 0 和 1, 但 它 的 法 比 Python 复 得 多 所 以, 很 少 有 程 序 用 机 器 言 程 相 反, 借 助 各 种 翻 器, 程 序 可 以 写 像 Python 或 JavaScript 的 高 言, 些 翻 器 会 将 程 序 成 机 器 言, 再 交 由 CPU 行 因 机 器 言 依 附 于 算 机 硬 件, 所 以 不 能 在 不 同 型 硬 件 之 移 植 使 用 高 言 写 的 程 序 可 以 在 不 同 的 算 机 之 移 植, 通 在 一 台 算 机 上 使 用 不 同 的 器, 或 者 重 新 代, 生 成 一 个 适 合 台 算 机 的 机 器 言 版 本 程 言 的 翻 器 大 体 可 分 :(1) 解 器 与 (2) 器 什 么 要 学 程 12

13 解 器 取 程 序 所 写 程 序 的 源 代, 解 析 源 代 并 解 指 令 Python 是 一 种 解 器 当 交 互 式 行 Python, 入 一 行 Python 句,Python 就 会 立 即 理 它, 并 做 好 准 我 入 下 一 条 句 Python 句 中 有 一 些 地 方 会 告 Python, 你 想 要 Python 住 等 下 会 用 到 的 一 些 数 据 就 需 要 数 据 挑 一 个 名 称 来 住 它, 之 后 就 可 以 通 个 名 称 来 取 的 数 据 了 我 使 用 量 (variable) 来 代 表 存 的 数 据 >>> x = 6 >>> print x 6 >>> y = x * 7 >>> print y 42 >>> 在 个 例 子 中, 我 Python 住 数 6, 并 将 6 量 x, 以 便 后 使 用 了 确 Python 已 住 个 数, 使 用 print 命 令 打 印 量 x 的 接 下 来, 我 Python 取 量 x 的 并 乘 以 7, 然 后 将 果 新 量 y 最 后, 打 印 出 当 量 y 的 当 前 一 次 入 一 行 命 令,Python 将 其 一 个 句 序 列, 后 面 的 句 可 以 取 前 面 句 的 数 据 四 句 成 的 段 落 以 一 种 有 的 和 有 意 的 序 写, 就 是 我 写 出 的 第 一 个 的 多 行 程 序 如 上 所 示, 解 器 的 本 是 行 交 互 式 器 需 要 将 整 个 程 序 放 在 一 个 文 件 中, 将 高 次 的 源 代 翻 成 低 次 的 机 器 言, 然 后 器 将 生 成 的 机 器 言 放 到 一 个 文 件 中 以 便 后 行 如 果 你 使 用 Windows 系, 些 可 行 的 机 器 言 程 序 通 常 有.exe 或.dll 后, 分 代 表 是 可 行 的 和 可 加 在 Linux 和 Mac 中 没 有 的 后 来 明 确 表 示 文 件 是 否 是 可 行 的 如 果 在 文 本 器 中 打 开 一 个 可 行 文 件, 眼 望 去 完 全 看 不 : ^?ELF^A^A^A^@^@^@^@^@^@^@^@^@^B^@^C^@^A^@^@^@\xa0\x82 ^D^H4^@^@^@\x90^]^@^@^@^@^@^@4^@ ^@^G^@(^@$^@!^@^F^@ ^@^@4^@^@^@4\x80^D^H4\x80^D^H\xe0^@^@^@\xe0^@^@^@^E ^@^@^@^D^@^@^@^C^@^@^@^T^A^@^@^T\x81^D^H^T\x81^D^H^S ^@^@^@^S^@^@^@^D^@^@^@^A^@^@^@^A\^D^HQVhT\x83^D^H\xe8... 机 器 言 的 写 并 不 容 易, 好 在 借 助 解 器 和 器, 能 使 用 Python 或 C 的 高 言 写 程 序 通 解 器 与 器 的, 你 Python 解 器 本 身 有 了 一 些 了 解 那 它 又 是 用 什 么 言 写 的? 是 用 言 写 的? 当 我 入 python, 究 竟 生 了 什 么? Python 的 解 器 是 用 C 言 写 的 你 可 以 网 站, 看 Python 解 器 的 源 代, 如 有 你 有 意 愿 改 造 些 源 代 也 是 可 以 的 Python 本 身 就 是 一 个 程 序, 它 被 成 机 器 代 当 你 ( 或 硬 件 供 商 ) 在 算 机 上 安 装 了 Python, 是 上 将 一 份 好 的 Python 程 序 的 机 器 代 拷 到 你 的 算 机 系 在 Windows 中,Python 可 行 的 机 器 代 很 可 能 位 于 以 下 文 件 中 : C:\Python27\python.exe 要 成 一 名 Python 程 序, 你 知 道 些 不 但 在 一 开 始, 花 一 些 解 些, 是 得 的 1.7 写 一 个 程 序 体 Python 功 能 的 最 好 方 式 是 在 Python 解 析 器 中 入 命 令, 但 不 建 采 用 种 方 式 来 解 决 复 的 什 么 要 学 程 13

14 程, 我 在 文 本 器 里 把 Python 指 令 写 到 一 个 文 件 里, 个 文 件 称 脚 本 一 般 而 言,Python 脚 本 以.py 命 名 尾 行 脚 本, 你 必 告 Python 解 器 脚 本 文 件 的 名 称 在 Unix 或 Windows 命 令 窗 口 中, 你 可 以 入 以 下 代 来 行 hello.py 脚 本 文 件 : csev$ cat hello.py print 'Hello world!' csev$ python hello.py Hello world! csev$ csev$ 是 操 作 系 提 示 符, cat hello.py 是 看 hello.py 文 件 的 内 容, 其 中 包 含 了 字 符 串 打 印 的 一 行 Python 程 序 我 用 Python 解 器, 告 它 从 hello.py 文 件 中 取 源 代, 而 不 是 用 命 令 行 交 互 式 行 Python 代 你 会, 没 有 必 要 在 Python 程 序 文 件 末 尾 加 上 quit() Python 取 源 代 文 件, 到 文 件 末 尾 它 会 自 己 停 止 1.8 什 么 是 程 序? 程 序 的 基 本 定 是, 完 成 特 定 任 的 一 Python 句 序 列 最 的 hello.py 脚 本 也 是 一 个 程 序, 不 只 是 一 行 代 的 程 序 了, 没 多 大 作 用, 但 是 从 格 的 定 上 来, 它 是 一 个 Python 程 序 考 一 个 可 以 被 程 序 解 决 的, 然 后 用 程 序 来 解 决 它, 可 能 是 理 解 程 序 的 最 方 式 假, 你 想 Facebook 上 的 帖 行 社 会 算 方 面 的 研 究, 可 能 感 趣 的 是 帖 中 最 常 用 的 是 什 么 你 可 以 打 印 出 些 帖, 然 后 通 文 本, 从 中 找 最 常 的, 但 需 要 很 而 且 很 容 易 出 通 写 Python 程 序 来 快 速 且 准 确 地 理 个 任, 会 比 明 智, 周 末 就 可 以 做 些 其 他 有 趣 的 事 了 例 来, 以 下 内 容, 是 关 于 一 个 小 丑 和 一 的 文 本, 找 出 出 次 数 最 多 的, 并 它 出 的 次 数 the clown ran after the car and the car ran into the tent and the tent fell down on the clown and the car 想 象 一 下, 要 数 百 万 行 文 本 来 完 成 个 任 会 是 怎 的 情 形 坦 率 地, 学 Python, 写 一 个 Python 程 序 来 的, 要 比 人 工 描 快 得 多 一 个 好 消 息, 我 用 一 个 程 序 解 决 了 在 文 本 文 件 中 找 到 最 常 的 个 我 已 写 好 并 了 个 程 序 在, 我 把 它 交 你 使 用, 就 可 以 省 你 的 一 些 name = raw_input('enter file:') handle = open(name, 'r') text = handle.read() words = text.split() counts = dict() for word in words: counts[word] = counts.get(word,0) + 1 bigcount = None bigword = None for word,count in counts.items(): if bigcount is None or count > bigcount: bigword = word bigcount = count print bigword, bigcount 什 么 要 学 程 14

15 你 甚 至 不 需 要 知 道 Python 就 可 以 使 用 个 程 序 你 需 要 通 本 第 10 章 来 完 全 理 解 所 用 到 的 Python 程 技 你 在 是 最 用, 只 需 使 用 个 程 序, 你 就 会 于 它 的 明, 感 如 何 你 脱 繁 重 的 手 工 描 你 只 需 入 代, 保 存 成 words.py 文 件 并 行 它, 或 者 也 可 以 从 下 源 个 示 例 充 分 体 了 Python 以 及 言 在 你 ( 最 用 ) 与 我 ( 程 序 ) 之 扮 演 的 中 人 角 色 在 安 装 了 Python 的 用 算 机 上,Python 作 一 种 通 用 言, 我 可 以 交 有 用 的 指 令 序 列 ( 即 程 序 ) 因 此, 我 并 不 是 跟 Python 交 流, 而 是 通 Python 与 其 他 人 交 流 1.9 程 序 的 架 后 章 会 介 深 Python 的 句 子 段 落 与 篇 章 我 将 学 Python 的 强 大 功 能, 以 及 如 何 将 些 功 能 合 起 来 建 有 用 的 程 序 程 序 的 造 包 含 一 些 低 次 的 概 念 模 式 些 造 模 式 不 Python 程 序, 而 是 每 一 种 程 言 从 机 器 言 到 高 言 的 通 用 成 部 分 入 : 从 外 部 世 界 取 数 据, 可 以 从 文 件 中 取 数 据, 或 者 从 某 种 感 器, 比 如 麦 克 或 GPS 取 数 据 在 我 最 初 的 程 序 中, 入 是 用 通 入 数 据 出 : 将 程 序 的 果 示 在 屏 幕 上, 或 保 存 在 一 个 文 件, 或 写 入 一 个, 如 声 器 可 以 播 放 音 或 朗 文 字 序 行 : 按 照 脚 本 中 的 句 序, 一 句 接 一 句 行 条 件 行 : 根 据 特 定 条 件 行 或 者 跳 特 定 句 序 列 重 复 行 : 重 复 行 一 些 句, 通 常 也 会 存 在 一 些 化 重 用 : 写 好 一 指 令, 它 命 名, 之 后 在 程 序 中 根 据 需 要 可 以 再 次 使 用 些 指 令 些 听 起 来 好 像 很 容 易, 事 上 并 不 是 那 么 就 好 比, 走 路 很 吧, 把 一 只 脚 放 在 一 只 脚 前 面 程 的 就 是 不 断 造 和 合 些 基 本 元 素, 造 用 有 用 的 西 除 了 重 用 模 式 之 外, 上 面 的 程 序 几 乎 用 到 了 上 面 提 及 的 所 有 模 式 1.10 致 出 的 原 因 在 前 面 与 Python 的 中 已 看 到, 我 写 Python 代 必 非 常 精 确, 很 小 的 偏 差 和 都 会 致 Python 放 弃 行 程 序 初 学 者 通 常,Python 不 能 容 忍 犯, 人 留 下 低 劣 可 恨 与 残 忍 的 印 象 然 Python 看 上 去 与 其 他 人 一, 但 它 能 理 解 初 学 者, 只 是 把 种 抱 怨 化 督 促, 我 更 好 地 写 程 序 不 要 再 Python 老 是 折 磨 我 了 >>> primt 'Hello world!' File "<stdin>", line 1 primt 'Hello world!' ^ SyntaxError: invalid syntax >>> primt 'Hello world' File "<stdin>", line 1 primt 'Hello world' ^ SyntaxError: invalid syntax >>> I hate you Python! File "<stdin>", line 1 I hate you Python! ^ SyntaxError: invalid syntax >>> if you come out of there, I would teach you a lesson File "<stdin>", line 1 什 么 要 学 程 15

16 if you come out of there, I would teach you a lesson ^ SyntaxError: invalid syntax >>> 与 Python 争 没 什 么 好 它 只 是 一 个 工 具, 没 有 情 感, 它 很 高 随 准 你 服 它 的 信 息 看 起 来 很 苛 刻, 但 些 信 息 帮 助 提 供 索 Python 看 到 了 你 入 的 内 容, 但 不 明 白 你 入 的 是 什 么 Python 更 像 一 只 狗, 无 条 件 你, 只 能 理 解 很 少 的 关, 用 它 那 甜 美 的 表 情 (>>>) 看 着 你, 等 待 你 入 一 些 它 能 理 解 的 西 当 Python 道 : SyntaxError: invalid syntax, 它 只 是 着 尾 巴 : 你 似 乎 了 什 么, 但 我 不 太 明 白, 你 跟 我 (>>>) 当 程 序 得 越 来 越 复, 你 会 遇 到 以 下 三 种 型 的 : 法 : 是 你 遇 到 的 第 一 种, 很 容 易 解 决 法 意 味 着, 你 反 了 Python 的 法 Python 会 尽 可 能 指 出 一 行 句 中 它 所 困 惑 不 能 理 解 的 地 方 和 字 符 法 唯 一 棘 手 的 是, 有 候 程 序 中 需 要 修 改 的 可 能 位 于 Python 所 指 出 困 惑 的 位 置 前 方 所 以,Python 指 出 的 法 位 置 只 是 你 排 的 起 点 : 是 程 序 没 有 法 前 提 下, 句 序 或 句 关 系 存 在 的 一 个 形 象 例 是, 打 开 水 瓶 喝 口 水, 把 它 放 到 包 里, 走 到, 然 后 再 把 水 瓶 盖 上 : 是 程 序 的 法 完 美 且 正 确, 但 无 法 到 期 也 就 是, 程 序 完 全 正 确, 但 它 不 能 做 到 你 想 要 它 做 的 事 一 个 的 例 子, 如 果 你 人 指 路 怎 么 去 一 家 餐, 如 此 : 当 你 走 到 有 加 油 站 的 十 字 路 口, 向 左, 走 一 英 里, 你 的 左 手 有 一 座 色 建 筑, 餐 就 在 那 儿 了 很, 你 的 朋 友 打 来, 他 正 在 一 个, 着 一 个 谷 圈, 并 没 有 看 到 餐 的 志 然 后, 你 : 你 在 加 油 站 左 是 右 了? 他 : 完 全 是 按 你 指 示 的 方 向 走, 我 写 到 上, 在 加 油 站 左, 走 一 英 里 然 后, 你 : 非 常 抱 歉, 然 我 的 方 向 指 示 在 法 上 没, 但 其 中 悲 催 地 包 含 了 一 个 很 小 的 没 有 被 的 于 三 种,Python 会 尽 最 大 努 力 按 照 你 的 要 求 准 确 地 去 行 1.11 学 之 旅 当 循 序 本, 如 果 初 次 遇 到 某 些 概 念 不 能 很 好 理 解, 不 要 担 心 小 候 学, 几 年 只 要 能 出 一 些 可 的 喃 喃 之 音, 不 是 什 么 花 6 个 月 的, 从 能 的 展 到 能 表 的 句 子, 再 用 5 到 6 年 的, 从 句 子 上 升 到 段 落, 的 展 程 是 正 常 的 再 几 年 就 能 依 据 自 身 趣, 独 立 写 出 一 篇 完 整 的 作 文 了 我 希 望 你 能 以 更 快 地 速 度 学 Python, 所 以 有 些 内 容 在 接 下 来 的 几 章 中 会 多 次 涉 及 到 学 一 新 言 需 要 花 去 吸 收 和 理 解, 才 能 做 到 用 自 如 全 景 是 由 一 小 的 片 段 拼 接 起 来 的 我 会 一 再 提 及 一 些 主, 你 看 清 全 景, 可 能 会 致 一 些 混 乱 由 于 的 体 例 是 性 的, 如 果 你 参 加 一, 推 方 式 是 性 的, 但 不 要 受 此 束 前 后 来 回 翻, 行 一 些 略 在 没 有 充 分 理 解 之 前, 跳 有 度 的 内 容, 有 助 于 更 好 的 理 解 程 之 道 通 回 之 前 的 内 容, 或 者 重 做 之 前 做 的, 你 可 能 会 感 收 多, 其 中 些 内 容 可 能 在 你 一 开 始 接 触 得 有 些 解 的 学 第 一 程 言, 通 常 会 有 一 些 得 呼 雀 的 刻 就 像 用 斧 精 心 雕 琢, 一 岩 石 最 在 你 手 中 成 一 尊 美 的 雕 塑 如 果 有 些 事 看 起 来 特 困, 通 宵 熬 夜 耗 着 是 没 有 意 的 休 息 一 下, 打 个, 吃 点 零 食, 向 某 人 ( 可 能 是 你 的 狗 ) 下 你 当 下 遇 到 的, 然 后, 以 全 新 的 眼 光 回 来 再 看 个 我 保, 一 旦 你 从 本 中 学 会 了 程 知, 再 回 看, 你 会 程 是 非 常 和 雅 的 行, 只 是 需 要 花 一 些 去 吸 收 了 1.12 臭 虫 : 程 序 中 的 什 么 要 学 程 16

17 中 央 理 元 : 所 有 算 机 的 心 我 写 的 件 都 由 它 来 行, 也 称 CPU 或 者 理 器 : 把 高 言 写 的 程 序 翻 成 低 言, 后 行 做 好 准 交 互 模 式 : 在 提 示 符 后 入 命 令 和 表 式, 是 Python 解 器 的 一 种 使 用 方 法 解 : 采 用 一 次 翻 一 行 的 方 式 来 行 高 言 写 的 程 序 低 言 : 一 种 旨 在 便 于 算 机 行 的 程 言, 也 称 机 器 或 言 机 器 代 : 最 接 近 硬 件 的 程 言, 可 直 接 由 中 央 理 元 (CPU) 行 主 存 器 : 存 程 序 和 数 据 关 源 后 主 存 器 的 信 息 会 失 解 析 : 程 序 和 分 析 法 可 移 植 性 : 程 序 的 一 个 属 性, 即 程 序 可 在 不 同 型 的 算 机 上 行 print 句 : 能 Python 解 器 在 屏 幕 上 示 数 据 的 指 令 解 决 : 提 出 一 个, 找 到 解 决 方 法 并 形 成 解 决 方 案 的 程 程 序 : 特 定 算 的 一 指 令 集 提 示 : 程 序 示 一 个 消 息, 等 待 用 的 入 助 存 器 : 存 程 序 和 数 据, 源 关 后 数 据 不 会 失 助 存 器 的 速 度 通 常 比 主 存 器 慢 助 存 器 包 括 磁 器 U 中 的 存 等 : 程 序 本 身 的 含 : 程 序 的 一 种 程 序 并 未 按 照 程 序 意 愿 做 事 源 代 : 程 序 的 高 言 代 算 机 的 助 存 器 的 功 能 是 什 么? a) 行 程 序 的 所 有 算 和 b) 在 互 网 上 索 网 c) 期 存 信 息, 甚 至 重 之 后 信 息 不 会 失 d) 接 收 用 的 入 1.2 什 么 是 程 序? 1.3 器 和 解 器 有 什 么 区? 1.4 下 面 个 包 含 了 机 器 代? a) 解 器 b) 什 么 要 学 程 17

18 c)python 源 文 件 d)word 文 档 1.5 找 出 下 面 代 的 : >>> primt 'Hello world!' File "<stdin>", line 1 primt 'Hello world!' ^ SyntaxError: invalid syntax >>> 1.6 行 以 下 Python 句, 量 X 存 于 何? x = 123 a) 中 央 理 器 b) 主 存 器 c) 助 存 器 d) 入 e) 出 1.7 以 下 程 序 会 出 什 么? x = 43 x = x + 1 print x a)43 b)44 c)x+1 d) 出, 因 x = x + 1 在 数 学 上 不 通 1.8 以 人 作 比, 解 以 下 事 物 :(1) 中 央 理 元,(2) 主 存 器,(3) 助 存 器,(4) 入 和 (5) 出 例 如, 算 机 的 中 央 理 元 相 当 人 体 个 部 位? 1.9 如 何 解 决 法? 1. 什 么 要 学 程 18

19 第 2 章 量 表 式 与 句 2.1 与 型 是 程 序 的 基 本 成 要 素, 如 一 个 字 母 或 一 个 数 字 目 前 止, 我 接 触 到 的 有 1 2 和 Hello,World! 些 属 于 不 同 的 型 :2 是 整 数, Hello,World! 是 字 符 串 ( 包 含 一 串 字 母 ) 你 ( 或 者 解 器 ) 可 以 根 据 有 无 引 号 来 判 是 否 是 字 符 串 print 句 也 可 以 打 印 整 数 入 python 命 令 解 器 python >>> print 4 4 如 果 不 确 定 一 个 属 于 种 型, 解 器 会 告 你 >>> type('hello, World!') <type 'str'> >>> type(17) <type 'int'> 而 易, 字 符 串 属 于 str 型, 整 数 属 于 int 型 小 数 点 的 数 字 使 用 浮 点 (floating-point) 格 式 表 示, 称 float 型 >>> type(3.2) <type 'float'> 那 么, 像 '17' 和 '3.2' 种 属 于 种 型 呢? 看 起 来 像 数 字, 但 它 和 字 符 串 一 被 放 在 引 号 里 面 >>> type('17') <type 'str'> >>> type('3.2') <type 'str'> 它 是 字 符 串 入 大 的 数 字, 可 能 会 在 每 三 个 数 字 之 加 一 个 逗 号, 例 如,1,000,000 在 Python 中 不 是 一 个 整 数, 但 表 示 是 合 法 的 >>> print 1,000, 不 是 我 想 要 的!Python 解 器 会 把 1,000,000 当 做 一 个 逗 号 分 隔 的 数 字 序 列, 它 会 把 三 部 分 依 次 打 印 出 来, 中 用 空 格 分 开 是 我 遇 到 的 第 一 个 例 子 : 代 行 不 会 出 任 何 信 息, 但 是 它 并 没 有 做 正 确 的 事 2.2 量 量 表 式 与 句 19

20 程 言 最 强 大 的 功 能 之 一 体 在 量 的 操 作 能 力 量 是 一 个 的 引 用 名 称 句 用 来 建 新 量 并 其 : >>> message = 'And now for something completely different' >>> n = 17 >>> pi = 个 例 子 列 了 三 种 不 同 型 的 句 第 一 条 句 将 字 符 串 量 message; 第 二 条 句 将 整 数 17 量 n, 第 三 条 句 将 π 的 近 似 量 pi 使 用 打 印 句 出 些 量 的 >>> print n 17 >>> print pi 量 的 型 就 是 它 所 指 向 的 的 型 >>> type(message) <type 'str'> >>> type(n) <type 'int'> >>> type(pi) <type 'float'> 2.3 量 名 与 关 字 程 序 通 常 会 有 意 的 量 名, 通 量 名 直 地 了 解 量 的 用 途 量 名 不 限 度, 可 以 同 包 含 字 母 和 数 字, 但 是 必 以 字 母 开 使 用 大 写 字 母 也 是 合 法 的, 但 使 用 小 写 字 母 会 更 好 ( 随 后 会 解 原 因 ) 下 划 可 以 出 在 量 名 中 它 常 用 在 含 有 多 个 的 量 名 中, 例 如,my_name 和 airspeed_of_unladen_swallow 量 名 可 以 采 用 下 划 开, 但 一 般 要 避 免 命 名, 除 非 是 写 供 他 人 使 用 的 Python 代 如 果 使 用 不 合 法 的 量 名, 你 就 会 得 到 一 个 法 : >>> 76trombones = 'big parade' SyntaxError: invalid syntax >>> more@ = SyntaxError: invalid syntax >>> class = 'Advanced Theoretical Zymurgy' SyntaxError: invalid syntax 76trombones 不 是 合 法 的 量 名, 它 不 是 以 字 母 开 的 more@ 也 是 不 合 法 的, 它 包 含 了 一 个 不 合 法 的 字 量 名 class 在 呢? 原 因 在 于,class 是 Python 的 保 留 关 字 Python 解 器 使 用 保 留 关 字 来 程 序 的, 因 此, 保 留 关 字 不 能 用 于 量 名 Python 的 31 个 保 留 关 字 如 下 所 示 1 : 量 表 式 与 句 20

21 and del from not while as elif global or with assert else if pass yield break except import print class exec in raise continue finally is return def for lambda try 你 可 以 在 手 存 留 一 份 如 果 解 器 指 出 了 一 个 量 名 不 合 法, 而 你 又 不 知 道 什 么, 那 么 一 下 量 名 是 否 在 个 列 表 里 面 2.4 句 句 是 Python 解 器 能 行 的 代 元 我 已 到 个 句 :print 和 assignment 在 交 互 模 式 中 入 一 条 句, 解 器 就 会 行 它 并 打 印 出 果 ( 如 果 有 果 的 ) 程 序 例 如 下 : print 1 x = 2 print x 得 到 以 下 出 果 : 1 2 其 中, 句 没 有 出 果 2.5 算 符 和 算 象 算 符 是 表 示 算 的 一 特 殊 符 号, 例 如, 加 法 与 乘 法 算 符 操 作 的 称 算 象 + - * / 和 ** 五 个 算 符 分 代 表 加 乘 除 和 次 方 的 算, 看 如 下 示 例 : hour-1 hour*60+minute minute/60 5**2 (5+9)*(15-7) 除 算 的 果 可 能 不 是 你 所 期 待 的 : >>> minute = 59 >>> minute/60 0 minute 的 是 59, 在 的 算 中,59 除 以 60 是 , 而 不 是 0 出 种 差 异 的 原 因 在 于,Python 行 的 是 地 板 除 法 (floor division) 2 当 个 算 象 都 是 整 数, 那 么 果 也 是 整 数 地 板 除 法 默 去 掉 小 数 部 分, 因 此 上 面 的 算 果 是 0 如 果 个 算 象 都 是 浮 点 数, 那 么 Python 会 行 浮 点 除 法, 果 就 是 浮 点 数 : 量 表 式 与 句 21

22 >>> minute/ 表 式 表 式 是 量 和 算 符 的 合 本 身 可 以 是 一 个 表 式, 量 亦 如 此 下 面 都 是 合 法 的 表 式 ( 假 量 x 已 被 ): 17 x x + 17 如 果 在 交 互 模 式 中 入 一 个 表 式, 解 器 就 会 行 它 并 把 果 打 印 出 来 >>> 然 而, 在 一 个 程 序 中, 表 式 本 身 并 不 能 做 任 何 事 情! 是 初 学 者 容 易 混 淆 的 一 点 2.1 在 Python 解 器 中 入 下 面 的 句 并 看 果 : 5 x = 5 x 算 序 当 一 个 表 式 中 出 多 个 算 符, 算 序 按 照 一 定 行 于 数 学 算 符 来,Python 遵 照 数 学 算, 先 括 号 再 次 方 接 着 乘 除 后 加 (PEMDAS) 会 帮 助 你 住 算 序 括 号 有 最 高 算 先, 表 式 按 特 定 序 行 算 括 号 内 的 表 式 先 行 算, 例 如,2 (3-1) 等 于 4, (1+1)**(5-2) 等 于 8 有 候, 括 号 即 便 没 有 改 算 果, 但 可 以 起 来 更 加 方 便, 例 如,(minute 100) / 60 算 的 次 于 括 号, 例 如,2**1+1 等 于 3, 而 不 是 4,3*1**3 等 于 3, 而 不 是 27 乘 法 和 除 法 具 有 相 同 的 先, 高 于 加 法 和 法 例 如,2*3-1 等 于 5, 而 不 是 4,6+4/2 等 于 8, 而 不 是 5 相 同 先 的 算 符 按 从 左 到 右 的 序 依 次 算 例 如,5-3-1 等 于 1, 而 不 是 3 先 算 5-3 得 到 的 2, 然 后 再 1 当 不 能 确 定 算 序, 通 常 使 用 括 号 来 确 保 既 定 的 算 序 2.8 模 算 模 的 算 象 是 整 数, 得 到 的 是 第 一 个 整 数 与 第 二 个 整 数 相 除 的 余 数 在 Python 中, 模 算 符 用 百 分 号 (%) 表 示, 法 与 其 他 算 符 一 致 : >>> quotient = 7 / 3 >>> print quotient 2 >>> remainder = 7 % 3 >>> print remainder 1 量 表 式 与 句 22

23 7 被 3 所 除 的 商 是 2, 余 数 是 1 模 算 非 常 用 例 来, 你 可 以 一 个 数 是 否 能 被 一 个 数 整 除, 如 果 x%y 的 果 是 0, 那 么 x 能 被 y 整 除 外, 模 算 也 可 以 提 取 出 一 个 数 字 最 右 的 数 位 例 来,x%10 可 以 提 取 出 一 个 数 最 右 的 一 位 数 字 ( 以 10 基 数 ) 同 理,x%100 可 以 提 取 出 一 个 数 最 右 的 位 数 字 2.9 字 符 串 算 符 加 号 的 算 象 是 字 符 串, 它 会 把 字 符 串 首 尾 相 里 不 是 数 学 意 上 的 加 号 例 如 : >>> first = 10 >>> second = 15 >>> print first+second 25 >>> first = '100' >>> second = '150' >>> print first + second 个 程 序 的 出 果 是 求 用 入 有 候 我 希 望 取 用 通 入 的 Python 提 供 了 一 个 入 函 数 raw_input, 用 来 取 入 3 当 用 个 函 数, 程 序 会 停 行, 等 待 用 的 入 当 用 按 下 回, 程 序 就 恢 复 行,raw_input 函 数 以 字 符 串 形 式 返 回 用 入 的 >>> input = raw_input() Some silly stuff >>> print input Some silly stuff 从 用 取 入 之 前, 最 好 打 印 一 条 提 示 句, 告 用 可 以 入 些 什 么 在 程 序 停 等 待 用 入 之 前, 你 可 以 在 raw_input 中 插 入 一 个 字 符 串 来 提 示 用 >>> name = raw_input('what is your name?\n') What is your name? Chuck >>> print name Chuck 提 示 尾 的 \n 表 示 新 开 辟 一 行, 它 是 一 个 用 于 行 的 特 殊 字 符 一 来, 用 入 的 位 置 出 在 提 示 句 的 下 面 如 果 希 望 用 入 一 个 整 数, 你 可 以 int() 函 数, 将 返 回 的 成 整 数 型 : What...is the airspeed velocity of an unladen swallow? 17 >>> int(speed) 17 >>> int(speed) 但 是, 如 果 用 入 的 不 是 数 字 成 的 字 符 串, 那 么 就 会 : 量 表 式 与 句 23

24 >>> speed = raw_input(prompt) What...is the airspeed velocity of an unladen swallow? What do you mean, an African or a European swallow? >>> int(speed) 随 后 会 介 如 何 理 2.11 注 当 程 序 得 越 来 越 复, 度 也 随 之 增 大 正 的 程 序 代 很 密 集, 常 会 遇 到 看 不 段 代 是 做 什 么 的, 或 者 什 么 要 写 解 决 个, 在 程 序 代 中 加 入 自 然 言 明, 解 段 代 的 作 用, 会 是 一 个 不 的 主 意 些 明 称 注, 它 以 # 号 开 : # compute the percentage of the hour that has elapsed percentage = (minute * 100) / 60 上 面 种 情 况, 注 本 身 占 一 行 你 也 可 以 把 它 加 到 一 行 代 的 末 尾 : percentage = (minute * 100) / 60 # percentage of an hour 从 # 号 开 始 到 一 行 的 最 后, 都 会 被 忽 略 掉, 它 不 会 程 序 生 任 何 影 代 不 著 的 特 征 行 明, 注 非 常 有 用 注 会 帮 助 代 者 搞 清 楚 段 代 的 作 用 注 用 于 代 什 么 写 的 解, 同 有 用 下 面 行 注 明 是 多 余 的, 没 什 么 作 用 : v = 5 # assign 5 to v 而 下 面 的 行 注 包 含 了 有 用 的 信 息 : v = 5 # velocity in meters/second. 清 晰 易 的 量 名 能 少 注 的 使 用, 但 是 量 名 如 果 太, 就 会 使 复 的 表 式 得 更 加, 所 以 需 要 衡 利 弊 2.12 易 的 量 名 只 要 遵 循 量 命 名 的, 避 免 使 用 保 留 字, 量 的 命 名 是 有 很 多 种 的 程 入 段, 你 在 人 的 程 序 和 写 自 己 的 程 序, 量 的 命 名 可 能 会 感 到 困 惑 例 如, 下 面 三 个 程 序 上 是 一 的, 但 是 和 理 解 起 来 差 很 大 a = 35.0 b = c = a * b print c hours = 35.0 rate = pay = hours * rate 量 表 式 与 句 24

25 print pay x1q3z9ahd = 35.0 x1q3z9afd = x1q3p9afd = x1q3z9ahd * x1q3z9afd print x1q3p9afd Python 解 器 三 个 程 序 的 理 方 式 完 全 一, 但 是 于 者 理 解 起 来 差 异 很 大 者 能 快 速 看 的 是 第 二 个 程 序, 是 因 程 序 了 能 代 表 量 取 含 的 量 名 种 量 命 名 法 称 助 量 命 名 法 助 4 的 意 思 就 是 帮 助 易 于 的 量 名, 有 助 于 我 住 当 初 建 个 量 是 了 做 什 么 看 起 来 不, 使 用 助 量 命 名 法 是 一 个 好 主 意, 但 可 能 也 会 初 学 者 解 析 与 理 解 代 上 生 面 影 由 于 初 学 者 可 能 没 有 全 Python 的 31 个 保 留 字, 如 果 量 名 中 包 含 太 多 描 述 性 的, 精 心 命 名 的 量 看 上 去 会 像 是 Python 言 的 一 部 分, 初 学 者 理 解 上 造 成 干 下 面 行 的 Python 代 了 循 循 将 在 第 5 章 介, 里 猜 猜 行 代 的 含 : for word in words: print word 行 上 面 的 代 会 生 什 么?for word in 等 几 个 中 些 是 保 留 字, 些 是 量 名?Python 能 理 解 的 基 本 含? 初 学 者 很 分 辨 出 代 中 些 部 分 必 照 抄 示 例 中 的, 而 些 部 分 是 可 以 自 主 的 下 面 的 代 和 上 面 的 代 上 是 一 的 : for slice in pizza: print slice 通 察 段 代, 初 学 者 可 以 容 易 地 分 辨 些 是 Python 保 留 字, 些 是 程 序 自 己 定 的 量 名 而 易,Python 不 能 理 解 pizza 和 slice 之 的 差, 上 就 是 一 个 披 可 以 切 成 很 多 如 果 程 序 要 取 数 据 并 在 数 据 中 找,pizza 和 slice 是 不 容 易 住 的 量 名 它 作 量 名 会 偏 离 程 序 的 本 意 不 了 多 久, 你 会 熟 悉 最 常 用 的 保 留 字 并 在 程 序 中 注 意 到 它 : for word in words: print word 段 Python 代 中 for in print 和 : 加 粗 示, 程 序 自 己 定 的 量 名 不 加 粗 很 多 文 本 器 支 持 Python 法, 它 会 使 用 不 同 的 色 来 保 留 字, 你 能 方 便 地 区 分 保 留 字 与 量 名 熟 悉 一 段 后, 你 就 会 很 快 地 区 分 些 是 保 留 字, 些 是 量 名 2.13 最 容 易 出 的 法 是 不 合 法 的 量 名, 例 如,class 和 yield 是 保 留 字, 或 者 包 含 不 合 法 字 符 的 odd~job 和 US$ 如 果 量 名 中 存 在 空 格,Python 会 它 是 没 有 算 符 的 个 算 象 : >>> bad name = 5 SyntaxError: invalid syntax 法 的 提 示 信 息 提 供 不 了 什 么 帮 助 最 常 的 信 息 是 SyntaxError: invalid syntax 和 SyntaxError: invalid token, 量 表 式 与 句 25

26 条 都 没 有 提 供 什 么 有 价 的 信 息 最 常 遇 到 的 行 是 use before def;, 个 的 意 思 是 使 用 了 一 个 没 有 的 量 种 情 况 容 易 出 在 量 名 拼 写 的 情 况 : >>> principal = >>> interest = principle * rate NameError: name 'principle' is not defined 量 名 区 分 大 小 写, 例 如,LaTeX 和 latex 是 不 一 的 最 容 易 出 的 是 算 序 例 来,\(\dfrac{1}{2π} \) 可 能 会 写 成 : >>> 1.0 / 2.0 * pi 个 句 首 先 行 除 法 算, 得 到 的 果 是 π/2, 然 跟 \( \dfrac{1}{2π} \) 不 是 一 回 事!Python 并 不 明 白 个 表 式 是 什 么 意 思 种 情 况 下 然 不 会, 但 算 果 是 的 2.14 : 量 予 一 个 的 句 接 : 将 个 算 象 首 尾 相 接 注 : 程 序 里 面 包 含 的 信 息, 旨 在 帮 助 其 他 程 序 ( 或 者 看 源 代 的 人 ) 理 解 程 序, 不 会 程 序 的 行 生 任 何 影 求 : 表 式 行 算, 得 到 一 个 表 式 : 量 算 符 和 的 合, 表 示 一 个 果 浮 点 : 有 小 数 部 分 的 数 地 板 除 法 : 截 掉 数 相 除 所 得 果 的 小 数 部 分 的 一 种 除 法 算 整 数 型 : 代 表 整 数 型 关 字 :Python 解 器 用 来 解 析 程 序 的 保 留 字 量 命 名 不 可 使 用 保 留 字, 例 如,if def 与 while 等 助 法 : 一 种 助 的 方 法 通 常 使 用 易 的 量 名 来 帮 助 我 理 解 量 本 身 包 含 的 内 容 模 算 : 用 百 分 号 (%) 表 示, 求 数 相 除 的 余 数 算 象 : 算 符 操 作 的 象 算 符 : 能 行 算 的 一 特 殊 符 号, 例 如, 加 法 乘 法 和 字 符 串 接 算 先 : 一 算, 用 来 定 多 个 算 符 和 算 象 的 表 式 中 算 行 的 次 序 句 : 包 含 指 令 和 行 的 一 段 代 目 前 止, 我 到 了 句 和 打 印 句 字 符 串 : 由 字 符 序 列 成 的 数 据 型 型 : 表 示 一 目 前 止, 我 到 了 整 数 (int), 浮 点 数 (float) 和 字 符 串 (str) 量 表 式 与 句 26

27 : 数 据 的 基 本 位, 例 如, 程 序 中 可 以 操 作 的 数 字 或 字 符 串 量 : 一 个 的 引 用 名 称 使 用 raw_input 写 一 个 程 序, 提 示 用 入 姓 名, 然 后 打 印 出 迎 Enter your name: Chuck Hello Chuck 2.3 写 一 个 程 序, 用 入 工 和 薪, 然 后 算 出 工 Enter Hours: 35 Enter Rate: 2.75 Pay: 不 用 担 心 果 是 否 精 确 到 小 数 点 后 位 如 果 需 要 精 确 到 小 数 点 后 位, 可 以 使 用 Python 内 置 的 round 函 数 2.4 行 下 面 的 句 : width = 17 height = 12.0 写 出 以 下 表 式 的 及 的 型 1. width/2 2. width/ height/ * 5 使 用 Python 解 器 你 的 果 是 否 正 确 2.5 写 一 个 程 序, 用 入 氏 温 度, 然 后 将 其 化 成 氏 温 度, 最 后 将 化 后 的 温 度 打 印 出 来 1. Python 3.0 中,exec 不 再 是 保 留 关 字,nonlocal 是 新 的 保 留 关 字 2. Python 3.0 中, 做 除 法 的 果 是 浮 点 数 新 的 算 符 // 做 整 数 除 法 3. Python 3.0 中, 个 函 数 称 input 4. " 助 " 的 有 关 介, 参 量 表 式 与 句 27

28 第 3 章 条 件 行 3.1 布 表 式 布 表 式 是 具 有 真 或 假 状 的 一 种 表 式 == 算 符 用 来 比 个 算 象, 若 者 相 等 返 回 True, 否 返 回 False: >>> 5 == 5 True >>> 5 == 6 False True 和 False 是 布 型 的 个 取, 它 不 是 字 符 串 : >>> type(true) <type 'bool'> >>> type(false) <type 'bool'> == 算 符 是 比 算 符 中 的 一 个, 其 他 的 比 算 符 如 下 : x!= y x > y x < y x >= y x <= y x is y x is not y # x is not equal to y # x is greater than y # x is less than y # x is greater than or equal to y # x is less than or equal to y # x is the same as y # x is not the same as y 然 你 可 能 很 熟 悉 些 算 符, 但 要 注 意 些 Python 符 号 并 不 等 同 于 数 学 符 号 一 个 常 的 是 用 等 号 (=), 而 没 有 用 双 等 号 (==) 住,= 是 算 符,== 是 比 算 符 不 存 在 =< 或 => 的 算 符 3.2 算 符 算 符 包 括 and( 与 ) or( 或 ) 与 not( 非 ) 三 种 些 算 符 的 与 它 的 英 文 含 相 似 例 如, x > 0 and x < 10 若 x 大 于 0 且 小 于 10, 真 若 n%2 == 0 or n%3 == 0 其 中 有 一 个 条 件 真, 即 个 数 字 能 被 2 或 3 整 除, 真 not 算 符 是 表 示 否 定 的 布 表 式 若 x > y 假, 即 x 小 于 或 者 等 于 y, 那 么 not (x > y) 真 格, 算 符 的 算 象 是 布 表 式, 但 在 Python 中 并 不 是 很 格 任 何 非 零 数 字 都 可 看 作 是 真 >>> 17 and True True 种 灵 活 性 的 存 在 是 有 用 的, 但 也 会 生 一 些 微 妙 的 困 惑 除 非 你 清 楚 自 己 在 做 什 么, 否 不 要 乱 用 条 件 行 28

29 3.3 条 件 行 了 写 出 有 用 的 程 序, 几 乎 是 需 要 根 据 条 件, 修 改 程 序 相 的 行 条 件 句 予 我 种 能 力 最 的 条 件 形 式 是 if 句 : if x > 0 : print 'x is positive' if 句 后 的 布 表 式 称 条 件 if 句 的 末 尾 用 冒 号 (:),if 句 之 后 的 句 要 若 条 件 真, 那 么 的 句 得 以 行 若 条 件 假, 那 么 的 句 就 会 被 跳 if 句 与 for 循 1 的 函 数 定 具 有 相 同 的 句 由 一 个 以 冒 号 (:) 束 的 行 和 随 后 的 一 个 代 区 域 成 由 于 包 含 多 行, 的 句 被 称 复 合 句 句 内 没 有 句 的 数 量 限 制, 但 至 少 要 有 一 行 有 候, 空 白 的 句 也 是 有 用 的, 通 常 是 未 写 的 代 留 空 在 种 情 况 下, 使 用 pass 句, 表 示 什 么 也 不 做 if x < 0 : pass # need to handle negative values! 如 果 在 Python 解 器 里 入 一 个 if 句, 提 示 符 会 从 三 个 > 成 三 个., 表 明 正 在 一 个 句 内, 如 下 所 示 : >>> x = 3 >>> if x < 10:... print 'Small'... Small >>> 3.4 分 支 行 if 句 的 第 二 种 形 式 是 行 句 中 存 在 种 可 能, 条 件 决 定 了 行 一 种 法 如 下 : if x%2 == 0 : print 'x is even' else : print 'x is odd' 若 x 除 以 2 的 余 数 0, x 是 偶 数, 程 序 就 行 第 一 个 print 句, 示 x is even 若 余 数 不 0, else 之 后 的 第 二 个 print 条 件 行 29

30 句 得 以 行 由 于 条 件 必 真 或 假, 所 以 条 句 中 有 一 条 会 被 行 些 句 称 行 流 程 中 的 分 支 3.5 式 条 件 有 候 存 在 种 以 上 的 可 能, 那 么 就 需 要 个 以 上 的 分 支 式 条 件 可 以 理 种 情 况 elif 是 else if 的 写, 表 示 又 有 一 个 分 支 将 被 行 elif 句 没 有 数 量 限 制 如 果 有 一 个 else 子 句, 那 它 必 是 最 后 一 个, 但 是 else 子 句 不 是 必 的 if choice == 'a': print 'Bad guess' elif choice == 'b': print 'Good guess' elif choice == 'c': print 'Close, but not correct' 依 次 每 个 条 件 如 果 第 一 个 假, 就 第 二 个, 以 此 下 去 如 果 其 中 一 个 条 件 真, 行 相 的 分 支, 至 此 句 束 即 使 不 止 一 个 条 件 真, 也 只 行 第 一 个 真 的 分 支 3.6 嵌 套 条 件 一 个 条 件 句 也 可 以 嵌 套 到 一 个 条 件 句 中 我 可 以 写 出 三 分 条 件 的 例 子 : 条 件 行 30

31 if x == y: print 'x and y are equal' else: if x < y: print 'x is less than y' else: print 'x is greater than y' 外 面 的 条 件 句 包 含 了 个 分 支 第 一 条 分 支 包 含 了 一 个 句 第 二 条 分 支 包 含 了 一 个 由 个 分 支 成 的 if 句 个 分 支 都 是 句, 然 个 分 支 包 含 条 件 句, 但 它 都 是 句 然 句 得 清 晰, 但 是 嵌 套 条 件 是 很 快 速 地 一 般 情 况 下, 是 尽 量 避 免 使 用 算 符 通 常 提 供 一 种 方 法 来 化 嵌 套 条 件 句 例 如, 使 用 个 条 件 改 写 以 下 代 : if 0 < x: if x < 10: print 'x is a positive single-digit number.' 当 个 条 件 都 足,print 句 才 会 行 使 用 and 算 符 也 能 到 相 同 的 效 果 : if 0 < x and x < 10: print 'x is a positive single-digit number.' 3.7 try 与 except 异 常 捕 之 前 我 看 到 一 段 代, 使 用 raw_input 和 int 函 数 取 和 解 析 用 入 的 整 数 由 此 来 的 潜 在 危 是 : >>> speed = raw_input(prompt) What...is the airspeed velocity of an unladen swallow? What do you mean, an African or a European swallow? >>> int(speed) ValueError: invalid literal for int() >>> 在 Python 解 器 中 行 些 句, 提 示, 然 后 会 新 起 一 行, 等 待 下 一 条 句 的 入 如 果 把 段 代 放 在 Python 脚 本 文 件 中, 当 生, 脚 本 的 行 会 立 即 停 止 在 一 行, 并 返 回 消 息, 之 后 的 句 不 条 件 行 31

32 会 被 行 inp = raw_input('enter Fahrenheit Temperature:') fahr = float(inp) cel = (fahr ) * 5.0 / 9.0 print cel 如 果 我 行 段 代, 入 一 个 无 效 的, 它 会 停 止 行, 并 返 回 一 个 不 友 好 的 信 息 : python fahren.py Enter Fahrenheit Temperature: python fahren.py Enter Fahrenheit Temperature:fred Traceback (most recent call last): File "fahren.py", line 2, in <module> fahr = float(inp) ValueError: invalid literal for float(): fred Python 内 置 了 try/except 条 件 行, 用 来 解 决 意 料 之 中 和 意 料 之 外 的 你 知 道 程 序 可 能 存 在, 希 望 在 生 增 加 一 些 句, try 和 except 就 派 上 用 了 如 果 没 有 出, 些 外 的 句 (except 句 ) 就 会 被 忽 略 掉 你 可 以 把 Python 的 try 和 except 功 能 看 作 是 程 序 的 保 温 度 程 序 重 新 写 如 下 : inp = raw_input('enter Fahrenheit Temperature:') try: fahr = float(inp) cel = (fahr ) * 5.0 / 9.0 print cel except: print 'Please enter a number' Python 首 先 行 try 句 如 果 一 切 利, 它 就 会 跳 except 句 如 果 在 try 句 里 生 意 外,Python 就 会 跳 出 try 句, 行 except 句 python fahren2.py Enter Fahrenheit Temperature: python fahren2.py Enter Fahrenheit Temperature:fred Please enter a number 用 try 句 理 异 常 的 行 称 异 常 捕 个 示 例 中 except 子 句 打 印 了 一 条 提 示 信 息 一 般 来, 捕 捉 到 异 常, 就 是 你 一 个 机 会 去 解 决 它, 或 者 是 再 一 次, 至 少 程 序 能 正 常 束 3.8 表 式 的 短 路 估 当 Python 理 如 x > = 2 and (x / y)> 2 的 表 式, 从 左 至 右 行 判 断 根 据 and 的 含, 如 果 x 小 于 2, 表 式 x>=2 假, 那 么 整 个 表 式 即 假, 不 管 后 面 的 (x / y)> 2 的 判 断 是 真 或 假 当 Python 表 式 剩 余 部 分 的 判 断 没 有 意 了, 它 就 停 止 剩 余 部 分 的 判 断 在 已 知 表 式 整 体 果 的 情 况 下 停 止 判 断, 称 短 路 估 条 件 行 32

33 看 起 来 是 一 个, 短 路 行 来 了 一 种 灵 活 的 理 方 式, 称 守 者 模 式 如 下 是 Python 解 器 中 的 一 段 代 : >>> x = 6 >>> y = 2 >>> x >= 2 and (x/y) > 2 True >>> x = 1 >>> y = 0 >>> x >= 2 and (x/y) > 2 False >>> x = 6 >>> y = 0 >>> x >= 2 and (x/y) > 2 Traceback (most recent call last): File "<stdin>", line 1, in <module> ZeroDivisionError: integer division or modulo by zero >>> 第 三 次 算 出 了 由 于 y 等 于 0,Python 算 (x/y) 出 行 但 是, 第 二 次 算 没 有 出 由 于 表 式 第 一 部 分 x > = 2 判 断 假, 所 以 根 据 短 路, (x / y) 根 本 没 有 被 行, 所 以 没 有 我 可 以 在 生 之 前, 策 略 性 地 放 置 一 个 守 估, 代 如 下 : >>> x = 1 >>> y = 0 >>> x >= 2 and y!= 0 and (x/y) > 2 False >>> x = 6 >>> y = 0 >>> x >= 2 and y!= 0 and (x/y) > 2 False >>> x >= 2 and (x/y) > 2 and y!= 0 Traceback (most recent call last): File "<stdin>", line 1, in <module> ZeroDivisionError: integer division or modulo by zero >>> 第 一 个 表 式 中 x > = 2 假, 所 以 在 and 之 前 判 断 就 停 止 了 第 二 个 表 式 中 x > = 2 真, 但 y!= 0 假, 所 以 (x/y) 没 有 机 会 得 到 判 断 第 三 个 表 式 中 y!= 0 位 于 (x/y) 之 后, 所 以 个 表 式 的 判 断 失 了 第 二 个 表 式 中 y!= 0 作 一 个 守, 确 保 y 不 等 于 0 只 行 (x/y) 3.9 当 生,Python 的 追 踪 (Traceback) 示 很 多 信 息, 但 有 可 能 消 息 多, 特 是 中 有 很 多 的 情 况 其 中 最 有 用 的 部 分 是 : 的 型 是 什 么 生 的 位 置 法 通 常 很 容 易 找 到, 但 也 存 在 一 些 陷 空 格 非 常 棘 手, 由 于 空 格 和 制 表 符 是 不 可 的, 常 常 会 被 忽 >>> x = 5 >>> y = 6 File "<stdin>", line 1 y = 6 ^ SyntaxError: invalid syntax 条 件 行 33

34 个 例 子 中 出 在 第 二 行 只 用 了 一 个 空 格 但 是 消 息 指 向 了 y, 其 是 一 种 一 般 情 况 下, 信 息 会 示 在 何 被, 但 是 可 能 会 在 所 示 的 代 之 前, 有 候 会 在 前 一 行 行 也 是 如 此 假 用 分 算 信 噪 比, 公 式 是 \(SNR~{db} = 10 log~{10}(\frac{p~{signal}}{p~{noise}})\),python 代 如 下 : import math signal_power = 9 noise_power = 10 ratio = signal_power / noise_power decibels = 10 * math.log10(ratio) print decibels 但 是 当 你 行 段 代, 就 会 收 到 如 下 信 息 2 : Traceback (most recent call last): File "snr.py", line 5, in? decibels = 10 * math.log10(ratio) OverflowError: math range error 信 息 示 第 5 行 出, 但 那 一 行 没 有 了 找 到 真 正 的, 将 ratio 打 印 出 来 可 能 会 有 用 原 来 是 ratio 0, 出 在 第 4 行, 原 因 是 数 相 除 采 用 的 是 地 板 除 法 ( 只 取 整 数 ) 解 决 方 法 是 用 浮 点 数 表 示 信 号 功 率 和 噪 声 功 率 一 般 情 况 下, 信 息 会 告 你 出 在, 但 个 出 位 置 并 不 准 确 3.10 主 体 : 复 合 句 中 的 一 句 布 表 式 : 取 只 有 真 (True) 或 假 (False) 其 中 之 一 的 表 式 分 支 : 条 件 句 中 可 供 的 一 句 式 条 件 : 有 多 个 可 分 支 的 条 件 句 比 算 符 : 算 象 行 比 的 一 种 算 符, 包 括 ==!= > < >=, 和 <= 条 件 句 : 根 据 某 些 条 件 来 控 制 程 序 行 序 的 句 条 件 : 条 件 句 中 的 布 表 式, 用 来 决 定 行 一 个 分 支 复 合 句 : 含 有 部 和 主 体 的 一 句 代 部 以 冒 号 (:) 尾 代 主 体 相 于 代 部 行 守 模 式 : 通 外 的 比 来 造 表 式, 充 分 利 用 短 路 行 算 符 : 合 布 表 式 的 算 符, 包 括 and or 和 not 嵌 套 条 件 : 一 个 条 件 句 作 一 个 条 件 句 的 分 支 追 踪 : 正 在 行 的 函 数 列 表, 当 出 异 常, 在 屏 幕 上 示 出 来 短 路 : 在 判 断 表 式 的 程 中, 如 果 Python 已 知 道 了 最 果, 会 停 止, 不 会 剩 余 的 表 式 行 判 断 条 件 行 34

35 重 写 薪 水 算 公 式, 如 果 工 工 作 超 40 小, 按 平 常 薪 水 的 1.5 倍 支 付 Enter Hours: 45 Enter Rate: 10 Pay: 用 try 和 except 重 写 支 付 程 序, 程 序 可 以 正 常 理 非 数 字 入 的 情 况, 如 果 是 非 数 字 入, 打 印 消 息 并 退 出 程 序 以 下 是 程 序 的 种 行 果 : Enter Hours: 20 Enter Rate: nine Error, please enter numeric input Enter Hours: forty Error, please enter numeric input 3.3 写 一 个 程 序, 提 示 分 数 在 0.0 和 1.0 之 如 果 分 数 超 出 个 范 打 印 出 如 果 分 数 在 0.0 和 1.0 之, 使 用 下 面 的 表 格 打 印 分 数 : Score Grade >= 0.9 A >= 0.8 B >= 0.7 C >= 0.6 D < 0.6 F Enter score: 0.95 A Enter score: perfect Bad score Enter score: 10.0 Bad score Enter score: 0.75 C Enter score: 0.5 F 重 复 行 个 程 序, 不 同 的 入 1. 第 4 章 介 函 数, 第 5 章 介 循 2. Python3.0 中, 不 再 出 消 息 即 使 是 整 数 象, 除 法 算 符 行 的 也 是 浮 点 除 法 条 件 行 35

36 第 4 章 函 数 4.1 函 数 用 程 中 的 函 数 是 行 算 的 一 个 命 名 句 序 列 当 定 函 数, 需 要 指 定 函 数 名 和 句 序 定 好 之 后, 通 函 数 名 就 可 以 用 函 数 之 前 我 到 一 个 函 数 示 例 : >>> type(32) <type 'int'> 个 函 数 的 名 称 是 type 括 号 里 面 的 表 式 称 函 数 的 参 数 参 数 可 以 是 一 个 或 量, 作 函 数 的 入 type 函 数 的 作 用 是 示 参 数 的 型 一 般 而 言, 函 数 取 参 数, 然 后 返 回 果 个 果 称 返 回 4.2 内 置 函 数 Python 提 供 了 很 多 重 要 的 内 置 函 数, 不 需 要 我 先 定 就 可 以 使 用 Python 开 者 定 了 解 决 常 的 函 数 集, 内 置 在 Python 中, 供 我 使 用 max 函 数 和 min 函 数 分 求 得 一 个 列 表 中 的 最 大 和 最 小 : >>> max('hello world') 'w' >>> min('hello world') ' ' >>> max 函 数 告 我, 个 字 符 串 中 最 大 的 字 符 是 ( w ),min 函 数 告 我 个 字 符 串 中 最 小 的 字 符 是 空 格 符 一 个 常 用 的 内 置 函 数 是 len 函 数, 它 能 返 回 参 数 的 度 如 果 len 函 数 的 参 数 是 一 个 字 符 串, 那 么 它 返 回 的 是 个 字 符 串 的 字 符 数 >>> len('hello world') 11 >>> 些 函 数 不 可 用 于 字 符 串, 能 操 作 其 他 数 据 型, 后 章 会 涉 及 到 你 可 以 将 内 置 函 数 比 保 留 字, 例 来, 不 要 使 用 max 作 量 名 4.3 型 函 数 Python 提 供 了 将 一 种 型 成 一 种 型 的 内 置 函 数 在 允 的 情 况 下,int 函 数 能 把 任 何 其 他 型 的 化 成 整 数 型, 如 果 不 能 就 会 : >>> int('32') 32 函 数 36

37 >>> int('hello') ValueError: invalid literal for int(): Hello int 函 数 能 将 浮 点 型 成 整 数 型, 但 是 它 不 行 四 舍 五 入, 只 是 直 接 去 掉 小 数 部 分 : >>> int( ) 3 >>> int(-2.3) -2 float 函 数 能 把 整 数 型 和 字 符 串 型 成 浮 点 型 : >>> float(32) 32.0 >>> float(' ') str 函 数 能 把 入 的 参 数 成 字 符 串 型 : >>> str(32) '32' >>> str( ) ' ' 4.4 随 机 数 既 定 入 的 情 况 下, 大 部 分 的 算 机 程 序 每 次 都 会 生 相 同 的 出, 也 就 是 是 板 上 的 事 情 一 般 而 言, 确 定 性 是 好 的, 我 希 望 同 一 个 算 法 生 相 同 的 果 然 而, 有 些 候 我 希 望 算 机 具 不 确 定 性, 比 如 游 就 是 一 个 典 型 例 子, 当 然 有 很 多 其 他 例 子 一 个 程 序 完 全 于 不 确 定 状, 很 做 到 但 是, 有 一 些 方 法 可 以 它 看 起 来 具 有 不 确 定 性 一 种 方 法 是 利 用 算 法 生 随 机 数 随 机 数 并 不 是 真 正 的 随 机 数, 原 因 在 于 它 是 利 用 确 定 的 算 法 算 出 来 的 看 些 数 字 并 不 会 它 和 真 正 的 随 机 数 有 什 么 不 同 随 机 数 模 提 供 了 随 机 数 生 成 的 函 数, 以 下 称 random random 函 数 返 回 一 个 介 于 的 随 机 浮 点 数 ( 包 括 0.0, 但 不 包 括 1.0) 每 次 用, 你 会 得 到 一 串 的 数 字 例 来, 行 下 面 的 循 句 : import random for i in range(10): x = random.random() print x 程 序 生 成 了 10 个 介 于 之 但 不 包 括 1.0 的 随 机 数 函 数 37

38 行 以 下 程 序 并 察 得 到 的 果, 不 妨 多 行 几 次 看 看 random 函 数 只 是 多 随 机 数 函 数 中 的 一 个 randint 函 数 入 个 整 数 参 数, 并 返 回 介 于 个 参 数 之 的 整 数 ( 包 括 个 参 数 在 内 ) >>> random.randint(5, 10) 5 >>> random.randint(5, 10) 9 取 得 一 中 的 随 机 元 素, 可 以 使 用 下 面 的 程 序 : >>> t = [1, 2, 3] >>> random.choice(t) 2 >>> random.choice(t) 3 random 模 提 供 了 从 分 布 函 数 中 提 取 随 机 的 函 数, 包 括 高 斯 函 数 指 数 函 数 伽 函 数 等 4.5 数 学 函 数 Python 的 math 模 提 供 了 很 多 常 的 数 学 函 数 在 使 用 之 前 要 入 相 的 包 : >>> import math 条 句 建 了 一 个 名 math 的 模 象 如 果 将 个 模 象 打 印 出 来, 就 会 得 到 关 于 它 的 一 些 信 息 : >>> print math <module 'math' from '/usr/lib/python2.5/lib-dynload/math.so'> 个 模 象 包 括 了 模 中 定 的 函 数 和 量 了 使 用 其 中 的 函 数, 你 必 指 定 模 名 和 函 数 名, 用 点 隔 开, 也 就 是 英 文 的 句 号 种 格 式 叫 做 点 (dot notation) >>> ratio = signal_power / noise_power >>> decibels = 10 * math.log10(ratio) >>> radians = 0.7 >>> height = math.sin(radians) 第 一 个 例 子 是 算 以 10 底 的 信 噪 比 的 数 math 模 提 供 了 log 函 数 用 来 求 以 e 底 的 数 第 二 个 例 子 用 了 正 弦 函 数 量 名 字 出 了 提 示, 除 了 正 弦 函 数, 有 余 弦, 正 切 等 其 他 三 函 数 都 采 用 弧 度 作 参 数 将 度 数 成 弧 度 的 算 是 除 以 360, 然 后 乘 以 2π: >>> degrees = 45 >>> radians = degrees / * 2 * math.pi >>> math.sin(radians) 函 数 38

39 math.pi 表 式 从 math 模 中 取 得 量 pi 的 个 量 是 π 的 一 个 近 似, 保 留 了 小 数 点 后 15 位 数 用 你 的 平 面 几 何 知, 与 2 的 平 方 根 再 除 以 2 的 果 行 比, 程 序 出 是 否 正 确 >>> math.sqrt(2) / 定 新 函 数 目 前 止, 我 只 是 使 用 了 Python 的 内 置 函 数, 除 此 之 外 也 可 以 自 定 新 函 数 通 定 函 数 名 和 一 句 序 列 来 定 一 个 新 函 数, 然 后 在 行 用 个 函 数 一 旦 定 了 一 个 函 数, 程 序 中 可 以 重 复 使 用 def print_lyrics(): print "I'm a lumberjack, and I'm okay." print 'I sleep all night and I work all day.' def 是 用 来 定 函 数 的 保 留 关 字 个 函 数 的 名 称 是 print_lyrics 函 数 命 名 与 量 命 名 的 基 本 上 是 一 的 字 母 数 字 以 及 一 些 符 号 是 合 法 的, 但 是 函 数 名 的 第 一 个 字 符 不 能 是 数 字 不 能 使 用 保 留 关 字 命 名 函 数, 也 要 避 免 函 数 名 和 量 名 相 同 函 数 名 后 面 的 空 括 号 表 明 个 函 数 没 有 指 定 参 数 接 下 来, 我 会 定 有 参 数 的 函 数 函 数 定 的 第 一 行 叫 做 函 数, 剩 余 的 部 分 叫 做 函 数 体 函 数 必 以 冒 号 束, 函 数 体 必 按 照 例, 一 般 4 个 空 格 函 数 体 可 以 包 括 任 意 数 量 的 句 print 句 要 出 的 字 符 串 放 在 双 引 号 里 面 引 号 和 双 引 号 作 用 是 一 的 除 了 在 字 符 串 中 也 有 引 号 的 冲 突 情 况 之 外, 大 多 数 人 会 使 用 引 号 如 果 你 在 Python 交 互 模 式 中 定 函 数, 解 器 会 打 印 省 略 号 ( ) 表 明 函 数 定 没 有 束 >>> def print_lyrics():... print "I'm a lumberjack, and I'm okay."... print 'I sleep all night and I work all day.'... 函 数 定 的 束 方 式 是 入 一 个 空 行 ( 当 然, 在 程 序 文 件 中 不 是 必 的 ) 定 函 数 的 同 也 会 建 一 个 和 函 数 名 相 同 的 量 名 >>> print print_lyrics <function print_lyrics at 0xb7e99e9c> >>> print type(print_lyrics) <type 'function'> print_lyrics 的 是 一 个 函 数 象, 它 的 型 是 函 数 用 自 定 函 数 与 用 内 置 函 数 的 法 是 一 的 : >>> print_lyrics() 函 数 39

40 I'm a lumberjack, and I'm okay. I sleep all night and I work all day. 函 数 定 好 之 后, 就 可 以 在 其 他 函 数 中 使 用 例 如, 了 重 复 用 之 前 的 函 数, 你 可 以 写 一 个 repeat_lyrics 函 数 : def repeat_lyrics(): print_lyrics() print_lyrics() 然 后 用 个 函 数 : >>> repeat_lyrics() I'm a lumberjack, and I'm okay. I sleep all night and I work all day. I'm a lumberjack, and I'm okay. I sleep all night and I work all day. 中 歌 曲 可 不 是 填 的 4.7 定 与 用 法 将 前 面 的 代 片 段 合 在 一 起, 完 整 的 程 序 如 下 : def print_lyrics(): print "I'm a lumberjack, and I'm okay." print 'I sleep all night and I work all day.' def repeat_lyrics(): print_lyrics() print_lyrics() repeat_lyrics() 个 程 序 包 含 了 个 自 定 函 数 :print_lyrics 和 repeat_lyrics 函 数 定 会 像 其 他 句 一 行, 但 它 的 作 用 是 新 建 函 数 函 数 体 里 面 的 代 并 没 有 被 行, 直 到 被 用 才 会 行, 函 数 定 是 没 有 出 的 正 如 所 期 望 的, 你 必 在 行 函 数 之 前 定 个 函 数 句, 函 数 在 第 一 次 被 用 之 前 就 定 好 4.2 将 上 面 程 序 的 最 后 一 行 到 最 开 始, 函 数 用 就 出 在 函 数 定 之 前 行 程 序 并 察 出 信 息 4.3 将 函 数 回 底 部, 将 函 数 print_lyrics 定 放 在 函 数 repeat_lyrics 后 面, 会 生 什 么 果? 4.8 行 流 程 了 保 函 数 定 是 在 第 一 次 使 用 之 前, 你 就 必 知 道 句 的 行 序, 称 行 流 程 程 序 一 般 从 第 一 条 句 开 始 行, 从 上 到 下 依 次 序 行 函 数 定 并 不 改 程 序 的 行 序, 但 要 住, 函 数 只 有 被 用 的 才 会 被 行 函 数 用 像 是 是 行 流 程 中 的 一 个 迂 回 当 遇 到 要 用 的 函 数, 不 会 接 着 去 行 下 一 句, 而 是 跳 到 函 数 体, 行 完 函 数 体 里 的 句, 然 后 回 到 才 跳 出 的 地 方 行 当 你 掌 握 了 函 数 之 的 用, 就 会 得 很 在 一 个 函 数 中, 程 序 可 能 需 要 行 一 个 函 数 的 句 有, 在 定 新 函 函 数 40

41 数, 程 序 可 能 需 要 行 一 个 函 数! 程 序 里 跳 来 跳 去, 明 了 什 么? 程 序 有 候 没 必 要 从 看 到 尾 有 候 按 照 行 流 程 会 你 更 好 地 程 序 4.9 形 式 参 数 与 参 数 我 之 前 到 的 内 置 函 数 需 要 入 参 数 例 如, 用 math.sin 函 数 需 要 入 一 个 数 作 参 数 有 些 函 数 不 止 有 一 个 参 数 : math.pow 函 数 需 要 入 个 参 数 : 底 数 和 指 数 在 函 数 内 部, 如 果 量 作 参 数 入, 那 么 种 参 数 叫 做 形 式 参 数 ( 称 形 参 ) 下 面 的 例 子 是 一 个 自 定 函 数 入 了 一 个 参 数 ( 称 参 ): def print_twice(bruce): print bruce print bruce 个 函 数 将 一 个 叫 做 bruce 的 参 去 当 函 数 被 用, 函 数 会 打 印 次 入 的 参 数 个 函 数 适 用 任 何 型 的 >>> print_twice('spam') Spam Spam >>> print_twice(17) >>> print_twice(math.pi) 种 参 数 入 方 式 适 用 于 内 置 函 数 与 自 定 函 数 任 何 型 的 表 式 都 可 以 作 函 数 print_twice 的 参 数 >>> print_twice('spam '*4) Spam Spam Spam Spam Spam Spam Spam Spam >>> print_twice(math.cos(math.pi)) 参 数 的 在 函 数 被 用 之 前 就 已 被 算 出 来 了, 因 此, 上 面 的 例 子 中 表 式 'Spam '*4 和 math.cos(math.pi) 只 被 算 了 一 次 你 可 以 使 用 量 作 参 数 : >> michael = 'Eric, the half a bee.' >>> print_twice(michael) Eric, the half a bee. Eric, the half a bee. 量 ( 如 michael) 作 形 参 与 参 ( 如 bruce) 不 同 函 数 的 形 式 参 数 是 什 么 型 的 都 可 以 被 入, 而 参 的 是 确 定 的,print_twice 函 数 的 返 回 就 是 参 数 bruce 本 身 4.10 返 回 的 函 数 和 空 函 数 函 数 41

42 我 使 用 的 有 些 函 数 ( 如 math 函 数 ) 有 返 回 由 于 没 有 更 好 的 叫 法, 我 称 之 有 返 回 的 函 数 其 他 的 一 些 函 数 比 如 print_twice, 行 任 但 不 返 回, 种 称 空 函 数 当 用 有 返 回 的 函 数, 大 部 分 候 你 想 要 利 用 返 回, 例 如, 将 它 一 个 量, 也 可 以 作 表 式 的 一 部 分 : x = math.cos(radians) golden = (math.sqrt(5) + 1) / 2 在 交 互 模 式 中 用 函 数,Python 会 示 果 >>> math.sqrt(5) 在 程 序 文 件 中, 如 果 不 把 有 返 回 的 函 数 的 返 回 保 存 在 量 里 的, 返 回 就 会 失 math.sqrt(5) 空 函 数 也 会 在 屏 幕 上 出 什 么 或 者 有 其 它 的 用 途, 但 其 本 身 没 有 返 回 如 果 你 着 将 果 一 个 量, 就 会 得 到 一 个 特 殊 的 None >>> result = print_twice('bing') Bing Bing >>> print result None None 与 字 符 串 None 是 不 一 的 它 是 一 种 特 殊 的 并 且 有 自 己 的 型 >>> print type(none) <type 'NoneType'> 使 用 return 句 从 函 数 中 返 回 果 例 如, 建 一 个 的 函 数 addtwo, 将 个 数 相 加 并 且 返 回 一 个 def addtwo(a, b): added = a + b return added x = addtwo(3, 5) print x 在 文 件 中 行 程 序,print 句 会 打 印 出 8 addtwo 函 数 被 用, 入 3 和 5 个 参 数 有 形 参 a 和 b 的 函 数, 分 是 3 和 5 个 函 数 将 个 数 相 加, 然 后 将 果 局 部 量 added, 最 后 使 用 return 句 将 算 果 x 并 打 印 出 来 4.11 什 么 需 要 函 数? 如 果 不 太 明 白 什 么 需 要 花 精 力 把 程 序 分 成 多 个 函 数, 看 如 下 理 由 : 定 新 函 数 可 以 你 有 机 会 一 句 命 名, 使 得 程 序 易 于 理 解 和 函 数 可 以 消 除 冗 余 代, 程 序 瘦 身 如 果 想 修 改 函 数, 只 需 要 改 一 即 可 将 程 序 分 割 成 多 个 函 数, 逐 一, 最 后 再 整 合 在 一 起 函 数 42

43 精 心 的 函 数 很 多 程 序 而 言 都 会 有 用 一 旦 建 并 后, 你 就 可 以 重 复 使 用 它 本 其 余 部 分 会 使 用 函 数 定 来 解 一 个 概 念 建 并 正 确 使 用 函 数 的 技 巧 之 一 是 捕 捉 到 一 个 想 法, 例 如, 找 出 列 表 中 的 最 小 随 后 我 会 介 min 函 数 的 代, 它 将 列 表 的 作 参 数 入, 然 后 返 回 其 中 的 最 小 4.12 制 表 符 和 空 格 通 常 不 可, 致 不 易, 因 此 最 好 一 个 能 自 的 文 本 器 外, 行 程 序 之 前 不 要 忘 保 存 有 一 些 开 境 可 以 自 保 存, 而 有 一 些 不 行 未 保 存 的 情 况 下 行 的 程 序 和 文 本 器 的 程 序 不 一 如 果 你 重 复 行 相 同 的 程 序, 那 么 会 很 久 确 保 行 的 代 是 文 本 器 中 你 所 看 到 的 代 如 果 不 确 定, 你 可 以 在 程 序 开 加 入 print 'hello' 的 代 再 行 如 果 没 有 看 到 hello 出, 那 么 就 没 有 正 确 行 程 序 4.13 算 法 : 解 决 一 的 一 般 程 参 数 : 函 数 被 用 入 的 函 数 中 个 会 被 予 相 的 参 数 函 数 体 : 函 数 定 中 的 一 句 序 列 合 : 一 个 表 式 作 一 个 表 式 的 一 部 分, 或 者 一 条 句 作 一 条 句 的 一 部 分 确 定 性 : 在 既 定 入 下, 程 序 每 次 行 都 一 并 返 回 相 同 的 果 点 : 在 一 个 模 中 用 函 数, 需 要 指 定 模 名 和 函 数 名, 用 句 号 隔 开 行 流 程 : 程 序 行 的 句 行 序 返 回 的 函 数 : 能 返 回 一 个 的 函 数 函 数 : 行 一 些 有 用 操 作 的 命 名 句 序 列 函 数 不 一 定 有 参 数, 也 不 一 定 返 回 果 函 数 用 : 行 函 数 的 句, 包 括 函 数 名 和 参 数 列 表 函 数 定 : 建 新 函 数 的 句, 需 要 指 定 名 称 参 数 和 行 句 函 数 象 : 通 函 数 定 建 的 函 数 名 就 是 参 引 函 数 象 的 量 函 数 部 : 函 数 定 的 第 一 行 import 句 : 取 模 文 件 并 建 模 象 的 句 模 象 :import 句 建 的 一 个, 用 以 提 供 模 中 定 的 数 据 和 代 形 式 参 数 : 函 数 中 用 来 参 引 入 参 数 的 量 名 随 机 数 : 看 起 来 像 随 机 数 的 一 串 数, 不 是 由 确 定 的 程 序 生 的 返 回 : 函 数 的 果 如 果 一 个 函 数 用 作 表 式 来 使 用, 那 么 返 回 就 是 个 表 式 的 函 数 43