pensepython.github.io/08-string.html at master · PensePython/pensepython.github.io

History

669 lines (642 loc) · 44.9 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

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"

"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<head>

<title>Strings — Pense Python 2e documentation</title>

var DOCUMENTATION_OPTIONS = {

URL_ROOT: './',

VERSION: '2e',

COLLAPSE_INDEX: false,

FILE_SUFFIX: '.html',

HAS_SOURCE: true

};

</script>

</head>

<h1>Strings<a class="headerlink" href="#strings" title="Permalink to this headline">¶</a></h1>

Strings are not like integers, floats, and booleans. A string is a

sequence, which means it is an ordered collection of other values.

In this chapter you’ll see how to access the characters that make up a

string, and you’ll learn about some of the methods strings provide.

<h2>A string is a sequence<a class="headerlink" href="#a-string-is-a-sequence" title="Permalink to this headline">¶</a></h2>

A string is a sequence of characters. You can access the characters one

at a time with the bracket operator:

<div class="highlight-python"><div class="highlight"><pre>>>> fruit = 'banana'

>>> letter = fruit[1]

</pre></div>

</div>

The second statement selects character number 1 from fruit and assigns

it to letter.

The expression in brackets is called an index. The index indicates

which character in the sequence you want (hence the name).

But you might not get what you expect:

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

'a'

</pre></div>

</div>

For most people, the first letter of <code class="docutils literal">'banana'</code> is b, not a. But for

computer scientists, the index is an offset from the beginning of the

string, and the offset of the first letter is zero.

<div class="highlight-python"><div class="highlight"><pre>>>> letter = fruit[0]

>>> letter

'b'

</pre></div>

</div>

So b is the 0th letter (“zero-eth”) of <code class="docutils literal">'banana'</code>, a is the 1th letter

(“one-eth”), and n is the 2th letter (“two-eth”).

As an index you can use an expression that contains variables and

operators:

<div class="highlight-python"><div class="highlight"><pre>>>> i = 1

>>> fruit[i]

'a'

>>> fruit[i+1]

'n'

</pre></div>

</div>

But the value of the index has to be an integer. Otherwise you get:

TypeError: string indices must be integers

</pre></div>

</div>

len is a built-in function that returns the number of characters in a

string:

<div class="highlight-python"><div class="highlight"><pre>>>> fruit = 'banana'

>>> len(fruit)

6

</pre></div>

</div>

To get the last letter of a string, you might be tempted to try

something like this:

<div class="highlight-python"><div class="highlight"><pre>>>> length = len(fruit)

>>> last = fruit[length]

IndexError: string index out of range

</pre></div>

</div>

The reason for the IndexError is that there is no letter in ’banana’

with the index 6. Since we started counting at zero, the six letters are

numbered 0 to 5. To get the last character, you have to subtract 1 from

length:

<div class="highlight-python"><div class="highlight"><pre>>>> last = fruit[length-1]

>>> last

'a'

</pre></div>

</div>

Or you can use negative indices, which count backward from the end of

the string. The expression fruit[-1] yields the last letter, fruit[-2]

yields the second to last, and so on.

</div>

<h2>Traversal with a for loop<a class="headerlink" href="#traversal-with-a-for-loop" title="Permalink to this headline">¶</a></h2>

A lot of computations involve processing a string one character at a

time. Often they start at the beginning, select each character in turn,

do something to it, and continue until the end. This pattern of

processing is called a traversal. One way to write a traversal is

with a while loop:

<div class="highlight-python"><div class="highlight"><pre>index = 0

while index < len(fruit):

letter = fruit[index]

print(letter)

index = index + 1

</pre></div>

</div>

This loop traverses the string and displays each letter on a line by

itself. The loop condition is index < len(fruit), so when index is equal

to the length of the string, the condition is false, and the body of the

loop doesn’t run. The last character accessed is the one with the index

len(fruit)-1, which is the last character in the string.

As an exercise, write a function that takes a string as an argument and

displays the letters backward, one per line.

Another way to write a traversal is with a for loop:

<div class="highlight-python"><div class="highlight"><pre>for letter in fruit:

print(letter)

</pre></div>

</div>

Each time through the loop, the next character in the string is assigned

to the variable letter. The loop continues until no characters are left.

