pensepython.github.io/15-cls-object.html at master · PensePython/pensepython.github.io

History

491 lines (471 loc) · 32.7 KB

Raw

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">

<head>

<title>Classes and objects — Pense Python 2e documentation</title>

var DOCUMENTATION_OPTIONS = {

URL_ROOT: './',

VERSION: '2e',

COLLAPSE_INDEX: false,

FILE_SUFFIX: '.html',

HAS_SOURCE: true

};

</script>

</head>

<h1>Classes and objects<a class="headerlink" href="#classes-and-objects" title="Permalink to this headline">¶</a></h1>

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.

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>.

<h2>Programmer-defined types<a class="headerlink" href="#programmer-defined-types" title="Permalink to this headline">¶</a></h2>

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.

In mathematical notation, points are often written in parentheses with a

comma separating the coordinates. For example, (0,0) represents

the origin, and (x,y) represents the point x units to

the right and y units up from the origin.

There are several ways we might represent points in Python:

<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>

Creating a new type is more complicated than the other options, but it

has advantages that will be apparent soon.

A programmer-defined type is also called a class. A class definition

looks like this:

<div class="highlight-python"><div class="highlight"><pre>class Point:

"""Represents a point in 2-D space."""

</pre></div>

</div>

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.

Defining a class named Point creates a class object.

<div class="highlight-python"><div class="highlight"><pre>>>> Point

</pre></div>

</div>

Because Point is defined at the top level, its “full name” is

<code class="docutils literal">__main__.Point</code>.

The class object is like a factory for creating objects. To create a

Point, you call Point as if it were a function.

<div class="highlight-python"><div class="highlight"><pre>>>> blank = Point()

>>> blank

<__main__.Point object at 0xb7e9d3ac>

</pre></div>

</div>

The return value is a reference to a Point object, which we assign to

blank.

Creating a new object is called instantiation, and the object is an

instance of the class.

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).

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.

</div>

<h2>Attributes<a class="headerlink" href="#attributes" title="Permalink to this headline">¶</a></h2>

You can assign values to an instance using dot notation:

<div class="highlight-python"><div class="highlight"><pre>>>> blank.x = 3.0

>>> blank.y = 4.0

</pre></div>

</div>

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 attributes.

As a noun, “AT-trib-ute” is pronounced with emphasis on the first

syllable, as opposed to “a-TRIB-ute”, which is a verb.

The following diagram shows the result of these assignments. A state

diagram that shows an object and its attributes is called an object

diagram; see Figure [fig.point].

Object diagram.

</div>

The variable blank refers to a Point object, which contains two

attributes. Each attribute refers to a floating-point number.

You can read the value of an attribute using the same syntax:

<div class="highlight-python"><div class="highlight"><pre>>>> blank.y

4.0

>>> x = blank.x

>>> x

3.0

</pre></div>

</div>

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.

You can use dot notation as part of any expression. For example:

<div class="highlight-python"><div class="highlight"><pre>>>> '(%g, %g)' % (blank.x, blank.y)

'(3.0, 4.0)'

>>> distance = math.sqrt(blank.x**2 + blank.y**2)

>>> distance

5.0

</pre></div>

</div>

You can pass an instance as an argument in the usual way. For example:

<div class="highlight-python"><div class="highlight"><pre>def print_point(p):

print('(%g, %g)' % (p.x, p.y))

</pre></div>

</div>

<code class="docutils literal">print_point</code> takes a point as an argument and displays it in

mathematical notation. To invoke it, you can pass blank as an argument:

<div class="highlight-python"><div class="highlight"><pre>>>> print_point(blank)

(3.0, 4.0)

</pre></div>

</div>

Inside the function, p is an alias for blank, so if the function

modifies p, blank changes.

As an exercise, write a function called <code class="docutils literal">distance_between_points</code> that

takes two Points as arguments and returns the distance between them.

</div>

<h2>Rectangles<a class="headerlink" href="#rectangles" title="Permalink to this headline">¶</a></h2>

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.

There are at least two possibilities:

<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>

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.

Here is the class definition:

<div class="highlight-python"><div class="highlight"><pre>class Rectangle:

