pythonlearn/html-270/book007.html at master · StudyCourse/pythonlearn

History

448 lines (445 loc) · 33.7 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

<!DOCTYPE html>

<html>

<head>

<title>Strings</title>

</head>

<body>

<hr />

<h1 class="chapter" id="sec73">Chapter&#XA0;6&#XA0;&#XA0;Strings</h1>

<h2 class="section" id="sec74">6.1&#XA0;&#XA0;A string is a sequence</h2>

<a id="hevea_default322"></a>A string is a sequence of characters.

You can access the characters one at a time with the

bracket operator:<pre class="verbatim">>>> fruit = 'banana'

>>> letter = fruit[1]

</pre><a id="hevea_default323"></a>

The second statement extracts the character at index position 1 from the

fruit variable and assigns it to the letter variable. 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:<pre class="verbatim">>>> print letter

</pre>For most people, the first letter of <code>'banana'</code> is b, not

a. But in Python, the index is an offset from the

beginning of the string, and the offset of the first letter is zero.<pre class="verbatim">>>> letter = fruit[0]

>>> print letter

</pre>So b is the 0th letter (&#X201C;zero-eth&#X201D;) of <code>'banana'</code>, a

is the 1th letter (&#X201C;one-eth&#X201D;), and n is the 2th (&#X201C;two-eth&#X201D;)

letter.<div class="center"><img src="book009.png" /></div><a id="hevea_default324"></a>

<a id="hevea_default325"></a>You can use any expression, including variables and operators, as an

index, but the value of the index has to be an integer. Otherwise you

get:<a id="hevea_default326"></a>

<a id="hevea_default328"></a><pre class="verbatim">>>> letter = fruit[1.5]

TypeError: string indices must be integers

</pre>

<h2 class="section" id="sec75">6.2&#XA0;&#XA0;Getting the length of a string using len</h2>

<a id="hevea_default330"></a>len is a built-in function that returns the number of characters

in a string:<pre class="verbatim">>>> fruit = 'banana'

>>> len(fruit)

</pre>To get the last letter of a string, you might be tempted to try something

like this:<a id="hevea_default331"></a>

<a id="hevea_default332"></a><pre class="verbatim">>>> length = len(fruit)

>>> last = fruit[length]

IndexError: string index out of range

</pre>The reason for the IndexError is that there is no letter in &#X2019;banana&#X2019; 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:<pre class="verbatim">>>> last = fruit[length-1]

>>> print last

</pre>Alternatively, 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.<a id="hevea_default333"></a>

<h2 class="section" id="sec76">6.3&#XA0;&#XA0;Traversal through a string with a loop</h2>

<a id="hevea_default340"></a>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:<pre class="verbatim">index = 0

while index < len(fruit):

letter = fruit[index]

print letter

index = index + 1

</pre>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 is not executed. The

last character accessed is the one with the index len(fruit)-1,

which is the last character in the string.<div class="theorem">Exercise&#XA0;1&#XA0;&#XA0;

Write a while loop that starts at the last character in the string

and works its way backwards to the first character in the string,

printing each letter on a separate line, except backwards.

</div>Another way to write a traversal is with a for loop:<pre class="verbatim">for char in fruit:

print char

</pre>Each time through the loop, the next character in the string is assigned

to the variable char. The loop continues until no characters are

left.

<h2 class="section" id="sec77">6.4&#XA0;&#XA0;String slices</h2>

<a id="hevea_default345"></a>A segment of a string is called a slice. Selecting a slice is

similar to selecting a character:<pre class="verbatim">>>> s = 'Monty Python'

>>> print s[0:5]

Monty

>>> print s[6:12]

Python

</pre>The operator [n:m] returns the part of the string from the

&#X201C;n-eth&#X201D; character to the &#X201C;m-eth&#X201D; character, including the first but

excluding the last. 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:<pre class="verbatim">>>> fruit = 'banana'

>>> fruit[:3]

'ban'

>>> fruit[3:]

'ana'

</pre>If the first index is greater than or equal to the second the result

is an empty string, represented by two quotation marks:<a id="hevea_default346"></a><pre class="verbatim">>>> fruit = 'banana'

>>> fruit[3:3]

</pre>An empty string contains no characters and has length 0, but other

than that, it is the same as any other string.<div class="theorem">Exercise&#XA0;2&#XA0;&#XA0;

Given that fruit is a string, what does

fruit[:] mean?<a id="hevea_default347"></a>

<h2 class="section" id="sec78">6.5&#XA0;&#XA0;Strings are immutable</h2>

<a id="hevea_default351"></a>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:<a id="hevea_default352"></a>

<a id="hevea_default353"></a><pre class="verbatim">>>> greeting = 'Hello, world!'

>>> greeting[0] = 'J'

TypeError: object does not support item assignment

</pre>The &#X201C;object&#X201D; in this case is the string and the &#X201C;item&#X201D; 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. An item is one of the values in a sequence.<a id="hevea_default354"></a>

<a id="hevea_default357"></a>The reason for the error is that

strings are immutable, which means you can&#X2019;t change an

existing string. The best you can do is create a new string

that is a variation on the original:<pre class="verbatim">>>> greeting = 'Hello, world!'

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

>>> print new_greeting

Jello, world!

</pre>This example concatenates a new first letter onto

a slice of greeting. It has no effect on

the original string.<a id="hevea_default358"></a>

<h2 class="section" id="sec79">6.6&#XA0;&#XA0;Looping and counting</h2>

<a id="hevea_default362"></a>The following program counts the number of times the letter a

appears in a string:<pre class="verbatim">word = 'banana'

count = 0

for letter in word:

if letter == 'a':

count = count + 1

print count

</pre>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&#X2014;the total number of a&#X2019;s.<div class="theorem">Exercise&#XA0;3&#XA0;&#XA0;

<a id="hevea_default363"></a>Encapsulate this code in a function named count, and generalize it so that it accepts the string and the

letter as arguments.

</div>

<h2 class="section" id="sec80">6.7&#XA0;&#XA0;The in operator</h2>

<a id="hevea_default367"></a>The word in is a boolean operator that takes two strings and

returns True if the first appears as a substring in the second:<pre class="verbatim">>>> 'a' in 'banana'

True

>>> 'seed' in 'banana'

False

</pre>

<h2 class="section" id="sec81">6.8&#XA0;&#XA0;String comparison</h2>

<a id="hevea_default369"></a>The comparison operators work on strings. To see if two strings are equal:<pre class="verbatim">if word == 'banana':

print 'All right, bananas.'

</pre>Other comparison operations are useful for putting words in alphabetical

order:<pre class="verbatim">if word < 'banana':

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

elif word > 'banana':

print 'Your word,' + word + ', comes after banana.'

else:

print 'All right, bananas.'

</pre>Python does not handle uppercase and lowercase letters the same way

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

lowercase letters, so:<pre class="verbatim">Your word, Pineapple, comes before banana.

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

<h2 class="section" id="sec82">6.9&#XA0;&#XA0;string methods</h2>

Strings are an example of Python objects. An object contains

both data (the actual string itself) and methods, which

are effectively functions that are built into the object and

are available to any instance of the object.Python has a function called dir which lists the methods available

for an object. The type function shows the type of an object

and the dir function shows the available methods.<pre class="verbatim">>>> stuff = 'Hello world'

>>> type(stuff)

>>> dir(stuff)

['capitalize', 'center', 'count', 'decode', 'encode',

'endswith', 'expandtabs', 'find', 'format', 'index',

'isalnum', 'isalpha', 'isdigit', 'islower', 'isspace',

'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip',

'partition', 'replace', 'rfind', 'rindex', 'rjust',

'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines',

'startswith', 'strip', 'swapcase', 'title', 'translate',

'upper', 'zfill']

>>> help(str.capitalize)

Help on method_descriptor:

capitalize(...)

S.capitalize() -> string

Return a copy of the string S with only its first character

capitalized.

>>>

</pre>While the dir function lists the methods, and you

can use help to get some simple documentation on a method,

a better source of documentation for string methods would be

https://docs.python.org/2/library/stdtypes.html#string-methods.Calling a method is similar to calling a function&#X2014;it

takes arguments and returns a value&#X2014;but the syntax is different.

We call a method by appending the method name to the variable name

using the period as a delimiter.For example, the

method upper takes a string and returns a new string with

all uppercase letters:<a id="hevea_default370"></a>

<a id="hevea_default371"></a>Instead of the function syntax upper(word), it uses

the method syntax word.upper().<a id="hevea_default372"></a><pre class="verbatim">>>> word = 'banana'

>>> new_word = word.upper()

>>> print new_word

BANANA

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

argument.<a id="hevea_default373"></a>A method call is called an invocation; in this case, we would

say that we are invoking upper on the word.<a id="hevea_default374"></a>For example, there is a string method named find that

searches for the position of one string within another:<pre class="verbatim">>>> word = 'banana'

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

>>> print index

</pre>In this example, we invoke find on word and pass

the letter we are looking for as a parameter.The find method can find substrings as well as characters:<pre class="verbatim">>>> word.find('na')

</pre>It can take as a second argument the index where it should start:<a id="hevea_default375"></a>

<a id="hevea_default376"></a><pre class="verbatim">>>> word.find('na', 3)

</pre>One common task is to remove white space (spaces, tabs, or newlines) from

the beginning and end of a string using the strip method:<pre class="verbatim">>>> line = ' Here we go '

>>> line.strip()

'Here we go'

</pre>Some methods such as startswith return boolean values.<pre class="verbatim">>>> line = 'Please have a nice day'

>>> line.startswith('Please')

True

>>> line.startswith('p')

False

</pre>You will note that startswith requires case to match, so sometimes

we take a line and map it all to lowercase before we do any checking

using the lower method.<pre class="verbatim">>>> line = 'Please have a nice day'

>>> line.startswith('p')

False

>>> line.lower()

'please have a nice day'

>>> line.lower().startswith('p')

True

</pre>In the last example, the method lower is called

and then we use startswith

to see if the resulting lowercase string

starts with the letter &#X201C;p&#X201D;. As long as we are careful

with the order, we can make multiple method calls in a

single expression.<div class="theorem">Exercise&#XA0;4&#XA0;&#XA0;

<a id="hevea_default378"></a>There is a string method called count that is similar

to the function in the previous exercise. Read the documentation

of this method at

https://docs.python.org/2/library/stdtypes.html#string-methods

and write an invocation that counts the number of times the

letter a occurs

in <code>'banana'</code>.

</div>

<h2 class="section" id="sec83">6.10&#XA0;&#XA0;Parsing strings</h2>

Often, we want to look into a string and find a substring. For example

if we were presented a series of lines formatted as follows:<pre>

From stephen.marquard@ uct.ac.za Sat Jan 5 09:14:16 2008

</pre>and we wanted to pull out only the second half of the address (i.e.,

uct.ac.za) from each line, we can do this by using the find

method and string slicing. First, we will find the position of the at-sign in the string. Then we will

find the position of the first space after the at-sign. And then we

will use string slicing to extract the portion of the string which we

are looking for.<pre class="verbatim">>>> data = 'From stephen.marquard@uct.ac.za Sat Jan 5 09:14:16 2008'

>>> atpos = data.find('@')

>>> print atpos

>>> sppos = data.find(' ',atpos)

>>> print sppos

>>> host = data[atpos+1:sppos]

>>> print host

uct.ac.za

>>>

</pre>We use a version of the find method which allows us to specify

a position in the string where we want find to start looking.

When we slice, we extract the characters

from &#X201C;one beyond the at-sign through up to but not including the

space character&#X201D;. The documentation for the find method is available at

https://docs.python.org/2/library/stdtypes.html#string-methods.

<h2 class="section" id="sec84">6.11&#XA0;&#XA0;Format operator</h2>

<a id="hevea_default380"></a>The format operator, %

allows us to construct strings, replacing parts of the strings

with the data stored in variables.

When applied to integers, % is the modulus operator. But

when the first operand is a string, % is the format operator.<a id="hevea_default381"></a>The first operand is the format string, which contains

one or more format sequences that specify how

the second operand is formatted. The result is a string.<a id="hevea_default382"></a>For example, the format sequence <code>'%d'</code> means that

the second operand should be formatted as an

integer (d stands for &#X201C;decimal&#X201D;):<pre class="verbatim">>>> camels = 42

>>> '%d' % camels

'42'

</pre>The result is the string <code>'42'</code>, which is not to be confused

with the integer value 42.A format sequence can appear anywhere in the string,

so you can embed a value in a sentence:<pre class="verbatim">>>> camels = 42

>>> 'I have spotted %d camels.' % camels

'I have spotted 42 camels.'

</pre>If there is more than one format sequence in the string,

the second argument has to be a tuple<a id="text10" href="#note10">1</a>. Each format sequence is

matched with an element of the tuple, in order.The following example uses <code>'%d'</code> to format an integer,

<code>'%g'</code> to format

a floating-point number (don&#X2019;t ask why), and <code>'%s'</code> to format

a string:<pre class="verbatim">>>> 'In %d years I have spotted %g %s.' % (3, 0.1, 'camels')

'In 3 years I have spotted 0.1 camels.'

</pre>The number of elements in the tuple must match the number

of format sequences in the string. The types of the

elements also must match the format sequences:<a id="hevea_default383"></a>

<a id="hevea_default384"></a><pre class="verbatim">>>> '%d %d %d' % (1, 2)

TypeError: not enough arguments for format string

>>> '%d' % 'dollars'

TypeError: illegal argument type for built-in operation

</pre>In the first example, there aren&#X2019;t enough elements; in the

second, the element is the wrong type.The format operator is powerful, but it can be difficult to use. You

can read more about it at

https://docs.python.org/2/library/stdtypes.html#string-formatting.

<h2 class="section" id="sec85">6.12&#XA0;&#XA0;Debugging</h2>

<a id="hevea_default385"></a>A skill that you should cultivate as you program is always

asking yourself, &#X201C;What could go wrong here?&#X201D; or alternatively,

&#X201C;What crazy thing might our user do to crash our (seemingly)

perfect program?&#X201D;For example, look at the program which we used to demonstrate

the while loop in the chapter on iteration:<pre class="verbatim">while True:

line = raw_input('> ')

if line[0] == '#' :

continue

if line == 'done':

break

print line

print 'Done!'

</pre>Look what happens when the user enters an empty line of input:<pre class="verbatim">> hello there

hello there

> # don't print this

> print this!

print this!

Traceback (most recent call last):

File "copytildone.py", line 3, in <module>

if line[0] == '#' :

</pre>The code works fine until it is presented an empty line. Then

there is no zero-th character, so we get a traceback. There are two

solutions to this to make line three &#X201C;safe&#X201D; even if the line is

empty.One possibility is to simply use the startswith method

which returns False if the string is empty.<pre class="verbatim"> if line.startswith('#') :

</pre><a id="hevea_default386"></a>

Another way is to safely write the if statement using the guardian

pattern and make sure the second logical expression is evaluated

only where there is at least one character in the string.:<pre class="verbatim"> if len(line) > 0 and line[0] == '#' :

</pre>

<h2 class="section" id="sec86">6.13&#XA0;&#XA0;Glossary</h2>

<dl class="description"><dt class="dt-description">counter:</dt><dd class="dd-description"> A variable used to count something, usually initialized

to zero and then incremented.

<a id="hevea_default388"></a></dd><dt class="dt-description">empty string:</dt><dd class="dd-description"> A string with no characters and length 0, represented

by two quotation marks.

<a id="hevea_default389"></a></dd><dt class="dt-description">format operator:</dt><dd class="dd-description"> An operator, %, that takes a format

string and a tuple and generates a string that includes

the elements of the tuple formatted as specified by the format string.

<a id="hevea_default391"></a></dd><dt class="dt-description">format sequence:</dt><dd class="dd-description"> A sequence of characters in a format string,

like %d, that specifies how a value should be formatted.

<a id="hevea_default392"></a></dd><dt class="dt-description">format string:</dt><dd class="dd-description"> A string, used with the format operator, that

contains format sequences.

<a id="hevea_default393"></a></dd><dt class="dt-description">flag:</dt><dd class="dd-description"> A boolean variable used to indicate whether a condition

is true.

<a id="hevea_default394"></a></dd><dt class="dt-description">invocation:</dt><dd class="dd-description"> A statement that calls a method.

<a id="hevea_default395"></a></dd><dt class="dt-description">immutable:</dt><dd class="dd-description"> The property of a sequence whose items cannot

be assigned.

<a id="hevea_default396"></a></dd><dt class="dt-description">index:</dt><dd class="dd-description"> An integer value used to select an item in

a sequence, such as a character in a string.

<a id="hevea_default397"></a></dd><dt class="dt-description">item:</dt><dd class="dd-description"> One of the values in a sequence.

<a id="hevea_default398"></a></dd><dt class="dt-description">method:</dt><dd class="dd-description"> A function that is associated with an object and called

using dot notation.

<a id="hevea_default399"></a></dd><dt class="dt-description">object:</dt><dd class="dd-description"> Something a variable can refer to. For now,

you can use &#X201C;object&#X201D; and &#X201C;value&#X201D; interchangeably.

<a id="hevea_default400"></a></dd><dt class="dt-description">search:</dt><dd class="dd-description"> A pattern of traversal that stops

when it finds what it is looking for.

<a id="hevea_default402"></a></dd><dt class="dt-description">sequence:</dt><dd class="dd-description"> An ordered set; that is, a set of

values where each value is identified by an integer index.

<a id="hevea_default403"></a></dd><dt class="dt-description">slice:</dt><dd class="dd-description"> A part of a string specified by a range of indices.

<a id="hevea_default404"></a></dd><dt class="dt-description">traverse:</dt><dd class="dd-description"> To iterate through the items in a sequence,

performing a similar operation on each.

<h2 class="section" id="sec87">6.14&#XA0;&#XA0;Exercises</h2>

<div class="theorem">Exercise&#XA0;5&#XA0;&#XA0;

Take the following Python code that stores a string:&#X2018;<pre>

str = &#X2019;X-DSPAM-Confidence: 0.8475&#X2019;

</pre>Use find and string slicing to extract the portion

of the string after the colon character and then use the

float function to convert the extracted string

into a floating point number.</div><div class="theorem">Exercise&#XA0;6&#XA0;&#XA0;

<a id="hevea_default407"></a>Read the documentation of the string methods at

https://docs.python.org/2/library/stdtypes.html#string-methods.

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

</div>

<a id="note10" href="#text10">1</a></dt><dd class="dd-thefootnotes"><div class="footnotetext">A tuple is a

sequence of comma-separated values inside a pair of brackets.

We will cover tuples in Chapter 10</div>

</dd></dl>

<hr />

</body>

</html>

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

FilesExpand file tree

book007.html

Latest commit

History

book007.html

File metadata and controls