The following example shows how to use concatenation (string addition)

and a for loop to generate an abecedarian series (that is, in

alphabetical order). In Robert McCloskey’s book Make Way for

Ducklings, the names of the ducklings are Jack, Kack, Lack, Mack, Nack,

Ouack, Pack, and Quack. This loop outputs these names in order:

<div class="highlight-python"><div class="highlight"><pre>prefixes = 'JKLMNOPQ'

suffix = 'ack'

for letter in prefixes:

print(letter + suffix)

</pre></div>

</div>

The output is:

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

Kack

Lack

Mack

Nack

Oack

Pack

Qack

</pre></div>

</div>

Of course, that’s not quite right because “Ouack” and “Quack” are

misspelled. As an exercise, modify the program to fix this error.

</div>

<h2>String slices<a class="headerlink" href="#string-slices" title="Permalink to this headline">¶</a></h2>

A segment of a string is called a slice. Selecting a slice is

similar to selecting a character:

<div class="highlight-python"><div class="highlight"><pre>>>> s = 'Monty Python'

>>> s[0:5]

'Monty'

>>> s[6:12]

'Python'

</pre></div>

</div>

The operator returns the part of the string from the “n-eth” character

to the “m-eth” character, including the first but excluding the last.

This behavior is counterintuitive, but it might help to imagine the

indices pointing between the characters, as in Figure [fig.banana].

Slice indices.

</div>

If you omit the first index (before the colon), the slice starts at the

beginning of the string. If you omit the second index, the slice goes to

the end of the string:

<div class="highlight-python"><div class="highlight"><pre>>>> fruit = 'banana'

>>> fruit[:3]

'ban'

>>> fruit[3:]

'ana'

</pre></div>

</div>

If the first index is greater than or equal to the second the result is

an empty string, represented by two quotation marks:

<div class="highlight-python"><div class="highlight"><pre>>>> fruit = 'banana'

>>> fruit[3:3]

''

</pre></div>

</div>

An empty string contains no characters and has length 0, but other than

that, it is the same as any other string.

Continuing this example, what do you think fruit[:] means? Try it and

see.

</div>

<h2>Strings are immutable<a class="headerlink" href="#strings-are-immutable" title="Permalink to this headline">¶</a></h2>

It is tempting to use the operator on the left side of an assignment,

with the intention of changing a character in a string. For example:

<div class="highlight-python"><div class="highlight"><pre>>>> greeting = 'Hello, world!'

>>> greeting[0] = 'J'

TypeError: 'str' object does not support item assignment

</pre></div>

</div>

The “object” in this case is the string and the “item” is the character

you tried to assign. For now, an object is the same thing as a value,

but we will refine that definition later (Section [equivalence]).

The reason for the error is that strings are immutable, which means

you can’t change an existing string. The best you can do is create a new

string that is a variation on the original:

<div class="highlight-python"><div class="highlight"><pre>>>> greeting = 'Hello, world!'

>>> new_greeting = 'J' + greeting[1:]

>>> new_greeting

'Jello, world!'

</pre></div>

</div>

This example concatenates a new first letter onto a slice of greeting.

It has no effect on the original string.

</div>

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

What does the following function do?

<div class="highlight-python"><div class="highlight"><pre>def find(word, letter):

index = 0

while index < len(word):

if word[index] == letter:

return index

index = index + 1

return -1

</pre></div>

</div>

In a sense, find is the inverse of the operator. Instead of taking an

index and extracting the corresponding character, it takes a character

and finds the index where that character appears. If the character is

not found, the function returns -1.

This is the first example we have seen of a return statement inside a

loop. If word[index] == letter, the function breaks out of the loop and

returns immediately.

If the character doesn’t appear in the string, the program exits the

loop normally and returns -1.

This pattern of computation—traversing a sequence and returning when we

find what we are looking for—is called a search.

As an exercise, modify find so that it has a third parameter, the index

in word where it should start looking.

</div>

<h2>Looping and counting<a class="headerlink" href="#looping-and-counting" title="Permalink to this headline">¶</a></h2>

The following program counts the number of times the letter a appears in

a string:

<div class="highlight-python"><div class="highlight"><pre>word = 'banana'

count = 0

for letter in word:

if letter == 'a':

count = count + 1

print(count)

</pre></div>

