Viewing: github-redirect.dependabot.com

Repository navigation

More items

Blame

History

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

531

532

533

534

535

536

537

538

539

540

541

542

543

544

545

546

547

548

549

550

551

552

553

554

555

556

557

558

559

560

561

562

563

564

565

566

567

568

569

570

571

572

573

574

575

576

577

578

579

580

581

582

583

584

585

586

587

588

589

590

591

592

593

594

595

596

597

598

599

600

601

602

603

604

605

606

607

608

609

610

611

612

613

614

615

616

617

618

619

620

621

622

623

624

625

626

627

628

629

630

631

632

633

634

635

636

637

638

639

640

641

642

643

644

645

646

647

648

649

650

651

652

653

654

655

656

657

658

659

660

661

662

663

664

665

666

667

668

669

670

671

672

673

674

675

676

677

678

679

680

681

682

683

684

685

686

687

688

689

690

691

692

693

694

695

696

697

698

699

700

701

702

703

704

705

706

707

708

709

710

711

712

713

714

715

716

717

718

719

720

721

722

723

724

725

726

727

728

729

730

731

732

733

734

735

736

737

738

739

740

741

742

743

744

745

746

747

748

749

750

751

752

753

754

755

756

757

758

759

760

761

762

763

764

765

766

767

768

769

770

771

772

773

774

775

776

777

778

779

780

781

782

783

784

785

786

787

788

789

790

791

792

793

794

795

796

797

798

799

800

801

802

803

804

805

806

807

808

809

810

811

812

813

814

815

816

817

818

819

820

821

822

823

824

825

826

827

828

829

830

831

832

833

834

835

# SOME DESCRIPTIVE TITLE.

# This file is distributed under the same license as the Python package.

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

# Translators:

# Maciej Olko <maciej.olko@gmail.com>, 2019

# Tomasz Rodzen <t.rodzen@poczta.fm>, 2020

# Igor Zubrycki <igorzubrycki@gmail.com>, 2020

#, fuzzy

msgid ""

msgstr ""

"Project-Id-Version: Python 3.9\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2021-01-01 05:02+0000\n"

"PO-Revision-Date: 2017-02-16 23:39+0000\n"

"Last-Translator: Igor Zubrycki <igorzubrycki@gmail.com>, 2020\n"

"Language-Team: Polish (https://www.transifex.com/python-doc/teams/5390/pl/)\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=UTF-8\n"

"Content-Transfer-Encoding: 8bit\n"

"Language: pl\n"

"Plural-Forms: nplurals=4; plural=(n==1 ? 0 : (n%10>=2 && n%10<=4) && "

"(n%100<12 || n%100>14) ? 1 : n!=1 && (n%10>=0 && n%10<=1) || (n%10>=5 && "

"n%10<=9) || (n%100>=12 && n%100<=14) ? 2 : 3);\n"

msgid "Classes"

msgstr "Klasy"

msgid ""

"Classes provide a means of bundling data and functionality together. "

"Creating a new class creates a new *type* of object, allowing new "

"*instances* of that type to be made. Each class instance can have "

"attributes attached to it for maintaining its state. Class instances can "

"also have methods (defined by its class) for modifying its state."

msgstr ""

"Klasy dostarczaj sposoby powizania informacji i funkcjonalnoci. "

"Stworzenie nowej klasy, tworzy nowy typ obiektu, pozwalajcy na tworzenie "

"nowych instancji tego typu. Kada instancja klasy moe mie atrybuty "

"przypisane w celu utrzymania jej stanu. Instancje klas mog rwnie posiada "

"metody (zdefiniowane przez jej klas) w celu modyfikacje ich stanu."

msgid ""

"Compared with other programming languages, Python's class mechanism adds "

"classes with a minimum of new syntax and semantics. It is a mixture of the "

"class mechanisms found in C++ and Modula-3. Python classes provide all the "

"standard features of Object Oriented Programming: the class inheritance "

"mechanism allows multiple base classes, a derived class can override any "

"methods of its base class or classes, and a method can call the method of a "

"base class with the same name. Objects can contain arbitrary amounts and "

"kinds of data. As is true for modules, classes partake of the dynamic "

"nature of Python: they are created at runtime, and can be modified further "

"after creation."

msgstr ""

"W porwnaniu do innych jzykw programowania, w Pythonie, mechanizm "

