python-docs-ja/tutorial/errors.po at 3.7 · python/python-docs-ja · GitHub

Repository navigation

History

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

531

532

533

534

535

536

537

538

539

540

# SOME DESCRIPTIVE TITLE.

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

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

# Translators:

# tomo, 2019

# Yuta Kanzawa, 2019

# Naoki Nakamura <agent@sohzoh.com>, 2020

# Yusuke Miyazaki <miyazaki.dev@gmail.com>, 2021

#, fuzzy

msgid ""

msgstr ""

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

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

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

"PO-Revision-Date: 2019-09-01 02:42+0000\n"

"Last-Translator: Yusuke Miyazaki <miyazaki.dev@gmail.com>, 2021\n"

"Language-Team: Japanese (https://www.transifex.com/python-doc/teams/5390/"

"ja/)\n"

"Language: ja\n"

"MIME-Version: 1.0\n"

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

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

"Plural-Forms: nplurals=1; plural=0;\n"

#: ../../tutorial/errors.rst:5

msgid "Errors and Exceptions"

msgstr "エラーと例外"

#: ../../tutorial/errors.rst:7

msgid ""

"Until now error messages haven't been more than mentioned, but if you have "

"tried out the examples you have probably seen some. There are (at least) "

"two distinguishable kinds of errors: *syntax errors* and *exceptions*."

msgstr ""

"これまでエラーメッセージについては簡単に触れるだけでしたが、チュートリアル中"

"の例を自分で試していたら、実際にいくつかのエラーメッセージを見ていることで"

"しょう。エラーには (少なくとも) 二つのはっきり異なる種類があります。それは *"

"構文エラー (syntax error)* と *例外 (exception)* です。"

#: ../../tutorial/errors.rst:15

msgid "Syntax Errors"

msgstr "構文エラー"

#: ../../tutorial/errors.rst:17

msgid ""

"Syntax errors, also known as parsing errors, are perhaps the most common "

"kind of complaint you get while you are still learning Python::"

msgstr ""

"構文エラーは構文解析エラー (parsing error) としても知られており、Python を勉"

"強している間に最もよく遭遇する問題の一つでしょう::"

#: ../../tutorial/errors.rst:26

msgid ""

"The parser repeats the offending line and displays a little 'arrow' pointing "

"at the earliest point in the line where the error was detected. The error "

"is caused by (or at least detected at) the token *preceding* the arrow: in "

"the example, the error is detected at the function :func:`print`, since a "

"colon (``':'``) is missing before it. File name and line number are printed "

"so you know where to look in case the input came from a script."

msgstr ""

"パーサは違反の起きている行を表示し、小さな「矢印」を表示して、行中でエラーが"

"検出された最初の位置を示します。エラーは矢印の *直前の* トークンでひき起こさ"

"れています (または、少なくともそこで検出されています)。上記の例では、エラーは"

"関数 :func:`print` で検出されています。コロン (``':'``) がその前に無いからで"

"す。入力がスクリプトから来ている場合は、どこを見ればよいか分かるようにファイ"

"ル名と行番号が出力されます。"

#: ../../tutorial/errors.rst:37

msgid "Exceptions"

msgstr "例外"

#: ../../tutorial/errors.rst:39

msgid ""

"Even if a statement or expression is syntactically correct, it may cause an "

"error when an attempt is made to execute it. Errors detected during "

"execution are called *exceptions* and are not unconditionally fatal: you "

"will soon learn how to handle them in Python programs. Most exceptions are "

"not handled by programs, however, and result in error messages as shown "

"here::"

msgstr ""

"たとえ文や式が構文的に正しくても、実行しようとしたときにエラーが発生するかも"

"しれません。実行中に検出されたエラーは *例外 (exception)* と呼ばれ、常に致命"

"的とは限りません。これから、Python プログラムで例外をどのように扱うかを学んで"

"いきます。ほとんどの例外はプログラムで処理されず、以下に示されるようなメッ"

"セージになります::"

#: ../../tutorial/errors.rst:58

msgid ""

"The last line of the error message indicates what happened. Exceptions come "

"in different types, and the type is printed as part of the message: the "

"types in the example are :exc:`ZeroDivisionError`, :exc:`NameError` and :exc:"

"`TypeError`. The string printed as the exception type is the name of the "

"built-in exception that occurred. This is true for all built-in exceptions, "

"but need not be true for user-defined exceptions (although it is a useful "