</div>

This program demonstrates another pattern of computation called a

counter. The variable count is initialized to 0 and then incremented

each time an a is found. When the loop exits, count contains the

result—the total number of a’s.

As an exercise, encapsulate this code in a function named count, and

generalize it so that it accepts the string and the letter as arguments.

Then rewrite the function so that instead of traversing the string, it

uses the three-parameter version of find from the previous section.

</div>

<h2>String methods<a class="headerlink" href="#string-methods" title="Permalink to this headline">¶</a></h2>

Strings provide methods that perform a variety of useful operations. A

method is similar to a function—it takes arguments and returns a

value—but the syntax is different. For example, the method upper takes a

string and returns a new string with all uppercase letters.

Instead of the function syntax upper(word), it uses the method syntax

word.upper().

<div class="highlight-python"><div class="highlight"><pre>>>> word = 'banana'

>>> new_word = word.upper()

>>> new_word

'BANANA'

</pre></div>

</div>

This form of dot notation specifies the name of the method, upper, and

the name of the string to apply the method to, word. The empty

parentheses indicate that this method takes no arguments.

A method call is called an invocation; in this case, we would say

that we are invoking upper on word.

As it turns out, there is a string method named find that is remarkably

similar to the function we wrote:

<div class="highlight-python"><div class="highlight"><pre>>>> word = 'banana'

>>> index = word.find('a')

>>> index

1

</pre></div>

</div>

In this example, we invoke find on word and pass the letter we are

looking for as a parameter.

Actually, the find method is more general than our function; it can find

substrings, not just characters:

<div class="highlight-python"><div class="highlight"><pre>>>> word.find('na')

2

</pre></div>

</div>

By default, find starts at the beginning of the string, but it can take

a second argument, the index where it should start:

4

</pre></div>

</div>

This is an example of an optional argument; find can also take a

third argument, the index where it should stop:

<div class="highlight-python"><div class="highlight"><pre>>>> name = 'bob'

>>> name.find('b', 1, 2)

-1

</pre></div>

</div>

This search fails because b does not appear in the index range from 1 to

2, not including 2. Searching up to, but not including, the second index

makes find consistent with the slice operator.

</div>

<h2>The in operator<a class="headerlink" href="#the-in-operator" title="Permalink to this headline">¶</a></h2>

The word in is a boolean operator that takes two strings and returns

True if the first appears as a substring in the second:

<div class="highlight-python"><div class="highlight"><pre>>>> 'a' in 'banana'

True

>>> 'seed' in 'banana'

False

</pre></div>

</div>

For example, the following function prints all the letters from word1

that also appear in word2:

<div class="highlight-python"><div class="highlight"><pre>def in_both(word1, word2):

for letter in word1:

if letter in word2:

print(letter)

</pre></div>

</div>

With well-chosen variable names, Python sometimes reads like English.

You could read this loop, “for (each) letter in (the first) word, if

(the) letter (appears) in (the second) word, print (the) letter.”

Here’s what you get if you compare apples and oranges:

<div class="highlight-python"><div class="highlight"><pre>>>> in_both('apples', 'oranges')

a

e

s

</pre></div>

</div>

<h2>String comparison<a class="headerlink" href="#string-comparison" title="Permalink to this headline">¶</a></h2>

The relational operators work on strings. To see if two strings are

equal:

<div class="highlight-python"><div class="highlight"><pre>if word == 'banana':

print('All right, bananas.')

</pre></div>

</div>

Other relational operations are useful for putting words in alphabetical

order:

<div class="highlight-python"><div class="highlight"><pre>if word < 'banana':

print('Your word, ' + word + ', comes before banana.')

elif word > 'banana':

else:

print('All right, bananas.')

</pre></div>

</div>

Python does not handle uppercase and lowercase letters the same way

people do. All the uppercase letters come before all the lowercase

letters, so:

<div class="highlight-python"><div class="highlight"><pre>Your word, Pineapple, comes before banana.

</pre></div>

</div>

A common way to address this problem is to convert strings to a standard

format, such as all lowercase, before performing the comparison. Keep

that in mind in case you have to defend yourself against a man armed

with a Pineapple.

</div>

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

When you use indices to traverse the values in a sequence, it is tricky

to get the beginning and end of the traversal right. Here is a function

