-
Notifications
You must be signed in to change notification settings - Fork 5
Expand file tree
/
Copy pathBasic_Objects.html
More file actions
1373 lines (1173 loc) · 122 KB
/
Basic_Objects.html
File metadata and controls
1373 lines (1173 loc) · 122 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
<!DOCTYPE html>
<!--[if IE 8]><html class="no-js lt-ie9" lang="zh-CN" > <![endif]-->
<!--[if gt IE 8]><!--> <html class="no-js" lang="zh-CN" > <!--<![endif]-->
<head>
<meta charset="utf-8">
<meta content="Topic: Basics of Python Objects, Difficulty: Easy, Category: Section" name="description" />
<meta content="integers, booleans, floats, floating point precision, lists, strings, fundamentals" name="keywords" />
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>基本对象类型 — Python Like You Mean It</title>
<script type="text/javascript" src="../_static/js/modernizr.min.js"></script>
<script type="text/javascript" id="documentation_options" data-url_root="../" src="../_static/documentation_options.js"></script>
<script src="../_static/jquery.js"></script>
<script src="../_static/underscore.js"></script>
<script src="../_static/doctools.js"></script>
<script src="../_static/language_data.js"></script>
<script src="https://www.googletagmanager.com/gtag/js?id=UA-115029372-1"></script>
<script src="../_static/gtag.js"></script>
<script src="../_static/translations.js"></script>
<script crossorigin="anonymous" integrity="sha256-Ae2Vz/4ePdIu6ZyI/5ZGsYnb+m0JlOmKPjt6XZ9JJkA=" src="https://cdnjs.cloudflare.com/ajax/libs/require.js/2.3.4/require.min.js"></script>
<script async="async" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.5/latest.js?config=TeX-AMS-MML_HTMLorMML"></script>
<script type="text/x-mathjax-config">MathJax.Hub.Config({"tex2jax": {"inlineMath": [["$", "$"], ["\\(", "\\)"]], "processEscapes": true, "ignoreClass": "document", "processClass": "math|output_area"}})</script>
<script type="text/javascript" src="../_static/js/theme.js"></script>
<link rel="stylesheet" href="../_static/css/theme.css" type="text/css" />
<link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
<link rel="stylesheet" href="../_static/my_theme.css" type="text/css" />
<link rel="index" title="索引" href="../genindex.html" />
<link rel="search" title="搜索" href="../search.html" />
<link rel="next" title="序列类型" href="SequenceTypes.html" />
<link rel="prev" title="模组2：Python基础" href="../module_2.html" />
</head>
<body class="wy-body-for-nav">
<div class="wy-grid-for-nav">
<nav data-toggle="wy-nav-shift" class="wy-nav-side">
<div class="wy-side-scroll">
<div class="wy-side-nav-search" >
<a href="../index.html" class="icon icon-home"> Python Like You Mean It
</a>
<div class="version">
1.4
</div>
<div role="search">
<form id="rtd-search-form" class="wy-form" action="../search.html" method="get">
<input type="text" name="q" placeholder="Search docs" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form>
</div>
</div>
<div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="main navigation">
<p class="caption"><span class="caption-text">目录:</span></p>
<ul class="current">
<li class="toctree-l1"><a class="reference internal" href="../intro.html">Python Like You Mean It</a></li>
<li class="toctree-l1"><a class="reference internal" href="../module_1.html">模组1：Python入门</a></li>
<li class="toctree-l1 current"><a class="reference internal" href="../module_2.html">模组2：Python基础</a><ul class="current">
<li class="toctree-l2 current"><a class="current reference internal" href="#">基本对象类型</a><ul>
<li class="toctree-l3"><a class="reference internal" href="#数字类型">数字类型</a><ul>
<li class="toctree-l4"><a class="reference internal" href="#Python的math模组">Python的math模组</a></li>
<li class="toctree-l4"><a class="reference internal" href="#整数">整数</a></li>
<li class="toctree-l4"><a class="reference internal" href="#浮点数">浮点数</a></li>
<li class="toctree-l4"><a class="reference internal" href="#复数">复数</a></li>
<li class="toctree-l4"><a class="reference internal" href="#赋值语句的简写">赋值语句的简写</a></li>
<li class="toctree-l4"><a class="reference internal" href="#提升数字的可读性">提升数字的可读性</a></li>
</ul>
</li>
<li class="toctree-l3"><a class="reference internal" href="#布尔类">布尔类</a><ul>
<li class="toctree-l4"><a class="reference internal" href="#逻辑运算符">逻辑运算符</a></li>
<li class="toctree-l4"><a class="reference internal" href="#布尔值对象其实就是整数">布尔值对象其实就是整数</a></li>
</ul>
</li>
<li class="toctree-l3"><a class="reference internal" href="#None类型">None类型</a></li>
<li class="toctree-l3"><a class="reference internal" href="#字符串">字符串</a><ul>
<li class="toctree-l4"><a class="reference internal" href="#字符串类型简介">字符串类型简介</a></li>
<li class="toctree-l4"><a class="reference internal" href="#字符串基础">字符串基础</a></li>
<li class="toctree-l4"><a class="reference internal" href="#格式化字符串">格式化字符串</a></li>
<li class="toctree-l4"><a class="reference internal" href="#字符串的官方说明文档">字符串的官方说明文档</a></li>
</ul>
</li>
<li class="toctree-l3"><a class="reference internal" href="#列表">列表</a><ul>
<li class="toctree-l4"><a class="reference internal" href="#列表是序列">列表是序列</a></li>
<li class="toctree-l4"><a class="reference internal" href="#列表是可变的">列表是可变的</a></li>
<li class="toctree-l4"><a class="reference internal" href="#列表的官方说明文档">列表的官方说明文档</a></li>
</ul>
</li>
<li class="toctree-l3"><a class="reference internal" href="#总结">总结</a></li>
<li class="toctree-l3"><a class="reference internal" href="#官方说明文档链接">官方说明文档链接</a></li>
<li class="toctree-l3"><a class="reference internal" href="#阅读理解答案">阅读理解答案</a></li>
</ul>
</li>
<li class="toctree-l2"><a class="reference internal" href="SequenceTypes.html">序列类型</a></li>
<li class="toctree-l2"><a class="reference internal" href="Variables_and_Assignment.html">变量和赋值</a></li>
<li class="toctree-l2"><a class="reference internal" href="Introduction.html">控制流简介</a></li>
<li class="toctree-l2"><a class="reference internal" href="ConditionalStatements.html">条件语</a></li>
<li class="toctree-l2"><a class="reference internal" href="ForLoops.html">For循环和While循环</a></li>
<li class="toctree-l2"><a class="reference internal" href="Iterables.html">可迭代物</a></li>
<li class="toctree-l2"><a class="reference internal" href="Generators_and_Comprehensions.html">生成器和理解表达式</a></li>
<li class="toctree-l2"><a class="reference internal" href="Itertools.html">Python的“Itertools”</a></li>
<li class="toctree-l2"><a class="reference internal" href="Functions.html">函数基础</a></li>
<li class="toctree-l2"><a class="reference internal" href="Scope.html">作用域</a></li>
<li class="toctree-l2"><a class="reference internal" href="DataStructures.html">数据结构（第一部分）：简介</a></li>
<li class="toctree-l2"><a class="reference internal" href="DataStructures_II_Dictionaries.html">数据结构（第二部分）：词典</a></li>
<li class="toctree-l2"><a class="reference internal" href="DataStructures_III_Sets_and_More.html">数据结构（第三部分）：集和集合模组</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="../module_2_problems.html">模组2：题目</a></li>
<li class="toctree-l1"><a class="reference internal" href="../module_3.html">模组3：NumPy基础</a></li>
<li class="toctree-l1"><a class="reference internal" href="../module_3_problems.html">模组3：题目</a></li>
<li class="toctree-l1"><a class="reference internal" href="../module_4.html">模组4：面向对象编程</a></li>
<li class="toctree-l1"><a class="reference internal" href="../module_5.html">模组5：琐碎话题</a></li>
</ul>
</div>
</div>
</nav>
<section data-toggle="wy-nav-shift" class="wy-nav-content-wrap">
<nav class="wy-nav-top" aria-label="top navigation">
<i data-toggle="wy-nav-top" class="fa fa-bars"></i>
<a href="../index.html">Python Like You Mean It</a>
</nav>
<div class="wy-nav-content">
<div class="rst-content">
<div role="navigation" aria-label="breadcrumbs navigation">
<ul class="wy-breadcrumbs">
<li><a href="../index.html">Docs</a> »</li>
<li><a href="../module_2.html">模组2：Python基础</a> »</li>
<li>基本对象类型</li>
<li class="wy-breadcrumbs-aside">
<a href="../_sources/Module2_EssentialsOfPython/Basic_Objects.md.txt" rel="nofollow"> View page source</a>
</li>
</ul>
<hr/>
</div>
<div role="main" class="document" itemscope="itemscope" itemtype="http://schema.org/Article">
<div itemprop="articleBody">
<style>
/* CSS overrides for sphinx_rtd_theme */
/* 24px margin */
.nbinput.nblast.container,
.nboutput.nblast.container {
margin-bottom: 19px; /* padding has already 5px */
}
/* ... except between code cells! */
.nblast.container + .nbinput.container {
margin-top: -19px;
}
.admonition > p:before {
margin-right: 4px; /* make room for the exclamation icon */
}
/* Fix math alignment, see https://github.com/rtfd/sphinx_rtd_theme/pull/686 */
.math {
text-align: unset;
}
</style>
<div class="section" id="基本对象类型">
<h1>基本对象类型<a class="headerlink" href="#基本对象类型" title="永久链接至标题">¶</a></h1>
<div class="admonition warning">
<p class="admonition-title fa fa-exclamation-circle"><strong>注</strong>：</p>
<p>在本资源各处会有一些阅读理解练习。这些题目旨在帮助读者活学活用文中的知识点。练习题的答案可以在本页底部找到。</p>
</div>
<p>本文会经常使用“对象”这一单词。在Python中，“对象”包含了很多东西：数字，字符串，列表，函数，等等。简单来讲，一个Python对象是任何可以赋值给变量的东西。尽管如此，对象是分<em>类型</em>（type）的：比如说在Python眼中，整数（integer）和字符串（string）的<em>类型</em>是不一样的。</p>
<p>不同类型的对象为了不同目的而存在，而因此也有着不同的内置函数。在这里，我们将复习Python自带的一些基本类型并以此写一些代码。我们将会讨论：</p>
<ul class="simple">
<li><p>数字（整数，浮点数，复数）（number（integer，float-point number，complex number））</p></li>
<li><p>布尔值（真或否）（boolean）</p></li>
<li><p>“空”值类（the “null” type）</p></li>
<li><p>字符串（string）</p></li>
<li><p>列表（list）</p></li>
</ul>
<p>Python自带的 <code class="docutils literal notranslate"><span class="pre">isinstance</span></code> 函数允许我们检测对象是否为某一类型。你也可以用自带的 <code class="docutils literal notranslate"><span class="pre">type</span></code> 函数来查看对象的类型。比如说，下面的代码会检测一个对象是否是整数：</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="c1"># 对变量 `x` 赋值整数 1</span>
<span class="o">>>></span> <span class="n">x</span> <span class="o">=</span> <span class="mi">1</span>
<span class="c1"># 查看 `x` 的类型</span>
<span class="o">>>></span> <span class="nb">type</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>
<span class="nb">int</span>
<span class="c1"># 检测 `x` 是否是整数类（integer）</span>
<span class="o">>>></span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="nb">int</span><span class="p">)</span>
<span class="kc">True</span>
</pre></div>
</div>
<p>在之后的模组中，你将学习“面对对象”的编程模式。这将允许你创建你自己的定制对象种类！</p>
<div class="section" id="数字类型">
<h2>数字类型<a class="headerlink" href="#数字类型" title="永久链接至标题">¶</a></h2>
<p>Python有三种基本的数字类型：整数（integer），浮点数（floating-point number），和复数（complex number）。你可以使用你熟悉的数学运算符来对这三种数字进行算术操作（像“大于”这种比较性的运算符没有定义如何处理复数）:</p>
<table class="docutils align-default">
<colgroup>
<col style="width: 16%" />
<col style="width: 84%" />
</colgroup>
<thead>
<tr class="row-odd"><th class="head"><p>操作</p></th>
<th class="head"><p>描述</p></th>
</tr>
</thead>
<tbody>
<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">x</span> <span class="pre">+</span> <span class="pre">y</span></code></p></td>
<td><p>求两数相加的结果</p></td>
</tr>
<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">x</span> <span class="pre">-</span> <span class="pre">y</span></code></p></td>
<td><p>求两数相减的结果</p></td>
</tr>
<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">x</span> <span class="pre">*</span> <span class="pre">y</span></code></p></td>
<td><p>求两数相乘的结果</p></td>
</tr>
<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">x</span> <span class="pre">/</span> <span class="pre">y</span></code></p></td>
<td><p>求两数相除的结果</p></td>
</tr>
<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">x</span> <span class="pre">//</span> <span class="pre">y</span></code></p></td>
<td><p>求两数相除的整数商</p></td>
</tr>
<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">x</span> <span class="pre">%</span> <span class="pre">y</span></code></p></td>
<td><p>求两数的模（<code class="docutils literal notranslate"><span class="pre">x</span></code> modulo: <code class="docutils literal notranslate"><span class="pre">y</span></code>，也就是 <code class="docutils literal notranslate"><span class="pre">x</span> <span class="pre">/</span> <span class="pre">y</span></code> 的余数）</p></td>
</tr>
<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">x</span> <span class="pre">**</span> <span class="pre">y</span></code></p></td>
<td><p>求 <code class="docutils literal notranslate"><span class="pre">x</span></code> 的幂 <code class="docutils literal notranslate"><span class="pre">y</span></code></p></td>
</tr>
<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">-x</span></code></p></td>
<td><p>求负数</p></td>
</tr>
<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">abs(x)</span></code></p></td>
<td><p>求数的绝对值</p></td>
</tr>
<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">x</span> <span class="pre">==</span> <span class="pre">y</span></code></p></td>
<td><p>检测两数是否等值</p></td>
</tr>
<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">x</span> <span class="pre">!=</span> <span class="pre">y</span></code></p></td>
<td><p>检测两数是否不等值</p></td>
</tr>
<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">x</span> <span class="pre">></span> <span class="pre">y</span></code></p></td>
<td><p>检测 <code class="docutils literal notranslate"><span class="pre">x</span></code> 是否大于 <code class="docutils literal notranslate"><span class="pre">y</span></code></p></td>
</tr>
<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">x</span> <span class="pre">>=</span> <span class="pre">y</span></code></p></td>
<td><p>检测 <code class="docutils literal notranslate"><span class="pre">x</span></code> 是否大于或等于 <code class="docutils literal notranslate"><span class="pre">y</span></code></p></td>
</tr>
<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">x</span> <span class="pre"><</span> <span class="pre">y</span></code></p></td>
<td><p>检测 <code class="docutils literal notranslate"><span class="pre">x</span></code> 是否小于 <code class="docutils literal notranslate"><span class="pre">y</span></code></p></td>
</tr>
<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">x</span> <span class="pre"><=</span> <span class="pre">y</span></code></p></td>
<td><p>检测 <code class="docutils literal notranslate"><span class="pre">x</span></code> 是否小于或等于 <code class="docutils literal notranslate"><span class="pre">y</span></code></p></td>
</tr>
</tbody>
</table>
<p>这些运算符和你平时在数学课上见到的运算顺序一样，在没有括号的情况下遵循先乘除后加减。</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="c1"># 先乘除后加减</span>
<span class="o">>>></span> <span class="mi">1</span> <span class="o">+</span> <span class="mi">2</span> <span class="o">*</span> <span class="mi">3</span>
<span class="mi">7</span>
<span class="c1"># 用括号更改运算顺序</span>
<span class="o">>>></span> <span class="p">(</span><span class="mi">1</span> <span class="o">+</span> <span class="mi">2</span><span class="p">)</span> <span class="o">*</span> <span class="mi">3</span>
<span class="mi">9</span>
<span class="c1"># 求余数</span>
<span class="o">>>></span> <span class="mi">11</span> <span class="o">%</span> <span class="mi">5</span>
<span class="mi">1</span>
<span class="c1"># 检测不等式是否成立</span>
<span class="o">>>></span> <span class="p">(</span><span class="mi">2</span> <span class="o">**</span> <span class="mi">3</span><span class="p">)</span> <span class="o"><</span> <span class="p">(</span><span class="mi">2</span> <span class="o">**</span> <span class="mi">4</span><span class="p">)</span>
<span class="kc">True</span>
</pre></div>
</div>
<p>请注意：在很多其他的编程语言中（包括Python 2），两个整数相除永远都会返回一个整数——就算数学上的结果应该是个分数。在Python 3中，<em>两个整数相除永远都会返回一个浮点数</em>（一个包含小数点的数字）：</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="c1"># 在很多别的语言中，3 / 2 会返回整数 1</span>
<span class="c1"># 在Python 3中，除法返回一个浮点数</span>
<span class="o">>>></span> <span class="mi">3</span> <span class="o">/</span> <span class="mi">2</span>
<span class="mf">1.5</span>
<span class="o">>>></span> <span class="mi">4</span> <span class="o">/</span> <span class="mi">2</span>
<span class="mf">2.0</span>
</pre></div>
</div>
<p>运算符 <code class="docutils literal notranslate"><span class="pre">//</span></code> 英文叫做“floor-divide”（直译“地板除”）：它取两数相除之后去尾（去掉浮点数小数点后的数字）得到的整数（因为浮点数取整可以往上入——4.5入到5——或者往下舍——4.5舍到4——，所以去尾被称为地板除）。这可以用来进行很多其他语言中传统的整数相除：</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="c1"># “地板除“</span>
<span class="o">>>></span> <span class="mi">1</span> <span class="o">//</span> <span class="mi">3</span> <span class="c1"># 0.3333.. -> 0</span>
<span class="mi">0</span>
<span class="o">>>></span> <span class="mi">3</span> <span class="o">//</span> <span class="mi">2</span> <span class="c1"># 1.5 -> 1</span>
<span class="mi">1</span>
</pre></div>
</div>
<div class="admonition note">
<p class="admonition-title fa fa-exclamation-circle"><strong>阅读理解：理解模运算符</strong></p>
<p>模运算符 <code class="docutils literal notranslate"><span class="pre">%</span></code> 在数学教材中并不常见。但是它在我们手中是很有用的一个运算符。<code class="docutils literal notranslate"><span class="pre">x</span> <span class="pre">%</span> <span class="pre">y</span></code> (读作 x “模”（mod）y）返回 <code class="docutils literal notranslate"><span class="pre">x</span> <span class="pre">/</span> <span class="pre">y</span></code> 的余数。比如说：</p>
<ul class="simple">
<li><p><span class="math notranslate nohighlight">\(\frac{3}{2} = 1 + \frac{1}{2}\)</span>. 3 中可以去除一个 2，最后余下 1，所以 <code class="docutils literal notranslate"><span class="pre">3</span> <span class="pre">%</span> <span class="pre">2</span></code> 返回 <code class="docutils literal notranslate"><span class="pre">1</span></code></p></li>
<li><p><span class="math notranslate nohighlight">\(\frac{9}{3} = 3\)</span>. 9 中可以去除三个 3，什么都不余下。所以 <code class="docutils literal notranslate"><span class="pre">9</span> <span class="pre">%</span> <span class="pre">3</span></code> 返回 <code class="docutils literal notranslate"><span class="pre">0</span></code></p></li>
</ul>
<p>根据以上对模运算符的解释，先自己猜测下方表达式的结果，并用IPython命令行检查你的答案:</p>
<ol class="arabic simple">
<li><p><code class="docutils literal notranslate"><span class="pre">1</span> <span class="pre">%</span> <span class="pre">5</span></code></p></li>
<li><p><code class="docutils literal notranslate"><span class="pre">2</span> <span class="pre">%</span> <span class="pre">5</span></code></p></li>
<li><p><code class="docutils literal notranslate"><span class="pre">22</span> <span class="pre">%</span> <span class="pre">1</span></code></p></li>
<li><p><code class="docutils literal notranslate"><span class="pre">22</span> <span class="pre">%</span> <span class="pre">2</span></code></p></li>
<li><p><code class="docutils literal notranslate"><span class="pre">22</span> <span class="pre">%</span> <span class="pre">3</span></code></p></li>
<li><p><code class="docutils literal notranslate"><span class="pre">22</span> <span class="pre">%</span> <span class="pre">4</span></code></p></li>
<li><p><code class="docutils literal notranslate"><span class="pre">22</span> <span class="pre">%</span> <span class="pre">5</span></code></p></li>
<li><p><code class="docutils literal notranslate"><span class="pre">22</span> <span class="pre">%</span> <span class="pre">6</span></code></p></li>
</ol>
<p>假设 <code class="docutils literal notranslate"><span class="pre">n</span></code> 是任何整数，<code class="docutils literal notranslate"><span class="pre">n</span> <span class="pre">%</span> <span class="pre">2</span></code> 可能返回哪些数值？尝试简明地解释 <code class="docutils literal notranslate"><span class="pre">n</span> <span class="pre">%</span> <span class="pre">2</span></code> 的行为。</p>
</div>
<div class="section" id="Python的math模组">
<h3>Python的math模组<a class="headerlink" href="#Python的math模组" title="永久链接至标题">¶</a></h3>
<p>标准库的math模组为我们提供更多的数学函数，像对数（logarithm）和三角函数。完整的列表<a class="reference external" href="https://docs.python.org/3/library/math.html#number-theoretic-and-representation-functions">可以在Python官网上找到</a>。要使用math模组里的函数，你必须先导入它。</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="c1"># 使用 `math` 模组里面的数学函数</span>
<span class="o">>>></span> <span class="kn">import</span> <span class="nn">math</span>
<span class="o">>>></span> <span class="n">math</span><span class="o">.</span><span class="n">sqrt</span><span class="p">(</span><span class="mf">4.</span><span class="p">)</span>
<span class="mf">2.0</span>
<span class="c1"># 以10为底的对数</span>
<span class="o">>>></span> <span class="n">math</span><span class="o">.</span><span class="n">log10</span><span class="p">(</span><span class="mf">10.</span><span class="p">)</span>
<span class="mf">1.0</span>
<span class="c1"># 4! = 4*3*2*1</span>
<span class="o">>>></span> <span class="n">math</span><span class="o">.</span><span class="n">factorial</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
<span class="mi">24</span>
</pre></div>
</div>
</div>
<div class="section" id="整数">
<h3>整数<a class="headerlink" href="#整数" title="永久链接至标题">¶</a></h3>
<p>像传统数学一样，一个整数是任何没有小数点的数字：<span class="math notranslate nohighlight">\(\dots, -3, -2, -1, 0, 1, 2, 3, \dots\)</span>。</p>
<p>整数属于内置类 <code class="docutils literal notranslate"><span class="pre">int</span></code>，而 <code class="docutils literal notranslate"><span class="pre">int</span></code> 则可以用来将其它对象转化成整数：</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">type</span><span class="p">(</span><span class="o">-</span><span class="mi">3</span><span class="p">)</span>
<span class="go">int</span>
<span class="go"># `1.3` 不是整数对象</span>
<span class="gp">>>> </span><span class="nb">isinstance</span><span class="p">(</span><span class="mf">1.3</span><span class="p">,</span> <span class="nb">int</span><span class="p">)</span>
<span class="go">False</span>
<span class="go"># 将字符串转化成整数</span>
<span class="gp">>>> </span><span class="nb">int</span><span class="p">(</span><span class="s2">"10"</span><span class="p">)</span>
<span class="go">10</span>
<span class="go"># 将浮点数转化成整数</span>
<span class="gp">>>> </span><span class="nb">int</span><span class="p">(</span><span class="mf">1.3</span><span class="p">)</span>
<span class="go">1</span>
</pre></div>
</div>
<p>整数想多大都可以；Python会分配相应该数字所需的内存来完全存储它（而不会丢失精度）。当然，说到底这还是受有多少内存可用的限制:</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="c1"># 你可以创建一个很大的整数</span>
<span class="o">>>></span> <span class="n">large_int</span> <span class="o">=</span> <span class="mi">281938481039848500192847576920</span>
</pre></div>
</div>
<p>整数有一些内置函数可用。完整的介绍可以在<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#additional-methods-on-integer-types">官方说明文档</a>中找到。很多这些函数的作用可能对新手而言比较难以理解。现在你只需要知道这些函数存在就行。</p>
</div>
<div class="section" id="浮点数">
<h3>浮点数<a class="headerlink" href="#浮点数" title="永久链接至标题">¶</a></h3>
<p>一个浮点数（floating-point number，或float）是有小数点的数字。这可以用来表达任何数字，但其精度受数字位数的限制。</p>
<p>这些对象属于内置类 <code class="docutils literal notranslate"><span class="pre">float</span></code>，而 <code class="docutils literal notranslate"><span class="pre">float</span></code> 则可以用来将其它对象转化成浮点数：</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="c1"># 几个浮点数的例子</span>
<span class="o">>>></span> <span class="mf">100.</span> <span class="o">**</span> <span class="mf">0.5</span>
<span class="mf">10.0</span>
<span class="o">>>></span> <span class="mi">1</span> <span class="o">/</span> <span class="mi">3</span>
<span class="mf">0.3333333333333333</span>
<span class="o">>>></span> <span class="mi">1</span> <span class="o">/</span> <span class="mi">2</span>
<span class="mf">0.5</span>
<span class="o">>>></span> <span class="nb">type</span><span class="p">(</span><span class="o">-</span><span class="mf">2.1</span><span class="p">)</span>
<span class="nb">float</span>
<span class="c1"># 整数 10 并不是浮点数</span>
<span class="o">>>></span> <span class="nb">isinstance</span><span class="p">(</span><span class="mi">10</span><span class="p">,</span> <span class="nb">float</span><span class="p">)</span>
<span class="kc">False</span>
<span class="c1"># 但加上一个小数点会让其成为浮点数</span>
<span class="o">>>></span> <span class="nb">isinstance</span><span class="p">(</span><span class="mf">10.</span><span class="p">,</span> <span class="nb">float</span><span class="p">)</span>
<span class="kc">True</span>
<span class="c1"># 将字符串转化成浮点数</span>
<span class="o">>>></span> <span class="nb">float</span><span class="p">(</span><span class="s2">"10.456"</span><span class="p">)</span>
<span class="mf">10.456</span>
<span class="c1"># 将整数转化成浮点数</span>
<span class="o">>>></span> <span class="nb">float</span><span class="p">(</span><span class="o">-</span><span class="mi">22</span><span class="p">)</span>
<span class="o">-</span><span class="mf">22.0</span>
</pre></div>
</div>
<p>浮点数有几个内置的函数可用。具体内容在<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#additional-methods-on-float">官方说明文件</a>中可以查阅。</p>
<div class="section" id="科学计数法">
<h4>科学计数法<a class="headerlink" href="#科学计数法" title="永久链接至标题">¶</a></h4>
<p>浮点数也可以用常见的科学计数法来创建。字符 <code class="docutils literal notranslate"><span class="pre">e</span></code> 用来代表 <span class="math notranslate nohighlight">\(\times 10\)</span>，而在这字符后的数字是幂。以下为几个传统的科学计数法例子和它们对应的Python表达式：</p>
<p><span class="math notranslate nohighlight">\(1.38 \times 10^{-4} \rightarrow\)</span> <code class="docutils literal notranslate"><span class="pre">1.38e-04</span></code></p>
<p><span class="math notranslate nohighlight">\(-4.2 \times 10^{10} \rightarrow\)</span> <code class="docutils literal notranslate"><span class="pre">-4.2e10</span></code></p>
<p>Python将自动用科学计数法来显示位数多的浮点数：</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="c1"># Python会用科学计数法来显示多位浮点数</span>
<span class="o">>>></span> <span class="mf">0.0000001</span> <span class="c1"># 7个前置0</span>
<span class="mf">1e-07</span>
</pre></div>
</div>
</div>
<div class="section" id="理解数字精度">
<h4>理解数字精度<a class="headerlink" href="#理解数字精度" title="永久链接至标题">¶</a></h4>
<p>虽然Python整数无大小限制，浮点数的精度<em>受限于它能存储多少位数</em>。具体来讲，你的电脑只会用固定量的内存（在大部分机器上是8字节，也就是32比特）来储存一个浮点数的值。</p>
<p>实际操作时，这意味着一个浮点数大概只能存储16位有效数字的<em>数值精度</em>。计算机并不能保证存这8字节之外的位数精度。比如说，接下来的代码定义了一个100位的整数。但当这个整数被转化成浮点数后，它只能保存16位的有效数字：</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="c1"># 演示浮点数的有限精度</span>
<span class="c1"># 一个100位的整数</span>
<span class="c1"># Python会分配足够多的的内存来存储这个整数</span>
<span class="o">>>></span> <span class="nb">int</span><span class="p">(</span><span class="s2">"1"</span><span class="o">*</span><span class="mi">100</span><span class="p">)</span> <span class="c1"># 创建一个含有100个“1”的字符串并将其转化成整数</span>
<span class="mi">1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111</span>
<span class="c1"># 当将同样的字符串转化成浮点数时，</span>
<span class="c1"># 它只能存储16位的有效数字</span>
<span class="c1"># 这也就是8字节内存能存储的大小</span>
<span class="o">>>></span> <span class="nb">float</span><span class="p">(</span><span class="s2">"1"</span><span class="o">*</span><span class="mi">100</span><span class="p">)</span> <span class="c1"># 创建一个含有100个“1”的字符串并将其转化成浮点数</span>
<span class="mf">1.111111111111111e+99</span>
</pre></div>
</div>
<p>计算机无法存储最后84位数字的原因是这样做会需要远超于8字节的内存去存储整个浮点数。假如你在数星星的话，用浮点数而不是整数来存储这个数字会让你漏掉其中整整 <span class="math notranslate nohighlight">\(1\times10^{83}\)</span> 个！</p>
<p>因此，试图用超过浮点数精度的数值去修改该浮点数并不会有任何效果：</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="c1"># 用超过浮点数精度的数值去修改该浮点数并不会有任何效果</span>
<span class="o">>>></span> <span class="mf">1.</span> <span class="o">+</span> <span class="mf">1e-16</span>
<span class="mf">1.0</span>
</pre></div>
</div>
<p>就算有了以上对浮点精度的讨论做铺垫，你也很可能会惊讶于以下浮点运算的结果：</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="c1"># 这令人意外的结果源自浮点数的有限精度</span>
<span class="o">>>></span> <span class="mf">0.1</span> <span class="o">+</span> <span class="mf">0.1</span> <span class="o">+</span> <span class="mf">0.1</span> <span class="o">-</span> <span class="mf">0.3</span> <span class="o">==</span> <span class="mf">0.</span>
<span class="kc">False</span>
<span class="c1"># 浮点数的有限精度的效果</span>
<span class="o">>>></span> <span class="mf">0.1</span> <span class="o">+</span> <span class="mf">0.1</span> <span class="o">+</span> <span class="mf">0.1</span> <span class="o">-</span> <span class="mf">0.3</span>
<span class="mf">5.551115123125783e-17</span>
</pre></div>
</div>
<p>这并不是什么Python的奇怪特征；这是一个已经被<a class="reference external" href="https://docs.python.org/3/tutorial/floatingpoint.html">完全理解</a>的操作有限精度的浮点数的现象。为了应对这个问题，你不应该检查两个浮点数是否“相同”，而应该检查两个浮点数是否“够相近”。 让我重点强调一下：</p>
<p><strong>你永远不应该检查两个浮点数是否完全相同。你应该检查两个浮点数是否足够相近。</strong></p>
<p><code class="docutils literal notranslate"><span class="pre">math</span></code> 模组有一个解决这个需求的函数；<code class="docutils literal notranslate"><span class="pre">math.isclose</span></code> 会检查两个数字之间的差是否小于 <span class="math notranslate nohighlight">\(1 \times 10^{-9}\)</span>。你可以修改这个函数使用的容忍值；详见此函数的<a class="reference external" href="https://docs.python.org/3/library/math.html#math.isclose">说明文档</a>。因为在之前的例子中我们对比的数值都很接近0，我们将检查它们的差的绝对值是否够小：</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="c1"># 检查两个浮点数是否“足够接近”</span>
<span class="o">>>></span> <span class="kn">import</span> <span class="nn">math</span>
<span class="c1"># 检查</span>
<span class="c1"># | (0.1 + 0.1 + 0.1 - 0.3) - 0 | < 1x10^{-9}</span>
<span class="o">>>></span> <span class="n">math</span><span class="o">.</span><span class="n">isclose</span><span class="p">((</span><span class="mf">0.1</span> <span class="o">+</span> <span class="mf">0.1</span> <span class="o">+</span> <span class="mf">0.1</span> <span class="o">-</span> <span class="mf">0.3</span><span class="p">),</span> <span class="mf">0.</span><span class="p">,</span> <span class="n">abs_tol</span><span class="o">=</span><span class="mf">1e-9</span><span class="p">)</span>
<span class="kc">True</span>
</pre></div>
</div>
<p>如果你不记住这一课，你未来绝对会导致一些严重，难查的bug。在Python（以及任何其它编程语言）中做和数字有关的工作时，你一定要理解浮点数的有限精度是一个错误源，就像测量工具的不精确一样。因此在错误分析的时候要考虑到它（如果你需要做错误分析的话）。</p>
<p>你可以用Python的<a class="reference external" href="https://docs.python.org/3.0/library/decimal.html">decimal模组</a>来定义比标准8字节的浮点数更高（或更低）精度的数字。任何使用这个模组的数学计算都是<em>完全精确</em>的，也就是说 <code class="docutils literal notranslate"><span class="pre">0.1</span> <span class="pre">+</span> <span class="pre">0.1</span> <span class="pre">+</span> <span class="pre">0.1</span> <span class="pre">-</span> <span class="pre">0.3</span></code> 正好是 <code class="docutils literal notranslate"><span class="pre">0.</span></code>。Python还有一个自带的<a class="reference external" href="https://docs.python.org/3/library/fractions.html#module-fractions">fractions模组</a>提供精确表达和操作有理数的工具。虽然我们不会在本资源中使用这些模组，但是你也应该知道这些模组的存在以及浮点数并不是唯一的选择这事实。</p>
</div>
</div>
<div class="section" id="复数">
<h3>复数<a class="headerlink" href="#复数" title="永久链接至标题">¶</a></h3>
<p>在数学中，一个“复数”（complex number）是任何 <span class="math notranslate nohighlight">\(a + bi\)</span> 形式的数字（<span class="math notranslate nohighlight">\(a\)</span> 和 <span class="math notranslate nohighlight">\(b\)</span> 为实数，<span class="math notranslate nohighlight">\(i\)</span> 的定义为满足 <span class="math notranslate nohighlight">\(i^2 = -1\)</span> 关系的数）。因为没有任何实数满足上述关系，<span class="math notranslate nohighlight">\(i\)</span> 被称为“虚数”。</p>
<p>奇奇怪怪的电气工程师用符号 <span class="math notranslate nohighlight">\(j\)</span> 来代替 <span class="math notranslate nohighlight">\(i\)</span>，所以Python会将复数 <span class="math notranslate nohighlight">\(2 + 3i\)</span> 打印成 <code class="docutils literal notranslate"><span class="pre">2+3j</span></code>（实际原因是 <span class="math notranslate nohighlight">\(i\)</span> 一般用来表达电流；我们还是要爱护电气工程师的）。</p>
<p>除了 <code class="docutils literal notranslate"><span class="pre">a</span> <span class="pre">+</span> <span class="pre">bj</span></code> 格式之外，内置的 <code class="docutils literal notranslate"><span class="pre">complex</span></code> 类可以用来创建复数：</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="c1"># 创建复数</span>
<span class="o">>>></span> <span class="mi">2</span> <span class="o">+</span> <span class="mi">3</span><span class="n">j</span>
<span class="p">(</span><span class="mi">2</span><span class="o">+</span><span class="mi">3</span><span class="n">j</span><span class="p">)</span>
<span class="o">>>></span> <span class="nb">complex</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="p">(</span><span class="mi">2</span><span class="o">+</span><span class="mi">3</span><span class="n">j</span><span class="p">)</span>
<span class="o">>>></span> <span class="nb">complex</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span><span class="o">**</span><span class="mi">2</span>
<span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="o">+</span><span class="mi">0</span><span class="n">j</span><span class="p">)</span>
<span class="o">>>></span> <span class="nb">type</span><span class="p">(</span><span class="mi">2</span><span class="o">+</span><span class="mi">3</span><span class="n">j</span><span class="p">)</span>
<span class="nb">complex</span>
<span class="o">>>></span> <span class="nb">isinstance</span><span class="p">(</span><span class="mi">2</span><span class="o">-</span><span class="mi">4</span><span class="n">j</span><span class="p">,</span> <span class="nb">complex</span><span class="p">)</span>
<span class="kc">True</span>
</pre></div>
</div>
<p>请注意，<code class="docutils literal notranslate"><span class="pre">j</span></code> 自身并不是代表 <span class="math notranslate nohighlight">\(i\)</span> 的特殊字符。只有在一个数字常量（numerical literal）（不是变量的数字）后的 <code class="docutils literal notranslate"><span class="pre">j</span></code> 才会被Python直译器理解为复数。</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span># 仅仅 'j' 本身并没有什么特殊含义
>>> j
NameError: name 'j' is not defined（名字 'j' 未定义）
# 而 `1j` 会被理解为虚数
>>> (1j) ** 2
(-1+0j)
</pre></div>
</div>
<p>你分别可以获取 <code class="docutils literal notranslate"><span class="pre">a</span> <span class="pre">+</span> <span class="pre">bj</span></code> 中的 <code class="docutils literal notranslate"><span class="pre">a</span></code> 和 <code class="docutils literal notranslate"><span class="pre">b</span></code>，也就是复数的实数（real）和虚数（imaginary）部分。</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="c1"># 获取复数的实数和虚数部分</span>
<span class="o">>>></span> <span class="n">x</span> <span class="o">=</span> <span class="nb">complex</span><span class="p">(</span><span class="mf">1.2</span><span class="p">,</span> <span class="o">-</span><span class="mf">3.4</span><span class="p">)</span>
<span class="o">>>></span> <span class="n">x</span><span class="o">.</span><span class="n">real</span>
<span class="mf">1.2</span>
<span class="o">>>></span> <span class="n">x</span><span class="o">.</span><span class="n">imag</span>
<span class="o">-</span><span class="mf">3.4</span>
</pre></div>
</div>
<p><code class="docutils literal notranslate"><span class="pre">cmath</span></code>（“complex math”）模组定义了一组复数的数学函数。完整的列表可以在<a class="reference external" href="https://docs.python.org/3/library/cmath.html#module-cmath">官方说明文件</a>找到。</p>
<div class="admonition note">
<p class="admonition-title fa fa-exclamation-circle"><strong>阅读理解：操作Python数字</strong></p>
<ol class="arabic simple">
<li><p>在Python中，对两个整数进行如加或乘的算术会返回一个整数，而对两个浮点数进行运算会返回一个浮点数：</p></li>
</ol>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="mi">2</span> <span class="o">*</span> <span class="mi">3</span>
<span class="go">6</span>
<span class="gp">>>> </span><span class="mf">2.0</span> <span class="o">*</span> <span class="mf">3.0</span>
<span class="go">6.0</span>
</pre></div>
</div>
<p>上述语句对 <code class="docutils literal notranslate"><span class="pre">+</span> <span class="pre">-</span> <span class="pre">*</span> <span class="pre">/</span> <span class="pre">**</span></code> 这些运算符中哪个<em>不</em>成立？</p>
<ol class="arabic simple" start="2">
<li><p>对一个整数和一个浮点数进行数学运算会返回哪种数字？是否所有的运算符都遵循这一规律？请在命令行中进行尝试以得到答案。</p></li>
<li><p>定义 <span class="math notranslate nohighlight">\(f(x) = e^{|x - 2|}\)</span>。使用 <code class="docutils literal notranslate"><span class="pre">math</span></code> 模组来运算 <span class="math notranslate nohighlight">\(f(-0.2)\)</span>。</p></li>
<li><p>使用Python的科学计数法语法来确认一万亿除以十亿等于一千。</p></li>
</ol>
</div>
</div>
<div class="section" id="赋值语句的简写">
<h3>赋值语句的简写<a class="headerlink" href="#赋值语句的简写" title="永久链接至标题">¶</a></h3>
<p>Python提供了一些方便你使用数学运算符更新变量的方式。假设你想要将 <code class="docutils literal notranslate"><span class="pre">x</span></code> 的值增加 1，你可能会如此操作：</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="c1"># 将 `x` 增加 1</span>
<span class="o">>>></span> <span class="n">x</span> <span class="o">=</span> <span class="mi">5</span>
<span class="o">>>></span> <span class="n">x</span> <span class="o">=</span> <span class="n">x</span> <span class="o">+</span> <span class="mi">1</span>
<span class="o">>>></span> <span class="n">x</span>
<span class="mi">6</span>
</pre></div>
</div>
<p>我们可以利用一个特殊的赋值符 <code class="docutils literal notranslate"><span class="pre">+=</span></code> 来简写这个更新操作。</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="c1"># 使用 `+=` 来将 `x` 增加 1</span>
<span class="o">>>></span> <span class="n">x</span> <span class="o">=</span> <span class="mi">5</span>
<span class="o">>>></span> <span class="n">x</span> <span class="o">+=</span> <span class="mi">1</span> <span class="c1"># 这和 `x = x + 1` 等值</span>
<span class="o">>>></span> <span class="n">x</span>
<span class="mi">6</span>
</pre></div>
</div>
<p><code class="docutils literal notranslate"><span class="pre">+=</span></code> 是一种<em>增强赋值语句</em>（augmented assignment statement）。总的来讲，一个增强赋值语句会对一个函数进行某种数学运算，并用运算的结果更新该函数。每个算术运算符都有着相对应的增强的赋值语句。假设 <code class="docutils literal notranslate"><span class="pre">x</span></code> 和 <code class="docutils literal notranslate"><span class="pre">n</span></code> 为数字，以下列表将总结我们可以用 <code class="docutils literal notranslate"><span class="pre">n</span></code> 对 <code class="docutils literal notranslate"><span class="pre">x</span></code> 进行的增强算术赋值语句：</p>
<ul class="simple">
<li><p><code class="docutils literal notranslate"><span class="pre">x</span> <span class="pre">+=</span> <span class="pre">n</span></code> <span class="math notranslate nohighlight">\(\rightarrow\)</span> <code class="docutils literal notranslate"><span class="pre">x</span> <span class="pre">=</span> <span class="pre">x</span> <span class="pre">+</span> <span class="pre">n</span></code></p></li>
<li><p><code class="docutils literal notranslate"><span class="pre">x</span> <span class="pre">-=</span> <span class="pre">n</span></code> <span class="math notranslate nohighlight">\(\rightarrow\)</span> <code class="docutils literal notranslate"><span class="pre">x</span> <span class="pre">=</span> <span class="pre">x</span> <span class="pre">-</span> <span class="pre">n</span></code></p></li>
<li><p><code class="docutils literal notranslate"><span class="pre">x</span> <span class="pre">*=</span> <span class="pre">n</span></code> <span class="math notranslate nohighlight">\(\rightarrow\)</span> <code class="docutils literal notranslate"><span class="pre">x</span> <span class="pre">=</span> <span class="pre">x</span> <span class="pre">*</span> <span class="pre">n</span></code></p></li>
<li><p><code class="docutils literal notranslate"><span class="pre">x</span> <span class="pre">/=</span> <span class="pre">n</span></code> <span class="math notranslate nohighlight">\(\rightarrow\)</span> <code class="docutils literal notranslate"><span class="pre">x</span> <span class="pre">=</span> <span class="pre">x</span> <span class="pre">/</span> <span class="pre">n</span></code></p></li>
<li><p><code class="docutils literal notranslate"><span class="pre">x</span> <span class="pre">//=</span> <span class="pre">n</span></code> <span class="math notranslate nohighlight">\(\rightarrow\)</span> <code class="docutils literal notranslate"><span class="pre">x</span> <span class="pre">=</span> <span class="pre">x</span> <span class="pre">//</span> <span class="pre">n</span></code></p></li>
<li><p><code class="docutils literal notranslate"><span class="pre">x</span> <span class="pre">**=</span> <span class="pre">n</span></code> <span class="math notranslate nohighlight">\(\rightarrow\)</span> <code class="docutils literal notranslate"><span class="pre">x</span> <span class="pre">=</span> <span class="pre">x</span> <span class="pre">**</span> <span class="pre">n</span></code></p></li>
</ul>
</div>
<div class="section" id="提升数字的可读性">
<h3>提升数字的可读性<a class="headerlink" href="#提升数字的可读性" title="永久链接至标题">¶</a></h3>
<p>Python 3.6版本提供了在数字位数之间插入下划线来视觉上划分它们的功能。这个符号可以用来提升多位数的可读性。比如说，利用 <code class="docutils literal notranslate"><span class="pre">_</span></code> 来区分每三位的数字，<code class="docutils literal notranslate"><span class="pre">662607004</span></code> 可以被重写成为 <code class="docutils literal notranslate"><span class="pre">662_607_004</span></code>。下划线不能出现在数字首位，尾位，或另一个下划线旁边，但除此以外这个符号可以出现在数字常量中间的任何位置。</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="c1"># 利用 `_` 来视觉上划分数字</span>
<span class="o">>>></span> <span class="mi">1_000_000</span> <span class="c1"># 这很实用！</span>
<span class="mi">1000000</span>
<span class="c1"># 虽然看起来挺恶心的，但这是合法的Python代码</span>
<span class="o">>>></span> <span class="mf">2_3_4.5_6_7</span>
<span class="mf">234.567</span>
<span class="c1"># 你可以在任何类型的数字中插入下划线</span>
<span class="o">>>></span> <span class="mi">10_000</span><span class="n">j</span>
<span class="mi">10000</span><span class="n">j</span>
</pre></div>
</div>
<div class="admonition warning">
<p class="admonition-title fa fa-exclamation-circle"><strong>兼容性警告</strong></p>
<p>在数字常量中插入下划线 <code class="docutils literal notranslate"><span class="pre">_</span></code> 的功能是在Python 3.6版本加入的。如果你使用此功能，那你的代码会和Python 3.5和更早的版本不兼容。</p>
</div>
</div>
</div>
<div class="section" id="布尔类">
<h2>布尔类<a class="headerlink" href="#布尔类" title="永久链接至标题">¶</a></h2>
<p>Python有两种布尔类（boolean）的对象：<code class="docutils literal notranslate"><span class="pre">True</span></code>（真）和 <code class="docutils literal notranslate"><span class="pre">False</span></code>（否）；它们属于内置的 <code class="docutils literal notranslate"><span class="pre">bool</span></code> 类型。我们在之前见到 <code class="docutils literal notranslate"><span class="pre">isinstance</span></code> 函数根据对象是否是某类的实例（instance）而返回 <code class="docutils literal notranslate"><span class="pre">True</span></code> 或 <code class="docutils literal notranslate"><span class="pre">False</span></code>。</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="c1"># 两种布尔类的对象：`True` 和 `False`</span>
<span class="o">>>></span> <span class="nb">type</span><span class="p">(</span><span class="kc">True</span><span class="p">)</span>
<span class="nb">bool</span>
<span class="c1"># `False` 是一个布尔类的对象</span>
<span class="o">>>></span> <span class="nb">isinstance</span><span class="p">(</span><span class="kc">False</span><span class="p">,</span> <span class="nb">bool</span><span class="p">)</span>
<span class="kc">True</span>
</pre></div>
</div>
<p>在Python中，<code class="docutils literal notranslate"><span class="pre">True</span></code> 和 <code class="docutils literal notranslate"><span class="pre">False</span></code> 必须要首字母大写。请不要将它们和字符串搞混；注意布尔值并两边没有引号。</p>
<div class="section" id="逻辑运算符">
<h3>逻辑运算符<a class="headerlink" href="#逻辑运算符" title="永久链接至标题">¶</a></h3>
<p>Python提供常见的布尔逻辑的操作符：</p>
<table class="docutils align-default">
<colgroup>
<col style="width: 68%" />
<col style="width: 32%" />
</colgroup>
<thead>
<tr class="row-odd"><th class="head"><p>逻辑运算名称</p></th>
<th class="head"><p>运算符号</p></th>
</tr>
</thead>
<tbody>
<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">and</span></code>（逻辑与）</p></td>
<td><p><code class="docutils literal notranslate"><span class="pre">&</span></code></p></td>
</tr>
<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">or</span></code> （逻辑或）</p></td>
<td><p>|</p></td>
</tr>
</tbody>
</table>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="c1"># 演示布尔逻辑运算符</span>
<span class="o">>>></span> <span class="kc">True</span> <span class="ow">or</span> <span class="kc">False</span>
<span class="kc">True</span>
<span class="o">>>></span> <span class="kc">True</span> <span class="ow">and</span> <span class="kc">False</span>
<span class="kc">False</span>
<span class="o">>>></span> <span class="ow">not</span> <span class="kc">False</span>
<span class="kc">True</span>
</pre></div>
</div>
<p>译者注：原文因为 <code class="docutils literal notranslate"><span class="pre">not</span></code>（逻辑否）在英文中很好理解没有多讨论。读者只需知道：<code class="docutils literal notranslate"><span class="pre">not</span></code> 返回输入的布尔值的反值。</p>
<p>你也可以使用 <code class="docutils literal notranslate"><span class="pre">and</span></code> 和 <code class="docutils literal notranslate"><span class="pre">or</span></code> 对应的运算符号：</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="c1"># 演示逻辑运算符</span>
<span class="o">>>></span> <span class="kc">False</span> <span class="o">|</span> <span class="kc">True</span> <span class="c1"># 和 `False or True` 等值</span>
<span class="kc">True</span>
<span class="o">>>></span> <span class="kc">False</span> <span class="o">&</span> <span class="kc">True</span> <span class="c1"># 和 `False and True` 等值</span>
<span class="kc">False</span>
</pre></div>
</div>
<p>一般来讲，使用运算名称，而不是符号，是更加“Python风格“的做法（也就是说这个方法在Python编程者之间更时兴）。</p>
<p>你可以在同行使用多个逻辑运算符，并用括号来细述运算顺序：</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="p">(</span><span class="kc">True</span> <span class="ow">or</span> <span class="kc">False</span><span class="p">)</span> <span class="ow">and</span> <span class="kc">True</span>
<span class="go">True</span>
</pre></div>
</div>
<p>基本的比大小语句自然会返回布尔类的对象。</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="mi">2</span> <span class="o"><</span> <span class="mi">3</span>
<span class="go">True</span>
<span class="gp">>>> </span><span class="mf">10.5</span> <span class="o"><</span> <span class="mi">0</span>
<span class="go">False</span>
<span class="gp">>>> </span><span class="p">(</span><span class="mi">2</span> <span class="o"><</span> <span class="mi">4</span><span class="p">)</span> <span class="ow">and</span> <span class="ow">not</span> <span class="p">(</span><span class="mi">4</span> <span class="o">!=</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="go">False</span>
</pre></div>
</div>
<p><code class="docutils literal notranslate"><span class="pre">bool</span></code> 类有着其它方便操作的方法。我们将在“条件语”小节讨论它们。</p>
</div>
<div class="section" id="布尔值对象其实就是整数">
<h3>布尔值对象其实就是整数<a class="headerlink" href="#布尔值对象其实就是整数" title="永久链接至标题">¶</a></h3>
<p><code class="docutils literal notranslate"><span class="pre">True</span></code> 和 <code class="docutils literal notranslate"><span class="pre">False</span></code> 这两个布尔值对象正式而言也是 <code class="docutils literal notranslate"><span class="pre">int</span></code> 类型的成员，其分别对应 <code class="docutils literal notranslate"><span class="pre">1</span></code> 和 <code class="docutils literal notranslate"><span class="pre">0</span></code>：</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">isinstance</span><span class="p">(</span><span class="kc">True</span><span class="p">,</span> <span class="nb">int</span><span class="p">)</span>
<span class="go">True</span>
<span class="gp">>>> </span><span class="nb">int</span><span class="p">(</span><span class="kc">True</span><span class="p">)</span>
<span class="go">1</span>
<span class="gp">>>> </span><span class="nb">isinstance</span><span class="p">(</span><span class="kc">False</span><span class="p">,</span> <span class="nb">int</span><span class="p">)</span>
<span class="go">True</span>
<span class="gp">>>> </span><span class="nb">int</span><span class="p">(</span><span class="kc">False</span><span class="p">)</span>
<span class="go">0</span>
</pre></div>
</div>
<p>因此，在数学运算中它们和 <code class="docutils literal notranslate"><span class="pre">1</span></code> 和 <code class="docutils literal notranslate"><span class="pre">0</span></code> 的作用一样：</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="mi">3</span><span class="o">*</span><span class="kc">True</span> <span class="o">-</span> <span class="kc">False</span> <span class="c1"># 和 3*1 + 0 等值</span>
<span class="go">3</span>
<span class="gp">>>> </span><span class="kc">True</span> <span class="o">/</span> <span class="kc">False</span> <span class="c1"># 和 1 / 0 等值</span>
<span class="go">---------------------------------------------------------------------------</span>
<span class="go">ZeroDivisionError Traceback (most recent call last)</span>
<span class="go"><ipython-input-4-f8487d9d0863> in <module>()</span>
<span class="go">----> 1 True / False</span>
<span class="go">ZeroDivisionError: division by zero</span>
<span class="go">（因为除以零所以直译器报错）</span>
</pre></div>
</div>
<p>为何 <code class="docutils literal notranslate"><span class="pre">True</span></code> 和 <code class="docutils literal notranslate"><span class="pre">False</span></code> 同时也是整数的原因超出了本节的纲领。熟悉这一特征会让你在写Python代码的时候避免一些错误。</p>
<div class="admonition note">
<p class="admonition-title fa fa-exclamation-circle"><strong>阅读理解：布尔表达式</strong></p>
<ol class="arabic simple">
<li><p>假设 <code class="docutils literal notranslate"><span class="pre">x</span></code> 是整数类。编写一个表达式，在 <code class="docutils literal notranslate"><span class="pre">x</span></code> 是偶数时返回 <code class="docutils literal notranslate"><span class="pre">True</span></code>，其它情况返回 <code class="docutils literal notranslate"><span class="pre">False</span></code>。（提示：回忆 <code class="docutils literal notranslate"><span class="pre">%</span></code> 运算符的功能）</p></li>
<li><p>假设 <code class="docutils literal notranslate"><span class="pre">x</span></code> 和 <code class="docutils literal notranslate"><span class="pre">y</span></code> 都是实数（也就是不是复数的数字）。编写一行代码，在以下情况中返回 <code class="docutils literal notranslate"><span class="pre">False</span></code>：<code class="docutils literal notranslate"><span class="pre">x</span></code> 和 <code class="docutils literal notranslate"><span class="pre">y</span></code> 相差小于0.9，且 <code class="docutils literal notranslate"><span class="pre">x</span></code> 大于零。（提示：尝试先编写在这个情况中会返回 <code class="docutils literal notranslate"><span class="pre">True</span></code> 的代码，然后再取反）</p></li>
<li><p>编写一个表达式，当 <code class="docutils literal notranslate"><span class="pre">x</span></code> 是布尔类型或浮点类型对象时返回 <code class="docutils literal notranslate"><span class="pre">True</span></code>。</p></li>
</ol>
</div>
</div>
</div>
<div class="section" id="None类型">
<h2>None类型<a class="headerlink" href="#None类型" title="永久链接至标题">¶</a></h2>
<p><code class="docutils literal notranslate"><span class="pre">NoneType</span></code>（None类型）仅仅只有一个对象：<code class="docutils literal notranslate"><span class="pre">None</span></code>。<code class="docutils literal notranslate"><span class="pre">None</span></code> 用来表达“无”/“空”，也就是什么都没有的意思。</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="c1"># `None` 是*唯一*属于NoneType的对象</span>
<span class="o">>>></span> <span class="nb">type</span><span class="p">(</span><span class="kc">None</span><span class="p">)</span>
<span class="n">NoneType</span>
</pre></div>
</div>
<p>因此，与其检查某对象是否属于NoneType，你应该直接检查该对象是否就是 <code class="docutils literal notranslate"><span class="pre">None</span></code>。Python保留 <code class="docutils literal notranslate"><span class="pre">is</span></code> 为检查两个对象是否相同的运算符。这和检查两个对象是否有着同样的值或态的 <code class="docutils literal notranslate"><span class="pre">==</span></code> 运算符不一样：</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="c1"># 检查对象是否*是*（is）None，而不是</span>
<span class="c1"># 检查对象是否是NoneType类的实例</span>
<span class="o">>>></span> <span class="n">x</span> <span class="o">=</span> <span class="mi">22</span>
<span class="o">>>></span> <span class="n">x</span> <span class="ow">is</span> <span class="kc">None</span>
<span class="kc">False</span>
<span class="o">>>></span> <span class="n">x</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span>
<span class="kc">True</span>
<span class="o">>>></span> <span class="n">y</span> <span class="o">=</span> <span class="kc">None</span>
<span class="o">>>></span> <span class="n">y</span> <span class="ow">is</span> <span class="kc">None</span>
<span class="kc">True</span>
</pre></div>
</div>
<p>译者注：<code class="docutils literal notranslate"><span class="pre">x</span> <span class="pre">is</span> <span class="pre">not</span> <span class="pre">None</span></code> 和 <code class="docutils literal notranslate"><span class="pre">not</span> <span class="pre">(x</span> <span class="pre">is</span> <span class="pre">None)</span></code> 等值，但前者因更符合英文语法而也被支持。</p>
<p><code class="docutils literal notranslate"><span class="pre">None</span></code> 经常作为占位符使用。以下代码将演示 <code class="docutils literal notranslate"><span class="pre">None</span></code> 在实际操作中的用法；如果你并不能完全理解这代码，不要担心：</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="c1"># 演示将 `None` 作为占位符的用法</span>
<span class="c1"># 在本代码中，我们想要找到列表中第一个大于10的物件</span>
<span class="c1"># 如果该物件不存在，我们将如实告诉用户</span>
<span class="n">large_num</span> <span class="o">=</span> <span class="kc">None</span>
<span class="k">for</span> <span class="n">number</span> <span class="ow">in</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">]:</span>
<span class="k">if</span> <span class="n">number</span> <span class="o">></span> <span class="mi">10</span><span class="p">:</span>
<span class="n">large_num</span> <span class="o">=</span> <span class="n">number</span>
<span class="k">break</span>
<span class="k">if</span> <span class="n">large_num</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"The list did not contain any number larger than 10"</span><span class="p">)</span>
</pre></div>
</div>
</div>
<div class="section" id="字符串">
<h2>字符串<a class="headerlink" href="#字符串" title="永久链接至标题">¶</a></h2>
<div class="section" id="字符串类型简介">
<h3>字符串类型简介<a class="headerlink" href="#字符串类型简介" title="永久链接至标题">¶</a></h3>
<p>字符串（string）类型被用于存储多个字符。你可以用一下语法创建字符串：</p>
<ul class="simple">
<li><p>单引号：<code class="docutils literal notranslate"><span class="pre">'Hello</span> <span class="pre">world'</span></code></p></li>
<li><p>双引号：<code class="docutils literal notranslate"><span class="pre">"Hello</span> <span class="pre">world"</span></code></p></li>
<li><p>三引号：<code class="docutils literal notranslate"><span class="pre">"""Hello</span> <span class="pre">world"""</span></code> 或 <code class="docutils literal notranslate"><span class="pre">'''Hello</span> <span class="pre">world'''</span></code></p></li>
</ul>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="c1"># 字符串可以存储任何字符，</span>
<span class="c1"># 不仅仅是英文字母表中的字母！</span>
<span class="o">>>></span> <span class="s2">"hello, 你好, Olá, 123"</span>
<span class="s1">'hello, 你好, Olá, 123'</span>
</pre></div>
</div>
<p>Python 3默认使用<a class="reference external" href="https://docs.python.org/3/howto/unicode.html#unicode-howto">UTF-8 unicode</a>来表达这些多样化的字符。暂时没必要太过关注这个细节，知道它存在就行。</p>
<p>字符串属于内置的 <code class="docutils literal notranslate"><span class="pre">str</span></code> 类型。<code class="docutils literal notranslate"><span class="pre">str</span></code> 则可以用来将非字符串对象转化成字符串。</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="c1"># `str` 类型</span>
<span class="o">>>></span> <span class="nb">type</span><span class="p">(</span><span class="s2">"hello"</span><span class="p">)</span>
<span class="nb">str</span>
<span class="o">>>></span> <span class="nb">isinstance</span><span class="p">(</span><span class="s2">"83"</span><span class="p">,</span> <span class="nb">str</span><span class="p">)</span>
<span class="kc">True</span>
<span class="c1"># 利用 `str` 类型来将非字符串对象转化成字符串</span>
<span class="o">>>></span> <span class="nb">str</span><span class="p">(</span><span class="mf">10.34</span><span class="p">)</span>
<span class="s1">'10.34'</span>
<span class="o">>>></span> <span class="nb">str</span><span class="p">(</span><span class="kc">True</span><span class="p">)</span>
<span class="s1">'True'</span>
</pre></div>
</div>
<p>当一个字符串被创建后，它的值无法被改变（除非你创建一个全新的字符串）。因此，任何一个字符串都无法被“改变”——字符串是*不可变*（immutable）的对象。</p>
<p>因为Python存储一<em>序列</em>（sequence）的字符，Python提供了调用字符串中单个字符和子字符串的工具：</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">sentence</span> <span class="o">=</span> <span class="s2">"The cat in the hat."</span>
<span class="gp">>>> </span><span class="n">sentence</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
<span class="go">'T'</span>
<span class="gp">>>> </span><span class="n">sentence</span><span class="p">[</span><span class="mi">0</span><span class="p">:</span><span class="mi">3</span><span class="p">]</span>
<span class="go">'The'</span>
</pre></div>
</div>
<p>字符串并不是Python中唯一的序列类；列表（list）和元组（tuple）也同样是序列的一种。我们在未来将专门花一节课来讨论Python提供的通用序列操作。这包括了以上展示的“索引“（indexing）和”切片“（slicing）。</p>
</div>
<div class="section" id="字符串基础">
<h3>字符串基础<a class="headerlink" href="#字符串基础" title="永久链接至标题">¶</a></h3>
<p>我们只会学习一些字符串的基础。如果你想要一个更全面的非正式字符串教程，请查阅<a class="reference external" href="https://docs.python.org/3/tutorial/introduction.html#strings">官方Python教程</a>。</p>
<p>在字符串中，<code class="docutils literal notranslate"><span class="pre">\n</span></code> 被视为一个字符。它代表着字符串的新行（new-line）。在打印时它也会如此显示。相似的 <code class="docutils literal notranslate"><span class="pre">\t</span></code> 会显示为一个tab字符。</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="c1"># 使用 `\n` 来创建新行</span>
<span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="s2">"hi...</span><span class="se">\n</span><span class="s2">...bye"</span><span class="p">)</span>
<span class="n">hi</span><span class="o">...</span>
<span class="o">...</span><span class="n">bye</span>
</pre></div>
</div>
<p>三引号将允许你编写一整块字符串，也就是说你可以在多行中编写同一个字符串：</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="c1"># 使用三引号来编写一个多行字符串</span>
<span class="o">>>></span> <span class="n">x</span> <span class="o">=</span> <span class="s2">""" I am a string.</span>
<span class="s2">I am part of the same string.</span>
<span class="s2"> me... too!"""</span>
<span class="o">>>></span> <span class="n">x</span>
<span class="s1">' I am a string.</span><span class="se">\n</span><span class="s1">I am part of the same string.</span><span class="se">\n</span><span class="s1"> me... too!'</span>
</pre></div>
</div>
<p>Python的字符串有着大量很有用的内置函数。熟悉了解这些函数<em>极其重要</em>。详见<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#string-methods">官方说明文件</a>。以下是其中一些函数的演示：</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="c1"># 演示几个字符串的内置函数</span>
<span class="o">>>></span> <span class="s2">"hello"</span><span class="o">.</span><span class="n">capitalize</span><span class="p">()</span> <span class="c1"># 译者注：首字母大写</span>
<span class="s1">'Hello'</span>
<span class="c1"># 使用“...”来讲多个字符串连接在一起</span>
<span class="o">>>></span> <span class="s2">"..."</span><span class="o">.</span><span class="n">join</span><span class="p">([</span><span class="s2">"item1"</span><span class="p">,</span> <span class="s2">"item2"</span><span class="p">,</span> <span class="s2">"item3"</span><span class="p">])</span>
<span class="s1">'item1...item2...item3'</span>
<span class="c1"># 每当“, ”出现时切分字符串</span>
<span class="o">>>></span> <span class="s1">'item1, item2, item3'</span><span class="o">.</span><span class="n">split</span><span class="p">(</span><span class="s2">", "</span><span class="p">)</span>
<span class="p">[</span><span class="s1">'item1'</span><span class="p">,</span> <span class="s1">'item2'</span><span class="p">,</span> <span class="s1">'item3'</span><span class="p">]</span>
<span class="c1"># 该字符串是否以“.py”结尾?</span>
<span class="o">>>></span> <span class="s2">"script.py"</span><span class="o">.</span><span class="n">endswith</span><span class="p">(</span><span class="s2">".py"</span><span class="p">)</span>
<span class="kc">True</span>
<span class="c1"># 该字符串是否以“sc”打头?</span>
<span class="o">>>></span> <span class="s2">"script.py"</span><span class="o">.</span><span class="n">startswith</span><span class="p">(</span><span class="s2">"sc"</span><span class="p">)</span>
<span class="kc">True</span>
<span class="c1"># 在占位符 {} 中将对象转化为字符串并插入</span>
<span class="o">>>></span> <span class="s2">"x: </span><span class="si">{}</span><span class="s2">, y: </span><span class="si">{}</span><span class="s2">, z: </span><span class="si">{}</span><span class="s2">"</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="mf">3.2</span><span class="p">,</span> <span class="mf">8.4</span><span class="p">,</span> <span class="o">-</span><span class="mf">1.0</span><span class="p">)</span>
<span class="s1">'x: 3.2, y: 8.4, z: -1.0'</span>
<span class="c1"># 该字符串的字符是否时数字位数？</span>
<span class="o">>>></span> <span class="s2">"7"</span><span class="o">.</span><span class="n">isdigit</span><span class="p">()</span>
<span class="kc">True</span>
</pre></div>
</div>
</div>
<div class="section" id="格式化字符串">
<h3>格式化字符串<a class="headerlink" href="#格式化字符串" title="永久链接至标题">¶</a></h3>
<p>Python提供多种设置字符串格式的语法；利用这些语法，我们可以轻松地将变量数值插入到字符串中，利用空格对齐行列，并控制字符串显示小数点后几位数。本节旨在向读者展示这些不同的字符串格式。</p>
<p>如果你想要完整（但仍然易懂）的Python字符串格式教程，请查阅<a class="reference external" href="https://pyformat.info">pyformat.info</a>。你也可以查阅<a class="reference external" href="https://docs.python.org/3/library/string.html#format-examples">官方教程</a>。</p>
<p>在Python 3中，你可以使用 <code class="docutils literal notranslate"><span class="pre">format</span></code> 方法来格式化字符串：</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="c1"># 使用 `format` 来用函数值代替占位符</span>
<span class="o">>>></span> <span class="s2">"</span><span class="si">{name}</span><span class="s2"> is </span><span class="si">{age}</span><span class="s2"> years old"</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">name</span><span class="o">=</span><span class="s2">"Bruce"</span><span class="p">,</span> <span class="n">age</span><span class="o">=</span><span class="mi">80</span><span class="p">)</span>
<span class="s1">'Bruce is 80 years old'</span>
<span class="c1"># 以下语法会前置空格来保证字符串至少有8字符长</span>
<span class="o">>>></span> <span class="s2">"</span><span class="si">{item:>8}</span><span class="s2">"</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">item</span><span class="o">=</span><span class="s2">"stew"</span><span class="p">)</span>
<span class="s1">' stew'</span>
</pre></div>
</div>
<p>你有时可能会见到别人用 <code class="docutils literal notranslate"><span class="pre">%</span></code> 运算符来格式化字符串：</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="c1"># 使用 `%` 来格式化字符串（注意不要使用此方法）</span>
<span class="o">>>></span> <span class="n">name</span> <span class="o">=</span> <span class="s2">"Selina"</span>
<span class="o">>>></span> <span class="s2">"My name is </span><span class="si">%s</span><span class="s2">"</span> <span class="o">%</span> <span class="n">name</span>
<span class="s1">'My name is Selina'</span>
</pre></div>
</div>
<p>这是Python 2的遗留物；你应注意避免使用此语法。</p>
<p>如果你在用Python 3.6和之后的版本，你可以使用f-string（f字符串），一种很方便格式化字符串的方法。以下是一个f字符串的范例：</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="c1"># “f字符串”范例</span>
<span class="o">>>></span> <span class="n">batman</span> <span class="o">=</span> <span class="mi">12</span>
<span class="o">>>></span> <span class="n">catwoman</span> <span class="o">=</span> <span class="mi">10</span>
<span class="o">>>></span> <span class="sa">f</span><span class="s2">"Batman has </span><span class="si">{</span><span class="n">batman</span><span class="si">}</span><span class="s2"> apples. Catwoman has </span><span class="si">{</span><span class="n">catwoman</span><span class="si">}</span><span class="s2"> apples. Together, they have </span><span class="si">{</span><span class="n">batman</span> <span class="o">+</span> <span class="n">catwoman</span><span class="si">}</span><span class="s2"> apples"</span>
<span class="s1">'Batman has 12 apples. Catwoman has 10 apples. Together, they have 22 apples'</span>
</pre></div>
</div>
<p>请注意f字符串是一种特殊语法；在第一个引号前输入小写字符f来使用f字符串：</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="c1"># 这是一个常见的空字符串</span>
<span class="o">>>></span> <span class="s2">""</span>
<span class="s1">''</span>
<span class="c1"># 这是一个空的f字符串</span>
<span class="o">>>></span> <span class="sa">f</span><span class="s2">""</span>
<span class="s1">''</span>
</pre></div>
</div>
<p>f字符串的特殊之处在于它允许我们在字符串<em>中</em>编写Python代码；任何在 <code class="docutils literal notranslate"><span class="pre">{}</span></code> 中的表达式都会作为Python代码被执行，其结果将会被转化成字符串并插入在 <code class="docutils literal notranslate"><span class="pre">{}</span></code> 在f字符串中的位置。</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">x</span> <span class="o">=</span> <span class="mf">7.9</span>
<span class="gp">>>> </span><span class="sa">f</span><span class="s2">"x is a </span><span class="si">{</span><span class="nb">type</span><span class="p">(</span><span class="n">x</span><span class="p">)</span><span class="si">}</span><span class="s2">-number. Its value is </span><span class="si">{</span><span class="n">x</span><span class="si">}</span><span class="s2">. The statement 'x is greater than 5' is </span><span class="si">{</span><span class="n">x</span> <span class="o">></span> <span class="mi">5</span><span class="si">}</span><span class="s2">"</span>
<span class="go">"x is a <class 'float'>-number. Its value is 7.9. The statement 'x is greater than 5' is True"</span>
<span class="go">（“x是一个浮点数类数字。它的值为7.9。表达式‘x大于5’为真”）</span>
</pre></div>
</div>
<p>如例中所见，这将允许我们优雅地在字符串创建时插入变量并甚至调用函数的输出。</p>
<div class="admonition warning">
<p class="admonition-title fa fa-exclamation-circle"><strong>f字符串兼容性</strong>：</p>
<p>f字符串是Python 3.6才加入的新语法。它在之前的Python版本不可用。</p>
</div>
</div>
<div class="section" id="字符串的官方说明文档">
<h3>字符串的官方说明文档<a class="headerlink" href="#字符串的官方说明文档" title="永久链接至标题">¶</a></h3>
<p>本文强烈建议读者花些时间了解所有字符串的自带函数。</p>
<ul class="simple">
<li><p><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#string-methods">字符串自带函数</a></p></li>
<li><p><a class="reference external" href="https://docs.python.org/3/library/string.html#format-examples">格式化字符串</a></p></li>
</ul>
<div class="admonition note">
<p class="admonition-title fa fa-exclamation-circle"><strong>阅读理解：字符串</strong></p>
<p>为了回答以下问题，你会需要查阅字符串内置函数的说明文档。你可能需要进行一些尝试才能理解说明文档的“[]”格式（用于表达函数的可选输入）。</p>
<ol class="arabic simple">
<li><p>使用一个函数，在输入字符串 <code class="docutils literal notranslate"><span class="pre">"cat"</span></code> 时返回字符串 <code class="docutils literal notranslate"><span class="pre">"</span>    <span class="pre">cat</span>    <span class="pre">"</span></code>（输出的长度为11个字符；这包含字符c，a，t）。之后，修改你调用该函数的方法以返回 <code class="docutils literal notranslate"><span class="pre">"----cat----"</span></code>。</p></li>
<li><p>用空格代替以下字符串的前三个句号：<code class="docutils literal notranslate"><span class="pre">"I.am.aware.that.spaces.are.a.thing"</span></code></p></li>
<li><p>去除该字符串两边的所有空格：<code class="docutils literal notranslate"><span class="pre">"</span>  <span class="pre">basket</span>    <span class="pre">"</span></code>。</p></li>
<li><p>创建一个打印时会如下显示的字符串（第二行打头的是一个tab符号）：</p></li>
</ol>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">Hello</span>
<span class="n">over</span> <span class="n">there</span>
</pre></div>
</div>
<ol class="arabic simple" start="5">
<li><p>将整数 <code class="docutils literal notranslate"><span class="pre">12</span></code> 转化成字符串 <code class="docutils literal notranslate"><span class="pre">"12"</span></code>。</p></li>
<li><p>只有13岁和以上的孩子可以观看电影《反斗智多星》。设变量 <code class="docutils literal notranslate"><span class="pre">name</span></code>（字符串）和 <code class="docutils literal notranslate"><span class="pre">age</span></code>（整数）。使用f字符串来显示：“NAME is old enough to watch the movie: BOOL”（“NAME可以看这电影：BOOL”）。NAME应该用孩子的名字来代替，而BOOL在孩子13岁或以上时为 <code class="docutils literal notranslate"><span class="pre">True</span></code>，不然为 <code class="docutils literal notranslate"><span class="pre">False</span></code>。</p></li>
</ol>
</div>
</div>
</div>
<div class="section" id="列表">
<h2>列表<a class="headerlink" href="#列表" title="永久链接至标题">¶</a></h2>
<p>一个 <code class="docutils literal notranslate"><span class="pre">list</span></code>（列表）是一个允许我们存储一序列Python对象的对象。列表的一大功能就是我们在未来可以更新列表中的内容。</p>
<p>你可以用方括号来创建列表，并用逗号区分其中的成员：<code class="docutils literal notranslate"><span class="pre">[item1,</span> <span class="pre">item2,</span> <span class="pre">...,</span> <span class="pre">itemN]</span></code>。它的成员可以是各种不同的类型。</p>
<p>译者注：注意使用英文的方括号和逗号。</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="c1"># 列表对象可以存储一序列的其它对象</span>
<span class="o">>>></span> <span class="p">[</span><span class="mf">3.5</span><span class="p">,</span> <span class="kc">None</span><span class="p">,</span> <span class="mf">3.5</span><span class="p">,</span> <span class="kc">True</span><span class="p">,</span> <span class="s2">"hello"</span><span class="p">]</span>
<span class="p">[</span><span class="mf">3.5</span><span class="p">,</span> <span class="kc">None</span><span class="p">,</span> <span class="mf">3.5</span><span class="p">,</span> <span class="kc">True</span><span class="p">,</span> <span class="s1">'hello'</span><span class="p">]</span>
<span class="o">>>></span> <span class="nb">type</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">])</span>
<span class="nb">list</span>
<span class="o">>>></span> <span class="nb">isinstance</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">],</span> <span class="nb">list</span><span class="p">)</span>
<span class="kc">True</span>
<span class="c1"># 空列表</span>
<span class="o">>>></span> <span class="p">[]</span>
<span class="p">[]</span>
<span class="c1"># 只有一个成员的列表</span>