python-docs-tr/whatsnew/2.4.html at gh-pages · python-docs-tr/python-docs-tr

History

1730 lines (1679 loc) · 169 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

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

531

532

533

534

535

536

537

538

539

540

541

542

543

544

545

546

547

548

549

550

551

552

553

554

555

556

557

558

559

560

561

562

563

564

565

566

567

568

569

570

571

572

573

574

575

576

577

578

579

580

581

582

583

584

585

586

587

588

589

590

591

592

593

594

595

596

597

598

599

600

601

602

603

604

605

606

607

608

609

610

611

612

613

614

615

616

617

618

619

620

621

622

623

624

625

626

627

628

629

630

631

632

633

634

635

636

637

638

639

640

641

642

643

644

645

646

647

648

649

650

651

652

653

654

655

656

657

658

659

660

661

662

663

664

665

666

667

668

669

670

671

672

673

674

675

676

677

678

679

680

681

682

683

684

685

686

687

688

689

690

691

692

693

694

695

696

697

698

699

700

701

702

703

704

705

706

707

708

709

710

711

712

713

714

715

716

717

718

719

720

721

722

723

724

725

726

727

728

729

730

731

732

733

734

735

736

737

738

739

740

741

742

743

744

745

746

747

748

749

750

751

752

753

754

755

756

757

758

759

760

761

762

763

764

765

766

767

768

769

770

771

772

773

774

775

776

777

778

779

780

781

782

783

784

785

786

787

788

789

790

791

792

793

794

795

796

797

798

799

800

801

802

803

804

805

806

807

808

809

810

811

812

813

814

815

816

817

818

819

820

821

822

823

824

825

826

827

828

829

830

831

832

833

834

835

836

837

838

839

840

841

842

843

844

845

846

847

848

849

850

851

852

853

854

855

856

857

858

859

860

861

862

863

864

865

866

867

868

869

870

871

872

873

874

875

876

877

878

879

880

881

882

883

884

885

886

887

888

889

890

891

892

893

894

895

896

897

898

899

900

901

902

903

904

905

906

907

908

909

910

911

912

913

914

915

916

917

918

919

920

921

922

923

924

925

926

927

928

929

930

931

932

933

934

935

936

937

938

939

940

941

942

943

944

945

946

947

948

949

950

951

952

953

954

955

956

957

958

959

960

961

962

963

964

965

966

967

968

969

970

971

972

973

974

975

976

977

978

979

980

981

982

983

984

985

986

987

988

989

990

991

992

993

994

995

996

997

998

999

1000

<!DOCTYPE html>

<head>

<title>What’s New in Python 2.4 — Python 3.11.5 belgelendirmesi</title><meta name="viewport" content="width=device-width, initial-scale=1.0">

title="Python 3.11.5 belgelendirmesi içinde ara"

href="../_static/opensearch.xml"/>

<style>