"dodawania nowych klas wymaga niewielkiej iloci nowej skadni i semantyki. "

"Jest to poczenie mechanizmu klas, ktre mona znale w C++ i Modula-3. "

"Klasy w Pythonie dostarczaj wszystkie standardowe cechy Programowania "

"Obiektowego: mechanizm dziedziczenia klas pozwala na tworzenie wielu "

"bazowych klas, pochodne klasy mog nadpisa kad metod klasy lub klas "

"bazowej i metoda moe przywoa metody klas bazowych o tej samej nazwie. "

"Obiekty mog zawiera dowoln ilo i rodzaj danych. Zarwno klasy jak i "

"moduy s czci dynamicznej natury Python'a: s tworzone w trakcje "

"dziaania programu i mog by modyfikowane pniej, po stworzeniu. "

msgid ""

"In C++ terminology, normally class members (including the data members) are "

"*public* (except see below :ref:`tut-private`), and all member functions are "

"*virtual*. As in Modula-3, there are no shorthands for referencing the "

"object's members from its methods: the method function is declared with an "

"explicit first argument representing the object, which is provided "

"implicitly by the call. As in Smalltalk, classes themselves are objects. "

"This provides semantics for importing and renaming. Unlike C++ and "

"Modula-3, built-in types can be used as base classes for extension by the "

"user. Also, like in C++, most built-in operators with special syntax "

"(arithmetic operators, subscripting etc.) can be redefined for class "

"instances."

msgstr ""

"Korzystajc z terminologii C++, skadniki klas (take pola)s *publiczne* (z "

"wyjtkiem zobacz :ref:`tut-private`), a wszystkie metody s *wirtualne*. "

"Podobnie jak w Moduli-3, nie ma skrtw pozwalajcych na odnoszenie si do "

"skadnikw klas z ich metod: metoda jest deklarowana poprzez podanie wprost "

"jako pierwszego argumentu obiektu, ktry w czasie wywoania metody zostanie "

"jej przekazany niejawnie. Podobnie jak w Smalltalku, same klasy take s "

"obiektami. Dostarcza nam to wyrae semantycznych pozwalajcych na "

"importowanie i zmian nazw klasy. Inaczej ni w C++ i Moduli-3 wbudowane "

"typy mog stanowi klasy z ktrych klasa uytkownika bdzie dziedziczy. "

"Podobnie jak w C++, wikszo wbudowanych operatorw ze specjaln skadni "

"(operatory arytmetyczne, indeksowanie) mog by przedefiniowane przez "

"instancje klasy."

msgid ""

"(Lacking universally accepted terminology to talk about classes, I will make "

"occasional use of Smalltalk and C++ terms. I would use Modula-3 terms, "

"since its object-oriented semantics are closer to those of Python than C++, "

"but I expect that few readers have heard of it.)"

msgstr ""

"(Z powodu braku oglnie zaakceptowanej terminologii w kontekcie klas, bd "

"uywa terminw ze Samlltalk i C++. Uybym Modula-3 poniewa semantyka "

"programowania obiektowego jest mu blisza Pythonowi ni C++ ale zakadam, e "

"mniej czytelnikw o nim syszao.)"

msgid "A Word About Names and Objects"

msgstr "Kilka sw o nazwach i obiektach"

msgid ""

"Objects have individuality, and multiple names (in multiple scopes) can be "

"bound to the same object. This is known as aliasing in other languages. "

"This is usually not appreciated on a first glance at Python, and can be "

"safely ignored when dealing with immutable basic types (numbers, strings, "

"tuples). However, aliasing has a possibly surprising effect on the "

"semantics of Python code involving mutable objects such as lists, "

"dictionaries, and most other types. This is usually used to the benefit of "

"the program, since aliases behave like pointers in some respects. For "

"example, passing an object is cheap since only a pointer is passed by the "

"implementation; and if a function modifies an object passed as an argument, "

"the caller will see the change --- this eliminates the need for two "

"different argument passing mechanisms as in Pascal."

msgstr ""

msgid "Python Scopes and Namespaces"

msgstr ""

msgid ""

"Before introducing classes, I first have to tell you something about "

"Python's scope rules. Class definitions play some neat tricks with "

"namespaces, and you need to know how scopes and namespaces work to fully "

"understand what's going on. Incidentally, knowledge about this subject is "

"useful for any advanced Python programmer."

