forked from sixu05202004/pythontutorial3
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathintroduction.html
More file actions
696 lines (617 loc) · 59.6 KB
/
introduction.html
File metadata and controls
696 lines (617 loc) · 59.6 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
<!DOCTYPE html>
<!--[if IE 8]><html class="no-js lt-ie9" lang="en" > <![endif]-->
<!--[if gt IE 8]><!--> <html class="no-js" lang="en" > <!--<![endif]-->
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>3. Python 简介 — Python tutorial 3.5.1 documentation</title>
<link href='https://fonts.googleapis.com/css?family=Lato:400,700,400italic,700italic|Roboto+Slab:400,700|Inconsolata:400,700&subset=latin,cyrillic' rel='stylesheet' type='text/css'>
<link rel="stylesheet" href="_static/css/theme.css" type="text/css" />
<link rel="top" title="Python tutorial 3.5.1 documentation" href="index.html"/>
<link rel="next" title="4. 深入 Python 流程控制" href="controlflow.html"/>
<link rel="prev" title="2. 使用 Python 解释器" href="interpreter.html"/>
<script src="https://cdnjs.cloudflare.com/ajax/libs/modernizr/2.6.2/modernizr.min.js"></script>
</head>
<body class="wy-body-for-nav" role="document">
<div class="wy-grid-for-nav">
<nav data-toggle="wy-nav-shift" class="wy-nav-side">
<div class="wy-side-nav-search">
<a href="index.html" class="fa fa-home"> Python tutorial</a>
<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">
<ul class="current">
<li class="toctree-l1"><a class="reference internal" href="appetite.html">1. 开胃菜</a></li>
<li class="toctree-l1"><a class="reference internal" href="interpreter.html">2. 使用 Python 解释器</a><ul>
<li class="toctree-l2"><a class="reference internal" href="interpreter.html#tut-invoking">2.1. 调用 Python 解释器</a></li>
<li class="toctree-l2"><a class="reference internal" href="interpreter.html#tut-interp">2.2. 解释器及其环境</a></li>
</ul>
</li>
<li class="toctree-l1 current"><a class="current reference internal" href="">3. Python 简介</a><ul>
<li class="toctree-l2"><a class="reference internal" href="#tut-calculator">3.1. 将 Python 当做计算器</a></li>
<li class="toctree-l2"><a class="reference internal" href="#tut-firststeps">3.2. 编程的第一步</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="controlflow.html">4. 深入 Python 流程控制</a><ul>
<li class="toctree-l2"><a class="reference internal" href="controlflow.html#if">4.1. if 语句</a></li>
<li class="toctree-l2"><a class="reference internal" href="controlflow.html#for">4.2. for 语句</a></li>
<li class="toctree-l2"><a class="reference internal" href="controlflow.html#range">4.3. range() 函数</a></li>
<li class="toctree-l2"><a class="reference internal" href="controlflow.html#break-continue-else">4.4. break 和 continue 语句, 以及循环中的 else 子句</a></li>
<li class="toctree-l2"><a class="reference internal" href="controlflow.html#pass">4.5. pass 语句</a></li>
<li class="toctree-l2"><a class="reference internal" href="controlflow.html#tut-functions">4.6. 定义函数</a></li>
<li class="toctree-l2"><a class="reference internal" href="controlflow.html#tut-defining">4.7. 深入 Python 函数定义</a></li>
<li class="toctree-l2"><a class="reference internal" href="controlflow.html#tut-codingstyle">4.8. 插曲：编码风格</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="datastructures.html">5. 数据结构</a><ul>
<li class="toctree-l2"><a class="reference internal" href="datastructures.html#tut-morelists">5.1. 关于列表更多的内容</a></li>
<li class="toctree-l2"><a class="reference internal" href="datastructures.html#del">5.2. del 语句</a></li>
<li class="toctree-l2"><a class="reference internal" href="datastructures.html#tut-tuples">5.3. 元组和序列</a></li>
<li class="toctree-l2"><a class="reference internal" href="datastructures.html#tut-sets">5.4. 集合</a></li>
<li class="toctree-l2"><a class="reference internal" href="datastructures.html#tut-dictionaries">5.5. 字典</a></li>
<li class="toctree-l2"><a class="reference internal" href="datastructures.html#tut-loopidioms">5.6. 循环技巧</a></li>
<li class="toctree-l2"><a class="reference internal" href="datastructures.html#tut-conditions">5.7. 深入条件控制</a></li>
<li class="toctree-l2"><a class="reference internal" href="datastructures.html#tut-comparing">5.8. 比较序列和其它类型</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="modules.html">6. 模块</a><ul>
<li class="toctree-l2"><a class="reference internal" href="modules.html#tut-moremodules">6.1. 深入模块</a></li>
<li class="toctree-l2"><a class="reference internal" href="modules.html#tut-standardmodules">6.2. 标准模块</a></li>
<li class="toctree-l2"><a class="reference internal" href="modules.html#dir">6.3. dir() 函数</a></li>
<li class="toctree-l2"><a class="reference internal" href="modules.html#tut-packages">6.4. 包</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="inputoutput.html">7. 输入和输出</a><ul>
<li class="toctree-l2"><a class="reference internal" href="inputoutput.html#tut-formatting">7.1. 格式化输出</a></li>
<li class="toctree-l2"><a class="reference internal" href="inputoutput.html#tut-files">7.2. 文件读写</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="errors.html">8. 错误和异常</a><ul>
<li class="toctree-l2"><a class="reference internal" href="errors.html#tut-syntaxerrors">8.1. 语法错误</a></li>
<li class="toctree-l2"><a class="reference internal" href="errors.html#tut-exceptions">8.2. 异常</a></li>
<li class="toctree-l2"><a class="reference internal" href="errors.html#tut-handling">8.3. 异常处理</a></li>
<li class="toctree-l2"><a class="reference internal" href="errors.html#tut-raising">8.4. 抛出异常</a></li>
<li class="toctree-l2"><a class="reference internal" href="errors.html#tut-userexceptions">8.5. 用户自定义异常</a></li>
<li class="toctree-l2"><a class="reference internal" href="errors.html#tut-cleanup">8.6. 定义清理行为</a></li>
<li class="toctree-l2"><a class="reference internal" href="errors.html#tut-cleanup-with">8.7. 预定义清理行为</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="classes.html">9. 类</a><ul>
<li class="toctree-l2"><a class="reference internal" href="classes.html#tut-object">9.1. 术语相关</a></li>
<li class="toctree-l2"><a class="reference internal" href="classes.html#python">9.2. Python 作用域和命名空间</a></li>
<li class="toctree-l2"><a class="reference internal" href="classes.html#tut-firstclasses">9.3. 初识类</a></li>
<li class="toctree-l2"><a class="reference internal" href="classes.html#tut-remarks">9.4. 一些说明</a></li>
<li class="toctree-l2"><a class="reference internal" href="classes.html#tut-inheritance">9.5. 继承</a></li>
<li class="toctree-l2"><a class="reference internal" href="classes.html#tut-private">9.6. 私有变量</a></li>
<li class="toctree-l2"><a class="reference internal" href="classes.html#tut-odds">9.7. 补充</a></li>
<li class="toctree-l2"><a class="reference internal" href="classes.html#tut-exceptionclasses">9.8. 异常也是类</a></li>
<li class="toctree-l2"><a class="reference internal" href="classes.html#tut-iterators">9.9. 迭代器</a></li>
<li class="toctree-l2"><a class="reference internal" href="classes.html#tut-generators">9.10. 生成器</a></li>
<li class="toctree-l2"><a class="reference internal" href="classes.html#tut-genexps">9.11. 生成器表达式</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="stdlib.html">10. Python 标准库概览</a><ul>
<li class="toctree-l2"><a class="reference internal" href="stdlib.html#tut-os-interface">10.1. 操作系统接口</a></li>
<li class="toctree-l2"><a class="reference internal" href="stdlib.html#tut-file-wildcards">10.2. 文件通配符</a></li>
<li class="toctree-l2"><a class="reference internal" href="stdlib.html#tut-command-line-arguments">10.3. 命令行参数</a></li>
<li class="toctree-l2"><a class="reference internal" href="stdlib.html#tut-stderr">10.4. 错误输出重定向和程序终止</a></li>
<li class="toctree-l2"><a class="reference internal" href="stdlib.html#tut-string-pattern-matching">10.5. 字符串正则匹配</a></li>
<li class="toctree-l2"><a class="reference internal" href="stdlib.html#tut-mathematics">10.6. 数学</a></li>
<li class="toctree-l2"><a class="reference internal" href="stdlib.html#tut-internet-access">10.7. 互联网访问</a></li>
<li class="toctree-l2"><a class="reference internal" href="stdlib.html#tut-dates-and-times">10.8. 日期和时间</a></li>
<li class="toctree-l2"><a class="reference internal" href="stdlib.html#tut-data-compression">10.9. 数据压缩</a></li>
<li class="toctree-l2"><a class="reference internal" href="stdlib.html#tut-performance-measurement">10.10. 性能度量</a></li>
<li class="toctree-l2"><a class="reference internal" href="stdlib.html#tut-quality-control">10.11. 质量控制</a></li>
<li class="toctree-l2"><a class="reference internal" href="stdlib.html#tut-batteries-included">10.12. “瑞士军刀”</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="stdlib2.html">11. 标准库浏览 – Part II</a><ul>
<li class="toctree-l2"><a class="reference internal" href="stdlib2.html#tut-output-formatting">11.1. 输出格式</a></li>
<li class="toctree-l2"><a class="reference internal" href="stdlib2.html#tut-templating">11.2. 模板</a></li>
<li class="toctree-l2"><a class="reference internal" href="stdlib2.html#tut-binary-formats">11.3. 使用二进制数据记录布局</a></li>
<li class="toctree-l2"><a class="reference internal" href="stdlib2.html#tut-multi-threading">11.4. 多线程</a></li>
<li class="toctree-l2"><a class="reference internal" href="stdlib2.html#tut-logging">11.5. 日志</a></li>
<li class="toctree-l2"><a class="reference internal" href="stdlib2.html#tut-weak-references">11.6. 弱引用</a></li>
<li class="toctree-l2"><a class="reference internal" href="stdlib2.html#tut-list-tools">11.7. 列表工具</a></li>
<li class="toctree-l2"><a class="reference internal" href="stdlib2.html#tut-decimal-fp">11.8. 十进制浮点数算法</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="venv.html">12. 虚拟环境和包</a><ul>
<li class="toctree-l2"><a class="reference internal" href="venv.html#id2">12.1. 简介</a></li>
<li class="toctree-l2"><a class="reference internal" href="venv.html#id3">12.2. 创建虚拟环境</a></li>
<li class="toctree-l2"><a class="reference internal" href="venv.html#pip">12.3. 使用 pip 管理包</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="whatnow.html">13. 接下来？</a></li>
<li class="toctree-l1"><a class="reference internal" href="interactive.html">14. 交互式输入行编辑历史回溯</a><ul>
<li class="toctree-l2"><a class="reference internal" href="interactive.html#tab">14.1. Tab 补全和历史记录</a></li>
<li class="toctree-l2"><a class="reference internal" href="interactive.html#tut-commentary">14.2. 其它交互式解释器</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="floatingpoint.html">15. 浮点数算法：争议和限制</a><ul>
<li class="toctree-l2"><a class="reference internal" href="floatingpoint.html#tut-fp-error">15.1. 表达错误</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="appendix.html">16. 附录</a><ul>
<li class="toctree-l2"><a class="reference internal" href="appendix.html#tut-interac">16.1. 交互模式</a></li>
</ul>
</li>
</ul>
</div>
</nav>
<section data-toggle="wy-nav-shift" class="wy-nav-content-wrap">
<nav class="wy-nav-top" role="navigation" aria-label="top navigation">
<i data-toggle="wy-nav-top" class="fa fa-bars"></i>
<a href="index.html">Python tutorial</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>3. Python 简介</li>
<li class="wy-breadcrumbs-aside">
<a href="_sources/introduction.txt" rel="nofollow"> View page source</a>
</li>
</ul>
<hr/>
</div>
<div role="main" class="document">
<div class="section" id="python">
<span id="tut-informal"></span><h1>3. Python 简介<a class="headerlink" href="#python" title="Permalink to this headline">¶</a></h1>
<p>下面的例子中，输入和输出分别由大于号和句号提示符（ <code class="docutils literal"><span class="pre">>>></span></code> 和 <code class="docutils literal"><span class="pre">...</span></code> ）标注：如果想重现这些例子，就要在解释器的提示符后，输入（提示符后面的）那些不包含提示符的代码行。需要注意的是在练习中遇到的从属提示符表示你需要在最后多输入一个空行，解释器才能知道这是一个多行命令的结束。</p>
<p>本手册中的很多示例——包括那些带有交互提示符的——都含有注释。Python 中的注释以 <code class="docutils literal"><span class="pre">#</span></code> 字符起始，直至实际的行尾（译注——这里原作者用了 physical line 以表示实际的换行而非编辑器的自动换行）。注释可以从行首开始，也可以在空白或代码之后，但是不出现在字符串中。文本字符串中的 <code class="docutils literal"><span class="pre">#</span></code> 字符仅仅表示 <code class="docutils literal"><span class="pre">#</span></code> 。代码中的注释不会被 Python 解释，录入示例的时候可以忽略它们。</p>
<p>如下示例:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="c"># this is the first comment</span>
<span class="n">spam</span> <span class="o">=</span> <span class="mi">1</span> <span class="c"># and this is the second comment</span>
<span class="c"># ... and now a third!</span>
<span class="n">text</span> <span class="o">=</span> <span class="s">"# This is not a comment because it's inside quotes."</span>
</pre></div>
</div>
<div class="section" id="tut-calculator">
<span id="id1"></span><h2>3.1. 将 Python 当做计算器<a class="headerlink" href="#tut-calculator" title="Permalink to this headline">¶</a></h2>
<p>我们来尝试一些简单的 Python 命令。启动解释器然后等待主提示符 <code class="docutils literal"><span class="pre">>>></span></code> 出现（不需要很久）。</p>
<div class="section" id="tut-numbers">
<span id="id2"></span><h3>3.1.1. 数字<a class="headerlink" href="#tut-numbers" title="Permalink to this headline">¶</a></h3>
<p>解释器表现得就像一个简单的计算器：可以向其录入一些表达式，它会给出返回值。表达式语法很直白：运算符 <code class="docutils literal"><span class="pre">+</span></code>，<code class="docutils literal"><span class="pre">-</span></code>，<code class="docutils literal"><span class="pre">*</span></code> 和 <code class="docutils literal"><span class="pre">/</span></code> 与其它语言一样(例如：Pascal 或 C)；括号 (<code class="docutils literal"><span class="pre">()</span></code>) 用于分组。例如:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="mi">2</span> <span class="o">+</span> <span class="mi">2</span>
<span class="go">4</span>
<span class="gp">>>> </span><span class="mi">50</span> <span class="o">-</span> <span class="mi">5</span><span class="o">*</span><span class="mi">6</span>
<span class="go">20</span>
<span class="gp">>>> </span><span class="p">(</span><span class="mi">50</span> <span class="o">-</span> <span class="mi">5</span><span class="o">*</span><span class="mi">6</span><span class="p">)</span> <span class="o">/</span> <span class="mi">4</span>
<span class="go">5.0</span>
<span class="gp">>>> </span><span class="mi">8</span> <span class="o">/</span> <span class="mi">5</span> <span class="c"># division always returns a floating point number</span>
<span class="go">1.6</span>
</pre></div>
</div>
<p>整数(例如，<code class="docutils literal"><span class="pre">2</span></code>， <code class="docutils literal"><span class="pre">4</span></code>， <code class="docutils literal"><span class="pre">20</span></code> )的类型是 <a class="reference external" href="https://docs.python.org/3/library/functions.html#int">int</a>，带有小数部分的数字(例如，<code class="docutils literal"><span class="pre">5.0</span></code>， <code class="docutils literal"><span class="pre">1.6</span></code>)的类型是 <a class="reference external" href="https://docs.python.org/3/library/functions.html#float">float</a>。在本教程的后面我们会看到更多关于数字类型的内容。</p>
<p>除法(<code class="docutils literal"><span class="pre">/</span></code>)永远返回一个浮点数。如要使用 <a class="reference external" href="https://docs.python.org/3/glossary.html#term-floor-division">floor 除法</a> 并且得到整数结果（丢掉任何小数部分），你可以使用 <code class="docutils literal"><span class="pre">//</span></code> 运算符；要计算余数你可以使用 <code class="docutils literal"><span class="pre">%</span></code></p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="mi">17</span> <span class="o">/</span> <span class="mi">3</span> <span class="c"># classic division returns a float</span>
<span class="go">5.666666666666667</span>
<span class="go">>>></span>
<span class="gp">>>> </span><span class="mi">17</span> <span class="o">//</span> <span class="mi">3</span> <span class="c"># floor division discards the fractional part</span>
<span class="go">5</span>
<span class="gp">>>> </span><span class="mi">17</span> <span class="o">%</span> <span class="mi">3</span> <span class="c"># the % operator returns the remainder of the division</span>
<span class="go">2</span>
<span class="gp">>>> </span><span class="mi">5</span> <span class="o">*</span> <span class="mi">3</span> <span class="o">+</span> <span class="mi">2</span> <span class="c"># result * divisor + remainder</span>
<span class="go">17</span>
</pre></div>
</div>
<p>通过 Python，还可以使用 <code class="docutils literal"><span class="pre">**</span></code> 运算符计算幂乘方 <a class="footnote-reference" href="#id8" id="id3">[1]</a>:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="mi">5</span> <span class="o">**</span> <span class="mi">2</span> <span class="c"># 5 squared</span>
<span class="go">25</span>
<span class="gp">>>> </span><span class="mi">2</span> <span class="o">**</span> <span class="mi">7</span> <span class="c"># 2 to the power of 7</span>
<span class="go">128</span>
</pre></div>
</div>
<p>等号( <code class="docutils literal"><span class="pre">'='</span></code> )用于给变量赋值。赋值之后，在下一个提示符之前不会有任何结果显示:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">width</span> <span class="o">=</span> <span class="mi">20</span>
<span class="gp">>>> </span><span class="n">height</span> <span class="o">=</span> <span class="mi">5</span><span class="o">*</span><span class="mi">9</span>
<span class="gp">>>> </span><span class="n">width</span> <span class="o">*</span> <span class="n">height</span>
<span class="go">900</span>
</pre></div>
</div>
<p>变量在使用前必须 “定义”(赋值)，否则会出错:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="c"># try to access an undefined variable</span>
<span class="gp">... </span><span class="n">n</span>
<span class="gt">Traceback (most recent call last):</span>
File <span class="nb">"<stdin>"</span>, line <span class="m">1</span>, in <span class="n"><module></span>
<span class="gr">NameError</span>: <span class="n">name 'n' is not defined</span>
</pre></div>
</div>
<p>浮点数有完整的支持；整数和浮点数的混合计算中，整数会被转换为浮点数:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="mi">3</span> <span class="o">*</span> <span class="mf">3.75</span> <span class="o">/</span> <span class="mf">1.5</span>
<span class="go">7.5</span>
<span class="gp">>>> </span><span class="mf">7.0</span> <span class="o">/</span> <span class="mi">2</span>
<span class="go">3.5</span>
</pre></div>
</div>
<p>交互模式中，最近一个表达式的值赋给变量 <code class="docutils literal"><span class="pre">_</span></code>。这样我们就可以把它当作一个桌面计算器，很方便的用于连续计算，例如:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">tax</span> <span class="o">=</span> <span class="mf">12.5</span> <span class="o">/</span> <span class="mi">100</span>
<span class="gp">>>> </span><span class="n">price</span> <span class="o">=</span> <span class="mf">100.50</span>
<span class="gp">>>> </span><span class="n">price</span> <span class="o">*</span> <span class="n">tax</span>
<span class="go">12.5625</span>
<span class="gp">>>> </span><span class="n">price</span> <span class="o">+</span> <span class="n">_</span>
<span class="go">113.0625</span>
<span class="gp">>>> </span><span class="nb">round</span><span class="p">(</span><span class="n">_</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
<span class="go">113.06</span>
</pre></div>
</div>
<p>此变量对于用户是只读的。不要尝试给它赋值 —— 你只会创建一个独立的同名局部变量，它屏蔽了系统内置变量的魔术效果。</p>
<p>除了 <a class="reference external" href="https://docs.python.org/3/library/functions.html#int">int</a> 和 <a class="reference external" href="https://docs.python.org/3/library/functions.html#float">float</a>，Python 还支持其它数字类型，例如 <a class="reference external" href="https://docs.python.org/3/library/decimal.html#decimal.Decimal">Decimal</a> 和 <a class="reference external" href="https://docs.python.org/3/library/fractions.html#fractions.Fraction">Fraction</a>。Python 还内建支持 <a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#typesnumeric">复数</a> ，使用后缀 <code class="docutils literal"><span class="pre">j</span></code> 或 <code class="docutils literal"><span class="pre">J</span></code> 表示虚数部分（例如，<code class="docutils literal"><span class="pre">3+5j</span></code>）。</p>
</div>
<div class="section" id="tut-strings">
<span id="id4"></span><h3>3.1.2. 字符串<a class="headerlink" href="#tut-strings" title="Permalink to this headline">¶</a></h3>
<p>相比数值，Python 也提供了可以通过几种不同方式表示的字符串。它们可以用单引号 (<code class="docutils literal"><span class="pre">'...'</span></code>) 或双引号 (<code class="docutils literal"><span class="pre">"..."</span></code>) 标识 <a class="footnote-reference" href="#id9" id="id5">[2]</a>。<code class="docutils literal"><span class="pre">\</span></code> 可以用来转义引号:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="s">'spam eggs'</span> <span class="c"># single quotes</span>
<span class="go">'spam eggs'</span>
<span class="gp">>>> </span><span class="s">'doesn</span><span class="se">\'</span><span class="s">t'</span> <span class="c"># use \' to escape the single quote...</span>
<span class="go">"doesn't"</span>
<span class="gp">>>> </span><span class="s">"doesn't"</span> <span class="c"># ...or use double quotes instead</span>
<span class="go">"doesn't"</span>
<span class="gp">>>> </span><span class="s">'"Yes," he said.'</span>
<span class="go">'"Yes," he said.'</span>
<span class="gp">>>> </span><span class="s">"</span><span class="se">\"</span><span class="s">Yes,</span><span class="se">\"</span><span class="s"> he said."</span>
<span class="go">'"Yes," he said.'</span>
<span class="gp">>>> </span><span class="s">'"Isn</span><span class="se">\'</span><span class="s">t," she said.'</span>
<span class="go">'"Isn\'t," she said.'</span>
</pre></div>
</div>
<p>在交互式解释器中，输出的字符串会用引号引起来，特殊字符会用反斜杠转义。虽然可能和输入看上去不太一样，但是两个字符串是相等的。如果字符串中只有单引号而没有双引号，就用双引号引用，否则用单引号引用。<a class="reference external" href="https://docs.python.org/3/library/functions.html#print">print()</a> 函数生成可读性更好的输出, 它会省去引号并且打印出转义后的特殊字符：</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="s">'"Isn</span><span class="se">\'</span><span class="s">t," she said.'</span>
<span class="go">'"Isn\'t," she said.'</span>
<span class="gp">>>> </span><span class="k">print</span><span class="p">(</span><span class="s">'"Isn</span><span class="se">\'</span><span class="s">t," she said.'</span><span class="p">)</span>
<span class="go">"Isn't," she said.</span>
<span class="gp">>>> </span><span class="n">s</span> <span class="o">=</span> <span class="s">'First line.</span><span class="se">\n</span><span class="s">Second line.'</span> <span class="c"># \n means newline</span>
<span class="gp">>>> </span><span class="n">s</span> <span class="c"># without print(), \n is included in the output</span>
<span class="go">'First line.\nSecond line.'</span>
<span class="gp">>>> </span><span class="k">print</span><span class="p">(</span><span class="n">s</span><span class="p">)</span> <span class="c"># with print(), \n produces a new line</span>
<span class="go">First line.</span>
<span class="go">Second line.</span>
</pre></div>
</div>
<p>如果你前面带有 <code class="docutils literal"><span class="pre">\</span></code> 的字符被当作特殊字符，你可以使用 <em>原始字符串</em>，方法是在第一个引号前面加上一个 <code class="docutils literal"><span class="pre">r</span></code>:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="k">print</span><span class="p">(</span><span class="s">'C:\some</span><span class="se">\n</span><span class="s">ame'</span><span class="p">)</span> <span class="c"># here \n means newline!</span>
<span class="go">C:\some</span>
<span class="go">ame</span>
<span class="gp">>>> </span><span class="k">print</span><span class="p">(</span><span class="s">r'C:\some\name'</span><span class="p">)</span> <span class="c"># note the r before the quote</span>
<span class="go">C:\some\name</span>
</pre></div>
</div>
<p>字符串文本能够分成多行。一种方法是使用三引号：<code class="docutils literal"><span class="pre">"""..."""</span></code> 或者 <code class="docutils literal"><span class="pre">'''...'''</span></code>。行尾换行符会被自动包含到字符串中，但是可以在行尾加上 <code class="docutils literal"><span class="pre">\</span></code> 来避免这个行为。下面的示例：
可以使用反斜杠为行结尾的连续字符串，它表示下一行在逻辑上是本行的后续内容:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="k">print</span><span class="p">(</span><span class="s">"""</span><span class="se">\</span>
<span class="s">Usage: thingy [OPTIONS]</span>
<span class="s"> -h Display this usage message</span>
<span class="s"> -H hostname Hostname to connect to</span>
<span class="s">"""</span><span class="p">)</span>
</pre></div>
</div>
<p>将生成以下输出（注意，没有开始的第一行）:</p>
<div class="highlight-text"><div class="highlight"><pre>Usage: thingy [OPTIONS]
-h Display this usage message
-H hostname Hostname to connect to
</pre></div>
</div>
<p>字符串可以由 <code class="docutils literal"><span class="pre">+</span></code> 操作符连接(粘到一起)，可以由 <code class="docutils literal"><span class="pre">*</span></code> 表示重复:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="c"># 3 times 'un', followed by 'ium'</span>
<span class="gp">>>> </span><span class="mi">3</span> <span class="o">*</span> <span class="s">'un'</span> <span class="o">+</span> <span class="s">'ium'</span>
<span class="go">'unununium'</span>
</pre></div>
</div>
<p>相邻的两个字符串文本自动连接在一起。:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="s">'Py'</span> <span class="s">'thon'</span>
<span class="go">'Python'</span>
</pre></div>
</div>
<p>它只用于两个字符串文本，不能用于字符串表达式:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">prefix</span> <span class="o">=</span> <span class="s">'Py'</span>
<span class="gp">>>> </span><span class="n">prefix</span> <span class="s">'thon'</span> <span class="c"># can't concatenate a variable and a string literal</span>
<span class="go"> ...</span>
<span class="go">SyntaxError: invalid syntax</span>
<span class="gp">>>> </span><span class="p">(</span><span class="s">'un'</span> <span class="o">*</span> <span class="mi">3</span><span class="p">)</span> <span class="s">'ium'</span>
<span class="go"> ...</span>
<span class="go">SyntaxError: invalid syntax</span>
</pre></div>
</div>
<p>如果你想连接多个变量或者连接一个变量和一个字符串文本，使用 <code class="docutils literal"><span class="pre">+</span></code>:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">prefix</span> <span class="o">+</span> <span class="s">'thon'</span>
<span class="go">'Python'</span>
</pre></div>
</div>
<p>这个功能在你想切分很长的字符串的时候特别有用:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">text</span> <span class="o">=</span> <span class="p">(</span><span class="s">'Put several strings within parentheses '</span>
<span class="go"> 'to have them joined together.')</span>
<span class="gp">>>> </span><span class="n">text</span>
<span class="go">'Put several strings within parentheses to have them joined together.'</span>
</pre></div>
</div>
<p>字符串也可以被截取(检索)。类似于 C ，字符串的第一个字符索引为 0 。Python没有单独的字符类型；一个字符就是一个简单的长度为1的字符串。:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">word</span> <span class="o">=</span> <span class="s">'Python'</span>
<span class="gp">>>> </span><span class="n">word</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="c"># character in position 0</span>
<span class="go">'P'</span>
<span class="gp">>>> </span><span class="n">word</span><span class="p">[</span><span class="mi">5</span><span class="p">]</span> <span class="c"># character in position 5</span>
<span class="go">'n'</span>
</pre></div>
</div>
<p>索引也可以是负数，这将导致从右边开始计算。例如:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">word</span><span class="p">[</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span> <span class="c"># last character</span>
<span class="go">'n'</span>
<span class="gp">>>> </span><span class="n">word</span><span class="p">[</span><span class="o">-</span><span class="mi">2</span><span class="p">]</span> <span class="c"># second-last character</span>
<span class="go">'o'</span>
<span class="gp">>>> </span><span class="n">word</span><span class="p">[</span><span class="o">-</span><span class="mi">6</span><span class="p">]</span>
<span class="go">'P'</span>
</pre></div>
</div>
<p>请注意 -0 实际上就是 0，所以它不会导致从右边开始计算。</p>
<p>除了索引，还支持 <em>切片</em>。索引用于获得单个字符，<em>切片</em> 让你获得一个子字符串:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">word</span><span class="p">[</span><span class="mi">0</span><span class="p">:</span><span class="mi">2</span><span class="p">]</span> <span class="c"># characters from position 0 (included) to 2 (excluded)</span>
<span class="go">'Py'</span>
<span class="gp">>>> </span><span class="n">word</span><span class="p">[</span><span class="mi">2</span><span class="p">:</span><span class="mi">5</span><span class="p">]</span> <span class="c"># characters from position 2 (included) to 5 (excluded)</span>
<span class="go">'tho'</span>
</pre></div>
</div>
<p>注意，包含起始的字符，不包含末尾的字符。这使得 <code class="docutils literal"><span class="pre">s[:i]</span> <span class="pre">+</span> <span class="pre">s[i:]</span></code> 永远等于 <code class="docutils literal"><span class="pre">s</span></code>:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">word</span><span class="p">[:</span><span class="mi">2</span><span class="p">]</span> <span class="o">+</span> <span class="n">word</span><span class="p">[</span><span class="mi">2</span><span class="p">:]</span>
<span class="go">'Python'</span>
<span class="gp">>>> </span><span class="n">word</span><span class="p">[:</span><span class="mi">4</span><span class="p">]</span> <span class="o">+</span> <span class="n">word</span><span class="p">[</span><span class="mi">4</span><span class="p">:]</span>
<span class="go">'Python'</span>
</pre></div>
</div>
<p>切片的索引有非常有用的默认值；省略的第一个索引默认为零，省略的第二个索引默认为切片的字符串的大小。:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">word</span><span class="p">[:</span><span class="mi">2</span><span class="p">]</span> <span class="c"># character from the beginning to position 2 (excluded)</span>
<span class="go">'Py'</span>
<span class="gp">>>> </span><span class="n">word</span><span class="p">[</span><span class="mi">4</span><span class="p">:]</span> <span class="c"># characters from position 4 (included) to the end</span>
<span class="go">'on'</span>
<span class="gp">>>> </span><span class="n">word</span><span class="p">[</span><span class="o">-</span><span class="mi">2</span><span class="p">:]</span> <span class="c"># characters from the second-last (included) to the end</span>
<span class="go">'on'</span>
</pre></div>
</div>
<p>有个办法可以很容易地记住切片的工作方式：切片时的索引是在两个字符 <em>之间</em> 。左边第一个字符的索引为 0，而长度为 <em>n</em> 的字符串其最后一个字符的右界索引为 <em>n</em>。例如:</p>
<div class="highlight-python"><div class="highlight"><pre> +---+---+---+---+---+---+
| P | y | t | h | o | n |
+---+---+---+---+---+---+
0 1 2 3 4 5 6
-6 -5 -4 -3 -2 -1
</pre></div>
</div>
<p>文本中的第一行数字给出字符串中的索引点 0...6。第二行给出相应的负索引。切片是从 <em>i</em> 到 <em>j</em> 两个数值标示的边界之间的所有字符。</p>
<p>对于非负索引，如果上下都在边界内，切片长度就是两个索引之差。例如，<code class="docutils literal"><span class="pre">word[1:3]</span></code> 是 2 。</p>
<p>试图使用太大的索引会导致错误:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">word</span><span class="p">[</span><span class="mi">42</span><span class="p">]</span> <span class="c"># the word only has 6 characters</span>
<span class="gt">Traceback (most recent call last):</span>
File <span class="nb">"<stdin>"</span>, line <span class="m">1</span>, in <span class="n"><module></span>
<span class="gr">IndexError</span>: <span class="n">string index out of range</span>
</pre></div>
</div>
<p>Python 能够优雅地处理那些没有意义的切片索引：一个过大的索引值(即下标值大于字符串实际长度)将被字符串实际长度所代替，当上边界比下边界大时(即切片左值大于右值)就返回空字符串:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">word</span><span class="p">[</span><span class="mi">4</span><span class="p">:</span><span class="mi">42</span><span class="p">]</span>
<span class="go">'on'</span>
<span class="gp">>>> </span><span class="n">word</span><span class="p">[</span><span class="mi">42</span><span class="p">:]</span>
<span class="go">''</span>
</pre></div>
</div>
<p>Python字符串不可以被更改 — 它们是 <a class="reference external" href="https://docs.python.org/3/glossary.html#term-immutable">不可变的</a> 。因此，赋值给字符串索引的位置会导致错误:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">word</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">=</span> <span class="s">'J'</span>
<span class="go"> ...</span>
<span class="go">TypeError: 'str' object does not support item assignment</span>
<span class="gp">>>> </span><span class="n">word</span><span class="p">[</span><span class="mi">2</span><span class="p">:]</span> <span class="o">=</span> <span class="s">'py'</span>
<span class="go"> ...</span>
<span class="go">TypeError: 'str' object does not support item assignment</span>
</pre></div>
</div>
<p>如果你需要一个不同的字符串，你应该创建一个新的:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="s">'J'</span> <span class="o">+</span> <span class="n">word</span><span class="p">[</span><span class="mi">1</span><span class="p">:]</span>
<span class="go">'Jython'</span>
<span class="gp">>>> </span><span class="n">word</span><span class="p">[:</span><span class="mi">2</span><span class="p">]</span> <span class="o">+</span> <span class="s">'py'</span>
<span class="go">'Pypy'</span>
</pre></div>
</div>
<p>内置函数 <a class="reference external" href="https://docs.python.org/3/library/functions.html#len">len()</a> 返回字符串长度:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">s</span> <span class="o">=</span> <span class="s">'supercalifragilisticexpialidocious'</span>
<span class="gp">>>> </span><span class="nb">len</span><span class="p">(</span><span class="n">s</span><span class="p">)</span>
<span class="go">34</span>
</pre></div>
</div>
<div class="admonition seealso">
<p class="first admonition-title">See also</p>
<dl class="last docutils">
<dt><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#textseq">Text Sequence Type — str</a></dt>
<dd>字符串是 <strong>序列类型</strong> 的例子，它们支持这种类型共同的操作。</dd>
<dt><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#string-methods">String Methods</a></dt>
<dd>字符串和Unicode字符串都支持大量的方法用于基本的转换和查找。</dd>
<dt><a class="reference external" href="https://docs.python.org/3/library/string.html#string-formatting">String Formatting</a></dt>
<dd>这里描述了使用 <a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str.format">str.format()</a> 进行字符串格式化的信息。</dd>
<dt><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#old-string-formatting">String Formatting Operations</a></dt>
<dd>这里描述了旧式的字符串格式化操作，它们在字符串和Unicode字符串是 <code class="docutils literal"><span class="pre">%</span></code> 操作符的左操作数时调用。</dd>
</dl>
</div>
</div>
<div class="section" id="tut-lists">
<span id="id6"></span><h3>3.1.3. 列表<a class="headerlink" href="#tut-lists" title="Permalink to this headline">¶</a></h3>
<p>Python 有几个 <em>复合</em> 数据类型，用于表示其它的值。最通用的是 <em>list</em> (列表) ，它可以写作中括号之间的一列逗号分隔的值。列表的元素不必是同一类型:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">squares</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">9</span><span class="p">,</span> <span class="mi">16</span><span class="p">,</span> <span class="mi">25</span><span class="p">]</span>
<span class="gp">>>> </span><span class="n">squares</span>
<span class="go">[1, 4, 9, 16, 25]</span>
</pre></div>
</div>
<p>就像字符串(以及其它所有内建的 <a class="reference external" href="https://docs.python.org/3/glossary.html#term-sequence">序列</a> 类型)一样，列表可以被索引和切片:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">squares</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="c"># indexing returns the item</span>
<span class="go">1</span>
<span class="gp">>>> </span><span class="n">squares</span><span class="p">[</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span>
<span class="go">25</span>
<span class="gp">>>> </span><span class="n">squares</span><span class="p">[</span><span class="o">-</span><span class="mi">3</span><span class="p">:]</span> <span class="c"># slicing returns a new list</span>
<span class="go">[9, 16, 25]</span>
</pre></div>
</div>
<p>所有的切片操作都会返回一个包含请求的元素的新列表。这意味着下面的切片操作返回列表一个新的（浅）拷贝副本:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">squares</span><span class="p">[:]</span>
<span class="go">[1, 4, 9, 16, 25]</span>
</pre></div>
</div>
<p>列表也支持连接这样的操作:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">squares</span> <span class="o">+</span> <span class="p">[</span><span class="mi">36</span><span class="p">,</span> <span class="mi">49</span><span class="p">,</span> <span class="mi">64</span><span class="p">,</span> <span class="mi">81</span><span class="p">,</span> <span class="mi">100</span><span class="p">]</span>
<span class="go">[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]</span>
</pre></div>
</div>
<p>不像 <em>不可变的</em> 字符串，列表是 <em>可变的</em>，它允许修改元素:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">cubes</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">8</span><span class="p">,</span> <span class="mi">27</span><span class="p">,</span> <span class="mi">65</span><span class="p">,</span> <span class="mi">125</span><span class="p">]</span> <span class="c"># something's wrong here</span>
<span class="gp">>>> </span><span class="mi">4</span> <span class="o">**</span> <span class="mi">3</span> <span class="c"># the cube of 4 is 64, not 65!</span>
<span class="go">64</span>
<span class="gp">>>> </span><span class="n">cubes</span><span class="p">[</span><span class="mi">3</span><span class="p">]</span> <span class="o">=</span> <span class="mi">64</span> <span class="c"># replace the wrong value</span>
<span class="gp">>>> </span><span class="n">cubes</span>
<span class="go">[1, 8, 27, 64, 125]</span>
</pre></div>
</div>
<p>你还可以使用 <code class="docutils literal"><span class="pre">append()</span></code> <em>方法</em> （后面我们会看到更多关于列表的方法的内容）在列表的末尾添加新的元素:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">cubes</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="mi">216</span><span class="p">)</span> <span class="c"># add the cube of 6</span>
<span class="gp">>>> </span><span class="n">cubes</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="mi">7</span> <span class="o">**</span> <span class="mi">3</span><span class="p">)</span> <span class="c"># and the cube of 7</span>
<span class="gp">>>> </span><span class="n">cubes</span>
<span class="go">[1, 8, 27, 64, 125, 216, 343]</span>
</pre></div>
</div>
<p>也可以对切片赋值，此操作可以改变列表的尺寸，或清空它:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">letters</span> <span class="o">=</span> <span class="p">[</span><span class="s">'a'</span><span class="p">,</span> <span class="s">'b'</span><span class="p">,</span> <span class="s">'c'</span><span class="p">,</span> <span class="s">'d'</span><span class="p">,</span> <span class="s">'e'</span><span class="p">,</span> <span class="s">'f'</span><span class="p">,</span> <span class="s">'g'</span><span class="p">]</span>
<span class="gp">>>> </span><span class="n">letters</span>
<span class="go">['a', 'b', 'c', 'd', 'e', 'f', 'g']</span>
<span class="gp">>>> </span><span class="c"># replace some values</span>
<span class="gp">>>> </span><span class="n">letters</span><span class="p">[</span><span class="mi">2</span><span class="p">:</span><span class="mi">5</span><span class="p">]</span> <span class="o">=</span> <span class="p">[</span><span class="s">'C'</span><span class="p">,</span> <span class="s">'D'</span><span class="p">,</span> <span class="s">'E'</span><span class="p">]</span>
<span class="gp">>>> </span><span class="n">letters</span>
<span class="go">['a', 'b', 'C', 'D', 'E', 'f', 'g']</span>
<span class="gp">>>> </span><span class="c"># now remove them</span>
<span class="gp">>>> </span><span class="n">letters</span><span class="p">[</span><span class="mi">2</span><span class="p">:</span><span class="mi">5</span><span class="p">]</span> <span class="o">=</span> <span class="p">[]</span>
<span class="gp">>>> </span><span class="n">letters</span>
<span class="go">['a', 'b', 'f', 'g']</span>
<span class="gp">>>> </span><span class="c"># clear the list by replacing all the elements with an empty list</span>
<span class="gp">>>> </span><span class="n">letters</span><span class="p">[:]</span> <span class="o">=</span> <span class="p">[]</span>
<span class="gp">>>> </span><span class="n">letters</span>
<span class="go">[]</span>
</pre></div>
</div>
<p>内置函数 <a class="reference external" href="https://docs.python.org/3/library/functions.html#len">len()</a> 同样适用于列表:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">letters</span> <span class="o">=</span> <span class="p">[</span><span class="s">'a'</span><span class="p">,</span> <span class="s">'b'</span><span class="p">,</span> <span class="s">'c'</span><span class="p">,</span> <span class="s">'d'</span><span class="p">]</span>
<span class="gp">>>> </span><span class="nb">len</span><span class="p">(</span><span class="n">letters</span><span class="p">)</span>
<span class="go">4</span>
</pre></div>
</div>
<p>允许嵌套列表(创建一个包含其它列表的列表)，例如:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">a</span> <span class="o">=</span> <span class="p">[</span><span class="s">'a'</span><span class="p">,</span> <span class="s">'b'</span><span class="p">,</span> <span class="s">'c'</span><span class="p">]</span>
<span class="gp">>>> </span><span class="n">n</span> <span class="o">=</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="gp">>>> </span><span class="n">x</span> <span class="o">=</span> <span class="p">[</span><span class="n">a</span><span class="p">,</span> <span class="n">n</span><span class="p">]</span>
<span class="gp">>>> </span><span class="n">x</span>
<span class="go">[['a', 'b', 'c'], [1, 2, 3]]</span>
<span class="gp">>>> </span><span class="n">x</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
<span class="go">['a', 'b', 'c']</span>
<span class="gp">>>> </span><span class="n">x</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="go">'b'</span>
</pre></div>
</div>
</div>
</div>
<div class="section" id="tut-firststeps">
<span id="id7"></span><h2>3.2. 编程的第一步<a class="headerlink" href="#tut-firststeps" title="Permalink to this headline">¶</a></h2>
<p>当然，我们可以使用 Python 完成比二加二更复杂的任务。例如，我们可以写一个生成 <em>菲波那契</em> 子序列的程序，如下所示:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="c"># Fibonacci series:</span>
<span class="gp">... </span><span class="c"># the sum of two elements defines the next</span>
<span class="gp">... </span><span class="n">a</span><span class="p">,</span> <span class="n">b</span> <span class="o">=</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">1</span>
<span class="gp">>>> </span><span class="k">while</span> <span class="n">b</span> <span class="o"><</span> <span class="mi">10</span><span class="p">:</span>
<span class="gp">... </span> <span class="k">print</span><span class="p">(</span><span class="n">b</span><span class="p">)</span>
<span class="gp">... </span> <span class="n">a</span><span class="p">,</span> <span class="n">b</span> <span class="o">=</span> <span class="n">b</span><span class="p">,</span> <span class="n">a</span><span class="o">+</span><span class="n">b</span>
<span class="gp">...</span>
<span class="go">1</span>
<span class="go">1</span>
<span class="go">2</span>
<span class="go">3</span>
<span class="go">5</span>
<span class="go">8</span>
</pre></div>
</div>
<p>这个例子介绍了几个新功能。</p>
<ul>
<li><p class="first">第一行包括了一个 <em>多重赋值</em>：变量 <code class="docutils literal"><span class="pre">a</span></code> 和 <code class="docutils literal"><span class="pre">b</span></code> 同时获得了新的值 0 和 1 最后一行又使用了一次。</p>
<p>在这个演示中，变量赋值前，右边首先完成计算。右边的表达式从左到右计算。</p>
</li>
<li><p class="first">条件（这里是 <code class="docutils literal"><span class="pre">b</span> <span class="pre"><</span> <span class="pre">10</span></code> ）为 true 时， <a class="reference external" href="https://docs.python.org/3/reference/compound_stmts.html#while">while</a> 循环执行。在 Python 中，类似于 C，任何非零整数都是 true；0 是 false 条件也可以是字符串或列表，实际上可以是任何序列；</p>
<p>所有长度不为零的是 true，空序列是 false。示例中的测试是一个简单的比较。标准比较操作符与 C 相同： <code class="docutils literal"><span class="pre"><</span></code> ， <code class="docutils literal"><span class="pre">></span></code> ， <code class="docutils literal"><span class="pre">==</span></code> ， <code class="docutils literal"><span class="pre"><=</span></code>， <code class="docutils literal"><span class="pre">>=</span></code> 和 <code class="docutils literal"><span class="pre">!=</span></code>。</p>
</li>
<li><p class="first">循环 <em>体</em> 是 <em>缩进</em> 的：缩进是 Python 是 Python 组织語句的方法。Python (还)不提供集成的行编辑功能，所以你要为每一个缩进行输入 TAB 或空格。</p>
<p>实践中建议你找个文本编辑来录入复杂的 Python 程序，大多数文本编辑器提供自动缩进。交互式录入复合语句时，必须在最后输入一个空行来标识结束（因为解释器没办法猜测你输入的哪一行是最后一行），需要 注意的是同一个语句块中的语句块必须缩进同样数量的空白。</p>
</li>
<li><p class="first">关键字 <a class="reference external" href="https://docs.python.org/3/library/functions.html#print">print()</a> 语句输出给定表达式的值。它控制多个表达式和字符串输出为你想要字符串（就像我们在前面计算器的例子中那样）。</p>
<p>字符串打印时不用引号包围，每两个子项之间插入空间，所以你可以把格式弄得很漂亮，像这样:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">i</span> <span class="o">=</span> <span class="mi">256</span><span class="o">*</span><span class="mi">256</span>
<span class="gp">>>> </span><span class="k">print</span><span class="p">(</span><span class="s">'The value of i is'</span><span class="p">,</span> <span class="n">i</span><span class="p">)</span>
<span class="go">The value of i is 65536</span>
</pre></div>
</div>
<p>用一个逗号结尾就可以禁止输出换行:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">a</span><span class="p">,</span> <span class="n">b</span> <span class="o">=</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">1</span>
<span class="gp">>>> </span><span class="k">while</span> <span class="n">b</span> <span class="o"><</span> <span class="mi">1000</span><span class="p">:</span>
<span class="gp">... </span> <span class="k">print</span><span class="p">(</span><span class="n">b</span><span class="p">,</span> <span class="n">end</span><span class="o">=</span><span class="s">','</span><span class="p">)</span>
<span class="gp">... </span> <span class="n">a</span><span class="p">,</span> <span class="n">b</span> <span class="o">=</span> <span class="n">b</span><span class="p">,</span> <span class="n">a</span><span class="o">+</span><span class="n">b</span>
<span class="gp">...</span>
<span class="go">1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,</span>
</pre></div>
</div>
</li>
</ul>
<p class="rubric">Footnotes</p>
<table class="docutils footnote" frame="void" id="id8" rules="none">
<colgroup><col class="label" /><col /></colgroup>
<tbody valign="top">
<tr><td class="label"><a class="fn-backref" href="#id3">[1]</a></td><td>因为 <code class="docutils literal"><span class="pre">**</span></code> 的优先级高于 <code class="docutils literal"><span class="pre">-</span></code>，所以 <code class="docutils literal"><span class="pre">-3**2</span></code> 将解释为 <code class="docutils literal"><span class="pre">-(3**2)</span></code> 且结果为 <code class="docutils literal"><span class="pre">-9</span></code>。为了避免这点并得到 <code class="docutils literal"><span class="pre">9</span></code>，你可以使用 <code class="docutils literal"><span class="pre">(-3)**2</span></code>。</td></tr>
</tbody>
</table>
<table class="docutils footnote" frame="void" id="id9" rules="none">
<colgroup><col class="label" /><col /></colgroup>
<tbody valign="top">
<tr><td class="label"><a class="fn-backref" href="#id5">[2]</a></td><td>与其它语言不同，特殊字符例如 <code class="docutils literal"><span class="pre">\n</span></code> 在单引号(<code class="docutils literal"><span class="pre">'...'</span></code>)和双引号(<code class="docutils literal"><span class="pre">"..."</span></code>)中具有相同的含义。两者唯一的区别是在单引号中，你不需要转义 <code class="docutils literal"><span class="pre">"</span></code> （但你必须转义 <code class="docutils literal"><span class="pre">\'</span></code> )，反之亦然。</td></tr>
</tbody>
</table>
</div>
</div>
</div>
<footer>
<div class="rst-footer-buttons" role="navigation" aria-label="footer navigation">
<a href="controlflow.html" class="btn btn-neutral float-right" title="4. 深入 Python 流程控制">Next <span class="fa fa-arrow-circle-right"></span></a>
<a href="interpreter.html" class="btn btn-neutral" title="2. 使用 Python 解释器"><span class="fa fa-arrow-circle-left"></span> Previous</a>
</div>
<hr/>
<div role="contentinfo">
<p>
© Copyright 2013, D.D.
</p>
</div>
Built with <a href="http://sphinx-doc.org/">Sphinx</a> using a <a href="https://github.com/snide/sphinx_rtd_theme">theme</a> provided by <a href="https://readthedocs.org">Read the Docs</a>.
</footer>
</div>
</div>
</section>
</div>
<script type="text/javascript">
var DOCUMENTATION_OPTIONS = {
URL_ROOT:'./',
VERSION:'3.5.1',
COLLAPSE_INDEX:false,
FILE_SUFFIX:'.html',
HAS_SOURCE: true
};
</script>
<script type="text/javascript" src="_static/jquery.js"></script>
<script type="text/javascript" src="_static/underscore.js"></script>
<script type="text/javascript" src="_static/doctools.js"></script>
<script type="text/javascript" src="_static/js/theme.js"></script>
<script type="text/javascript">
jQuery(function () {
SphinxRtdTheme.StickyNav.enable();
});
</script>
</body>
</html>