@media only screen {

table.full-width-table {

width: 100%;

}

</style>

</head>

<body>

<input type="checkbox" id="menuToggler" class="toggler__input" aria-controls="navigation"

aria-pressed="false" aria-expanded="false" role="button" aria-label="Menu" />

</label>

</a>

</svg>

</form>

</nav>

Theme

<option value="light">Light</option>

</select>

</label>

<div>

<h3><a href="../contents.html">İçindekiler</a></h3>

<ul>

<li><a class="reference internal" href="#">What’s New in Python 2.4</a><ul>

<li><a class="reference internal" href="#pep-218-built-in-set-objects">PEP 218: Built-In Set Objects</a></li>

<li><a class="reference internal" href="#pep-237-unifying-long-integers-and-integers">PEP 237: Unifying Long Integers and Integers</a></li>

<li><a class="reference internal" href="#pep-289-generator-expressions">PEP 289: Generator Expressions</a></li>

<li><a class="reference internal" href="#pep-292-simpler-string-substitutions">PEP 292: Simpler String Substitutions</a></li>

<li><a class="reference internal" href="#pep-318-decorators-for-functions-and-methods">PEP 318: Decorators for Functions and Methods</a></li>

<li><a class="reference internal" href="#pep-322-reverse-iteration">PEP 322: Reverse Iteration</a></li>

<li><a class="reference internal" href="#pep-324-new-subprocess-module">PEP 324: New subprocess Module</a></li>

<li><a class="reference internal" href="#pep-327-decimal-data-type">PEP 327: Decimal Data Type</a><ul>

<li><a class="reference internal" href="#why-is-decimal-needed">Why is Decimal needed?</a></li>

<li><a class="reference internal" href="#the-decimal-type">The <code class="xref py py-class docutils literal notranslate">Decimal</code> type</a></li>

<li><a class="reference internal" href="#the-context-type">The <code class="xref py py-class docutils literal notranslate">Context</code> type</a></li>

</ul>

</li>

<li><a class="reference internal" href="#pep-328-multi-line-imports">PEP 328: Multi-line Imports</a></li>

<li><a class="reference internal" href="#pep-331-locale-independent-float-string-conversions">PEP 331: Locale-Independent Float/String Conversions</a></li>

<li><a class="reference internal" href="#other-language-changes">Other Language Changes</a><ul>

<li><a class="reference internal" href="#optimizations">Optimizations</a></li>

</ul>

</li>

<li><a class="reference internal" href="#new-improved-and-deprecated-modules">New, Improved, and Deprecated Modules</a><ul>

<li><a class="reference internal" href="#cookielib">cookielib</a></li>

<li><a class="reference internal" href="#doctest">doctest</a></li>

</ul>

</li>

<li><a class="reference internal" href="#build-and-c-api-changes">Build and C API Changes</a><ul>

<li><a class="reference internal" href="#port-specific-changes">Port-Specific Changes</a></li>

</ul>

</li>

<li><a class="reference internal" href="#porting-to-python-2-4">Porting to Python 2.4</a></li>

<li><a class="reference internal" href="#acknowledgements">Acknowledgements</a></li>

</ul>

</li>

</ul>

</div>

<div>

<h4>Önceki konu</h4>

<a href="2.5.html"

title="önceki bölüm">What’s New in Python 2.5</a>

</div>

<div>

<h4>Sonraki konu</h4>

<a href="2.3.html"

title="sonraki bölüm">What’s New in Python 2.3</a>

</div>

<h3>Bu Sayfa</h3>

<li><a href="../bugs.html">Hata Bildir</a></li>

<li>

<a href="https://github.com/python/cpython/blob/3.11/Doc/whatsnew/2.4.rst"

rel="nofollow">Kaynağı Göster

</a>

</li>

</ul>

</div>

</nav>

</div>

<h3>Gezinti</h3>

<ul>

<a href="../genindex.html" title="Genel Endeks"

accesskey="I">dizin</a></li>

<a href="../py-modindex.html" title="Python Modül Dizini"

>modülleri</a> |</li>

<a href="2.3.html" title="What’s New in Python 2.3"

accesskey="N">sonraki</a> |</li>

<a href="2.5.html" title="What’s New in Python 2.5"

accesskey="P">önceki</a> |</li>

<li><a href="https://www.python.org/">Python</a> »</li>

</li>

<li>

</li>

<a href="../index.html">3.11.5 Documentation</a> »

</li>

<li class="nav-item nav-item-1"><a href="index.html" accesskey="U">What’s New in Python</a> »</li>

<li class="nav-item nav-item-this"><a href="">What’s New in Python 2.4</a></li>

</form>

</div>

</li>

Theme

<option value="light">Light</option>

</select>

</label> |</li>

</ul>

</div>

<h1>What’s New in Python 2.4<a class="headerlink" href="#what-s-new-in-python-2-4" title="Permalink to this heading">¶</a></h1>

<dt class="field-odd">Author:</dt>

<dd class="field-odd">A.M. Kuchling

</dd>

</dl>

This article explains the new features in Python 2.4.1, released on March 30,

2005.

Python 2.4 is a medium-sized release. It doesn’t introduce as many changes as

the radical Python 2.2, but introduces more features than the conservative 2.3

release. The most significant new language features are function decorators and

generator expressions; most other changes are to the standard library.

According to the CVS change logs, there were 481 patches applied and 502 bugs

fixed between Python 2.3 and 2.4. Both figures are likely to be underestimates.

This article doesn’t attempt to provide a complete specification of every single

new feature, but instead provides a brief introduction to each feature. For

full details, you should refer to the documentation for Python 2.4, such as the

Python Library Reference and the Python Reference Manual. Often you will be

referred to the PEP for a particular new feature for explanations of the

implementation and design rationale.

<h2>PEP 218: Built-In Set Objects<a class="headerlink" href="#pep-218-built-in-set-objects" title="Permalink to this heading">¶</a></h2>

Python 2.3 introduced the <code class="xref py py-mod docutils literal notranslate">sets</code> module. C implementations of set data

types have now been added to the Python core as two new built-in types,

<code class="docutils literal notranslate">set(iterable)</code> and <code class="docutils literal notranslate">frozenset(iterable)</code>. They provide high speed

operations for membership testing, for eliminating duplicates from sequences,

and for mathematical operations like unions, intersections, differences, and

symmetric differences.

<div class="highlight-python3 notranslate"><div class="highlight"><pre>>>> a = set('abracadabra') # form a set from a string

>>> 'z' in a # fast membership testing

False

>>> a # unique letters in a

set(['a', 'r', 'b', 'c', 'd'])

>>> ''.join(a) # convert back into a string

'arbcd'

>>> b = set('alacazam') # form a second set

>>> a - b # letters in a but not in b

set(['r', 'd', 'b'])

>>> a | b # letters in either a or b

set(['a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'])

>>> a & b # letters in both a and b

set(['a', 'c'])

>>> a ^ b # letters in a or b but not both

set(['r', 'd', 'b', 'm', 'z', 'l'])

>>> a.add('z') # add a new element

>>> a.update('wxy') # add multiple new elements

>>> a

set(['a', 'c', 'b', 'd', 'r', 'w', 'y', 'x', 'z'])

>>> a.remove('x') # take one element out

>>> a

set(['a', 'c', 'b', 'd', 'r', 'w', 'y', 'z'])

</pre></div>

</div>

The <a class="reference internal" href="../library/stdtypes.html#frozenset" title="frozenset"><code class="xref py py-func docutils literal notranslate">frozenset()</code></a> type is an immutable version of <a class="reference internal" href="../library/stdtypes.html#set" title="set"><code class="xref py py-func docutils literal notranslate">set()</code></a>. Since it is

immutable and hashable, it may be used as a dictionary key or as a member of

another set.

The <code class="xref py py-mod docutils literal notranslate">sets</code> module remains in the standard library, and may be useful if you

wish to subclass the <code class="xref py py-class docutils literal notranslate">Set</code> or <code class="xref py py-class docutils literal notranslate">ImmutableSet</code> classes. There are

currently no plans to deprecate the module.

Ayrıca bakınız

<dt><a class="pep reference external" href="https://peps.python.org/pep-0218/">PEP 218</a> - Adding a Built-In Set Object Type</dt><dd>Originally proposed by Greg Wilson and ultimately implemented by Raymond

Hettinger.

</dd>

</dl>

</div>

</section>

<h2>PEP 237: Unifying Long Integers and Integers<a class="headerlink" href="#pep-237-unifying-long-integers-and-integers" title="Permalink to this heading">¶</a></h2>

The lengthy transition process for this PEP, begun in Python 2.2, takes another

step forward in Python 2.4. In 2.3, certain integer operations that would

behave differently after int/long unification triggered <a class="reference internal" href="../library/exceptions.html#FutureWarning" title="FutureWarning"><code class="xref py py-exc docutils literal notranslate">FutureWarning</code></a>

warnings and returned values limited to 32 or 64 bits (depending on your

platform). In 2.4, these expressions no longer produce a warning and instead

produce a different result that’s usually a long integer.

The problematic expressions are primarily left shifts and lengthy hexadecimal

and octal constants. For example, <code class="docutils literal notranslate">2 << 32</code> results in a warning in 2.3,

evaluating to 0 on 32-bit platforms. In Python 2.4, this expression now returns

the correct answer, 8589934592.

Ayrıca bakınız

<dt><a class="pep reference external" href="https://peps.python.org/pep-0237/">PEP 237</a> - Unifying Long Integers and Integers</dt><dd>Original PEP written by Moshe Zadka and GvR. The changes for 2.4 were

implemented by Kalle Svensson.

</dd>

</dl>

</div>

</section>

<h2>PEP 289: Generator Expressions<a class="headerlink" href="#pep-289-generator-expressions" title="Permalink to this heading">¶</a></h2>

The iterator feature introduced in Python 2.2 and the <a class="reference internal" href="../library/itertools.html#module-itertools" title="itertools: Functions creating iterators for efficient looping."><code class="xref py py-mod docutils literal notranslate">itertools</code></a> module

make it easier to write programs that loop through large data sets without

having the entire data set in memory at one time. List comprehensions don’t fit

into this picture very well because they produce a Python list object containing

all of the items. This unavoidably pulls all of the objects into memory, which

can be a problem if your data set is very large. When trying to write a

functionally styled program, it would be natural to write something like:

<div class="highlight-python3 notranslate"><div class="highlight"><pre>links = [link for link in get_all_links() if not link.followed]

for link in links:

...

</pre></div>

</div>

instead of

<div class="highlight-python3 notranslate"><div class="highlight"><pre>for link in get_all_links():

if link.followed:

continue

...

</pre></div>

</div>

The first form is more concise and perhaps more readable, but if you’re dealing

with a large number of link objects you’d have to write the second form to avoid

having all link objects in memory at the same time.

Generator expressions work similarly to list comprehensions but don’t

materialize the entire list; instead they create a generator that will return

elements one by one. The above example could be written as:

<div class="highlight-python3 notranslate"><div class="highlight"><pre>links = (link for link in get_all_links() if not link.followed)

for link in links:

...

</pre></div>

</div>

Generator expressions always have to be written inside parentheses, as in the

above example. The parentheses signalling a function call also count, so if you

want to create an iterator that will be immediately passed to a function you

could write:

<div class="highlight-python3 notranslate"><div class="highlight"><pre>print sum(obj.count for obj in list_all_objects())

</pre></div>

</div>

Generator expressions differ from list comprehensions in various small ways.

Most notably, the loop variable (obj in the above example) is not accessible

outside of the generator expression. List comprehensions leave the variable

assigned to its last value; future versions of Python will change this, making

list comprehensions match generator expressions in this respect.

Ayrıca bakınız

<dt><a class="pep reference external" href="https://peps.python.org/pep-0289/">PEP 289</a> - Generator Expressions</dt><dd>Proposed by Raymond Hettinger and implemented by Jiwon Seo with early efforts

steered by Hye-Shik Chang.

</dd>

</dl>

</div>

</section>

<h2>PEP 292: Simpler String Substitutions<a class="headerlink" href="#pep-292-simpler-string-substitutions" title="Permalink to this heading">¶</a></h2>

Some new classes in the standard library provide an alternative mechanism for

substituting variables into strings; this style of substitution may be better

for applications where untrained users need to edit templates.

The usual way of substituting variables by name is the <code class="docutils literal notranslate">%</code> operator:

<div class="highlight-python3 notranslate"><div class="highlight"><pre>>>> '%(page)i: %(title)s' % {'page':2, 'title': 'The Best of Times'}

'2: The Best of Times'

</pre></div>

</div>

When writing the template string, it can be easy to forget the <code class="docutils literal notranslate">i</code> or <code class="docutils literal notranslate">s</code>

after the closing parenthesis. This isn’t a big problem if the template is in a

Python module, because you run the code, get an “Unsupported format character”

<a class="reference internal" href="../library/exceptions.html#ValueError" title="ValueError"><code class="xref py py-exc docutils literal notranslate">ValueError</code></a>, and fix the problem. However, consider an application such

as Mailman where template strings or translations are being edited by users who

aren’t aware of the Python language. The format string’s syntax is complicated

to explain to such users, and if they make a mistake, it’s difficult to provide

helpful feedback to them.

PEP 292 adds a <code class="xref py py-class docutils literal notranslate">Template</code> class to the <a class="reference internal" href="../library/string.html#module-string" title="string: Common string operations."><code class="xref py py-mod docutils literal notranslate">string</code></a> module that uses

<code class="docutils literal notranslate">$</code> to indicate a substitution:

<div class="highlight-python3 notranslate"><div class="highlight"><pre>>>> import string

>>> t = string.Template('$page: $title')

>>> t.substitute({'page':2, 'title': 'The Best of Times'})

'2: The Best of Times'

</pre></div>

</div>

If a key is missing from the dictionary, the <code class="xref py py-meth docutils literal notranslate">substitute()</code> method will

raise a <a class="reference internal" href="../library/exceptions.html#KeyError" title="KeyError"><code class="xref py py-exc docutils literal notranslate">KeyError</code></a>. There’s also a <code class="xref py py-meth docutils literal notranslate">safe_substitute()</code> method that

ignores missing keys:

<div class="highlight-python3 notranslate"><div class="highlight"><pre>>>> t = string.Template('$page: $title')

>>> t.safe_substitute({'page':3})

'3: $title'

</pre></div>

</div>

Ayrıca bakınız

<dt><a class="pep reference external" href="https://peps.python.org/pep-0292/">PEP 292</a> - Simpler String Substitutions</dt><dd>Written and implemented by Barry Warsaw.

</dd>

</dl>

</div>

</section>

<h2>PEP 318: Decorators for Functions and Methods<a class="headerlink" href="#pep-318-decorators-for-functions-and-methods" title="Permalink to this heading">¶</a></h2>

Python 2.2 extended Python’s object model by adding static methods and class

methods, but it didn’t extend Python’s syntax to provide any new way of defining

static or class methods. Instead, you had to write a <a class="reference internal" href="../reference/compound_stmts.html#def"><code class="xref std std-keyword docutils literal notranslate">def</code></a> statement

in the usual way, and pass the resulting method to a <a class="reference internal" href="../library/functions.html#staticmethod" title="staticmethod"><code class="xref py py-func docutils literal notranslate">staticmethod()</code></a> or

<a class="reference internal" href="../library/functions.html#classmethod" title="classmethod"><code class="xref py py-func docutils literal notranslate">classmethod()</code></a> function that would wrap up the function as a method of the

new type. Your code would look like this:

<div class="highlight-python3 notranslate"><div class="highlight"><pre>class C:

def meth (cls):

...

meth = classmethod(meth) # Rebind name to wrapped-up class method

</pre></div>

</div>

If the method was very long, it would be easy to miss or forget the

The intention was always to add some syntax to make such definitions more

readable, but at the time of 2.2’s release a good syntax was not obvious. Today

a good syntax still isn’t obvious but users are asking for easier access to

the feature; a new syntactic feature has been added to meet this need.

The new feature is called “function decorators”. The name comes from the idea

that <a class="reference internal" href="../library/functions.html#classmethod" title="classmethod"><code class="xref py py-func docutils literal notranslate">classmethod()</code></a>, <a class="reference internal" href="../library/functions.html#staticmethod" title="staticmethod"><code class="xref py py-func docutils literal notranslate">staticmethod()</code></a>, and friends are storing

additional information on a function object; they’re decorating functions with

more details.

The notation borrows from Java and uses the <code class="docutils literal notranslate">'@'</code> character as an indicator.

Using the new syntax, the example above would be written:

<div class="highlight-python3 notranslate"><div class="highlight"><pre>class C:

@classmethod

def meth (cls):

...

</pre></div>

</div>

The <code class="docutils literal notranslate">@classmethod</code> is shorthand for the <code class="docutils literal notranslate">meth=classmethod(meth)</code> assignment.

More generally, if you have the following:

<div class="highlight-python3 notranslate"><div class="highlight"><pre>@A

@B

@C

def f ():

...

</pre></div>

</div>

It’s equivalent to the following pre-decorator code:

<div class="highlight-python3 notranslate"><div class="highlight"><pre>def f(): ...

f = A(B(C(f)))

</pre></div>

</div>

Decorators must come on the line before a function definition, one decorator per

line, and can’t be on the same line as the def statement, meaning that <code class="docutils literal notranslate">@A def

f(): ...</code> is illegal. You can only decorate function definitions, either at

the module level or inside a class; you can’t decorate class definitions.

A decorator is just a function that takes the function to be decorated as an

argument and returns either the same function or some new object. The return

value of the decorator need not be callable (though it typically is), unless

further decorators will be applied to the result. It’s easy to write your own

decorators. The following simple example just sets an attribute on the function

object:

<div class="highlight-python3 notranslate"><div class="highlight"><pre>>>> def deco(func):

... func.attr = 'decorated'

... return func

...

>>> @deco

... def f(): pass

...

>>> f

>>> f.attr

'decorated'

>>>

</pre></div>

</div>

As a slightly more realistic example, the following decorator checks that the

supplied argument is an integer:

<div class="highlight-python3 notranslate"><div class="highlight"><pre>def require_int (func):

def wrapper (arg):

assert isinstance(arg, int)

return func(arg)

return wrapper

@require_int

def p1 (arg):

print arg

@require_int

def p2(arg):

print arg*2

</pre></div>

</div>

An example in <a class="pep reference external" href="https://peps.python.org/pep-0318/">PEP 318</a> contains a fancier version of this idea that lets you

both specify the required type and check the returned type.

Decorator functions can take arguments. If arguments are supplied, your

decorator function is called with only those arguments and must return a new

decorator function; this function must take a single function and return a

function, as previously described. In other words, <code class="docutils literal notranslate">@A @B @C(args)</code> becomes:

<div class="highlight-python3 notranslate"><div class="highlight"><pre>def f(): ...

_deco = C(args)

f = A(B(_deco(f)))

</pre></div>

</div>

Getting this right can be slightly brain-bending, but it’s not too difficult.

A small related change makes the <code class="xref py py-attr docutils literal notranslate">func_name</code> attribute of functions

writable. This attribute is used to display function names in tracebacks, so

decorators should change the name of any new function that’s constructed and

returned.

Ayrıca bakınız

<dt><a class="pep reference external" href="https://peps.python.org/pep-0318/">PEP 318</a> - Decorators for Functions, Methods and Classes</dt><dd>Written by Kevin D. Smith, Jim Jewett, and Skip Montanaro. Several people

wrote patches implementing function decorators, but the one that was actually

checked in was patch #979728, written by Mark Russell.

</dd>

<dt><a class="reference external" href="https://wiki.python.org/moin/PythonDecoratorLibrary">https://wiki.python.org/moin/PythonDecoratorLibrary</a></dt><dd>This Wiki page contains several examples of decorators.

</dd>

</dl>

</div>

</section>

<h2>PEP 322: Reverse Iteration<a class="headerlink" href="#pep-322-reverse-iteration" title="Permalink to this heading">¶</a></h2>

A new built-in function, <code class="docutils literal notranslate">reversed(seq)</code>, takes a sequence and returns an

iterator that loops over the elements of the sequence in reverse order.

<div class="highlight-python3 notranslate"><div class="highlight"><pre>>>> for i in reversed(xrange(1,4)):

... print i

...

3

2

1

</pre></div>

</div>

Compared to extended slicing, such as <code class="docutils literal notranslate">range(1,4)[::-1]</code>, <a class="reference internal" href="../library/functions.html#reversed" title="reversed"><code class="xref py py-func docutils literal notranslate">reversed()</code></a> is

easier to read, runs faster, and uses substantially less memory.

Note that <a class="reference internal" href="../library/functions.html#reversed" title="reversed"><code class="xref py py-func docutils literal notranslate">reversed()</code></a> only accepts sequences, not arbitrary iterators. If

you want to reverse an iterator, first convert it to a list with <a class="reference internal" href="../library/stdtypes.html#list" title="list"><code class="xref py py-func docutils literal notranslate">list()</code></a>.

<div class="highlight-python3 notranslate"><div class="highlight"><pre>>>> input = open('/etc/passwd', 'r')

>>> for line in reversed(list(input)):

... print line

...

root:*:0:0:System Administrator:/var/root:/bin/tcsh

...

</pre></div>

</div>

Ayrıca bakınız

<dt><a class="pep reference external" href="https://peps.python.org/pep-0322/">PEP 322</a> - Reverse Iteration</dt><dd>Written and implemented by Raymond Hettinger.

</dd>

</dl>

</div>

</section>

<h2>PEP 324: New subprocess Module<a class="headerlink" href="#pep-324-new-subprocess-module" title="Permalink to this heading">¶</a></h2>

The standard library provides a number of ways to execute a subprocess, offering

different features and different levels of complexity.

<code class="docutils literal notranslate">os.system(command)</code> is easy to use, but slow (it runs a shell process

which executes the command) and dangerous (you have to be careful about escaping

the shell’s metacharacters). The <code class="xref py py-mod docutils literal notranslate">popen2</code> module offers classes that can

capture standard output and standard error from the subprocess, but the naming

is confusing. The <a class="reference internal" href="../library/subprocess.html#module-subprocess" title="subprocess: Subprocess management."><code class="xref py py-mod docutils literal notranslate">subprocess</code></a> module cleans this up, providing a unified

interface that offers all the features you might need.

Instead of <code class="xref py py-mod docutils literal notranslate">popen2</code>’s collection of classes, <a class="reference internal" href="../library/subprocess.html#module-subprocess" title="subprocess: Subprocess management."><code class="xref py py-mod docutils literal notranslate">subprocess</code></a> contains a

single class called <code class="xref py py-class docutils literal notranslate">Popen</code> whose constructor supports a number of

different keyword arguments.

<div class="highlight-python3 notranslate"><div class="highlight"><pre>class Popen(args, bufsize=0, executable=None,

stdin=None, stdout=None, stderr=None,

preexec_fn=None, close_fds=False, shell=False,

cwd=None, env=None, universal_newlines=False,

startupinfo=None, creationflags=0):

</pre></div>

</div>

args is commonly a sequence of strings that will be the arguments to the

program executed as the subprocess. (If the shell argument is true, args

can be a string which will then be passed on to the shell for interpretation,

just as <a class="reference internal" href="../library/os.html#os.system" title="os.system"><code class="xref py py-func docutils literal notranslate">os.system()</code></a> does.)

stdin, stdout, and stderr specify what the subprocess’s input, output, and

error streams will be. You can provide a file object or a file descriptor, or

you can use the constant <code class="docutils literal notranslate">subprocess.PIPE</code> to create a pipe between the

subprocess and the parent.

The constructor has a number of handy options:

<li>close_fds requests that all file descriptors be closed before running the

subprocess.</li>

<li>cwd specifies the working directory in which the subprocess will be executed

(defaulting to whatever the parent’s working directory is).</li>

<li>env is a dictionary specifying environment variables.</li>

<li>preexec_fn is a function that gets called before the child is started.</li>

<li>universal_newlines opens the child’s input and output using Python’s

<a class="reference internal" href="../glossary.html#term-universal-newlines">universal newlines</a> feature.</li>

</ul>

Once you’ve created the <code class="xref py py-class docutils literal notranslate">Popen</code> instance, you can call its <code class="xref py py-meth docutils literal notranslate">wait()</code>

method to pause until the subprocess has exited, <code class="xref py py-meth docutils literal notranslate">poll()</code> to check if it’s

exited without pausing, or <code class="docutils literal notranslate">communicate(data)</code> to send the string data

to the subprocess’s standard input. <code class="docutils literal notranslate">communicate(data)</code> then reads any

data that the subprocess has sent to its standard output or standard error,

returning a tuple <code class="docutils literal notranslate">(stdout_data, stderr_data)</code>.

<code class="xref py py-func docutils literal notranslate">call()</code> is a shortcut that passes its arguments along to the <code class="xref py py-class docutils literal notranslate">Popen</code>

constructor, waits for the command to complete, and returns the status code of

the subprocess. It can serve as a safer analog to <a class="reference internal" href="../library/os.html#os.system" title="os.system"><code class="xref py py-func docutils literal notranslate">os.system()</code></a>:

<div class="highlight-python3 notranslate"><div class="highlight"><pre>sts = subprocess.call(['dpkg', '-i', '/tmp/new-package.deb'])

if sts == 0:

# Success

...

else:

# dpkg returned an error

...

</pre></div>

</div>

The command is invoked without use of the shell. If you really do want to use

the shell, you can add <code class="docutils literal notranslate">shell=True</code> as a keyword argument and provide a string

instead of a sequence:

<div class="highlight-python3 notranslate"><div class="highlight"><pre>sts = subprocess.call('dpkg -i /tmp/new-package.deb', shell=True)

</pre></div>

</div>

The PEP takes various examples of shell and Python code and shows how they’d be

translated into Python code that uses <a class="reference internal" href="../library/subprocess.html#module-subprocess" title="subprocess: Subprocess management."><code class="xref py py-mod docutils literal notranslate">subprocess</code></a>. Reading this section

of the PEP is highly recommended.

Ayrıca bakınız

<dt><a class="pep reference external" href="https://peps.python.org/pep-0324/">PEP 324</a> - subprocess - New process module</dt><dd>Written and implemented by Peter Åstrand, with assistance from Fredrik Lundh and

others.

</dd>

</dl>

</div>

</section>

<h2>PEP 327: Decimal Data Type<a class="headerlink" href="#pep-327-decimal-data-type" title="Permalink to this heading">¶</a></h2>

Python has always supported floating-point (FP) numbers, based on the underlying

C double type, as a data type. However, while most programming

languages provide a floating-point type, many people (even programmers) are

unaware that floating-point numbers don’t represent certain decimal fractions

accurately. The new <code class="xref py py-class docutils literal notranslate">Decimal</code> type can represent these fractions

accurately, up to a user-specified precision limit.

<h3>Why is Decimal needed?<a class="headerlink" href="#why-is-decimal-needed" title="Permalink to this heading">¶</a></h3>

The limitations arise from the representation used for floating-point numbers.

FP numbers are made up of three components:

<li>The sign, which is positive or negative.</li>

<li>The mantissa, which is a single-digit binary number followed by a fractional

part. For example, <code class="docutils literal notranslate">1.01</code> in base-2 notation is <code class="docutils literal notranslate">1 + 0/2 + 1/4</code>, or 1.25 in

decimal notation.</li>

<li>The exponent, which tells where the decimal point is located in the number

represented.</li>

</ul>

For example, the number 1.25 has positive sign, a mantissa value of 1.01 (in

binary), and an exponent of 0 (the decimal point doesn’t need to be shifted).

The number 5 has the same sign and mantissa, but the exponent is 2 because the

mantissa is multiplied by 4 (2 to the power of the exponent 2); 1.25 * 4 equals

5.

Modern systems usually provide floating-point support that conforms to a

standard called IEEE 754. C’s double type is usually implemented as a

64-bit IEEE 754 number, which uses 52 bits of space for the mantissa. This

means that numbers can only be specified to 52 bits of precision. If you’re

trying to represent numbers whose expansion repeats endlessly, the expansion is

cut off after 52 bits. Unfortunately, most software needs to produce output in

base 10, and common fractions in base 10 are often repeating decimals in binary.

For example, 1.1 decimal is binary <code class="docutils literal notranslate">1.0001100110011 ...</code>; .1 = 1/16 + 1/32 +

1/256 plus an infinite number of additional terms. IEEE 754 has to chop off

that infinitely repeated decimal after 52 digits, so the representation is

slightly inaccurate.

Sometimes you can see this inaccuracy when the number is printed:

<div class="highlight-python3 notranslate"><div class="highlight"><pre>>>> 1.1

1.1000000000000001

</pre></div>

</div>

The inaccuracy isn’t always visible when you print the number because the

FP-to-decimal-string conversion is provided by the C library, and most C libraries try

to produce sensible output. Even if it’s not displayed, however, the inaccuracy

is still there and subsequent operations can magnify the error.

For many applications this doesn’t matter. If I’m plotting points and

displaying them on my monitor, the difference between 1.1 and 1.1000000000000001

is too small to be visible. Reports often limit output to a certain number of

decimal places, and if you round the number to two or three or even eight

decimal places, the error is never apparent. However, for applications where it

does matter, it’s a lot of work to implement your own custom arithmetic

routines.

Hence, the <code class="xref py py-class docutils literal notranslate">Decimal</code> type was created.

</section>

<h3>The <code class="xref py py-class docutils literal notranslate">Decimal</code> type<a class="headerlink" href="#the-decimal-type" title="Permalink to this heading">¶</a></h3>

A new module, <a class="reference internal" href="../library/decimal.html#module-decimal" title="decimal: Implementation of the General Decimal Arithmetic Specification."><code class="xref py py-mod docutils literal notranslate">decimal</code></a>, was added to Python’s standard library. It

contains two classes, <code class="xref py py-class docutils literal notranslate">Decimal</code> and <code class="xref py py-class docutils literal notranslate">Context</code>. <code class="xref py py-class docutils literal notranslate">Decimal</code>

instances represent numbers, and <code class="xref py py-class docutils literal notranslate">Context</code> instances are used to wrap up

various settings such as the precision and default rounding mode.

<code class="xref py py-class docutils literal notranslate">Decimal</code> instances are immutable, like regular Python integers and FP

numbers; once it’s been created, you can’t change the value an instance

represents. <code class="xref py py-class docutils literal notranslate">Decimal</code> instances can be created from integers or

strings:

<div class="highlight-python3 notranslate"><div class="highlight"><pre>>>> import decimal

>>> decimal.Decimal(1972)

Decimal("1972")

>>> decimal.Decimal("1.1")

Decimal("1.1")

</pre></div>

</div>

You can also provide tuples containing the sign, the mantissa represented as a

tuple of decimal digits, and the exponent:

<div class="highlight-python3 notranslate"><div class="highlight"><pre>>>> decimal.Decimal((1, (1, 4, 7, 5), -2))

Decimal("-14.75")

</pre></div>

</div>

Cautionary note: the sign bit is a Boolean value, so 0 is positive and 1 is

negative.

Converting from floating-point numbers poses a bit of a problem: should the FP

number representing 1.1 turn into the decimal number for exactly 1.1, or for 1.1

plus whatever inaccuracies are introduced? The decision was to dodge the issue

and leave such a conversion out of the API. Instead, you should convert the

floating-point number into a string using the desired precision and pass the

string to the <code class="xref py py-class docutils literal notranslate">Decimal</code> constructor:

<div class="highlight-python3 notranslate"><div class="highlight"><pre>>>> f = 1.1

>>> decimal.Decimal(str(f))

Decimal("1.1")

>>> decimal.Decimal('%.12f' % f)

Decimal("1.100000000000")

</pre></div>

</div>

Once you have <code class="xref py py-class docutils literal notranslate">Decimal</code> instances, you can perform the usual mathematical

operations on them. One limitation: exponentiation requires an integer

exponent:

<div class="highlight-python3 notranslate"><div class="highlight"><pre>>>> a = decimal.Decimal('35.72')

>>> b = decimal.Decimal('1.73')

>>> a+b

Decimal("37.45")

>>> a-b

Decimal("33.99")

>>> a*b

Decimal("61.7956")

>>> a/b

Decimal("20.64739884393063583815028902")

>>> a ** 2

Decimal("1275.9184")

>>> a**b

Traceback (most recent call last):

...

decimal.InvalidOperation: x ** (non-integer)

</pre></div>

</div>

You can combine <code class="xref py py-class docutils literal notranslate">Decimal</code> instances with integers, but not with

floating-point numbers:

<div class="highlight-python3 notranslate"><div class="highlight"><pre>>>> a + 4

Decimal("39.72")

>>> a + 4.5

Traceback (most recent call last):

...

TypeError: You can interact Decimal only with int, long or Decimal data types.

>>>

</pre></div>

</div>

<code class="xref py py-class docutils literal notranslate">Decimal</code> numbers can be used with the <a class="reference internal" href="../library/math.html#module-math" title="math: Mathematical functions (sin() etc.)."><code class="xref py py-mod docutils literal notranslate">math</code></a> and <a class="reference internal" href="../library/cmath.html#module-cmath" title="cmath: Mathematical functions for complex numbers."><code class="xref py py-mod docutils literal notranslate">cmath</code></a>

modules, but note that they’ll be immediately converted to floating-point

numbers before the operation is performed, resulting in a possible loss of

precision and accuracy. You’ll also get back a regular floating-point number

and not a <code class="xref py py-class docutils literal notranslate">Decimal</code>.

<div class="highlight-python3 notranslate"><div class="highlight"><pre>>>> import math, cmath

>>> d = decimal.Decimal('123456789012.345')

>>> math.sqrt(d)

351364.18288201344

>>> cmath.sqrt(-d)

351364.18288201344j

</pre></div>

</div>

<code class="xref py py-class docutils literal notranslate">Decimal</code> instances have a <code class="xref py py-meth docutils literal notranslate">sqrt()</code> method that returns a

<code class="xref py py-class docutils literal notranslate">Decimal</code>, but if you need other things such as trigonometric functions

you’ll have to implement them.

<div class="highlight-python3 notranslate"><div class="highlight"><pre>>>> d.sqrt()

Decimal("351364.1828820134592177245001")

</pre></div>

</div>

</section>

<h3>The <code class="xref py py-class docutils literal notranslate">Context</code> type<a class="headerlink" href="#the-context-type" title="Permalink to this heading">¶</a></h3>

Instances of the <code class="xref py py-class docutils literal notranslate">Context</code> class encapsulate several settings for

decimal operations:

<li><code class="xref py py-attr docutils literal notranslate">prec</code> is the precision, the number of decimal places.</li>

<li><code class="xref py py-attr docutils literal notranslate">rounding</code> specifies the rounding mode. The <a class="reference internal" href="../library/decimal.html#module-decimal" title="decimal: Implementation of the General Decimal Arithmetic Specification."><code class="xref py py-mod docutils literal notranslate">decimal</code></a> module has

constants for the various possibilities: <code class="xref py py-const docutils literal notranslate">ROUND_DOWN</code>,

<code class="xref py py-const docutils literal notranslate">ROUND_CEILING</code>, <code class="xref py py-const docutils literal notranslate">ROUND_HALF_EVEN</code>, and various others.</li>

<li><code class="xref py py-attr docutils literal notranslate">traps</code> is a dictionary specifying what happens on encountering certain

error conditions: either an exception is raised or a value is returned. Some

examples of error conditions are division by zero, loss of precision, and

overflow.</li>

</ul>

There’s a thread-local default context available by calling <code class="xref py py-func docutils literal notranslate">getcontext()</code>;

you can change the properties of this context to alter the default precision,

rounding, or trap handling. The following example shows the effect of changing

the precision of the default context:

28

>>> decimal.Decimal(1) / decimal.Decimal(7)

Decimal("0.1428571428571428571428571429")

Decimal("0.142857143")

</pre></div>

</div>

The default action for error conditions is selectable; the module can either

return a special value such as infinity or not-a-number, or exceptions can be

raised:

<div class="highlight-python3 notranslate"><div class="highlight"><pre>>>> decimal.Decimal(1) / decimal.Decimal(0)

Traceback (most recent call last):

...

decimal.DivisionByZero: x / 0

>>> decimal.getcontext().traps[decimal.DivisionByZero] = False

Decimal("Infinity")

>>>

</pre></div>

</div>

The <code class="xref py py-class docutils literal notranslate">Context</code> instance also has various methods for formatting numbers

such as <code class="xref py py-meth docutils literal notranslate">to_eng_string()</code> and <code class="xref py py-meth docutils literal notranslate">to_sci_string()</code>.

For more information, see the documentation for the <a class="reference internal" href="../library/decimal.html#module-decimal" title="decimal: Implementation of the General Decimal Arithmetic Specification."><code class="xref py py-mod docutils literal notranslate">decimal</code></a> module, which

includes a quick-start tutorial and a reference.

Ayrıca bakınız

<dt><a class="pep reference external" href="https://peps.python.org/pep-0327/">PEP 327</a> - Decimal Data Type</dt><dd>Written by Facundo Batista and implemented by Facundo Batista, Eric Price,

Raymond Hettinger, Aahz, and Tim Peters.

</dd>

<dt><a class="reference external" href="http://www.lahey.com/float.htm">http://www.lahey.com/float.htm</a></dt><dd>The article uses Fortran code to illustrate many of the problems that

floating-point inaccuracy can cause.

</dd>

<dt><a class="reference external" href="http://speleotrove.com/decimal/">http://speleotrove.com/decimal/</a></dt><dd>A description of a decimal-based representation. This representation is being

proposed as a standard, and underlies the new Python decimal type. Much of this

material was written by Mike Cowlishaw, designer of the Rexx language.

</dd>

</dl>

</div>

</section>

<h2>PEP 328: Multi-line Imports<a class="headerlink" href="#pep-328-multi-line-imports" title="Permalink to this heading">¶</a></h2>

One language change is a small syntactic tweak aimed at making it easier to

import many names from a module. In a <code class="docutils literal notranslate">from module import names</code> statement,

names is a sequence of names separated by commas. If the sequence is very

long, you can either write multiple imports from the same module, or you can use

backslashes to escape the line endings like this:

<div class="highlight-python3 notranslate"><div class="highlight"><pre>from SimpleXMLRPCServer import SimpleXMLRPCServer,\

SimpleXMLRPCRequestHandler,\

CGIXMLRPCRequestHandler,\

resolve_dotted_attribute

</pre></div>

</div>

The syntactic change in Python 2.4 simply allows putting the names within

parentheses. Python ignores newlines within a parenthesized expression, so the

backslashes are no longer needed:

<div class="highlight-python3 notranslate"><div class="highlight"><pre>from SimpleXMLRPCServer import (SimpleXMLRPCServer,

SimpleXMLRPCRequestHandler,

CGIXMLRPCRequestHandler,

resolve_dotted_attribute)

</pre></div>

</div>

The PEP also proposes that all <a class="reference internal" href="../reference/simple_stmts.html#import"><code class="xref std std-keyword docutils literal notranslate">import</code></a> statements be absolute imports,

with a leading <code class="docutils literal notranslate">.</code> character to indicate a relative import. This part of the

PEP was not implemented for Python 2.4, but was completed for Python 2.5.

Ayrıca bakınız

<dt><a class="pep reference external" href="https://peps.python.org/pep-0328/">PEP 328</a> - Imports: Multi-Line and Absolute/Relative</dt><dd>Written by Aahz. Multi-line imports were implemented by Dima Dorfman.

</dd>

</dl>

</div>

</section>

<h2>PEP 331: Locale-Independent Float/String Conversions<a class="headerlink" href="#pep-331-locale-independent-float-string-conversions" title="Permalink to this heading">¶</a></h2>

The <a class="reference internal" href="../library/locale.html#module-locale" title="locale: Internationalization services."><code class="xref py py-mod docutils literal notranslate">locale</code></a> modules lets Python software select various conversions and

display conventions that are localized to a particular country or language.

However, the module was careful to not change the numeric locale because various

functions in Python’s implementation required that the numeric locale remain set

to the <code class="docutils literal notranslate">'C'</code> locale. Often this was because the code was using the C

library’s <code class="xref c c-func docutils literal notranslate">atof()</code> function.

Not setting the numeric locale caused trouble for extensions that used third-party

C libraries, however, because they wouldn’t have the correct locale set.

The motivating example was GTK+, whose user interface widgets weren’t displaying

numbers in the current locale.

The solution described in the PEP is to add three new functions to the Python

API that perform ASCII-only conversions, ignoring the locale setting:

<li><code class="docutils literal notranslate">PyOS_ascii_strtod(str, ptr)</code> and <code class="docutils literal notranslate">PyOS_ascii_atof(str, ptr)</code>

both convert a string to a C double.</li>

<li><code class="docutils literal notranslate">PyOS_ascii_formatd(buffer, buf_len, format, d)</code> converts a

double to an ASCII string.</li>

</ul>

The code for these functions came from the GLib library

(<a class="reference external" href="https://developer-old.gnome.org/glib/2.26/">https://developer-old.gnome.org/glib/2.26/</a>), whose developers kindly

relicensed the relevant functions and donated them to the Python Software

Foundation. The <a class="reference internal" href="../library/locale.html#module-locale" title="locale: Internationalization services."><code class="xref py py-mod docutils literal notranslate">locale</code></a> module can now change the numeric locale,

letting extensions such as GTK+ produce the correct results.

Ayrıca bakınız

<dt><a class="pep reference external" href="https://peps.python.org/pep-0331/">PEP 331</a> - Locale-Independent Float/String Conversions</dt><dd>Written by Christian R. Reis, and implemented by Gustavo Carneiro.

</dd>

</dl>

</div>

</section>

<h2>Other Language Changes<a class="headerlink" href="#other-language-changes" title="Permalink to this heading">¶</a></h2>

Here are all of the changes that Python 2.4 makes to the core Python language.

<ul>

<li>Decorators for functions and methods were added (<a class="pep reference external" href="https://peps.python.org/pep-0318/">PEP 318</a>).</li>

<li>Built-in <a class="reference internal" href="../library/stdtypes.html#set" title="set"><code class="xref py py-func docutils literal notranslate">set()</code></a> and <a class="reference internal" href="../library/stdtypes.html#frozenset" title="frozenset"><code class="xref py py-func docutils literal notranslate">frozenset()</code></a> types were added (<a class="pep reference external" href="https://peps.python.org/pep-0218/">PEP 218</a>).

Other new built-ins include the <code class="docutils literal notranslate">reversed(seq)</code> function (<a class="pep reference external" href="https://peps.python.org/pep-0322/">PEP 322</a>).</li>

<li>Generator expressions were added (<a class="pep reference external" href="https://peps.python.org/pep-0289/">PEP 289</a>).</li>

<li>Certain numeric expressions no longer return values restricted to 32 or 64

bits (<a class="pep reference external" href="https://peps.python.org/pep-0237/">PEP 237</a>).</li>

<li>You can now put parentheses around the list of names in a <code class="docutils literal notranslate">from module import

names</code> statement (<a class="pep reference external" href="https://peps.python.org/pep-0328/">PEP 328</a>).</li>

<li>The <a class="reference internal" href="../library/stdtypes.html#dict.update" title="dict.update"><code class="xref py py-meth docutils literal notranslate">dict.update()</code></a> method now accepts the same argument forms as the

<a class="reference internal" href="../library/stdtypes.html#dict" title="dict"><code class="xref py py-class docutils literal notranslate">dict</code></a> constructor. This includes any mapping, any iterable of key/value

pairs, and keyword arguments. (Contributed by Raymond Hettinger.)</li>

<li>The string methods <code class="xref py py-meth docutils literal notranslate">ljust()</code>, <code class="xref py py-meth docutils literal notranslate">rjust()</code>, and <code class="xref py py-meth docutils literal notranslate">center()</code> now take

an optional argument for specifying a fill character other than a space.

(Contributed by Raymond Hettinger.)</li>

<li>Strings also gained an <code class="xref py py-meth docutils literal notranslate">rsplit()</code> method that works like the <code class="xref py py-meth docutils literal notranslate">split()</code>

method but splits from the end of the string. (Contributed by Sean

Reifschneider.)

<div class="highlight-python3 notranslate"><div class="highlight"><pre>>>> 'www.python.org'.split('.', 1)

['www', 'python.org']

'www.python.org'.rsplit('.', 1)

['www.python', 'org']

</pre></div>

</div>

</li>

<li>Three keyword parameters, cmp, key, and reverse, were added to the

<code class="xref py py-meth docutils literal notranslate">sort()</code> method of lists. These parameters make some common usages of

<code class="xref py py-meth docutils literal notranslate">sort()</code> simpler. All of these parameters are optional.

For the cmp parameter, the value should be a comparison function that takes

two parameters and returns -1, 0, or +1 depending on how the parameters compare.

This function will then be used to sort the list. Previously this was the only

parameter that could be provided to <code class="xref py py-meth docutils literal notranslate">sort()</code>.

key should be a single-parameter function that takes a list element and

returns a comparison key for the element. The list is then sorted using the

comparison keys. The following example sorts a list case-insensitively:

>>> L.sort() # Case-sensitive sort

>>> L

['A', 'D', 'b', 'c']

>>> # Using 'key' parameter to sort list

>>> L.sort(key=lambda x: x.lower())

>>> L

['A', 'b', 'c', 'D']

>>> # Old-fashioned way

>>> L.sort(cmp=lambda x,y: cmp(x.lower(), y.lower()))

>>> L

['A', 'b', 'c', 'D']

</pre></div>

</div>

The last example, which uses the cmp parameter, is the old way to perform a

case-insensitive sort. It works but is slower than using a key parameter.

Using key calls <code class="xref py py-meth docutils literal notranslate">lower()</code> method once for each element in the list while

using cmp will call it twice for each comparison, so using key saves on

invocations of the <code class="xref py py-meth docutils literal notranslate">lower()</code> method.

For simple key functions and comparison functions, it is often possible to avoid

a <a class="reference internal" href="../reference/expressions.html#lambda"><code class="xref std std-keyword docutils literal notranslate">lambda</code></a> expression by using an unbound method instead. For example,

the above case-insensitive sort is best written as:

<div class="highlight-python3 notranslate"><div class="highlight"><pre>>>> L.sort(key=str.lower)

>>> L

['A', 'b', 'c', 'D']

</pre></div>

</div>

Finally, the reverse parameter takes a Boolean value. If the value is true,

the list will be sorted into reverse order. Instead of <code class="docutils literal notranslate">L.sort();

L.reverse()</code>, you can now write <code class="docutils literal notranslate">L.sort(reverse=True)</code>.

The results of sorting are now guaranteed to be stable. This means that two

entries with equal keys will be returned in the same order as they were input.

For example, you can sort a list of people by name, and then sort the list by

age, resulting in a list sorted by age where people with the same age are in

name-sorted order.

(All changes to <code class="xref py py-meth docutils literal notranslate">sort()</code> contributed by Raymond Hettinger.)

</li>

<li>There is a new built-in function <code class="docutils literal notranslate">sorted(iterable)</code> that works like the

in-place <a class="reference internal" href="../library/stdtypes.html#list.sort" title="list.sort"><code class="xref py py-meth docutils literal notranslate">list.sort()</code></a> method but can be used in expressions. The

differences are:</li>

<li>the input may be any iterable;</li>

<li>a newly formed copy is sorted, leaving the original intact; and</li>

<li>the expression returns the new sorted copy

<div class="highlight-python3 notranslate"><div class="highlight"><pre>>>> L = [9,7,8,3,2,4,1,6,5]

>>> [10+i for i in sorted(L)] # usable in a list comprehension

[11, 12, 13, 14, 15, 16, 17, 18, 19]

>>> L # original is left unchanged

[9,7,8,3,2,4,1,6,5]

>>> sorted('Monty Python') # any iterable may be an input

[' ', 'M', 'P', 'h', 'n', 'n', 'o', 'o', 't', 't', 'y', 'y']

>>> # List the contents of a dict sorted by key values

>>> colormap = dict(red=1, blue=2, green=3, black=4, yellow=5)

>>> for k, v in sorted(colormap.iteritems()):

... print k, v

...

black 4

View remainder of file in raw view

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

FilesExpand file tree

2.4.html

Latest commit

History

2.4.html

File metadata and controls