msgstr ""

msgid "Let's begin with some definitions."

msgstr ""

msgid ""

"A *namespace* is a mapping from names to objects. Most namespaces are "

"currently implemented as Python dictionaries, but that's normally not "

"noticeable in any way (except for performance), and it may change in the "

"future. Examples of namespaces are: the set of built-in names (containing "

"functions such as :func:`abs`, and built-in exception names); the global "

"names in a module; and the local names in a function invocation. In a sense "

"the set of attributes of an object also form a namespace. The important "

"thing to know about namespaces is that there is absolutely no relation "

"between names in different namespaces; for instance, two different modules "

"may both define a function ``maximize`` without confusion --- users of the "

"modules must prefix it with the module name."

msgstr ""

msgid ""

"By the way, I use the word *attribute* for any name following a dot --- for "

"example, in the expression ``z.real``, ``real`` is an attribute of the "

"object ``z``. Strictly speaking, references to names in modules are "

"attribute references: in the expression ``modname.funcname``, ``modname`` is "

"a module object and ``funcname`` is an attribute of it. In this case there "

"happens to be a straightforward mapping between the module's attributes and "

"the global names defined in the module: they share the same namespace! [#]_"

msgstr ""

msgid ""

"Attributes may be read-only or writable. In the latter case, assignment to "

"attributes is possible. Module attributes are writable: you can write "

"``modname.the_answer = 42``. Writable attributes may also be deleted with "

"the :keyword:`del` statement. For example, ``del modname.the_answer`` will "

"remove the attribute :attr:`the_answer` from the object named by ``modname``."

msgstr ""

msgid ""

"Namespaces are created at different moments and have different lifetimes. "

"The namespace containing the built-in names is created when the Python "

"interpreter starts up, and is never deleted. The global namespace for a "

"module is created when the module definition is read in; normally, module "

"namespaces also last until the interpreter quits. The statements executed "

"by the top-level invocation of the interpreter, either read from a script "

"file or interactively, are considered part of a module called :mod:"

"`__main__`, so they have their own global namespace. (The built-in names "

"actually also live in a module; this is called :mod:`builtins`.)"

msgstr ""

msgid ""

"The local namespace for a function is created when the function is called, "

"and deleted when the function returns or raises an exception that is not "

"handled within the function. (Actually, forgetting would be a better way to "

"describe what actually happens.) Of course, recursive invocations each have "

"their own local namespace."

msgstr ""

msgid ""

"A *scope* is a textual region of a Python program where a namespace is "

"directly accessible. \"Directly accessible\" here means that an unqualified "

"reference to a name attempts to find the name in the namespace."

msgstr ""

msgid ""

"Although scopes are determined statically, they are used dynamically. At any "

"time during execution, there are 3 or 4 nested scopes whose namespaces are "

"directly accessible:"

msgstr ""

msgid "the innermost scope, which is searched first, contains the local names"

msgstr ""

msgid ""

"the scopes of any enclosing functions, which are searched starting with the "

"nearest enclosing scope, contains non-local, but also non-global names"

msgstr ""

msgid "the next-to-last scope contains the current module's global names"

msgstr ""

msgid ""

"the outermost scope (searched last) is the namespace containing built-in "

"names"

msgstr ""

msgid ""

"If a name is declared global, then all references and assignments go "

"directly to the middle scope containing the module's global names. To "

"rebind variables found outside of the innermost scope, the :keyword:"

"`nonlocal` statement can be used; if not declared nonlocal, those variables "

"are read-only (an attempt to write to such a variable will simply create a "

"*new* local variable in the innermost scope, leaving the identically named "

"outer variable unchanged)."

msgstr ""

msgid ""

"Usually, the local scope references the local names of the (textually) "

"current function. Outside functions, the local scope references the same "

"namespace as the global scope: the module's namespace. Class definitions "

"place yet another namespace in the local scope."

msgstr ""

msgid ""

"It is important to realize that scopes are determined textually: the global "

"scope of a function defined in a module is that module's namespace, no "

"matter from where or by what alias the function is called. On the other "

"hand, the actual search for names is done dynamically, at run time --- "

"however, the language definition is evolving towards static name resolution, "

"at \"compile\" time, so don't rely on dynamic name resolution! (In fact, "

"local variables are already determined statically.)"

msgstr ""

msgid ""

"A special quirk of Python is that -- if no :keyword:`global` or :keyword:"