"convention). Standard exception names are built-in identifiers (not reserved "

"keywords)."

msgstr ""

"エラーメッセージの最終行は何が起こったかを示しています。例外は様々な型 "

"(type) で起こり、その型がエラーメッセージの一部として出力されます。上の例での"

"型は :exc:`ZeroDivisionError`, :exc:`NameError`, :exc:`TypeError` です。例外"

"型として出力される文字列は、発生した例外の組み込み名です。これは全ての組み込"

"み例外について成り立ちますが、ユーザ定義の例外では (成り立つようにするのは有"

"意義な慣習ですが) 必ずしも成り立ちません。標準例外の名前は組み込みの識別子で"

"す (予約語ではありません)。"

#: ../../tutorial/errors.rst:66

msgid ""

"The rest of the line provides detail based on the type of exception and what "

"caused it."

msgstr "残りの行は例外の詳細で、その例外の型と何が起きたかに依存します。"

#: ../../tutorial/errors.rst:69

msgid ""

"The preceding part of the error message shows the context where the "

"exception happened, in the form of a stack traceback. In general it contains "

"a stack traceback listing source lines; however, it will not display lines "

"read from standard input."

msgstr ""

"エラーメッセージの先頭部分では、例外が発生した実行コンテキスト (context) を、"

"スタックのトレースバック (stack traceback) の形式で示しています。一般には、こ"

"の部分にはソースコード行をリストしたトレースバックが表示されます。しかし、標"

"準入力から読み取られたコードは表示されません。"

#: ../../tutorial/errors.rst:74

msgid ""

":ref:`bltin-exceptions` lists the built-in exceptions and their meanings."

msgstr ""

":ref:`bltin-exceptions` には、組み込み例外とその意味がリストされています。"

#: ../../tutorial/errors.rst:80

msgid "Handling Exceptions"

msgstr "例外を処理する"

#: ../../tutorial/errors.rst:82

msgid ""

"It is possible to write programs that handle selected exceptions. Look at "

"the following example, which asks the user for input until a valid integer "

"has been entered, but allows the user to interrupt the program (using :kbd:"

"`Control-C` or whatever the operating system supports); note that a user-"

"generated interruption is signalled by raising the :exc:`KeyboardInterrupt` "

"exception. ::"

msgstr ""

"例外を選別して処理するようなプログラムを書くことができます。以下の例を見てく"

"ださい。この例では、有効な文字列が入力されるまでユーザに入力を促しますが、"

"ユーザがプログラムに (:kbd:`Control-C` か、またはオペレーティングシステムがサ"

"ポートしている何らかのキーを使って) 割り込みをかけてプログラムを中断させるこ"

"とができるようにしています。ユーザが生成した割り込みは、 :exc:"

"`KeyboardInterrupt` 例外が送出されることで通知されるということに注意してくだ"

"さい。 ::"

#: ../../tutorial/errors.rst:96

msgid "The :keyword:`try` statement works as follows."

msgstr ":keyword:`try` 文は下記のように動作します。"

#: ../../tutorial/errors.rst:98

msgid ""

"First, the *try clause* (the statement(s) between the :keyword:`try` and :"

"keyword:`except` keywords) is executed."

msgstr ""

"まず、 *try 節 (try clause)* (キーワード :keyword:`try` と :keyword:`except` "

"の間の文) が実行されます。"

#: ../../tutorial/errors.rst:101

msgid ""

"If no exception occurs, the *except clause* is skipped and execution of the :"

"keyword:`try` statement is finished."

msgstr ""

"何も例外が発生しなければ、 *except 節* をスキップして :keyword:`try` 文の実行"

"を終えます。"

#: ../../tutorial/errors.rst:104

msgid ""

"If an exception occurs during execution of the try clause, the rest of the "

"clause is skipped. Then if its type matches the exception named after the :"

"keyword:`except` keyword, the except clause is executed, and then execution "

"continues after the :keyword:`try` statement."

msgstr ""

"try 節内の実行中に例外が発生すると、その節の残りは飛ばされます。次に、例外型"

"が :keyword:`except` キーワードの後に指定されている例外に一致する場合、"

"except 節が実行された後、 :keyword:`try` 文の後ろへ実行が継続されます。"

#: ../../tutorial/errors.rst:109

msgid ""

"If an exception occurs which does not match the exception named in the "

"except clause, it is passed on to outer :keyword:`try` statements; if no "