"""Represents a rectangle.

attributes: width, height, corner.

"""

</pre></div>

</div>

The docstring lists the attributes: width and height are numbers; corner

is a Point object that specifies the lower-left corner.

To represent a rectangle, you have to instantiate a Rectangle object and

assign values to the attributes:

<div class="highlight-python"><div class="highlight"><pre>box = Rectangle()

box.width = 100.0

box.height = 200.0

box.corner = Point()

box.corner.x = 0.0

box.corner.y = 0.0

</pre></div>

</div>

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.”

Object diagram.

</div>

Figure [fig.rectangle] shows the state of this object. An object that is

an attribute of another object is embedded.

</div>

<h2>Instances as return values<a class="headerlink" href="#instances-as-return-values" title="Permalink to this headline">¶</a></h2>

Functions can return instances. For example, <code class="docutils literal">find_center</code> takes a

Rectangle as an argument and returns a Point that contains the

coordinates of the center of the Rectangle:

<div class="highlight-python"><div class="highlight"><pre>def find_center(rect):

p = Point()

p.x = rect.corner.x + rect.width/2

p.y = rect.corner.y + rect.height/2

return p

</pre></div>

</div>

Here is an example that passes box as an argument and assigns the

resulting Point to center:

<div class="highlight-python"><div class="highlight"><pre>>>> center = find_center(box)

>>> print_point(center)

(50, 100)

</pre></div>

</div>

<h2>Objects are mutable<a class="headerlink" href="#objects-are-mutable" title="Permalink to this headline">¶</a></h2>

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:

<div class="highlight-python"><div class="highlight"><pre>box.width = box.width + 50

box.height = box.height + 100

</pre></div>

</div>

You can also write functions that modify objects. For example,

<code class="docutils literal">grow_rectangle</code> takes a Rectangle object and two numbers, dwidth and

dheight, and adds the numbers to the width and height of the rectangle:

<div class="highlight-python"><div class="highlight"><pre>def grow_rectangle(rect, dwidth, dheight):

rect.width += dwidth

rect.height += dheight

</pre></div>

</div>

Here is an example that demonstrates the effect:

<div class="highlight-python"><div class="highlight"><pre>>>> box.width, box.height

(150.0, 300.0)

>>> grow_rectangle(box, 50, 100)

>>> box.width, box.height

(200.0, 400.0)

</pre></div>

</div>

Inside the function, rect is an alias for box, so when the function

modifies rect, box changes.

As an exercise, write a function named <code class="docutils literal">move_rectangle</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.

</div>

<h2>Copying<a class="headerlink" href="#copying" title="Permalink to this headline">¶</a></h2>

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.

Copying an object is often an alternative to aliasing. The copy module

contains a function called copy that can duplicate any object:

<div class="highlight-python"><div class="highlight"><pre>>>> p1 = Point()

>>> p1.x = 3.0

>>> p1.y = 4.0

>>> import copy

>>> p2 = copy.copy(p1)

</pre></div>

</div>

p1 and p2 contain the same data, but they are not the same Point.

<div class="highlight-python"><div class="highlight"><pre>>>> print_point(p1)

(3, 4)

>>> print_point(p2)

(3, 4)

>>> p1 is p2

False

>>> p1 == p2

False

</pre></div>

</div>

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.

If you use copy.copy to duplicate a Rectangle, you will find that it

copies the Rectangle object but not the embedded Point.

<div class="highlight-python"><div class="highlight"><pre>>>> box2 = copy.copy(box)

>>> box2 is box

False

>>> box2.corner is box.corner

True

</pre></div>

</div>

Object diagram.

</div>

Figure [fig.rectangle2] shows what the object diagram looks like. This

operation is called a shallow copy because it copies the object and

any references it contains, but not the embedded objects.

For most applications, this is not what you want. In this example,

invoking <code class="docutils literal">grow_rectangle</code> on one of the Rectangles would not affect

the other, but invoking <code class="docutils literal">move_rectangle</code> on either would affect both!

This behavior is confusing and error-prone.

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 they refer to, and so on. You will not be surprised to learn