"`nonlocal` statement is in effect -- assignments to names always go into the "

"innermost scope. Assignments do not copy data --- they just bind names to "

"objects. The same is true for deletions: the statement ``del x`` removes "

"the binding of ``x`` from the namespace referenced by the local scope. In "

"fact, all operations that introduce new names use the local scope: in "

"particular, :keyword:`import` statements and function definitions bind the "

"module or function name in the local scope."

msgstr ""

msgid ""

"The :keyword:`global` statement can be used to indicate that particular "

"variables live in the global scope and should be rebound there; the :keyword:"

"`nonlocal` statement indicates that particular variables live in an "

"enclosing scope and should be rebound there."

msgstr ""

msgid "Scopes and Namespaces Example"

msgstr ""

msgid ""

"This is an example demonstrating how to reference the different scopes and "

"namespaces, and how :keyword:`global` and :keyword:`nonlocal` affect "

"variable binding::"

msgstr ""

msgid "The output of the example code is:"

msgstr ""

msgid ""

"Note how the *local* assignment (which is default) didn't change "

"*scope_test*\\'s binding of *spam*. The :keyword:`nonlocal` assignment "

"changed *scope_test*\\'s binding of *spam*, and the :keyword:`global` "

"assignment changed the module-level binding."

msgstr ""

msgid ""

"You can also see that there was no previous binding for *spam* before the :"

"keyword:`global` assignment."

msgstr ""

msgid "A First Look at Classes"

msgstr ""

msgid ""

"Classes introduce a little bit of new syntax, three new object types, and "

"some new semantics."

msgstr ""

msgid "Class Definition Syntax"

msgstr ""

msgid "The simplest form of class definition looks like this::"

msgstr ""

msgid ""

"Class definitions, like function definitions (:keyword:`def` statements) "

"must be executed before they have any effect. (You could conceivably place "

"a class definition in a branch of an :keyword:`if` statement, or inside a "

"function.)"

msgstr ""

msgid ""

"In practice, the statements inside a class definition will usually be "

"function definitions, but other statements are allowed, and sometimes useful "

"--- we'll come back to this later. The function definitions inside a class "

"normally have a peculiar form of argument list, dictated by the calling "

"conventions for methods --- again, this is explained later."

msgstr ""

msgid ""

"When a class definition is entered, a new namespace is created, and used as "

"the local scope --- thus, all assignments to local variables go into this "

"new namespace. In particular, function definitions bind the name of the new "

"function here."

msgstr ""

msgid ""

"When a class definition is left normally (via the end), a *class object* is "

"created. This is basically a wrapper around the contents of the namespace "

"created by the class definition; we'll learn more about class objects in the "

"next section. The original local scope (the one in effect just before the "

"class definition was entered) is reinstated, and the class object is bound "

"here to the class name given in the class definition header (:class:"

"`ClassName` in the example)."

msgstr ""

msgid "Class Objects"

msgstr ""

msgid ""

"Class objects support two kinds of operations: attribute references and "

"instantiation."

msgstr ""

msgid ""

"*Attribute references* use the standard syntax used for all attribute "

"references in Python: ``obj.name``. Valid attribute names are all the names "

"that were in the class's namespace when the class object was created. So, "

"if the class definition looked like this::"

msgstr ""

msgid ""

"then ``MyClass.i`` and ``MyClass.f`` are valid attribute references, "

"returning an integer and a function object, respectively. Class attributes "

"can also be assigned to, so you can change the value of ``MyClass.i`` by "

"assignment. :attr:`__doc__` is also a valid attribute, returning the "

"docstring belonging to the class: ``\"A simple example class\"``."

msgstr ""

msgid ""

"Class *instantiation* uses function notation. Just pretend that the class "

"object is a parameterless function that returns a new instance of the class. "

"For example (assuming the above class)::"

msgstr ""

msgid ""

"creates a new *instance* of the class and assigns this object to the local "

"variable ``x``."

msgstr ""

msgid ""

"The instantiation operation (\"calling\" a class object) creates an empty "

"object. Many classes like to create objects with instances customized to a "

"specific initial state. Therefore a class may define a special method named :"

"meth:`__init__`, like this::"

msgstr ""

msgid ""

"When a class defines an :meth:`__init__` method, class instantiation "

"automatically invokes :meth:`__init__` for the newly-created class "