"handler is found, it is an *unhandled exception* and execution stops with a "

"message as shown above."

msgstr ""

"もしも except 節で指定された例外と一致しない例外が発生すると、その例外は :"

"keyword:`try` 文の外側に渡されます。例外に対するハンドラ (handler、処理部) が"

"どこにもなければ、 *処理されない例外 (unhandled exception)* となり、上記に示"

"したようなメッセージを出して実行を停止します。"

#: ../../tutorial/errors.rst:114

msgid ""

"A :keyword:`try` statement may have more than one except clause, to specify "

"handlers for different exceptions. At most one handler will be executed. "

"Handlers only handle exceptions that occur in the corresponding try clause, "

"not in other handlers of the same :keyword:`!try` statement. An except "

"clause may name multiple exceptions as a parenthesized tuple, for example::"

msgstr ""

"一つの :keyword:`try` 文には複数の except 節が付けられ、別々の例外に対するハ"

"ンドラを指定できます。\n"

"多くとも一つのハンドラしか実行されません。\n"

"ハンドラは対応する try 節内で発生した例外だけを処理し、同じ :keyword:`!try` "

"節内の別の例外ハンドラで起きた例外は処理しません。\n"

"except 節では丸括弧で囲ったタプルという形で複数の例外を指定できます。例えば次"

"のようにします::"

#: ../../tutorial/errors.rst:123

msgid ""

"A class in an :keyword:`except` clause is compatible with an exception if it "

"is the same class or a base class thereof (but not the other way around --- "

"an except clause listing a derived class is not compatible with a base "

"class). For example, the following code will print B, C, D in that order::"

msgstr ""

":keyword:`except` 節のクラスは、例外と同じクラスか基底クラスのときに互換 "

"(compatible)となります。 (逆方向では成り立ちません --- 派生クラスの例外がリス"

"トされている except 節は基底クラスの例外と互換ではありません)。例えば、次の"

"コードは、 B, C, D を順序通りに出力します::"

#: ../../tutorial/errors.rst:147

msgid ""

"Note that if the except clauses were reversed (with ``except B`` first), it "

"would have printed B, B, B --- the first matching except clause is triggered."

msgstr ""

"except 節が逆に並んでいた場合 (``except B`` が最初にくる場合)、 B, B, B と出"

"力されるはずだったことに注意してください --- 最初に一致した except 節が駆動さ"

"れるのです。"

#: ../../tutorial/errors.rst:150

msgid ""

"The last except clause may omit the exception name(s), to serve as a "

"wildcard. Use this with extreme caution, since it is easy to mask a real "

"programming error in this way! It can also be used to print an error "

"message and then re-raise the exception (allowing a caller to handle the "

"exception as well)::"

msgstr ""

"最後の except 節では例外名を省いて、ワイルドカード (wildcard、総称記号) にす"

"ることができます。ワイルドカードの except 節は非常に注意して使ってください。"

"というのは、ワイルドカードは通常のプログラムエラーをたやすく隠してしまうから"

"です！ワイルドカードの except 節はエラーメッセージを出力した後に例外を再送出"

"する (関数やメソッドの呼び出し側が同様にして例外を処理できるようにする) 用途"

"にも使えます::"

#: ../../tutorial/errors.rst:169

msgid ""

"The :keyword:`try` ... :keyword:`except` statement has an optional *else "

"clause*, which, when present, must follow all except clauses. It is useful "

"for code that must be executed if the try clause does not raise an "

"exception. For example::"

msgstr ""

":keyword:`try` ... :keyword:`except` 文には、オプションで *else 節 (else "

"clause)* を設けることができます。 :keyword:`else` 節を設ける場合、全ての :"

"keyword:`except` 節よりも後ろに置かなければなりません。 :keyword:`else` 節は "

"try 節で全く例外が送出されなかったときに実行されるコードを書くのに役立ちま"

"す。例えば次のようにします::"

#: ../../tutorial/errors.rst:183

msgid ""

"The use of the :keyword:`!else` clause is better than adding additional code "

"to the :keyword:`try` clause because it avoids accidentally catching an "

"exception that wasn't raised by the code being protected by the :keyword:`!"

"try` ... :keyword:`!except` statement."

msgstr ""

"追加のコードを付け加えるのは :keyword:`try` 節よりも :keyword:`!else` 節の方"

"がよいでしょう。\n"