that this operation is called a deep copy.

<div class="highlight-python"><div class="highlight"><pre>>>> box3 = copy.deepcopy(box)

>>> box3 is box

False

>>> box3.corner is box.corner

False

</pre></div>

</div>

box3 and box are completely separate objects.

As an exercise, write a version of <code class="docutils literal">move_rectangle</code> that creates and

returns a new Rectangle instead of modifying the old one.

</div>

<h2>Debugging<a class="headerlink" href="#debugging" title="Permalink to this headline">¶</a></h2>

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:

<div class="highlight-python"><div class="highlight"><pre>>>> p = Point()

>>> p.x = 3

>>> p.y = 4

>>> p.z

AttributeError: Point instance has no attribute 'z'

</pre></div>

</div>

If you are not sure what type an object is, you can ask:

<div class="highlight-python"><div class="highlight"><pre>>>> type(p)

</pre></div>

</div>

You can also use isinstance to check whether an object is an instance of

a class:

<div class="highlight-python"><div class="highlight"><pre>>>> isinstance(p, Point)

True

</pre></div>

</div>

If you are not sure whether an object has a particular attribute, you

can use the built-in function hasattr:

<div class="highlight-python"><div class="highlight"><pre>>>> hasattr(p, 'x')

True

>>> hasattr(p, 'z')

False

</pre></div>

</div>

The first argument can be any object; the second argument is a string

that contains the name of the attribute.

You can also use a try statement to see if the object has the attributes

you need:

<div class="highlight-python"><div class="highlight"><pre>try:

x = p.x

except AttributeError:

x = 0

</pre></div>

</div>

This approach can make it easier to write functions that work with

different types; more on that topic is coming up in

Section [polymorphism].

</div>

<h2>Glossary<a class="headerlink" href="#glossary" title="Permalink to this headline">¶</a></h2>

<dt>classe (class)</dt>

<dd>A programmer-defined type. A class definition creates a new class object.</dd>

<dt>objeto-classe (class object)</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 (instance)</dt>

<dd>An object that belongs to a class.</dd>

<dt>instanciar (instantiate)</dt>

<dd>To create a new object.</dd>

<dt>atributo (attribute)</dt>

<dd>One of the named values associated with an object.</dd>

<dt>objeto embutido (embedded object)</dt>

<dd>An object that is stored as an attribute of another object.</dd>

<dt>cópia rasa (shallow copy)</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 (deep copy)</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 (object diagram)</dt>

<dd>A diagram that shows objects, their attributes, and the values of the attributes.</dd>

</dl>

</div>

<h2>Exercises<a class="headerlink" href="#exercises" title="Permalink to this headline">¶</a></h2>

Write a definition for a class named Circle with attributes center and

radius, where center is a Point object and radius is a number.

Instantiate a Circle object that represents a circle with its center at

(150, 100) and radius 75.

Write a function named <code class="docutils literal">point_in_circle</code> that takes a Circle and a

Point and returns True if the Point lies in or on the boundary of the

circle.

Write a function named <code class="docutils literal">rect_in_circle</code> that takes a Circle and a

Rectangle and returns True if the Rectangle lies entirely in or on the

boundary of the circle.

Write a function named <code class="docutils literal">rect_circle_overlap</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.

Solution: <a class="reference external" href="http://thinkpython2.com/code/Circle.py">http://thinkpython2.com/code/Circle.py</a>.

Write a function called <code class="docutils literal">draw_rect</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.

Write a function called <code class="docutils literal">draw_circle</code> that takes a Turtle and a Circle

and draws the Circle.

Solution: <a class="reference external" href="http://thinkpython2.com/code/draw.py">http://thinkpython2.com/code/draw.py</a>.

</div>

<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>

<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>

<li><a href="_sources/15-cls-object.txt"

rel="nofollow">Show Source</a></li>

</ul>

</div>

<h3>Quick search</h3>

</form>

Enter search terms or a module, class or function name.

</div>

</div>

</div>

& <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>

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

FilesExpand file tree

15-cls-object.html

Latest commit

History

15-cls-object.html

File metadata and controls