"instance. So in this example, a new, initialized instance can be obtained "

"by::"

msgstr ""

msgid ""

"Of course, the :meth:`__init__` method may have arguments for greater "

"flexibility. In that case, arguments given to the class instantiation "

"operator are passed on to :meth:`__init__`. For example, ::"

msgstr ""

msgid "Instance Objects"

msgstr ""

msgid ""

"Now what can we do with instance objects? The only operations understood by "

"instance objects are attribute references. There are two kinds of valid "

"attribute names: data attributes and methods."

msgstr ""

msgid ""

"*data attributes* correspond to \"instance variables\" in Smalltalk, and to "

"\"data members\" in C++. Data attributes need not be declared; like local "

"variables, they spring into existence when they are first assigned to. For "

"example, if ``x`` is the instance of :class:`MyClass` created above, the "

"following piece of code will print the value ``16``, without leaving a "

"trace::"

msgstr ""

msgid ""

"The other kind of instance attribute reference is a *method*. A method is a "

"function that \"belongs to\" an object. (In Python, the term method is not "

"unique to class instances: other object types can have methods as well. For "

"example, list objects have methods called append, insert, remove, sort, and "

"so on. However, in the following discussion, we'll use the term method "

"exclusively to mean methods of class instance objects, unless explicitly "

"stated otherwise.)"

msgstr ""

msgid ""

"Valid method names of an instance object depend on its class. By "

"definition, all attributes of a class that are function objects define "

"corresponding methods of its instances. So in our example, ``x.f`` is a "

"valid method reference, since ``MyClass.f`` is a function, but ``x.i`` is "

"not, since ``MyClass.i`` is not. But ``x.f`` is not the same thing as "

"``MyClass.f`` --- it is a *method object*, not a function object."

msgstr ""

msgid "Method Objects"

msgstr ""

msgid "Usually, a method is called right after it is bound::"

msgstr ""

msgid ""

"In the :class:`MyClass` example, this will return the string ``'hello "

"world'``. However, it is not necessary to call a method right away: ``x.f`` "

"is a method object, and can be stored away and called at a later time. For "

"example::"

msgstr ""

msgid "will continue to print ``hello world`` until the end of time."

msgstr ""

msgid ""

"What exactly happens when a method is called? You may have noticed that ``x."

"f()`` was called without an argument above, even though the function "

"definition for :meth:`f` specified an argument. What happened to the "

"argument? Surely Python raises an exception when a function that requires an "

"argument is called without any --- even if the argument isn't actually "

"used..."

msgstr ""

msgid ""

"Actually, you may have guessed the answer: the special thing about methods "

"is that the instance object is passed as the first argument of the "

"function. In our example, the call ``x.f()`` is exactly equivalent to "

"``MyClass.f(x)``. In general, calling a method with a list of *n* arguments "

"is equivalent to calling the corresponding function with an argument list "

"that is created by inserting the method's instance object before the first "

"argument."

msgstr ""

msgid ""

"If you still don't understand how methods work, a look at the implementation "

"can perhaps clarify matters. When a non-data attribute of an instance is "

"referenced, the instance's class is searched. If the name denotes a valid "

"class attribute that is a function object, a method object is created by "

"packing (pointers to) the instance object and the function object just found "

"together in an abstract object: this is the method object. When the method "

"object is called with an argument list, a new argument list is constructed "

"from the instance object and the argument list, and the function object is "

"called with this new argument list."

msgstr ""

msgid "Class and Instance Variables"

msgstr ""

msgid ""

"Generally speaking, instance variables are for data unique to each instance "

"and class variables are for attributes and methods shared by all instances "

"of the class::"

msgstr ""

msgid ""

"As discussed in :ref:`tut-object`, shared data can have possibly surprising "

"effects with involving :term:`mutable` objects such as lists and "

"dictionaries. For example, the *tricks* list in the following code should "

"not be used as a class variable because just a single list would be shared "

"by all *Dog* instances::"

msgstr ""

msgid "Correct design of the class should use an instance variable instead::"

msgstr ""

msgid "Random Remarks"

msgstr ""

msgid ""

"If the same attribute name occurs in both an instance and in a class, then "

"attribute lookup prioritizes the instance::"

msgstr ""

msgid ""

"Data attributes may be referenced by methods as well as by ordinary users "

"(\"clients\") of an object. In other words, classes are not usable to "