"なぜなら、そうすることで :keyword:`!try` ... :keyword:`!except` 文で保護され"

"たコードから送出されたもの以外の例外を過って捕捉してしまうという事態を避けら"

"れるからです。"

#: ../../tutorial/errors.rst:188

msgid ""

"When an exception occurs, it may have an associated value, also known as the "

"exception's *argument*. The presence and type of the argument depend on the "

"exception type."

msgstr ""

"例外が発生するとき、例外は関連付けられた値を持つことができます。この値は例外"

"の *引数 (argument)* とも呼ばれます。引数の有無および引数の型は、例外の型に依"

"存します。"

#: ../../tutorial/errors.rst:192

msgid ""

"The except clause may specify a variable after the exception name. The "

"variable is bound to an exception instance with the arguments stored in "

"``instance.args``. For convenience, the exception instance defines :meth:"

"`__str__` so the arguments can be printed directly without having to "

"reference ``.args``. One may also instantiate an exception first before "

"raising it and add any attributes to it as desired. ::"

msgstr ""

"except 節では、例外名の後に変数を指定することができます。この変数は例外インス"

"タンスに結び付けられており、 ``instance.args`` に例外インスタンス生成時の引数"

"が入っています。例外インスタンスには :meth:`__str__` が定義されており、 ``."

"args`` を参照しなくても引数を直接印字できるように利便性が図られています。必要"

"なら、例外を送出する前にインスタンス化して、任意の属性を追加できます。 ::"

#: ../../tutorial/errors.rst:216

msgid ""

"If an exception has arguments, they are printed as the last part ('detail') "

"of the message for unhandled exceptions."

msgstr ""

"例外が引数を持っていれば、それらは処理されない例外のメッセージの最後の部分 "

"(「詳細説明」) に出力されます。"

#: ../../tutorial/errors.rst:219

msgid ""

"Exception handlers don't just handle exceptions if they occur immediately in "

"the try clause, but also if they occur inside functions that are called "

"(even indirectly) in the try clause. For example::"

msgstr ""

"例外ハンドラは、try 節の直接内側で発生した例外を処理するだけではなく、その "

"try 節から (たとえ間接的にでも) 呼び出された関数の内部で発生した例外も処理し"

"ます。例えば::"

#: ../../tutorial/errors.rst:237

msgid "Raising Exceptions"

msgstr "例外を送出する"

#: ../../tutorial/errors.rst:239

msgid ""

"The :keyword:`raise` statement allows the programmer to force a specified "

"exception to occur. For example::"

msgstr ""

":keyword:`raise` 文を使って、特定の例外を発生させることができます。例えば::"

#: ../../tutorial/errors.rst:247

msgid ""

"The sole argument to :keyword:`raise` indicates the exception to be raised. "

"This must be either an exception instance or an exception class (a class "

"that derives from :class:`Exception`). If an exception class is passed, it "

"will be implicitly instantiated by calling its constructor with no "

"arguments::"

msgstr ""

":keyword:`raise` の唯一の引数は送出される例外を指し示します。\n"

"これは例外インスタンスか例外クラス (:class:`Exception` を継承したクラス) でな"

"ければなりません。\n"

"例外クラスが渡された場合は、引数無しのコンストラクタが呼び出され、暗黙的にイ"

"ンスタンス化されます::"

#: ../../tutorial/errors.rst:254

msgid ""

"If you need to determine whether an exception was raised but don't intend to "

"handle it, a simpler form of the :keyword:`raise` statement allows you to re-"

"raise the exception::"

msgstr ""

"例外が発生したかどうかを判定したいだけで、その例外を処理するつもりがなけれ"

"ば、単純な形式の :keyword:`raise` 文を使って例外を再送出させることができま"

"す::"

#: ../../tutorial/errors.rst:273

msgid "User-defined Exceptions"

msgstr "ユーザー定義例外"

#: ../../tutorial/errors.rst:275

msgid ""

"Programs may name their own exceptions by creating a new exception class "

"(see :ref:`tut-classes` for more about Python classes). Exceptions should "

"typically be derived from the :exc:`Exception` class, either directly or "

"indirectly."

msgstr ""

"プログラム上で新しい例外クラスを作成することで、独自の例外を指定することがで"

"きます (Python のクラスについては :ref:`tut-classes` 参照)。例外は、典型的"

"に :exc:`Exception` クラスから、直接または間接的に派生したものです。"

