-
Notifications
You must be signed in to change notification settings - Fork 1
/
Copy path15-cls-object.html
491 lines (471 loc) · 32.7 KB
/
15-cls-object.html
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
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>Classes and objects — Pense Python 2e documentation</title>
<link rel="stylesheet" href="_static/alabaster.css" type="text/css" />
<link rel="stylesheet" href="_static/pygments.css" type="text/css" />
<script type="text/javascript">
var DOCUMENTATION_OPTIONS = {
URL_ROOT: './',
VERSION: '2e',
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>
<link rel="top" title="Pense Python 2e documentation" href="index.html" />
<link rel="next" title="Classes and functions" href="16-cls-fn.html" />
<link rel="prev" title="Files" href="14-file.html" />
<meta name="viewport" content="width=device-width, initial-scale=0.9, maximum-scale=0.9">
</head>
<body role="document">
<div class="document">
<div class="documentwrapper">
<div class="bodywrapper">
<div class="body" role="main">
<div class="section" id="classes-and-objects">
<h1>Classes and objects<a class="headerlink" href="#classes-and-objects" title="Permalink to this headline">¶</a></h1>
<p>At this point you know how to use functions to organize code and
built-in types to organize data. The next step is to learn
“object-oriented programming”, which uses programmer-defined types to
organize both code and data. Object-oriented programming is a big topic;
it will take a few chapters to get there.</p>
<p>Code examples from this chapter are available from
<a class="reference external" href="http://thinkpython2.com/code/Point1.py">http://thinkpython2.com/code/Point1.py</a>; solutions to the exercises are
available from <a class="reference external" href="http://thinkpython2.com/code/Point1_soln.py">http://thinkpython2.com/code/Point1_soln.py</a>.</p>
<div class="section" id="programmer-defined-types">
<h2>Programmer-defined types<a class="headerlink" href="#programmer-defined-types" title="Permalink to this headline">¶</a></h2>
<p>We have used many of Python’s built-in types; now we are going to define
a new type. As an example, we will create a type called Point that
represents a point in two-dimensional space.</p>
<p>In mathematical notation, points are often written in parentheses with a
comma separating the coordinates. For example, <span class="math">(0,0)</span> represents
the origin, and <span class="math">(x,y)</span> represents the point <span class="math">x</span> units to
the right and <span class="math">y</span> units up from the origin.</p>
<p>There are several ways we might represent points in Python:</p>
<ul class="simple">
<li>We could store the coordinates separately in two variables, x and y.</li>
<li>We could store the coordinates as elements in a list or tuple.</li>
<li>We could create a new type to represent points as objects.</li>
</ul>
<p>Creating a new type is more complicated than the other options, but it
has advantages that will be apparent soon.</p>
<p>A programmer-defined type is also called a <strong>class</strong>. A class definition
looks like this:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="k">class</span> <span class="nc">Point</span><span class="p">:</span>
<span class="sd">"""Represents a point in 2-D space."""</span>
</pre></div>
</div>
<p>The header indicates that the new class is called Point. The body is a
docstring that explains what the class is for. You can define variables
and methods inside a class definition, but we will get back to that
later.</p>
<p>Defining a class named Point creates a <strong>class object</strong>.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">Point</span>
<span class="go"><class '__main__.Point'></span>
</pre></div>
</div>
<p>Because Point is defined at the top level, its “full name” is
<code class="docutils literal"><span class="pre">__main__.Point</span></code>.</p>
<p>The class object is like a factory for creating objects. To create a
Point, you call Point as if it were a function.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">blank</span> <span class="o">=</span> <span class="n">Point</span><span class="p">()</span>
<span class="gp">>>> </span><span class="n">blank</span>
<span class="go"><__main__.Point object at 0xb7e9d3ac></span>
</pre></div>
</div>
<p>The return value is a reference to a Point object, which we assign to
blank.</p>
<p>Creating a new object is called <strong>instantiation</strong>, and the object is an
<strong>instance</strong> of the class.</p>
<p>When you print an instance, Python tells you what class it belongs to
and where it is stored in memory (the prefix 0x means that the following
number is in hexadecimal).</p>
<p>Every object is an instance of some class, so “object” and “instance”
are interchangeable. But in this chapter I use “instance” to indicate
that I am talking about a programmer-defined type.</p>
</div>
<div class="section" id="attributes">
<h2>Attributes<a class="headerlink" href="#attributes" title="Permalink to this headline">¶</a></h2>
<p>You can assign values to an instance using dot notation:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">blank</span><span class="o">.</span><span class="n">x</span> <span class="o">=</span> <span class="mf">3.0</span>
<span class="gp">>>> </span><span class="n">blank</span><span class="o">.</span><span class="n">y</span> <span class="o">=</span> <span class="mf">4.0</span>
</pre></div>
</div>
<p>This syntax is similar to the syntax for selecting a variable from a
module, such as math.pi or string.whitespace. In this case, though, we
are assigning values to named elements of an object. These elements are
called <strong>attributes</strong>.</p>
<p>As a noun, “AT-trib-ute” is pronounced with emphasis on the first
syllable, as opposed to “a-TRIB-ute”, which is a verb.</p>
<p>The following diagram shows the result of these assignments. A state
diagram that shows an object and its attributes is called an <strong>object
diagram</strong>; see Figure [fig.point].</p>
<div class="figure" id="id1">
<img alt="Object diagram." src="_images/point.pdf" />
<p class="caption"><span class="caption-text">Object diagram.</span></p>
</div>
<p>The variable blank refers to a Point object, which contains two
attributes. Each attribute refers to a floating-point number.</p>
<p>You can read the value of an attribute using the same syntax:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">blank</span><span class="o">.</span><span class="n">y</span>
<span class="go">4.0</span>
<span class="gp">>>> </span><span class="n">x</span> <span class="o">=</span> <span class="n">blank</span><span class="o">.</span><span class="n">x</span>
<span class="gp">>>> </span><span class="n">x</span>
<span class="go">3.0</span>
</pre></div>
</div>
<p>The expression blank.x means, “Go to the object blank refers to and get
the value of x.” In the example, we assign that value to a variable
named x. There is no conflict between the variable x and the attribute
x.</p>
<p>You can use dot notation as part of any expression. For example:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="s">'(</span><span class="si">%g</span><span class="s">, </span><span class="si">%g</span><span class="s">)'</span> <span class="o">%</span> <span class="p">(</span><span class="n">blank</span><span class="o">.</span><span class="n">x</span><span class="p">,</span> <span class="n">blank</span><span class="o">.</span><span class="n">y</span><span class="p">)</span>
<span class="go">'(3.0, 4.0)'</span>
<span class="gp">>>> </span><span class="n">distance</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="n">blank</span><span class="o">.</span><span class="n">x</span><span class="o">**</span><span class="mi">2</span> <span class="o">+</span> <span class="n">blank</span><span class="o">.</span><span class="n">y</span><span class="o">**</span><span class="mi">2</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">distance</span>
<span class="go">5.0</span>
</pre></div>
</div>
<p>You can pass an instance as an argument in the usual way. For example:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="k">def</span> <span class="nf">print_point</span><span class="p">(</span><span class="n">p</span><span class="p">):</span>
<span class="k">print</span><span class="p">(</span><span class="s">'(</span><span class="si">%g</span><span class="s">, </span><span class="si">%g</span><span class="s">)'</span> <span class="o">%</span> <span class="p">(</span><span class="n">p</span><span class="o">.</span><span class="n">x</span><span class="p">,</span> <span class="n">p</span><span class="o">.</span><span class="n">y</span><span class="p">))</span>
</pre></div>
</div>
<p><code class="docutils literal"><span class="pre">print_point</span></code> takes a point as an argument and displays it in
mathematical notation. To invoke it, you can pass blank as an argument:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">print_point</span><span class="p">(</span><span class="n">blank</span><span class="p">)</span>
<span class="go">(3.0, 4.0)</span>
</pre></div>
</div>
<p>Inside the function, p is an alias for blank, so if the function
modifies p, blank changes.</p>
<p>As an exercise, write a function called <code class="docutils literal"><span class="pre">distance_between_points</span></code> that
takes two Points as arguments and returns the distance between them.</p>
</div>
<div class="section" id="rectangles">
<h2>Rectangles<a class="headerlink" href="#rectangles" title="Permalink to this headline">¶</a></h2>
<p>Sometimes it is obvious what the attributes of an object should be, but
other times you have to make decisions. For example, imagine you are
designing a class to represent rectangles. What attributes would you use
to specify the location and size of a rectangle? You can ignore angle;
to keep things simple, assume that the rectangle is either vertical or
horizontal.</p>
<p>There are at least two possibilities:</p>
<ul class="simple">
<li>You could specify one corner of the rectangle (or the center), the
width, and the height.</li>
<li>You could specify two opposing corners.</li>
</ul>
<p>At this point it is hard to say whether either is better than the other,
so we’ll implement the first one, just as an example.</p>
<p>Here is the class definition:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="k">class</span> <span class="nc">Rectangle</span><span class="p">:</span>
<span class="sd">"""Represents a rectangle.</span>
<span class="sd"> attributes: width, height, corner.</span>
<span class="sd"> """</span>
</pre></div>
</div>
<p>The docstring lists the attributes: width and height are numbers; corner
is a Point object that specifies the lower-left corner.</p>
<p>To represent a rectangle, you have to instantiate a Rectangle object and
assign values to the attributes:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="n">box</span> <span class="o">=</span> <span class="n">Rectangle</span><span class="p">()</span>
<span class="n">box</span><span class="o">.</span><span class="n">width</span> <span class="o">=</span> <span class="mf">100.0</span>
<span class="n">box</span><span class="o">.</span><span class="n">height</span> <span class="o">=</span> <span class="mf">200.0</span>
<span class="n">box</span><span class="o">.</span><span class="n">corner</span> <span class="o">=</span> <span class="n">Point</span><span class="p">()</span>
<span class="n">box</span><span class="o">.</span><span class="n">corner</span><span class="o">.</span><span class="n">x</span> <span class="o">=</span> <span class="mf">0.0</span>
<span class="n">box</span><span class="o">.</span><span class="n">corner</span><span class="o">.</span><span class="n">y</span> <span class="o">=</span> <span class="mf">0.0</span>
</pre></div>
</div>
<p>The expression box.corner.x means, “Go to the object box refers to and
select the attribute named corner; then go to that object and select the
attribute named x.”</p>
<div class="figure" id="id2">
<img alt="Object diagram." src="_images/rectangle.pdf" />
<p class="caption"><span class="caption-text">Object diagram.</span></p>
</div>
<p>Figure [fig.rectangle] shows the state of this object. An object that is
an attribute of another object is <strong>embedded</strong>.</p>
</div>
<div class="section" id="instances-as-return-values">
<h2>Instances as return values<a class="headerlink" href="#instances-as-return-values" title="Permalink to this headline">¶</a></h2>
<p>Functions can return instances. For example, <code class="docutils literal"><span class="pre">find_center</span></code> takes a
Rectangle as an argument and returns a Point that contains the
coordinates of the center of the Rectangle:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="k">def</span> <span class="nf">find_center</span><span class="p">(</span><span class="n">rect</span><span class="p">):</span>
<span class="n">p</span> <span class="o">=</span> <span class="n">Point</span><span class="p">()</span>
<span class="n">p</span><span class="o">.</span><span class="n">x</span> <span class="o">=</span> <span class="n">rect</span><span class="o">.</span><span class="n">corner</span><span class="o">.</span><span class="n">x</span> <span class="o">+</span> <span class="n">rect</span><span class="o">.</span><span class="n">width</span><span class="o">/</span><span class="mi">2</span>
<span class="n">p</span><span class="o">.</span><span class="n">y</span> <span class="o">=</span> <span class="n">rect</span><span class="o">.</span><span class="n">corner</span><span class="o">.</span><span class="n">y</span> <span class="o">+</span> <span class="n">rect</span><span class="o">.</span><span class="n">height</span><span class="o">/</span><span class="mi">2</span>
<span class="k">return</span> <span class="n">p</span>
</pre></div>
</div>
<p>Here is an example that passes box as an argument and assigns the
resulting Point to center:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">center</span> <span class="o">=</span> <span class="n">find_center</span><span class="p">(</span><span class="n">box</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">print_point</span><span class="p">(</span><span class="n">center</span><span class="p">)</span>
<span class="go">(50, 100)</span>
</pre></div>
</div>
</div>
<div class="section" id="objects-are-mutable">
<h2>Objects are mutable<a class="headerlink" href="#objects-are-mutable" title="Permalink to this headline">¶</a></h2>
<p>You can change the state of an object by making an assignment to one of
its attributes. For example, to change the size of a rectangle without
changing its position, you can modify the values of width and height:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="n">box</span><span class="o">.</span><span class="n">width</span> <span class="o">=</span> <span class="n">box</span><span class="o">.</span><span class="n">width</span> <span class="o">+</span> <span class="mi">50</span>
<span class="n">box</span><span class="o">.</span><span class="n">height</span> <span class="o">=</span> <span class="n">box</span><span class="o">.</span><span class="n">height</span> <span class="o">+</span> <span class="mi">100</span>
</pre></div>
</div>
<p>You can also write functions that modify objects. For example,
<code class="docutils literal"><span class="pre">grow_rectangle</span></code> takes a Rectangle object and two numbers, dwidth and
dheight, and adds the numbers to the width and height of the rectangle:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="k">def</span> <span class="nf">grow_rectangle</span><span class="p">(</span><span class="n">rect</span><span class="p">,</span> <span class="n">dwidth</span><span class="p">,</span> <span class="n">dheight</span><span class="p">):</span>
<span class="n">rect</span><span class="o">.</span><span class="n">width</span> <span class="o">+=</span> <span class="n">dwidth</span>
<span class="n">rect</span><span class="o">.</span><span class="n">height</span> <span class="o">+=</span> <span class="n">dheight</span>
</pre></div>
</div>
<p>Here is an example that demonstrates the effect:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">box</span><span class="o">.</span><span class="n">width</span><span class="p">,</span> <span class="n">box</span><span class="o">.</span><span class="n">height</span>
<span class="go">(150.0, 300.0)</span>
<span class="gp">>>> </span><span class="n">grow_rectangle</span><span class="p">(</span><span class="n">box</span><span class="p">,</span> <span class="mi">50</span><span class="p">,</span> <span class="mi">100</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">box</span><span class="o">.</span><span class="n">width</span><span class="p">,</span> <span class="n">box</span><span class="o">.</span><span class="n">height</span>
<span class="go">(200.0, 400.0)</span>
</pre></div>
</div>
<p>Inside the function, rect is an alias for box, so when the function
modifies rect, box changes.</p>
<p>As an exercise, write a function named <code class="docutils literal"><span class="pre">move_rectangle</span></code> that takes a
Rectangle and two numbers named dx and dy. It should change the location
of the rectangle by adding dx to the x coordinate of corner and adding
dy to the y coordinate of corner.</p>
</div>
<div class="section" id="copying">
<h2>Copying<a class="headerlink" href="#copying" title="Permalink to this headline">¶</a></h2>
<p>Aliasing can make a program difficult to read because changes in one
place might have unexpected effects in another place. It is hard to keep
track of all the variables that might refer to a given object.</p>
<p>Copying an object is often an alternative to aliasing. The copy module
contains a function called copy that can duplicate any object:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">p1</span> <span class="o">=</span> <span class="n">Point</span><span class="p">()</span>
<span class="gp">>>> </span><span class="n">p1</span><span class="o">.</span><span class="n">x</span> <span class="o">=</span> <span class="mf">3.0</span>
<span class="gp">>>> </span><span class="n">p1</span><span class="o">.</span><span class="n">y</span> <span class="o">=</span> <span class="mf">4.0</span>
<span class="gp">>>> </span><span class="kn">import</span> <span class="nn">copy</span>
<span class="gp">>>> </span><span class="n">p2</span> <span class="o">=</span> <span class="n">copy</span><span class="o">.</span><span class="n">copy</span><span class="p">(</span><span class="n">p1</span><span class="p">)</span>
</pre></div>
</div>
<p>p1 and p2 contain the same data, but they are not the same Point.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">print_point</span><span class="p">(</span><span class="n">p1</span><span class="p">)</span>
<span class="go">(3, 4)</span>
<span class="gp">>>> </span><span class="n">print_point</span><span class="p">(</span><span class="n">p2</span><span class="p">)</span>
<span class="go">(3, 4)</span>
<span class="gp">>>> </span><span class="n">p1</span> <span class="ow">is</span> <span class="n">p2</span>
<span class="go">False</span>
<span class="gp">>>> </span><span class="n">p1</span> <span class="o">==</span> <span class="n">p2</span>
<span class="go">False</span>
</pre></div>
</div>
<p>The is operator indicates that p1 and p2 are not the same object, which
is what we expected. But you might have expected == to yield True
because these points contain the same data. In that case, you will be
disappointed to learn that for instances, the default behavior of the ==
operator is the same as the is operator; it checks object identity, not
object equivalence. That’s because for programmer-defined types, Python
doesn’t know what should be considered equivalent. At least, not yet.</p>
<p>If you use copy.copy to duplicate a Rectangle, you will find that it
copies the Rectangle object but not the embedded Point.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">box2</span> <span class="o">=</span> <span class="n">copy</span><span class="o">.</span><span class="n">copy</span><span class="p">(</span><span class="n">box</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">box2</span> <span class="ow">is</span> <span class="n">box</span>
<span class="go">False</span>
<span class="gp">>>> </span><span class="n">box2</span><span class="o">.</span><span class="n">corner</span> <span class="ow">is</span> <span class="n">box</span><span class="o">.</span><span class="n">corner</span>
<span class="go">True</span>
</pre></div>
</div>
<div class="figure" id="id3">
<img alt="Object diagram." src="_images/rectangle2.pdf" />
<p class="caption"><span class="caption-text">Object diagram.</span></p>
</div>
<p>Figure [fig.rectangle2] shows what the object diagram looks like. This
operation is called a <strong>shallow copy</strong> because it copies the object and
any references it contains, but not the embedded objects.</p>
<p>For most applications, this is not what you want. In this example,
invoking <code class="docutils literal"><span class="pre">grow_rectangle</span></code> on one of the Rectangles would not affect
the other, but invoking <code class="docutils literal"><span class="pre">move_rectangle</span></code> on either would affect both!
This behavior is confusing and error-prone.</p>
<p>Fortunately, the copy module provides a method named deepcopy that
copies not only the object but also the objects it refers to, and the
objects <em>they</em> refer to, and so on. You will not be surprised to learn
that this operation is called a <strong>deep copy</strong>.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">box3</span> <span class="o">=</span> <span class="n">copy</span><span class="o">.</span><span class="n">deepcopy</span><span class="p">(</span><span class="n">box</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">box3</span> <span class="ow">is</span> <span class="n">box</span>
<span class="go">False</span>
<span class="gp">>>> </span><span class="n">box3</span><span class="o">.</span><span class="n">corner</span> <span class="ow">is</span> <span class="n">box</span><span class="o">.</span><span class="n">corner</span>
<span class="go">False</span>
</pre></div>
</div>
<p>box3 and box are completely separate objects.</p>
<p>As an exercise, write a version of <code class="docutils literal"><span class="pre">move_rectangle</span></code> that creates and
returns a new Rectangle instead of modifying the old one.</p>
</div>
<div class="section" id="debugging">
<h2>Debugging<a class="headerlink" href="#debugging" title="Permalink to this headline">¶</a></h2>
<p>When you start working with objects, you are likely to encounter some
new exceptions. If you try to access an attribute that doesn’t exist,
you get an AttributeError:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">p</span> <span class="o">=</span> <span class="n">Point</span><span class="p">()</span>
<span class="gp">>>> </span><span class="n">p</span><span class="o">.</span><span class="n">x</span> <span class="o">=</span> <span class="mi">3</span>
<span class="gp">>>> </span><span class="n">p</span><span class="o">.</span><span class="n">y</span> <span class="o">=</span> <span class="mi">4</span>
<span class="gp">>>> </span><span class="n">p</span><span class="o">.</span><span class="n">z</span>
<span class="go">AttributeError: Point instance has no attribute 'z'</span>
</pre></div>
</div>
<p>If you are not sure what type an object is, you can ask:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="nb">type</span><span class="p">(</span><span class="n">p</span><span class="p">)</span>
<span class="go"><class '__main__.Point'></span>
</pre></div>
</div>
<p>You can also use isinstance to check whether an object is an instance of
a class:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="nb">isinstance</span><span class="p">(</span><span class="n">p</span><span class="p">,</span> <span class="n">Point</span><span class="p">)</span>
<span class="go">True</span>
</pre></div>
</div>
<p>If you are not sure whether an object has a particular attribute, you
can use the built-in function hasattr:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="nb">hasattr</span><span class="p">(</span><span class="n">p</span><span class="p">,</span> <span class="s">'x'</span><span class="p">)</span>
<span class="go">True</span>
<span class="gp">>>> </span><span class="nb">hasattr</span><span class="p">(</span><span class="n">p</span><span class="p">,</span> <span class="s">'z'</span><span class="p">)</span>
<span class="go">False</span>
</pre></div>
</div>
<p>The first argument can be any object; the second argument is a <em>string</em>
that contains the name of the attribute.</p>
<p>You can also use a try statement to see if the object has the attributes
you need:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="k">try</span><span class="p">:</span>
<span class="n">x</span> <span class="o">=</span> <span class="n">p</span><span class="o">.</span><span class="n">x</span>
<span class="k">except</span> <span class="ne">AttributeError</span><span class="p">:</span>
<span class="n">x</span> <span class="o">=</span> <span class="mi">0</span>
</pre></div>
</div>
<p>This approach can make it easier to write functions that work with
different types; more on that topic is coming up in
Section [polymorphism].</p>
</div>
<div class="section" id="glossary">
<span id="glossary15"></span><h2>Glossary<a class="headerlink" href="#glossary" title="Permalink to this headline">¶</a></h2>
<dl class="docutils">
<dt>classe (<em>class</em>)</dt>
<dd>A programmer-defined type. A class definition creates a new class object.</dd>
<dt>objeto-classe (<em>class object</em>)</dt>
<dd>An object that contains information about a programmer-defined type. The class object can be used to create instances of the type.</dd>
<dt>instância (<em>instance</em>)</dt>
<dd>An object that belongs to a class.</dd>
<dt>instanciar (<em>instantiate</em>)</dt>
<dd>To create a new object.</dd>
<dt>atributo (<em>attribute</em>)</dt>
<dd>One of the named values associated with an object.</dd>
<dt>objeto embutido (<em>embedded object</em>)</dt>
<dd>An object that is stored as an attribute of another object.</dd>
<dt>cópia rasa (<em>shallow copy</em>)</dt>
<dd>To copy the contents of an object, including any references to embedded objects; implemented by the copy function in the copy module.</dd>
<dt>cópia profunda (<em>deep copy</em>)</dt>
<dd>To copy the contents of an object as well as any embedded objects, and any objects embedded in them, and so on; implemented by the deepcopy function in the copy module.</dd>
<dt>diagrama de objetos (<em>object diagram</em>)</dt>
<dd>A diagram that shows objects, their attributes, and the values of the attributes.</dd>
</dl>
</div>
<div class="section" id="exercises">
<h2>Exercises<a class="headerlink" href="#exercises" title="Permalink to this headline">¶</a></h2>
<p>Write a definition for a class named Circle with attributes center and
radius, where center is a Point object and radius is a number.</p>
<p>Instantiate a Circle object that represents a circle with its center at
<span class="math">(150, 100)</span> and radius 75.</p>
<p>Write a function named <code class="docutils literal"><span class="pre">point_in_circle</span></code> that takes a Circle and a
Point and returns True if the Point lies in or on the boundary of the
circle.</p>
<p>Write a function named <code class="docutils literal"><span class="pre">rect_in_circle</span></code> that takes a Circle and a
Rectangle and returns True if the Rectangle lies entirely in or on the
boundary of the circle.</p>
<p>Write a function named <code class="docutils literal"><span class="pre">rect_circle_overlap</span></code> that takes a Circle and a
Rectangle and returns True if any of the corners of the Rectangle fall
inside the circle. Or as a more challenging version, return True if any
part of the Rectangle falls inside the circle.</p>
<p>Solution: <a class="reference external" href="http://thinkpython2.com/code/Circle.py">http://thinkpython2.com/code/Circle.py</a>.</p>
<p>Write a function called <code class="docutils literal"><span class="pre">draw_rect</span></code> that takes a Turtle object and a
Rectangle and uses the Turtle to draw the Rectangle. See
Chapter [turtlechap] for examples using Turtle objects.</p>
<p>Write a function called <code class="docutils literal"><span class="pre">draw_circle</span></code> that takes a Turtle and a Circle
and draws the Circle.</p>
<p>Solution: <a class="reference external" href="http://thinkpython2.com/code/draw.py">http://thinkpython2.com/code/draw.py</a>.</p>
</div>
</div>
</div>
</div>
</div>
<div class="sphinxsidebar" role="navigation" aria-label="main navigation">
<div class="sphinxsidebarwrapper">
<h3><a href="index.html">Table Of Contents</a></h3>
<ul>
<li><a class="reference internal" href="#">Classes and objects</a><ul>
<li><a class="reference internal" href="#programmer-defined-types">Programmer-defined types</a></li>
<li><a class="reference internal" href="#attributes">Attributes</a></li>
<li><a class="reference internal" href="#rectangles">Rectangles</a></li>
<li><a class="reference internal" href="#instances-as-return-values">Instances as return values</a></li>
<li><a class="reference internal" href="#objects-are-mutable">Objects are mutable</a></li>
<li><a class="reference internal" href="#copying">Copying</a></li>
<li><a class="reference internal" href="#debugging">Debugging</a></li>
<li><a class="reference internal" href="#glossary">Glossary</a></li>
<li><a class="reference internal" href="#exercises">Exercises</a></li>
</ul>
</li>
</ul>
<div class="relations">
<h3>Related Topics</h3>
<ul>
<li><a href="index.html">Documentation overview</a><ul>
<li>Previous: <a href="14-file.html" title="previous chapter">Files</a></li>
<li>Next: <a href="16-cls-fn.html" title="next chapter">Classes and functions</a></li>
</ul></li>
</ul>
</div>
<div role="note" aria-label="source link">
<h3>This Page</h3>
<ul class="this-page-menu">
<li><a href="_sources/15-cls-object.txt"
rel="nofollow">Show Source</a></li>
</ul>
</div>
<div id="searchbox" style="display: none" role="search">
<h3>Quick search</h3>
<form class="search" action="search.html" method="get">
<input type="text" name="q" />
<input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form>
<p class="searchtip" style="font-size: 90%">
Enter search terms or a module, class or function name.
</p>
</div>
<script type="text/javascript">$('#searchbox').show(0);</script>
</div>
</div>
<div class="clearer"></div>
</div>
<div class="footer">
©2015, Allen B. Downey.
|
Powered by <a href="http://sphinx-doc.org/">Sphinx 1.3.1</a>
& <a href="https://github.com/bitprophet/alabaster">Alabaster 0.7.6</a>
|
<a href="_sources/15-cls-object.txt"
rel="nofollow">Page source</a>
</div>
</body>
</html>