"implement pure abstract data types. In fact, nothing in Python makes it "

"possible to enforce data hiding --- it is all based upon convention. (On "

"the other hand, the Python implementation, written in C, can completely hide "

"implementation details and control access to an object if necessary; this "

"can be used by extensions to Python written in C.)"

msgstr ""

msgid ""

"Clients should use data attributes with care --- clients may mess up "

"invariants maintained by the methods by stamping on their data attributes. "

"Note that clients may add data attributes of their own to an instance object "

"without affecting the validity of the methods, as long as name conflicts are "

"avoided --- again, a naming convention can save a lot of headaches here."

msgstr ""

msgid ""

"There is no shorthand for referencing data attributes (or other methods!) "

"from within methods. I find that this actually increases the readability of "

"methods: there is no chance of confusing local variables and instance "

"variables when glancing through a method."

msgstr ""

msgid ""

"Often, the first argument of a method is called ``self``. This is nothing "

"more than a convention: the name ``self`` has absolutely no special meaning "

"to Python. Note, however, that by not following the convention your code "

"may be less readable to other Python programmers, and it is also conceivable "

"that a *class browser* program might be written that relies upon such a "

"convention."

msgstr ""

msgid ""

"Any function object that is a class attribute defines a method for instances "

"of that class. It is not necessary that the function definition is "

"textually enclosed in the class definition: assigning a function object to a "

"local variable in the class is also ok. For example::"

msgstr ""

msgid ""

"Now ``f``, ``g`` and ``h`` are all attributes of class :class:`C` that refer "

"to function objects, and consequently they are all methods of instances of :"

"class:`C` --- ``h`` being exactly equivalent to ``g``. Note that this "

"practice usually only serves to confuse the reader of a program."

msgstr ""

msgid ""

"Methods may call other methods by using method attributes of the ``self`` "

"argument::"

msgstr ""

msgid ""

"Methods may reference global names in the same way as ordinary functions. "

"The global scope associated with a method is the module containing its "

"definition. (A class is never used as a global scope.) While one rarely "

"encounters a good reason for using global data in a method, there are many "

"legitimate uses of the global scope: for one thing, functions and modules "

"imported into the global scope can be used by methods, as well as functions "

"and classes defined in it. Usually, the class containing the method is "

"itself defined in this global scope, and in the next section we'll find some "

"good reasons why a method would want to reference its own class."

msgstr ""

msgid ""

"Each value is an object, and therefore has a *class* (also called its "

"*type*). It is stored as ``object.__class__``."

msgstr ""

msgid "Inheritance"

msgstr ""

msgid ""

"Of course, a language feature would not be worthy of the name \"class\" "

"without supporting inheritance. The syntax for a derived class definition "

"looks like this::"

msgstr ""

msgid ""

"The name :class:`BaseClassName` must be defined in a scope containing the "

"derived class definition. In place of a base class name, other arbitrary "

"expressions are also allowed. This can be useful, for example, when the "

"base class is defined in another module::"

msgstr ""

msgid ""

"Execution of a derived class definition proceeds the same as for a base "

"class. When the class object is constructed, the base class is remembered. "

"This is used for resolving attribute references: if a requested attribute is "

"not found in the class, the search proceeds to look in the base class. This "

"rule is applied recursively if the base class itself is derived from some "

"other class."

msgstr ""

msgid ""

"There's nothing special about instantiation of derived classes: "

"``DerivedClassName()`` creates a new instance of the class. Method "

"references are resolved as follows: the corresponding class attribute is "

"searched, descending down the chain of base classes if necessary, and the "

"method reference is valid if this yields a function object."

msgstr ""

msgid ""

"Derived classes may override methods of their base classes. Because methods "

"have no special privileges when calling other methods of the same object, a "

"method of a base class that calls another method defined in the same base "

"class may end up calling a method of a derived class that overrides it. "

"(For C++ programmers: all methods in Python are effectively ``virtual``.)"

msgstr ""

msgid ""

"An overriding method in a derived class may in fact want to extend rather "

"than simply replace the base class method of the same name. There is a "

"simple way to call the base class method directly: just call ``BaseClassName."

"methodname(self, arguments)``. This is occasionally useful to clients as "

"well. (Note that this only works if the base class is accessible as "

"``BaseClassName`` in the global scope.)"

msgstr ""