#: ../../tutorial/errors.rst:279

msgid ""

"Exception classes can be defined which do anything any other class can do, "

"but are usually kept simple, often only offering a number of attributes that "

"allow information about the error to be extracted by handlers for the "

"exception. When creating a module that can raise several distinct errors, a "

"common practice is to create a base class for exceptions defined by that "

"module, and subclass that to create specific exception classes for different "

"error conditions::"

msgstr ""

"例外クラスでは、普通のクラスができることなら何でも定義することができますが、"

"通常は単純なものにしておきます。大抵は、いくつかの属性だけを提供し、例外が発"

"生したときにハンドラがエラーに関する情報を取り出せるようにする程度にとどめま"

"す。複数の別個の例外を送出するようなモジュールを作成する際には、そのモジュー"

"ルで定義されている例外の基底クラスを作成するのが一般的なプラクティスです::"

#: ../../tutorial/errors.rst:317

msgid ""

"Most exceptions are defined with names that end in \"Error\", similar to the "

"naming of the standard exceptions."

msgstr ""

"ほとんどの例外は、標準の例外の名前付けと同様に、\"Error\" で終わる名前で定義"

"されています。"

#: ../../tutorial/errors.rst:320

msgid ""

"Many standard modules define their own exceptions to report errors that may "

"occur in functions they define. More information on classes is presented in "

"chapter :ref:`tut-classes`."

msgstr ""

"多くの標準モジュールでは、モジュールで定義されている関数内で発生する可能性の"

"あるエラーを報告させるために、独自の例外を定義しています。クラスについての詳"

"細な情報は :ref:`tut-classes` 章で提供されています。"

#: ../../tutorial/errors.rst:328

msgid "Defining Clean-up Actions"

msgstr "クリーンアップ動作を定義する"

#: ../../tutorial/errors.rst:330

msgid ""

"The :keyword:`try` statement has another optional clause which is intended "

"to define clean-up actions that must be executed under all circumstances. "

"For example::"

msgstr ""

":keyword:`try` 文にはもう一つオプションの節があります。この節はクリーンアップ"

"動作を定義するためのもので、どんな状況でも必ず実行されます。例を示します::"

#: ../../tutorial/errors.rst:344

msgid ""

"If a :keyword:`finally` clause is present, the :keyword:`!finally` clause "

"will execute as the last task before the :keyword:`try` statement completes. "

"The :keyword:`!finally` clause runs whether or not the :keyword:`!try` "

"statement produces an exception. The following points discuss more complex "

"cases when an exception occurs:"

msgstr ""

"もし :keyword:`finally` 節がある場合、 :keyword:`try` 文が終わる前の最後の処"

"理を、 :keyword:`!finally` 節が実行します。 :keyword:`!try` 文が例外を発生さ"

"せるか否かに関わらず、 :keyword:`!finally` 節は実行されます。以下では、例外が"

"発生するという更に複雑なケースを議論します:"

#: ../../tutorial/errors.rst:350

msgid ""

"If an exception occurs during execution of the :keyword:`!try` clause, the "

"exception may be handled by an :keyword:`except` clause. If the exception is "

"not handled by an :keyword:`!except` clause, the exception is re-raised "

"after the :keyword:`!finally` clause has been executed."

msgstr ""

"もし :keyword:`!try` 文の実行中に例外が発生したら、その例外は :keyword:"

"`except` 節によって処理されるでしょう。もしその例外が :keyword:`!except` 節に"

"よって処理されなければ、 :keyword:`!finally` 節が実行された後に、その例外が再"

"送出されます。"

#: ../../tutorial/errors.rst:356

msgid ""

"An exception could occur during execution of an :keyword:`!except` or :"

"keyword:`!else` clause. Again, the exception is re-raised after the :keyword:"

"`!finally` clause has been executed."

msgstr ""

":keyword:`!except` 節または :keyword:`!else` 節の実行中に例外が発生することが"

"あり得ます。その場合も、 :keyword:`!finally` 節が実行された後に例外が再送出さ"

"れます。"

#: ../../tutorial/errors.rst:360

msgid ""

"If the :keyword:`!try` statement reaches a :keyword:`break`, :keyword:"

"`continue` or :keyword:`return` statement, the :keyword:`!finally` clause "

"will execute just prior to the :keyword:`!break`, :keyword:`!continue` or :"

"keyword:`!return` statement's execution."

msgstr ""

