Python 第 1 课 安 装... 4 Python 第 2 课 print... 5 Python 第 3 课 IDE... 8 Python 第 4 课 输 入... 10 Python 第 5 课 变 量... 12 Python 第 6 课 bool... 14 Python 第 7 课 if... 17 Python 第 8 课 while... 21 Python 第 9 课 random... 24 Python 第 10 课 变 量 2... 26 Python 第 11 课 逻 辑 判 断... 27 Python 第 12 课 for 循 环... 28 Python 第 13 课 字 符 串... 30 Python 第 14 课 字 符 串 格 式 化... 32 Python 第 15 课 循 环 的 嵌 套... 33 Python 第 16 课 字 符 串 格 式 化 2... 35 Python 第 17 课 类 型 转 换... 36 Python 第 18 课 bool 类 型 转 换... 38 Python 第 19 课 函 数... 39 Python 第 21 课 函 数 的 参 数... 44 Python 第 22 课 函 数 应 用 示 例... 45 Python 第 23 课 if, elif, else... 47 Python 第 24 课 if 的 嵌 套... 52 Python 第 25 课 初 探 list... 54 Python 第 26 课 操 作 list... 56 Python 第 28 课 字 符 串 的 分 割... 63 Python 第 29 课 连 接 list... 69 Python 第 30 课 字 符 串 的 索 引 和 切 片... 70 Python 第 31 课 读 文 件... 72 Python 第 32 课 写 文 件... 74 Python 第 33 课 处 理 文 件 中 的 数 据... 75 Python 第 34 课 break... 81 Python 第 35 课 continue... 82 Python 第 36 课 异 常 处 理... 85 Python 第 37 课 字 典... 88 Python 第 38 课 模 块... 91 Python 第 39 课 用 文 件 保 存 游 戏 (1)... 94 Python 第 40 课 用 文 件 保 存 游 戏 (2)... 96 Python 第 41 课 用 文 件 保 存 游 戏 (3)... 99 Python 第 42 课 函 数 的 默 认 参 数... 103 Python 第 43 课 查 天 气 (1)... 105 Python 第 44 课 查 天 气 (2)... 106 Python 第 45 课 查 天 气 (3)... 109 Python 第 46 课 查 天 气 (4)... 111
Python 第 47 课 面 向 对 象 (1)... 114 Python 第 48 课 面 向 对 象 (2)... 115 Python 第 49 课 面 向 对 象 (3)... 116 Python 第 50 课 面 向 对 象 (4)... 118 Python 第 51 课 and-or 技 巧... 121 Python 第 52 课 元 组... 122 Python 第 53 课 数 学 运 算... 123 Python 第 54 课 真 值 表... 125 Python 第 55 课 正 则 表 达 式 (1)... 126 Python 第 56 课 正 则 表 达 式 (2)... 128 Python 第 57 课 正 则 表 达 式 (3)... 129 Python 第 58 课 正 则 表 达 式 (4)... 132 Python 第 59 课 正 则 表 达 式 (5)... 133 Python 第 60 课 随 机 数... 135 python 模 块 的 常 用 安 装 方 式... 137 正 则 表 达 式 30 分 钟 入 门 教 程... 138 目 录... 138 本 文 目 标... 139 如 何 使 用 本 教 程... 139 正 则 表 达 式 到 底 是 什 么 东 西?... 140 入 门... 140 测 试 正 则 表 达 式... 141 元 字 符... 142 字 符 转 义... 144 重 复... 144 字 符 类... 144 分 枝 条 件... 145 分 组... 145 反 义... 146 后 向 引 用... 146 零 宽 断 言... 147 负 向 零 宽 断 言... 148 注 释... 149 贪 婪 与 懒 惰... 149 处 理 选 项... 150 平 衡 组 / 递 归 匹 配... 150 还 有 些 什 么 东 西 没 提 到... 152 联 系 作 者... 153 网 上 的 资 源 及 本 文 参 考 文 献... 153 更 新 纪 录... 153
Python 第 0 课 Why Python? 为 什 么 用 Python 作 为 编 程 入 门 语 言? 原 因 很 简 单 每 种 语 言 都 会 有 它 的 支 持 者 和 反 对 者 去 Google 一 下 why python, 你 会 得 到 很 多 结 果, 诸 如 应 用 范 围 广 泛 开 源 社 区 活 跃 丰 富 的 库 跨 平 台 等 等 等 等, 也 可 能 找 到 不 少 对 它 的 批 评, 格 式 死 板 效 率 低 国 内 用 的 人 很 少 之 类 不 过 这 些 优 缺 点 的 权 衡 都 是 程 序 员 们 的 烦 恼 作 为 一 个 想 要 学 点 编 程 入 门 的 初 学 者 来 说, 简 单 才 是 最 重 要 的 当 学 C++ 的 同 学 还 在 写 链 表, 学 Java 的 同 学 还 在 折 腾 运 行 环 境 的 时 候, 学 Python 的 你 已 经 像 上 图 一 样 飞 上 天 了
当 然, 除 了 简 单, 还 有 一 个 重 要 的 原 因 : 因 为 我 现 在 每 天 都 在 写 Python 虽 然 以 后 可 能 会 讲 些 手 机 编 程 之 类 ( 如 果 真 的 有 那 么 一 天 π_π), 但 目 前 这 时 候, 各 位 也 就 看 菜 吃 饭, 有 啥 吃 啥 了 每 天 5 分 钟, 先 别 计 较 太 多 况 且 Python 还 是 挺 有 利 于 形 成 良 好 编 程 思 维 的 一 门 语 言 推 荐 两 本 我 个 人 比 较 喜 欢 的 Python 入 门 书 籍, 一 本 是 简 明 Python 教 程, 我 自 己 最 开 始 就 是 看 着 它 学 的, 接 下 来 也 会 大 体 参 考 里 面 的 内 容 讲 另 一 本 是 Head First Python,Head First 系 列 都 是 非 常 浅 显 易 懂 的 入 门 类 书 籍, 虽 然 我 只 瞄 过 几 眼, 但 感 觉 还 是 不 错 的 Python 第 1 课 安 装 进 入 Python 的 官 方 下 载 页 面 http://www.python.org/download/ 你 会 看 到 一 堆 下 载 链 接 我 们 就 选 Python 2.7.5 Windows Installer, 如 果 是 64 位 系 统 的 同 学 选 下 面 那 个 Python 2.7.5 Windows X86-64 Installer 为 什 么 不 选 最 上 面 那 个 3.3.2 的 新 版 本? 因 为 我 在 用 python2.7.x,python3 改 了 不 少 地 方, 不 熟 下 载 之 后, 就 和 装 其 他 软 件 一 样, 双 击, 一 路 Next, 想 换 安 装 路 径 的 同 学 可 以 换 个 位 置 但 不 管 换 不 换, 请 把 这 个 路 径 复 制 下 来, 比 如 我 的 是 C:\python27\, 后 面 要 用 到 它 安 装 结 束 还 没 完, 我 们 还 差 最 后 一 步 : 设 置 环 境 变 量 这 是 什 么 东 西 我 暂 时 先 不 解 释, 大 家 照 着 做 就 好 右 键 单 击 我 的 电 脑 ( 不, 是 你 的 电 脑 ), 依 次 点 击 " 属 性 "->" 高 级 "->" 环 境 变 量 ", 在 系 统 变 量 表 单 中 点 击 叫 做 Path 的 变 量, 然 后 编 辑 这 个 变 量, 把 ;C:\Python27\, 也 就 是 你 刚 才 复 制 的 安 装 路 径, 加 到 它 的 结 尾 注 意! 要 用 英 文 分 号 和 前 面 已 有 的 内 容 隔 开 然 后 点 确 定, 点 确 定, 再 点 确 定 完 成 怎 么 知 道 你 已 经 成 功 安 装 了 Python 呢? 这 时 候 你 需 要 打 开 命 令 行, 或 者 叫 命 令 提 示 符 控 制 台 方 法 是 : 点 击 开 始 菜 单 -> 程 序 -> 附 件 -> 命 令 提 示 符 ; 或 者 直 接 在 桌 面 按 快 捷 键 Win+r, Win 键 就 是 Ctrl 和 Alt 旁 边 那 个 有 windows 图 标 的 键, 输 入 cmd, 回 车 这 时 候 你 就 看 到 可 爱 的 黑 底 白 字 了 在 命 令 行 里 输 入 python, 回 车 如 果 看 到 诸 如 : Python 2.7.5 (default, May 15 2013, 22:43:36) [MSC v.1500 32 bit (Intel)] on win32 的 提 示 文 字, 恭 喜 你! 否 则, 请 重 新 检 查 你 哪 里 的 打 开 方 式 不 对, 或 者 直 接 给 我 留 言 接 下 来, 你 就 可 以 输 入 那 句 程 序 员 最 爱 的
print Hello World 向 Python 的 世 界 里 发 出 第 一 声 啼 哭 嗯 如 果 这 么 几 步 你 还 是 被 绕 晕 了, 没 关 系, 我 还 留 了 一 手 : 打 开 你 的 浏 览 器,Google 一 下 python online, 点 击 第 一 条 结 果 Execute Python Script Online ; 或 者 直 接 打 开 compileonline.com, 找 到 Python 点 进 去 http://www.compileonline.com/execute_python_online.php 这 是 一 个 在 线 的 python 运 行 环 境, 你 可 以 在 这 里 练 习, 无 需 任 何 下 载 安 装 配 置 左 边 页 面 是 写 代 码 的 地 方, 点 击 左 上 角 的 Execute Sctipt, 就 可 以 在 右 边 页 面 看 到 输 出 结 果 那 Mac 的 同 学 怎 么 办?Mac 上 叫 终 端, 英 文 版 叫 Terminal, 可 以 在 应 用 程 序 里 找 到, 也 可 以 直 接 在 你 的 Mac 上 搜 索 终 端 或 者 Terminal 找 到 打 开 之 后 输 入 python, 回 车, 就 可 以 进 入 python 了 好 了, 今 天 就 这 么 多, 快 去 试 试 你 的 python, 输 出 一 行 Hello World 吧 完 成 的 同 学 可 以 截 个 屏 发 给 我 欢 迎 各 种 建 议 讨 论 和 闲 聊, 当 然 更 欢 迎 你 把 这 里 分 享 给 更 多 的 朋 友 我 今 天 发 现 昨 天 提 供 的 compileonline.com 网 站 有 时 候 会 很 慢, 甚 至 无 法 正 常 运 行, 于 是 我 又 找 了 一 个 : http://www.pythonfiddle.com 似 乎 要 快 一 点, 不 过 好 像 只 能 在 电 脑 上 的 浏 览 器 打 开 另 外 就 是, 昨 天 忘 了 给 Mac 的 同 学 们 说 一 下 怎 么 打 开 命 令 行 Mac 上 叫 做 终 端 或 者 Terminal, 可 以 在 应 用 程 序 里 找 到, 也 可 以 直 接 在 spotlight 里 直 接 输 入 Terminal 打 开 打 开 后 就 可 以 通 过 python 命 令 进 入 开 发 环 境 了 Python 第 2 课 print print, 中 文 意 思 是 打 印, 在 python 里 它 不 是 往 纸 上 打 印, 而 是 打 印 在 命 令 行, 或 者 叫 终 端 控 制 台 里 面 print 是 python 里 很 基 本 很 常 见 的 一 个 操 作, 它 的 操 作 对 象 是 一 个 字 符 串 ( 什 么 是 字 符 串, 此 处 按 住 不 表, 且 待 日 后 慢 慢 道 来 ) 基 本 格 式 是 : print 你 要 打 印 的 东 西 或 者 print( 你 要 打 印 的 东 西 ) 这 里 一 定 要 英 文 字 符 的 括 号, 所 有 程 序 中 出 现 的 符 号 都 必 须 是 英 文 字 符, 注 意 别 被 你 的 输 入 法 坑 了 各 位 同 学 可 以 在 自 己 的 python 环 境 中 试 着 输 出 以 下 内 容 ( 这 里 是 命 令 行 下 的 效 果, 使 用 在 线 编 辑 器 或 者 IDE 的 同 学, 只 需 要 输 入 >>> 后 面 的 内 容 就 可 以 了 ):
>>> print "hello" hello >>> print 'world' world >>> print 1 1 >>> print 3.14 3.14 >>> print 3e30 3e+30 >>> print 1 + 2 * 3 7 >>> print 2 > 5 False 直 接 在 print 后 面 加 一 段 文 字 来 输 出 的 话, 需 要 给 文 字 加 上 双 引 号 或 者 单 引 号 大 家 发 现, print 除 了 打 印 文 字 之 外, 还 能 输 出 各 种 数 字 运 算 结 果 比 较 结 果 等 你 们 试 着 自 己 pri nt 一 些 别 的 东 西, 看 看 哪 些 能 成 功, 哪 些 会 失 败, 有 兴 趣 的 话 再 猜 一 猜 失 败 的 原 因 其 实 在 python 命 令 行 下,print 是 可 以 省 略 的, 默 认 就 会 输 出 每 一 次 命 令 的 结 果 就 像 这 样 : >>> 'Your YiDa!' 'Your YiDa!' >>> 2+13+250 265 >>> 5<50 True 今 天 内 容 就 这 么 多 没 听 出 个 所 以 然? 没 关 系, 只 要 成 功 print 出 来 结 果 就 可 以, 我 们 以 后 还 有 很 多 时 间 来 讨 论 其 中 的 细 节
这 个 短 期 目 标 就 是 一 个 很 简 单 很 弱 智 的 小 游 戏 : COM: Guess what I think? 5 COM: Your answer is too small. 12 COM: Your answer is too large. 9 COM: Your answer is too small. 10 COM: BINGO!!! 解 释 一 下 : 首 先 电 脑 会 在 心 中 掐 指 一 算, 默 念 一 个 数 字, 然 后 叫 你 猜 你 猜 了 个 答 案, 电 脑 会 厚 道 地 告 诉 你 大 了 还 是 小 了, 直 到 最 终 被 你 果 断 猜 中 这 是 我 十 几 年 前 刚 接 触 编 程 时 候 写 的 第 一 个 程 序, 当 时 家 里 没 有 电 脑, 在 纸 上 琢 磨 了 很 久 之 后, 熬 到 第 二 个 星 期 的 电 脑 课 才 在 学 校 的 486 上 run 起 来 后 来 我 还 写 过 一 个 windows 下 的 窗 口 版 本 现 在 就 让 它 也 成 为 你 们 第 一 个 完 整 的 程 序 吧 照 我 们 每 天 5 分 钟 的 进 度, 初 步 估 计 半 个 月 后 大 约 能 完 成 了
Python 第 3 课 IDE 打 个 不 恰 当 的 比 方, 如 果 说 写 代 码 是 制 作 一 件 工 艺 品, 那 IDE 就 是 机 床 再 打 个 不 恰 当 的 比 方,PS 就 是 图 片 的 IDE,Word 就 是 doc 文 档 的 IDE,PowerPoint 就 是 ppt 文 件 的 IDE python 也 有 自 己 的 IDE, 而 且 还 有 很 多 python 自 带 了 一 款 IDE, 叫 做 IDLE 先 说 Windows,Windows 上 安 装 了 之 后, 可 以 在 开 始 菜 单 -> 程 序 -> Python 2.7 里 找 到 它 打 开 后 之 后 很 像 我 们 之 前 用 过 的 命 令 行 没 错, 它 就 是 的, 在 里 面 print 一 下 试 试 不 知 之 前 用 命 令 行 的 同 学 有 没 有 注 意 到, 命 令 行 输 一 行 命 令 就 会 返 回 结 果, 而 且 之 前 print 了 那 么 多, 关 掉 之 后 也 不 知 道 到 哪 里 去 了 所 以 它 没 法 满 足 我 们 编 写 弱 智 小 游 戏 的 大 计 划 我 们 需 要 用 新 的 方 法! 点 击 窗 口 上 方 菜 单 栏 的 File -> New Window, 会 打 一 个 长 得 很 像 的 新 窗 口, 但 里 面 什 么 也 没 有 这 是 一 个 文 本 编 辑 器, 在 这 里 面 就 可 以 写 我 们 的 python 程 序 了 继 续 print 几 行, 这 次 可 以 多 print 一 点 : print 'Hello' print 'IDE' print 'Here I am.' 现 在 是, 见 证 奇 迹 的 时 刻! 点 击 Run -> Run Module, 或 者 直 接 按 快 捷 键 F5 会 提 示 你 保 存 刚 才 文 件, 随 便 取 个 名 字, 比 如 lesson3.py (.py 是 python 代 码 文 件 的 类 型, 虽
然 不 指 定.py 也 是 可 以 的, 但 建 议 还 按 规 范 来 ) 保 存 完 毕 后, 之 前 那 个 控 制 台 窗 口 里 就 会 一 次 性 输 出 你 要 的 结 果 以 后 想 再 次 编 辑 或 运 行 刚 才 的 代 码, 只 要 在 IDLE 里 选 择 File -> Open..., 打 开 刚 才 保 存 的.py 文 件 就 可 以 了 Mac 上 的 IDLE 是 预 装 好 了, 在 终 端 里 输 入 IDLE 就 可 以 启 动, 使 用 方 法 同 Windows 也 可 以 在 文 件 夹 /usr/bin 里 可 以 找 到 IDLE 如 果 是 重 新 下 载 安 装 了 python, 似 乎 是 可 以 在 应 用 程 序 里 找 到 IDLE 的,Mac 的 同 学 可 以 验 证 下 另 外,Windows 下 有 一 个 第 三 方 的 免 费 IDE, 叫 PyScripter, 把 文 件 目 录 文 本 编 辑 器 命 令 行 都 整 合 到 了 一 起, 还 增 加 了 很 多 辅 助 功 能 有 兴 趣 的 同 学 也 可 以 去 找 来 试 试 看 地 址 : http://code.google.com/p/pyscripter/ 用 起 来 应 该 比 IDLE 方 便, 但 有 一 点 要 注 意, 它 的 安 装 位 置 和.py 文 件 的 保 存 位 置 都 不 要 有 中 文, 不 然 可 能 会 有 问 题 今 天 的 内 容 有 点 长 配 置 开 发 环 境 这 种 事 最 麻 烦 了, 大 家 耐 心 一 点, 毕 竟 一 次 投 入, 长 期 受 益 以 后 我 们 的 课 程 都 会 在 IDE 中 进 行, 基 本 不 再 往 命 令 行 里 直 接 敲 代 码 了 最 后 说 下, 有 很 多 python 程 序 员 都 不 使 用 任 何 IDE 至 于 原 因 嘛, 可 能 就 像 优 秀 的 手 工 艺 人 是 不 会 用 机 床 来 加 工 艺 术 品 的 吧
Python 第 4 课 输 入 前 print 了 那 么 多, 都 是 程 序 在 向 屏 幕 输 出 那 有 来 得 有 往, 有 借 得 有 还, 有 吃 咳 咳! 那 啥, 我 们 得 有 向 程 序 输 入 信 息 的 办 法, 才 能 和 程 序 对 话, 进 行 所 谓 的 人 机 交 互 python 有 一 个 接 收 命 令 行 下 输 入 的 方 法 : input() 注 意, 和 print 不 同 的 是, 这 次 我 们 必 须 得 加 上 () 了, 而 且 得 是 英 文 字 符 的 括 号 好 了, 终 于 可 以 搬 出 那 个 弱 智 小 游 戏 了, 耶! 游 戏 里 我 们 需 要 跟 程 序 一 问 一 答, 所 以 我 们 先 把 话 给 说 上 打 开 我 们 的 python 编 辑 器, 不 管 是 IDLE, 在 线 编 辑 器, 还 是 其 他 的 IDE 在 代 码 编 辑 器 中 输 入 下 面 几 句 代 码 : print "Who do you think I am?" input() print "Oh, yes!" 然 后,Run!(Forrest Run!) 你 会 在 命 令 行 中 看 到, 程 序 输 出 了 第 一 句 之 后 就 停 住 了, 这 是 input 在 等 待 你 的 输 入 输 入 你 的 回 答, 回 车 你 会 看 到 程 序 的 回 答 注 意! 引 号!! 又 是 引 号!!! 和 print 一 样, 如 果 你 输 的 是 一 串 文 字, 要 用 引 号 '' 或 者 "" 引 起 来, 如 果 是 数 字 则 不 用 ( 插 一 句,python 还 有 一 个 输 入 的 方 法 :raw_input(), 它 把 所 有 的 输 入 都 直 接 当 作 一 串 字 符, 于 是 就 可 以 不 用 加 引 号, 有 兴 趣 的 同 学 可 以 试 一 试, 体 会 一 下 两 者 的 不 同 关 于 这 个 令 人 纠 结 的 引 号, 我 们 以 后 会 再 讨 论 它 ) 看 上 去 不 错 哦, 似 乎 就 这 么 对 上 话 了 是 不 是 觉 得 离 小 游 戏 的 完 成 迈 进 了 一 大 步? 可 是 大 家 发 现 没 有, 即 使 你 说 "Idiot!", 程 序 仍 然 会 淡 定 地 回 答 "Oh, yes!" 因 为 它 左 耳 进 右 耳 出, 根 本 就 没 听 进 去 我 们 到 底 说 了 啥 那 怎 么 才 能 让 它 认 真 听 话 呢? 啪! 且 听 下 回 分 解
回 顾 一 下 我 们 之 前 几 节 课 我 们 到 现 在 一 共 提 到 了 三 种 可 以 运 行 print 的 方 式 : 1. 命 令 行, 包 括 Win 下 的 控 制 台 (CMD) 和 Mac 下 的 终 端 (Terminal) 它 可 以 帮 我 们 确 认 自 己 电 脑 上 的 python 是 不 是 正 常 但 是 这 种 方 法 很 难 帮 我 们 实 现 写 一 个 完 整 小 程 序 的 目 标 2. IDE, 包 括 python 自 带 的 IDLE 和 其 他 第 三 方 的 IDE 不 知 道 大 家 是 不 是 都 顺 利 搞 定, 并 且 能 顺 利 保 存 并 打 开 py 文 件 了 呢? 以 后 我 们 课 程 里 的 内 容, 你 都 可 以 在 这 里 面 进 行 3. 在 线 编 辑 器,compileonline 或 者 pythonfiddle 他 们 同 样 包 括 代 码 编 辑 器 ( 写 代 码 的 地 方 ) 和 控 制 台 ( 输 出 结 果 的 地 方 ) 两 部 分 所 以 我 们 在 本 地 IDE 里 的 操 作 都 可 以 在 其 中 实 现 只 不 过 保 存 文 件 会 有 些 复 杂,compileonline 是 点 击 download files 打 包 下 载,pythonfiddle 需 要 注 册 一 下 当 然, 你 也 可 以 直 接 把 你 写 好 的 代 码
复 制 下 来, 保 存 在 本 地, 下 次 再 粘 贴 上 去 接 着 写 Python 第 5 课 变 量 昨 天 说 到, 需 要 让 程 序 理 解 我 们 输 入 的 东 西 那 首 先, 就 需 要 有 东 西 把 我 们 输 入 的 内 容 记 录 下 来, 好 为 接 下 来 的 操 作 做 准 备 Python 之 神 说, 要 有 变 量! 于 是 就 有 了 变 量 变 量, 望 文 生 义, 就 是 变 化 的 量 python 里 创 建 一 个 变 量 的 方 法 很 简 单, 给 它 起 个 名 字, 然 后 给 它 一 个 值 举 起 几 个 栗 子 : name = 'Crossin' myvar = 123 price = 5.99 visible = True = 的 作 用 是 把 右 边 的 值 赋 予 给 左 边 的 变 量 这 里 说 一 下 另 外 一 个 概 念, 叫 做 数 据 类 型, 上 面 4 颗 栗 子 分 别 代 表 了 python 中 较 常 见 的 四 种 基 本 类 型 : 字 符 串 - 表 示 一 串 字 符, 需 要 用 '' 或 "" 引 起 来 整 数 浮 点 数 - 就 是 小 数 bool( 布 尔 ) - 这 个 比 较 特 殊, 是 用 来 表 示 逻 辑 是 非 的 一 种 类 型, 它 只 有 两 个 值, True 和 False ( 注 意 这 里 没 有 引 号, 有 了 引 号 就 变 成 字 符 串 了 ) 再 次 用 到 我 们 熟 悉 的 print 这 次, 我 们 升 级 了, 要 用 print 输 出 一 个 变 量 :
name = 'Crossin' print name 看 到 结 果 了 吗? 没 有 输 出 name, 也 没 有 报 错, 而 是 输 出 了 Crossin 现 在 是 不 是 能 想 明 白 一 些, 为 什 么 之 前 print 一 段 文 字 没 加 引 号 就 会 报 错, 而 print 一 个 数 字 就 没 有 问 题 呢? 它 叫 变 量, 那 就 是 能 变 的 所 以 在 一 次 赋 值 操 作 之 后, 还 可 以 继 续 给 它 赋 予 新 的 值, 而 且 可 以 是 不 同 类 型 的 值 a = 123 print a a = 'hi' print a = 的 右 边 还 可 以 更 复 杂 一 点, 比 如 是 一 个 计 算 出 的 值 : value = 3 * 4 print value value = 2 < 5 print value 甚 至, 也 可 以 是 input(): name = input() print name 于 是, 我 们 又 可 以 进 化 一 下 我 们 的 小 游 戏 了 把 上 次 写 的 内 容 稍 微 改 一 下, 加 上 变 量 : print "Who do you think I am?" you = input() print "Oh, yes! I am a" print you 看 来 程 序 已 经 知 道 我 们 的 输 入 了 接 下 来, 就 要 让 它 学 会 对 不 同 的 答 案 做 出 判 断 这 个 我 们 留 到 下 次 再 说
今 天 是 周 五 我 觉 得 吧, 到 周 末 了, 大 家 应 该 远 离 一 下 电 脑, 多 陪 陪 家 人 朋 友, 吃 吃 饭, 出 去 走 走 祝 大 家 周 末 愉 快! Python 第 6 课 bool 昨 天 说 到 了 python 中 的 几 个 基 本 类 型, 字 符 串 整 数 浮 点 数 都 还 算 好 理 解, 关 于 剩 下 的 那 个 bool( 布 尔 值 ) 我 要 稍 微 多 说 几 句 逻 辑 判 断 在 编 程 中 是 非 常 重 要 的 大 量 的 复 杂 程 序 在 根 本 上 都 是 建 立 在 真 与 假 的 基 本 逻 辑 之 上 而 bool 所 表 示 的 就 是 这 种 最 单 纯 最 本 质 的 True / Flase, 真 与 假, 是 与 非 来 看 下 面 的 例 子 : a = 1 < 3
print a b = 1 c = 3 print b > c 通 过 用 > < 来 比 较 两 个 数 值, 我 们 就 得 到 了 一 个 bool 值 这 个 bool 值 的 真 假 取 决 于 比 较 的 结 果 > < 在 编 程 语 言 中 被 成 为 逻 辑 运 算 符, 常 用 的 逻 辑 运 算 符 包 括 : >: 大 于 <: 小 于 >=: 大 于 等 于 <=: 小 于 等 于 ==: 等 于 比 较 两 个 值 是 否 相 等 之 所 以 用 两 个 等 号, 是 为 了 和 变 量 赋 值 区 分 开 来!=: 不 等 与 not: 逻 辑 非 如 果 x 为 True, 则 not x 为 False and: 逻 辑 与 如 果 x 为 True, 且 y 为 True, 则 x and y 为 True or: 逻 辑 或 如 果 x y 中 至 少 有 一 个 为 True, 则 x or y 为 True 关 于 bool 值 和 逻 辑 运 算 其 实 远 不 止 这 些, 但 现 在 我 们 暂 时 不 去 考 虑 那 么 多, 以 免 被 绕 得 找 不 到 北 最 基 本 的 大 于 小 于 等 于 已 经 够 我 们 先 用 一 用 的 了 试 试 把 bool 加 到 我 们 的 小 游 戏 里 : num = 10 print 'Guess what I think?' answer = input() result = answer<num print 'too small?' print result result = answer>num print 'too big?' print result
result = answer==num print 'equal?' print result 代 码 比 之 前 稍 微 多 了 一 点, 解 释 一 下 第 一 段 代 码 : 先 创 建 一 个 值 为 10 的 变 量 num, 输 出 一 句 提 示, 然 后 再 输 入 一 个 值 给 变 量 answer 第 二 段 代 码 : 计 算 answer<num 的 结 果, 记 录 在 result 里, 输 出 提 示, 再 输 出 结 果 第 三 段 第 四 段 都 与 第 二 段 类 似, 只 是 比 较 的 内 容 不 一 样 看 看 结 果 是 不 是 跟 你 预 期 的 一 致? 虽 然 看 上 去 还 是 有 点 傻, 但 是 离 目 标 又 进 了 一 步 现 在 数 数 你 手 上 的 工 具 : 输 入 输 出, 用 来 记 录 数 值 的 变 量, 还 有 可 以 比 较 数 值 大 小 的 逻 辑 运 算 用 它 们 在 你 的 python 里 折 腾 一 番 吧
Python 第 7 课 if 继 续 上 次 的 程 序 我 们 已 经 能 让 判 断 我 们 输 入 的 值 了, 但 这 程 序 还 是 有 点 呆, 不 过 怎 样 都 要 把 话 说 三 遍 因 为 到 目 前 为 止, 我 们 的 程 序 都 是 按 照 顺 序 从 上 到 下 一 行 接 一 行 地 执 行 有 同 学 发 来 问 题 了 : 怎 么 能 让 它 根 据 我 们 输 入 的 结 果 来 选 择 执 行 呢? 答 案 就 是 if 来 看 一 张 图 ( 纯 手 绘, 渣 画 质 )
解 释 一 下, 程 序 顺 序 往 下 执 行 遇 到 if 语 句 的 时 候, 会 去 判 断 它 所 带 条 件 的 真 假 如 果 为 True, 就 会 去 执 行 接 下 来 的 内 容 如 果 为 False, 就 跳 过 语 法 为 : if 条 件 : 选 择 执 行 的 语 句 特 别 说 明 : 条 件 后 面 的 冒 号 不 能 少, 同 样 必 须 是 英 文 字 符 特 别 特 别 说 明 :if 内 部 的 语 句 需 要 有 一 个 统 一 的 缩 进, 一 般 用 4 个 空 格 python 用 这 种 方 法
替 代 了 其 他 很 多 编 程 语 言 中 的 {} 你 也 可 以 选 择 1/2/3... 个 空 格 或 者 按 一 下 tab 键, 但 必 须 整 个 文 件 中 都 统 一 起 来 千 万 不 可 以 tab 和 空 格 混 用, 不 然 就 会 出 现 各 种 莫 名 其 妙 的 错 误 所 以 建 议 都 直 接 用 4 个 空 格 上 栗 子 : thisislove = input() if thisislove: print " 再 转 身 就 该 勇 敢 留 下 来 " 试 试 看? 输 入 True, 就 会 得 到 回 答 输 入 False, 什 么 也 没 有 ( 如 果 你 那 里 输 出 中 文 有 问 题, 请 自 行 改 成 英 文 ) 所 以, 我 们 的 游 戏 可 以 这 样 改 写 : num = 10 print 'Guess what I think?' answer = input() if answer<num: print 'too small!' if answer>num: print 'too big!' if answer==num: print 'BINGO!'
if 在 编 程 语 言 中 被 称 为 控 制 流 语 句, 用 来 控 制 程 序 的 执 行 顺 序 还 有 其 他 的 控 制 流 语 句, 后 面 我 们 会 用 到 重 新 发 一 下 代 码 thisislove = input() if thisislove: print " 再 转 身 就 该 勇 敢 留 下 来 " ======== num = 10 print 'Guess what I think?' answer = input() if answer<num: print 'too small!' if answer>num:
print 'too big!' if answer==num: print 'BINGO!' Python 第 8 课 while 先 介 绍 一 个 新 东 西 : 注 释 python 里, 以 # 开 头 的 文 字 都 不 会 被 认 为 是 可 执 行 的 代 码 和 print hello world print "hello world" # 输 出 一 行 字 是 同 样 的 效 果 但 后 者 可 以 帮 助 开 发 者 更 好 地 理 解 代 码 在 接 下 来 的 课 程 中, 我 会 经 常 用 注 释 来 解 释 代 码 用 if 改 进 完 我 们 的 小 游 戏 后, 功 能 已 经 基 本 实 现 了 很 多 同 学 做 完 后 纷 纷 表 示, 每 次 只 能 猜 一 次, 完 了 之 后 又 得 重 新 run, 感 觉 好 麻 烦 能 不 能 有 办 法 让 玩 家 一 直 猜, 直 到 猜 中 为 止? 答 案 很 显 然, 如 果 这 种 小 问 题 都 解 决 不 了, 那 python 可 就 弱 爆 了 最 简 单 的 解 决 方 法 就 是 while 同 if 一 样,while 也 是 一 种 控 制 流 语 句, 另 外 它 也 被 称 作 循 环 语 句 继 续 来 看 渣 画 质 手 绘 流 程 图 :
程 序 执 行 到 while 处, 当 条 件 为 True 时, 就 去 执 行 while 内 部 的 代 码, 当 条 件 为 False 时, 就 跳 过 语 法 为 : while 条 件 : 循 环 执 行 的 语 句 同 if 一 样, 注 意 冒 号, 注 意 缩 进
今 天 的 栗 子 : a = 1 # 先 a 设 为 1 while a!= 0: #a 不 等 于 0 就 一 直 做 print "please input" a = input() print "over" 想 想 怎 么 用 while 改 进 小 游 戏? 有 多 种 写 法, 大 家 自 己 思 考 下, 我 不 多 做 说 明 了 下 图 给 出 一 种 方 法
注 意, 这 里 出 现 了 两 层 缩 进, 要 保 持 每 层 缩 进 的 空 格 数 相 同 到 此 为 止, 小 游 戏 已 经 基 本 成 型 了 不 过 好 像 还 差 一 点 : 每 次 自 己 都 知 道 答 案, 这 玩 起 来 有 神 马 意 思 明 天 来 讲, 怎 么 让 你 不 知 道 电 脑 的 答 案 Python 第 9 课 random 之 前 我 们 用 了 很 多 次 的 print 和 input 方 法, 它 们 的 作 用 是 实 现 控 制 台 的 输 入 和 输 出 除 此 之 外,python 还 提 供 了 很 多 模 块, 用 来 实 现 各 种 常 见 的 功 能, 比 如 时 间 处 理 科 学 计 算 网 络 请 求 随 机 数 等 等 等 等 今 天 我 就 来 说 说, 如 何 用 python 自 带 的 随 机 数 模 块, 给 我 们 的 小 游 戏 增 加 不 确 定 性 引 入 模 块 的 方 法 : from 模 块 名 import 方 法 名 看 不 懂 没 关 系, 这 东 西 以 后 我 们 会 反 复 用 到 今 天 你 只 要 记 住, 你 想 要 产 生 一 个 随 机 的 整 数, 就 在 程 序 的 最 开 头 写 上 : from random import randint 之 后 你 就 可 以 用 randint 来 产 生 随 机 数 了 还 记 得 input 后 面 的 () 吗, 我 们 使 用 randint 的 时 候 后 面 也 要 有 () 而 且, 还 要 在 括 号 中 提 供 两 个 数 字, 先 后 分 别 是 产 生 随 机 整 数 范 围 的 下 限 和 上 限 例 如 : randint(5, 10) 这 样 将 会 产 生 一 个 5 到 10 之 间 ( 包 括 5 和 10) 的 随 机 整 数
放 到 我 们 的 小 游 戏 里, 用 answer = randint(1, 100) 替 代 answer = 10 程 序 在 运 行 时 候, 会 产 生 一 个 1 到 100 的 随 机 整 数, 存 在 answer 里, 我 们 也 不 知 道 是 多 少, 真 的 全 靠 猜 了 好 了, 觉 得 还 有 点 意 思 么? 我 们 终 于 一 步 步 把 这 个 弱 智 小 游 戏 给 做 出 来 了, 有 没 有 一 丁 点 的 成 就 感 呢? 如 果 你 对 其 中 的 某 些 细 节 还 不 是 很 理 解, 恭 喜 你, 你 已 经 开 始 入 门 了 相 信 你 会 带 着 一 颗 追 求 真 相 的 心, 在 编 程 这 条 路 上 不 断 走 下 去 我 们 的 课 程, 也 才 刚 刚 开 始
Python 第 10 课 变 量 2 变 量 这 东 西, 我 们 已 经 用 过 有 了 变 量, 就 可 以 存 储 和 计 算 数 据 今 天 来 讲 点 变 量 的 细 节 #==== 变 量 命 名 规 则 ====# 变 量 名 不 是 你 想 起 就 能 起 的 : 第 一 个 字 符 必 须 是 字 母 或 者 下 划 线 _ 剩 下 的 部 分 可 以 是 字 母 下 划 线 _ 或 数 字 (0-9) 变 量 名 称 是 对 大 小 写 敏 感 的,myname 和 myname 不 是 同 一 个 变 量 几 个 有 效 的 栗 子 : i my_name name_23 a1b2_c3 几 个 坏 掉 的 栗 子 ( 想 一 下 为 什 么 不 对 ): 2things this is spaced out my-name #==== 变 量 的 运 算 ====# 我 们 前 面 有 用 到 变 量 来 存 储 数 据 : num = 10 answer = input() 也 有 用 到 变 量 来 比 较 大 小 : answer < num 除 此 之 外, 变 量 还 可 以 进 行 数 学 运 算 : a = 5 b = a + 3 c = a + b python 中 运 算 的 顺 序 是, 先 把 = 右 边 的 结 果 算 出 了, 再 赋 值 给 左 边 的 变 量 下 面 这 个 例 子 : a = 5 a = a + 3 print a 你 会 看 到, 输 出 了 8, 因 为 先 计 算 出 了 右 边 的 值 为 8, 再 把 8 赋 给 左 边 的 a 通 过 这 种 方 法, 可 以 实 现 累 加 求 和 的 效 果 它 还 有 个 简 化 的 写 法 : a += 3 这 个 和 a = a + 3 是 一 样 的
于 是, 利 用 变 量 循 环 累 加, 可 以 写 一 个 程 序, 来 完 成 传 说 中 高 斯 大 牛 在 小 时 候 做 过 的 题 : 1+2+3+...+100=? 从 1 加 到 100 等 于 多 少? 提 示 : 你 可 以 用 一 个 变 量 记 录 现 在 加 到 几 了, 再 用 一 个 变 量 记 录 加 出 来 的 结 果, 通 过 while 来 判 断 是 不 是 加 到 100 了 Python 第 11 课 逻 辑 判 断 之 前 粗 略 地 提 到 bool 类 型 的 变 量, 又 说 到 if 和 while 的 判 断 条 件 有 些 同 学 反 馈 说 没 怎 么 理 解, 为 什 么 一 会 儿 是 bingo=false, 一 会 又 是 bingo==false, 一 会 儿 是 while 在 条 件 为 True 的 时 候 执 行, 一 会 儿 又 是 while 在 bingo==false 的 时 候 执 行 别 急, 你 听 我 说 首 先, 要 理 解, 一 个 逻 辑 表 达 式, 其 实 最 终 是 代 表 了 一 个 bool 类 型 的 结 果, 比 如 : 1 < 3 这 个 就 像 当 于 是 一 个 True 的 值 2 == 3 这 个 就 是 False 把 它 们 作 为 判 断 条 件 放 到 if 或 者 while 的 后 面, 就 是 根 据 他 们 的 值 来 决 定 要 不 要 执 行 同 样 的 栗 子 再 来 几 颗 : a = 1print a>3 #Falseprint a==2-1 #Trueb = 3 print a+b==2+2 #True 比 较 容 易 搞 混 的, 是 bool 变 量 的 值 和 一 个 逻 辑 表 达 式 的 值, 比 如 : a = Falseprint a #False print a==false #True
虽 然 a 本 身 的 值 是 False, 但 是 a==false 这 个 表 达 式 的 值 是 True ( 说 人 话!) a 是 错 的, 但 a 是 错 的 这 句 话 是 对 的 回 到 上 面 那 几 个 概 念 : bingo=false 把 bingo 设 为 一 个 值 为 False 的 变 量 bingo==false 判 断 bingo 的 值 是 不 是 False, 如 果 是, 那 么 这 句 话 就 是 True while 在 判 断 条 件 条 件 为 True 时 执 行 循 环, 所 以 当 bingo==false 时, 条 件 为 True, 循 环 是 要 执 行 的 晕 了 没? 谁 刚 学 谁 都 晕 不 晕 的 属 于 骨 骼 惊 奇 百 年 一 遇 的 编 程 奇 才, 还 不 赶 紧 转 行 做 程 序 员! 逻 辑 这 东 西 是 初 学 编 程 的 一 大 坑, 我 们 后 面 还 要 在 这 个 坑 里 挣 扎 很 久 留 个 习 题 :a = True b = not a # 不 记 得 not 请 回 复 6 想 想 下 面 这 些 逻 辑 运 算 的 结 果, 然 后 用 print 看 看 你 想 的 对 不 对 :bnot ba == ba!= ba and ba or b1<2 and b==true Python 第 12 课 for 循 环 大 家 对 while 循 环 已 经 有 点 熟 悉 了 吧? 今 天 我 们 来 讲 另 一 种 循 环 语 句 : for... in... 同 while 一 样,for 循 环 可 以 用 来 重 复 做 一 件 事 情 在 某 些 场 景 下, 它 比 while 更 好 用 比 如 之 前 的 一 道 习 题 : 输 出 1 到 100( 回 复 903 可 看 详 细 内 容 ) 我 们 用 while 来 做, 需 要 有 一 个 值 来 记 录 已 经 做 了 多 少 次, 还 需 要 在 while 后 面 判 断 是 不 是 到 了 100 如 果 用 for 循 环, 则 可 以 这 么 写 : for i in range(1, 101): print i
解 释 一 下,range(1, 101) 表 示 从 1 开 始, 到 101 为 止 ( 不 包 括 101), 取 其 中 所 有 的 整 数 for i in range(1, 101) 就 是 说, 把 这 些 数, 依 次 赋 值 给 变 量 i 相 当 于 一 个 一 个 循 环 过 去, 第 一 次 i = 1, 第 二 次 i = 2,, 直 到 i = 100 当 i = 101 时 跳 出 循 环 所 以, 当 你 需 要 一 个 循 环 10 次 的 循 环, 你 就 只 需 要 写 : for i in range(1, 11) 或 者 for i in range(0, 10) 区 别 在 于 前 者 i 是 从 1 到 10, 后 者 i 是 从 0 到 9 当 然, 你 也 可 以 不 用 i 这 个 变 量 名 比 如 一 个 循 环 n 次 的 循 环 : for count in range(0, n) for 循 环 的 本 质 是 对 一 个 序 列 中 的 元 素 进 行 递 归 什 么 是 序 列, 以 后 再 说 先 记 住 这 个 最 简 单 的 形 式 : for i in range(a, b) 从 a 循 环 至 b-1 现 在, 你 可 以 用 for 循 环 来 改 写 习 题 903,904,905,906 了
Python 第 13 课 字 符 串 字 符 串 就 是 一 组 字 符 的 序 列 ( 序 列! 又 见 序 列! 还 记 得 我 说 过,range 就 是 产 生 一 组 整 数 序 列 今 天 仍 然 不 去 细 说 它 ), 它 一 向 是 编 程 中 的 常 见 问 题 之 前 我 们 用 过 它, 以 后 我 们 还 要 不 停 地 用 它 python 中 最 常 用 的 字 符 串 表 示 方 式 是 单 引 号 ( ) 和 双 引 号 ("") 我 还 是 要 再 说 : 一 定 得 是 英 文 字 符! 'string' 和 string 的 效 果 是 一 样 的 可 以 直 接 输 出 一 个 字 符 串 print good 也 可 以 用 一 个 变 量 来 保 存 字 符 串, 然 后 输 出 str = bad print str 如 果 你 想 表 示 一 段 带 有 英 文 单 引 号 或 者 双 引 号 的 文 字, 那 么 表 示 这 个 字 符 串 的 引 号 就 要 与 内 容 区 别 开 内 容 带 有 单 引 号, 就 用 双 引 号 表 示 "It's good" 反 之 亦 然 You are a "BAD" man python 中 还 有 一 种 表 示 字 符 串 的 方 法 : 三 个 引 号 ( ) 或 者 (""") 在 三 个 引 号 中, 你 可 以 方 便 地 使 用 单 引 号 和 双 引 号, 并 且 可 以 直 接 换 行 ''' "What's your name?" I asked. "I'm Han Meimei." ''' 还 有 一 种 在 字 符 串 中 表 示 引 号 的 方 法, 就 是 用 \, 可 以 不 受 引 号 的 限 制 \' 表 示 单 引 号,\" 表 示 双 引 号 I\'m a \"good\" teacher
\ 被 称 作 转 译 字 符, 除 了 用 来 表 示 引 号, 还 有 比 如 用 \\ 表 示 字 符 串 中 的 \ \n 表 示 字 符 串 中 的 换 行 \ 还 有 个 用 处, 就 是 用 来 在 代 码 中 换 行, 而 不 影 响 输 出 的 结 果 : "this is the\ same line" 这 个 字 符 串 仍 然 只 有 一 行, 和 "this is thesame line" 是 一 样 的, 只 是 在 代 码 中 换 了 行 当 你 要 写 一 行 很 长 的 代 码 时, 这 个 会 派 上 用 场 作 业 时 间 用 print 输 出 以 下 文 字 : 1. He said, "I'm yours!" 2. \\_v_// 3. Stay hungry, stay foolish. -- Steve Jobs 4. * *** ***** *** *
Python 第 14 课 字 符 串 格 式 化 我 们 在 输 出 字 符 串 的 时 候, 如 果 想 对 输 出 的 内 容 进 行 一 些 整 理, 比 如 把 几 段 字 符 拼 接 起 来, 或 者 把 一 段 字 符 插 入 到 另 一 段 字 符 中 间, 就 需 要 用 到 字 符 串 的 格 式 化 输 出 先 从 简 单 的 开 始, 如 果 你 想 把 两 段 字 符 连 起 来 输 出 str1 = 'good' str2 = 'bye' 你 可 以 print str1 + str2 或 者 还 可 以 把 字 符 变 量 一 个 字 符 串 相 加 print 'very' + str1 print str1 + ' and ' + str2 但 如 果 你 想 要 把 一 个 数 字 加 到 文 字 后 面 输 出, 比 如 这 样 num = 18 print 'My age is' + num 程 序 就 会 报 错 因 为 字 符 和 数 字 不 能 直 接 用 + 相 加 一 种 解 决 方 法 是, 用 str() 把 数 字 转 换 成 字 符 串 print 'My age is' + str(18) 或 num = 18 print 'My age is' + str(num) 还 有 一 种 方 法, 就 是 用 % 对 字 符 串 进 行 格 式 化 num = 18 print 'My age is %d' % num 输 出 的 时 候,%d 会 被 % 后 面 的 值 替 换 输 出 My age is 18 这 里,%d 只 能 用 来 替 换 整 数 如 果 你 想 格 式 化 的 数 值 是 小 数, 要 用 %f print Price is %f % 4.99
输 出 Price is 4.990000 如 果 你 想 保 留 两 位 小 数, 需 要 在 f 前 面 加 上 条 件 :%.2f print Price is %.2f % 4.99 输 出 Price is 4.99 另 外, 可 以 用 %s 来 替 换 一 段 字 符 串 name = 'Crossin' print '%s is a good teacher.' % name 输 出 Crossin is a good teacher. 或 者 print 'Today is %s.' % 'Friday' 输 出 Today is Friday. 注 意 区 分 : 有 引 号 的 表 示 一 段 字 符, 没 有 引 号 的 就 是 一 个 变 量, 这 个 变 量 可 能 是 字 符, 也 可 能 是 数 字, 但 一 定 要 和 % 所 表 示 的 格 式 相 一 致 现 在, 试 试 看 用 字 符 串 格 式 化 改 进 一 下 之 前 你 写 的 小 游 戏 比 如 你 输 了 一 个 数 字 72, 程 序 会 回 答 你 72 is too small. 或 者 Bingo, 72 is the right answer! Python 第 15 课 循 环 的 嵌 套 设 想 一 样, 如 果 我 们 要 输 出 5 个 *, 用 for 循 环 要 这 么 写 for i in range(0, 5): print '*' 如 果 想 让 这 5 个 * 在 同 一 行, 就 在 print 语 句 后 面 加 上 逗 号
for i in range(0, 5): print '*', 但 如 果 我 想 要 这 样 一 个 图 形, 怎 么 办? * * * * * * * * * * * * * * * * * * * * * * * * * 当 然, 你 可 以 循 环 5 次, 每 次 输 出 一 行 * * * * * 那 如 果 再 进 一 步, 这 样 呢? * ** *** **** ***** 除 了 你 自 己 动 手 打 好 一 个 多 行 字 符 串 外, 也 可 以 让 程 序 帮 我 们 解 决 这 种 问 题, 我 们 需 要 的 是 两 个 嵌 套 在 一 起 的 循 环 : for i in range(0, 5): for j in range(0, 5): print i, j 第 二 个 for 循 环 在 第 一 个 for 循 环 的 内 部, 表 示 每 一 次 外 层 的 循 环 中, 都 要 进 行 一 遍 内 层 的 循 环 看 一 下 输 出 的 结 果 : 0 0 0 1 0 2 0 3 0 4 1 0... 4 4 内 层 循 环 中 的 print 语 句 一 共 被 执 行 了 25 次 i 从 0 到 4 循 环 了 5 次 对 应 于 每 一 个 i 的 值,j 又 做 了 从 0 到 4 五 次 循 环 所 以 5*5 一 共 25 次 所 以 如 果 要 输 出 一 个 5*5 的 方 阵 图 案, 我 们 可 以 for i in range(0, 5):
for j in range(0, 5): print print '*', 注 意 : 第 二 个 print 的 缩 进 和 内 层 的 for 是 一 样 的, 这 表 明 它 是 外 层 for 循 环 中 的 语 句, 每 次 i 的 循 环 中, 它 会 执 行 一 次 print 后 面 没 有 写 任 何 东 西, 是 起 到 换 行 的 作 用, 这 样, 每 输 出 5 个 *, 就 会 换 行 要 输 出 第 二 个 三 角 图 案 时, 我 们 需 要 根 据 当 前 外 层 循 环 的 序 数, 设 置 内 层 循 环 应 当 执 行 的 次 数 for i in range(0, 5): for j in range(0, i+1): print '*', print 内 层 的 j 每 次 从 0 到 i+1 进 行 循 环 这 样, 当 第 一 次 i=0 时,j 就 是 range(0,1), 只 输 出 1 个 * 而 当 最 后 一 次 i=4 时,j 就 是 range(0,5), 输 出 5 个 * 最 后 顺 便 说 下, 如 果 有 同 学 用 的 是 PyScripter, 或 者 其 他 第 三 方 IDE, 可 以 通 过 debug 中 的 step, 查 看 程 序 是 怎 样 一 行 一 行 运 行 的 IDLE 在 这 方 面 做 得 不 太 好, 虽 然 也 可 以 步 进 调 试, 但 是 很 麻 烦 且 不 直 观, 所 以 就 不 推 荐 去 用 了 Python 第 16 课 字 符 串 格 式 化 2 之 前 我 们 说 到, 可 以 用 % 来 构 造 一 个 字 符 串, 比 如 print '%s is easy to learn' % 'Python' 有 时 候, 仅 仅 代 入 一 个 值 不 能 满 足 我 们 构 造 字 符 串 的 需 要 假 设 你 现 在 有 一 组 学 生 成 绩 的 数 据, 你 要 输 出 这 些 数 据 在 一 行 中, 既 要 输 出 学 生 的 姓 名, 又 要 输 出 他 的 成 绩 例 如 Mike s score is 87.
Lily s score is 95. 在 python 中, 你 可 以 这 样 实 现 : print "%s's score is %d" % ('Mike', 87) 或 者 name = Lily score = 95 print "%s's score is %d" % (name, score) 无 论 你 有 多 少 个 值 需 要 代 入 字 符 串 中 进 行 格 式 化, 只 需 要 在 字 符 串 中 的 合 适 位 置 用 对 应 格 式 的 % 表 示, 然 后 在 后 面 的 括 号 中 按 顺 序 提 供 代 入 的 值 就 可 以 了 占 位 的 % 和 括 号 中 的 值 在 数 量 上 必 须 相 等, 类 型 也 要 匹 配 ('Mike', 87) 这 种 用 () 表 示 的 一 组 数 据 在 python 中 被 称 为 元 组 (tuple), 是 python 的 一 种 基 本 数 据 结 构, 以 后 我 们 还 会 用 到 Python 第 17 课 类 型 转 换 python 的 几 种 最 基 本 的 数 据 类 型, 我 们 已 经 见 过 : 字 符 串 整 数 小 数 ( 浮 点 数 ) bool 类 型 python 在 定 义 一 个 变 量 时 不 需 要 给 它 限 定 类 型 变 量 会 根 据 赋 给 它 的 值, 自 动 决 定 它 的 类 型 你 也 可 以 在 程 序 中, 改 变 它 的 值, 于 是 也 就 改 变 了 它 的 类 型 例 如 a = 1 print a a = 'hello' print a
a = True print a 变 量 a 先 后 成 为 了 整 数 字 符 串 bool 类 型 虽 然 类 型 可 以 随 意 改 变, 但 当 你 对 一 个 特 定 类 型 的 变 量 进 行 操 作 时, 如 果 这 个 操 作 与 它 的 数 据 类 型 不 匹 配, 就 会 产 生 错 误 比 如 以 下 几 行 代 码 print Hello +1 print hello%d % '123' 程 序 运 行 时 会 报 错 因 为 第 一 句 里, 字 符 串 和 整 数 不 能 相 加 ; 第 二 句 里,%d 需 要 的 是 一 个 整 数, 而 '123' 是 字 符 串 这 种 情 况 下,python 提 供 了 一 些 方 法 对 数 值 进 行 类 型 转 换 : int(x) # 把 x 转 换 成 整 数 float(x) # 把 x 转 换 成 浮 点 数 str(x) # 把 x 转 换 成 字 符 串 bool(x) # 把 x 转 换 成 bool 值 上 述 两 个 例 子 就 可 以 写 成 : print Hello +str(1) print hello%d % int('123') 以 下 等 式 的 结 果 均 为 真 : int('123') == 123 float('3.3') == 3.3 str(111) == '111' bool(0) == False
并 不 是 所 有 的 值 都 能 做 类 型 转 换, 比 如 int('abc') 同 样 会 报 错,python 没 办 法 把 它 转 成 一 个 整 数 另 外 关 于 bool 类 型 的 转 换, 我 们 会 专 门 再 详 细 说 明 大 家 可 以 先 试 试 以 下 结 果 的 值, 自 己 摸 索 一 下 转 换 成 bool 类 型 的 规 律 : bool(-123) bool(0) bool('abc') bool('false') bool('') Python 第 18 课 bool 类 型 转 换 昨 天 最 后 留 的 几 句 关 于 bool 类 型 的 转 换, 其 中 有 一 行 : bool('false') print 一 下 结 果, 会 发 现 是 True 这 是 什 么 原 因? 因 为 在 python 中, 以 下 数 值 会 被 认 为 是 False: 为 0 的 数 字, 包 括 0,0.0 空 字 符 串, 包 括 '',"" 表 示 空 值 的 None 空 集 合, 包 括 (),[],{} 其 他 的 值 都 认 为 是 True None 是 python 中 的 一 个 特 殊 值, 表 示 什 么 都 没 有, 它 和 0 空 字 符 False 空 集 合 都 不 一 样 关 于 集 合, 我 们 后 面 的 课 程 再 说 所 以, False 是 一 个 不 为 空 的 字 符 串, 当 被 转 换 成 bool 类 型 之 后, 就 得 到 True 同 样 bool(' ') 的 结 果 是 True, 一 个 空 格 也 不 能 算 作 空 字 符 串 bool('') 才 是 False 在 if while 等 条 件 判 断 语 句 里, 判 断 条 件 会 自 动 进 行 一 次 bool 的 转 换 比 如 a = '123' if a: print 'this is not a blank string'
这 在 编 程 中 是 很 常 见 的 一 种 写 法 效 果 等 同 于 if bool(a) 或 者 if a!= '' Python 第 19 课 函 数 数 学 上 的 函 数, 是 指 给 定 一 个 输 入, 就 会 有 唯 一 输 出 的 一 种 对 应 关 系 编 程 语 言 里 的 函 数 跟 这 个 意 思 差 不 多, 但 也 有 不 同 函 数 就 是 一 块 语 句, 这 块 语 句 有 个 名 字, 你 可 以 在 需 要 时 反 复 地 使 用 这 块 语 句 它 有 可 能 需 要 输 入, 有 可 能 会 返 回 输 出 举 一 个 现 实 中 的 场 景 : 我 们 去 餐 厅 吃 饭, 跟 服 务 员 点 了 菜, 过 了 一 会 儿, 服 务 员 把 做 好 的 菜 端 上 来 餐 厅 的 厨 房 就 可 以 看 作 是 一 个 函 数, 我 们 点 的 菜 单, 就 是 给 这 个 函 数 的 参 数 ; 厨 师 在 厨 房 里 做 菜 的 过 程 就 是 这 个 函 数 的 执 行 过 程 ; 做 好 的 菜 是 返 回 结 果, 返 回 到 我 们 的 餐 桌 上 我 们 之 前 已 经 用 到 过 python 里 内 建 的 函 数, 比 如 input 和 range 以 range(1,10) 为 例,range 是 这 个 函 数 的 名 称, 后 面 括 号 里 的 1 和 10 是 range 需 要 的 参 数 它 有 返 回 结 果, 就 是 一 个 从 1 到 9 的 序 列 再 来 看 input(), 括 号 里 面 没 有, 表 示 我 们 没 有 给 参 数 函 数 执 行 过 程 中, 需 要 我 们 从 控 制 台 输 入 一 个 值 函 数 的 返 回 结 果 就 是 我 们 输 入 的 内 容 PS:range 还 可 以 接 受 1 个 或 3 个 参 数,input 也 可 以 接 受 1 个 字 符 串 参 数 可 以 等 我 以 后 讲, 或 去 查 阅 相 关 资 料 了 解 详 细
如 果 我 们 要 自 己 写 一 个 函 数, 就 需 要 去 定 义 它 python 里 的 关 键 字 叫 def(define 的 缩 写 ), 格 式 如 下 : def sayhello(): print 'hello world!' sayhello 是 这 个 函 数 的 名 字, 后 面 的 括 号 里 是 参 数, 这 里 没 有, 表 示 不 需 要 参 数 但 括 号 和 后 面 的 冒 号 都 不 能 少 下 面 缩 进 的 代 码 块 就 是 整 个 函 数 的 内 容, 称 作 函 数 体 然 后 我 们 去 调 用 这 个 函 数 : sayhello() 得 到 和 直 接 执 行 print 'hello world!' 一 样 的 结 果
Python 第 20 课 命 令 行 常 用 命 令 今 天 茬 开 话 题, 说 一 下 命 令 行 (Windows 下 叫 命 令 提 示 符,Mac 下 叫 终 端 ) 里 的 常 用 命 令 已 经 熟 悉 同 学 可 略 过 打 开 命 令 行, 我 们 会 看 到 每 行 前 面 都 有 诸 如 C:\Documents and Settings\Crossin> 或 者 MyMacBook:~ crossin$ 之 类 的 这 个 提 示 符 表 示 了 当 前 命 令 行 所 在 目 录
在 这 里, 我 们 输 入 python 就 可 以 进 入 python 环 境 了 但 今 天 我 们 暂 时 不 这 么 做 第 一 个 常 用 的 命 令 是 : dir (windows 环 境 下 ) ls (mac 环 境 下 ) dir 和 ls 的 作 用 差 不 多, 都 是 显 示 出 当 前 目 录 下 的 文 件 和 文 件 夹 具 体 效 果 可 参 见 文 末 的 附 图 第 二 个 常 用 命 令 是 : cd 目 录 名 通 过 dir 或 ls 了 解 当 前 目 录 的 结 构 之 后, 可 以 通 过 cd 目 录 名 的 方 式, 进 入 到 当 前 目 录 下 的 子 目 录 里 如 果 要 跳 回 到 上 级 目 录, 可 以 用 命 令 : cd.. 另 外,Windows 下 如 果 要 写 换 盘 符, 需 要 输 入 盘 符 : 比 如 从 c 盘 切 换 到 d 盘 C:\Documents and Settings\Crossin>d:
有 了 以 上 两 个 命 令, 就 可 以 在 文 件 目 录 的 迷 宫 里 游 荡 了 虽 然 没 可 视 化 的 目 录 下 的 操 作 那 么 直 观, 但 是 会 显 得 你 更 像 个 程 序 员 于 是 乎, 再 说 个 高 阶 玩 法 : 现 在 你 可 以 不 用 idle 那 套 东 西 了, 随 便 找 个 顺 手 的 文 本 软 件, 把 你 的 代 码 写 好, 保 存 好, 最 好 是 保 存 成 py 文 件 然 后 在 命 令 行 下 进 入 到 py 文 件 保 存 的 目 录, 使 用 命 令 : python 你 把 程 序 保 存 的 文 件 名 就 可 以 运 行 你 写 的 程 序 了 嗯, 这 才 像 个 python 程 序 员 的 样!
其 他 常 用 命 令, 诸 如 拷 贝 文 件 删 除 文 件 新 建 文 件 夹 之 类 的, 请 自 行 搜 索 相 关 资 料 很 容 易 的, 比 如 你 搜 mac 终 端 常 用 命 令, 就 可 以 找 到 很 多 了 PS: 贴 吧 里 转 了 一 篇 关 于 怎 么 把 py 文 件 转 成 别 人 电 脑 上 也 可 执 行 的 exe 文 件, 稍 稍 有 点 复 杂, 想 挑 战 的 可 以 去 试 试 Python 第 21 课 函 数 的 参 数 今 天 发 现 了 一 个 ipad 上 的 游 戏, 叫 Cargo-Bot 这 个 游 戏 需 要 你 用 指 令 控 制 一 个 机 械 臂 去 搬 箱 子 游 戏 里 蕴 含 了 很 多 编 程 的 思 想, 包 括 循 环 函 数 调 用 条 件 判 断 寄 存 器 递 归 等 等, 挺 有 意 思 的 更 厉 害 的 是, 这 个 游 戏 是 用 一 个 叫 Codea 的 app 直 接 在 ipad 上 编 写 出 来 的 有 ipad 的 同 学 不 妨 玩 玩 看, 挑 战 一 下 你 的 程 商 言 归 正 传, 在 19 课 里, 我 们 讲 了 怎 样 定 义 一 个 自 己 的 函 数, 但 我 们 没 有 给 他 提 供 输 入 参 数 的 功 能 不 能 指 定 参 数 的 函 数 就 好 比 你 去 餐 厅 吃 饭, 服 务 员 告 诉 你, 不 能 点 菜, 有 啥 吃 啥 这 显 然 不 能 满 足 很 多 情 况 所 以, 如 果 我 们 希 望 自 己 定 义 的 函 数 里 允 许 调 用 者 提 供 一 些 参 数, 就 把 这 些 参 数 写 在 括 号 里, 如 果 有 多 个 参 数, 用 逗 号 隔 开, 如 : def sayhello(someone): print someone + ' says Hello!' 或 者
def plus(num1, num2): print num1+num2 参 数 在 函 数 中 相 当 于 一 个 变 量, 而 这 个 变 量 的 值 是 在 调 用 函 数 的 时 候 被 赋 予 的 在 函 数 内 部, 你 可 以 像 过 去 使 用 变 量 一 样 使 用 它 调 用 带 参 数 的 函 数 时, 同 样 把 需 要 传 入 的 参 数 值 放 在 括 号 中, 用 逗 号 隔 开 要 注 意 提 供 的 参 数 值 的 数 量 和 类 型 需 要 跟 函 数 定 义 中 的 一 致 如 果 这 个 函 数 不 是 你 自 己 写 的, 你 需 要 先 了 解 它 的 参 数 类 型, 才 能 顺 利 调 用 它 比 如 上 面 两 个 函 数, 我 们 可 以 直 接 传 入 值 : sayhello('crossin') 还 是 注 意, 字 符 串 类 型 的 值 不 能 少 了 引 号 或 者 也 可 以 传 入 变 量 : x = 3 y = 4 plus(x, y) 在 这 个 函 数 被 调 用 时, 相 当 于 做 了 num1=x, num2=y 这 么 一 件 事 所 以 结 果 是 输 出 了 7 Python 第 22 课 函 数 应 用 示 例 前 两 课 稍 稍 介 绍 了 一 下 函 数, 但 光 说 概 念 还 是 有 些 抽 象 了, 今 天 就 来 把 之 前 那 个 小 游 戏 用 函 数 改 写 一 下
我 希 望 有 这 样 一 个 函 数, 它 比 较 两 个 数 的 大 小 如 果 第 一 个 数 小 了, 就 输 出 too small 如 果 第 一 个 数 大 了, 就 输 出 too big 如 果 相 等, 就 输 出 bingo 函 数 还 有 个 返 回 值, 当 两 数 相 等 的 时 候 返 回 True, 不 等 就 返 回 False 于 是 我 们 来 定 义 这 个 函 数 : def isequal(num1, num2): if num1<num2: print 'too small' return False; if num1>num2: print 'too big' return False; if num1==num2: print 'bingo' return True 这 里 说 一 下,return 是 函 数 的 结 束 语 句,return 后 面 的 值 被 作 为 这 个 函 数 的 返 回 值 函 数 中 任 何 地 方 的 return 被 执 行 到 的 时 候, 这 个 函 数 就 会 结 束 然 后 在 我 们 的 小 游 戏 里 使 用 这 个 函 数 : from random import randint num = randint(1, 100) print 'Guess what I think?' bingo = False while bingo == False: answer = input()
bingo = isequal(answer, num) 在 isequal 函 数 内 部, 会 输 出 answer 和 num 的 比 较 结 果, 如 果 相 等 的 话,bingo 会 得 到 返 回 值 True, 否 则 bingo 得 到 False, 循 环 继 续 函 数 可 以 把 某 个 功 能 的 代 码 分 离 出 来, 在 需 要 的 时 候 重 复 使 用, 就 像 拼 装 积 木 一 样, 这 会 让 程 序 结 构 更 清 晰 Python 第 23 课 if, elif, else
今 天 补 充 之 前 讲 过 的 一 个 语 句 :if 为 什 么 我 跳 要 着 讲, 因 为 我 的 想 法 是 先 讲 下 最 最 基 本 的 概 念, 让 你 能 用 起 来, 之 后 你 熟 悉 了, 再 说 些 细 节 关 于 if, 可 以 发 送 数 字 7 回 顾 之 前 的 课 程 它 除 了 我 们 之 前 讲 的 用 法 外, 还 可 以 配 合 elif 和 else 使 用, 使 程 序 的 运 行 顺 序 更 灵 活 之 前 说 的 if, 是 : 如 果 条 件 满 足, 就 做 xxx, 否 则 就 不 做 else 顾 名 思 义, 就 是 : 否 则 就 做 yyy
当 if 后 面 的 条 件 语 句 不 满 足 时, 与 之 相 对 应 的 else 中 的 代 码 块 将 被 执 行 if a == 1: print 'right' else print 'wrong'
elif 意 为 else if, 含 义 就 是 : 否 则 如 果 条 件 满 足, 就 做 yyy elif 后 面 需 要 有 一 个 逻 辑 判 断 语 句 当 if 条 件 不 满 足 时, 再 去 判 断 elif 的 条 件, 如 果 满 足 则 执 行 其 中 的 代 码 块 if a == 1: print 'one' elif a == 2:
print 'two' if, elif, else 可 组 成 一 个 整 体 的 条 件 语 句 if 是 必 须 有 的 ; elif 可 以 没 有, 也 可 以 有 很 多 个, 每 个 elif 条 件 不 满 足 时 会 进 入 下 一 个 elif 判 断 ; else 可 以 没 有, 如 果 有 的 话 只 能 有 一 个, 必 须 在 条 件 语 句 的 最 后 if a == 1: print 'one' elif a == 2: print 'two' elif a == 3: print 'three' else: print 'too many' 我 们 昨 天 刚 改 写 的 小 游 戏 中 的 函 数 isequal, 用 了 三 个 条 件 判 断, 我 们 可 以 再 改 写 成 一 个 包 含 if...elif...else 的 结 构 : def isequal(num1, num2): if num1<num2: print 'too small' return False; elif num1>num2: print 'too big' return False; else: print 'bingo' return True
Python 第 24 课 if 的 嵌 套 和 for 循 环 一 样,if 也 可 以 嵌 套 使 用, 即 在 一 个 if/elif/else 的 内 部, 再 使 用 if 这 有 点 类 似 于 电 路 的 串 联 if 条 件 1: if 条 件 2: 语 句 1 else: 语 句 2 else: if 条 件 2: 语 句 3 else: 语 句 4
在 上 面 这 个 两 层 if 的 结 构 中, 当 条 件 1 为 True, 条 件 2 为 True 时, 执 行 语 句 1; 条 件 1 为 True, 条 件 2 为 False 时, 执 行 语 句 2; 条 件 1 为 False, 条 件 2 为 True 时, 执 行 语 句 3; 条 件 1 为 False, 条 件 2 为 False 时, 执 行 语 句 4 假 设 需 要 这 样 一 个 程 序 : 我 们 先 向 程 序 输 入 一 个 值 x, 再 输 入 一 个 值 y (x,y) 表 示 一 个 点 的 坐 标 程 序 要 告 诉 我 们 这 个 点 处 在 坐 标 系 的 哪 一 个 象 限 x>=0,y>=0, 输 出 1; x<0,y>=0, 输 出 2; x<0,y<0, 输 出 3; x>=0,y<0, 输 出 4 你 可 以 分 别 写 4 个 if, 也 可 以 用 if 的 嵌 套 : if y >= 0: if x >= 0: print 1 else: print 2 else:
if x < 0: print 3 else: print 4 从 流 程 图 上 来 看, 应 该 是 这 样 Python 第 25 课 初 探 list 昨 天 课 程 里 的 例 子 有 点 没 说 清 楚, 有 同 学 表 示 写 在 程 序 里 发 生 了 错 误 因 为 我 当 时 写 这 个 代 码 片 段 时, 心 里 假 想 着 这 是 在 一 个 函 数 的 内 部, 所 以 用 了 return 语 句 如 果 你 没 有 把 它 放 在 函 数 里, 那 return 的 话 就 会 出 错, 你 可 以 换 成 print 今 天 要 说 一 个 新 概 念 --list, 中 文 可 以 翻 译 成 列 表, 是 用 来 处 理 一 组 有 序 项 目 的 数 据 结 构 想 象 一 下 你 的 购 物 清 单 待 办 工 作 手 机 通 讯 录 等 等, 它 们 都 可 以 看 作 是 一 个 列 表 说 它 是 新 概 念 也 不 算 确 切, 因 为 我 们 之 前 已 经 用 过 它, 就 在 这 个 语 句 里 :
for i in range(1, 10): # 此 处 略 过 数 行 代 码 看 出 来 list 在 哪 里 了 吗? 你 试 一 下 : print range(1,10) 得 到 的 结 果 是 : [1, 2, 3, 4, 5, 6, 7, 8, 9] 这 就 是 一 个 list 它 由 range 产 生 把 上 面 那 个 for 循 环 语 句 写 成 : l = range(1, 10) for i in l: 效 果 是 一 样 的 于 是 可 以 看 出,for 循 环 做 的 事 情 其 实 就 是 遍 历 一 个 列 表 中 的 每 一 项, 每 次 循 环 都 把 当 前 项 赋 值 给 一 个 变 量 ( 这 里 是 i), 直 到 列 表 结 束 我 们 也 可 以 定 义 自 己 的 列 表, 格 式 就 是 用 中 括 号 包 围 逗 号 隔 开 的 一 组 数 值 : l = [1, 1, 2, 3, 5, 8, 13] 可 以 用 print 输 出 这 个 列 表 : print l
同 样 也 可 以 用 for...in 遍 历 这 个 列 表, 依 次 输 出 了 列 表 中 的 每 一 项 : for i in l: print l, 列 表 中 的 元 素 也 可 以 是 别 的 类 型, 比 如 : l = ['meat', 'egg', 'fish', 'milk'] 甚 至 是 不 同 类 型 的 混 合 : l = [365, 'everyday', 0.618, True] l 身 为 一 个 列 表, 有 一 些 特 有 的 功 能, 这 个 我 们 下 回 再 说 Python 第 26 课 操 作 list 上 周 给 list 开 了 个 头, 知 道 了 什 么 是 list 假 设 我 们 现 在 有 一 个 list: l = [365, 'everyday', 0.618, True] 除 了 用 for...in 遍 历 l 中 的 元 素, 我 们 还 能 做 点 啥? 1. 访 问 list 中 的 元 素 list 中 的 每 个 元 素 都 对 应 一 个 递 增 的 序 号 与 现 实 中 习 惯 的 序 号 不 同 在 于, 计 算 机 中 的 计 数 通 常 都 是 从 0 开 始,python 也 不 例 外 如 果 你 记 不 清 这 个 而 导 致 了 错 误, 请 去 听 一 下 孙 燕 姿 的 爱 从 零 开 始 要 访 问 l 中 的 第 1 个 元 素 365, 只 要 用 l[0] 就 可 以 了 依 次 类 推, print l[1] 就 会 输 出 'everyday'
注 意, 你 不 能 访 问 一 个 不 存 在 的 元 素, 比 如 l[10], 程 序 就 会 报 错, 提 示 你 index 越 界 了 2. 修 改 list 中 的 元 素 修 改 list 中 的 某 一 个 元 素, 只 需 要 直 接 给 那 个 元 素 赋 值 就 可 以 了 : l[0] = 123 输 出 l, 得 到 [123, 'everyday', 0.618, True], 第 1 个 元 素 已 经 从 365 被 改 成 了 123 3. 向 list 中 添 加 元 素 list 有 一 个 append 方 法, 可 以 增 加 元 素 以 l 这 个 列 表 为 例, 调 用 的 方 法 是 : l.append(1024) 输 出 l, 你 会 看 到 [123, 'everyday', 0.618, True, 1024],1024 被 添 加 到 了 l, 成 为 最 后 一 个 元 素 ( 第 一 个 元 素 在 上 一 步 被 改 成 了 123) 然 后 同 样 可 以 用 l[4] 得 到 1024 4. 删 除 list 中 的 元 素 删 除 list 中 的 某 一 个 元 素, 要 用 到 del: del l[0]
输 出 l, 得 到 ['everyday', 0.618, True, 1024] 这 时 候 再 调 用 l[0], 会 得 到 'everyday', 其 他 元 素 的 序 号 也 相 应 提 前 以 上 这 些 命 令, 你 可 以 直 接 在 python shell 中 尝 试 #==== 点 球 小 游 戏 ====# 我 打 算 从 今 天 开 始, 每 天 说 一 点 这 个 小 游 戏 的 做 法 方 法 有 很 多 种, 我 只 是 提 供 一 种 参 考 你 可 以 按 照 自 己 喜 欢 的 方 式 去 做, 那 样 她 才 是 属 于 你 的 游 戏 先 说 一 下 方 向 的 设 定 我 的 想 法 比 较 简 单, 就 是 左 中 右 三 个 方 向, 用 字 符 串 来 表 示 射 门 或 者 扑 救 的 时 候, 直 接 输 入 方 向 所 以 这 里 我 准 备 用
raw_input 有 同 学 是 用 1-8 的 数 字 来 表 示 八 个 方 向, 每 次 输 入 一 个 数 字, 这 也 是 可 以 的 不 过 这 样 守 门 员 要 扑 住 的 概 率 可 就 小 多 了 至 于 电 脑 随 机 挑 选 方 向, 如 果 你 是 用 数 字 表 示, 就 用 我 们 之 前 讲 过 的 randint 来 随 机 就 行 不 过 我 这 次 打 算 用 random 的 另 一 个 方 法 :choice 它 的 作 用 是 从 一 个 list 中 随 机 挑 选 一 个 元 素 于 是, 罚 球 的 过 程 可 以 这 样 写 : from random import choice print 'Choose one side to shoot:' print 'left, center, right' you = raw_input() print 'You kicked ' + you direction = ['left', 'center', 'right'] com = choice(direction) print 'Computer saved ' + com if you!= com: print 'Goal!' else: print 'Oops...' 反 之 亦 然, 不 赘 述 list 有 两 类 常 用 操 作 : 索 引 (index) 和 切 片 (slice) 昨 天 我 们 说 的 用 [] 加 序 号 访 问 的 方 法 就 是 索 引 操 作 除 了 指 定 位 置 进 行 索 引 外,list 还 可 以 处 理 负 数 的 索 引 继 续 用 昨 天 的 例 子 :
l = [365, 'everyday', 0.618, True] l[-1] 表 示 l 中 的 最 后 一 个 元 素 l[-3] 表 示 倒 数 第 3 个 元 素 切 片 操 作 符 是 在 [] 内 提 供 一 对 可 选 数 字, 用 : 分 割 冒 号 前 的 数 表 示 切 片 的 开 始 位 置, 冒 号 后 的 数 字 表 示 切 片 到 哪 里 结 束 同 样, 计 数 从 0 开 始 注 意, 开 始 位 置 包 含 在 切 片 中, 而 结 束 位 置 不 包 括 l[1:3] 得 到 的 结 果 是 ['everyday', 0.618] 如 果 不 指 定 第 一 个 数, 切 片 就 从 列 表 第 一 个 元 素 开 始 如 果 不 指 定 第 二 个 数, 就 一 直 到 最 后 一 个 元 素 结 束 都 不 指 定, 则 返 回 整 个 列 表 的 一 个 拷 贝 l[:3] l[1:] l[:] 同 索 引 一 样, 切 片 中 的 数 字 也 可 以 使 用 负 数 比 如 : l[1:-1] 得 到 ['everyday', 0.618]
#==== 点 球 小 游 戏 ====# 昨 天 有 了 一 次 罚 球 的 过 程, 今 天 我 就 让 它 循 环 5 次, 并 且 记 录 下 得 分 先 不 判 断 胜 负 用 score_you 表 示 你 的 得 分,score_com 表 示 电 脑 得 分 开 始 都 为 0, 每 进 一 球 就 加 1 from random import choice score_you = 0 score_com = 0 direction = ['left', 'center', 'right'] for i in range(5): print '==== Round %d - You Kick! ====' % (i+1) print 'Choose one side to shoot:'
print 'left, center, right' you = raw_input() print 'You kicked ' + you com = choice(direction) print 'Computer saved ' + com if you!= com: print 'Goal!' score_you += 1 else: print 'Oops...' print 'Score: %d(you) - %d(com)\n' % (score_you, score_com) print '==== Round %d - You Save! ====' % (i+1) print 'Choose one side to save:' print 'left, center, right' you = raw_input() print 'You saved ' + you com = choice(direction) print 'Computer kicked ' + com if you == com: print 'Saved!' else: print 'Oops...' score_com += 1 print 'Score: %d(you) - %d(com)\n' % (score_you, score_com) 注 意 : 手 机 上 代 码 有 可 能 会 被 换 行 这 段 代 码 里 有 两 段 相 似 度 很 高, 想 想 是 不 是 可 以 有 办 法 可 以 用 个 函 数 把 它 们 分 离 出 来
Python 第 28 课 字 符 串 的 分 割 字 符 串 和 list 之 间 有 很 多 不 得 不 说 的 事 比 如 有 同 学 想 要 用 python 去 自 动 抓 取 某 个 网 页 上 的 下 载 链 接, 那 就 需 要 对 网 页 的 代 码 进 行 处 理 处 理 的 过 程 中, 免 不 了 要 在 字 符 串 和 list 之 间 进 行 很 多 操 作
我 们 先 从 最 基 本 的 开 始 假 设 你 现 在 拿 到 了 一 个 英 语 句 子, 需 要 把 这 个 句 子 中 的 每 一 个 单 词 拿 出 来 单 独 处 理 sentence = 'I am an Englist sentence' 这 时 就 需 要 对 字 符 串 进 行 分 割 sentence.split() split() 会 把 字 符 串 按 照 其 中 的 空 格 进 行 分 割, 分 割 后 的 每 一 段 都 是 一 个 新 的 字 符 串, 最 终 返 回 这 些 字 符 串 组 成 一 个 list 于 是 得 到 ['I', 'am', 'an', 'Englist', 'sentence'] 原 来 字 符 串 中 的 空 格 不 再 存 在 除 了 空 格 外,split() 同 时 也 会 按 照 换 行 符 \n, 制 表 符 \t 进 行 分 割 所 以 应 该 说,split 默 认 是 按 照 空 白 字 符 进 行 分 割 之 所 以 说 默 认, 是 因 为 split 还 可 以 指 定 分 割 的 符 号 比 如 你 有 一 个 很 长 的 字 符 串 section = 'Hi. I am the one. Bye.' 通 过 指 定 分 割 符 号 为 '.', 可 以 把 每 句 话 分 开 section.split('.') 得 到
['Hi', ' I am the one', ' Bye', ''] 这 时 候,'.' 作 为 分 割 符 被 去 掉 了, 而 空 格 仍 然 保 留 在 它 的 位 置 上 注 意 最 后 那 个 空 字 符 串 每 个 '.' 都 会 被 作 为 分 割 符, 即 使 它 的 后 面 没 有 其 他 字 符, 也 会 有 一 个 空 串 被 分 割 出 来 例 如 'aaa'.split('a') 将 会 得 到 ['', '', '', ''], 由 四 个 空 串 组 成 的 list 既 然 有 把 字 符 串 分 割 成 list, 那 也 相 应 就 有 把 list 连 接 成 字 符 串, 这 个 明 天 说 #==== 点 球 小 游 戏 ====# 在 昨 天 代 码 的 基 础 上, 我 们 加 上 胜 负 判 断, 如 果 5 轮 结 束 之 后 是 平 分, 就 继 续 踢
所 以 我 们 把 一 轮 的 过 程 单 独 拿 出 来 作 为 一 个 函 数 kick, 在 5 次 循 环 之 后 再 加 上 一 个 while 循 环 另 外, 这 里 把 之 前 的 score_you 和 score_com 合 并 成 了 一 个 score 数 组 这 里 的 原 因 是, 要 让 kick 函 数 里 用 到 外 部 定 义 的 变 量, 需 要 使 用 全 局 变 量 的 概 念 暂 时 想 避 免 说 这 个, 而 用 list 不 存 在 这 个 问 题 from random import choice score = [0, 0] direction = ['left', 'center', 'right'] def kick(): print '==== You Kick! ====' print 'Choose one side to shoot:' print 'left, center, right' you = raw_input() print 'You kicked ' + you com = choice(direction) print 'Computer saved ' + com if you!= com: print 'Goal!' score[0] += 1 else: print 'Oops...' print 'Score: %d(you) - %d(com)\n' % (score[0], score[1]) print '==== You Save! ====' print 'Choose one side to save:' print 'left, center, right' you = raw_input() print 'You saved ' + you com = choice(direction) print 'Computer kicked ' + com if you == com:
print 'Saved!' else: print 'Oops...' score[1] += 1 print 'Score: %d(you) - %d(com)\n' % (score[0], score[1]) for i in range(1): print '==== Round %d ====' % (i+1) kick() while(score[0] == score[1]): i += 1 print '==== Round %d ====' % (i+1) kick() if score[0] > score[1]: print 'You Win!' else: print 'You Lose.'
Python 第 29 课 连 接 list 今 天 要 说 的 方 法 是 join 它 和 昨 天 说 的 split 正 好 相 反 :split 是 把 一 个 字 符 串 分 割 成 很 多 字 符 串 组 成 的 list, 而 join 则 是 把 一 个 list 中 的 所 有 字 符 串 连 接 成 一 个 字 符 串 join 的 格 式 有 些 奇 怪, 它 不 是 list 的 方 法, 而 是 字 符 串 的 方 法 首 先 你 需 要 有 一 个 字 符 串 作 为 list 中 所 有 元 素 的 连 接 符, 然 后 再 调 用 这 个 连 接 符 的 join 方 法,join 的 参 数 是 被 连 接 的 list: s = ';' li = ['apple', 'pear', 'orange'] fruit = s.join(li) print fruit 得 到 结 果 'apple;pear;orange' 从 结 果 可 以 看 到, 分 号 把 list 中 的 几 个 字 符 串 都 连 接 了 起 来 你 也 可 以 直 接 在 shell 中 输 入 : ';'.join(['apple', 'pear', 'orange']) 得 到 同 样 的 结 果 用 来 连 接 的 字 符 串 可 以 是 多 个 字 符, 也 可 以 是 一 个 空 串 : ''.join(['hello', 'world'])
得 到 'helloworld', 字 符 串 被 无 缝 连 接 在 一 起 #==== 点 球 小 游 戏 ====# 昨 天 的 代 码 已 经 能 实 现 一 个 完 整 的 点 球 比 赛 过 程, 但 有 同 学 提 出 : 这 不 符 合 真 实 比 赛 规 则, 说 好 的 提 前 结 束 比 赛 呢?! 关 于 这 个, 我 想 了 下, 可 以 有 好 几 种 解 决 方 法, 但 似 乎 都 有 些 绕 所 以 放 到 明 天 单 独 来 讲, 把 这 个 小 游 戏 收 尾 Python 第 30 课 字 符 串 的 索 引 和 切 片 之 前 说 了, 字 符 串 和 list 有 很 多 不 得 不 说 的 事 今 天 就 来 说 说 字 符 串 的 一 些 与 list 相 似 的 操 作 1. 遍 历 通 过 for...in 可 以 遍 历 字 符 串 中 的 每 一 个 字 符 word = 'helloworld' for c in word: print c 2. 索 引 访 问 通 过 [] 加 索 引 的 方 式, 访 问 字 符 串 中 的 某 个 字 符 print word[0] print word[-2] 与 list 不 同 的 是, 字 符 串 能 通 过 索 引 访 问 去 更 改 其 中 的 字 符 word[1] = 'a' 这 样 的 赋 值 是 错 误 的
3. 切 片 通 过 两 个 参 数, 截 取 一 段 子 串, 具 体 规 则 和 list 相 同 print word[5:7] print word[:-5] print word[:] 4. 连 接 字 符 join 方 法 也 可 以 对 字 符 串 使 用, 作 用 就 是 用 连 接 符 把 字 符 串 中 的 每 个 字 符 重 新 连 接 成 一 个 新 字 符 串 不 过 觉 得 这 个 方 法 有 点 鸡 肋, 不 知 道 在 什 么 场 景 下 会 用 到 newword = ','.join(word)
Python 第 31 课 读 文 件 之 前, 我 们 写 的 程 序 绝 大 多 数 都 依 赖 于 从 命 令 行 输 入 假 如 某 个 程 序 需 要 输 入 很 多 数 据, 比 如 一 次 考 试 的 全 班 学 生 成 绩, 再 这 么 输 就 略 显 痛 苦 了 一 个 常 见 的 办 法 就 是 把 学 生 的 成 绩 都 保 存 在 一 个 文 件 中, 然 后 让 程 序 自 己 从 这 个 文 件 里 取 数 据 要 读 取 文 件, 先 得 有 文 件 我 们 新 建 个 文 件, 就 叫 它 data.txt 在 里 面 随 便 写 上 一 些 话, 保 存 把 这 个 文 件 放 在 接 下 来 你 打 算 保 存 代 码 的 文 件 夹 下, 这 么 做 是 为 了 方 便 我 们 的 程 序 找 到 它 准 备 工 作 就 绪, 可 以 来 写 我 们 的 代 码 了 打 开 一 个 文 件 的 命 令 很 简 单 : file(' 文 件 名 ') 这 里 的 文 件 名 可 以 用 文 件 的 完 整 路 径, 也 可 以 是 相 对 路 径 因 为 我 们 把 要 读 取 的 文 件 和 代 码 放 在 了 同 一 个 文 件 夹 下, 所 以 只 需 要 写 它 的 文 件 名 就 够 了 f = file('data.txt') 但 这 一 步 只 是 打 开 了 一 个 文 件, 并 没 有 得 到 其 中 的 内 容 变 量 f 保 存 了 这 个 文 件, 还 需 要 去 读 取 它 的 内 容 你 可 以 通 过 read() 函 数 把 文 件 内 所 有 内 容 读 进 一 个 字 符 串 中 data = f.read() 做 完 对 文 件 的 操 作 之 后, 记 得 用 close() 关 闭 文 件, 释 放 资 源 虽 然 现 在 这 样 一 个 很 短 的 程 序, 不 做 这 一 步 也 不 会 影 响 运 行 结 果 但 养 成 好 习 惯, 可 以 避 免 以 后 发 生 莫 名 的 错 误
完 整 程 序 示 例 : f = file('data.txt') data = f.read() print data f.close() 是 不 是 很 简 单? 读 取 文 件 内 容 的 方 法 还 有 readline() # 读 取 一 行 内 容 readlines() # 把 内 容 按 行 读 取 至 一 个 list 中 去 替 换 程 序 的 第 二 行, 看 看 它 们 的 区 别
Python 第 32 课 写 文 件 打 开 文 件 我 们 昨 天 已 经 讲 过 但 python 默 认 是 以 只 读 模 式 打 开 文 件 如 果 想 要 写 入 内 容, 在 打 开 文 件 的 时 候 需 要 指 定 打 开 模 式 为 写 入 : f = file('output.txt', 'w') 'w' 就 是 writing, 以 这 种 模 式 打 开 文 件, 原 来 文 件 中 的 内 容 会 被 你 新 写 入 的 内 容 覆 盖 掉, 如 果 文 件 不 存 在, 会 自 动 创 建 文 件 不 加 参 数 时,file 为 你 默 认 为 'r',reading, 只 读 模 式, 文 件 必 须 存 在, 否 则 引 发 异 常 另 外 还 有 一 种 模 式 是 'a',appending 它 也 是 一 种 写 入 模 式, 但 你 写 入 的 内 容 不 会 覆 盖 之 前 的 内 容, 而 是 添 加 到 文 件 中 打 开 文 件 还 有 一 种 方 法, 就 是 open(), 用 法 和 file() 是 一 致 的 写 入 内 容 的 方 法 同 样 简 单 : f.write('a string you want to write') write 的 参 数 可 以 是 一 个 字 符 串, 或 者 一 个 字 符 串 变 量 示 例 程 序 : data = 'I will be in a file.\nso cool!' out = open('output.txt', 'w') out.write(data) out.close() 在 你 的 程 序 保 存 目 录 下, 打 开 output.txt 就 会 看 到 结 果
留 两 道 课 后 作 业 : 1. 从 一 个 文 件 中 读 出 内 容, 保 存 至 另 一 个 文 件 2. 从 控 制 台 输 入 一 些 内 容, 保 存 至 一 个 文 件 Python 第 33 课 处 理 文 件 中 的 数 据 比 如 我 现 在 拿 到 一 份 文 档, 里 面 有 某 个 班 级 里 所 有 学 生 的 平 时 作 业 成 绩 因 为 每 个 人 交 作 业 的 次 数 不 一 样, 所 以 成 绩 的 数 目 也 不 同, 没 交 作 业 的 时 候 就 没 有 分 我 现 在 需 要 统 计 每 个 学 生 的 平 时 作 业 总 得 分 记 得 我 小 的 时 候, 经 常 有 同 学 被 老 师 喊 去 做 统 计 分 数 这 种 苦 力 现 在 电 脑 普 及 了, 再 这 么 干 就 太 弱 了 用 python, 几 行 代 码 就 可 以 搞 定 看 一 下 我 们 的 文 档 里 的 数 据 : #-- scores.txt 刘 备 23 35 44 47 51 关 羽 60 77 68 张 飞 97 99 89 91 诸 葛 亮 100 1. 先 把 文 件 读 进 来 : f = file('scores.txt') 2. 取 得 文 件 中 的 数 据 因 为 每 一 行 都 是 一 条 学 生 成 绩 的 记 录, 所 以 用 readlines, 把 每 一 行 分 开, 便 于 之 后 的 数 据 处 理 : lines = f.readlines()
f.close() 提 示 : 在 程 序 中, 经 常 使 用 print 来 查 看 数 据 的 中 间 状 态, 可 以 便 于 你 理 解 程 序 的 运 行 比 如 这 里 你 可 以 print lines, 看 一 下 内 容 被 存 成 了 什 么 格 式 3. 对 每 一 条 数 据 进 行 处 理 按 照 空 格, 把 姓 名 每 次 的 成 绩 分 割 开 : for line in lines: data = line.split() 接 下 来 的 4 5 两 个 步 骤 都 是 针 对 一 条 数 据 的 处 理, 所 以 都 是 在 for 循 环 的 内 部 4. 整 个 程 序 最 核 心 的 部 分 到 了 如 何 把 一 个 学 生 的 几 次 成 绩 合 并, 并 保 存 起 来 呢? 我 的 做 法 是 : 对 于 每 一 条 数 据, 都 新 建 一 个 字 符 串, 把 学 生 的 名 字 和 算 好 的 总 成 绩 保 存 进 去 最 后 再 把 这 些 字 符 串 一 起 保 存 到 文 件 中 : sum = 0 for score in data[1:]: sum += int(score) result = '%s\t: %d\n' % (data[0], sum) 这 里 几 个 要 注 意 的 点 : 对 于 每 一 行 分 割 的 数 据,data[0] 是 姓 名,data[1:] 是 所 有 成 绩 组 成 的 列 表 每 次 循 环 中,sum 都 要 先 清 零 score 是 一 个 字 符 串, 为 了 做 计 算, 需 要 转 成 整 数 值 int result 中, 我 加 了 一 个 制 表 符 \t 和 换 行 符 \n, 让 输 出 的 结 果 更 好 看 些 5. 得 到 一 个 学 生 的 总 成 绩 后, 把 它 添 加 到 一 个 list 中
results.append(result) results 需 要 在 循 环 之 前 初 始 化 results = [] 6. 最 后, 全 部 成 绩 处 理 完 毕 后, 把 results 中 的 内 容 保 存 至 文 件 因 为 results 是 一 个 字 符 串 组 成 的 list, 这 里 我 们 直 接 用 writelines 方 法 : output = file('result.txt', 'w') output.writelines(results) outpus.close() 大 功 告 成, 打 开 文 件 检 验 一 下 结 果 吧 以 下 是 完 整 程 序, 把 其 中 print 前 面 的 注 释 符 号 去 掉, 可 以 查 看 关 键 步 骤 的 数 据 状 态 不 过 因 为 字 符 编 码 的 问 题,list 的 中 文 可 能 会 显 示 为 你 看 不 懂 的 字 符 f = file('scores.txt') lines = f.readlines() #print lines f.close() results = [] for line in lines: #print line data = line.split() #print data sum = 0 for score in data[1:]: sum += int(score)
result = '%s \t: %d\n' % (data[0], sum) #print result results.append(result) #print results output = file('result.txt', 'w') output.writelines(results)
output.close()
Python 第 34 课 break while 循 环 在 条 件 不 满 足 时 结 束, for 循 环 遍 历 完 序 列 后 结 束 如 果 在 循 环 条 件 仍 然 满 足 或 序 列 没 有 遍 历 完 的 时 候, 想 要 强 行 跳 出 循 环, 就 需 要 用 到 break 语 句 while True: a = raw_input() if a == 'EOF': break 上 面 的 程 序 不 停 接 受 用 户 输 入 当 用 户 输 入 一 行 EOF 时, 程 序 结 束 for i in range(10): a = raw_input() if a == 'EOF': break
上 面 的 程 序 接 受 用 户 10 次 输 入, 当 用 户 输 入 一 行 EOF 时, 程 序 提 前 结 束 回 到 我 们 最 早 的 那 个 猜 数 字 小 游 戏 用 break 可 以 加 上 一 个 功 能, 当 用 户 输 入 负 数 时, 游 戏 就 结 束 如 此 一 来, 假 如 有 玩 家 猜 了 几 次 之 后 仍 然 猜 不 中, 一 怒 之 下 想 要 直 接 退 出 游 戏, 就 猜 一 个 负 数 添 加 的 代 码 是 : if answer < 0: print 'Exit game...' break 与 break 类 似 的 还 有 一 个 continue 语 句, 明 天 说 Python 第 35 课 continue break 是 彻 底 地 跳 出 循 环, 而 continue 只 是 略 过 本 次 循 环 的 余 下 内 容, 直 接 进 入 下 一 次 循 环
在 我 们 前 面 写 的 那 个 统 计 分 数 的 程 序 里, 如 果 发 现 有 成 绩 不 足 60 分, 就 不 记 入 总 成 绩 当 然, 你 可 以 用 if 判 断 来 实 现 这 个 效 果 但 我 们 今 天 要 说 另 一 种 方 法 :continue for score in data[1:]: point = int(score) if point < 60: continue sum += point
注 意 : 无 论 是 continue 还 是 break, 其 改 变 的 仅 仅 是 当 前 所 处 的 最 内 层 循 环 的 运 行, 如 果 外 层 还 有 循 环, 并 不 会 因 此 略 过 或 跳 出 在 脑 中 模 拟 运 行 下 面 这 段 程 序, 想 想 会 输 出 什 么 结 果 再 敲 到 代 码 里 验 证 一 下 : i = 0 while i < 5: i += 1 for j in range(3): print j if j == 2: break for k in range(3): if k == 2: continue print k if i > 3: break print i
Python 第 36 课 异 常 处 理 在 程 序 运 行 时, 如 果 我 们 的 代 码 引 发 了 错 误,python 就 会 中 断 程 序, 并 且 输 出 错 误 提 示 比 如 我 们 写 了 一 句 : print int('0.5') 运 行 后 程 序 得 到 错 误 提 示 : Traceback (most recent call last): File "C:/Python27/test.py", line 1, in <module> print int('0.5') ValueError: invalid literal for int() with base 10: '0.5' 意 思 是, 在 test.py 这 个 文 件, 第 1 行,print int('0.5') 这 里, 你 拿 了 一 个 不 是 10 进 制 能 够 表 示 的 字 符, 我 没 法 把 它 转 成 int 值 上 面 的 错 误 可 以 避 免, 但 在 实 际 的 应 用 中, 有 很 多 错 误 是 开 发 者 无 法 控 制 的, 例 如 用 户 输 入 了 一 个 不 合 规 定 的 值, 或 者 需 要 打 开 的 文 件 不 存 在 这 些 情 况 被 称 作 异 常, 一 个 好 的 程 序 需 要 能 处 理 可 能 发 生 的 异 常, 避 免 程 序 因 此 而 中 断
例 如 我 们 去 打 开 一 个 文 件 : f = file('non-exist.txt') print 'File opened!' f.close() 假 如 这 个 文 件 因 为 某 种 原 因 并 没 有 出 现 在 应 该 出 现 的 文 件 夹 里, 程 序 就 会 报 错 : IOError: [Errno 2] No such file or directory: 'non-exist.txt' 程 序 在 出 错 处 中 断, 后 面 的 print 不 会 被 执 行 在 python 中, 可 以 使 用 try...except 语 句 来 处 理 异 常 做 法 是, 把 可 能 引 发 异 常 的 语 句 放 在 try- 块 中, 把 处 理 异 常 的 语 句 放 在 except- 块 中 把 刚 才 那 段 代 码 放 入 try...except 中 :
try: f = file('non-exist.txt') print 'File opened!' f.close() except: print 'File not exists.' print 'Done' 当 程 序 在 try 内 部 打 开 文 件 引 发 异 常 时, 会 跳 过 try 中 剩 下 的 代 码, 直 接 跳 转 到 except 中 的 语 句 处 理 异 常 于 是 输 出 了 File not exists. 如 果 文 件 被 顺 利 打 开, 则 会 输 出 File opened!, 而 不 会 去 执 行 except 中 的 语 句 但 无 论 如 何, 整 个 程 序 不 会 中 断, 最 后 的 Done 都 会 被 输 出 在 try...except 语 句 中,try 中 引 发 的 异 常 就 像 是 扔 出 了 一 只 飞 盘, 而 except 就 是 一 只 灵 敏 的 狗, 总 能 准 确 地 接 住 飞 盘
Python 第 37 课 字 典 今 天 介 绍 一 个 python 中 的 基 本 类 型 -- 字 典 (dictionary) 字 典 这 种 数 据 结 构 有 点 像 我 们 平 常 用 的 通 讯 录, 有 一 个 名 字 和 这 个 名 字 对 应 的 信 息 在 字 典 中, 名 字 叫 做 键, 对 应 的 内 容 信 息 叫 做 值 字 典 就 是 一 个 键 / 值 对 的 集 合 它 的 基 本 格 式 是 (key 是 键,alue 是 值 ): d = {key1 : value1, key2 : value2 } 键 / 值 对 用 冒 号 分 割, 每 个 对 之 间 用 逗 号 分 割, 整 个 字 典 包 括 在 花 括 号 中 关 于 字 典 的 键 要 注 意 的 是 : 1. 键 必 须 是 唯 一 的 ; 2. 键 只 能 是 简 单 对 象, 比 如 字 符 串 整 数 浮 点 数 bool 值
list 就 不 能 作 为 键, 但 是 可 以 作 为 值 举 个 简 单 的 字 典 例 子 : score = { ' 萧 峰 ': 95, ' 段 誉 ': 97, ' 虚 竹 ': 89 } python 字 典 中 的 键 / 值 对 没 有 顺 序, 我 们 无 法 用 索 引 访 问 字 典 中 的 某 一 项, 而 是 要 用 键 来 访 问 print score[' 段 誉 '] 注 意, 如 果 你 的 键 是 字 符 串, 通 过 键 访 问 的 时 候 就 需 要 加 引 号, 如 果 是 数 字 作 为 键 则 不 用 字 典 也 可 以 通 过 for...in 遍 历 : for name in score:
print score[name] 注 意, 遍 历 的 变 量 中 存 储 的 是 字 典 的 键 如 果 要 改 变 某 一 项 的 值, 就 直 接 给 这 一 项 赋 值 : score[' 虚 竹 '] = 91 增 加 一 项 字 典 项 的 方 法 是, 给 一 个 新 键 赋 值 : score[' 慕 容 复 '] = 88 删 除 一 项 字 典 项 的 方 法 是 del: del score[' 萧 峰 '] 注 意, 这 个 键 必 须 已 存 在 于 字 典 中 如 果 你 想 新 建 一 个 空 的 字 典, 只 需 要 :