msgid "Python has two built-in functions that work with inheritance:"

msgstr ""

msgid ""

"Use :func:`isinstance` to check an instance's type: ``isinstance(obj, int)`` "

"will be ``True`` only if ``obj.__class__`` is :class:`int` or some class "

"derived from :class:`int`."

msgstr ""

msgid ""

"Use :func:`issubclass` to check class inheritance: ``issubclass(bool, int)`` "

"is ``True`` since :class:`bool` is a subclass of :class:`int`. However, "

"``issubclass(float, int)`` is ``False`` since :class:`float` is not a "

"subclass of :class:`int`."

msgstr ""

msgid "Multiple Inheritance"

msgstr ""

msgid ""

"Python supports a form of multiple inheritance as well. A class definition "

"with multiple base classes looks like this::"

msgstr ""

msgid ""

"For most purposes, in the simplest cases, you can think of the search for "

"attributes inherited from a parent class as depth-first, left-to-right, not "

"searching twice in the same class where there is an overlap in the "

"hierarchy. Thus, if an attribute is not found in :class:`DerivedClassName`, "

"it is searched for in :class:`Base1`, then (recursively) in the base classes "

"of :class:`Base1`, and if it was not found there, it was searched for in :"

"class:`Base2`, and so on."

msgstr ""

msgid ""

"In fact, it is slightly more complex than that; the method resolution order "

"changes dynamically to support cooperative calls to :func:`super`. This "

"approach is known in some other multiple-inheritance languages as call-next-"

"method and is more powerful than the super call found in single-inheritance "

"languages."

msgstr ""

msgid ""

"Dynamic ordering is necessary because all cases of multiple inheritance "

"exhibit one or more diamond relationships (where at least one of the parent "

"classes can be accessed through multiple paths from the bottommost class). "

"For example, all classes inherit from :class:`object`, so any case of "

"multiple inheritance provides more than one path to reach :class:`object`. "

"To keep the base classes from being accessed more than once, the dynamic "

"algorithm linearizes the search order in a way that preserves the left-to-"

"right ordering specified in each class, that calls each parent only once, "

"and that is monotonic (meaning that a class can be subclassed without "

"affecting the precedence order of its parents). Taken together, these "

"properties make it possible to design reliable and extensible classes with "

"multiple inheritance. For more detail, see https://www.python.org/download/"

"releases/2.3/mro/."

msgstr ""

msgid "Private Variables"

msgstr ""

msgid ""

"\"Private\" instance variables that cannot be accessed except from inside an "

"object don't exist in Python. However, there is a convention that is "

"followed by most Python code: a name prefixed with an underscore (e.g. "

"``_spam``) should be treated as a non-public part of the API (whether it is "

"a function, a method or a data member). It should be considered an "

"implementation detail and subject to change without notice."

msgstr ""

msgid ""

"Since there is a valid use-case for class-private members (namely to avoid "

"name clashes of names with names defined by subclasses), there is limited "

"support for such a mechanism, called :dfn:`name mangling`. Any identifier "

"of the form ``__spam`` (at least two leading underscores, at most one "

"trailing underscore) is textually replaced with ``_classname__spam``, where "

"``classname`` is the current class name with leading underscore(s) "

"stripped. This mangling is done without regard to the syntactic position of "

"the identifier, as long as it occurs within the definition of a class."

msgstr ""

msgid ""

"Name mangling is helpful for letting subclasses override methods without "

"breaking intraclass method calls. For example::"

msgstr ""

msgid ""

"The above example would work even if ``MappingSubclass`` were to introduce a "

"``__update`` identifier since it is replaced with ``_Mapping__update`` in "

"the ``Mapping`` class and ``_MappingSubclass__update`` in the "

"``MappingSubclass`` class respectively."

msgstr ""

msgid ""

"Note that the mangling rules are designed mostly to avoid accidents; it "

"still is possible to access or modify a variable that is considered "

"private. This can even be useful in special circumstances, such as in the "

"debugger."

msgstr ""

msgid ""

"Notice that code passed to ``exec()`` or ``eval()`` does not consider the "

"classname of the invoking class to be the current class; this is similar to "

"the effect of the ``global`` statement, the effect of which is likewise "

"restricted to code that is byte-compiled together. The same restriction "

"applies to ``getattr()``, ``setattr()`` and ``delattr()``, as well as when "