"もし :keyword:`!try` 文が :keyword:`break` 文、 :keyword:`continue` 文また"

"は :keyword:`return` 文のいずれかに達すると、その :keyword:`!break` 文、 :"

"keyword:`!continue` 文または :keyword:`!return` 文の実行の直前に :keyword:`!"

"finally` 節が実行されます。"

#: ../../tutorial/errors.rst:366

msgid ""

"If a :keyword:`!finally` clause includes a :keyword:`!return` statement, the "

"returned value will be the one from the :keyword:`!finally` clause's :"

"keyword:`!return` statement, not the value from the :keyword:`!try` "

"clause's :keyword:`!return` statement."

msgstr ""

"もし :keyword:`!finally` 節が :keyword:`!return` 文を含む場合、返される値は :"

"keyword:`!try` 節の :keyword:`!return` 文ではなく、:keyword:`!finally` 節の :"

"keyword:`!return` 文によるものになります。"

#: ../../tutorial/errors.rst:372

msgid "For example::"

msgstr "例えば::"

#: ../../tutorial/errors.rst:383

msgid "A more complicated example::"

msgstr "より複雑な例::"

#: ../../tutorial/errors.rst:408

msgid ""

"As you can see, the :keyword:`finally` clause is executed in any event. "

"The :exc:`TypeError` raised by dividing two strings is not handled by the :"

"keyword:`except` clause and therefore re-raised after the :keyword:`!"

"finally` clause has been executed."

msgstr ""

"見てわかるとおり、 :keyword:`finally` 節はどの場合にも実行されています。\n"

"文字列で割り算をすることで発生した :exc:`TypeError` は :keyword:`except` 節で"

"処理されていないので、 :keyword:`!finally` 節実行後に再度送出されています。"

#: ../../tutorial/errors.rst:413

msgid ""

"In real world applications, the :keyword:`finally` clause is useful for "

"releasing external resources (such as files or network connections), "

"regardless of whether the use of the resource was successful."

msgstr ""

"実世界のアプリケーションでは、 :keyword:`finally` 節は(ファイルやネットワーク"

"接続などの)外部リソースを、利用が成功したかどうかにかかわらず解放するために便"

"利です。"

#: ../../tutorial/errors.rst:421

msgid "Predefined Clean-up Actions"

msgstr "定義済みクリーンアップ処理"

#: ../../tutorial/errors.rst:423

msgid ""

"Some objects define standard clean-up actions to be undertaken when the "

"object is no longer needed, regardless of whether or not the operation using "

"the object succeeded or failed. Look at the following example, which tries "

"to open a file and print its contents to the screen. ::"

msgstr ""

"オブジェクトのなかには、その利用の成否にかかわらず、不要になった際に実行され"

"る標準的なクリーンアップ処理が定義されているものがあります。以下の、ファイル"

"をオープンして内容を画面に表示する例をみてください。 ::"

#: ../../tutorial/errors.rst:431

msgid ""

"The problem with this code is that it leaves the file open for an "

"indeterminate amount of time after this part of the code has finished "

"executing. This is not an issue in simple scripts, but can be a problem for "

"larger applications. The :keyword:`with` statement allows objects like files "

"to be used in a way that ensures they are always cleaned up promptly and "

"correctly. ::"

msgstr ""

"このコードの問題点は、コードの実行が終わった後に不定の時間ファイルを開いたま"

"までいることです。これは単純なスクリプトでは問題になりませんが、大きなアプリ"

"ケーションでは問題になりえます。 :keyword:`with` 文はファイルのようなオブジェ"

"クトが常に、即座に正しくクリーンアップされることを保証します。 ::"

#: ../../tutorial/errors.rst:441

msgid ""

"After the statement is executed, the file *f* is always closed, even if a "

"problem was encountered while processing the lines. Objects which, like "

"files, provide predefined clean-up actions will indicate this in their "

"documentation."

msgstr ""

"この文が実行されたあとで、たとえ行の処理中に問題があったとしても、ファイル "

"*f* は常に close されます。ファイルなどの、定義済みクリーンアップ処理を持つオ"

"ブジェクトについては、それぞれのドキュメントで示されます。"

python-docs-ja/tutorial/errors.po at 3.7 · python/python-docs-ja · GitHub

Repository navigation

Expand file tree

Breadcrumbs

errors.po

Latest commit

History

Breadcrumbs

errors.po

File metadata and controls