that is supposed to compare two words and return True if one of the

words is the reverse of the other, but it contains two errors:

<div class="highlight-python"><div class="highlight"><pre>def is_reverse(word1, word2):

if len(word1) != len(word2):

return False

i = 0

j = len(word2)

while j > 0:

if word1[i] != word2[j]:

return False

i = i+1

j = j-1

return True

</pre></div>

</div>

The first if statement checks whether the words are the same length. If

not, we can return False immediately. Otherwise, for the rest of the

function, we can assume that the words are the same length. This is an

example of the guardian pattern in Section [guardian].

i and j are indices: i traverses word1 forward while j traverses word2

backward. If we find two letters that don’t match, we can return False

immediately. If we get through the whole loop and all the letters match,

we return True.

If we test this function with the words “pots” and “stop”, we expect the

return value True, but we get an IndexError:

<div class="highlight-python"><div class="highlight"><pre>>>> is_reverse('pots', 'stop')

...

File "reverse.py", line 15, in is_reverse

if word1[i] != word2[j]:

IndexError: string index out of range

</pre></div>

</div>

For debugging this kind of error, my first move is to print the values

of the indices immediately before the line where the error appears.

<div class="highlight-python"><div class="highlight"><pre>while j > 0:

print(i, j) # print here

return False

i = i+1

j = j-1

</pre></div>

</div>

Now when I run the program again, I get more information:

0 4

...

IndexError: string index out of range

</pre></div>

</div>

The first time through the loop, the value of j is 4, which is out of

range for the string <code class="docutils literal">'pots'</code>. The index of the last character is 3,

so the initial value for j should be len(word2)-1.

If I fix that error and run the program again, I get:

0 3

1 2

2 1

True

</pre></div>

</div>

This time we get the right answer, but it looks like the loop only ran

three times, which is suspicious. To get a better idea of what is

happening, it is useful to draw a state diagram. During the first

iteration, the frame for <code class="docutils literal">is_reverse</code> is shown in Figure [fig.state4].

State diagram.

</div>

I took some license by arranging the variables in the frame and adding

dotted lines to show that the values of i and j indicate characters in

word1 and word2.

Starting with this diagram, run the program on paper, changing the

values of i and j during each iteration. Find and fix the second error

in this function. [isreverse]

</div>

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

<dt>objeto (object)</dt>

<dd>Something a variable can refer to. For now, you can use “object” and “value” interchangeably.</dd>

<dt>sequência de formatação (sequence)</dt>

<dd>An ordered collection of values where each value is identified by an integer index.</dd>

<dd>One of the values in a sequence.</dd>

<dt>índice (index)</dt>

<dd>An integer value used to select an item in a sequence, such as a character in a string. In Python indices start from 0.</dd>

<dt>código provisório (slice)</dt>

<dd>A part of a string specified by a range of indices.</dd>

<dt>string vazia (empty string)</dt>

<dd>A string with no characters and length 0, represented by two quotation marks.</dd>

<dt>imutável (immutable)</dt>

<dd>The property of a sequence whose items cannot be changed.</dd>

<dt>percorrer (traverse)</dt>

<dd>To iterate through the items in a sequence, performing a similar operation on each.</dd>

<dt>busca (search)</dt>

<dd>A pattern of traversal that stops when it finds what it is looking for.</dd>

<dt>contador (counter)</dt>

<dd>A variable used to count something, usually initialized to zero and then incremented.</dd>

<dt>invocação (invocation)</dt>

<dd>A statement that calls a method.</dd>

<dt>argumento opcional (optional argument)</dt>

<dd>A function or method argument that is not required.</dd>

</dl>

</div>

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

Read the documentation of the string methods at

<a class="reference external" href="http://docs.python.org/3/library/stdtypes.html#string-methods">http://docs.python.org/3/library/stdtypes.html#string-methods</a>. You might

want to experiment with some of them to make sure you understand how

they work. strip and replace are particularly useful.

The documentation uses a syntax that might be confusing. For example, in

<code class="docutils literal">find(sub[, start[, end]])</code>, the brackets indicate optional arguments.

So sub is required, but start is optional, and if you include start,

then end is optional.

There is a string method called count that is similar to the function in

Section [counter]. Read the documentation of this method and write an