"referencing ``__dict__`` directly."

msgstr ""

msgid "Odds and Ends"

msgstr ""

msgid ""

"Sometimes it is useful to have a data type similar to the Pascal \"record\" "

"or C \"struct\", bundling together a few named data items. An empty class "

"definition will do nicely::"

msgstr ""

msgid ""

"A piece of Python code that expects a particular abstract data type can "

"often be passed a class that emulates the methods of that data type "

"instead. For instance, if you have a function that formats some data from a "

"file object, you can define a class with methods :meth:`read` and :meth:`!"

"readline` that get the data from a string buffer instead, and pass it as an "

"argument."

msgstr ""

msgid ""

"Instance method objects have attributes, too: ``m.__self__`` is the instance "

"object with the method :meth:`m`, and ``m.__func__`` is the function object "

"corresponding to the method."

msgstr ""

msgid "Iterators"

msgstr ""

msgid ""

"By now you have probably noticed that most container objects can be looped "

"over using a :keyword:`for` statement::"

msgstr ""

msgid ""

"This style of access is clear, concise, and convenient. The use of "

"iterators pervades and unifies Python. Behind the scenes, the :keyword:"

"`for` statement calls :func:`iter` on the container object. The function "

"returns an iterator object that defines the method :meth:`~iterator."

"__next__` which accesses elements in the container one at a time. When "

"there are no more elements, :meth:`~iterator.__next__` raises a :exc:"

"`StopIteration` exception which tells the :keyword:`!for` loop to "

"terminate. You can call the :meth:`~iterator.__next__` method using the :"

"func:`next` built-in function; this example shows how it all works::"

msgstr ""

msgid ""

"Having seen the mechanics behind the iterator protocol, it is easy to add "

"iterator behavior to your classes. Define an :meth:`__iter__` method which "

"returns an object with a :meth:`~iterator.__next__` method. If the class "

"defines :meth:`__next__`, then :meth:`__iter__` can just return ``self``::"

msgstr ""

msgid "Generators"

msgstr ""

msgid ""

":term:`Generators <generator>` are a simple and powerful tool for creating "

"iterators. They are written like regular functions but use the :keyword:"

"`yield` statement whenever they want to return data. Each time :func:`next` "

"is called on it, the generator resumes where it left off (it remembers all "

"the data values and which statement was last executed). An example shows "

"that generators can be trivially easy to create::"

msgstr ""

msgid ""

"Anything that can be done with generators can also be done with class-based "

"iterators as described in the previous section. What makes generators so "

"compact is that the :meth:`__iter__` and :meth:`~generator.__next__` methods "

"are created automatically."

msgstr ""

msgid ""

"Another key feature is that the local variables and execution state are "

"automatically saved between calls. This made the function easier to write "

"and much more clear than an approach using instance variables like ``self."

"index`` and ``self.data``."

msgstr ""

msgid ""

"In addition to automatic method creation and saving program state, when "

"generators terminate, they automatically raise :exc:`StopIteration`. In "

"combination, these features make it easy to create iterators with no more "

"effort than writing a regular function."

msgstr ""

msgid "Generator Expressions"

msgstr ""

msgid ""

"Some simple generators can be coded succinctly as expressions using a syntax "

"similar to list comprehensions but with parentheses instead of square "

"brackets. These expressions are designed for situations where the generator "

"is used right away by an enclosing function. Generator expressions are more "

"compact but less versatile than full generator definitions and tend to be "

"more memory friendly than equivalent list comprehensions."

msgstr ""

msgid "Examples::"

msgstr ""

msgid "Footnotes"

msgstr "Przypisy"

msgid ""

"Except for one thing. Module objects have a secret read-only attribute "

"called :attr:`~object.__dict__` which returns the dictionary used to "

"implement the module's namespace; the name :attr:`~object.__dict__` is an "

"attribute but not a global name. Obviously, using this violates the "

"abstraction of namespace implementation, and should be restricted to things "

"like post-mortem debuggers."

msgstr ""

Terms
Privacy
Security
Status
Community
Docs
Contact
Manage cookies
Do not share my personal information

Navigation Menu

Repository navigation

Files

classes.po

classes.po

Navigation Menu

Repository navigation

FilesExpand file tree

Breadcrumbs

classes.po

Latest commit

History

Breadcrumbs

classes.po

File metadata and controls

Footer

Footer navigation

Files