|
6 | 6 | "collapsed": true
|
7 | 7 | },
|
8 | 8 | "source": [
|
9 |
| - "# 赋值语句 \n", |
| 9 | + "# 1. 赋值语句 \n", |
10 | 10 | "基本形式是等号左边写赋值语句的目标,要赋值的对象位于右侧。 \n",
|
11 | 11 | "- **赋值语句建立对象引用值。**赋值语句总是建立对象的引用值,而不是复制对象。因此,Python变量更像是指针,而不是数据存储区域。 \n",
|
12 | 12 | "- **变量名在首次赋值时会被创建。**一旦赋值了,每当这个变量名出现在表达式时,就会被其所引用的值取代。 \n",
|
|
18 | 18 | "cell_type": "markdown",
|
19 | 19 | "metadata": {},
|
20 | 20 | "source": [
|
21 |
| - "## 赋值语句的形式\n", |
| 21 | + "## 1.1 赋值语句的形式\n", |
22 | 22 | "\n",
|
23 | 23 | "**运算**|**解释**\n",
|
24 | 24 | ":-------|:------\n",
|
|
68 | 68 | "cell_type": "markdown",
|
69 | 69 | "metadata": {},
|
70 | 70 | "source": [
|
71 |
| - "## 序列赋值 " |
| 71 | + "## 1.2 序列赋值 " |
72 | 72 | ]
|
73 | 73 | },
|
74 | 74 | {
|
|
189 | 189 | "cell_type": "markdown",
|
190 | 190 | "metadata": {},
|
191 | 191 | "source": [
|
192 |
| - "## 扩展序列解包 \n", |
| 192 | + "## 1.3 扩展序列解包 \n", |
193 | 193 | "一个带有单个星号的名称 `*X`,可以在赋值目标中使用,以指定对于序列的一个更为通用的匹配——一个列表赋给了带星号的名称,该列表收集了序列中没有赋值给其他名称的所有项。 \n",
|
194 | 194 | "\n",
|
195 | 195 | "**扩展解包的实际应用**"
|
|
213 | 213 | ],
|
214 | 214 | "source": [
|
215 | 215 | "seq = [1, 2, 3, 4]\n",
|
216 |
| - "a, *b = seq # a匹配第一项,b匹配剩下的内容\n", |
| 216 | + "a, *b = seq # a 匹配第一项,b 匹配剩下的内容\n", |
217 | 217 | "a"
|
218 | 218 | ]
|
219 | 219 | },
|
|
713 | 713 | "cell_type": "markdown",
|
714 | 714 | "metadata": {},
|
715 | 715 | "source": [
|
716 |
| - "## 多目标赋值语句 \n", |
| 716 | + "## 1.4 多目标赋值语句 \n", |
717 | 717 | "直接把所有提供的变量名都赋值给右侧的对象。"
|
718 | 718 | ]
|
719 | 719 | },
|
|
772 | 772 | "cell_type": "markdown",
|
773 | 773 | "metadata": {},
|
774 | 774 | "source": [
|
775 |
| - "在这里,修改b只会对b发生修改,因为数字不支持在原处的修改。只要赋值对象是不可变的,即使有一个以上的变量名使用该对象也无所谓。 \n", |
| 775 | + "在这里,修改 b 只会对 b 发生修改,因为数字不支持在原处的修改。只要赋值对象是不可变的,即使有一个以上的变量名使用该对象也无所谓。 \n", |
| 776 | + "\n", |
776 | 777 | "当变量初始值设为空的可变对象时(诸如列表或字典),我们就得小心一点:"
|
777 | 778 | ]
|
778 | 779 | },
|
|
802 | 803 | "cell_type": "markdown",
|
803 | 804 | "metadata": {},
|
804 | 805 | "source": [
|
805 |
| - "因为a和b引用相同的对象,通过b在原处附加值上去,通过a也会看见所有的效果。 \n", |
| 806 | + "因为 a 和 b 引用相同的对象,通过 b 在原处附加值上去,通过 a 也会看见所有的效果。 \n", |
| 807 | + "\n", |
806 | 808 | "为避免这个问题,要在单独的语句中初始化可变对象,以便分别执行独立地常量表达式来创建独立地空对象:"
|
807 | 809 | ]
|
808 | 810 | },
|
|
833 | 835 | "cell_type": "markdown",
|
834 | 836 | "metadata": {},
|
835 | 837 | "source": [
|
836 |
| - "## 增强赋值语句 \n", |
| 838 | + "## 1.5 增强赋值语句 \n", |
837 | 839 | "`X += Y` `X &= Y` `X -= Y` `X |= Y` \n",
|
838 | 840 | "`X *= Y` `X ^= Y` `X /=Y` `X >>= Y` \n",
|
839 | 841 | "`X %= Y` `X <<= Y` `X **= Y` `X //= Y`"
|
|
844 | 846 | "metadata": {},
|
845 | 847 | "source": [
|
846 | 848 | "增强赋值语句使用于任何支持隐式二元表达式的类型。 \n",
|
| 849 | + "\n", |
847 | 850 | "用于字符串时,增强形式会改为执行合并运算。"
|
848 | 851 | ]
|
849 | 852 | },
|
|
875 | 878 | "source": [
|
876 | 879 | "增强赋值语句有三个优点:\n",
|
877 | 880 | "- 程序员输入减少。\n",
|
878 |
| - "- 左侧只需计算一次。在完整形式X = X + Y中,X出现两次,必须执行两次,因此,增强赋值语句通常执行得更快。\n", |
| 881 | + "- 左侧只需计算一次。在完整形式 X = X + Y 中,X 出现两次,必须执行两次,因此,增强赋值语句通常执行得更快。\n", |
879 | 882 | "- 优化技术会自动选择。对于支持原处修改的对象而言,增强形式会自动执行原处的修改运算,而不是相比来说速度更慢的复制。"
|
880 | 883 | ]
|
881 | 884 | },
|
|
885 | 888 | "source": [
|
886 | 889 | "**增强赋值以及共享引用** \n",
|
887 | 890 | "“+=”对列表是做原处修改,不像“+”合并,总是生成新的对象。 \n",
|
| 891 | + "\n", |
888 | 892 | "就所有共享引用情况而言,只有其他变量名引用的对象被修改,其差别才可能体现出来:"
|
889 | 893 | ]
|
890 | 894 | },
|
|
906 | 910 | ],
|
907 | 911 | "source": [
|
908 | 912 | "L = [1, 2]\n",
|
909 |
| - "M = L # L和M引用相同对象\n", |
| 913 | + "M = L # L 和 M 引用相同对象\n", |
910 | 914 | "L = L + [3, 4] # 合并创建一个新的对象\n",
|
911 |
| - "L, M # 改变L,但没有改变M" |
| 915 | + "L, M # 改变 L,但没有改变 M" |
912 | 916 | ]
|
913 | 917 | },
|
914 | 918 | {
|
|
938 | 942 | "cell_type": "markdown",
|
939 | 943 | "metadata": {},
|
940 | 944 | "source": [
|
941 |
| - "## 变量命名规则 \n", |
| 945 | + "## 1.6 变量命名规则 \n", |
942 | 946 | "**语法:**(下划线或字母)+(任意数目的字母、数字或下划线) \n",
|
943 | 947 | "**区分大小写** \n",
|
944 | 948 | "**禁止使用保留字** "
|
|
954 | 958 | "- 以两下划线开头、但结尾没有两个下划线的变量名(`__X`)是类的本地(“压缩”)变量。\n",
|
955 | 959 | "- 通过交互模式运行时,只有单个下划线的变量名(`_`)会保存最后表达式的结果。\n",
|
956 | 960 | "\n",
|
957 |
| - "Python程序员通常会遵循各种其他惯例,例如类变量名通常以一个大写字母开头,而模块变量名以小写字母开头。" |
| 961 | + "Python 程序员通常会遵循各种其他惯例,例如类变量名通常以一个大写字母开头,而模块变量名以小写字母开头。" |
958 | 962 | ]
|
959 | 963 | },
|
960 | 964 | {
|
961 | 965 | "cell_type": "markdown",
|
962 | 966 | "metadata": {},
|
963 | 967 | "source": [
|
964 |
| - "# 表达式语句 \n", |
965 |
| - "在Python中,可以使用表达式作为语句(本身只占一行)。 \n", |
| 968 | + "# 2. 表达式语句 \n", |
| 969 | + "在 Python 中,可以使用表达式作为语句(本身只占一行)。 \n", |
966 | 970 | "表达式结果不会存储,只有当表达式工作并作为附加的效果,这样才有意义。 \n",
|
967 | 971 | "\n",
|
968 | 972 | "通常在两种情况下表达式用作语句:\n",
|
|
974 | 978 | "cell_type": "markdown",
|
975 | 979 | "metadata": {},
|
976 | 980 | "source": [
|
977 |
| - "**常见Python表达式语句**\n", |
| 981 | + "**常见 Python 表达式语句**\n", |
978 | 982 | "\n",
|
979 | 983 | "**运算**|**解释**\n",
|
980 | 984 | ":-------|:------\n",
|
981 | 985 | "`spam(eggs, ham)`|函数调用\n",
|
982 | 986 | "`spam.ham(eggs)`|方法调用\n",
|
983 | 987 | "`spam`|在交互模式解释器内打印变量\n",
|
984 |
| - "`print(a, b, c, sep='')`|Python 3.X中的打印操作\n", |
| 988 | + "`print(a, b, c, sep='')`|Python 3.X \"中的打印操作\n", |
985 | 989 | "`yield x ** 2`|产生表达式的语句"
|
986 | 990 | ]
|
987 | 991 | },
|
988 | 992 | {
|
989 | 993 | "cell_type": "markdown",
|
990 | 994 | "metadata": {},
|
991 | 995 | "source": [
|
992 |
| - "## 表达式语句和在原处的修改 \n", |
| 996 | + "## 2.1 表达式语句和在原处的修改 \n", |
993 | 997 | "表达式语句通常用于执行可于原处修改列表的列表方法:"
|
994 | 998 | ]
|
995 | 999 | },
|
|
1044 | 1048 | "cell_type": "markdown",
|
1045 | 1049 | "metadata": {},
|
1046 | 1050 | "source": [
|
1047 |
| - "# 打印操作 \n", |
| 1051 | + "# 3. 打印操作 \n", |
1048 | 1052 | "打印是把一个或多个对象转换为其文本表达形式,然后发送给标准输出或另一个类似文件的流。 "
|
1049 | 1053 | ]
|
1050 | 1054 | },
|
1051 | 1055 | {
|
1052 | 1056 | "cell_type": "markdown",
|
1053 | 1057 | "metadata": {},
|
1054 | 1058 | "source": [
|
1055 |
| - "## print函数 \n", |
1056 |
| - "print内置函数通常在其自身的一行中调用,但是它不会返回我们所关心的任何值(返回None)。 \n", |
| 1059 | + "## 3.1 print 函数 \n", |
| 1060 | + "print 内置函数通常在其自身的一行中调用,但是它不会返回我们所关心的任何值(返回 None)。 \n", |
1057 | 1061 | "\n",
|
1058 | 1062 | "**调用格式** \n",
|
1059 | 1063 | "`print([object, ...][, sep=' '][, end='\\n'][, file=sys.stdout][, flush=False])` \n",
|
|
1108 | 1112 | "metadata": {},
|
1109 | 1113 | "source": [
|
1110 | 1114 | "print 中不需要把对象转换为字符串,而在文件写入方法中则需要这么做。 \n",
|
| 1115 | + "\n", |
1111 | 1116 | "默认情况下,print 在打印的对象之间添加一个空格。给 sep 关键字参数发送一个空字符串,或者自己所选择的替代分隔符,以取消空格。"
|
1112 | 1117 | ]
|
1113 | 1118 | },
|
|
1125 | 1130 | }
|
1126 | 1131 | ],
|
1127 | 1132 | "source": [
|
1128 |
| - "print(x, y, z, sep='')" |
| 1133 | + "print(x, y, z, sep='') # 抑制分隔符" |
1129 | 1134 | ]
|
1130 | 1135 | },
|
1131 | 1136 | {
|
|
1142 | 1147 | }
|
1143 | 1148 | ],
|
1144 | 1149 | "source": [
|
1145 |
| - "print(x, y, z, sep=',')" |
| 1150 | + "print(x, y, z, sep=',') # 自定义分隔符" |
1146 | 1151 | ]
|
1147 | 1152 | },
|
1148 | 1153 | {
|
|
1166 | 1171 | }
|
1167 | 1172 | ],
|
1168 | 1173 | "source": [
|
1169 |
| - "print(x, y, z, end='')" |
| 1174 | + "print(x, y, z, end='') # 抑制行终止符" |
1170 | 1175 | ]
|
1171 | 1176 | },
|
1172 | 1177 | {
|
|
1200 | 1205 | }
|
1201 | 1206 | ],
|
1202 | 1207 | "source": [
|
1203 |
| - "print(x, y, z, end='...\\n')" |
| 1208 | + "print(x, y, z, end='...\\n') # 自定义行终止符" |
1204 | 1209 | ]
|
1205 | 1210 | },
|
1206 | 1211 | {
|
|
1224 | 1229 | }
|
1225 | 1230 | ],
|
1226 | 1231 | "source": [
|
1227 |
| - "print(x, y, z, sep='...', end='!\\n')" |
| 1232 | + "print(x, y, z, sep='...', end='!\\n') # 多个关键字" |
1228 | 1233 | ]
|
1229 | 1234 | },
|
1230 | 1235 | {
|
|
1277 | 1282 | }
|
1278 | 1283 | ],
|
1279 | 1284 | "source": [
|
1280 |
| - "print(open('data.txt').read()) # 打印文件内容" |
| 1285 | + "print(open('data.txt').read()) # 显示文件文本" |
1281 | 1286 | ]
|
1282 | 1287 | },
|
1283 | 1288 | {
|
|
1326 | 1331 | "cell_type": "markdown",
|
1327 | 1332 | "metadata": {},
|
1328 | 1333 | "source": [
|
1329 |
| - "## 打印流重定向 \n", |
| 1334 | + "## 3.2 打印流重定向 \n", |
1330 | 1335 | "**重定向输出流** \n",
|
1331 | 1336 | "`print(X, Y)` \n",
|
1332 | 1337 | "等价于: \n",
|
|
1366 | 1371 | "metadata": {},
|
1367 | 1372 | "source": [
|
1368 | 1373 | "重设 sys.stdout 后,程序中任何地方的 print 语句都会讲文字写至文件 log.txt 的末尾,而不是原始的输出流。 \n",
|
| 1374 | + "\n", |
1369 | 1375 | "进程中只有一个 sys 模块,通过这种方式赋值 sys.stdout 会把程序中任何地方的每个 print 都进行重定向。 \n",
|
| 1376 | + "\n", |
1370 | 1377 | "甚至可以将 sys.stdout 重设为非文件的对象,只要该对象有 write 方法。当该对象是类时,打印的文字可以定位并通过任意方式进行处理。 "
|
1371 | 1378 | ]
|
1372 | 1379 | },
|
|
1376 | 1383 | "source": [
|
1377 | 1384 | "**自动化流重定向** \n",
|
1378 | 1385 | "通过赋值 sys.stdout 而将打印文字重定向的技巧实际上非常常用。但是有一个潜在的问题,就是没有直接的方式可以保存原始的输出流,在打印至文件后,可以切换回来。 \n",
|
| 1386 | + "\n", |
1379 | 1387 | "在 Python 3.X 中,file 关键字允许一个单个的 print 调用将其文本发送给一个文件的 write 方法,而不用真正地重设 sys.stdout。因为这种重定向是暂时的,普通的 print 语句还是会继续打印到原始的输出流。"
|
1380 | 1388 | ]
|
1381 | 1389 | },
|
|
1386 | 1394 | "outputs": [],
|
1387 | 1395 | "source": [
|
1388 | 1396 | "log = open('log.txt', 'a')\n",
|
1389 |
| - "print(x, y, z, file=log)\n", |
1390 |
| - "print(x, y, z)" |
| 1397 | + "print(x, y, z, file=log) # 打印到文件对象\n", |
| 1398 | + "print(x, y, z) # 打印到原始输出流" |
1391 | 1399 | ]
|
1392 | 1400 | },
|
1393 | 1401 | {
|
|
1449 | 1457 | "name": "python",
|
1450 | 1458 | "nbconvert_exporter": "python",
|
1451 | 1459 | "pygments_lexer": "ipython3",
|
1452 |
| - "version": "3.6.6" |
| 1460 | + "version": "3.6.5" |
1453 | 1461 | }
|
1454 | 1462 | },
|
1455 | 1463 | "nbformat": 4,
|
|
0 commit comments