invocation that counts the number of a’s in <code class="docutils literal">'banana'</code>.

A string slice can take a third index that specifies the “step size”;

that is, the number of spaces between successive characters. A step size

of 2 means every other character; 3 means every third, etc.

<div class="highlight-python"><div class="highlight"><pre>>>> fruit = 'banana'

>>> fruit[0:5:2]

'bnn'

</pre></div>

</div>

A step size of -1 goes through the word backwards, so the slice

<code class="docutils literal">[::-1]</code> generates a reversed string.

Use this idiom to write a one-line version of <code class="docutils literal">is_palindrome</code> from

Exercise [palindrome].

The following functions are all intended to check whether a string

contains any lowercase letters, but at least some of them are wrong. For

each function, describe what the function actually does (assuming that

the parameter is a string).

<div class="highlight-python"><div class="highlight"><pre>def any_lowercase1(s):

for c in s:

if c.islower():

return True

else:

return False

def any_lowercase2(s):

for c in s:

if 'c'.islower():

return 'True'

else:

return 'False'

def any_lowercase3(s):

for c in s:

flag = c.islower()

return flag

def any_lowercase4(s):

flag = False

for c in s:

flag = flag or c.islower()

return flag

def any_lowercase5(s):

for c in s:

if not c.islower():

return False

return True

</pre></div>

</div>

[exrotate] A Caesar cypher is a weak form of encryption that involves

“rotating” each letter by a fixed number of places. To rotate a letter

means to shift it through the alphabet, wrapping around to the beginning

if necessary, so ’A’ rotated by 3 is ’D’ and ’Z’ rotated by 1 is ’A’.

To rotate a word, rotate each letter by the same amount. For example,

“cheer” rotated by 7 is “jolly” and “melon” rotated by -10 is “cubed”.

In the movie 2001: A Space Odyssey, the ship computer is called HAL,

which is IBM rotated by -1.

Write a function called <code class="docutils literal">rotate_word</code> that takes a string and an

integer as parameters, and returns a new string that contains the

letters from the original string rotated by the given amount.

You might want to use the built-in function ord, which converts a

character to a numeric code, and chr, which converts numeric codes to

characters. Letters of the alphabet are encoded in alphabetical order,

so for example:

<div class="highlight-python"><div class="highlight"><pre>>>> ord('c') - ord('a')

2

</pre></div>

</div>

Because <code class="docutils literal">'c'</code> is the two-eth letter of the alphabet. But beware: the

numeric codes for upper case letters are different.

Potentially offensive jokes on the Internet are sometimes encoded in

ROT13, which is a Caesar cypher with rotation 13. If you are not easily

offended, find and decode some of them. Solution:

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

</div>

<h3><a href="index.html">Table Of Contents</a></h3>

<ul>

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

<li><a class="reference internal" href="#a-string-is-a-sequence">A string is a sequence</a></li>

<li><a class="reference internal" href="#traversal-with-a-for-loop">Traversal with a for loop</a></li>

<li><a class="reference internal" href="#string-slices">String slices</a></li>

<li><a class="reference internal" href="#strings-are-immutable">Strings are immutable</a></li>

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

<li><a class="reference internal" href="#looping-and-counting">Looping and counting</a></li>

<li><a class="reference internal" href="#string-methods">String methods</a></li>

<li><a class="reference internal" href="#the-in-operator">The in operator</a></li>

<li><a class="reference internal" href="#string-comparison">String comparison</a></li>

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

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

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

</ul>

</li>

</ul>

<h3>Related Topics</h3>

<ul>

<li><a href="index.html">Documentation overview</a><ul>

<li>Previous: <a href="07-iteration.html" title="previous chapter">Iteration</a></li>

<li>Next: <a href="09-case-word.html" title="next chapter">Case study: word play</a></li>

</ul></li>

</ul>

</div>

<li><a href="_sources/08-string.txt"

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

</ul>

</div>

<h3>Quick search</h3>

</form>

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

</div>

</div>

</div>

& <a href="https://github.com/bitprophet/alabaster">Alabaster 0.7.6</a>

<a href="_sources/08-string.txt"

rel="nofollow">Page source</a>

</div>

</body>

</html>

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

FilesExpand file tree

08-string.html

Latest commit

History

08-string.html

File metadata and controls