Hướng dẫn python essential reference 6th edition pdf - python cần thiết tài liệu tham khảo phiên bản thứ 6 pdf

Table of contents :
Table of Contents......Page 8
Introduction......Page 26
I: The Python Language......Page 28
Running Python......Page 30
Variables and Arithmetic Expressions......Page 32
Conditionals......Page 34
File Input and Output......Page 35
Strings......Page 36
Lists......Page 37
Tuples......Page 39
Sets......Page 40
Dictionaries......Page 41
Iteration and Looping......Page 42
Functions......Page 43
Generators......Page 44
Coroutines......Page 45
Objects and Classes......Page 46
Exceptions......Page 47
Modules......Page 48
Getting Help......Page 49
Line Structure and Indentation......Page 50
Numeric Literals......Page 51
String Literals......Page 52
Containers......Page 54
Decorators......Page 55
Source Code Encoding......Page 56
Object Identity and Type......Page 58
Reference Counting and Garbage Collection......Page 59
References and Copies......Page 60
First-Class Objects......Page 61
Built-in Types for Representing Data......Page 62
Built-in Types for Representing Program Structure......Page 72
Built-in Types for Interpreter Internals......Page 76
Object Behavior and Special Methods......Page 79
Operations on Numbers......Page 90
Operations on Sequences......Page 92
String Formatting......Page 95
Advanced String Formatting......Page 97
Operations on Dictionaries......Page 99
Augmented Assignment......Page 100
Conversion Functions......Page 101
Boolean Expressions and Truth Values......Page 102
Order of Evaluation......Page 103
Conditional Expressions......Page 104
Conditional Execution......Page 106
Loops and Iteration......Page 107
Exceptions......Page 109
Context Managers and the with Statement......Page 114
Assertions and __debug__......Page 116
Functions......Page 118
Parameter Passing and Return Values......Page 120
Scoping Rules......Page 121
Functions as Objects and Closures......Page 123
Decorators......Page 126
Generators and yield......Page 127
Coroutines and yield Expressions......Page 129
Using Generators and Coroutines......Page 131
List Comprehensions......Page 133
Generator Expressions......Page 134
Declarative Programming......Page 135
Recursion......Page 137
Documentation Strings......Page 138
Function Attributes......Page 139
eval[], exec[], and compile[]......Page 140
The class Statement......Page 142
Scoping Rules......Page 143
Inheritance......Page 144
Polymorphism Dynamic Binding and Duck Typing......Page 147
Static Methods and Class Methods......Page 148
Properties......Page 149
Descriptors......Page 151
Data Encapsulation and Private Attributes......Page 152
Object Memory Management......Page 153
Object Representation and Attribute Binding......Page 156
__slots__......Page 157
Operator Overloading......Page 158
Types and Class Membership Tests......Page 159
Abstract Base Classes......Page 161
Metaclasses......Page 163
Class Decorators......Page 166
Modules and the import Statement......Page 168
Importing Selected Symbols from a Module......Page 170
Execution as the Main Program......Page 171
Module Loading and Compilation......Page 172
Packages......Page 174
Distributing Python Programs and Libraries......Page 177
Installing Third-Party Libraries......Page 179
Reading Command-Line Options......Page 182
Files and File Objects......Page 183
Standard Input, Output, and Error......Page 186
The print Statement......Page 187
Variable Interpolation in Text Output......Page 188
Generating Output......Page 189
Unicode String Handling......Page 190
Unicode I/O......Page 192
Object Persistence and the pickle Module......Page 196
Interpreter Options and Environment......Page 198
Interactive Sessions......Page 200
Launching Python Applications......Page 201
Per-user Site Packages......Page 202
Enabling Future Features......Page 203
Program Termination......Page 204
Documentation Strings and the doctest Module......Page 206
Unit Testing and the unittest Module......Page 208
The Python Debugger and the pdb Module......Page 211
Program Profiling......Page 215
Tuning and Optimization......Page 216
II: The Python Library......Page 224
Built-in Functions and Types......Page 226
Built-In Exceptions......Page 237
Built-In Warnings......Page 241
future_builtins......Page 242
copy......Page 244
gc......Page 245
inspect......Page 247
pickle......Page 251
sys......Page 254
traceback......Page 260
types......Page 262
warnings......Page 263
weakref......Page 265
decimal......Page 268
fractions......Page 275
math......Page 276
numbers......Page 277
random......Page 279
abc......Page 282
array......Page 284
bisect......Page 286
collections......Page 287
contextlib......Page 292
functools......Page 293
heapq......Page 294
itertools......Page 295
operator......Page 298
codecs......Page 302
re......Page 306
string......Page 312
struct......Page 315
unicodedata......Page 318
Relational Database API Specification......Page 322
sqlite3 Module......Page 328
DBM-Style Database Modules......Page 335
shelve Module......Page 336
bz2......Page 338
filecmp......Page 339
fnmatch......Page 341
gzip......Page 342
shutil......Page 343
tarfile......Page 344
tempfile......Page 348
zipfile......Page 349
zlib......Page 353
commands......Page 356
configParser, Configparser......Page 357
datetime......Page 361
errno......Page 368
fcntl......Page 372
io......Page 374
logging......Page 380
mmap......Page 394
msvcrt......Page 397
optparse......Page 399
os......Page 403
os.path......Page 421
signal......Page 424
subprocess......Page 427
time......Page 430
winreg......Page 433
Basic Concepts......Page 438
Concurrent Programming and Python......Page 439
multiprocessing......Page 440
threading......Page 461
queue, Queue......Page 469
Coroutines and Microthreading......Page 471
Network Programming Basics......Page 474
asynchat......Page 477
asyncore......Page 480
select......Page 484
socket......Page 494
ssl......Page 511
SocketServer......Page 514
ftplib......Page 522
http Package......Page 525
smtplib......Page 538
urllib Package......Page 539
xmlrpc Package......Page 549
23 Web Programming......Page 556
cgi......Page 558
cgitb......Page 564
wsgiref......Page 565
webbrowser......Page 569
base64......Page 570
binascii......Page 572
csv......Page 573
email Package......Page 577
hmac......Page 584
HTMLParser......Page 586
json......Page 588
mimetypes......Page 591
quopri......Page 592
xml Package......Page 593
Python Services......Page 610
Operating System Modules......Page 611
Internationalization......Page 612
Miscellaneous......Page 613
III: Extending and Embedding......Page 614
Extension Modules......Page 616
Embedding the Python Interpreter......Page 633
ctypes......Page 637
Advanced Extending and Embedding......Page 644
Jython and IronPython......Page 645
Who Should Be Using Python 3?......Page 646
Set Literals......Page 647
Extended Iterable Unpacking......Page 648
Function Annotations......Page 649
Keyword-Only Arguments......Page 650
Chained Exceptions......Page 651
Advanced Metaclasses......Page 652
Text Versus Bytes......Page 654
print[] and exec[] Functions......Page 656
Use of Iterators and Views......Page 657
File Names, Arguments, and Environment Variables......Page 658
Porting Code to Python 2.6......Page 659
Using the 2to3 Tool......Page 660
A Practical Porting Strategy......Page 662
Participate......Page 663
Index......Page 664
A......Page 665
B......Page 668
C......Page 670
D......Page 677
E......Page 682
F......Page 686
G......Page 690
H......Page 695
I......Page 697
J......Page 701
L......Page 702
M......Page 705
N......Page 709
O......Page 711
P......Page 713
Q......Page 718
R......Page 719
S......Page 723
T......Page 732
U......Page 736
W......Page 739
X......Page 741
Z......Page 742

Xem trước trích dẫn

Python Tài liệu tham khảo thiết yếu

Phiên bản thứ tư

H lib

Nhà phát triển Thư viện Tài liệu tham khảo thiết yếu cho các chuyên gia lập trình

Sách thư viện nhà phát triển được thiết kế để cung cấp cho các lập trình viên thực hành các tài liệu tham khảo và hướng dẫn chất lượng cao, độc đáo về các ngôn ngữ và công nghệ lập trình mà họ sử dụng trong công việc hàng ngày của họ. Tất cả các cuốn sách trong thư viện nhà phát triển được viết bởi các nhà thực hành công nghệ chuyên gia, những người đặc biệt có kỹ năng tổ chức và trình bày thông tin theo cách mà hữu ích cho các lập trình viên khác. Các tiêu đề chính bao gồm một số cuốn sách hay nhất được hoan nghênh nhất trong lĩnh vực chủ đề của họ: phát triển web PHP và MySQL

Python Tài liệu tham khảo thiết yếu

Luke Welling & Laura Thomson ISBN 978-0-672-32916-6

David Beazley ISBN-13: 978-0-672-32862-6

Mysql

Lập trình trong Objective-C

Paul Dubois ISBN-13: 978-0-672-32938-8

Stephen G. Kochan ISBN-13: 978-0-321-56615-7

Phát triển kernel Linux

Postgresql

Robert Love ISBN-13: 978-0-672-32946-3

Korry Douglas ISBN-13: 978-0-672-33015-5

Sách thư viện nhà phát triển có sẵn tại hầu hết các nhà sách bán lẻ và trực tuyến, cũng như bằng cách đăng ký từ Safari Books Online tại Safari.informit.com

Thư viện nhà phát triển Informit.com/devl Library

H lib

Nhà phát triển Thư viện Tài liệu tham khảo thiết yếu cho các chuyên gia lập trình

Phiên bản thứ tư

Python Tài liệu tham khảo thiết yếu

H lib

Nhà phát triển Thư viện Tài liệu tham khảo thiết yếu cho các chuyên gia lập trình

Python Tài liệu tham khảo thiết yếu

Luke Welling & Laura Thomson ISBN 978-0-672-32916-6

David Beazley ISBN-13: 978-0-672-32862-6

Mysql

Lập trình trong Objective-C

Paul Dubois ISBN-13: 978-0-672-32938-8

Stephen G. Kochan ISBN-13: 978-0-321-56615-7

Phát triển kernel Linux

Postgresql

Robert Love ISBN-13: 978-0-672-32946-3

Korry Douglas ISBN-13: 978-0-672-33015-5

H lib

Nhà phát triển Thư viện Tài liệu tham khảo thiết yếu cho các chuyên gia lập trình

H lib

Nhà phát triển Thư viện Tài liệu tham khảo thiết yếu cho các chuyên gia lập trình

Python Tài liệu tham khảo thiết yếu

Luke Welling & Laura Thomson ISBN 978-0-672-32916-6

David Beazley ISBN-13: 978-0-672-32862-6

Mysql

Lập trình trong Objective-C

117

143

157

Paul Dubois ISBN-13: 978-0-672-32938-8

173

Stephen G. Kochan ISBN-13: 978-0-321-56615-7

181

Phát triển kernel Linux

201

13 Dịch vụ thời gian chạy Python 14 Toán học

219

243

15 Cấu trúc dữ liệu, thuật toán và đơn giản hóa mã 16 Chuỗi và xử lý văn bản

277

17 Truy cập cơ sở dữ liệu Python

297

18 tệp và thư mục xử lý

313

19 Dịch vụ hệ điều hành

331

20 chủ đề và đồng thời

413

21 Lập trình mạng và ổ cắm 22 Lập trình ứng dụng Internet 23 Lập trình web

257

449 497

531

24 Xử lý dữ liệu Internet và mã hóa 25 Mô -đun thư viện linh tinh

545

585

Phần III: Mở rộng và nhúng 26 phần mở rộng và nhúng Python

Phụ lục: Chỉ số Python 3

591

621

639

H lib

Mục lục Giới thiệu

I: Ngôn ngữ Python 1 Giới thiệu hướng dẫn chạy Python 5

Các biến số và biểu thức số học điều kiện

Danh sách các chuỗi đầu vào và đầu ra của tập tin

11 12

Bộ bộ đếm

14 15

Từ điển

Chức năng lặp và vòng lặp

Máy phát điện

Coroutines

Đối tượng và lớp Các mô -đun ngoại lệ

22 23

Tìm sự giúp đỡ

2 quy ước từ vựng và cú pháp 25 Cấu trúc dòng và thụt lề 25 định danh và các từ dành riêng.

26 27

Người vận hành, phân định và các biểu tượng đặc biệt Tài liệu Chuỗi trang trí

Mã mã nguồn

3 loại và thuật ngữ đối tượng 33

Nhận dạng đối tượng và loại

Đếm tài liệu tham khảo và thu thập rác tham chiếu và bản sao

H lib

Mục lục Giới thiệu

I: Ngôn ngữ Python 1 Giới thiệu hướng dẫn chạy Python 5

Các biến số và biểu thức số học điều kiện

Danh sách các chuỗi đầu vào và đầu ra của tập tin

11 12

Bộ bộ đếm

14 15

Từ điển

Chức năng lặp và vòng lặp

Máy phát điện

Coroutines

Đối tượng và lớp Các mô -đun ngoại lệ

22 23

Tìm sự giúp đỡ

2 quy ước từ vựng và cú pháp 25 Cấu trúc dòng và thụt lề 25 định danh và các từ dành riêng.

26 27

Người vận hành, phân định và các biểu tượng đặc biệt Tài liệu Chuỗi trang trí

Mã mã nguồn

3 loại và thuật ngữ đối tượng 33

Nhận dạng đối tượng và loại

Đếm tài liệu tham khảo và thu thập rác tham chiếu và bản sao

viii

Nội dung

Đối tượng hạng nhất

Các loại tích hợp để đại diện cho dữ liệu

Không có loại

Các loại số

Các loại trình tự

Các loại ánh xạ các loại đặt

H lib

I: Ngôn ngữ Python 1 Giới thiệu hướng dẫn chạy Python 5

Các biến số và biểu thức số học điều kiện

Danh sách các chuỗi đầu vào và đầu ra của tập tin

11 12

Bộ bộ đếm

14 15

Từ điển

Chức năng lặp và vòng lặp

Máy phát điện

Coroutines

Đối tượng và lớp Các mô -đun ngoại lệ

22 23

101

Tìm sự giúp đỡ

102

2 quy ước từ vựng và cú pháp 25 Cấu trúc dòng và thụt lề 25 định danh và các từ dành riêng.

104

26 27

106

Người vận hành, phân định và các biểu tượng đặc biệt Tài liệu Chuỗi trang trí

108

Mã mã nguồn

109

3 loại và thuật ngữ đối tượng 33

Nhận dạng đối tượng và loại

Đếm tài liệu tham khảo và thu thập rác tham chiếu và bản sao

110

112

viii

113

114

Nội dung

115

Đối tượng hạng nhất

Các loại tích hợp để đại diện cho dữ liệu

117

Không có loại

119

H lib

Mục lục Giới thiệu

I: Ngôn ngữ Python 1 Giới thiệu hướng dẫn chạy Python 5

Các biến số và biểu thức số học điều kiện

122

123

124

Danh sách các chuỗi đầu vào và đầu ra của tập tin

126

11 12

127

128

Bộ bộ đếm

14 15

132

Từ điển

133

Chức năng lặp và vòng lặp

131

134

136

138

Máy phát điện

141

Coroutines

146

147

Đối tượng và lớp Các mô -đun ngoại lệ

147

22 23

149

Tìm sự giúp đỡ

149

2 quy ước từ vựng và cú pháp 25 Cấu trúc dòng và thụt lề 25 định danh và các từ dành riêng.

26 27

158

Người vận hành, phân định và các biểu tượng đặc biệt Tài liệu Chuỗi trang trí

158

157

Mã mã nguồn

161

3 loại và thuật ngữ đối tượng 33

Nhận dạng đối tượng và loại

152

154

Đếm tài liệu tham khảo và thu thập rác tham chiếu và bản sao

163

164

viii

145

165

167

Mã hóa dữ liệu Unicode

168

Thuộc tính ký tự Unicode

170

Sự tồn tại đối tượng và mô -đun Pickle

171

H lib

Nội dung

10 Môi trường thực thi 173 Tùy chọn phiên dịch và Phiên tương tác môi trường

173

175

Khởi chạy các tệp cấu hình trang web của ứng dụng Python

177

Gói trang web của người dùng

177

Cho phép chấm dứt chương trình tính năng trong tương lai

176

178

179

11 Kiểm tra, gỡ lỗi, lập hồ sơ và điều chỉnh 181 chuỗi tài liệu và mô -đun tài liệu thử nghiệm đơn vị 181 và mô -đun Unittest

183

Trình gỡ lỗi Python và mô -đun PDB

Lệnh gỡ lỗi

Gỡ lỗi từ dòng lệnh Định cấu hình chương trình trình gỡ lỗi định hình 190 điều chỉnh và tối ưu hóa

191

Tạo phép đo bộ nhớ

192

194

II: Thư viện Python

199

12 Chức năng và ngoại lệ tích hợp các chức năng và loại ngoại lệ tích hợp 201

201

212

Các lớp cơ sở ngoại lệ Các trường hợp ngoại lệ

212

Các lớp ngoại lệ được xác định trước Cảnh báo tích hợp 216

213

217

13 Dịch vụ thời gian chạy Python ATEXIT 219 Bản sao

191

193

Chiến lược điều chỉnh

Tương lai_builtins

189

190

Làm cho các phép đo thời gian tháo gỡ

186

187

219

Ghi chú

220

H lib

Nội dung

10 Môi trường thực thi 173 Tùy chọn phiên dịch và Phiên tương tác môi trường

220

Khởi chạy các tệp cấu hình trang web của ứng dụng Python

226

Gói trang web của người dùng

226

Cho phép chấm dứt chương trình tính năng trong tương lai

11 Kiểm tra, gỡ lỗi, lập hồ sơ và điều chỉnh 181 chuỗi tài liệu và mô -đun tài liệu thử nghiệm đơn vị 181 và mô -đun Unittest

Trình gỡ lỗi Python và mô -đun PDB

229

Lệnh gỡ lỗi

Gỡ lỗi từ dòng lệnh Định cấu hình chương trình trình gỡ lỗi định hình 190 điều chỉnh và tối ưu hóa

237

Tạo phép đo bộ nhớ

II: Thư viện Python

12 Chức năng và ngoại lệ tích hợp các chức năng và loại ngoại lệ tích hợp 201

Các lớp cơ sở ngoại lệ Các trường hợp ngoại lệ

Các lớp ngoại lệ được xác định trước Cảnh báo tích hợp 216

13 Dịch vụ thời gian chạy Python ATEXIT 219 Bản sao

Chiến lược điều chỉnh

244

Tương lai_builtins

244

Làm cho các phép đo thời gian tháo gỡ

247

248

Ghi chú

251

Ghi chú

252

XII

252

254

Ghi chú 222 Kiểm tra 222 Thống chế

254

Ghi chú Pickle

255

256

H lib

Nội dung

10 Môi trường thực thi 173 Tùy chọn phiên dịch và Phiên tương tác môi trường

257

259

Khởi chạy các tệp cấu hình trang web của ứng dụng Python

262

Gói trang web của người dùng

262

263

Cho phép chấm dứt chương trình tính năng trong tương lai

265

11 Kiểm tra, gỡ lỗi, lập hồ sơ và điều chỉnh 181 chuỗi tài liệu và mô -đun tài liệu thử nghiệm đơn vị 181 và mô -đun Unittest

268

269

Trình gỡ lỗi Python và mô -đun PDB

270

Lệnh gỡ lỗi

Gỡ lỗi từ dòng lệnh Định cấu hình chương trình trình gỡ lỗi định hình 190 điều chỉnh và tối ưu hóa

Tạo phép đo bộ nhớ

277

II: Thư viện Python

279

12 Chức năng và ngoại lệ tích hợp các chức năng và loại ngoại lệ tích hợp 201

Các lớp cơ sở ngoại lệ Các trường hợp ngoại lệ

277

Các lớp ngoại lệ được xác định trước Cảnh báo tích hợp 216

280

13 Dịch vụ thời gian chạy Python ATEXIT 219 Bản sao

281

283

Chiến lược điều chỉnh

284

285

286

Tương lai_builtins

287

Làm cho các phép đo thời gian tháo gỡ

Ghi chú

XII

290

291

H lib

Nội dung

Ghi chú 222 Kiểm tra 222 Thống chế

Ghi chú Pickle

291

Ghi chú 229 229

sys

Biến

297

298

Chức năng 233 235

300

301

Các loại TraceBack

302

Ghi chú cảnh báo

302

237 238

303

Ghi chú yếu

305

239 240

311

Ví dụ ghi chú

313

314

242 242

316

14 Toán học 243 thập phân 243 đối tượng thập phân

316

Đối tượng bối cảnh

Các chức năng và các ví dụ về hằng số

317

Ghi chú 249 Phân số 250 Toán học

319

số

322

Ghi chú 253 ngẫu nhiên 254 Hạt giống và khởi tạo số nguyên ngẫu nhiên

Trình tự ngẫu nhiên

H lib

Nội dung

Ghi chú phân phối ngẫu nhiên có giá trị thực

15 Cấu trúc dữ liệu, thuật toán và đơn giản hóa mã ABC 257 mảng

331

332

XIII

332

Ghi chú 261 Bisect 261 Bộ sưu tập

332

334

Ghi chú

336

XII

336

Ghi chú 222 Kiểm tra 222 Thống chế

338

Ghi chú Pickle

339

Ghi chú 229 229

340

sys

341

342

Biến

343

Chức năng 233 235

Các loại TraceBack

344

Ghi chú cảnh báo

237 238

Ghi chú yếu

346

349

350

239 240

351

353

Ví dụ ghi chú

354

242 242

354

14 Toán học 243 thập phân 243 đối tượng thập phân

Đối tượng bối cảnh

355

Các chức năng và các ví dụ về hằng số

355

Ghi chú 249 Phân số 250 Toán học

số

364

Ghi chú 253 ngẫu nhiên 254 Hạt giống và khởi tạo số nguyên ngẫu nhiên

366

Trình tự ngẫu nhiên

366

369

H lib

Ghi chú phân phối ngẫu nhiên có giá trị thực

Nội dung

15 Cấu trúc dữ liệu, thuật toán và đơn giản hóa mã ABC 257 mảng

369

XIII

374

Ghi chú 261 Bisect 261 Bộ sưu tập

Deque và DefaultDict có tên Tuples

Các lớp cơ sở trừu tượng 267

379

bối cảnh functools Heapq

390

itertools

395

Ví dụ 273 273

381

386

396

nhà điều hành

399

16 chuỗi và xử lý văn bản codecs 277

401

Giao diện Codec cấp thấp giao diện các hàm liên quan đến I/O Hằng số hữu ích

404

Mã hóa tiêu chuẩn Re

Ghi chú 281

279 280

Hàm cú pháp mẫu

Ghi chú

411

XII

413

Ghi chú 222 Kiểm tra 222 Thống chế

414

415

Ghi chú Pickle

417

424

Ghi chú 229 229

426

428

433

sys

434

Biến

435

luồng

Đối tượng của các đối tượng đối tượng

436 437 f

H lib

Nội dung

Khóa đối tượng rlock

xvii

438

Semaphore và các sự kiện Semaphore bị ràng buộc

439

440

Biến điều kiện

441

Làm việc với khóa

442

Chấm dứt chủ đề và các chức năng tiện ích đình chỉ

443

Lập trình khóa thông dịch toàn cầu với Chủ đề 444

444 444

Hàng đợi, hàng đợi

Ví dụ về hàng đợi với các chủ đề 445 Coroutines và Microthreading 446 21 Lập trình mạng và ổ đĩa Lập trình mạng cơ bản 449 Asynchat

452

không đồng bộ

455

449

Ví dụ 457 Chọn 459 tính năng mô -đun nâng cao

460

Ví dụ I/O không đồng bộ nâng cao

460

Khi nào nên xem xét ổ cắm mạng không đồng bộ 469 địa chỉ các loại ổ cắm về các chức năng giải quyết các chức năng

470

470 471

473

Ví dụ ngoại lệ

467

485 485

Ghi chú 486 SSL 486 Ví dụ

489

Máy chủ lưu trữ

489

Máy chủ xử lý

490 491

Xác định máy chủ tùy chỉnh

492

Tùy chỉnh máy chủ ứng dụng

494

H lib

Nội dung

Khóa đối tượng rlock

xvii

497

Semaphore và các sự kiện Semaphore bị ràng buộc

Biến điều kiện

Làm việc với khóa

502

Chấm dứt chủ đề và các chức năng tiện ích đình chỉ

511

Lập trình khóa thông dịch toàn cầu với Chủ đề 444

513

444 444

Hàng đợi, hàng đợi

Ví dụ về hàng đợi với các chủ đề 445 Coroutines và Microthreading 446 21 Lập trình mạng và ổ đĩa Lập trình mạng cơ bản 449 Asynchat

515

520

không đồng bộ

Ví dụ 457 Chọn 459 tính năng mô -đun nâng cao

523

Ví dụ I/O không đồng bộ nâng cao

524

Khi nào nên xem xét ổ cắm mạng không đồng bộ 469 địa chỉ các loại ổ cắm về các chức năng giải quyết các chức năng

531

470 471

537

Ví dụ ngoại lệ

485 485

Ghi chú 486 SSL 486 Ví dụ

540

Máy chủ lưu trữ

540

542

Máy chủ xử lý

490 491

545

547

548

Xác định máy chủ tùy chỉnh

551

Tùy chỉnh máy chủ ứng dụng

551

H lib

Nội dung

Khóa đối tượng rlock

xvii

552

Semaphore và các sự kiện Semaphore bị ràng buộc

552

Biến điều kiện

555

Làm việc với khóa

559

Tùy chỉnh máy chủ ứng dụng

xviii

22 Lập trình ứng dụng Internet FTPLIB 497 Ví dụ

562

500 500

Gói HTTP

566

567

http.client [httplib]

568

http.server [baseHttpserver, cgihttpserver, simpleHttpserver] 506 http.cookies [cookie]

http.cookiejar [cookielib] smtplib 513 ví dụ

569

514 514

580

Gói Urllib

583

Urllib.Request [Urllib2] Urllib.Response Urllib.Parse Urllib.error

586

520 523

585

586

587

Urllib.robotparser [Robotparser]

587

Ghi chú 524 XMLRPC Gói 524 XMLRPC.Client [XMLRPCLIB]

588

XMLRPC.Server [SimplexMLRPCServer, DOCXMLRPCServer] 527 23 Lập trình web CGI 533

589

Lời khuyên lập trình CGI

591

Ghi chú 538 539

593

CGITB

595

WSGIREF

596

Đặc tả WSGI Gói WSGiref 544

597

trình duyệt web

602

H lib

xviii

Nội dung

22 Lập trình ứng dụng Internet FTPLIB 497 Ví dụ

605

500 500

604

607

Gói HTTP

http.client [httplib]

608

http.server [baseHttpserver, cgihttpserver, simpleHttpserver] 506 http.cookies [cookie]

608

http.cookiejar [cookielib] smtplib 513 ví dụ

610

514 514

611

612

613

Gói Urllib

615

Urllib.Request [Urllib2] Urllib.Response Urllib.Parse Urllib.error

616

617

520 523

619

620

Urllib.robotparser [Robotparser]

621

622

Ghi chú 524 XMLRPC Gói 524 XMLRPC.Client [XMLRPCLIB]

608

622

XMLRPC.Server [SimplexMLRPCServer, DOCXMLRPCServer] 527 23 Lập trình web CGI 533

624

Lời khuyên lập trình CGI

625

Ghi chú 538 539

626

CGITB

626

WSGIREF

627

Đặc tả WSGI Gói WSGiref 544

623

624

trình duyệt web

24 Cơ sở xử lý và mã hóa dữ liệu Internet64 545 Binascii CSV

623

627

Phương ngữ

H lib

Nội dung

xviii

631

632

22 Lập trình ứng dụng Internet FTPLIB 497 Ví dụ

500 500

633

Gói HTTP

633

http.client [httplib]

633

634

http.server [baseHttpserver, cgihttpserver, simpleHttpserver] 506 http.cookies [cookie]

http.cookiejar [cookielib] smtplib 513 ví dụ

514 514

634

635

Gói Urllib

637

Urllib.Request [Urllib2] Urllib.Response Urllib.Parse Urllib.error

638

520 523

H lib

xviii

About the Technical Editor Noah Gift is the co-author of Python For UNIX and Linux System Administration [O’Reilly] and is also working on Google App Engine In Action [Manning]. He is an author, speaker, consultant, and community leader, writing for publications such as IBM developerWorks, Red Hat Magazine, O’Reilly, and MacTech. His consulting company’s website is //www.giftcs.com, and much of his writing can be found at //noahgift.com.You can also follow Noah on Twitter. Noah has a master’s degree in CIS from Cal State, Los Angeles, a B.S. in nutritional science from Cal Poly San Luis Obispo, is an Apple and LPI-certified SysAdmin, and has worked at companies such as Caltech, Disney Feature Animation, Sony Imageworks, and Turner Studios. He is currently working at Weta Digital in New Zealand. In his free time he enjoys spending time with his wife Leah and their son Liam, composing for the piano, running marathons, and exercising religiously.

h Lib

Acknowledgments This book would not be possible without the support of many people. First and foremost, I’d like to thank Noah Gift for jumping into the project and providing his amazing feedback on the fourth edition. Kurt Grandis also provided useful comments for many chapters. I’d also like to acknowledge past technical reviewers Timothy Boronczyk, Paul DuBois, Mats Wichmann, David Ascher, and Tim Bell for their valuable comments and advice that made earlier editions a success. Guido van Rossum, Jeremy Hylton, Fred Drake, Roger Masse, and Barry Warsaw also provided tremendous assistance with the first edition while hosting me for a few weeks back in the hot summer of 1999. Last, but not least, this book would not be possible without all of the feedback I received from readers.There are far too many people to list individually, but I have done my best to incorporate your suggestions for making the book even better. I’d also like to thank all the folks at Addison-Wesley and Pearson Education for their continued commitment to the project and assistance. Mark Taber, Michael Thurston, Seth Kerney, and Lisa Thibault all helped out to get this edition out the door in good shape. A special thanks is in order for Robin Drake, whose tremendous effort in editing previous editions made the third edition possible. Finally, I’d like to acknowledge my amazing wife and partner Paula Kamen for all of her encouragement, diabolical humor, and love.

h Lib

We Want to Hear from You! As the reader of this book, you are our most important critic and commentator.We value your opinion and want to know what we’re doing right, what we could do better, what areas you’d like to see us publish in, and any other words of wisdom you’re willing to pass our way. You can email or write me directly to let me know what you did or didn’t like about this book—as well as what we can do to make our books stronger. Please note that I cannot help you with technical problems related to the topic of this book, and that due to the high volume of mail I receive, I might not be able to reply to every message. When you write, please be sure to include this book’s title and author as well as your name and phone or email address. I will carefully review your comments and share them with the author and editors who worked on the book. Email: Mail:

[email protected] Mark Taber Associate Publisher Pearson Education 800 East 96th Street Indianapolis, IN 46240 USA

Reader Services Visit our website and register this book at informit.com/register for convenient access to any updates, downloads, or errata that might be available for this book.

h Lib

Introduction T

his book is intended to be a concise reference to the Python programming language. Although an experienced programmer will probably be able to learn Python from this book, it’s not intended to be an extended tutorial or a treatise on how to program. Rather, the goal is to present the core Python language, and the most essential parts of the Python library in a manner that’s accurate and concise.This book assumes that the reader has prior programming experience with Python or another language such as C or Java. In addition, a general familiarity with systems programming topics [for example, basic operating system concepts and network programming] may be useful in understanding certain parts of the library reference. Python is freely available for download at //www.python.org.Versions are available for almost every operating system, including UNIX,Windows, and Macintosh. In addition, the Python website includes links to documentation, how-to guides, and a wide assortment of third-party software. This edition of Python Essential Reference comes at a pivotal time in Python’s evolution. Python 2.6 and Python 3.0 are being released almost simultaneously.Yet, Python 3 is a release that breaks backwards compatibility with prior Python versions. As an author and programmer, I’m faced with a dilemma: do I simply jump forward to Python 3.0 or do I build upon the Python 2.x releases that are more familiar to most programmers? Years ago, as a C programmer I used to treat certain books as the ultimate authority on what programming language features should be used. For example, if you were using something that wasn’t documented in the K&R book, it probably wasn’t going to be portable and should be approached with caution.This approach served me very well as a programmer and it’s the approach I have decided to take in this edition of the Essential Reference. Namely, I have chosen to omit features of Python 2 that have been removed from Python 3. Likewise, I don’t focus on features of Python 3 that have not been back-ported [although such features are still covered in an appendix]. As a result, I hope this book can be a useful companion for Python programmers, regardless of what Python version is being used. The fourth edition of Python Essential Reference also includes some of the most exciting changes since its initial publication nearly ten years ago. Much of Python’s development throughout the last few years has focused on new programming language features—especially related to functional and meta programming. As a result, the chapters on functions and object-oriented programming have been greatly expanded to cover topics such as generators, iterators, coroutines, decorators, and metaclasses.The library chapters have been updated to focus on more modern modules. Examples and code fragments have also been updated throughout the book. I think most programmers will be quite pleased with the expanded coverage. Finally, it should be noted that Python already includes thousands of pages of useful documentation.The contents of this book are largely based on that documentation, but with a number of key differences. First, this reference presents information in a much more compact form, with different examples and alternative descriptions of many topics. Second, a significant number of topics in the library reference have been expanded

H lib

Giới thiệu

Để bao gồm các tài liệu tham khảo bên ngoài. Điều này đặc biệt đúng đối với các mô-đun mạng và hệ thống cấp thấp trong đó sử dụng hiệu quả một mô-đun thường dựa vào vô số các tùy chọn được liệt kê trong hướng dẫn và tham chiếu bên ngoài. Ngoài ra, để tạo ra một tài liệu tham khảo súc tích hơn, một số mô -đun thư viện không phản đối và tương đối mơ hồ đã bị bỏ qua. Khi viết cuốn sách này, mục tiêu của tôi là sản xuất một tài liệu tham khảo chứa hầu như mọi thứ tôi cần để sử dụng Python và bộ sưu tập lớn các mô -đun. Mặc dù điều này không có nghĩa là giới thiệu nhẹ nhàng về ngôn ngữ Python, tôi hy vọng rằng bạn tìm thấy nội dung của cuốn sách này là một bổ sung hữu ích cho thư viện tham khảo chương trình của bạn trong nhiều năm tới. Tôi hoan nghênh những góp ý của bạn. David Beazley Chicago, Illinois tháng 6 năm 2009

H lib

Giới thiệu

Tôi ngôn ngữ Python

Giới thiệu hướng dẫn

Các quy ước và cú pháp từ vựng

Các loại và đối tượng

Người vận hành và biểu thức

Cấu trúc chương trình và luồng điều khiển

Chức năng và lập trình chức năng

Các lớp và lập trình hướng đối tượng

Các mô -đun, gói và phân phối

Đầu vào và đầu ra

H lib

Giới thiệu

H lib

Giới thiệu

Tôi ngôn ngữ Python

H lib

Giới thiệu

Tôi ngôn ngữ Python

Giới thiệu hướng dẫn

Các quy ước và cú pháp từ vựng

Các loại và đối tượng

Các tệp nguồn Python là các tệp văn bản thông thường và thường có hậu tố .py. Ký tự # biểu thị một nhận xét mở rộng đến cuối dòng. Để thực thi tệp Helloworld.py, bạn cung cấp tên tệp cho trình thông dịch như sau: % Python HelloWorld.py Hello World %

Trên Windows, các chương trình Python có thể được bắt đầu bằng cách nhấp đúp vào tệp .py hoặc nhập tên của chương trình vào lệnh Run trên menu Windows Start. Điều này khởi chạy trình thông dịch và chạy chương trình trong cửa sổ bảng điều khiển. Tuy nhiên, hãy lưu ý rằng cửa sổ bảng điều khiển sẽ biến mất ngay sau khi chương trình hoàn thành việc thực hiện [thường trước khi bạn có thể đọc đầu ra của nó]. Để gỡ lỗi, tốt hơn là chạy chương trình trong một công cụ phát triển Python như nhàn rỗi. Trên Unix, bạn có thể sử dụng #! Trên dòng đầu tiên của chương trình, như thế này: #!/usr/bin/env Python in "Hello World"

H lib

Các biến và biểu thức số học

Trình thông dịch chạy các câu lệnh cho đến khi nó đi đến cuối tệp đầu vào. Nếu nó chạy tương tác, bạn có thể thoát khỏi trình thông dịch bằng cách nhập ký tự EOF [cuối tệp] hoặc bằng cách chọn thoát khỏi menu kéo xuống của một IDE Python. Trên Unix, EOF là Ctrl+D; Trên Windows, nó CTRL+Z. Một chương trình có thể yêu cầu thoát bằng cách tăng ngoại lệ hệ thống. >>> Nâng cao hệ thống

Các biến và biểu thức số học Chương trình trong liệt kê 1.1 cho thấy việc sử dụng các biến và biểu thức bằng cách thực hiện tính toán lợi ích hợp chất đơn giản. Liệt kê 1.1

Tính toán hợp chất đơn giản

Hiệu trưởng = 1000 # tỷ lệ = 0,05 # numyears = 5 # năm = 1 trong khi năm 8]: In "Tôi sẽ lấy nó!"

Lưu ý Viết các trường hợp thử nghiệm phức tạp thường dẫn đến các tuyên bố liên quan đến một dòng mã dài khó chịu. Để cải thiện khả năng đọc, bạn có thể tiếp tục bất kỳ câu lệnh nào cho dòng tiếp theo bằng cách sử dụng dấu gạch chéo ngược [\] ở cuối dòng như được hiển thị. Nếu bạn làm điều này, các quy tắc thụt bình thường don don áp dụng cho dòng tiếp theo, vì vậy bạn có thể tự do định dạng các dòng tiếp tục như bạn muốn.

Python không có công tắc đặc biệt hoặc câu lệnh CASE để kiểm tra các giá trị. Để xử lý các trường hợp nhiều thử nghiệm, hãy sử dụng câu lệnh ELIF, như thế này: Nếu hậu tố == ". .

Để biểu thị các giá trị sự thật, hãy sử dụng các giá trị boolean đúng và sai. Ở đây, một ví dụ: nếu 'spam' trong s: has_spam = true other: has_spam = false

All relational operators such as < and > return True or False as results.The in operator used in this example is commonly used to check whether a value is contained inside of another object such as a string, list, or dictionary. It also returns True or False, so the preceding example could be shortened to this: has_spam = 'spam' in s

H lib

Các biến và biểu thức số học

Tính toán hợp chất đơn giản

Hiệu trưởng = 1000 # tỷ lệ = 0,05 # numyears = 5 # năm = 1 trong khi năm 8]: In "Tôi sẽ lấy nó!"

Để biểu thị các giá trị sự thật, hãy sử dụng các giá trị boolean đúng và sai. Ở đây, một ví dụ: nếu 'spam' trong s: has_spam = true other: has_spam = false

Although these examples have worked with files, the same techniques apply to the standard output and input streams of the interpreter. For example, if you wanted to read user input interactively, you can read from the file sys.stdin. If you want to write data to the screen, you can write to sys.stdout, which is the same file used to output data produced by the print statement. For example: import sys sys.stdout.write["Enter your name :"] name = sys.stdin.readline[]

In Python 2, this code can also be shortened to the following: name = raw_input["Enter your name :"]

h Lib

Strings

In Python 3, the raw_input[] function is called input[], but it works in exactly the same manner.

Strings To create string literals, enclose them in single, double, or triple quotes as follows: a = "Hello World" b = 'Python is groovy' c = """Computer says 'No'"""

The same type of quote used to start a string must be used to terminate it.Triplequoted strings capture all the text that appears prior to the terminating triple quote, as opposed to single- and double-quoted strings, which must be specified on one logical line.Triple-quoted strings are useful when the contents of a string literal span multiple lines of text such as the following: print '''Content-type: text/html Hello World Click here. '''

Strings are stored as sequences of characters indexed by integers, starting at zero.To extract a single character, use the indexing operator s[i] like this: a = "Hello World" b = a[4]

# b = 'o'

To extract a substring, use the slicing operator s[i:j].This extracts all characters from s whose index k is in the range i >> x = 3.4 >>> str[x] '3.4' >>> repr[x] '3.3999999999999999' >>>

The inexact representation of 3.4 in the previous example is not a bug in Python. It is an artifact of double-precision floating-point numbers, which by their design can not exactly represent base-10 decimals on the underlying computer hardware. The format[] function is used to convert a value to a string with a specific formatting applied. For example: >>> format[x,"0.5f"] '3.40000' >>>

Lists Lists are sequences of arbitrary objects.You create a list by enclosing values in square brackets, as follows: names = [ "Dave", "Mark", "Ann", "Phil" ]

Lists are indexed by integers, starting with zero. Use the indexing operator to access and modify individual items of the list: a = names[2] names[0] = "Jeff"

# Returns the third item of the list, "Ann" # Changes the first item to "Jeff"

To append new items to the end of a list, use the append[] method: names.append["Paula"]

To insert an item into the middle of a list, use the insert[] method: names.insert[2, "Thomas"]

You can extract or reassign a portion of a list by using the slicing operator: b = names[0:2] c = names[2:] names[1] = 'Jeff' names[0:2] = ['Dave','Mark','Jeff']

# # # # #

Returns [ "Jeff", "Mark" ] Returns [ "Thomas", "Ann", "Phil", "Paula" ] Replace the 2nd item in names with 'Jeff' Replace the first two items of the list with the list on the right.

Use the plus [+] operator to concatenate lists: a = [1,2,3] + [4,5]

# Result is [1,2,3,4,5]

An empty list is created in one of two ways: names = [] names = list[]

# An empty list # An empty list

h Lib

Lists

Lists can contain any kind of Python object, including other lists, as in the following example: a = [1,"Dave",3.14, ["Mark", 7, 9, [100,101]], 10]

Items contained in nested lists are accessed by applying more than one indexing operation, as follows: a[1] a[3][2] a[3][3][1]

# Returns "Dave" # Returns 9 # Returns 101

The program in Listing 1.2 illustrates a few more advanced features of lists by reading a list of numbers from a file specified on the command line and outputting the minimum and maximum values. Listing 1.2

Advanced List Features

import sys # Load the sys module if len[sys.argv] != 2 # Check number of command line arguments : print "Please supply a filename" raise SystemExit[1] f = open[sys.argv[1]] # Filename on the command line lines = f.readlines[] # Read all lines into a list f.close[] # Convert all of the input values from strings to floats fvalues = [float[line] for line in lines] # Print min and max values print "The minimum value is ", min[fvalues] print "The maximum value is ", max[fvalues]

The first line of this program uses the import statement to load the sys module from the Python library.This module is being loaded in order to obtain command-line arguments. The open[] function uses a filename that has been supplied as a command-line option and placed in the list sys.argv.The readlines[] method reads all the input lines into a list of strings. The expression [float[line] for line in lines] constructs a new list by looping over all the strings in the list lines and applying the function float[] to each element.This particularly powerful method of constructing a list is known as a list comprehension. Because the lines in a file can also be read using a for loop, the program can be shortened by converting values using a single statement like this: fvalues = [float[line] for line in open[sys.argv[1]]]

Sau khi các dòng đầu vào đã được chuyển đổi thành một danh sách các số điểm nổi, các hàm min [] và tối đa [] tích hợp tính toán tính toán các giá trị tối thiểu và tối đa.

H lib

Chương 1

Giới thiệu hướng dẫn

Tuples Để tạo các cấu trúc dữ liệu đơn giản, bạn có thể đóng gói một tập hợp các giá trị với nhau thành một đối tượng bằng cách sử dụng một tuple. = ['www.python.org', 80] person = [first_name, last_name, điện thoại]

Python thường nhận ra rằng một tuple được dự định ngay cả khi dấu ngoặc đơn bị thiếu: stock = 'goog', 100, 490.10 Địa chỉ = 'www.python.org', 80 người = first_name, last_name, điện thoại

Để hoàn thiện, có thể xác định các bộ dữ liệu 0- và 1 phần tử, nhưng có cú pháp đặc biệt: a = [] b = [mục,] c = item,

# 0-TULE [trống Tuple] # 1-Tuple [Lưu ý dấu phẩy kéo dài] # 1-Tuple [Lưu ý dấu phẩy kéo dài]

Các giá trị trong một tuple có thể được trích xuất bằng chỉ mục số giống như một danh sách. Tuy nhiên, thông thường hơn là giải nén các bộ dữ

Mặc dù Tuples hỗ trợ hầu hết các hoạt động giống như danh sách [như lập chỉ mục, cắt và nối], nội dung của một tuple không thể được sửa đổi sau khi tạo [nghĩa là bạn không thể thay thế, xóa hoặc nối các yếu tố mới vào một bộ thuật hiện có] . Điều này phản ánh thực tế rằng một tuple được xem tốt nhất là một đối tượng duy nhất bao gồm một số phần, không phải là một tập hợp các đối tượng riêng biệt mà bạn có thể chèn hoặc loại bỏ các mục. Bởi vì có quá nhiều sự chồng chéo giữa các bộ dữ liệu và danh sách, một số lập trình viên có xu hướng bỏ qua các bộ dữ liệu hoàn toàn và chỉ cần sử dụng danh sách vì chúng có vẻ linh hoạt hơn. Mặc dù điều này hoạt động, nó lãng phí bộ nhớ nếu chương trình của bạn sẽ tạo ra một số lượng lớn danh sách nhỏ [nghĩa là mỗi danh sách chứa ít hơn một tá mục]. . Bởi vì các bộ dữ liệu là bất biến, chúng sử dụng một đại diện nhỏ gọn hơn khi không có thêm không gian. Tuples và danh sách thường được sử dụng cùng nhau để đại diện cho dữ liệu. Ví dụ: chương trình này cho thấy cách bạn có thể đọc một tệp bao gồm các cột dữ liệu khác nhau được phân tách bằng dấu phẩy: # Tệp chứa các dòng của biểu mẫu "Tên, Cổ phiếu, Giá" Tên = "Danh mục đầu tư.CSV" Danh mục đầu tư = [] Open [Tên tệp]: Field = line.split [","] # chia mỗi dòng thành một tên danh sách = trường [0] # Trích xuất và chuyển đổi các trường riêng lẻ chia sẻ = int [trường [1]] price = float [trường [2 ]] Stock = [Tên, Cổ phiếu, Giá] # Tạo Tuple [Tên, Cổ phiếu, Giá] Danh mục đầu tư

Phương thức chia [] của chuỗi chia một chuỗi thành một danh sách các trường được phân tách bằng ký tự phân cách đã cho. Cấu trúc dữ liệu danh mục đầu tư kết quả được tạo bởi chương trình này

H lib

Chương 1

Giới thiệu hướng dẫn

Để hoàn thiện, có thể xác định các bộ dữ liệu 0- và 1 phần tử, nhưng có cú pháp đặc biệt: a = [] b = [mục,] c = item,

# 0-TULE [trống Tuple] # 1-Tuple [Lưu ý dấu phẩy kéo dài] # 1-Tuple [Lưu ý dấu phẩy kéo dài]

Các giá trị trong một tuple có thể được trích xuất bằng chỉ mục số giống như một danh sách. Tuy nhiên, thông thường hơn là giải nén các bộ dữ

Bộ

Trông giống như một mảng hai chiều của các hàng và cột. Mỗi hàng được biểu thị bằng một tuple và có thể được truy cập như sau: >>> Danh mục đầu tư [0] ['Goog', 100, 490.10] >>> Danh mục đầu tư [1] ['MSFT', 50, 54.23] >>>

Các mục dữ liệu riêng lẻ có thể được truy cập như thế này: >>> Danh mục đầu tư [1] [1] 50 >>> Danh mục đầu tư [1] [2] 54.23 >>>

Ở đây, một cách dễ dàng để lặp qua tất cả các hồ sơ và mở rộng các trường thành một tập hợp các biến: tổng số = 0,0 cho tên, cổ phiếu, giá trong danh mục đầu tư: Total += cổ phiếu * Giá cả

Đặt một tập hợp được sử dụng để chứa một bộ sưu tập các đối tượng không được đặt hàng. Để tạo một tập hợp, sử dụng hàm set [] và cung cấp một chuỗi các mục như sau: s = set [[3,5,9,10]] t = t = Đặt ["Xin chào"]

# Tạo một bộ số # Tạo một tập hợp các ký tự độc đáo

Không giống như danh sách và bộ dữ liệu, các bộ không được đặt hàng và không thể được lập chỉ mục bởi các số. Hơn nữa, các yếu tố của một bộ không bao giờ được nhân đôi. Ví dụ: nếu bạn kiểm tra giá trị của t từ mã trước, bạn sẽ nhận được như sau: >>> t set [['H', 'e', 'l', 'o']]]

Lưu ý rằng chỉ có một 'L' xuất hiện. Bộ hỗ trợ một bộ sưu tập các hoạt động tiêu chuẩn, bao gồm liên minh, giao lộ, sự khác biệt và sự khác biệt đối xứng. Đây là một ví dụ: A B C D

H lib

Chương 1

Giới thiệu hướng dẫn

Để truy cập các thành viên của từ điển, hãy sử dụng toán tử chỉ số khóa như sau: name = stock ["name"] value = stock ["cổ phiếu"] * chia sẻ ["Giá"]

Chèn hoặc sửa đổi các đối tượng hoạt động như thế này: Stock ["Cổ phiếu"] = 75 cổ phiếu ["Ngày"] = "Ngày 7 tháng 6 năm 2007"

Mặc dù các chuỗi là loại khóa phổ biến nhất, bạn có thể sử dụng nhiều đối tượng Python khác, bao gồm cả số và bộ dữ liệu. Một số đối tượng, bao gồm danh sách và từ điển, không thể được sử dụng làm khóa vì nội dung của chúng có thể thay đổi. Từ điển là một cách hữu ích để xác định một đối tượng bao gồm các trường được đặt tên như được hiển thị trước đó. Tuy nhiên, từ điển cũng được sử dụng như một thùng chứa để thực hiện tra cứu nhanh trên dữ liệu chưa được đặt hàng. Ví dụ: ở đây, một từ điển giá cổ phiếu: Giá = {"GOOG" "AAPL" "IBM" "MSFT"}

:::

490.10, 123,50, 91,50, 52.13

Một từ điển trống được tạo theo một trong hai cách: giá = {} # một giá trị trống rỗng = dict [] # một dict trống rỗng

Tư cách thành viên từ điển được kiểm tra với toán tử trong, như trong ví dụ sau: Nếu "SCOX" về giá: p = giá ["SCOX"] khác: p = 0,0

Chuỗi các bước cụ thể này cũng có thể được thực hiện nhỏ gọn hơn như sau: p = price.get ["scox", 0,0]

Để có được danh sách các khóa từ điển, hãy chuyển đổi từ điển thành danh sách: syms = danh sách [giá]

# syms = ["aapl", "msft", "ibm", "goog"]]

Sử dụng câu lệnh DEL để xóa một phần tử của từ điển: giá DEL ["MSFT"]

Từ điển có lẽ là loại dữ liệu được điều chỉnh tốt nhất trong trình thông dịch Python. Vì vậy, nếu bạn chỉ đang cố gắng lưu trữ và làm việc với dữ liệu trong chương trình của mình, bạn hầu như luôn luôn sử dụng từ điển hơn là cố gắng tự mình đưa ra một số loại cấu trúc dữ liệu tùy chỉnh.

H lib

Lặp lại và vòng lặp

Lặp lại và lặp lại cấu trúc vòng lặp được sử dụng rộng rãi nhất là cho câu lệnh, được sử dụng để lặp lại một bộ sưu tập các mục. Lặp lại là một trong những tính năng phong phú nhất của Python. Tuy nhiên, hình thức lặp lại phổ biến nhất là chỉ cần lặp qua tất cả các thành viên của một chuỗi như chuỗi, danh sách hoặc tuple. Ở đây, một ví dụ: Đối với N trong [1,2,3,4,5,6,7,8,8]: In "2 đến %D Power là %d" %[n, 2 ** n]

Trong ví dụ này, biến N sẽ được chỉ định các mục liên tiếp từ danh sách [1,2,3,4,, 9] trên mỗi lần lặp. Bởi vì việc lặp qua các phạm vi số nguyên là khá phổ biến, các phím tắt sau đây thường được sử dụng cho mục đích đó: với n trong phạm vi [1,10]: in "2 đến %d công suất là %d" %[n, 2 ** n ]

Hàm Phạm vi [I, J [, Stride]] tạo ra một đối tượng đại diện cho một phạm vi số nguyên có giá trị I đến J-1. Nếu giá trị bắt đầu bị bỏ qua, nó sẽ được coi là bằng không. Một sải chân tùy chọn cũng có thể được đưa ra như một đối số thứ ba. Đây là một ví dụ: A B C D

= = = =

Phạm vi [5] Phạm vi [1,8] Phạm vi [0,14,3] Phạm vi [8,1, -1]

# # # #

A B C D

= = = =

Phạm vi [5] Phạm vi [1,8] Phạm vi [0,14,3] Phạm vi [8,1, -1]

# # # #

A B C D

0,1,2,3,4 1,2,3,4,5,6,7 0,3,6,9,12 8,7,6,5,4,3,2

H lib

Lặp lại và vòng lặp

= = = =

# // đang cắt ngắn sự phân chia.

Để gọi một hàm, chỉ cần sử dụng tên của hàm theo sau là các đối số của nó được đặt trong ngoặc đơn, chẳng hạn như kết quả = phần còn lại [37,15]. Bạn có thể sử dụng một tuple để trả về nhiều giá trị từ một hàm, như được hiển thị ở đây: def Divide [a, b]: q = a // b r = a - q*b return [q, r]

# Nếu A và B là số nguyên, q là số nguyên

Khi trả lại nhiều giá trị trong một tuple, bạn có thể dễ dàng giải quyết kết quả thành các biến riêng biệt như thế này: thương số, phần còn lại = chia [1456,33]

Để gán giá trị mặc định cho tham số hàm, sử dụng gán: def Connect [tên máy chủ, cổng, thời gian chờ = 300]: # cơ thể chức năng

Khi các giá trị mặc định được đưa ra trong một định nghĩa hàm, chúng có thể được bỏ qua từ các cuộc gọi hàm tiếp theo. Khi bị bỏ qua, đối số sẽ chỉ đơn giản là có giá trị mặc định. Ở đây, một ví dụ: Kết nối ['www.python.org', 80]

Bạn cũng có thể gọi các chức năng bằng cách sử dụng các đối số từ khóa và cung cấp các đối số theo thứ tự tùy ý. Tuy nhiên, điều này đòi hỏi bạn phải biết tên của các đối số trong định nghĩa hàm. Ở đây, một ví dụ: Kết nối [cổng = 80, tên máy chủ = "www.python.org"]

Khi các biến được tạo hoặc gán bên trong một hàm, phạm vi của chúng là cục bộ. Đó là, biến chỉ được xác định bên trong phần thân của hàm và bị phá hủy khi hàm trả về. Để sửa đổi giá trị của biến toàn cầu từ bên trong hàm, Sử dụng câu lệnh toàn cầu như sau: Count = 0 ... def foo []: Số đếm toàn cầu += 1

# Thay đổi số lượng biến toàn cầu

H lib

Máy phát điện

Trình tạo thay vì trả về một giá trị duy nhất, một hàm có thể tạo ra toàn bộ chuỗi kết quả nếu nó sử dụng câu lệnh năng suất. Ví dụ: Def Countdown [n]: In "Đếm xuống!" Trong khi n> 0: năng suất n # tạo ra một giá trị [n] n -= 1

Bất kỳ chức năng nào sử dụng năng suất đều được gọi là máy phát. Gọi hàm Trình tạo tạo một đối tượng tạo chuỗi kết quả thông qua các cuộc gọi liên tiếp đến phương thức tiếp theo [] [hoặc _ _Next_ _ [] trong Python 3]. Ví dụ: >>> c = đếm ngược [5] >>> c.next [] đếm ngược! 5 >>> c.next [] 4 >>> c.next [] 3 >>>

Cuộc gọi tiếp theo [] làm cho một hàm máy phát chạy cho đến khi nó đạt đến câu lệnh NETENT SENID. Tại thời điểm này, giá trị được truyền cho năng suất được trả về bởi tiếp theo [] và hàm đình chỉ thực thi. Hàm tiếp tục thực thi trên câu lệnh sau khi sản lượng khi tiếp theo [] được gọi lại. Quá trình này tiếp tục cho đến khi hàm trở lại. Thông thường bạn sẽ không gọi thủ công tiếp theo [] như được hiển thị. Thay vào đó, bạn kết nối nó lên một vòng lặp như thế này: >>> Đối với tôi trong đếm ngược [5]: ... in tôi, đếm ngược! 5 4 3 2 1 >>>

Máy phát điện là một cách cực kỳ mạnh mẽ để viết các chương trình dựa trên các đường ống xử lý, luồng hoặc luồng dữ liệu. Ví dụ: hàm máy phát sau bắt chước hành vi của lệnh unix đuôi -f thường được sử dụng để theo dõi các tệp nhật ký: # đuôi một tệp [như đuôi -f] nhập thời gian def đuôi [f]: f.seek [0,2 ] # Di chuyển đến EOF trong khi đúng: line = f.Readline [] # Hãy thử đọc một dòng văn bản mới nếu không dòng: # Nếu không có gì, ngủ ngắn gọn và thử lại thời gian

Ở đây, một trình tạo tìm kiếm một chuỗi con cụ thể trong một chuỗi các dòng: def grep [dòng, searchText]: Đối với dòng trong dòng: Nếu searchtext trong dòng: dòng năng suất

H lib

Máy phát điện

Một coroutine bị đình chỉ cho đến khi một giá trị được gửi đến nó bằng cách sử dụng Send []. Khi điều này xảy ra, giá trị đó được trả về bởi biểu thức [năng suất] bên trong coroutine và được xử lý bởi các câu lệnh theo sau. Việc xử lý tiếp tục cho đến khi biểu thức tiếp theo [năng suất] gặp phải tại điểm chỉ định chức năng. Điều này tiếp tục cho đến khi hàm coroutine trở lại hoặc đóng [] được gọi trên nó như trong ví dụ trước. Coroutines rất hữu ích khi viết các chương trình đồng thời dựa trên các vấn đề sản xuất trong đó một phần của chương trình đang tạo ra dữ liệu được tiêu thụ bởi một phần khác của chương trình. Trong mô hình này, một coroutine đại diện cho người tiêu dùng dữ liệu. Dưới đây là một ví dụ về việc sử dụng các trình tạo và coroutines cùng nhau: # một bộ các trình chỉnh sửa coroutines của Matcher = [print_matches ["python"], print_matches ["guido"], print_matches ["jython"]]

H lib

Đối tượng và các lớp

# Chuẩn bị tất cả các trình chỉnh sửa bằng cách gọi Next [] cho m trong Matchers: m.next [] # Feed một tệp nhật ký hoạt động vào tất cả các trình kết hợp. Lưu ý cho việc này hoạt động, # một máy chủ web phải được tích cực ghi dữ liệu vào nhật ký. wwwlog = đuôi [mở ["access-log"]]] cho dòng trong wwwlog: for m in matchers: m.send [dòng] # Gửi dữ liệu vào mỗi coroutine của người khớp

Thông tin chi tiết về coroutines có thể được tìm thấy trong Chương 6.

Đối tượng và các lớp Tất cả các giá trị được sử dụng trong một chương trình là các đối tượng. Một đối tượng bao gồm dữ liệu nội bộ và các phương thức thực hiện các loại hoạt động khác nhau liên quan đến dữ liệu đó. Bạn đã sử dụng các đối tượng và phương thức khi làm việc với các loại tích hợp như chuỗi và danh sách. Ví dụ: các mục = [37, 42] các mục.append [73]

# Tạo đối tượng Danh sách # Gọi phương thức append []

Hàm Dir [] liệt kê các phương thức có sẵn trên một đối tượng và là một công cụ hữu ích để thử nghiệm tương tác. Ví dụ: >>> Các mục = [37, 42] >>> DIR [Mục] ['_ _ADD_ _', '_ _CLASS_ _', ' , ... 'Phụ lục', 'đếm', 'mở rộng', 'index', 'chèn', 'pop', 'xóa', 'đảo ngược', 'sort']

Khi kiểm tra các đối tượng, bạn sẽ thấy các phương thức quen thuộc như append [] và chèn [] được liệt kê. Tuy nhiên, bạn cũng sẽ thấy các phương pháp đặc biệt luôn bắt đầu và kết thúc bằng một dấu gạch dưới kép. Các phương pháp này thực hiện các hoạt động ngôn ngữ khác nhau. Ví dụ: phương thức _ _add_ _ [] thực hiện toán tử +: >>> items._ _add_ _ [[73,101]] [37, 42, 73, 101] >>>>

Tuyên bố lớp được sử dụng để xác định các loại đối tượng mới và cho lập trình hướng đối tượng. Ví dụ: lớp sau xác định một ngăn xếp đơn giản với các thao tác PUSP [], POP [] và LEGN [] đối tượng]: self.stack.append [object] def pop [self]: return self.stack.pop [] def length [self]: return len [self.stack]

# Khởi tạo ngăn xếp

Trong dòng đầu tiên của định nghĩa lớp, ngăn xếp lớp câu lệnh [đối tượng] tuyên bố ngăn xếp là một đối tượng. Việc sử dụng dấu ngoặc đơn là cách Python chỉ định kế thừa trong trường hợp này, xếp chồng kế thừa từ đối tượng, là gốc của tất cả các loại Python . Bên trong định nghĩa lớp, các phương thức được xác định bằng cách sử dụng câu lệnh DEF. Đối số đầu tiên trong mỗi đối số

H lib

Đối tượng và các lớp

Thông tin chi tiết về coroutines có thể được tìm thấy trong Chương 6.

# Tạo đối tượng Danh sách # Gọi phương thức append []

In this case, @staticmethod declares the method that follows to be a static method. @staticmethod is an example of using an a decorator, a topic that is discussed further in Chapter 6.

Exceptions If an error occurs in your program, an exception is raised and a traceback message such as the following appears: Traceback [most recent call last]: File "foo.py", line 12, in IOError: [Errno 2] No such file or directory: 'file.txt'

The traceback message indicates the type of error that occurred, along with its location. Normally, errors cause a program to terminate. However, you can catch and handle exceptions using try and except statements, like this: try: f = open["file.txt","r"] except IOError as e: print e

h Lib

Modules

If an IOError occurs, details concerning the cause of the error are placed in e and control passes to the code in the except block. If some other kind of exception is raised, it’s passed to the enclosing code block [if any]. If no errors occur, the code in the except block is ignored.When an exception is handled, program execution resumes with the statement that immediately follows the last except block.The program does not return to the location where the exception occurred. The raise statement is used to signal an exception.When raising an exception, you can use one of the built-in exceptions, like this: raise RuntimeError["Computer says no"]

Or you can create your own exceptions, as described in the section “Defining New Exceptions” in Chapter 5, “ Program Structure and Control Flow.” Proper management of system resources such as locks, files, and network connections is often a tricky problem when combined with exception handling.To simplify such programming, you can use the with statement with certain kinds of objects. Here is an example of writing code that uses a mutex lock: import threading message_lock = threading.Lock[] ... with message_lock: messages.add[newmessage]

In this example, the message_lock object is automatically acquired when the with statement executes.When execution leaves the context of the with block, the lock is automatically released.This management takes place regardless of what happens inside the with block. For example, if an exception occurs, the lock is released when control leaves the context of the block. The with statement is normally only compatible with objects related to system resources or the execution environment such as files, connections, and locks. However, user-defined objects can define their own custom processing.This is covered in more detail in the “Context Management Protocol” section of Chapter 3, “Types and Objects.”

Modules As your programs grow in size, you will want to break them into multiple files for easier maintenance.To do this, Python allows you to put definitions in a file and use them as a module that can be imported into other programs and scripts.To create a module, put the relevant statements and definitions into a file that has the same name as the module. [Note that the file must have a .py suffix.] Here’s an example: # file : div.py def divide[a,b]: q = a/b r = a - q*b return [q,r]

# If a and b are integers, q is an integer

To use your module in other programs, you can use the import statement: import div a, b = div.divide[2305, 29]

h Lib

Chapter 1

A Tutorial Introduction

The import statement creates a new namespace and executes all the statements in the associated .py file within that namespace.To access the contents of the namespace after import, simply use the name of the module as a prefix, as in div.divide[] in the preceding example. If you want to import a module using a different name, supply the import statement with an optional as qualifier, as follows: import div as foo a,b = foo.divide[2305,29]

To import specific definitions into the current namespace, use the from statement: from div import divide a,b = divide[2305,29]

# No longer need the div prefix

To load all of a module’s contents into the current namespace, you can also use the following: from div import *

As with objects, the dir[] function lists the contents of a module and is a useful tool for interactive experimentation: >>> import string >>> dir[string] ['_ _builtins_ _', '_ _doc_ _', '_ _file_ _', '_ _name_ _', '_idmap', '_idmapL', '_lower', '_swapcase', '_upper', 'atof', 'atof_error', 'atoi', 'atoi_error', 'atol', 'atol_error', 'capitalize', 'capwords', 'center', 'count', 'digits', 'expandtabs', 'find', ... >>>

Getting Help When working with Python, you have several sources of quickly available information. First, when Python is running in interactive mode, you can use the help[] command to get information about built-in modules and other aspects of Python. Simply type help[] by itself for general information or help['modulename'] for information about a specific module.The help[] command can also be used to return information about specific functions if you supply a function name. Most Python functions have documentation strings that describe their usage.To print the doc string, simply print the _ _doc_ _ attribute. Here’s an example: >>> print issubclass._ _doc_ _ issubclass[C, B] -> bool Return whether class C is a subclass [i.e., a derived class] of class B. When using a tuple as the second argument issubclass[X, [A, B, ...]], is a shortcut for issubclass[X, A] or issubclass[X, B] or ... [etc.]. >>>

Cuối cùng, nhưng không kém phần quan trọng, hầu hết các cài đặt Python cũng bao gồm PYDOC lệnh, có thể được sử dụng để trả về tài liệu về các mô -đun Python. Đơn giản chỉ cần gõ chủ đề PYDOC tại dấu nhắc lệnh hệ thống.

H lib

2 quy ước từ vựng và cú pháp t

Chương của ông mô tả các quy ước cú pháp và từ vựng của một chương trình Python. Các chủ đề bao gồm cấu trúc dòng, nhóm các câu lệnh, từ dành riêng, nghĩa đen, toán tử, mã thông báo và mã hóa mã nguồn.

Cấu trúc dòng và thụt lề Mỗi câu lệnh trong một chương trình được chấm dứt với một dòng mới. Các câu lệnh dài có thể trải dài nhiều dòng bằng cách sử dụng ký tự liên tục dòng [\], như được hiển thị trong ví dụ sau: a = math.cos [3 * [x - n]] + \ math.sin [3 * [y - n ]]

Bạn không cần ký tự tiếp tục dòng khi định nghĩa của chuỗi ba chuỗi, danh sách, tuple hoặc từ điển được trích xuất ba dòng. Tổng quát hơn, bất kỳ phần nào của chương trình được đặt trong ngoặc đơn [...], dấu ngoặc [...], niềng ni Sự khởi đầu và kết thúc của một định nghĩa. Thắng được sử dụng để biểu thị các khối mã khác nhau, chẳng hạn như các cơ thể của các hàm, điều kiện, vòng lặp và các lớp. Số lượng thụt được sử dụng cho câu lệnh đầu tiên của một khối là tùy ý, nhưng sự thụt của toàn bộ khối phải nhất quán. Đây

# Thắng nhất quán

# Thụt không nhất quán [lỗi]

Nếu phần thân của một hàm, điều kiện, vòng lặp hoặc lớp ngắn và chỉ chứa một câu lệnh, nó có thể được đặt trên cùng một dòng, như thế này: nếu A: khác:

Tuyên bố1 tuyên bố2

Để biểu thị một thân hoặc khối trống, hãy sử dụng câu lệnh PASS. Đây là một ví dụ: Nếu A: Truyền khác: Báo cáo

H lib

2 quy ước từ vựng và cú pháp t

# Thắng nhất quán

# Thụt không nhất quán [lỗi]

Tuyên bố1 tuyên bố2

Để biểu thị một thân hoặc khối trống, hãy sử dụng câu lệnh PASS. Đây là một ví dụ: Nếu A: Truyền khác: Báo cáo

H lib

2 quy ước từ vựng và cú pháp t

The identifiers True and False are interpreted as Boolean values with the integer values of 1 and 0, respectively. A number such as 1234 is interpreted as a decimal integer. To specify an integer using octal, hexadecimal, or binary notation, precede the value with 0, 0x, or 0b, respectively [for example, 0644, 0x100fea8, or 0b11101010]. Integers in Python can have an arbitrary number of digits, so if you want to specify a really large integer, just write out all of the digits, as in 12345678901234567890. However, when inspecting values and looking at old Python code, you might see large numbers written with a trailing l [lowercase L] or L character, as in 12345678901234567890L.This trailing L is related to the fact that Python internally represents integers as either a fixed-precision machine integer or an arbitrary precision long integer type depending on the magnitude of the value. In older versions of Python, you could explicitly choose to use either type and would add the trailing L to explicitly indicate the long type.Today, this distinction is unnecessary and is actively discouraged. So, if you want a large integer value, just write it without the L. Numbers such as 123.34 and 1.2334e+02 are interpreted as floating-point numbers. An integer or floating-point number with a trailing j or J, such as 12.34J, is an imaginary number.You can create complex numbers with real and imaginary parts by adding a real number and an imaginary number, as in 1.2 + 12.34J.

String Literals String literals are used to specify a sequence of characters and are defined by enclosing text in single ['], double ["], or triple [''' or """] quotes.There is no semantic difference between quoting styles other than the requirement that you use the same type of quote to start and terminate a string. Single- and double-quoted strings must be defined on a single line, whereas triple-quoted strings can span multiple lines and include all of the enclosed formatting [that is, newlines, tabs, spaces, and so on]. Adjacent strings [separated by white space, newline, or a line-continuation character] such as "hello" 'world' are concatenated to form a single string "helloworld". Within string literals, the backslash [\] character is used to escape special characters such as newlines, the backslash itself, quotes, and nonprinting characters.Table 2.1 shows the accepted escape codes. Unrecognized escape sequences are left in the string unmodified and include the leading backslash. Table 2.1

Standard Character Escape Codes

Character

Description

Newline continuation Backslash Single quote Double quote Bell Backspace Escape Null

\\ \' \" \a \b \e \0

h Lib

Chapter 2 Lexical Conventions and Syntax

Table 2.1

Continued

Character

Description

\n \v \t

Line feed Vertical tab Horizontal tab Carriage return Form feed Octal value [\000 to \377] Unicode character [\u0000 to \uffff] Unicode character [\U00000000 to \Uffffffff] Unicode character name Hexadecimal value [\x00 to \xff]

\r \f \OOO \uxxxx \Uxxxxxxxx \N{charname} \xhh

The escape codes \OOO and \x are used to embed characters into a string literal that can’t be easily typed [that is, control codes, nonprinting characters, symbols, international characters, and so on]. For these escape codes, you have to specify an integer value corresponding to a character value. For example, if you wanted to write a string literal for the word “Jalapeño”, you might write it as "Jalape\xf1o" where \xf1 is the character code for ñ. In Python 2 string literals correspond to 8-bit character or byte-oriented data. A serious limitation of these strings is that they do not fully support international character sets and Unicode.To address this limitation, Python 2 uses a separate string type for Unicode data.To write a Unicode string literal, you prefix the first quote with the letter “u”. For example: s = u"Jalape\u00f1o"

In Python 3, this prefix character is unnecessary [and is actually a syntax error] as all strings are already Unicode. Python 2 will emulate this behavior if you run the interpreter with the -U option [in which case all string literals will be treated as Unicode and the u prefix can be omitted]. Regardless of which Python version you are using, the escape codes of \u, \U, and \N in Table 2.1 are used to insert arbitrary characters into a Unicode literal. Every Unicode character has an assigned code point, which is typically denoted in Unicode charts as U+XXXX where XXXX is a sequence of four or more hexadecimal digits. [Note that this notation is not Python syntax but is often used by authors when describing Unicode characters.] For example, the character ñ has a code point of U+00F1.The \u escape code is used to insert Unicode characters with code points in the range U+0000 to U+FFFF [for example, \u00f1].The \U escape code is used to insert characters in the range U+10000 and above [for example, \U00012345]. One subtle caution concerning the \U escape code is that Unicode characters with code points above U+10000 usually get decomposed into a pair of characters known as a surrogate pair.This has to do with the internal representation of Unicode strings and is covered in more detail in Chapter 3, “Types and Objects.” Unicode characters also have a descriptive name. If you know the name, you can use the \N{character name} escape sequence. For example: s = u"Jalape\N{LATIN SMALL LETTER N WITH TILDE}o"

h Lib

Containers

For an authoritative reference on code points and character names, consult //www.unicode.org/charts. Optionally, you can precede a string literal with an r or R, such as in r'\d'.These strings are known as raw strings because all their backslash characters are left intact—that is, the string literally contains the enclosed text, including the backslashes.The main use of raw strings is to specify literals where the backslash character has some significance. Examples might include the specification of regular expression patterns with the re module or specifying a filename on a Windows machine [for example, r'c:\newdata\tests']. Raw strings cannot end in a single backslash, such as r"\".Within raw strings, \uXXXX escape sequences are still interpreted as Unicode characters, provided that the number of preceding \ characters is odd. For instance, ur"\u1234" defines a raw Unicode string with the single character U+1234, whereas ur"\\u1234" defines a seven-character string in which the first two characters are slashes and the remaining five characters are the literal "u1234". Also, in Python 2.2, the r must appear after the u in raw Unicode strings as shown. In Python 3.0, the u prefix is unnecessary. String literals should not be defined using a sequence of raw bytes that correspond to a data encoding such as UTF-8 or UTF-16. For example, directly writing a raw UTF-8 encoded string such as 'Jalape\xc3\xb1o' simply produces a nine-character string U+004A, U+0061, U+006C, U+0061, U+0070, U+0065, U+00C3, U+00B1, U+006F, which is probably not what you intended.This is because in UTF-8, the multibyte sequence \xc3\xb1 is supposed to represent the single character U+00F1, not the two characters U+00C3 and U+00B1.To specify an encoded byte string as a literal, prefix the first quote with a "b" as in b"Jalape\xc3\xb1o".When defined, this literally creates a string of single bytes. From this representation, it is possible to create a normal string by decoding the value of the byte literal with its decode[] method. More details about this are covered in Chapter 3 and Chapter 4, “Operators and Expressions.” The use of byte literals is quite rare in most programs because this syntax did not appear until Python 2.6, and in that version there is no difference between a byte literal and a normal string. In Python 3, however, byte literals are mapped to a new bytes datatype that behaves differently than a normal string [see Appendix A, “Python 3”].

Containers Values enclosed in square brackets [...], parentheses [...], and braces {...} denote a collection of objects contained in a list, tuple, and dictionary, respectively, as in the following example: a = [ 1, 3.4, 'hello' ] b = [ 10, 20, 30 ] c = { 'a': 3, 'b': 42 }

# A list # A tuple # A dictionary

List, tuple, and dictionary literals can span multiple lines without using the linecontinuation character [\]. In addition, a trailing comma is allowed on the last item. For example: a = [ 1, 3.4, 'hello', ]

h Lib

Chapter 2 Lexical Conventions and Syntax

Operators, Delimiters, and Special Symbols The following operators are recognized: + ^ -=

* < /=

** > //=

/ = **=

% == &=

& += >>=

| >> factorial[6] 120 >>> """ if n >> help[factorial] Help on function call in module _ _main_ _: call[*args, **kwargs] [END] >>>

h Lib

114

Chapter 6 Functions and Functional Programming

To fix this, write decorator functions so that they propagate the function name and documentation string. For example: def wrap[func]: call[*args,**kwargs]: return func[*args,**kwargs] call._ _doc_ _ = func._ _doc_ _ call._ _name_ _ = func._ _name_ _ return call

Because this is a common problem, the functools module provides a function wraps that can automatically copy these attributes. Not surprisingly, it is also a decorator: from functools import wraps def wrap[func]: @wraps[func] call[*args,**kwargs]: return func[*args,**kwargs] return call

The @wraps[func] decorator, defined in functools, propagates attributes from func to the wrapper function that is being defined.

Function Attributes Functions can have arbitrary attributes attached to them. Here’s an example: def foo[]: statements foo.secure = 1 foo.private = 1

Function attributes are stored in a dictionary that is available as the __dict__ attribute of a function. The primary use of function attributes is in highly specialized applications such as parser generators and application frameworks that would like to attach additional information to function objects. As with documentation strings, care should be given if mixing function attributes with decorators. If a function is wrapped by a decorator, access to the attributes will actually take place on the decorator function, not the original implementation.This may or may not be what you want depending on the application.To propagate already defined function attributes to a decorator function, use the following template or the functools.wraps[] decorator as shown in the previous section: def wrap[func]: call[*args,**kwargs]: return func[*args,**kwargs] call._ _doc_ _ = func._ _doc_ _ call._ _name_ _ = func._ _name_ _ call._ _dict_ _.update[func._ _dict_ _] return call

h Lib

eval[], exec[], and compile[]

eval[], exec[],

115

and compile[]

The eval[str [,globals [,locals]]] function executes an expression string and returns the result. Here’s an example: a = eval['3*math.sin[3.5+x] + 7.2']

Similarly, the exec[str [, globals [, locals]]] function executes a string containing arbitrary Python code.The code supplied to exec[] is executed as if the code actually appeared in place of the exec operation. Here’s an example: a = [3, 5, 10, 13] exec["for i in a: print[i]"]

One caution with exec is that in Python 2, exec is actually defined as a statement. Thus, in legacy code, you might see statements invoking exec without the surrounding parentheses, such as exec "for i in a: print i". Although this still works in Python 2.6, it breaks in Python 3. Modern programs should use exec[] as a function. Both of these functions execute within the namespace of the caller [which is used to resolve any symbols that appear within a string or file]. Optionally, eval[] and exec[] can accept one or two mapping objects that serve as the global and local namespaces for the code to be executed, respectively. Here’s an example: globals = {'x': 7, 'y': 10, 'birds': ['Parrot', 'Swallow', 'Albatross'] } locals = { } # Execute using the above dictionaries as the global and local namespace a = eval["3 * x + 4 * y", globals, locals] exec["for b in birds: print[b]", globals, locals]

If you omit one or both namespaces, the current values of the global and local namespaces are used. Also, due to issues related to nested scopes, the use of exec[] inside of a function body may result in a SyntaxError exception if that function also contains nested function definitions or uses the lambda operator. When a string is passed to exec[] or eval[] the parser first compiles it into bytecode. Because this process is expensive, it may be better to precompile the code and reuse the bytecode on subsequent calls if the code will be executed multiple times. The compile[str,filename,kind] function compiles a string into bytecode in which str is a string containing the code to be compiled and filename is the file in which the string is defined [for use in traceback generation].The kind argument specifies the type of code being compiled—'single' for a single statement, 'exec' for a set of statements, or 'eval' for an expression.The code object returned by the compile[] function can also be passed to the eval[] function and exec[] statement. Here’s an example: s = "for i in range[0,10]: print[i]" c = compile[s,'','exec'] # Compile into a code object exec[c] # Execute it s2 = "3 * x + 4 * y" c2 = compile[s2, '', 'eval'] result = eval[c2]

# Compile into an expression # Execute it

h Lib

This page intentionally left blank

h Lib

7 Classes and Object-Oriented Programming C

lasses are the mechanism used to create new kinds of objects.This chapter covers the details of classes, but is not intended to be an in-depth reference on object-oriented programming and design. It’s assumed that the reader has some prior experience with data structures and object-oriented programming in other languages such as C or Java. [Chapter 3, “Types and Objects,” contains additional information about the terminology and internal implementation of objects.]

The class Statement A class defines a set of attributes that are associated with, and shared by, a collection of objects known as instances. A class is most commonly a collection of functions [known as methods], variables [which are known as class variables], and computed attributes [which are known as properties]. A class is defined using the class statement.The body of a class contains a series of statements that execute during class definition. Here’s an example: class Account[object]: num_accounts = 0 def _ _init_ _[self,name,balance]: self.name = name self.balance = balance Account.num_accounts += 1 def _ _del_ _[self]: Account.num_accounts -= 1 def deposit[self,amt]: self.balance = self.balance + amt def withdraw[self,amt]: self.balance = self.balance - amt def inquiry[self]: return self.balance

The values created during the execution of the class body are placed into a class object that serves as a namespace much like a module. For example, the members of the Account class are accessed as follows: Account.num_accounts Account._ _init_ _ Account._ _del_ _ Account.deposit Account.withdraw Account.inquiry

h Lib

118

Chapter 7 Classes and Object-Oriented Programming

It’s important to note that a class statement by itself doesn’t create any instances of the class [for example, no accounts are actually created in the preceding example]. Rather, a class merely sets up the attributes that will be common to all the instances that will be created later. In this sense, you might think of it as a blueprint. The functions defined inside a class are known as instance methods. An instance method is a function that operates on an instance of the class, which is passed as the first argument. By convention, this argument is called self, although any legal identifier name can be used. In the preceding example, deposit[], withdraw[], and inquiry[] are examples of instance methods. Class variables such as num_accounts are values that are shared among all instances of a class [that is, they’re not individually assigned to each instance]. In this case, it’s a variable that’s keeping track of how many Account instances are in existence.

Các phiên bản lớp của một lớp được tạo bằng cách gọi một đối tượng lớp là hàm. Điều này tạo ra một thể hiện mới sau đó được chuyển sang phương thức _ _init_ _ [] của lớp. Các đối số đến _ _init_ _ [] bao gồm đã tạo trường hợp tự cùng với các đối số được cung cấp khi gọi đối tượng lớp. Ví dụ: # Tạo một vài tài khoản a = tài khoản ["guido", 1000.00] b = tài khoản ["Bill", 10,00]

# Gọi tài khoản._ _init_ _ [a, "guido", 1000.00]

Bên trong _ _init_ _ [], các thuộc tính được lưu trong trường hợp bằng cách gán cho bản thân. Ví dụ: self.name = name đang lưu thuộc tính tên trong trường hợp. Khi phiên bản mới được tạo đã được trả lại cho người dùng, các thuộc tính này cũng như các thuộc tính của lớp được truy cập bằng toán tử DOT [.]

# CALK ACCORS.DEPOSIT [A, 100.00] # CALK

Toán tử DOT [.] Chịu trách nhiệm liên kết thuộc tính. Khi bạn truy cập một thuộc tính, giá trị kết quả có thể đến từ một số nơi khác nhau. Ví dụ: A.Name trong ví dụ trước trả về thuộc tính tên của thể hiện a. Tuy nhiên, a.deposit trả về thuộc tính tiền gửi [một phương thức] của lớp tài khoản. Khi bạn truy cập một thuộc tính, trường hợp được kiểm tra trước và nếu không có gì được biết mà một lớp chia sẻ các thuộc tính của nó với tất cả các trường hợp của nó.

Các quy tắc phạm vi Mặc dù các lớp xác định không gian tên, các lớp không tạo phạm vi cho các tên được sử dụng bên trong các cơ thể của các phương thức. Do đó, khi bạn thực hiện một lớp, các tham chiếu đến các thuộc tính và phương thức phải có đủ điều kiện. Ví dụ, trong các phương thức, bạn luôn tham khảo các thuộc tính của trường hợp thông qua bản thân. Do đó, trong ví dụ bạn sử dụng bản thân. Điều này cũng áp dụng nếu bạn muốn gọi một phương thức từ một phương thức khác, như được hiển thị trong ví dụ sau:

H lib

Di sản

119

lớp foo [đối tượng]: def Bar [self]: in ["thanh!"] def spam [self]: bar [self] # không chính xác! 'Bar' tạo ra một nameerror self.bar [] # cái này hoạt động foo.bar [self] # Điều này cũng hoạt động

Việc thiếu phạm vi trong các lớp là một khu vực mà Python khác với C ++ hoặc Java. Nếu bạn đã sử dụng các ngôn ngữ đó, tham số tự trong Python giống như con trỏ này. Việc sử dụng bản thân rõ ràng là do Python không cung cấp phương tiện để khai báo rõ ràng y trong c]. Nếu không có điều này, không có cách nào để biết liệu một nhiệm vụ cho một biến trong một phương thức được cho là một biến cục bộ hay nếu nó được cho là được lưu dưới dạng thuộc tính thể hiện. Việc sử dụng rõ ràng bản thân sửa lỗi này, tất cả các giá trị được lưu trữ trên bản thân là một phần của trường hợp và tất cả các bài tập khác chỉ là các biến cục bộ.

Kế thừa kế thừa là một cơ chế để tạo ra một lớp mới chuyên hoặc sửa đổi hành vi của một lớp hiện có. Lớp gốc được gọi là lớp cơ sở hoặc một lớp siêu. Thông qua kế thừa, nó đã thừa hưởng các thuộc tính được xác định bởi các lớp cơ sở của nó. Tuy nhiên, một lớp dẫn xuất có thể xác định lại bất kỳ thuộc tính nào trong số này và thêm các thuộc tính mới của riêng nó. Kế thừa được chỉ định với một danh sách được phân tách bằng dấu phẩy các tên lớp cơ sở trong tuyên bố lớp. Nếu không có lớp cơ sở logic, một lớp kế thừa từ đối tượng, như đã được hiển thị trong các ví dụ trước. Đối tượng là một lớp là gốc của tất cả các đối tượng Python và cung cấp việc triển khai mặc định của một số phương pháp phổ biến như _ _str_ _ [], tạo ra một chuỗi để sử dụng trong in. Kế thừa thường được sử dụng để xác định lại hành vi của các phương pháp hiện có. Ví dụ, đây là phiên bản chuyên dụng của tài khoản xác định lại phương thức điều tra [] để định kỳ quá mức cân bằng hiện tại với hy vọng ai đó không chú ý sẽ vượt qua tài khoản của mình và phải chịu một hình phạt lớn khi thanh toán cho thế chấp dưới chuẩn của họ: Nhập Random Class EvilAccount [tài khoản]: Def Thắc mắc [tự]: Nếu ngẫu nhiên.randint [0,4] == 1: return self.balance * 1.10 khác: return self.

# Lưu ý: Ý tưởng đang chờ cấp bằng sáng chế

C = EvilAccount ["George", 1000.00] C.Deposit [10.0]

Trong ví dụ này, các trường hợp của EvilAccount giống hệt với các trường hợp của tài khoản ngoại trừ phương thức điều tra được xác định lại []. Kế thừa được thực hiện chỉ với một sự tăng cường nhỏ của toán tử DOT [.]. Cụ thể, nếu việc tìm kiếm một thuộc tính không tìm thấy một trận đấu trong trường hợp hoặc lớp thể hiện, thì tìm kiếm sẽ chuyển sang lớp cơ sở. Quá trình này tiếp tục cho đến khi không có thêm các lớp cơ sở để tìm kiếm. Trong ví dụ trước, điều này giải thích lý do tại sao c.deposit [] gọi việc triển khai tiền gửi [] được xác định trong lớp tài khoản.

H lib

120

Chương 7 Các lớp và lập trình hướng đối tượng

Một lớp con có thể thêm các thuộc tính mới vào các phiên bản bằng cách xác định phiên bản riêng của _ _init_ _ []. Ví dụ: phiên bản này của EvilAccount thêm một thuộc tính mới EvilFactor: Class EvilAccount [tài khoản]: def _ _init_ _ [self, name, alancefactor]: account._ _init_ _ [tự, tên, cân bằng] # tự khởi tạo tài khoản. EvilFactor = EvilFactor def Thắc mắc [tự]: Nếu ngẫu nhiên.randint [0,4] == 1: return self.balance * self.evilfactor khác: return self.balance

Khi một lớp dẫn xuất định nghĩa _ _init_ _ [], các phương thức _ _init_ _ [] của các lớp cơ sở không được tự động gọi. ] Phương pháp. Trong ví dụ trước, điều này được hiển thị trong câu lệnh gọi tài khoản._ _init_ _ []. Nếu một lớp cơ sở không xác định _ _init_ _ [], bước này có thể được bỏ qua. Nếu bạn không biết liệu lớp cơ sở có định nghĩa _ _init_ _ [] hay không, thì luôn luôn an toàn khi gọi nó mà không có bất kỳ đối số nào vì luôn có một triển khai mặc định đơn giản là không làm gì. Thỉnh thoảng, một lớp dẫn xuất sẽ tái tạo phương thức nhưng cũng muốn gọi triển khai ban đầu. Để thực hiện điều này, một phương thức có thể gọi rõ ràng phương thức ban đầu trong lớp cơ sở, chuyển thể hiện bản thân là tham số đầu tiên như được hiển thị ở đây: Lớp MoreEvilArcount [ EvilAccount]: Tiền gửi def [tự, số tiền]: self.withDraw [5,00] # trừ phí "tiện lợi" EvilAccount.deposit [tự, số tiền] # Bây giờ, gửi tiền gửi

Một sự tinh tế trong ví dụ này là lớp EvilAccount không thực sự thực hiện phương thức tiền gửi []. Thay vào đó, nó được thực hiện trong lớp tài khoản. Mặc dù mã này hoạt động, có thể gây nhầm lẫn cho ai đó đọc mã [ví dụ: EvilAccount được cho là để thực hiện tiền gửi []?] Def Tiền gửi [tự, số tiền]: self.WithDraw [5,00] # Trừ phí tiện lợi

Super [CLS, ví dụ] trả về một đối tượng đặc biệt cho phép bạn thực hiện tra cứu thuộc tính trên các lớp cơ sở. Nếu bạn sử dụng điều này, Python sẽ tìm kiếm một thuộc tính bằng cách sử dụng các quy tắc tìm kiếm thông thường sẽ được sử dụng trên các lớp cơ sở. muốn gọi cho việc triển khai trước mà không quan tâm đến lớp cơ sở định nghĩa nó]. Thật không may, cú pháp của Super [] để lại nhiều điều mong muốn. Nếu bạn đang sử dụng Python 3, bạn có thể sử dụng Super []. Tiền gửi [số tiền] đơn giản hóa để thực hiện tính toán được hiển thị trong ví dụ. Tuy nhiên, trong Python 2, bạn phải sử dụng phiên bản dài dòng hơn. Python hỗ trợ nhiều kế thừa. Điều này được chỉ định bằng cách có một danh sách lớp nhiều lớp cơ sở. Ví dụ, đây là một tập hợp các lớp:

H lib

Chương 7 Các lớp và lập trình hướng đối tượng

121

Trong hầu hết các trường hợp, danh sách này dựa trên các quy tắc mà có ý nghĩa. Đó là, một lớp dẫn xuất luôn được kiểm tra trước các lớp cơ sở của nó và nếu một lớp có nhiều phụ huynh, cha mẹ luôn được kiểm tra theo cùng thứ tự như được liệt kê Trong định nghĩa lớp. Tuy nhiên, thứ tự chính xác của các lớp cơ sở thực sự khá phức tạp và không dựa trên bất kỳ loại thuật toán đơn giản nào của đơn giản, chẳng hạn như tìm kiếm chiều sâu đầu tiên hoặc đầu tiên. Thay vào đó, thứ tự được xác định theo thuật toán tuyến tính hóa C3, được mô tả trong bài báo Một tuyến tính siêu lớp đơn điệu cho Dylan, [K. Barrett, et al, được trình bày tại

H lib

122

Chương 7 Các lớp và lập trình hướng đối tượng

Oopsla hè96]. Một khía cạnh tinh tế của thuật toán này là một số phân cấp lớp nhất định sẽ bị Python từ chối với một kiểu mẫu. Ở đây, một ví dụ: Lớp X [Đối tượng]: Pass Class Y [x]: Pass Class Z [X, Y]: Pass # typeerror. # Không thể tạo ra phân giải phương thức nhất quán thứ tự_ _

Trong trường hợp này, thuật toán độ phân giải phương thức từ chối lớp Z vì nó có thể xác định một thứ tự của các lớp cơ sở có ý nghĩa. Ví dụ: lớp X xuất hiện trước lớp Y trong danh sách kế thừa, do đó phải được kiểm tra trước. Tuy nhiên, lớp Y chuyên biệt hơn vì nó kế thừa từ X.HEREfrese, nếu X được kiểm tra trước, bạn sẽ không thể giải quyết các phương pháp chuyên dụng trong Y. trong thực tế, những vấn đề này hiếm khi phát sinh và nếu chúng làm Một vấn đề thiết kế nghiêm trọng hơn với một chương trình. Theo nguyên tắc chung, nhiều kế thừa là điều tốt nhất tránh được trong hầu hết các chương trình. Tuy nhiên, đôi khi nó được sử dụng để xác định những gì được gọi là các lớp mixin. Một lớp mixin thường xác định một tập hợp các phương thức có nghĩa là được trộn lẫn trong các lớp khác để thêm chức năng bổ sung [gần giống như một macro]. xây dựng dựa trên chúng. Các lớp tiền gửi và rút tiền trong ví dụ trước đó minh họa điều này. Các lớp này thêm các phương thức mới như story_fee [] vào các lớp bao gồm chúng là một trong các lớp cơ sở. Tuy nhiên, bạn sẽ không bao giờ tự khởi tạo tiền gửi. Trên thực tế, nếu bạn đã làm, nó sẽ tạo ra một thể hiện có thể được sử dụng cho bất cứ điều gì hữu ích [nghĩa là một phương thức được xác định sẽ không thực hiện chính xác]. Chỉ là một lưu ý cuối cùng, nếu bạn muốn sửa các tham chiếu có vấn đề về phí trong ví dụ này, việc triển khai story_fee [] và reking_fee [] nên được thay đổi để tham khảo thuộc tính trực tiếp bằng tên lớp thay vì bản thân [ví dụ: Tiền gửi.fee].

Liên kết động đa hình và liên kết động gõ vịt [đôi khi cũng được gọi là đa hình khi được sử dụng trong bối cảnh kế thừa] là khả năng sử dụng một thể hiện mà không liên quan đến loại của nó. Nó được xử lý hoàn toàn thông qua quá trình tra cứu thuộc tính được mô tả để kế thừa trong phần trước. Bất cứ khi nào một thuộc tính được truy cập là obj.attr, attr được đặt bằng cách tìm kiếm trong trường hợp, định nghĩa lớp của trường hợp và sau đó là các lớp cơ sở, theo thứ tự đó . Trận đấu đầu tiên được tìm thấy được trả lại. Một khía cạnh quan trọng của quá trình ràng buộc này là nó độc lập với loại đối tượng obj là gì. Vì vậy, nếu bạn thực hiện một tra cứu như obj.name, nó sẽ hoạt động trên bất kỳ OBJ nào có thuộc tính tên. Đôi khi được gọi là gõ vịt liên quan đến câu ngạn ngữ nếu nó trông giống như, những kẻ thích, và đi bộ như một con vịt, thì đó là một con vịt. Các lập trình viên Python thường viết các chương trình dựa vào hành vi này. Ví dụ: nếu bạn muốn tạo một phiên bản tùy chỉnh của một đối tượng hiện có, bạn có thể kế thừa từ nó hoặc bạn có thể chỉ cần tạo một đối tượng hoàn toàn mới trông và hoạt động như nó nhưng không liên quan. Cách tiếp cận sau này thường được sử dụng để duy trì Một khớp nối lỏng lẻo của các thành phần chương trình. Ví dụ: mã có thể được viết để hoạt động với bất kỳ loại đối tượng nào miễn là nó có một tập hợp các phương thức nhất định. Một trong những ví dụ phổ biến nhất là với các đối tượng giống như tệp khác nhau được xác định trong thư viện tiêu chuẩn. Mặc dù các đối tượng này hoạt động như các tệp, nhưng chúng không kế thừa từ đối tượng tệp tích hợp. F

H lib

Chương 7 Các lớp và lập trình hướng đối tượng

123

To call a static method, you just prefix it by the class name.You do not pass it any additional information. For example: x = Foo.add[3,4]

# x

= 7

A common use of static methods is in writing classes where you might have many different ways to create new instances. Because there can only be one _ _init_ _[] function, alternative creation functions are often defined as shown here: class Date[object]: def _ _init_ _[self,year,month,day]: self.year = year self.month = month self.day = day @staticmethod def now[]: t = time.localtime[] return Date[t.tm_year, t.tm_mon, t.tm_day] @staticmethod def tomorrow[]: t = time.localtime[time.time[]+86400] return Date[t.tm_year, t.tm_mon, t.tm_day] # a b c

Example of creating some dates = Date[1967, 4, 9] = Date.now[] # Calls static method now[] = Date.tomorrow[] # Calls static method tomorrow[]

Class methods are methods that operate on the class itself as an object. Defined using the @classmethod decorator, a class method is different than an instance method in that the class is passed as the first argument which is named cls by convention. For example: class Times[object]: factor = 1 @classmethod def mul[cls,x]: return cls.factor*x class TwoTimes[Times]: factor = 2 x = TwoTimes.mul[4]

# Calls Times.mul[TwoTimes, 4] -> 8

h Lib

124

Chapter 7 Classes and Object-Oriented Programming

In this example, notice how the class TwoTimes is passed to mul[] as an object. Although this example is esoteric, there are practical, but subtle, uses of class methods. As an example, suppose that you defined a class that inherited from the Date class shown previously and customized it slightly: class EuroDate[Date]: # Modify string conversion to use European dates def _ _str_ _[self]: return "%02d/%02d/%4d" % [self.day, self.month, self.year]

Because the class inherits from Date, it has all of the same features. However, the now[] and tomorrow[] methods are slightly broken. For example, if someone calls EuroDate.now[], a Date object is returned instead of a EuroDate object. A class method can fix this: class Date[object]: ... @classmethod def now[cls]: t = time.localtime[] # Create an object of the appropriate type return cls[t.tm_year, t.tm_month, t.tm_day] class EuroDate[Date]: ... a = Date.now[] b = EuroDate.now[]

# Calls Date.now[Date] and returns a Date # Calls Date.now[EuroDate] and returns a EuroDate

One caution about static and class methods is that Python does not manage these methods in a separate namespace than the instance methods. As a result, they can be invoked on an instance. For example: a = Date[1967,4,9] b = d.now[]

# Calls Date.now[Date]

This is potentially quite confusing because a call to d.now[] doesn’t really have anything to do with the instance d.This behavior is one area where the Python object system differs from that found in other OO languages such as Smalltalk and Ruby. In those languages, class methods are strictly separate from instance methods.

Properties Normally, when you access an attribute of an instance or a class, the associated value that is stored is returned. A property is a special kind of attribute that computes its value when accessed. Here is a simple example: class Circle[object]: def _ _init_ _[self,radius]: self.radius = radius # Some additional properties of Circles @property def area[self]: return math.pi*self.radius**2 @property def perimeter[self]: return 2*math.pi*self.radius

h Lib

Properties

125

The resulting Circle object behaves as follows: >>> c = Circle[4.0] >>> c.radius 4.0 >>> c.area 50.26548245743669 >>> c.perimeter 25.132741228718345 >>> c.area = 2 Traceback [most recent call last]: File "", line 1, in AttributeError: can't set attribute >>>

In this example, Circle instances have an instance variable c.radius that is stored. c.area and c.perimeter are simply computed from that value.The @property decorator makes it possible for the method that follows to be accessed as a simple attribute, without the extra [] that you would normally have to add to call the method.To the user of the object, there is no obvious indication that an attribute is being computed other than the fact that an error message is generated if an attempt is made to redefine the attribute [as shown in the AttributeError exception above]. Using properties in this way is related to something known as the Uniform Access Principle. Essentially, if you’re defining a class, it is always a good idea to make the programming interface to it as uniform as possible.Without properties, certain attributes of an object would be accessed as a simple attribute such as c.radius whereas other attributes would be accessed as methods such as c.area[]. Keeping track of when to add the extra [] adds unnecessary confusion. A property can fix this. Python programmers don’t often realize that methods themselves are implicitly handled as a kind of property. Consider this class: class Foo[object]: def _ _init_ _[self,name]: self.name = name def spam[self,x]: print["%s, %s" % [self.name, x]

Khi người dùng tạo một thể hiện như f = foo ["guido"] và sau đó truy cập f.spam, spam đối tượng hàm gốc không được trả về. Thay vào đó, bạn nhận được một cái gì đó được gọi là một phương thức ràng buộc, đó là một đối tượng đại diện cho cuộc gọi phương thức sẽ thực thi khi toán tử [] được gọi trên nó. Một phương thức ràng buộc giống như một hàm được đánh giá một phần trong đó tham số tự được điền vào, nhưng các đối số bổ sung vẫn cần được cung cấp bởi bạn khi bạn gọi nó bằng cách sử dụng []. Việc tạo đối tượng phương thức ràng buộc này được xử lý âm thầm thông qua Chức năng thuộc tính thực thi phía sau hậu trường. Khi bạn xác định các phương thức tĩnh và lớp bằng cách sử dụng @staticmethod và @ClassMethod, bạn thực sự chỉ định việc sử dụng một hàm thuộc tính khác sẽ xử lý quyền truy cập vào các phương thức đó theo một cách khác. Ví dụ: @staticmethod chỉ cần trả lại chức năng phương thức trở lại như là mà không có bất kỳ gói hoặc xử lý đặc biệt nào. Các thuộc tính cũng có thể chặn các hoạt động để đặt và xóa một thuộc tính. Điều này được thực hiện bằng cách đính kèm các phương thức setter và deleter bổ sung vào một thuộc tính. Đây là một ví dụ:

H lib

126

Chương 7 Các lớp và lập trình hướng đối tượng

lớp foo [đối tượng]: def _ _init_ _ [self, name]: self._ _name = name @property def name [self]: return self. . "] n = f.name f.name =" monty "f.name = 45 del f.name

# # # #

cuộc gọi cuộc gọi cuộc gọi

f.name [] -Nhận hàm setter tên [f, "monty"] tên setter [f, 45] -> typeerror deleter name [f] -> typeerror

Trong ví dụ này, tên thuộc tính lần đầu tiên được xác định là thuộc tính chỉ đọc bằng cách sử dụng trình trang trí @property và phương thức liên kết. thuộc tính tên. Tên của các phương thức này phải khớp chính xác với tên của thuộc tính gốc. Trong các phương thức này, lưu ý rằng giá trị thực của tên được lưu trữ trong một thuộc tính _ _name. Tên của thuộc tính được lưu trữ không phải tuân theo bất kỳ quy ước nào, nhưng nó phải khác với thuộc tính để phân biệt nó với tên của chính tài sản. Trong mã cũ hơn, bạn sẽ thường thấy các thuộc tính được xác định bằng thuộc tính [getf = none, setf = none, delf = none, doc = none] với một tập hợp các phương thức được đặt tên duy nhất để thực hiện từng thao tác. Ví dụ: Lớp foo [Object]: def getName [self]: return self._ _name def setName [self, value]: nếu không isInstance [giá trị, str]: tăng loại interror ["phải là một chuỗi!"] Tự. _ _name = value def delname [self]: nâng TypeError ["Không thể xóa tên"] name = property [getName, setName, delname]

Cách tiếp cận cũ này vẫn được hỗ trợ, nhưng phiên bản trang trí có xu hướng dẫn đến các lớp học được đánh bóng hơn một chút. Ví dụ: nếu bạn sử dụng các trình trang trí, các chức năng GET, SET và XÓA cũng có thể nhìn thấy như các phương pháp.

Các mô tả với các thuộc tính, quyền truy cập vào một thuộc tính được kiểm soát bởi một loạt các hàm GE, đặt và xóa do người dùng xác định. Đây là loại điều khiển thuộc tính này có thể được khái quát hóa thêm thông qua việc sử dụng đối tượng mô tả. Một mô tả chỉ đơn giản là một đối tượng đại diện cho giá trị của một thuộc tính. Bằng cách triển khai một hoặc nhiều phương thức đặc biệt _ _get_ _ [], _ _set_ _ [] và _ _delete_ _ [], nó có thể nối vào cơ chế truy cập thuộc tính và có thể tùy chỉnh các hoạt động đó. Đây là một ví dụ:

H lib

Chương 7 Các lớp và lập trình hướng đối tượng

127

lớp foo [đối tượng]: def _ _init_ _ [self, name]: self._ _name = name @property def name [self]: return self. . "] n = f.name f.name =" monty "f.name = 45 del f.name

# # # #

cuộc gọi cuộc gọi cuộc gọi

Mô tả chỉ có thể được khởi tạo ở cấp lớp. Việc tạo các mô tả trên cơ sở trên cơ sở trên cơ sở bằng cách tạo các đối tượng mô tả bên trong _ _init_ _ [] và các phương thức khác. Ngoài ra, tên thuộc tính được sử dụng bởi lớp để giữ một mô tả được ưu tiên hơn các thuộc tính được lưu trữ trên các trường hợp. Trong ví dụ trước, đây là lý do tại sao đối tượng mô tả lấy tham số tên và tại sao tên được thay đổi một chút bằng cách chèn một dấu gạch dưới hàng đầu. Để người mô tả lưu trữ một giá trị trên ví dụ, nó phải chọn một cái tên khác với bản mô tả được sử dụng bởi chính mô tả.

Đóng gói dữ liệu và các thuộc tính riêng tư theo mặc định, tất cả các thuộc tính và phương thức của một lớp là công khai. Điều này có nghĩa là tất cả chúng đều có thể truy cập mà không có bất kỳ hạn chế nào. Nó cũng ngụ ý rằng mọi thứ được xác định trong một lớp cơ sở đều được kế thừa và có thể truy cập trong một lớp dẫn xuất. Hành vi này thường không mong muốn trong các ứng dụng hướng đối tượng vì nó phơi bày việc thực hiện nội bộ của một đối tượng và có thể dẫn đến xung đột không gian tên giữa lớp và những người được xác định trong một lớp cơ sở. Để khắc phục sự cố này, tất cả các tên trong một lớp bắt đầu bằng một dấu gạch dưới kép, chẳng hạn như _ _foo, tự động bị xáo trộn để tạo thành một tên mới của biểu mẫu _ClassName_ _foo. Điều này có hiệu quả cung cấp một cách để một lớp có các thuộc tính và phương thức riêng tư vì các tên riêng được sử dụng trong một lớp dẫn xuất won va chạm với cùng tên riêng được sử dụng trong một lớp cơ sở. Ở đây, một ví dụ: Lớp A [đối tượng]: def _ _init_ _ [self]: self._ _x = 3 def _ _spam [self]: pass def Bar [self]: self._ _spam []

# Mangled to self._a_ _x # Mangled to _a_ _spam []

# Chỉ gọi A._ _Spam []

H lib

128

Chương 7 Các lớp và lập trình hướng đối tượng

Lớp B [a]: def _ _init_ _ [self]: a._ _init_ _ [self] self._ _x = 37 def _ _spam [self]: Pass Pass

# Mangled to self._b_ _x # Mangled to _b_ _spam []

Mặc dù sơ đồ này cung cấp ảo tưởng về việc ẩn dữ liệu, nhưng không có cơ chế nghiêm ngặt nào để thực sự ngăn chặn quyền truy cập vào các thuộc tính riêng tư của một lớp. Cụ thể, nếu tên của lớp và thuộc tính riêng tương ứng được biết đến, chúng có thể được truy cập bằng cách sử dụng tên bị hỏng. Một lớp có thể làm cho các thuộc tính này ít được nhìn thấy bằng cách xác định lại phương thức _ _DIR_ _ [], cung cấp danh sách các tên được trả về bởi hàm Dir [] mà sử dụng để kiểm tra các đối tượng. Mặc dù tên này có thể trông giống như một bước xử lý bổ sung, quá trình xáo trộn thực sự chỉ xảy ra một lần tại thời điểm một lớp được xác định. Nó không xảy ra trong quá trình thực hiện các phương thức, cũng không thêm chi phí để thực hiện chương trình. Ngoài ra, hãy lưu ý rằng tên xáo trộn không xảy ra trong các hàm như getAttr [], hasAttr [], setAttr [] hoặc delattr [] trong đó tên thuộc tính được chỉ định là chuỗi. Đối với các chức năng này, bạn cần sử dụng rõ ràng tên được xử lý như _ClassName_ _Name để truy cập thuộc tính. Chúng tôi nên sử dụng các thuộc tính riêng tư khi xác định các thuộc tính có thể thay đổi thông qua các thuộc tính. Bằng cách làm như vậy, bạn sẽ khuyến khích người dùng sử dụng tên thuộc tính thay vì truy cập trực tiếp vào dữ liệu phiên bản cơ bản [có lẽ không phải là những gì bạn dự định nếu bạn gói nó bằng một thuộc tính để bắt đầu]. Một ví dụ về điều này xuất hiện trong phần trước. Đặt một phương pháp một tên riêng là một kỹ thuật mà một siêu lớp có thể sử dụng để ngăn chặn một lớp có nguồn gốc xác định lại và thay đổi việc thực hiện một phương thức. Ví dụ: phương thức a.bar [] trong ví dụ chỉ gọi a._ _spam [], bất kể loại bản thân hoặc sự hiện diện của phương thức _ _spam [] khác trong một lớp dẫn xuất. Cuối cùng, don lồng nhầm lẫn việc đặt tên của các thuộc tính lớp tư nhân với việc đặt tên của các định nghĩa riêng tư trong một mô -đun. Một sai lầm phổ biến là xác định một lớp trong đó một dấu gạch dưới hàng đầu được sử dụng trên các tên thuộc tính trong nỗ lực ẩn các giá trị của chúng [ví dụ: _NAME]. Trong các mô -đun, quy ước đặt tên này ngăn chặn các tên được xuất bởi câu lệnh nhập từ mô -đun *. Tuy nhiên, trong các lớp, quy ước đặt tên này không che giấu thuộc tính cũng như không ngăn chặn các cuộc đụng độ tên phát sinh nếu ai đó kế thừa từ lớp và định nghĩa một thuộc tính hoặc phương thức mới có cùng tên.

Quản lý bộ nhớ đối tượng Khi một lớp được xác định, lớp kết quả là một nhà máy để tạo các trường hợp mới. Ví dụ: Lớp Circle [Object]: def _ _init_ _ [self, RADIUS]: self.radius = RADIUS # Tạo một số phiên bản vòng tròn C = Circle [4.0] D = Circle [5.0]

H lib

Chương 7 Các lớp và lập trình hướng đối tượng

129

The creation of an instance is carried out in two steps using the special method _ _new_ _[], which creates a new instance, and _ _init_ _[], which initializes it. For example, the operation c = Circle[4.0] performs these steps: c = Circle._ _new_ _[Circle, 4.0] if isinstance[c,Circle]: Circle._ _init_ _[c,4.0]

The _ _new_ _[] method of a class is something that is rarely defined by user code. If it is defined, it is typically written with the prototype _ _new_ _[cls, *args, **kwargs] where args and kwargs are the same arguments that will be passed to _ _init_ _[]. _ _new_ _[] is always a class method that receives the class object as the first parameter. Although _ _new_ _[] creates an instance, it does not automatically call _ _init_ _[]. If you see _ _new_ _[] defined in a class, it usually means the class is doing one of two things. First, the class might be inheriting from a base class whose instances are immutable.This is common if defining objects that inherit from an immutable built-in type such as an integer, string, or tuple because _ _new_ _[] is the only method that executes prior to the instance being created and is the only place where the value could be modified [in _ _init_ _[], it would be too late]. For example: class Upperstr[str]: def _ _new_ _[cls,value=""]: return str._ _new_ _[cls, value.upper[]] u = Upperstr["hello"]

# value is "HELLO"

The other major use of _ _new_ _[] is when defining metaclasses.This is described at the end of this chapter. Once created, instances are managed by reference counting. If the reference count reaches zero, the instance is immediately destroyed.When the instance is about to be destroyed, the interpreter first looks for a _ _del_ _[] method associated with the object and calls it. In practice, it’s rarely necessary for a class to define a _ _del_ _[] method.The only exception is when the destruction of an object requires a cleanup action such as closing a file, shutting down a network connection, or releasing other system resources. Even in these cases, it’s dangerous to rely on _ _del_ _[] for a clean shutdown because there’s no guarantee that this method will be called when the interpreter exits. A better approach may be to define a method such as close[] that a program can use to explicitly perform a shutdown. Occasionally, a program will use the del statement to delete a reference to an object. If this causes the reference count of the object to reach zero, the _ _del_ _[] method is called. However, in general, the del statement doesn’t directly call _ _del_ _[]. A subtle danger involving object destruction is that instances for which _ _del_ _[] is defined cannot be collected by Python’s cyclic garbage collector [which is a strong reason not to define _ _del_ _ unless you need to]. Programmers coming from languages without automatic garbage collection [e.g., C++] should take care not to adopt a programming style where _ _del_ _[] is unnecessarily defined. Although it is rare to break the garbage collector by defining _ _del_ _[], there are certain types of programming patterns, especially those involving parent-child relationships or graphs, where this

h Lib

130

Chapter 7 Classes and Object-Oriented Programming

can be a problem. For example, suppose you had an object that was implementing a variant of the “Observer Pattern.” class Account[object]: def _ _init_ _[self,name,balance]: self.name = name self.balance = balance self.observers = set[] def _ _del_ _[self]: for ob in self.observers: ob.close[] del self.observers def register[self,observer]: self.observers.add[observer] def unregister[self,observer]: self.observers.remove[observer] def notify[self]: for ob in self.observers: ob.update[] def withdraw[self,amt]: self.balance -= amt self.notify[] class AccountObserver[object]: def _ _init_ _[self, theaccount]: self.theaccount = theaccount theaccount.register[self] def _ _del_ _[self]: self.theaccount.unregister[self] del self.theaccount def update[self]: print["Balance is %0.2f" % self.theaccount.balance] def close[self]: print["Account no longer in use"] # Example setup a = Account['Dave',1000.00] a_ob = AccountObserver[a]

In this code, the Account class allows a set of AccountObserver objects to monitor an Account instance by receiving an update whenever the balance changes.To do this, each Account keeps a set of the observers and each AccountObserver keeps a reference back to the account. Each class has defined _ _del_ _[] in an attempt to provide some sort of cleanup [such as unregistering and so on]. However, it just doesn’t work. Instead, the classes have created a reference cycle in which the reference count never drops to 0 and there is no cleanup. Not only that, the garbage collector [the gc module] won’t even clean it up, resulting in a permanent memory leak. One way to fix the problem shown in this example is for one of the classes to create a weak reference to the other using the weakref module. A weak reference is a way of creating a reference to an object without increasing its reference count.To work with a weak reference, you have to add an extra bit of functionality to check whether the object being referred to still exists. Here is an example of a modified observer class: import weakref class AccountObserver[object]: def _ _init_ _[self, theaccount]: self.accountref = weakref.ref[theaccount] theaccount.register[self]

# Tạo một yếu

H lib

Biểu diễn đối tượng và ràng buộc thuộc tính

131

def _ _del_ _ [self]: acc = self.AccountRef [] # Nhận tài khoản nếu ACC: # ungister nếu vẫn tồn tại acc.unregister [self] def update [self]: in ["Số dư là % 0,2f" % self. accountref []. Cân bằng] def Close [self]: in ["tài khoản không còn sử dụng"] # Ví dụ Cài đặt A = tài khoản ['Dave', 1000.00] A_OB = AccountObserver [A]

Trong ví dụ này, một Accountref tham chiếu yếu được tạo. Để truy cập vào tài khoản cơ bản, bạn gọi nó giống như một hàm. Điều này hoặc trả về tài khoản hoặc không có nếu nó không còn xung quanh nữa. Với sửa đổi này, không còn một chu kỳ tham chiếu nữa. Nếu đối tượng tài khoản bị phá hủy, phương thức _ _del_ _ của nó sẽ chạy và các nhà quan sát nhận được thông báo. Mô -đun GC cũng hoạt động đúng. Thông tin thêm về mô -đun yếu có thể được tìm thấy trong Chương 13, Dịch vụ thời gian chạy của Python.

Biểu diễn đối tượng và ràng buộc thuộc tính bên trong, các trường hợp được triển khai bằng cách sử dụng từ điển có thể truy cập được như là phiên bản __DICT__ thuộc tính. Từ điển này chứa dữ liệu mà duy nhất cho mỗi trường hợp. Ở đây, một ví dụ: >>> a = tài khoản ['guido', 1100.0] >>> a._ _dict_ _ {'aland': 1100.0, 'name': 'guido'}

Các thuộc tính mới có thể được thêm vào một ví dụ bất cứ lúc nào, như thế này: A.Number = 123456

# Thêm thuộc tính 'Số' vào A._ _DICT_ _

Các sửa đổi cho một thể hiện luôn được phản ánh trong thuộc tính _ _dict_ _ cục bộ. Tương tự như vậy, nếu bạn thực hiện các sửa đổi thành _ _dict_ _ trực tiếp, những sửa đổi đó được phản ánh trong các thuộc tính. Các trường hợp được liên kết trở lại lớp của họ bởi một thuộc tính đặc biệt _ _Class_ _. Bản thân lớp cũng chỉ là một lớp mỏng trên một từ điển có thể được tìm thấy trong thuộc tính _ _dict_ _ của chính nó. Từ điển lớp là nơi bạn tìm thấy các phương thức. Ví dụ: >>> A._ _Class_ _

>>> tài khoản._ _dict_ _.Keys [] ['_ _dict_ _', '_ _module_ _', 'yêu cầu', 'tiền gửi', 'rút', '_ _del_ _', 'num_accounts', '_ _ _ ',' _ _doc_ _ ',' _ _init_ _ '] >>>>

Cuối cùng, các lớp được liên kết với các lớp cơ sở của chúng trong một thuộc tính đặc biệt _ _Base_ _, đây là một bộ thuật của các lớp cơ sở. Cấu trúc cơ bản này là cơ sở cho tất cả các hoạt động có được, đặt và xóa các thuộc tính của các đối tượng. Bất cứ khi nào một thuộc tính được đặt bằng obj.name = value, phương thức đặc biệt obj._ _setAttr_ _ ["name", value] được gọi. Nếu một thuộc tính bị xóa bằng del obj.name, phương thức đặc biệt obj._ _delattr_ _ ["name"] sẽ được gọi. thuộc tính xảy ra tương ứng với một thuộc tính hoặc mô tả. Trong

H lib

132

Biểu diễn đối tượng và ràng buộc thuộc tính

_ _SLOTS_ _ Một lớp có thể hạn chế tập hợp các tên thuộc tính thể hiện pháp lý bằng cách xác định một biến đặc biệt gọi là _ _slots_ _. Ở đây, một ví dụ: Tài khoản lớp [đối tượng]: _ _SLOTS_ _ = ['tên', 'cân bằng'] ...

Khi _ _Slots_ _ được xác định, các tên thuộc tính có thể được gán trên các trường hợp được giới hạn trong các tên được chỉ định. Nếu không, một ngoại lệ thuộc tính được nâng lên. Hạn chế này ngăn ai đó thêm các thuộc tính mới vào các trường hợp hiện có và giải quyết vấn đề phát sinh nếu ai đó gán giá trị cho một thuộc tính mà họ có thể đánh vần chính xác. Trong thực tế, _ _Slots_ _ không bao giờ được triển khai để trở thành một tính năng an toàn. Thay vào đó, nó thực sự là một tối ưu hóa hiệu suất cho cả bộ nhớ và tốc độ thực hiện. Các thể hiện của một lớp sử dụng _ _SLOTS_ _ không còn sử dụng từ điển để lưu trữ dữ liệu thể hiện. Thay vào đó, một cấu trúc dữ liệu nhỏ gọn hơn nhiều dựa trên một mảng được sử dụng. Trong các chương trình mà

H lib

Quá tải người vận hành

133

Tạo một số lượng lớn các đối tượng, sử dụng _ _Slots_ _ có thể dẫn đến việc giảm đáng kể thời gian sử dụng và thực hiện bộ nhớ. Xin lưu ý rằng việc sử dụng _ _slots_ _ có tương tác khó khăn với kế thừa. Nếu một lớp kế thừa từ một lớp cơ sở sử dụng _ _slots_ _, thì nó cũng cần xác định _ _SLOTS_ _ để lưu trữ các thuộc tính của chính mình [ngay cả khi nó không thêm bất kỳ] để tận dụng lợi ích _ _SLOTS_ _ cung cấp. Nếu bạn quên điều này, lớp dẫn xuất sẽ chạy chậm hơn và sử dụng nhiều bộ nhớ hơn so với những gì đã được sử dụng nếu _ _slots_ _ chưa được sử dụng trên bất kỳ lớp nào! Việc sử dụng _ _Slots_ _ cũng có thể phá vỡ mã dự kiến các trường hợp sẽ có thuộc tính _ _dict_ _ bên dưới. Mặc dù điều này thường không áp dụng cho mã người dùng, các thư viện tiện ích và các công cụ khác để hỗ trợ các đối tượng có thể được lập trình để xem _ _dict_ _ để gỡ lỗi, tuần tự hóa các đối tượng và các hoạt động khác. Cuối cùng, sự hiện diện của _ _Slots_ _ không có tác dụng đối với việc gọi các phương thức như _ _getAttribution_ _ [], _ _getAttr_ _ [] và _ _setAttr_ _ [] nếu chúng được xác định lại trong một lớp. Tuy nhiên, hành vi mặc định của các phương thức này sẽ tính đến _ _SLOTS_ _. Ngoài ra, cần nhấn mạnh rằng không cần thiết phải thêm tên phương thức hoặc thuộc tính vào _ _Slots_ _, vì chúng được lưu trữ trong lớp, không phải trên cơ sở trên cơ sở.

Nhà điều hành quá tải các đối tượng do người dùng xác định có thể được thực hiện để hoạt động với tất cả các toán tử tích hợp Python, bằng cách thêm các phương thức đặc biệt được mô tả trong Chương 3 vào một lớp. Ví dụ: nếu bạn muốn thêm một loại số mới vào Python, bạn có thể xác định một lớp trong đó các phương pháp đặc biệt như _ _add_ _ [] được xác định để làm cho các trường hợp hoạt động với các toán tử toán học tiêu chuẩn. Ví dụ sau đây cho thấy cách thức này hoạt động bằng cách xác định một lớp thực hiện các số phức tạp với một số toán tử toán học tiêu chuẩn. Lưu ý Vì Python đã cung cấp một loại số phức, lớp này chỉ được cung cấp cho mục đích minh họa.

lớp phức tạp [đối tượng]: def _ _init_ _ [self, real, hình ảnh = 0]: self.real = float [real] self.imag = float [hình ảnh] def _ _repr_ _ [self]: return "phức tạp [%s ,%s] "%[self.real, self.imag] def _ _str_ _ [self]: return" [%g +%gj] "%[self.real, self.imag] # self + other def _ _add_ _ . self.imag - other.imag]

Trong ví dụ, phương thức _ _REPR_ _ [] tạo ra một chuỗi có thể được đánh giá để tạo lại đối tượng [nghĩa là "phức tạp [thực, hình ảnh]"]. Công ước này nên được tuân theo cho tất cả các đối tượng do người dùng xác định nếu có. Mặt khác, phương thức _ _str_ _ []

H lib

134

Quá tải người vận hành

Hoạt động C + 4.0 hoạt động một phần do tai nạn. Tất cả các số tích hợp Python đã có các thuộc tính .real và .imag, vì vậy chúng đã được sử dụng trong tính toán. Nếu đối tượng khác không có các thuộc tính này, việc triển khai sẽ bị phá vỡ. Nếu bạn muốn việc triển khai phức tạp của mình hoạt động với các đối tượng thiếu các thuộc tính này, bạn phải thêm mã chuyển đổi bổ sung để trích xuất thông tin cần thiết [có thể phụ thuộc vào loại đối tượng khác]. Hoạt động 4.0 + C hoàn toàn không hoạt động vì loại điểm nổi tích hợp không biết gì về lớp phức tạp. Để khắc phục điều này, bạn có thể thêm các phương thức đảo ngược vào phức tạp: phức hợp lớp [đối tượng]: ... def _ _radd_ _ [self, other]: return phức tạp [khác. .Imag - self.img] ...

Những phương pháp này phục vụ như một dự phòng. Nếu hoạt động 4.0 + C không thành công, Python sẽ cố gắng thực thi c._ _radd_ _ [4.0] trước khi phát hành một kiểu. Các phiên bản cũ của Python đã thử các cách tiếp cận khác nhau để ép buộc trong các hoạt động hỗn hợp. Ví dụ: bạn có thể gặp các lớp Python kế thừa thực hiện phương thức _ _Coerce_ _ []. Điều này không còn được sử dụng bởi Python 2.6 hoặc Python 3. Ngoài ra, đừng bị đánh lừa bằng các phương pháp đặc biệt như _ _int_ _ [], _ _FLOAT_ _ [] hoặc _ _complex_ _ []. Mặc dù các phương pháp này được gọi bằng các chuyển đổi rõ ràng như int [x] hoặc float [x], chúng không bao giờ được gọi là ngầm để thực hiện chuyển đổi loại trong số học loại hỗn hợp. Vì vậy, nếu bạn đang viết các lớp trong đó các nhà khai thác phải làm việc với các loại hỗn hợp, bạn phải xử lý rõ ràng việc chuyển đổi loại trong việc thực hiện từng toán tử.

Các loại và các bài kiểm tra thành viên lớp Khi bạn tạo một thể hiện của một lớp, loại phiên bản đó là bản thân lớp. Để kiểm tra thành viên trong một lớp, sử dụng chức năng tích hợp isInstance [obj, cname].

H lib

Các loại và bài kiểm tra thành viên của lớp

135

Hàm trả về true nếu một đối tượng, obj, thuộc về lớp cname hoặc bất kỳ lớp nào có nguồn gốc từ cname. Ở đây, một ví dụ: Lớp A [đối tượng]: Pass Class B [a]: Pass Class C [Object]: Pass A = A [] B = B [] C = C []

# Phiên bản của 'A' # phiên bản của 'B' # của 'C'

loại [a] isinstance [a, a] isinstance [b, a] isinstance [b, c]

# # # #

Trả về trả về trả về

đối tượng lớp là sự thật, b có nguồn gốc từ sai, c không xuất phát từ

Tương tự, chức năng tích hợp ISSUBCLASS [A, B] Trả về true nếu lớp A là một lớp con của lớp B. Ở đây, một ví dụ: ISSUBCLASS [B, A] ISSUBCLASS [C, A]

# Trả về đúng # trả về sai

Một vấn đề tinh tế với việc kiểm tra loại đối tượng là các lập trình viên thường bỏ qua sự kế thừa và chỉ cần tạo các đối tượng bắt chước hành vi của một đối tượng khác. Ví dụ, hãy xem xét hai lớp sau: Class foo [Object]: Def Spam [self, a, b]: pass fooproxy [object]: def _ _init_ _ [self, f]: self.f = f def spam [ tự, a, b]: return self.f.spam [a, b]

Trong ví dụ này, Fooproxy có chức năng giống hệt với FOO. Nó thực hiện các phương thức tương tự, và nó thậm chí còn sử dụng foo bên dưới vỏ. Ví dụ: f = foo [] g = fooproxy [f] isinstance [g, foo]

# Tạo foo # Tạo fooproxy # trả về sai

Nếu một chương trình đã được viết để kiểm tra rõ ràng một foo sử dụng isinstance [], thì nó chắc chắn đã giành được công việc với một đối tượng fooproxy. Tuy nhiên, mức độ nghiêm ngặt này thường không chính xác những gì bạn muốn. Thay vào đó, có thể có ý nghĩa hơn khi khẳng định rằng một đối tượng có thể được sử dụng đơn giản là foo vì nó có cùng giao diện. Để làm điều này, có thể xác định một đối tượng xác định lại hành vi của isInstance [] và phát hành class [] cho Mục đích của việc nhóm các đối tượng lại với nhau và kiểm tra loại. Đây là một ví dụ: lớp iclass [đối tượng]: def _ _init_ _ [self]: self.implementors = set [] def register [self, c]: self. ]: return self

H lib

136

Các loại và bài kiểm tra thành viên của lớp

# Phiên bản của 'A' # phiên bản của 'B' # của 'C'

a Foo a FooProxy Returns True Returns True Returns True

In this example, it’s important to emphasize that no strong type-checking is occurring. The IFoo object has overloaded the instance checking operations in a way that allows a you to assert that a class belongs to a group. It doesn’t assert any information on the actual programming interface, and no other verification actually occurs. In fact, you can simply register any collection of objects you want to group together without regard to how those classes are related to each other.Typically, the grouping of classes is based on some criteria such as all classes implementing the same programming interface. However, no such meaning should be inferred when overloading _ _instancecheck_ _[] or _ _subclasscheck_ _[].The actual interpretation is left up to the application. Python provides a more formal mechanism for grouping objects, defining interfaces, and type-checking.This is done by defining an abstract base class, which is defined in the next section.

Abstract Base Classes In the last section, it was shown that the isinstance[] and issubclass[] operations can be overloaded.This can be used to create objects that group similar classes together and to perform various forms of type-checking. Abstract base classes build upon this concept and provide a means for organizing objects into a hierarchy, making assertions about required methods, and so forth. To define an abstract base class, you use the abc module.This module defines a metaclass [ABCMeta] and a set of decorators [@abstractmethod and @abstractproperty] that are used as follows: from abc import ABCMeta, abstractmethod, abstractproperty class Foo: # In Python 3, you use the syntax _ _metaclass_ _ = ABCMeta # class Foo[metaclass=ABCMeta] @abstractmethod def spam[self,a,b]: pass @abstractproperty

h Lib

Abstract Base Classes

137

def name[self]: pass

The definition of an abstract class needs to set its metaclass to ABCMeta as shown [also, be aware that the syntax differs between Python 2 and 3].This is required because the implementation of abstract classes relies on a metaclass [described in the next section]. Within the abstract class, the @abstractmethod and @abstractproperty decorators specify that a method or property must be implemented by subclasses of Foo. An abstract class is not meant to be instantiated directly. If you try to create a Foo for the previous class, you will get the following error: >>> f = Foo[] Traceback [most recent call last]: File "", line 1, in TypeError: Can't instantiate abstract class Foo with abstract methods spam >>>

This restriction carries over to derived classes as well. For instance, if you have a class Bar that inherits from Foo but it doesn’t implement one or more of the abstract methods, attempts to create a Bar will fail with a similar error. Because of this added checking, abstract classes are useful to programmers who want to make assertions on the methods and properties that must be implemented on subclasses. Although an abstract class enforces rules about methods and properties that must be implemented, it does not perform conformance checking on arguments or return values.Thus, an abstract class will not check a subclass to see whether a method has used the same arguments as an abstract method. Likewise, an abstract class that requires the definition of a property does not check to see whether the property in a subclass supports the same set of operations [get, set, and delete] of the property specified in a base. Although an abstract class can not be instantiated, it can define methods and properties for use in subclasses. Moreover, an abstract method in the base can still be called from a subclass. For example, calling Foo.spam[a,b] from the subclass is allowed. Abstract base classes allow preexisting classes to be registered as belonging to that base.This is done using the register[] method as follows: class Grok[object]: def spam[self,a,b]: print["Grok.spam"] Foo.register[Grok]

# Register with Foo abstract base class

When a class is registered with an abstract base, type-checking operations involving the abstract base [such as isinstance[] and issubclass[]] will return True for instances of the registered class.When a class is registered with an abstract class, no checks are made to see whether the class actually implements any of the abstract methods or properties.This registration process only affects type-checking. It does not add extra error checking to the class that is registered. Unlike many other object-oriented languages, Python’s built-in types are organized into a relatively flat hierarchy. For example, if you look at the built-in types such as int or float, they directly inherit from object, the root of all objects, instead of an intermediate base class representing numbers.This makes it clumsy to write programs that want to inspect and manipulate objects based on a generic category such as simply being an instance of a number.

H lib

138

Chương 7 Các lớp và lập trình hướng đối tượng

Cơ chế lớp trừu tượng giải quyết vấn đề này bằng cách cho phép các đối tượng có sẵn được tổ chức thành các phân cấp loại có thể xác định người dùng. Ngoài ra, một số mô-đun thư viện nhằm mục đích tổ chức các loại tích hợp theo các khả năng khác nhau mà chúng sở hữu. Mô-đun bộ sưu tập chứa các lớp cơ sở trừu tượng cho các loại hoạt động liên quan đến trình tự, bộ và từ điển. Mô-đun số chứa các lớp cơ sở trừu tượng liên quan đến tổ chức một hệ thống phân cấp số. Thông tin chi tiết có thể được tìm thấy trong Chương 14, Toán học, Hồi và Chương 15, cấu trúc dữ liệu, thuật toán và tiện ích.

Metaclasses Khi bạn xác định một lớp trong Python, bản thân định nghĩa lớp trở thành một đối tượng. Ở đây, một ví dụ: Lớp foo [đối tượng]: Pass isinstance [foo, object]

# Trả về đúng

Nếu bạn nghĩ về điều này đủ lâu, bạn sẽ nhận ra rằng một cái gì đó phải tạo ra đối tượng foo. Sự tạo ra đối tượng lớp này được điều khiển bởi một loại đối tượng đặc biệt được gọi là metaclass. Nói một cách đơn giản, một Metaclass là một đối tượng biết cách tạo và quản lý các lớp. Trong ví dụ trước, metaclass đang kiểm soát việc tạo FOO là một lớp được gọi là loại. Trên thực tế, nếu bạn hiển thị loại foo, bạn sẽ phát hiện ra rằng đó là một loại: >>> loại [foo]

Khi một lớp mới được xác định với câu lệnh lớp, một số điều xảy ra. Đầu tiên, phần thân của lớp được thực thi dưới dạng một loạt các câu trong từ điển riêng của nó. Việc thực hiện các câu lệnh giống hệt như trong mã thông thường với việc bổ sung tên xảy ra trên các thành viên riêng [tên bắt đầu bằng _ _]. Cuối cùng, tên của lớp, danh sách các lớp cơ sở và từ điển được chuyển cho hàm tạo của một metaclass để tạo đối tượng lớp tương ứng. Đây là một ví dụ về cách nó hoạt động: class_name = "foo" # tên của class_parents = [object,] # cơ sở class_body = "" " # class body def _ _init_ _ [self, x]: self.x = x def blah [self]: print ["hello world"] "" "class_dict = {} # thực thi cơ thể trong từ điển cục bộ class_dict exec [class_body, globals [], class_dict] , class_parents, class_dict]

Bước cuối cùng của việc tạo lớp trong đó loại metaclass [] được gọi có thể được tùy chỉnh. Sự lựa chọn về những gì xảy ra trong bước cuối cùng của định nghĩa lớp được kiểm soát trong

H lib

Chương 7 Các lớp và lập trình hướng đối tượng

139

# Trả về đúng

Trong metaclass này, phương thức _ _init_ _ [] đã được viết để kiểm tra nội dung của từ điển lớp. Nó quét từ điển tìm kiếm các phương thức và kiểm tra xem liệu tất cả chúng có có chuỗi tài liệu hay không. Nếu không, một ngoại lệ loại được tạo ra. Mặt khác, việc triển khai mặc định của loại._ _init_ _ [] được gọi để khởi tạo lớp. Để sử dụng metaclass này, một lớp cần chọn rõ ràng nó. Kỹ thuật phổ biến nhất để thực hiện điều này là trước tiên để xác định một lớp cơ sở, chẳng hạn như sau: Lớp được ghi lại: _ _Metaclass_ _ = DocMeta

# Trong Python 3, hãy sử dụng Cú pháp # Lớp được ghi lại [metaclass = DocMeta]

H lib

140

Chương 7 Các lớp và lập trình hướng đối tượng

Lớp cơ sở này sau đó được sử dụng làm cha mẹ cho tất cả các đối tượng sẽ được ghi lại. Ví dụ: Lớp FOO [tài liệu]: Spam [tự, A, B]: "Spam làm gì đó" vượt qua

Ví dụ này minh họa một trong những cách sử dụng chính của các metaclass, đó là kiểm tra và thu thập thông tin về các định nghĩa của lớp. Metaclass không thay đổi bất cứ điều gì về lớp thực sự được tạo nhưng chỉ đơn thuần là thêm một số kiểm tra bổ sung. Trong các ứng dụng Metaclass nâng cao hơn, một Metaclass có thể kiểm tra và thay đổi nội dung của định nghĩa lớp trước khi tạo lớp. Nếu các thay đổi sẽ được thực hiện, bạn nên xác định lại phương thức _ _New_ _ [] chạy trước khi tạo bản thân lớp. Kỹ thuật này thường được kết hợp với các kỹ thuật bao bọc các thuộc tính với các mô tả hoặc thuộc tính vì đó là một cách để nắm bắt Các tên đang được sử dụng trong lớp. Ví dụ, đây là phiên bản sửa đổi của bộ mô tả typedproperty đã được sử dụng trong phần Mô tả của Cameron type = type if default: self.default = mặc định khác: self.default = type [] def _ _get_ _ [self, fory, cls]: return getAttr [instance, self.name, self.default] def _ _set_ _ [ bản thân, ví dụ, giá trị]: Nếu không phải là isInstance [value, self.type]: tăng loại horror ["phải là % s" % self.type] setAttr [ví dụ, self.name, value] def _ _delete_ _ [self, phiên bản]: Raise ApertyError ["Không thể xóa thuộc tính"]

Trong ví dụ này, thuộc tính tên của bộ mô tả chỉ đơn giản được đặt thành none. Để điền vào điều này, chúng tôi sẽ dựa vào một lớp meta. Ví dụ: Lớp typedmeta [loại]: def _ _New_ _ [cls, tên, cơ sở, dict]: slots = [] cho khóa, giá trị trong dict.items []: if isInstance [value, typedproperty]: value.name = "_" + các khe khóa.Append [value.name] Dict : # Trong Python 3, sử dụng cú pháp _ _Metaclass_ _ = typedmeta # class gõ [metaclass = typedmeta]

Trong ví dụ này, Metaclass quét từ điển lớp và tìm kiếm các trường hợp của typedproperty. Nếu tìm thấy, nó đặt thuộc tính tên và xây dựng một danh sách các tên trong các khe. Sau khi thực hiện điều này, thuộc tính _ _SLOTS_ _ được thêm vào từ điển lớp và lớp được xây dựng bằng cách gọi phương thức _ _New_ _ [] của loại [] metaclass. Dưới đây là một ví dụ về việc sử dụng metaclass mới này: class foo [gõ]: name = typedproperty [str] num = typedproperty [int, 42]

H lib

Chương 7 Các lớp và lập trình hướng đối tượng

141

Ở đây, việc sử dụng cú pháp trang trí chủ yếu là một trong những tiện lợi. Một cách khác để thực hiện điều tương tự sẽ là thế này: lớp foo [đối tượng]: _ _clsid_ _ = "

Mặc dù nó có thể nghĩ về những điều độc ác vô tận mà người ta có thể làm với một lớp trong chức năng trang trí lớp, nhưng có lẽ tốt nhất là tránh ma thuật quá mức như đặt một trình bao bọc xung quanh lớp hoặc viết lại nội dung của lớp.

H lib

Trang này cố ý để trống

H lib

Trang này cố ý để trống

8 mô -đun, gói và phân phối l

Các chương trình Arge Python được tổ chức thành các mô -đun và gói. Ngoài ra, một số lượng lớn các mô -đun được bao gồm trong thư viện tiêu chuẩn Python. Chương này mô tả hệ thống mô -đun và gói chi tiết hơn. Ngoài ra, nó cung cấp thông tin về cách cài đặt các mô-đun bên thứ ba và phân phối mã nguồn.

Các mô -đun và câu lệnh nhập bất kỳ tệp nguồn Python nào cũng có thể được sử dụng làm mô -đun. Ví dụ: xem xét mã sau: # spam.py a = 37 def foo []: in ["Tôi là foo và A là % s" % a] def Bar []: in ["Tôi là thanh và tôi 'm Calling foo "] foo [] Class Spam [Object]: def Grok [self]: in [" Tôi là spam.grok "]

Để tải mã này làm mô -đun, hãy sử dụng statems stop stop. Nhập lần đầu được sử dụng để tải mô -đun, nó thực hiện ba điều: 1. Nó tạo một không gian tên mới đóng vai trò là một thùng chứa cho tất cả các đối tượng được xác định trong Tệp nguồn. Đây là không gian tên được truy cập khi các chức năng và phương thức được xác định trong mô -đun Sử dụng câu lệnh toàn cầu. 2. Nó thực thi mã có trong mô -đun trong không gian tên mới được tạo. 3. Nó tạo một tên trong trình gọi đề cập đến không gian tên mô -đun. Tên này khớp với tên của mô -đun và được sử dụng như sau: Nhập spam x = spam.a spam.foo [] s = spam.spam [] s .cảm nhận[] ...

# # # #

H lib

144

Trang này cố ý để trống

8 mô -đun, gói và phân phối l

h Lib

Importing Selected Symbols from a Module

145

Importing Selected Symbols from a Module The from statement is used to load specific definitions within a module into the current namespace.The from statement is identical to import except that instead of creating a name referring to the newly created module namespace, it places references to one or more of the objects defined in the module into the current namespace: from spam import foo foo[] spam.foo[]

# Imports spam and puts 'foo' in current namespace # Calls spam.foo[] # NameError: spam

The from statement also accepts a comma-separated list of object names. For example: from spam import foo, bar

If you have a very long list of names to import, the names can be enclosed in parentheses.This makes it easier to break the import statement across multiple lines. Here’s an example: from spam import [foo, bar, Spam]

In addition, the as qualifier can be used to rename specific objects imported with from. Here’s an example: from spam import Spam as Sp s = Sp[]

The asterisk [*] wildcard character can also be used to load all the definitions in a module, except those that start with an underscore. Here’s an example: from spam import *

# Load all definitions into current namespace

The from module import * statement may only be used at the top level of a module. In particular, it is illegal to use this form of import inside function bodies due to the way in which it interacts with function scoping rules [e.g., when functions are compiled into internal bytecode, all of the symbols used within the function need to be fully specified]. Modules can more precisely control the set of names imported by from module import * by defining the list _ _all_ _. Here’s an example: # module: spam.py _ _all_ _ = [ 'bar', 'Spam' ]

# Names I will export with from spam import *

Importing definitions with the from form of import does not change their scoping rules. For example, consider this code: from spam import foo a = 42 foo[] # Prints "I'm foo and a is 37"

In this example, the definition of foo[] in spam.py refers to a global variable a.When a reference to foo is placed into a different namespace, it doesn’t change the binding rules for variables within that function.Thus, the global namespace for a function is always the module in which the function was defined, not the namespace into which a function is imported and called.This also applies to function calls. For example, in the

h Lib

146

Chapter 8 Modules, Packages, and Distribution

following code, the call to bar[] results in a call to spam.foo[], not the redefined foo[] that appears in the previous code example: from spam import bar def foo[]: print["I'm a different foo"] bar[] # When bar calls foo[], it calls spam.foo[], not # the definition of foo[] above

Another common confusion with the from form of import concerns the behavior of global variables. For example, consider this code: from spam import a, foo a = 42 foo[] print[a]

# # # #

Import Modify Prints Prints

a global variable the variable "I'm foo and a is 37" "42"

Here, it is important to understand that variable assignment in Python is not a storage operation.That is, the assignment to a in the earlier example is not storing a new value in a, overwriting the previous value. Instead, a new object containing the value 42 is created and the name a is made to refer to it. At this point, a is no longer bound to the value in the imported module but to some other object. Because of this behavior, it is not possible to use the from statement in a way that makes variables behave similarly as global variables or common blocks in languages such as C or Fortran. If you want to have mutable global program parameters in your program, put them in a module and use the module name explicitly using the import statement [that is, use spam.a explicitly].

Execution as the Main Program There are two ways in which a Python source file can execute.The import statement executes code in its own namespace as a library module. However, code might also execute as the main program or script.This occurs when you supply the program as the script name to the interpreter: % python spam.py

Each module defines a variable, _ _name_ _, that contains the module name. Programs can examine this variable to determine the module in which they’re executing.The top-level module of the interpreter is named _ _main_ _. Programs specified on the command line or entered interactively run inside the _ _main_ _ module. Sometimes a program may alter its behavior, depending on whether it has been imported as a module or is running in _ _main_ _. For example, a module may include some testing code that is executed if the module is used as the main program but which is not executed if the module is simply imported by another module.This can be done as follows: # Check if running as a program if _ _name_ _ == '_ _main_ _': # Yes statements else: # No, I must have been imported as a module statements

It is common practice for source files intended for use as libraries to use this technique for including optional testing or example code. For example, if you’re developing a

h Lib

Module Loading and Compilation

147

module, you can put code for testing the features of your library inside an if statement as shown and simply run Python on your module as the main program to run it.That code won’t run for users who import your library.

The Module Search Path When loading modules, the interpreter searches the list of directories in sys.path.The first entry in sys.path is typically an empty string '', which refers to the current working directory. Other entries in sys.path may consist of directory names, .zip archive files, and .egg files.The order in which entries are listed in sys.path determines the search order used when modules are loaded.To add new entries to the search path, simply add them to this list. Although the path usually contains directory names, zip archive files containing Python modules can also be added to the search path.This can be a convenient way to package a collection of modules as a single file. For example, suppose you created two modules, foo.py and bar.py, and placed them in a zip file called mymodules.zip.The file could be added to the Python search path as follows: import sys sys.path.append["mymodules.zip"] import foo, bar

Specific locations within the directory structure of a zip file can also be used. In addition, zip files can be mixed with regular pathname components. Here’s an example: sys.path.append["/tmp/modules.zip/lib/python"]

In addition to .zip files, you can also add .egg files to the search path. .egg files are packages created by the setuptools library.This is a common format encountered when installing third-party Python libraries and extensions. An .egg file is actually just a .zip file with some extra metadata [e.g., version number, dependencies, etc.] added to it.Thus, you can examine and extract data from an .egg file using standard tools for working with .zip files. Despite support for zip file imports, there are some restrictions to be aware of. First, it is only possible import .py, .pyw, .pyc, and .pyo files from an archive. Shared libraries and extension modules written in C cannot be loaded directly from archives, although packaging systems such as setuptools are sometimes able to provide a workaround [typically by extracting C extensions to a temporary directory and loading modules from it]. Moreover, Python will not create .pyc and .pyo files when .py files are loaded from an archive [described next].Thus, it is important to make sure these files are created in advance and placed in the archive in order to avoid poor performance when loading modules.

Module Loading and Compilation So far, this chapter has presented modules as files containing pure Python code. However, modules loaded with import really fall into four general categories: n Code written in Python [.py files] n C or C++ extensions that have been compiled into shared libraries or DLLs

h Lib

Chapter 8 Modules, Packages, and Distribution

148

n n

Packages containing a collection of modules Built-in modules written in C and linked into the Python interpreter

When looking for a module [for example, foo], the interpreter searches each of the directories in sys.path for the following files [listed in search order]: 1. A directory, foo, defining a package 2. foo.pyd, foo.so, foomodule.so, or foomodule.dll [compiled extensions] 3. foo.pyo [only if the -O or -OO option has been used] 4. foo.pyc 5. foo.py [on Windows, Python also checks for .pyw files.] Packages are described shortly; compiled extensions are described in Chapter 26, “Extending and Embedding Python.” For .py files, when a module is first imported, it’s compiled into bytecode and written back to disk as a .pyc file. On subsequent imports, the interpreter loads this precompiled bytecode unless the modification date of the .py file is more recent [in which case, the .pyc file is regenerated]. .pyo files are used in conjunction with the interpreter’s -O option.These files contain bytecode stripped of line numbers, assertions, and other debugging information. As a result, they’re somewhat smaller and allow the interpreter to run slightly faster. If the -OO option is specified instead of -O, documentation strings are also stripped from the file.This removal of documentation strings occurs only when .pyo files are created—not when they’re loaded. If none of these files exists in any of the directories in sys.path, the interpreter checks whether the name corresponds to a built-in module name. If no match exists, an ImportError exception is raised. The automatic compilation of files into .pyc and .pyo files occurs only in conjunction with the import statement. Programs specified on the command line or standard input don’t produce such files. In addition, these files aren’t created if the directory containing a module’s .py file doesn’t allow writing [e.g., either due to insufficient permission or if it’s part of a zip archive].The -B option to the interpreter also disables the generation of these files. If .pyc and .pyo files are available, it is not necessary for a corresponding .py file to exist.Thus, if you are packaging code and don’t wish to include source, you can merely bundle a set of .pyc files together. However, be aware that Python has extensive support for introspection and disassembly. Knowledgeable users will still be able to inspect and find out a lot of details about your program even if the source hasn’t been provided. Also, be aware that .pyc files tend to be version-specific.Thus, a .pyc file generated for one version of Python might not work in a future release. When import searches for files, it matches filenames in a case-sensitive manner— even on machines where the underlying file system is case-insensitive, such as on Windows and OS X [such systems are case-preserving, however].Therefore, import foo will only import the file foo.py and not the file FOO.PY. However, as a general rule, you should avoid the use of module names that differ in case only.

H lib

Gói

149

Mô -đun tải lại và dỡ hàng Python không cung cấp hỗ trợ thực sự để tải lại hoặc dỡ tải các mô -đun đã nhập trước đó. Mặc dù bạn có thể xóa một mô -đun khỏi sys.modules, nhưng điều này thường không tải mô -đun từ bộ nhớ. Đây là do các tham chiếu đến đối tượng mô -đun vẫn có thể tồn tại trong các thành phần chương trình khác sử dụng nhập để tải mô -đun đó. Hơn nữa, nếu có các trường hợp của các lớp được xác định trong mô -đun, các trường hợp đó chứa các tài liệu tham khảo trở lại đối tượng lớp của họ, từ đó giữ các tham chiếu đến mô -đun mà nó được xác định. Thực tế là các tham chiếu mô -đun tồn tại ở nhiều nơi làm cho việc tải lại một mô -đun thường không thực tế sau khi thực hiện các thay đổi đối với việc thực hiện nó. Ví dụ: nếu bạn xóa một mô -đun khỏi sys.modules và sử dụng nhập để tải lại, điều này sẽ không thay đổi tất cả các tài liệu tham khảo trước đó cho mô -đun được sử dụng trong một chương trình. Thay vào đó, bạn sẽ có một tham chiếu đến mô -đun mới được tạo bởi câu lệnh nhập gần đây nhất và một bộ tham chiếu đến mô -đun cũ được tạo bởi các phần nhập trong các phần khác của mã. Điều này hiếm khi bạn muốn và không bao giờ an toàn để sử dụng Bất kỳ loại mã sản xuất lành mạnh nào trừ khi bạn có thể kiểm soát cẩn thận toàn bộ môi trường thực thi. Các phiên bản cũ hơn của Python đã cung cấp hàm tải lại [] để tải lại mô -đun. Tuy nhiên, việc sử dụng chức năng này không bao giờ thực sự an toàn [vì tất cả các lý do đã nói ở trên], và việc sử dụng nó đã được khuyến khích tích cực trừ khi là một hỗ trợ gỡ lỗi có thể. Python 3 loại bỏ hoàn toàn tính năng này. Vì vậy, nó tốt nhất không dựa vào nó. Cuối cùng, cần lưu ý rằng các tiện ích mở rộng C/C ++ cho Python không thể được tải hoặc tải lại một cách an toàn theo bất kỳ cách nào. Không có sự hỗ trợ nào được cung cấp cho điều này, và hệ điều hành cơ bản có thể cấm nó dù sao đi nữa, cách duy nhất của bạn là khởi động lại quy trình phiên dịch Python.

Các gói gói cho phép một bộ sưu tập các mô -đun được nhóm theo tên gói chung. Kỹ thuật này giúp giải quyết xung đột không gian tên giữa các tên mô -đun được sử dụng trong các ứng dụng khác nhau. Một gói được xác định bằng cách tạo một thư mục có cùng tên với gói và tạo tệp _ _init_ _.py trong thư mục đó. Bạn có thể đặt thêm các tệp nguồn, biên dịch các phần mở rộng và thanh toán con trong thư mục này, khi cần. Ví dụ: một gói có thể được tổ chức như sau: đồ họa/ _ _init_ _.py nguyên thủy/ _ _init_ _.py lines.py fill.py text.py ... graph2d/ _ _init_ _.py plot2d.py ... Graph3d/ _ _init_ _.py plot3d.py ... định dạng/ _ _init_ _.py gif.py

H lib

Gói

150

Chương 8 Mô -đun, Gói và Phân phối

png.py tiff.py jpeg.py

Câu lệnh nhập được sử dụng để tải các mô -đun từ một gói theo một số cách: n

Nhập đồ họa.primitive.fill

Điều này tải đồ họa mô hình con. N

từ đồ họa. Nhập khẩu điền vào

Điều này tải trọng điền vào mô hình con nhưng làm cho nó có sẵn mà không có tiền tố gói; Ví dụ: fill.floodfill [img, x, y, màu]. N

Bây giờ khi người dùng phát hành một câu lệnh nhập khẩu đồ họa. Một vấn đề tinh tế khác với các gói liên quan đến các mô hình con muốn nhập các mô hình con khác trong cùng một gói. Ví dụ: giả sử mô -đun đồ họa.primitive. Như thế này: # fill.py từ. Nhập dòng

Trong ví dụ này,. được sử dụng trong tuyên bố từ. Nhập các dòng đề cập đến cùng một thư mục của mô -đun gọi. Vì vậy, câu lệnh này tìm kiếm một dòng mô -đun trong

H lib

Gói

151

cùng thư mục với tệp fill.py. Cần cẩn thận để tránh sử dụng một câu lệnh như nhập mô -đun để nhập mô hình con gói. Trong các phiên bản cũ của Python, không rõ liệu câu lệnh MODULE nhập khẩu có đề cập đến một mô -đun thư viện tiêu chuẩn hay mô hình con của gói hay không. Các phiên bản cũ hơn của Python trước tiên sẽ cố gắng tải mô -đun từ cùng một thư mục gói với mô hình con trong đó câu lệnh nhập xuất hiện và sau đó chuyển sang các mô -đun thư viện tiêu chuẩn nếu không tìm thấy khớp. Tuy nhiên, trong Python 3, nhập giả định một đường dẫn tuyệt đối và chỉ đơn giản là cố gắng tải mô -đun từ thư viện tiêu chuẩn. Nhập khẩu tương đối rõ ràng hơn ý định của bạn. Nhập khẩu tương đối cũng có thể được sử dụng để tải các mô hình con có trong các thư mục khác nhau của cùng một gói. Ví dụ: nếu mô -đun đồ họa.graph2d.plot2d muốn nhập graphics.primitives.lines, nó có thể sử dụng một câu như thế này: # Plot2D.Py từ .. PRIMITIVES Dòng nhập nhập

Ở đây, .. chuyển ra một cấp độ thư mục và nguyên thủy rơi xuống một thư mục gói khác. Nhập khẩu tương đối chỉ có thể được chỉ định bằng mẫu biểu tượng nhập từ mô -đun của câu lệnh nhập. Vì vậy, các câu lệnh như nhập ..primitives.lines hoặc nhập .lines là lỗi cú pháp. Ngoài ra, biểu tượng phải là một định danh hợp lệ. Vì vậy, một tuyên bố như từ .. nhập khẩu nguyên thủy.lines cũng là bất hợp pháp. Cuối cùng, nhập khẩu tương đối chỉ có thể được sử dụng trong một gói; Việc sử dụng nhập khẩu tương đối là bất hợp pháp để chỉ các mô -đun đơn giản nằm trong một thư mục khác trên hệ thống tập tin. Nhập tên gói một mình không nhập tất cả các mô hình con có trong gói. Ví dụ: mã sau đây không hoạt động: Nhập đồ họa đồ họa.primitive.fill.floodfill [img, x, y, color]

# Thất bại!

Tuy nhiên, vì câu lệnh Đồ họa nhập thực thi tệp _ _init_ _.py trong thư mục đồ họa, có thể tự động nhập tất cả các mô hình con, như sau: # Graphics/_ _init_ _.py từ. Nhập nguyên thủy, Graph2D, Graph3d # Graphics/Primitive/_ _init_ _.py từ. Nhập dòng, điền, văn bản, ...

Bây giờ câu lệnh Đồ họa nhập nhập khẩu tất cả các mô hình con và cung cấp chúng có sẵn bằng cách sử dụng tên đủ điều kiện của chúng. Một lần nữa, điều quan trọng là nhấn mạnh rằng một gói nhập khẩu tương đối nên được sử dụng như được hiển thị. Nếu bạn sử dụng một câu lệnh đơn giản như mô -đun nhập, các mô -đun thư viện tiêu chuẩn có thể được tải thay thế. Cuối cùng, khi Python nhập gói, nó định nghĩa một biến đặc biệt, _ _Path_ _, chứa danh sách các thư mục được tìm kiếm khi tìm kiếm các mô hình con gói [_ _path_ _ là phiên bản cụ thể của biến số của sys.path]. _ _Path_ _ có thể truy cập được vào mã có trong các tệp _ _init_ _.py và ban đầu chứa một mục duy nhất với tên thư mục của gói. Nếu cần thiết, một gói có thể cung cấp các thư mục bổ sung cho danh sách _ _path_ _ để thay đổi đường dẫn tìm kiếm được sử dụng để tìm các mô hình con. Điều này có thể hữu ích nếu tổ chức của một gói trên hệ thống tệp rất phức tạp và không phù hợp với hệ thống phân cấp gói.

H lib

152

Gói

# Một mô -đun thư viện duy nhất # gói mô -đun hỗ trợ

# Một tập lệnh để chạy như: python runspam.py

Bạn nên tổ chức mã của mình để nó hoạt động bình thường khi chạy trình thông dịch Python trong thư mục cấp cao nhất. Ví dụ: nếu bạn bắt đầu Python trong thư mục spam, bạn sẽ có thể nhập các mô -đun, nhập các thành phần gói và chạy tập lệnh mà không phải thay đổi bất kỳ cài đặt Python nào như đường dẫn tìm kiếm mô -đun. Sau khi bạn đã tổ chức mã của mình, hãy tạo một thiết lập tệp trong thư mục hàng đầu nhất [spam trong các ví dụ trước]. Trong tệp này, hãy đặt mã sau: # setup.py từ distutils.core Nhập Cài đặt thiết lập [name = "spam", phiên bản = "1.0", py_modules = ['libspam'], gói = ['spampkg'] = ['runspam.py'],]

Trong cuộc gọi setup [], đối số py_modules là danh sách tất cả các mô-đun python một tệp đơn, các gói là danh sách tất cả các thư mục gói và tập lệnh là danh sách các tệp script. Bất kỳ đối số nào trong số này có thể bị bỏ qua nếu phần mềm của bạn không có bất kỳ thành phần phù hợp nào [tức là, không có tập lệnh]. Tên là tên của gói của bạn và phiên bản là số phiên bản dưới dạng chuỗi. Call to setup [] hỗ trợ nhiều tham số khác cung cấp siêu dữ liệu khác nhau về gói của bạn. Có thể 8.1 cho thấy các tham số phổ biến nhất có thể được chỉ định. Tất cả các giá trị là các chuỗi ngoại trừ tham số phân loại, là danh sách các chuỗi như ['trạng thái phát triển :: 4 - beta', 'Ngôn ngữ lập trình :: Python'] [có thể tìm thấy danh sách đầy đủ tại // pypi .Python.org]. Bảng 8.1

Tham số để setup []

Tham số

Sự mô tả

Tên phiên bản tác giả tác giả_Email

Tên của gói [Yêu cầu] Số phiên bản [Yêu cầu] Tác giả Tên tác giả Địa chỉ email của tác giả

H lib

Phân phối các chương trình và thư viện Python

Bảng 8.1

153

Tiếp tục

Tham số

Sự mô tả

Tên phiên bản tác giả tác giả_Email

Tên của gói [Yêu cầu] Số phiên bản [Yêu cầu] Tác giả Tên tác giả Địa chỉ email của tác giả

H lib

h Lib

154

Chapter 8 Modules, Packages, and Distribution

binary executable, that is beyond the scope of what can be covered here [look at a third-party module such as py2exe or py2app for further details]. If all you are doing is distributing libraries or simple scripts to people, it is usually unnecessary to package your code with the Python interpreter and runtime as well. Finally, it should be noted that there are many more options to distutils than those covered here. Chapter 26 describes how distutils can be used to compile C and C++ extensions. Although not part of the standard Python distribution, Python software is often distributed in the form of an .egg file.This format is created by the popular setuptools extension [//pypi.python.org/pypi/setuptools].To support setuptools, you can simply change the first part of your setup.py file as follows: # setup.py try: from setuptools import setup except ImportError: from distutils.core import setup setup[name = "spam", ... ]

Installing Third-Party Libraries The definitive resource for locating third-party libraries and extensions to Python is the Python Package Index [PyPI], which is located at //pypi.python.org. Installing thirdparty modules is usually straightforward but can become quite involved for very large packages that also depend on other third-party modules. For the more major extensions, you will often find a platform-native installer that simply steps you through the process using a series of dialog screens. For other modules, you typically unpack the download, look for the setup.py file, and type python setup.py install to install the software. By default, third-party modules are installed in the site-packages directory of the Python standard library. Access to this directory typically requires root or administrator access. If this is not the case, you can type python setup.py install --user to have the module installed in a per-user library directory.This installs the package in a per-user directory such as "/Users/beazley/.local/lib/python2.6/site-packages" on UNIX. If you want to install the software somewhere else entirely, use the --prefix option to setup.py. For example, typing python setup.py install --prefix=/home/ beazley/pypackages installs a module under the directory /home/beazley/ pypackages.When installing in a nonstandard location, you will probably have to adjust the setting of sys.path in order for Python to locate your newly installed modules. Be aware that many extensions to Python involve C or C++ code. If you have downloaded a source distribution, your system will have to have a C++ compiler installed in order to run the installer. On UNIX, Linux, and OS X, this is usually not an issue. On Windows, it has traditionally been necessary to have a version of Microsoft Visual Studio installed. If you’re working on that platform, you’re probably better off looking for a precompiled version of your extension.

h Lib

Installing Third-Party Libraries

155

If you have installed setuptools, a script easy_install is available to install packages. Simply type easy_install pkgname to install a specific package. If configured correctly, this will download the appropriate software from PyPI along with any dependencies and install it for you. Of course, your mileage might vary. If you would like to add your own software to PyPI, simply type python setup.py register.This will upload metadata about the latest version of your software to the index [note that you will have to register a username and password first].

h Lib

This page intentionally left blank

h Lib

9 Input and Output T

his chapter describes the basics of Python input and output [I/O], including command-line options, environment variables, file I/O, Unicode, and how to serialize objects using the pickle module.

Reading Command-Line Options When Python starts, command-line options are placed in the list sys.argv.The first element is the name of the program. Subsequent items are the options presented on the command line after the program name.The following program shows a minimal prototype of manually processing simple command-line arguments: import sys if len[sys.argv] != 3: sys.stderr.write["Usage : python %s inputfile outputfile\n" % sys.argv[0]] raise SystemExit[1] inputfile = sys.argv[1] outputfile = sys.argv[2]

In this program, sys.argv[0] contains the name of the script being executed.Writing an error message to sys.stderr and raising SystemExit with a non-zero exit code as shown is standard practice for reporting usage errors in command-line tools. Although you can manually process command options for simple scripts, use the optparse module for more complicated command-line handling. Here is a simple example: import optparse p = optparse.OptionParser[] # An option taking an argument p.add_option["-o",action="store",dest="outfile"] p.add_option["--output",action="store",dest="outfile"] # An option that sets a boolean flag p.add_option["-d",action="store_true",dest="debug"] p.add_option["--debug",action="store_true",dest="debug"] # Set default values for selected options p.set_defaults[debug=False] # Parse the command line opts, args = p.parse_args[] # Retrieve the option settings outfile = opts.outfile debugmode = opts.debug

H lib

158

Chương 9 Đầu vào và đầu ra

Trong ví dụ này, hai loại tùy chọn được thêm Tùy chọn, -D hoặc - -Debug, chỉ đơn thuần là đặt cờ boolean. Điều này được bật bằng cách chỉ định Action = 'store_true' trong p.add_option []. Đối số số phận cho p.add_option [] sẽ được lưu trữ sau khi phân tích cú pháp. Phương thức p.set_defaults [] Đặt các giá trị mặc định cho một hoặc nhiều tùy chọn. Tên đối số được sử dụng với phương thức này sẽ khớp với các tên đích được chọn cho mỗi tùy chọn. Nếu không có giá trị mặc định được chọn, giá trị mặc định được đặt thành không có. Chương trình trước đó nhận ra tất cả các kiểu dòng lệnh sau: % % % %

Python Python Python Python

prog.py prog.py prog.py prog.py

-o Outfile -d Infile1 ... Infilen -Output = Outfile -Debug Infile1 ... Infilen -H - -Help

Phân tích cú pháp được thực hiện bằng phương thức p.parse_args []. Phương thức này trả về 2-tuple [opts, args] trong đó opts là một đối tượng chứa các giá trị tùy chọn được phân tích cú pháp và ARGS là danh sách các mục trên dòng lệnh không được phân tích cú pháp làm tùy chọn. Các giá trị tùy chọn được truy xuất bằng Opts.Dest WHERE DEST là tên đích được sử dụng khi thêm tùy chọn. Ví dụ: đối số cho đối số -O hoặc --Output Cung cấp tùy chọn -H hoặc -Help liệt kê các tùy chọn có sẵn nếu người dùng yêu cầu. Các tùy chọn xấu cũng dẫn đến một thông báo lỗi. Ví dụ này chỉ hiển thị việc sử dụng đơn giản nhất của mô -đun OptParse. Thông tin chi tiết về một số tùy chọn nâng cao hơn có thể được tìm thấy trong Chương 19, Dịch vụ hệ điều hành.

Biến môi trường Biến môi trường được truy cập trong từ điển OS.ENVION. Ở đây, một ví dụ: Nhập OS PATH = OS.ENVION ["PATH"] user = os.environ ["user"] editor = os.environ ["Editor"] ... vv ...

Để sửa đổi các biến môi trường, hãy đặt biến OS.ENVION. Ví dụ: Os.Envir ["foo"] = "Bar"

Sửa đổi thành OS.EnVION ảnh hưởng đến cả chương trình đang chạy và các quy trình con được tạo bởi Python.

Các tệp và đối tượng tệp Mở chức năng tích hợp [name [, mode [, bufsize]]] mở và tạo một đối tượng tệp, như được hiển thị ở đây: f = open ["foo"] f = open ["foo", 'r '] f = open ["foo",' w ']

# Mở "Foo" để đọc # Mở "Foo" để đọc [giống như trên] # Mở để viết

H lib

Chương 9 Đầu vào và đầu ra

159

Chuỗi trống], bất kỳ kết thúc dòng nào được công nhận là Newlines, nhưng không được dịch trong văn bản đầu vào. Nếu Newline có bất kỳ giá trị pháp lý nào khác, giá trị đó là những gì được sử dụng để chấm dứt các dòng. CloseFD kiểm soát xem bộ mô tả tệp cơ bản có thực sự đóng khi phương thức đóng [] được gọi hay không. Theo mặc định, điều này được đặt thành true. Bảng 9.1 cho thấy các phương thức được hỗ trợ bởi các đối tượng tệp. Bảng 9.1

Phương pháp tập tin

Phương pháp

Sự mô tả

F.Read [[n]] F.Readline [[n]]

Đọc nhiều nhất n byte. Đọc một dòng duy nhất đầu vào lên đến n ký tự. Nếu N bị bỏ qua, phương pháp này sẽ đọc toàn bộ dòng. Đọc tất cả các dòng và trả về một danh sách. Kích thước tùy chọn chỉ định số lượng ký tự gần đúng để đọc trên tệp trước khi dừng. Viết chuỗi s. Viết tất cả các chuỗi trong các dòng trình tự. Đóng tệp.

F.ReadLines [[kích thước]]

f.write [s] f.writelines [dòng] f.close []

H lib

160

Chương 9 Đầu vào và đầu ra

Bảng 9.1

Tiếp tục

Phương pháp

Sự mô tả

F.Read [[n]] F.Readline [[n]]

F.ReadLines [[kích thước]]

f.write [s] f.writelines [dòng] f.close []

H lib

Chương 9 Đầu vào và đầu ra

161

Bảng 9.1

Thuộc tính đối tượng tệp

Thuộc tính

Sự mô tả

f.closed

Giá trị Boolean chỉ ra trạng thái tệp: Sai Nếu tệp được mở, đúng nếu đóng. Chế độ I/O cho tệp. Tên của tệp nếu được tạo bằng Open []. Nếu không, nó sẽ là một chuỗi chỉ ra nguồn của tệp. Giá trị Boolean cho biết liệu một ký tự không gian có cần được in trước một giá trị khác khi sử dụng câu lệnh in hay không. Các lớp mô phỏng các tệp phải cung cấp một thuộc tính có thể ghi của tên này mà ban đầu được khởi tạo về 0 [chỉ Python 2]. Khi một tệp được mở ở chế độ NEWLINE phổ quát, thuộc tính này chứa biểu diễn NewLine thực sự được tìm thấy trong tệp. Giá trị không có nếu không gặp phải dòng mới nào, một chuỗi chứa '\ n', '\ r' hoặc '\ r \ n' hoặc một tuple chứa tất cả các mã hóa dòng mới khác nhau được thấy. Một chuỗi biểu thị mã hóa tệp, nếu có [ví dụ: 'Latin-1' hoặc 'UTF-8']. Giá trị là không nếu không có mã hóa đang được sử dụng.

F.Mode F.Name F.SoFtsPace

F.Newlines

f.encoding

Đầu vào tiêu chuẩn, đầu ra và lỗi Trình thông dịch cung cấp ba đối tượng tệp tiêu chuẩn, được gọi là đầu vào tiêu chuẩn, đầu ra tiêu chuẩn và lỗi tiêu chuẩn, có sẵn trong mô -đun SYS như sys.stdin, sys.stdout và sys.stderr, tương ứng. Stdin là một đối tượng tệp tương ứng với luồng các ký tự đầu vào được cung cấp cho trình thông dịch. Stdout là đối tượng tệp nhận được đầu ra được tạo bằng in. Stderr là một tệp nhận được thông báo lỗi. Thường xuyên hơn không, Stdin được ánh xạ tới bàn phím của người dùng, trong khi Stdout và Stderr tạo văn bản trên màn hình.

H lib

162

Chương 9 Đầu vào và đầu ra

Các phương thức được mô tả trong phần trước có thể được sử dụng để thực hiện I/O RAW với người dùng. Ví dụ: mã sau ghi vào đầu ra tiêu chuẩn và đọc một dòng đầu vào từ đầu vào tiêu chuẩn: nhập sys sys.stdout.write ["Nhập tên của bạn:"] name = sys.stdin.readline []

Ngoài ra, chức năng tích hợp RAW_INPUT [nhắc] có thể đọc một dòng văn bản từ stdin và in tùy chọn nhắc nhở: name = raw_input ["Nhập tên của bạn:"]

Các dòng được đọc bởi Raw_Input [] không bao gồm dòng mới. Điều này khác với việc đọc trực tiếp từ sys.stdin nơi các dòng mới được đưa vào văn bản đầu vào. Trong Python 3, Raw_Input [] đã được đổi tên thành Input []. Các ngắt bàn phím [thường được tạo bởi CTRL+C] dẫn đến ngoại lệ của bàn phím có thể bị bắt bằng cách sử dụng trình xử lý ngoại lệ. Nếu cần thiết, các giá trị của sys.stdout, sys.stdin và sys.stderr có thể được thay thế bằng các đối tượng tệp khác, trong trường hợp đó câu lệnh in và hàm đầu vào sử dụng các giá trị mới. Nếu cần phải khôi phục giá trị ban đầu của sys.stdout, nó nên được lưu trước. sys._ _stdin_ _ và sys._ _stderr_ _, tương ứng. Lưu ý rằng trong một số trường hợp, Sys.stdin, sys.stdout và sys.stderr có thể bị thay đổi bằng cách sử dụng môi trường phát triển tích hợp [IDE]. Ví dụ, khi Python được chạy theo Idle, Sys.stdin được thay thế bằng một đối tượng hoạt động giống như một tệp nhưng thực sự là một đối tượng trong môi trường phát triển. Trong trường hợp này, một số phương thức Lowlevel nhất định, chẳng hạn như Read [] và Seek [], có thể không khả dụng.

Câu lệnh in Python 2 sử dụng một câu lệnh in đặc biệt để tạo đầu ra trên tệp có trong sys.stdout. In chấp nhận danh sách các đối tượng được phân tách bằng dấu phẩy như sau: in "Các giá trị là", x, y, z

Đối với mỗi đối tượng, hàm str [] được gọi để tạo ra một chuỗi đầu ra. Các chuỗi đầu ra này sau đó được nối và phân tách bởi một không gian duy nhất để tạo ra chuỗi đầu ra cuối cùng. Tuyên bố in. Trong trường hợp này, câu lệnh in tiếp theo sẽ chèn một không gian trước khi in thêm các mục. Đầu ra của không gian này được điều khiển bởi thuộc tính seftspace của tệp được sử dụng cho đầu ra. In "Các giá trị là", x, y, z, w # in cùng một văn bản, sử dụng hai câu lệnh in in "Các giá trị là"

Để tạo ra đầu ra được định dạng, hãy sử dụng toán tử định dạng chuỗi [%] hoặc phương thức .format [] như được mô tả trong Chương 4, toán tử và biểu thức. Đây là một ví dụ: In "Các giá trị là %d %7,5f %s" %[x, y, z] # được định dạng I/O in "Các giá trị là {0: d} {1: 7.5f} {2}" .format [x, y, z]

H lib

Chương 9 Đầu vào và đầu ra

163

Hàm in [] Một trong những thay đổi quan trọng nhất trong Python 3 là bản in được biến thành một hàm. Trong Python 2.6, cũng có thể sử dụng in như một hàm nếu bạn bao gồm câu lệnh từ _ _future_ _ Nhập in_Function trong mỗi mô -đun khi sử dụng. Hàm in [] hoạt động gần như chính xác giống như câu lệnh in được mô tả trong phần trước. Để in một loạt các giá trị được phân tách bằng không gian, chỉ cần cung cấp tất cả để in [] như thế này: in ["Các giá trị là", x, y, z]

Để triệt tiêu hoặc thay đổi kết thúc dòng, hãy sử dụng đối số từ khóa kết thúc = kết thúc. Ví dụ: in ["Các giá trị là", x, y, z, end = '']

# Đàn áp dòng mới

Để chuyển hướng đầu ra sang tệp, hãy sử dụng đối số từ khóa File = Outfile. Ví dụ: in ["Các giá trị là", x, y, z, file = f]

# Chuyển hướng đến tệp đối tượng f

Để thay đổi ký tự phân cách giữa các mục, hãy sử dụng đối số từ khóa SEP = SEPCHR. Ví dụ: in ["Các giá trị là", x, y, z, sep = ',']

# Đặt dấu phẩy giữa các giá trị

Nội suy biến trong đầu ra văn bản Một vấn đề phổ biến khi tạo ra đầu ra là sản xuất các đoạn văn bản lớn có chứa các thay thế biến nhúng. Nhiều ngôn ngữ kịch bản như Perl và PHP cho phép các biến được chèn vào các chuỗi bằng cách sử dụng các thay thế biến đồng đô la [nghĩa là $ name, $ địa chỉ, v.v.]. Python không cung cấp tương đương trực tiếp với tính năng này, nhưng nó có thể được mô phỏng bằng cách sử dụng I/O được định dạng kết hợp với các chuỗi được trích dẫn ba. Ví dụ: bạn có thể viết một chữ cái biểu mẫu ngắn, điền vào tên, tên vật phẩm và số lượng, như được hiển thị trong ví dụ sau: # Lưu ý: Trailing Slash ngay sau "" "Ngăn chặn # một dòng trống xuất hiện dưới dạng Dòng đầu tiên Mẫu = "" "\ Dear %[Tên] S,

H lib

164

Chương 9 Đầu vào và đầu ra

Vui lòng gửi lại %[mục] của tôi hoặc trả cho tôi $ %[số tiền] 0,2f. Trân trọng của bạn, Joe Python Người dùng "" "In Form % {'name': 'Ông Bush', 'Item': 'Blender', 'Số tiền': 50.00,}

Điều này tạo ra đầu ra sau: Thưa ông Bush, xin vui lòng gửi lại máy xay của tôi hoặc trả cho tôi $ 50,00. Trân trọng của bạn, người dùng Joe Python

Phương thức định dạng [] là một giải pháp thay thế hiện đại hơn để làm sạch một số mã trước đó. Ví dụ: form = "" " Bush ', item =' Blender ', số tiền = 50.0]

Đối với một số loại biểu mẫu nhất định, bạn cũng có thể sử dụng chuỗi mẫu, như sau: Nhập chuỗi biểu mẫu = String.Template ["" " "" ".

Trong trường hợp này, các biến $ đặc biệt trong chuỗi chỉ ra sự thay thế. Phương thức form.subst acy [] có một từ điển thay thế và trả về một chuỗi mới. Mặc dù các phương pháp trước đây rất đơn giản, nhưng chúng không phải lúc nào cũng là giải pháp mạnh mẽ nhất để tạo văn bản. Khung Web và các khung ứng dụng lớn khác có xu hướng cung cấp các công cụ chuỗi mẫu của riêng họ hỗ trợ dòng điều khiển nhúng, thay thế thay đổi, bao gồm tệp và các công cụ khác các tính năng tiên tiến.

Tạo đầu ra làm việc trực tiếp với các tệp là mô hình I/O quen thuộc nhất với các lập trình viên. Tuy nhiên, các chức năng của máy phát cũng có thể được sử dụng để phát ra luồng I/O như một chuỗi các đoạn dữ liệu. Để làm điều này, chỉ cần sử dụng câu lệnh năng suất như bạn sẽ sử dụng câu lệnh Write [] hoặc in. Đây là một ví dụ:

H lib

Chương 9 Đầu vào và đầu ra

165

Điều này tạo ra đầu ra sau: Thưa ông Bush, xin vui lòng gửi lại máy xay của tôi hoặc trả cho tôi $ 50,00. Trân trọng của bạn, người dùng Joe Python

Đối với một số loại biểu mẫu nhất định, bạn cũng có thể sử dụng chuỗi mẫu, như sau: Nhập chuỗi biểu mẫu = String.Template ["" " "" ".

Đối với các chương trình định tuyến đầu ra cho các tệp hoặc kết nối mạng, cách tiếp cận của trình tạo cũng có thể dẫn đến giảm đáng kể việc sử dụng bộ nhớ vì toàn bộ luồng đầu ra thường có thể được tạo và xử lý trong các đoạn nhỏ thay vì được thu thập đầu tiên vào một chuỗi đầu ra lớn hoặc danh sách các chuỗi. Cách tiếp cận đầu ra này đôi khi được nhìn thấy khi viết các chương trình tương tác với giao diện Cổng dịch vụ web Python [WSGI] được sử dụng để giao tiếp giữa các thành phần trong một số khung web nhất định.

Chuỗi Unicode Xử lý một vấn đề chung liên quan đến xử lý I/O là xử lý các ký tự quốc tế được đại diện là Unicode. Nếu bạn có một chuỗi các byte thô có chứa biểu diễn được mã hóa của chuỗi unicode, hãy sử dụng phương thức s.decode [[mã hóa [, lỗi]]] để chuyển đổi nó thành chuỗi unicode thích hợp. Để chuyển đổi chuỗi unicode, u, u, Để một chuỗi byte được mã hóa, hãy sử dụng phương thức chuỗi U.enCode [[mã hóa [, lỗi]]]. Cả hai toán tử chuyển đổi này đều yêu cầu sử dụng tên mã hóa đặc biệt, chỉ định cách các giá trị ký tự unicode được ánh xạ tới một chuỗi các ký tự 8 bit trong chuỗi byte và ngược lại.

H lib

166

Chương 9 Đầu vào và đầu ra

và là một trong hơn một trăm mã hóa ký tự khác nhau. Tuy nhiên, các giá trị sau đây là phổ biến nhất: giá trị

Sự mô tả

'ASCII' 'Latin-1' hoặc 'ISO-8859-1'

ASCII 7-bit ISO 8859-1 Latin-1 Windows 1252 Mã hóa mã hóa biến đổi độ dài thay đổi 8 bit [có thể là ít hoặc lớn UTF-16, mã hóa endian nhỏ, mã hóa endian lớn Cùng một định dạng với unicode nghĩa đen u "chuỗi" cùng định dạng với unicode thô theo nghĩa đen của bạn "chuỗi"

'CP1252' 'UTF-8' 'UTF-16' 'UTF-16-LE' 'UTF-16-BE' 'Unicode-Escape' 'Raw-Unicode-Escape'

Mã hóa mặc định được đặt trong mô -đun trang web và có thể được truy vấn bằng sys.getDefaultEncoding []. Trong nhiều trường hợp, mã hóa mặc định là 'ASCII', có nghĩa là các ký tự ASCII có giá trị trong phạm vi [0x00,0x7F] được ánh xạ trực tiếp đến các ký tự Unicode trong phạm vi [U+0000, U+007F]. Tuy nhiên, 'UTF-8' cũng là một cài đặt rất phổ biến. Chi tiết kỹ thuật liên quan đến các mã hóa phổ biến xuất hiện trong một phần sau. Khi sử dụng phương thức s.decode [], người ta luôn cho rằng s là một chuỗi byte. Trong Python 2, điều này có nghĩa là S là một chuỗi tiêu chuẩn, nhưng trong Python 3, S phải là loại byte đặc biệt. Tương tự, kết quả của t.encode [] luôn luôn là một chuỗi byte. Một thận trọng nếu bạn quan tâm đến tính di động là các phương pháp này có một chút mờ nhạt trong Python 2. Ví dụ, chuỗi Python 2 có cả hai phương thức giải mã [] và mã hóa [], trong khi trong Python 3, chuỗi chỉ có phương thức mã hóa [] và Loại byte chỉ có phương thức decode []. Để đơn giản hóa mã trong python 2, đảm bảo bạn chỉ sử dụng encode [] trên chuỗi unicode và giải mã [] trên chuỗi byte. Khi các giá trị chuỗi đang được chuyển đổi, một ngoại lệ unicodeerror có thể được nâng lên nếu một ký tự có thể được chuyển đổi được chuyển đổi. Chẳng hạn, nếu bạn đang cố gắng mã hóa một chuỗi thành 'ASCII' và nó chứa một ký tự unicode như U+1F28, bạn sẽ gặp lỗi mã hóa vì giá trị ký tự này quá lớn để được biểu diễn trong bộ ký tự ASCII. tham số lỗi của các phương thức mã hóa [] và giải mã [] xác định cách xử lý lỗi mã hóa. Nó có một chuỗi với một trong các giá trị sau: Giá trị

Sự mô tả

'ASCII' 'Latin-1' hoặc 'ISO-8859-1'

'CP1252' 'UTF-8' 'UTF-16' 'UTF-16-LE' 'UTF-16-BE' 'Unicode-Escape' 'Raw-Unicode-Escape'

H lib

Chương 9 Đầu vào và đầu ra

167

và là một trong hơn một trăm mã hóa ký tự khác nhau. Tuy nhiên, các giá trị sau đây là phổ biến nhất: giá trị

Unicode I/O Khi làm việc với các chuỗi Unicode, không bao giờ có thể trực tiếp ghi dữ liệu Unicode thô vào một tệp. Đây là do các ký tự Unicode được biểu diễn bên trong như số nguyên đa tế bào và việc viết số nguyên đó trực tiếp vào luồng đầu ra gây ra Các vấn đề liên quan đến đặt hàng byte. Ví dụ: bạn sẽ phải quyết định tùy ý để ký tự UNICode U+HHLL được viết theo định dạng Little Little endian là chuỗi byte sẽ hoặc ở định dạng end endian endian là chuỗi byte hh ll. Hơn nữa, các công cụ khác mà quá trình unicode sẽ phải biết bạn đã sử dụng mã hóa nào. Do vấn đề này, biểu diễn bên ngoài của chuỗi Unicode luôn được thực hiện theo quy tắc mã hóa cụ thể xác định chính xác các ký tự unicode được biểu diễn như một chuỗi byte. Trong phần trước được mở rộng cho các tệp. Mô-đun codec tích hợp chứa một tập hợp các chức năng để chuyển đổi dữ liệu hướng byte sang và từ các chuỗi Unicode theo nhiều sơ đồ mã hóa dữ liệu khác nhau. Có lẽ cách đơn giản nhất để xử lý các tệp unicode là sử dụng hàm codecs.open [tên tệp [, chế độ [, mã hóa [, lỗi]]]] ',' utf-8 ',' nghiêm ngặt '] g = codecs.open [' bar.txt ',' w ',' utf-8 ']]

# Đọc viết

Điều này tạo ra một đối tượng tệp đọc hoặc ghi các chuỗi unicode. Tham số mã hóa chỉ định mã hóa ký tự cơ bản sẽ được sử dụng để dịch dữ liệu vì nó được đọc hoặc ghi vào tệp. Tham số lỗi xác định cách xử lý lỗi và là một trong số ' nghiêm ngặt ',' phớt lờ ',' thay thế ',' backslashreplace 'hoặc' xmlcharrefreplace 'như được mô tả trong phần trước. Nếu bạn đã có một đối tượng tệp, codecs.encodedfile [file, inputenc [, outputenc [, error]]] có thể được sử dụng để đặt một trình bao bọc mã hóa xung quanh nó. Ở đây, một ví dụ: f = open ["foo.txt", "rb"] ... fenc = codecs.encodedfile [f, 'UTF-8']

H lib

168

Chương 9 Đầu vào và đầu ra

Trong trường hợp này, dữ liệu được đọc từ tệp sẽ được giải thích theo mã hóa được cung cấp trong InputenC. Dữ liệu được ghi vào tệp sẽ được giải thích theo mã hóa trong InputenC và được viết theo mã hóa trong OutputenC. Nếu OutputenCenc bị bỏ qua, nó mặc định giống như InputenC. Lỗi có ý nghĩa tương tự như được mô tả trước đó. Khi đặt một trình bao bọc mã hóa xung quanh một tệp hiện có, hãy đảm bảo rằng tệp ở chế độ nhị phân. Nếu không, bản dịch mới có thể phá vỡ mã hóa. Khi bạn làm việc với các tệp Unicode, mã hóa dữ liệu thường được nhúng trong chính tệp. Ví dụ: trình phân tích cú pháp XML có thể xem xét một vài byte đầu tiên của chuỗi '' để xác định mã hóa tài liệu. Nếu bốn giá trị đầu tiên là 3C 3F 78 6D ['>>

Để khắc phục điều này, bạn có thể đặt biến môi trường pythonioencoding thành một cái gì đó như 'ASCII: Backslashreplace' hoặc 'UTF-8'. Bây giờ, bạn sẽ nhận được cái này: >>> a = 'jalape \ xf1o' >>> a 'jalape \ xf1o' >>>

Trên Windows, một số biến môi trường như PythonPath được đọc bổ sung từ các mục đăng ký được tìm thấy trong HKEY_LOCAL_MACHINE/phần mềm/Python.

Các phiên tương tác Nếu không có tên chương trình được đưa ra và đầu vào tiêu chuẩn cho trình thông dịch là một thiết bị đầu cuối tương tác, Python bắt đầu ở chế độ tương tác. Trong chế độ này, một thông báo biểu ngữ được in và người dùng được trình bày với lời nhắc. Ngoài ra, trình thông dịch đánh giá tập lệnh có trong biến môi trường PythonStartup [nếu SET]. Tập lệnh này được đánh giá như thể nó là một phần của chương trình đầu vào [nghĩa là nó được tải bằng cách sử dụng câu lệnh nhập]. Một ứng dụng của tập lệnh này có thể là đọc tệp cấu hình người dùng như .pythonrc. Khi đầu vào tương tác đang được chấp nhận, hai lời nhắc của người dùng sẽ xuất hiện. Lời nhắc >>> xuất hiện khi bắt đầu một câu lệnh mới; ... lời nhắc biểu thị một câu lệnh tiếp tục. Ở đây, một ví dụ: >>> cho tôi trong phạm vi [0,4]: ... In I, ... 0 1 2 3 >>>

H lib

Chương 9 Đầu vào và đầu ra

176

def my_display [x]: r = repr [x] nếu len [r]> 40: in [r [: 40]+"..."+r [-1]] khác: in [r] sys.displayhook = My_Display 3+4 Phạm vi [100000] 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 1 ...]

Cuối cùng, ở chế độ tương tác, rất hữu ích khi biết rằng kết quả của thao tác cuối cùng được lưu trữ trong một biến đặc biệt [_]. Biến này có thể được sử dụng để truy xuất kết quả nếu bạn cần sử dụng nó trong các hoạt động tiếp theo. Ở đây, một ví dụ: >>> 7 + 3 10 >>> _ + 2 12 >>>

Cài đặt của biến _ xảy ra trong hàm DisplayHook [] được hiển thị trước đó. Nếu bạn xác định lại DisplayHook [], chức năng thay thế của bạn cũng sẽ đặt _ nếu bạn muốn giữ lại chức năng đó.

Khởi chạy các ứng dụng Python Trong hầu hết các trường hợp, bạn sẽ muốn các chương trình tự động khởi động trình thông dịch, thay vì trước tiên phải bắt đầu trình thông dịch theo cách thủ công. Trên Unix, điều này được thực hiện bằng cách cấp cho phép chương trình thực thi và đặt dòng đầu tiên của chương trình thành một cái gì đó như thế này: #! ..

Trên Windows, nhấp đúp vào một tệp .py, .pyw, .wpy, .pyc hoặc .pyo tự động khởi chạy trình thông dịch. Thông thường, các chương trình chạy trong một cửa sổ bảng điều khiển trừ khi chúng được đổi tên bằng một hậu tố .pyw [trong trường hợp đó chương trình chạy im lặng]. Nếu nó cần thiết để cung cấp các tùy chọn cho trình thông dịch, Python cũng có thể được bắt đầu từ tệp .bat. Ví dụ: tệp .bat này chỉ cần chạy Python trên tập lệnh và chuyển bất kỳ tùy chọn nào được cung cấp trên dấu nhắc lệnh cho trình thông dịch: :: foo.bat :: chạy tập lệnh foo.py và chuyển các tùy chọn dòng lệnh được cung cấp theo [nếu có] C: \ python26 \ python.exe C: \ Pythonscripts \ foo.py %*

H lib

Gói trang web của người dùng

177

Các tệp cấu hình trang web Một cài đặt Python điển hình có thể bao gồm một số mô-đun và gói của bên thứ ba. Để định cấu hình các gói này, trình thông dịch đầu tiên nhập trang web mô-đun. Vai trò của trang web là tìm kiếm các tệp gói và thêm các thư mục bổ sung vào mô-đun tìm kiếm sys.path. Ngoài ra, mô -đun trang web đặt mã hóa mặc định cho các chuyển đổi chuỗi Unicode. Mô -đun trang web hoạt động bằng cách đầu tiên tạo một danh sách các tên thư mục được xây dựng từ các giá trị của sys.prefix và sys.exec_prefix như sau: [sys.prefix, # windows chỉ sys.exec_prefix, # windows chỉ sys.prefix /trang web-gói ', sys.prefix +' lib/site-python ', sys.exec_prefix +' lib/pythonvers/trang web trang web ', sys.exec_prefix +' lib/site-python ']]

Ngoài ra, nếu được bật, thư mục gói trang web dành riêng cho người dùng có thể được thêm vào danh sách này [được mô tả trong phần tiếp theo]. Đối với mỗi thư mục trong danh sách, một séc được thực hiện để xem liệu thư mục có tồn tại hay không. Nếu vậy, nó đã thêm vào biến sys.path. Tiếp theo, một kiểm tra được thực hiện để xem liệu nó có chứa bất kỳ tệp cấu hình đường dẫn nào không [các tệp có hậu tố .pth]. Tệp cấu hình đường dẫn chứa một danh sách các thư mục, tệp zip hoặc các tệp .egg liên quan đến vị trí của tệp đường dẫn nên được thêm vào sys.path. Ví dụ: # Foo Cấu hình gói tệp 'foo.pth' foo Bar

Mỗi thư mục trong tệp cấu hình đường dẫn phải được liệt kê trên một dòng riêng biệt. Nhận xét và các dòng trống bị bỏ qua. Khi mô -đun trang web tải tệp, nó kiểm tra xem mỗi thư mục có tồn tại hay không. Nếu vậy, thư mục được thêm vào sys.path. Các mục trùng lặp được thêm vào đường dẫn chỉ một lần. Sau khi tất cả các đường dẫn đã được thêm vào sys.Path, một nỗ lực được thực hiện để nhập một mô -đun có tên Sitecustomize. Mục đích của mô -đun này là thực hiện bất kỳ tùy chỉnh trang web bổ sung [và tùy ý] nào. Nếu việc nhập sitecustomize không thành công với một nhà nhập khẩu, lỗi âm thầm bị bỏ qua. Nhập Sitecustomize xảy ra trước khi thêm bất kỳ thư mục người dùng nào vào sys.path.SUS, việc đặt tệp này vào thư mục của riêng bạn không có hiệu lực. Mô -đun trang web cũng chịu trách nhiệm thiết lập mã hóa Unicode mặc định. Theo mặc định, mã hóa được đặt thành 'ASCII'. Tuy nhiên, mã hóa có thể được thay đổi bằng cách đặt mã trong sitecustomize.py gọi sys.setDefaultEncoding [] với mã hóa mới như 'UTF-8'. Nếu bạn sẵn sàng thử nghiệm, mã nguồn của trang web cũng có thể được sửa đổi để tự động đặt mã hóa dựa trên cài đặt địa phương của máy.

Thông thường, các gói trang web của người dùng, các mô-đun bên thứ ba được cài đặt theo cách giúp chúng có thể truy cập được cho tất cả người dùng. Tuy nhiên, người dùng cá nhân có thể cài đặt các mô-đun và gói trong thư mục trang web trên mỗi người dùng. Trên các hệ thống Unix và Macintosh, thư mục này được tìm thấy trong ~/.Local và được đặt tên là một cái gì đó như ~/.Local/lib/python2.6/trang web. Trên Windows Systems, thư mục này được xác định bởi biến môi trường % AppData %,

H lib

178

Chương 10 Môi trường thực hiện

Đây thường là một cái gì đó tương tự như C: \ Tài liệu và Cài đặt \ David Beazley \ Dữ liệu ứng dụng. Trong thư mục đó, bạn sẽ tìm thấy thư mục "Python \ Python26 \ Site-Packages". Nếu bạn đang viết các mô-đun và gói Python của riêng mình mà bạn muốn sử dụng trong thư viện, chúng có thể được đặt trong thư mục trang web trên mỗi người dùng. Nếu bạn đang cài đặt các mô-đun bên thứ ba, bạn có thể cài đặt chúng theo cách thủ công trong thư mục này bằng cách cung cấp tùy chọn --User để setup.py. Ví dụ: Cài đặt python setup.py.

Kích hoạt các tính năng trong tương lai Các tính năng ngôn ngữ mới ảnh hưởng đến khả năng tương thích với các phiên bản Python cũ hơn thường bị vô hiệu hóa khi chúng xuất hiện lần đầu tiên trong bản phát hành. Để có thể sử dụng các tính năng này, câu lệnh từ _ _future_ _ Nhập tính năng nhập có thể được sử dụng. Ở đây, một ví dụ: # Bật ngữ nghĩa phân chia mới từ _ _future_ _ Bộ phận nhập khẩu

Khi được sử dụng, câu lệnh này sẽ xuất hiện dưới dạng câu lệnh đầu tiên của một mô -đun hoặc chương trình. Hơn nữa, phạm vi nhập khẩu _ _future_ _ chỉ bị giới hạn ở mô -đun mà nó được sử dụng. Vì vậy, việc nhập một tính năng trong tương lai không ảnh hưởng đến hành vi của các mô -đun thư viện của Python hoặc mã cũ hơn yêu cầu hành vi trước đó của trình thông dịch để vận hành chính xác. Hiện tại, các tính năng sau đã được xác định: Bảng 10.3

Tên tính năng trong mô -đun _ _future_ _

Tên tính năng

Sự mô tả

Nested_scopes

Hỗ trợ cho phạm vi lồng nhau trong các chức năng. Được giới thiệu lần đầu tiên trong Python 2.1 và thực hiện hành vi mặc định trong Python 2.2. Hỗ trợ cho máy phát điện. Được giới thiệu lần đầu tiên trong Python 2.2 và thực hiện hành vi mặc định trong Python 2.3. Phân chia được sửa đổi ngữ nghĩa nơi phân chia số nguyên trả về kết quả phân số. Ví dụ: 1/4 mang lại 0,25 thay vì 0. lần đầu tiên được giới thiệu trong Python 2.2 và vẫn là một tính năng tùy chọn như Python 2.6. Đây là hành vi mặc định trong Python 3.0. Hành vi sửa đổi của nhập khẩu liên quan đến gói. Hiện tại, khi một mô hình con của một gói tạo ra một câu lệnh nhập như Chuỗi nhập, trước tiên nó nhìn vào thư mục hiện tại của gói và sau đó là thư mục trong sys.path. Tuy nhiên, điều này làm cho không thể tải các mô -đun trong thư viện tiêu chuẩn nếu một gói tình cờ sử dụng các tên mâu thuẫn. Khi tính năng này được bật, mô -đun nhập câu lệnh là nhập tuyệt đối. Do đó, một câu lệnh như chuỗi nhập sẽ luôn tải mô -đun chuỗi từ thư viện tiêu chuẩn. Được giới thiệu lần đầu tiên trong Python 2.5 và vẫn bị vô hiệu hóa trong Python 2.6. Nó được kích hoạt trong Python 3.0. Hỗ trợ cho các nhà quản lý bối cảnh và tuyên bố với. Được giới thiệu lần đầu tiên trong Python 2.5 và được bật theo mặc định trong Python 2.6. Sử dụng hàm python 3.0 print [] thay vì câu lệnh in. Được giới thiệu lần đầu tiên trong Python 2.6 và được bật theo mặc định trong Python 3.0.

Bộ phận máy phát điện

Tuyệt đối_Import

với_statement print_function

H lib

Chương 10 Môi trường thực hiện

179

One final peculiarity about program termination is that the _ _del_ _ method for some objects may try to access global data or methods defined in other modules. Because these objects may already have been destroyed, a NameError exception occurs in _ _del_ _, and you may get an error such as the following: Exception exceptions.NameError: 'c' in ignored

If this occurs, it means that _ _del_ _ has aborted prematurely. It also implies that it may have failed in an attempt to perform an important operation [such as cleanly shutting down a server connection]. If this is a concern, it’s probably a good idea to perform an explicit shutdown step in your code, rather than rely on the interpreter to destroy objects cleanly at program termination.The peculiar NameError exception can also be

h Lib

180

Chapter 10 Execution Environment

eliminated by declaring default arguments in the declaration of the _ _del_ _[] method: import foo class Bar[object]: def _ _del_ _[self, foo=foo]: foo.bar[] # Use something in module foo

In some cases, it may be useful to terminate program execution without performing any cleanup actions.This can be accomplished by calling os._exit[status].This function provides an interface to the low-level exit[] system call responsible for killing the Python interpreter process.When it’s invoked, the program immediately terminates without any further processing or cleanup.

h Lib

11 Testing, Debugging, Profiling, and Tuning U

nlike programs in languages such as C or Java, Python programs are not processed by a compiler that produces an executable program. In those languages, the compiler is the first line of defense against programming errors—catching mistakes such as calling functions with the wrong number of arguments or assigning improper values to variables [that is, type checking]. In Python, however, these kinds of checks do not occur until a program runs. Because of this, you will never really know if your program is correct until you run and test it. Not only that, unless you are able to run your program in a way that executes every possible branch of its internal control-flow, there is always some chance of a hidden error just waiting to strike [fortunately, this usually only happens a few days after shipping, however]. To address these kinds of problems, this chapter covers techniques and library modules used to test, debug, and profile Python code. At the end, some strategies for optimizing Python code are discussed.

Documentation Strings and the doctest Module If the first line of a function, class, or module is a string, that string is known as a documentation string.The inclusion of documentation strings is considered good style because these strings are used to supply information to Python software development tools. For example, the help[] command inspects documentation strings, and Python IDEs look at the strings as well. Because programmers tend to view documentation strings while experimenting in the interactive shell, it is common for the strings to include short interactive examples. For example: # splitter.py def split[line, types=None, delimiter=None]: """Splits a line of text and optionally performs type conversion. For example: >>> split['GOOG 100 490.50'] ['GOOG', '100', '490.50'] >>> split['GOOG 100 490.50',[str, int, float]] ['GOOG', 100, 490.5] >>>

h Lib

182

Chapter 11 Testing, Debugging, Profiling, and Tuning

By default, splitting is performed on whitespace, but a different delimiter can be selected with the delimiter keyword argument: >>> split['GOOG,100,490.50',delimiter=','] ['GOOG', '100', '490.50'] >>> """ fields = line.split[delimiter] if types: fields = [ ty[val] for ty,val in zip[types,fields] ] return fields

A common problem with writing documentation is keeping the documentation synchronized with the actual implementation of a function. For example, a programmer might modify a function but forget to update the documentation. To address this problem, use the doctest module. doctest collects documentation strings, scans them for interactive sessions, and executes them as a series of tests.To use doctest, you typically create a separate module for testing. For example, if the previous function is in a file splitter.py, you would create a file testsplitter.py for testing, as follows: # testsplitter.py import splitter import doctest nfail, ntests = doctest.testmod[splitter]

In this code, the call to doctest.testmod[module] runs tests on the specified module and returns the number of failures and total number of tests executed. No output is produced if all of the tests pass. Otherwise, you will get a failure report that shows the difference between the expected and received output. If you want to see verbose output of the tests, you can use testmod[module, verbose=True]. As an alternative to creating a separate testing file, library modules can test themselves by including code such as this at the end of the file: ... if _ _name_ _ == '_ _main_ _': # test myself import doctest doctest.testmod[]

Với mã này, các thử nghiệm tài liệu sẽ chạy nếu tệp được chạy làm chương trình chính cho trình thông dịch. Mặt khác, các thử nghiệm bị bỏ qua nếu tệp được tải với nhập. DocTest mong đợi đầu ra của các chức năng phù hợp với đầu ra chính xác mà bạn nhận được trong trình thông dịch tương tác. Kết quả là, nó khá nhạy cảm với các vấn đề về không gian trắng và độ chính xác số. Ví dụ, hãy xem xét chức năng này: def Half [x]: "" "Halves x.

Ví dụ:

>>> Một nửa [6.8] 3.4 >>> "" "Return X/2

H lib

Kiểm tra đơn vị và mô -đun nhất

183

Nếu bạn chạy tài liệu về chức năng này, bạn sẽ nhận được một báo cáo thất bại như thế này: ****** / TÌM HIỂU ****** / TÌM _main_ _.half Ví dụ thất bại: một nửa [6.8] Dự kiến: 3.4 Got: 3.39999999999999 ****** / TÌM HIỂU

Để khắc phục điều này, bạn cần phải làm cho tài liệu chính xác khớp với đầu ra hoặc cần chọn một ví dụ tốt hơn trong tài liệu. Bởi vì sử dụng DocTest gần như tầm thường, hầu như không có lý do gì để không sử dụng nó với các chương trình của riêng bạn. Tuy nhiên, hãy nhớ rằng DocTest không phải là một mô -đun mà bạn thường sử dụng để thử nghiệm chương trình đầy đủ. Làm như vậy có xu hướng dẫn đến các chuỗi tài liệu quá dài và phức tạp, điều này đánh bại điểm sản xuất tài liệu hữu ích [ví dụ: người dùng có thể sẽ khó chịu nếu anh ta yêu cầu trợ giúp và tài liệu liệt kê 50 ví dụ bao gồm tất cả các loại trường hợp khó khăn]. Đối với loại thử nghiệm này, bạn muốn sử dụng mô -đun Unittest. Cuối cùng, mô -đun tài liệu nhất có một số lượng lớn các tùy chọn cấu hình liên quan đến các khía cạnh khác nhau của cách thực hiện thử nghiệm và cách báo cáo kết quả. Bởi vì các tùy chọn này không bắt buộc cho việc sử dụng mô -đun phổ biến nhất, chúng không được đề cập ở đây. Tham khảo ý kiến //docs.python.org/l Library/doctest.html để biết thêm chi tiết.

Kiểm tra đơn vị và mô -đun Unittest để thử nghiệm chương trình đầy đủ hơn, hãy sử dụng mô -đun Unittest. Với thử nghiệm đơn vị, một nhà phát triển viết một tập hợp các trường hợp kiểm tra bị cô lập cho mỗi yếu tố tạo nên một chương trình [ví dụ: các chức năng, phương pháp, lớp học riêng lẻ và lớp Các mô -đun]. Các thử nghiệm này sau đó được chạy để xác minh hành vi chính xác của các khối xây dựng cơ bản tạo nên các chương trình lớn hơn. Khi các chương trình phát triển về kích thước, các thử nghiệm đơn vị cho các thành phần khác nhau có thể được kết hợp để tạo ra các khung thử nghiệm lớn và các công cụ kiểm tra. Điều này có thể đơn giản hóa rất nhiều nhiệm vụ xác minh hành vi chính xác cũng như cách ly và khắc phục các vấn đề khi chúng xảy ra. Việc sử dụng mô -đun này có thể được minh họa bằng danh sách mã trong phần trước: # splitter.py def split [line, type = none, delimiter = none]: "" "chia một dòng văn bản và tùy chọn thực hiện chuyển đổi loại. .. .. ""

H lib

184

Kiểm tra đơn vị và mô -đun nhất

Được gọi để thực hiện các bước thiết lập trước khi chạy bất kỳ phương pháp kiểm tra nào. t.teardown []

Được gọi để thực hiện các hành động dọn dẹp sau khi chạy các bài kiểm tra.

H lib

Kiểm tra đơn vị và mô -đun nhất

185

T.ASSERT_ [expr [, msg]] t.failunless [expr [, msg]]

Báo hiệu một lỗi kiểm tra nếu expr đánh giá là sai. MSG là một chuỗi tin nhắn đưa ra một lời giải thích cho sự thất bại [nếu có]. T.assertequal [X, Y [, MSG]] T.Failunlessequal [X, Y [, MSG]]

Tín hiệu lỗi kiểm tra nếu x và y không bằng nhau. MSG là một thông điệp giải thích sự thất bại [nếu có]. T.assertNotequal [x, y [, msg]] t.failifequal [x, y, [, msg]]

Tín hiệu thất bại kiểm tra nếu x và y bằng nhau. MSG là một thông điệp giải thích sự thất bại [nếu có]. T.Assertal gần như [x, y [, địa điểm [, msg]]]

Tín hiệu lỗi kiểm tra nếu số x và y không ở trong số các vị trí thập phân của nhau. Điều này được kiểm tra bằng cách tính toán chênh lệch của x và y và làm tròn kết quả đến số lượng vị trí đã cho. Nếu kết quả bằng không, x và y gần như bằng nhau. MSG là một thông điệp giải thích sự thất bại [nếu có]. T.assertnotal gần như [x, y, [, địa điểm [, msg]]]

Tín hiệu thất bại thử nghiệm nếu X và Y ít nhất là các vị trí thập phân. MSG là một thông điệp giải thích sự thất bại [nếu có]. T.Assertraise [exc, callable, ...] T.Failunlessraiese [exc, callable, ...]

Tín hiệu lỗi kiểm tra nếu đối tượng có thể gọi được có thể gọi không tăng ngoại lệ Exc. Các đối số còn lại được thông qua dưới dạng đối số cho có thể gọi được. Nhiều trường hợp ngoại lệ có thể được kiểm tra bằng cách sử dụng một bộ ngoại lệ như Exc. T.Failif [expr [, MSG]]

Tín hiệu thất bại kiểm tra nếu expr đánh giá là đúng. MSG là một thông điệp giải thích sự thất bại [nếu có]. T.Fail [[MSG]]

Báo hiệu một lỗi kiểm tra. MSG là một thông điệp giải thích sự thất bại [nếu có]. T.FailureException

Thuộc tính này được đặt thành giá trị ngoại lệ cuối cùng bị bắt trong một thử nghiệm. Điều này có thể hữu ích nếu bạn không chỉ muốn kiểm tra xem ngoại lệ có được nêu ra không, nhưng ngoại lệ sẽ tăng giá trị thích hợp, ví dụ, nếu bạn muốn kiểm tra lỗi Tin nhắn được tạo ra như một phần của việc nâng cao một ngoại lệ.

H lib

186

Kiểm tra đơn vị và mô -đun nhất

T.ASSERT_ [expr [, msg]] t.failunless [expr [, msg]]

Tín hiệu lỗi kiểm tra nếu x và y không bằng nhau. MSG là một thông điệp giải thích sự thất bại [nếu có]. T.assertNotequal [x, y [, msg]] t.failifequal [x, y, [, msg]]

Tín hiệu thất bại kiểm tra nếu x và y bằng nhau. MSG là một thông điệp giải thích sự thất bại [nếu có]. T.Assertal gần như [x, y [, địa điểm [, msg]]]

Tín hiệu thất bại kiểm tra nếu expr đánh giá là đúng. MSG là một thông điệp giải thích sự thất bại [nếu có]. T.Fail [[MSG]]

H lib

Trình gỡ lỗi Python và mô -đun PDB

187

Các lệnh gỡ lỗi khi trình gỡ lỗi bắt đầu, nó trình bày một lời nhắc [pdb] như sau: >>> nhập pdb >>> nhập buggymodule >>> pdb.run ['buggymodule.start []']> [0]? [ ] [PDB]

[PDB] là lời nhắc trình gỡ lỗi mà tại đó các lệnh sau được nhận dạng. Ghi chú

rằng một số lệnh có một hình thức ngắn và dài. Trong trường hợp này, dấu ngoặc đơn được sử dụng để chỉ ra cả hai hình thức. Ví dụ, H [ELP] có nghĩa là H hoặc trợ giúp được chấp nhận. [!]bản tường trình

Thực thi câu lệnh [một dòng] trong bối cảnh của khung ngăn xếp hiện tại. Điểm nhấn dấu có thể bị bỏ qua, nhưng nó phải được sử dụng để tránh sự mơ hồ nếu từ đầu tiên của câu lệnh giống như lệnh gỡ lỗi. Để đặt biến toàn cầu, Bạn có thể tiền tố lệnh gán với lệnh toàn cầu trên cùng một dòng: [pdb] toàn cầu list_options; list_options = ['-l'] [pdb] a [rgs]

In danh sách đối số của hàm hiện tại. Bí danh [Tên [Lệnh]]

Tạo một bí danh được gọi là tên thực thi lệnh. Trong chuỗi lệnh, chuỗi con '%1', '%2', v.v. được thay thế bằng các tham số khi bí danh được gõ. '%*' được thay thế bằng tất cả các tham số. Nếu không có lệnh nào được đưa ra, danh sách bí danh hiện tại được hiển thị. Bí danh có thể được lồng và có thể chứa bất cứ thứ gì có thể được gõ hợp pháp tại dấu nhắc PDB. Dưới đây là một ví dụ: # PRIN INSTANCE Biến [cách sử dụng "pi classinst"] bí danh pi cho k in%1._ _dict_ _.keys []: in "%1.", K, "=",%1._dict_ _ .

Đặt điểm dừng tại vị trí loc. LoC chỉ định tên tệp và số dòng cụ thể hoặc là tên của hàm trong mô -đun. Cú pháp sau được sử dụng: Cài đặt

Sự mô tả

N FILENAME: n Mô -đun chức năng.Function

A a a

Số dòng trong số dòng tệp hiện tại trong tên chức năng tệp khác trong tên hàm mô -đun hiện tại trong mô -đun

Nếu LỘC bị bỏ qua, tất cả các điểm dừng hiện tại được in. Điều kiện là một biểu thức phải đánh giá đúng trước khi điểm dừng được tôn vinh. Tất cả các điểm dừng được chỉ định

H lib

188

Trình gỡ lỗi Python và mô -đun PDB

[PDB] là lời nhắc trình gỡ lỗi mà tại đó các lệnh sau được nhận dạng. Ghi chú

In danh sách đối số của hàm hiện tại. Bí danh [Tên [Lệnh]]

Đặt điểm dừng tại vị trí loc. LoC chỉ định tên tệp và số dòng cụ thể hoặc là tên của hàm trong mô -đun. Cú pháp sau được sử dụng: Cài đặt

Sự mô tả

N FILENAME: n Mô -đun chức năng.Function

A a a

Số dòng trong số dòng tệp hiện tại trong tên chức năng tệp khác trong tên hàm mô -đun hiện tại trong mô -đun

H lib

Trình gỡ lỗi Python và mô -đun PDB

189

[PDB] là lời nhắc trình gỡ lỗi mà tại đó các lệnh sau được nhận dạng. Ghi chú

In danh sách đối số của hàm hiện tại. Bí danh [Tên [Lệnh]]

Chạy cho đến khi hàm hiện tại trả về. chạy [args]

Khởi động lại chương trình và sử dụng các đối số dòng lệnh trong Args làm cài đặt mới của sys.argv. Tất cả các điểm dừng và cài đặt trình gỡ lỗi khác được bảo tồn. bươc]

Thực hiện một dòng nguồn duy nhất và dừng bên trong các chức năng được gọi là. tbreak [loc [, điều kiện]]

Đặt một điểm dừng tạm thời mà đã loại bỏ sau lần đánh đầu tiên. lên]

Di chuyển khung hiện tại một cấp trong dấu vết ngăn xếp. Tên Unalias

Xóa bí danh được chỉ định. cho đến khi

Tiếp tục thực thi cho đến khi điều khiển rời khỏi khung thực thi hiện tại hoặc cho đến khi đạt được số dòng lớn hơn số dòng hiện tại. Ví dụ: nếu trình gỡ lỗi bị dừng ở dòng cuối cùng trong một thân vòng, gõ cho đến khi sẽ thực thi tất cả các câu lệnh trong vòng lặp cho đến khi vòng lặp kết thúc. ở đâu]

In một dấu vết ngăn xếp.

Gỡ lỗi từ dòng lệnh Một phương pháp thay thế để chạy trình gỡ lỗi là gọi nó trên dòng lệnh. Dưới đây là một ví dụ: % python -m pdb somePramram.py

H lib

190

Chương 11 Thử nghiệm, gỡ lỗi, hồ sơ và điều chỉnh

Trong trường hợp này, trình gỡ lỗi được khởi chạy tự động khi bắt đầu khởi động chương trình, nơi bạn được tự do đặt các điểm dừng và thực hiện các thay đổi cấu hình khác. Để thực hiện chương trình, chỉ cần sử dụng lệnh tiếp tục. Ví dụ: nếu bạn muốn gỡ lỗi chức năng chia [] từ trong một chương trình đã sử dụng nó, bạn có thể làm điều này: % pythonTHERM PDB someProgram.py> /Users/beazley/code/someprogram.py [1] [] -> Nhập bộ chia [PDB] b Splitter.Split Breakpoint 1 at /Users = line.split [Delimiter] [PDB]

Định cấu hình trình gỡ lỗi nếu tệp .pdbrc tồn tại trong thư mục nhà của người dùng hoặc trong thư mục hiện tại, nó được đọc và thực thi như thể nó đã được nhập vào dấu nhắc trình gỡ lỗi. Điều này có thể hữu ích để chỉ định các lệnh gỡ lỗi mà bạn muốn thực thi Thời gian trình gỡ lỗi được bắt đầu [trái ngược với việc phải gõ các lệnh tương tác mỗi lần].

Chương trình Hồ sơ hồ sơ và các mô -đun CPROFILE được sử dụng để thu thập thông tin định hình. Cả hai mô -đun đều hoạt động theo cùng một cách, nhưng CPROFILE được triển khai như một phần mở rộng C, nhanh hơn đáng kể và hiện đại hơn. Một mô -đun được sử dụng để thu thập cả thông tin bảo hiểm [nghĩa là các chức năng được thực thi] cũng như thống kê hiệu suất. Cách dễ nhất để lập trình một chương trình là thực thi nó từ dòng lệnh như sau: % python -m cprofile someProgrogram.py

Ngoài ra, chức năng sau trong mô -đun hồ sơ có thể được sử dụng: chạy [lệnh [, tên tệp]]

Thực thi nội dung của lệnh bằng cách sử dụng câu lệnh EXEC trong hồ sơ. Tên tệp là tên của một tệp trong đó dữ liệu hồ sơ thô được lưu. Nếu nó bị bỏ qua, một báo cáo được in ra đầu ra tiêu chuẩn. Kết quả của việc chạy Profiler là một báo cáo như sau: 126 cuộc gọi chức năng [6 cuộc gọi nguyên thủy] trong 5.130 CPU giây được đặt hàng bởi: Tên tiêu chuẩn NCALLS TOTTIME PERCALL CUMTIME PERCALL FILE ?] 121/1 5.020 0.041 5.020 5.020 Book.py:11[Process] 1 0,020 0.020 5.040 5.040 Book.Py:5 [?] Hồ sơ: 0 [Execfile ['Book.py']] 0 0.000 0.000 Cấu hình: 0 [Profiler]

Các phần khác nhau của báo cáo được tạo bởi Run [] được giải thích như sau:

H lib

Chương 11 Thử nghiệm, gỡ lỗi, hồ sơ và điều chỉnh

191

Ngoài ra, chức năng sau trong mô -đun hồ sơ có thể được sử dụng: chạy [lệnh [, tên tệp]]

Thực hiện các phép đo thời gian Nếu bạn đơn giản muốn thời gian một chương trình Python dài, cách dễ nhất để làm điều đó thường chỉ là chạy nó cho đến khi kiểm soát một thứ như lệnh thời gian Unix. Ngoài ra, nếu bạn có một khối các tuyên bố dài mà bạn muốn thời gian, bạn có thể chèn các cuộc gọi vào Time.Clock [] để đọc hiện tại về thời gian CPU đã qua -Clock thời gian. Ví dụ: start_cpu = Time.Clock [] start_real = Time.time [] Câu lệnh end_cpu = Time.clock [] end_real = Time.time [] in [" % f thực sự" % [end_real - start_real]] " % f CPU Seconds" % [end_cpu - start_cpu]]

Hãy ghi nhớ rằng kỹ thuật này thực sự chỉ hoạt động nếu mã được hẹn giờ chạy trong một khoảng thời gian hợp lý. Nếu bạn có một câu lệnh chi tiết mà bạn muốn điểm chuẩn, bạn có thể sử dụng hàm timeit [mã [, setup]] trong mô-đun thời gian. Ví dụ: >>> Từ thời gian nhập thời gian thời gian >>> timeit ['math.sqrt [2.0]', 'nhập khẩu'] 0.20388007164001465 >>> thời gian

H lib

192

Chương 11 Thử nghiệm, gỡ lỗi, hồ sơ và điều chỉnh

Trong ví dụ này, đối số đầu tiên cho timeit [] là mã bạn muốn điểm chuẩn. Đối số thứ hai là một tuyên bố được thực thi một lần để thiết lập môi trường thực thi. Hàm timeit [] chạy câu lệnh được cung cấp một triệu lần và báo cáo thời gian thực hiện. đối số từ khóa đến thời gian []. Mô -đun thời gian cũng có hàm lặp lại [] có thể được sử dụng để thực hiện các phép đo. Hàm này hoạt động giống như thời gian [] ngoại trừ việc lặp lại phép đo thời gian ba lần và trả về danh sách kết quả. Ví dụ: >>> từ Nhập thời gian lặp lại >>> lặp lại ['Math.sqrt [2.0]', 'nhập khẩu'] [0.20306601524353027, 0.19715800285339355, 0.2090739250181055] >>>

Khi thực hiện đo lường hiệu suất, người ta thường chỉ tham khảo SpeedUp liên quan, thường đề cập đến thời gian thực hiện ban đầu chia cho thời gian thực hiện mới. Ví dụ, trong các phép đo thời gian trước đó, sử dụng SQRT [2.0] thay vì Math.sqrt [2.0] biểu thị tốc độ tăng tốc 0,20388/0.14494 hoặc khoảng 1,41. Đôi khi điều này được báo cáo dưới dạng phần trăm bằng cách nói rằng tốc độ tăng tốc là khoảng 41 phần trăm.

Tạo các phép đo bộ nhớ Mô -đun SYS có hàm getsizeof [] có thể được sử dụng để điều tra dấu chân bộ nhớ [tính bằng byte] của các đối tượng python riêng lẻ. Ví dụ: >>> >>> 14 >>> 52 >>> 52 >>> 56

Nhập sys sys.getsizeOf [1] sys.getsizeOf ["Hello World"] sys.getsizeOf [[1,2,3,4]] Sum [sys.getSizeOf [x] cho x trong [1,2,3,4 ]]

Đối với các thùng chứa như danh sách, bộ dữ liệu và từ điển, kích thước được báo cáo chỉ dành cho chính đối tượng container, chứ không phải kích thước tích lũy của tất cả các đối tượng có bên trong nó. Ví dụ, trong ví dụ trước, kích thước được báo cáo của danh sách [1,2,3,4] thực sự nhỏ hơn không gian cần thiết cho bốn số nguyên [mỗi số là 14 byte]. Đây là vì nội dung của danh sách là Không bao gồm trong tổng số. Bạn có thể sử dụng sum [] như được hiển thị ở đây để tính tổng kích thước của nội dung danh sách. Xin lưu ý rằng hàm getSizeof [] sẽ chỉ cung cấp cho bạn một ý tưởng sơ bộ về việc sử dụng bộ nhớ tổng thể cho các đối tượng khác nhau. Trong nội bộ, thông dịch viên tích cực chia sẻ các đối tượng thông qua việc đếm tham chiếu để bộ nhớ thực tế được tiêu thụ bởi một đối tượng có thể ít hơn nhiều so với bạn tưởng tượng đầu tiên. Ngoài ra, do các phần mở rộng C cho Python có thể phân bổ bộ nhớ bên ngoài trình thông dịch Trình xem quá trình hệ thống hoặc Trình quản lý tác vụ. Thành thật mà nói, một cách tốt hơn để xử lý việc sử dụng bộ nhớ có thể là ngồi xuống và phân tích về nó. Nếu bạn biết chương trình của bạn sẽ phân bổ các loại cấu trúc dữ liệu khác nhau và bạn biết loại dữ liệu nào sẽ được lưu trữ trong các cấu trúc đó [nghĩa là INT, phao, chuỗi, v.v.], bạn có thể sử dụng kết quả của getsizeof [] chức năng để

H lib

Chương 11 Thử nghiệm, gỡ lỗi, hồ sơ và điều chỉnh

193

15 load_global 18 jump_if_false 21 pop_top

22 25 26 29 32 35 38 41 42 45 48 51 54 57 60 63 66 67 70 73 76 79

>> 5

Build_list DUP_TOP Store_Fast Load_Global Load_Global Load_Fast Call_Function get_ITER FOR_ITER unpack_singence store_fast store_fast load_fast load_fast call_function list_append jump_absolute xóa

80 load_fast 83 return_value

0 0 1 1 2

[dòng] [chia] [DELIMITER] [Trường]

1 [loại] 58 [đến 79]

0 3 2 1 2 2

[_ [1]] [zip] [loại] [trường]

25 2 4 5 3 4 5 1

[đến 70] [TY] [Val] [_ [1]] [Ty] [Val]

42 3 [_ [1]] 2 [trường] 1 [đến 80]

2 [Trường]

>>>

Các lập trình viên chuyên gia có thể sử dụng thông tin này theo hai cách. Đầu tiên, một sự tháo gỡ sẽ cho bạn thấy chính xác những hoạt động nào liên quan đến việc thực hiện một chức năng. Với nghiên cứu cẩn thận, bạn có thể phát hiện ra các cơ hội để thực hiện tăng tốc. Thứ hai, nếu bạn đang lập trình với các chủ đề, mỗi dòng được in trong việc tháo gỡ đại diện cho một hoạt động phiên dịch duy nhất trong số đó có thực thi nguyên tử. Vì vậy, nếu bạn đang cố gắng theo dõi một điều kiện đua khó khăn, thông tin này có thể hữu ích.

H lib

194

Chương 11 Thử nghiệm, gỡ lỗi, hồ sơ và điều chỉnh

Các chiến lược điều chỉnh Các phần sau đây phác thảo một vài chiến lược tối ưu hóa, theo ý kiến của tác giả, đã được chứng minh là hữu ích với mã Python.

Hiểu chương trình của bạn trước khi bạn tối ưu hóa bất cứ điều gì, hãy biết rằng SpeedUp có được bằng cách tối ưu hóa một phần của chương trình có liên quan trực tiếp đến phần đóng góp của phần đó vào thời gian thực hiện. Ví dụ: nếu bạn tối ưu hóa một chức năng bằng cách làm cho nó chạy nhanh gấp 10 lần nhưng chức năng đó chỉ đóng góp tới 10%tổng thời gian thực hiện của chương trình, bạn sẽ chỉ tăng tốc độ tăng tốc khoảng 9%10%. Tùy thuộc vào nỗ lực liên quan đến việc thực hiện tối ưu hóa, điều này có thể hoặc không xứng đáng. Luôn luôn là một ý tưởng tốt để sử dụng mô -đun định hình trên mã mà bạn dự định tối ưu hóa. Bạn thực sự chỉ muốn tập trung vào các chức năng và phương pháp trong đó chương trình của bạn dành phần lớn thời gian của nó, không phải là hoạt động tối nghĩa chỉ được gọi là.

Hiểu các thuật toán Một thuật toán O [n log n] được thực hiện kém sẽ vượt trội hơn thuật toán O [N3] được điều chỉnh tốt nhất. Don Tiết tối ưu hóa các thuật toán không hiệu quả trước tiên tìm kiếm một thuật toán tốt hơn.

Sử dụng các loại hình, danh sách, bộ và từ điển tích hợp của Python được triển khai hoàn toàn trong C và là cấu trúc dữ liệu được điều chỉnh tinh xảo nhất trong trình thông dịch. Bạn nên chủ động sử dụng các loại này để lưu trữ và thao tác dữ liệu trong chương trình của bạn và chống lại sự thôi thúc xây dựng các cấu trúc dữ liệu tùy chỉnh của riêng bạn bắt chước chức năng của chúng [nghĩa là các cây tìm kiếm nhị phân, danh sách được liên kết, v.v.]. Phải nói rằng, bạn vẫn nên xem xét kỹ hơn các loại trong thư viện tiêu chuẩn. Một số mô-đun thư viện cung cấp các loại mới vượt trội so với các công việc xây dựng ở một số nhiệm vụ nhất định. Chẳng hạn, loại thu gom.deque cung cấp chức năng tương tự như một danh sách nhưng đã được tối ưu hóa cao để chèn các mục mới ở cả hai đầu. Một danh sách, ngược lại, chỉ hiệu quả khi kết thúc các mục ở cuối. Nếu bạn chèn các mục ở phía trước, tất cả các yếu tố khác cần phải được thay đổi để tạo phòng. Thời gian cần thiết để thực hiện điều này phát triển khi danh sách ngày càng lớn hơn. Chỉ để cung cấp cho bạn một ý tưởng về sự khác biệt, đây là một phép đo thời gian chèn một triệu mục ở phía trước danh sách và một deque: >>> từ thời gian nhập thời gian >>> thời gian ['S.Appendleft [37]' , ... 'Bộ sưu tập nhập; 1000000] 612.95199513435364

H lib

195

Chương 11 Thử nghiệm, gỡ lỗi, hồ sơ và điều chỉnh

Nếu chương trình của bạn tạo ra hàng triệu từ điển khi nó chạy, thì bạn nên biết rằng cách tiếp cận đầu tiên nhanh hơn. Với một số ngoại lệ, bất kỳ tính năng nào thêm tăng cường hoặc thay đổi cách thức mà đối tượng Python hiện tại hoạt động sẽ chạy chậm hơn.

Biết cách các lớp và trường hợp xây dựng dựa trên các lớp và trường hợp do người dùng xác định từ điển được xây dựng bằng từ điển. Bởi vì điều này, các hoạt động tra cứu, đặt hoặc xóa dữ liệu phiên bản hầu như luôn luôn chạy chậm hơn so với trực tiếp thực hiện các hoạt động này trên từ điển. Nếu tất cả những gì bạn đang làm là xây dựng một cấu trúc dữ liệu đơn giản để lưu trữ dữ liệu, từ điển có thể là một lựa chọn hiệu quả hơn so với việc xác định một lớp. Chỉ để minh họa sự khác biệt, đây là một lớp đơn giản thể hiện sự nắm giữ của cổ phiếu: cổ phiếu lớp [đối tượng]: def _ _init_ _ [self, name, cổ phiếu, giá]: self.name = name self.shares = chia sẻ bản thân. Giá = Giá

Nếu bạn so sánh hiệu suất của việc sử dụng lớp này với từ điển, kết quả rất thú vị. Đầu tiên, hãy so sánh hiệu suất của việc tạo các trường hợp đơn giản: >>> từ thời gian nhập thời gian >>> thời gian ["s = stock ['goog', 100.490.10]" s = {'name': 'goog', 'chia sẻ': 100, 'giá': 490.10} "] 0.37812089920043945 >>>

Ở đây, tốc độ tạo ra các đối tượng mới là khoảng 3,5. Tiếp theo, chúng ta hãy xem hiệu suất của việc thực hiện tính toán đơn giản: >>> thời gian ["S.Shares*s.price", ... "từ cổ phiếu chứng khoán; >>> Timeit ["S ['chia sẻ']*s ['giá']", ... "s = {'name': 'goog', 'chia sẻ': 100, 'giá': 490.10}"] 0.23622798919677734 >>>

Ở đây, SpeedUp là khoảng 1.2. Bài học ở đây là chỉ vì bạn có thể xác định một đối tượng mới bằng cách sử dụng một lớp, nó không phải là cách duy nhất để làm việc với dữ liệu. Các mẫu và từ điển thường đủ tốt. Sử dụng chúng sẽ làm cho chương trình của bạn chạy nhanh hơn và sử dụng ít bộ nhớ hơn.

H lib

196

Chương 11 Thử nghiệm, gỡ lỗi, hồ sơ và điều chỉnh

Sử dụng _ _SLOTS_ _ Nếu chương trình của bạn tạo một số lượng lớn các phiên bản của các lớp do người dùng xác định, bạn có thể xem xét sử dụng thuộc tính _ _slots_ _ trong một định nghĩa lớp. Ví dụ: Class Stock [Đối tượng]: _ _Slots_ _ = ['name', 'chia sẻ', 'giá'] def __init __ [self, tên, chia sẻ, giá]: self.name = name self.shares = chia sẻ tự. Giá = Giá

_ _slots_ _ đôi khi được xem là một tính năng an toàn vì nó hạn chế tập hợp của Attrial-

Tên ute. Tuy nhiên, nó thực sự là một tối ưu hóa hiệu suất. Các lớp sử dụng _ _SLOTS_ _ don lồng sử dụng từ điển để lưu trữ dữ liệu thể hiện [thay vào đó, cấu trúc dữ liệu nội bộ hiệu quả hơn được sử dụng]. Vì vậy, không chỉ các trường hợp sẽ sử dụng bộ nhớ ít hơn nhiều mà còn truy cập vào dữ liệu thể hiện cũng hiệu quả hơn. Trong một số trường hợp, chỉ cần thêm _ _Slots_ _ sẽ làm cho một chương trình chạy nhanh hơn đáng kể mà không thực hiện bất kỳ thay đổi nào khác. Tuy nhiên, có một cảnh báo với việc sử dụng _ _slots_ _, tuy nhiên. Thêm tính năng này vào một lớp có thể khiến mã khác bị phá vỡ một cách bí ẩn. Ví dụ: người ta thường biết rằng các trường hợp lưu trữ dữ liệu của họ trong một từ điển có thể được truy cập dưới dạng thuộc tính _ _dict_ _. Khi các khe được xác định, thuộc tính này không tồn tại để bất kỳ mã nào dựa trên _ _ .

Tránh toán tử [.] Bất cứ khi nào bạn sử dụng [.] Để tra cứu một thuộc tính trên một đối tượng, nó luôn liên quan đến việc tra cứu tên. Ví dụ: khi bạn nói X.Name, có một cái nhìn cho tên biến "x" trong môi trường và sau đó là tìm kiếm thuộc tính "tên" trên x. Đối với các đối tượng do người dùng xác định, tra cứu thuộc tính có thể liên quan đến việc tìm kiếm trong từ điển, từ điển lớp và từ điển của các lớp cơ sở. Đối với các tính toán liên quan đến việc sử dụng nhiều phương thức hoặc tra cứu mô -đun, hầu như luôn luôn tốt hơn để loại bỏ việc tra cứu thuộc tính bằng cách đặt thao tác bạn muốn thực hiện vào một biến cục bộ trước tiên. Ví dụ: nếu bạn đang thực hiện nhiều thao tác gốc, việc sử dụng 'từ Math Nhập SQRT' và 'SQRT [x]' sẽ nhanh hơn là gõ 'Math.sqrt [x]'. Trong phần đầu tiên của phần này, chúng tôi đã thấy rằng phương pháp này dẫn đến tăng tốc khoảng 1,4. Rõ ràng bạn không nên cố gắng loại bỏ các tra cứu thuộc tính ở mọi nơi trong chương trình của bạn vì nó sẽ làm cho mã của bạn rất khó đọc. Tuy nhiên, đối với các phần quan trọng về hiệu suất, đây là một kỹ thuật hữu ích.

Sử dụng các ngoại lệ để xử lý các trường hợp không phổ biến để tránh lỗi, bạn có thể có xu hướng thêm kiểm tra thêm vào chương trình. Ví dụ: def parse_header [line]: field = line.split [":"] Nếu len [trường]! = 2: nâng cao RunTimeError ["Tiêu đề không phù hợp"] Tiêu đề, giá trị = trường trả về trường.Lower [], giá trị. dải []

H lib

Điều chỉnh và tối ưu hóa

197

Tuy nhiên, một cách khác để xử lý các lỗi là chỉ cần để chương trình tạo ra một ngoại lệ và bắt nó. Ví dụ: def parse_header [line]: field = line.split [":"] Hãy thử: tiêu đề, value = trường return return.lower [], value.strip [] ngoại trừ valueError: RAIN

Nếu bạn điểm chuẩn cả hai phiên bản trên một dòng được định dạng đúng, phiên bản thứ hai của mã sẽ chạy nhanh hơn khoảng 10 phần trăm. Thiết lập một khối thử cho mã thường không nâng cao các ngoại lệ chạy nhanh hơn so với thực hiện câu lệnh IF.

Tránh các trường hợp ngoại lệ cho các trường hợp phổ biến don don mã viết sử dụng xử lý ngoại lệ cho trường hợp phổ biến. Ví dụ, giả sử bạn đã có một chương trình thực hiện rất nhiều bộ tra cứu từ điển, nhưng hầu hết các bộ tra cứu này là dành cho các khóa đã tồn tại. Bây giờ, hãy xem xét hai cách tiếp cận để thực hiện tra cứu: # tiếp cận 1: Thực hiện tra cứu và bắt một ngoại lệ Hãy thử: value = item trong các mục: value = items [key] other: value = none

Trong một phép đo hiệu suất đơn giản trong đó không tìm thấy khóa, cách tiếp cận thứ hai chạy nhanh hơn 17 lần! Trong trường hợp bạn đang tự hỏi, cách tiếp cận sau này cũng chạy nhanh gần gấp đôi so với sử dụng items.get [khóa] vì toán tử trong nhanh hơn để thực hiện hơn là một cuộc gọi phương thức.

Embrace Lập trình chức năng và Liệt kê danh sách lặp lại, biểu thức máy phát, máy phát điện, coroutines và đóng cửa hiệu quả hơn nhiều so với hầu hết các lập trình viên Python nhận ra. Để xử lý dữ liệu đặc biệt, liệt kê các biểu thức toàn diện và trình tạo chạy nhanh hơn đáng kể so với mã theo cách thủ công dữ liệu và thực hiện các hoạt động tương tự. Các hoạt động này cũng chạy nhanh hơn nhiều so với mã Python cũ sử dụng các chức năng như MAP [] và Filter [] . Máy phát điện có thể được sử dụng để viết mã không chỉ chạy nhanh mà còn sử dụng bộ nhớ hiệu quả.

Sử dụng trang trí và metaclasses và metaclasses là các tính năng được sử dụng để sửa đổi các chức năng và lớp học. Tuy nhiên, vì chúng hoạt động tại thời điểm chức năng hoặc định nghĩa lớp, chúng có thể được sử dụng theo cách dẫn đến hiệu suất được cải thiện, đặc biệt là nếu một chương trình có nhiều tính năng tùy chọn có thể được bật hoặc tắt. Chương 6, Các chức năng và lập trình chức năng, có một ví dụ về việc sử dụng trình trang trí để cho phép ghi nhật ký các chức năng, nhưng theo cách không ảnh hưởng đến hiệu suất khi đăng nhập bị vô hiệu hóa.

H lib

Điều chỉnh và tối ưu hóa

H lib

Điều chỉnh và tối ưu hóa

Trang này cố ý để trống

II Thư viện Python

Chức năng tích hợp sẵn

Dịch vụ thời gian chạy Python

toán học

Cấu trúc dữ liệu, thuật toán và các tiện ích

Chuỗi và xử lý văn bản

Truy cập cơ sở dữ liệu Python

H lib

Điều chỉnh và tối ưu hóa

H lib

Điều chỉnh và tối ưu hóa

H lib

202

Chương 12 Chức năng và ngoại lệ tích hợp

Basestring

Đây là một loại dữ liệu trừu tượng là siêu lớp của tất cả các chuỗi trong Python 2 [Str và Unicode]. Nó chỉ được sử dụng để thử nghiệm loại của chuỗi. Ví dụ: isinstance [s, basestring] trả về true nếu s là loại chuỗi. Python 2 chỉ. bin [x]

Trả về một chuỗi chứa biểu diễn nhị phân của số nguyên x. Bool [[x]]

Loại đại diện cho các giá trị boolean đúng và sai. Nếu được sử dụng để chuyển đổi X, nó sẽ trả về đúng nếu X đánh giá đúng bằng cách sử dụng ngữ nghĩa thử nghiệm sự thật thông thường [nghĩa là số khác, danh sách không trống, v.v.]. Nếu không, sai được trả lại. Sai cũng là giá trị mặc định được trả về nếu bool [] được gọi mà không có bất kỳ đối số nào. Lớp bool kế thừa từ int để các giá trị boolean đúng và sai có thể được sử dụng làm số nguyên có giá trị 1 và 0 trong các tính toán toán học. bytearray [[x]]

Một loại đại diện cho một mảng byte có thể thay đổi. Khi tạo một thể hiện, x có thể là một chuỗi số nguyên trong phạm vi 0 đến 255, chuỗi 8 bit hoặc byte theo nghĩa đen hoặc một số nguyên chỉ định kích thước của mảng byte [ trong trường hợp đó, mọi mục sẽ được khởi tạo thành 0]. Một đối tượng bytearray trông giống như một loạt các số nguyên. Nếu bạn thực hiện tra cứu như [i], bạn sẽ nhận được giá trị số nguyên đại diện cho giá trị byte tại Index i. Các bài tập như [i] = v cũng yêu cầu v là giá trị byte số nguyên. Tuy nhiên, một bytearray cũng cung cấp tất cả các hoạt động thường được liên kết với các chuỗi [nghĩa là cắt, tìm [], chia [], thay thế []. Chuỗi chữ với B để chỉ ra rằng bạn đang làm việc với byte. Ví dụ: nếu bạn muốn chia một mảng byte a thành các trường bằng cách sử dụng bộ phân cách ký tự dấu phẩy, bạn sẽ sử dụng a.split [b ','] không a.split [',']. Kết quả của các hoạt động này luôn mới Các đối tượng bytearray, không phải chuỗi. Để biến một bytearray a thành một chuỗi, sử dụng phương thức a.decode [mã hóa]. Việc mã hóa 'Latin-1' sẽ trực tiếp biến một bytearray của các ký tự 8 bit thành một chuỗi mà không có bất kỳ sửa đổi nào của các giá trị ký tự cơ bản. Bytearray [S, mã hóa]

Một quy ước gọi thay thế để tạo một thể hiện bytearray từ các ký tự trong một chuỗi S trong đó mã hóa chỉ định mã hóa ký tự để sử dụng trong chuyển đổi. Byte [[x]]

Một loại đại diện cho một mảng byte bất biến. Trong Python 2, đây là bí danh cho str [] tạo ra một chuỗi các ký tự 8 bit tiêu chuẩn. Trong Python 3, byte là một loại hoàn toàn riêng biệt là phiên bản bất biến của loại bytearray được mô tả trước đó. Trong trường hợp đó, đối số X có cùng cách giải thích và có thể được sử dụng theo cách tương tự. Một cảnh báo tính di động là mặc dù các byte được xác định trong Python 2, đối tượng kết quả không hoạt động nhất quán với Python 3. Ví dụ: nếu A là một thể hiện được tạo bởi byte [], thì [i] trả về một chuỗi ký tự trong Python 2, nhưng trả về một số nguyên trong Python 3.

H lib

Chương 12 Chức năng và ngoại lệ tích hợp

203

Basestring

Trả về một chuỗi chứa biểu diễn nhị phân của số nguyên x. Bool [[x]]

Chức năng và loại tích hợp

Byte [S, mã hóa]

Danh sách các tùy chọn cảnh báo được cung cấp cho trình thông dịch với tùy chọn dòng lệnh. Winver

Số phiên bản được sử dụng để hình thành các khóa đăng ký trên Windows.

H lib

sys

233

Các chức năng Các chức năng sau có sẵn: _clear_type_cache []

Xóa bộ đệm loại bên trong. Để tối ưu hóa phương pháp tra cứu, một bộ đệm nhỏ 1024 của các phương pháp được sử dụng gần đây được duy trì bên trong trình thông dịch. Bộ đệm này tăng tốc độ tra cứu phương pháp lặp đi lặp lại, đặc biệt là trong mã có hệ thống phân cấp kế thừa sâu. Thông thường, bạn không cần phải xóa bộ đệm này, nhưng bạn có thể làm như vậy nếu bạn đang cố gắng theo dõi vấn đề đếm tham chiếu bộ nhớ thực sự khó khăn. Ví dụ, nếu một phương thức trong bộ đệm đang giữ một tham chiếu đến một đối tượng mà bạn đang mong đợi bị phá hủy. _Current_Frames []

Trả về một định danh luồng ánh xạ từ điển vào khung ngăn xếp trên cùng của luồng thực thi tại thời điểm gọi. Thông tin này có thể hữu ích trong các công cụ viết liên quan đến gỡ lỗi luồng [nghĩa là theo dõi bế tắc]. Hãy nhớ rằng các giá trị được trả về bởi hàm này chỉ thể hiện một ảnh chụp nhanh của trình thông dịch tại thời điểm gọi. Chủ đề có thể được thực hiện ở nơi khác vào thời điểm bạn nhìn vào dữ liệu được trả về. DisplayHook [[Giá trị]]

Hàm này được gọi để in kết quả của một biểu thức khi trình thông dịch đang chạy ở chế độ tương tác. Theo mặc định, giá trị của repr [giá trị] được in thành đầu ra tiêu chuẩn và giá trị được lưu trong biến _ _builtin_ _._. Displayhook có thể được xác định lại để cung cấp hành vi khác nhau nếu muốn. ngoại lệ [loại, giá trị, traceback]

Hàm này được gọi là khi một ngoại lệ chưa được thực hiện. Loại là lớp ngoại lệ, giá trị là giá trị được cung cấp bởi câu lệnh RAISE và TraceBack là đối tượng Traceback. Hành vi mặc định là in ngoại lệ và theo dõi thành lỗi tiêu chuẩn. Tuy nhiên, chức năng này có thể được xác định lại để cung cấp xử lý thay thế các trường hợp ngoại lệ chưa được thực hiện [có thể hữu ích trong các ứng dụng chuyên dụng như gỡ lỗi hoặc tập lệnh CGI]. exc_clear []

Xóa tất cả các thông tin liên quan đến ngoại lệ cuối cùng xảy ra. Nó chỉ xóa thông tin cụ thể cho luồng gọi. exc_info []

Trả về một tuple [loại, giá trị, traceback] chứa thông tin về ngoại lệ mà hiện đang được xử lý. Loại là loại ngoại lệ, giá trị là tham số ngoại lệ được truyền để nâng cao và TraceBack là đối tượng Traceback chứa ngăn xếp cuộc gọi tại điểm xảy ra ngoại lệ. Trả về không nếu không có ngoại lệ hiện đang được xử lý. Thoát [[n]]

Thoát Python bằng cách nâng ngoại lệ hệ thống. N là mã thoát số nguyên biểu thị mã trạng thái. Giá trị 0 được coi là bình thường [mặc định]; Giá trị khác không được coi là bất thường. Nếu một giá trị không được cung cấp cho N, thì nó được in vào sys.stderr và mã thoát của 1 được sử dụng.

H lib

234

sys

Các chức năng Các chức năng sau có sẵn: _clear_type_cache []

Xóa tất cả các thông tin liên quan đến ngoại lệ cuối cùng xảy ra. Nó chỉ xóa thông tin cụ thể cho luồng gọi. exc_info []

Chương 13 Dịch vụ thời gian chạy Python

getCheckInterval []

Trả về hàm theo dõi được đặt bởi hàm setTrace []. getWindowsVersion []

Trả về một tuple [chính, nhỏ, xây dựng, nền tảng, văn bản] mô tả phiên bản Windows đang được sử dụng. Major là số phiên bản chính. Ví dụ: giá trị 4 cho biết Windows NT 4.0 và giá trị 5 cho biết Windows 2000 và Windows XP

H lib

tìm lại

235

biến thể. Nhỏ là số phiên bản nhỏ. Ví dụ: 0 chỉ ra Windows 2000, trong khi 1 cho biết Windows XP. Bản dựng là số xây dựng Windows. Nền tảng xác định nền tảng và là một số nguyên với một trong các giá trị chung sau: 0 [Win32 trên Windows 3.1], 1 [Windows 95,98 hoặc ME], 2 [Windows NT, 2000, XP] hoặc 3 [Windows CE ]. Văn bản là một chuỗi chứa thông tin bổ sung như "Gói dịch vụ 3". setCheckInterval [n]

Đặt số lượng hướng dẫn máy ảo Python phải được trình thông dịch thực hiện trước khi kiểm tra các sự kiện định kỳ như tín hiệu và chuyển đổi ngữ cảnh luồng. Giá trị mặc định là 10.

Đặt mã hóa mặc định. ENC là một chuỗi như 'ASCII' hoặc 'UTF-8'. Hàm này chỉ được xác định bên trong mô-đun trang web. Nó có thể được gọi từ các mô-đun Sitecustomize có thể xác định người dùng. setdlopenflags [cờ]

Đặt các cờ được truyền đến hàm c dlopen [], được sử dụng để tải các mô -đun mở rộng trên UNIX. Điều này sẽ ảnh hưởng đến cách giải quyết các ký hiệu giữa các thư viện và các mô -đun mở rộng khác. Cờ là bitwise hoặc của các giá trị có thể được tìm thấy trong mô -đun DL [xem Chương 19, Lập trình mạng mạng] - Ví dụ: Sys.SetDlopenFlags [dl.rtld_now | dl.rtld_global]. setprofile [PFUNC]

Đặt chức năng cấu hình hệ thống có thể được sử dụng để thực hiện trình hồ sơ mã nguồn. setrecursionlimit [n]

Thay đổi giới hạn đệ quy cho các hàm. Giá trị mặc định là 1000. Lưu ý rằng hệ điều hành có thể áp đặt giới hạn cứng đối với kích thước ngăn xếp, do đó, việc đặt quá mức này có thể khiến quá trình thông dịch viên Python gặp sự cố với lỗi phân đoạn hoặc vi phạm truy cập. SetTrace [TFUNC]

Đặt chức năng theo dõi hệ thống, có thể được sử dụng để thực hiện trình gỡ lỗi. Tham khảo Chương 11 để biết thông tin về trình gỡ lỗi Python.

TraceBack Mô -đun Traceback được sử dụng để thu thập và in dấu vết ngăn xếp của chương trình sau khi xảy ra ngoại lệ. Ví dụ, mô-đun cần báo cáo các lỗi theo cách không chuẩn, nếu bạn đang chạy các chương trình Python được nhúng sâu vào máy chủ mạng và bạn muốn chuyển hướng truy tìm đến tệp nhật ký. print_tb [traceback [, giới hạn [, tệp]]]]

In để giới hạn các mục nhập dấu vết từ Traceback sang tệp. Nếu giới hạn bị bỏ qua, tất cả các mục được in. Nếu tệp bị bỏ qua, đầu ra sẽ được gửi đến sys.stderr.

H lib

236

tìm lại

Đặt chức năng cấu hình hệ thống có thể được sử dụng để thực hiện trình hồ sơ mã nguồn. setrecursionlimit [n]

Đặt chức năng theo dõi hệ thống, có thể được sử dụng để thực hiện trình gỡ lỗi. Tham khảo Chương 11 để biết thông tin về trình gỡ lỗi Python.

Chương 13 Dịch vụ thời gian chạy Python

print_exception [loại, giá trị, tracback [, giới hạn [, tệp]]]]]

Giống như Format_List [Extract_TB [TraceBack, Limit]]. format_stack [[khung [, giới hạn]]]]

Giống như Format_List [Extract_Stack [khung, giới hạn]]. TB_LINENO [Traceback]

Trả về số dòng được đặt trong một đối tượng TraceBack.

H lib

loại

237

Các loại Mô-đun xác định tên cho các loại tích hợp tương ứng với các hàm, mô-đun, trình tạo, khung ngăn xếp và các yếu tố chương trình khác. Nội dung của mô-đun này thường được sử dụng cùng với hàm isInstance [] tích hợp Các hoạt động liên quan đến loại. Biến đổi

Sự mô tả

BuildInfunctionType CodeType frameType functionType Generatortype getSetDescriptypePype LambDatype thành viênDescriptype Phương thức

Loại chức năng tích hợp Loại đối tượng mã Loại khung thực thi Đối tượng Loại chức năng do người dùng xác định và LambDas Loại đối tượng máy phát điện loại Loại getSet đối tượng mô tả Loại mô -đun loại đối tượng theo dõi

Hầu hết các đối tượng loại trước đóng vai trò là hàm tạo có thể được sử dụng để tạo một đối tượng thuộc loại đó. Các mô tả sau đây cung cấp các tham số được sử dụng để tạo các hàm, mô -đun, đối tượng mã và phương thức. Chương 3 chứa thông tin chi tiết về các thuộc tính của các đối tượng được tạo và các đối số cần được cung cấp cho các chức năng được mô tả tiếp theo. FunctionType [Mã, Globals [, Tên [, DeFarags [, đóng]]]]]]

Tạo một đối tượng chức năng mới. CodeType [argcount, nlocals, stacksize, flags, codestring, hằng số, tên, varnames, fileName, tên, firstlineno, lnotab [, freevars [, cellvars]]]

Tạo một đối tượng mã mới. MethodType [hàm, ví dụ, lớp]

Tạo một phương thức thể hiện ràng buộc mới. Moduletype [Tên [, Doc]]

Tạo một đối tượng mô -đun mới.

Ghi chú n

Không nên sử dụng mô-đun các loại để giới thiệu loại đối tượng tích hợp như số nguyên, danh sách hoặc từ điển. Trong Python 2, các loại chứa các tên khác như inttype và dictType. Tuy nhiên, những cái tên này chỉ là bí danh cho tên loại tích hợp của Int và Dict. Trong mã hiện đại, bạn chỉ nên sử dụng tên loại tích hợp vì mô-đun loại chỉ chứa các tên được liệt kê trước đây trong Python 3.

H lib

238

loại

Sự mô tả

BuildInfunctionType CodeType frameType functionType Generatortype getSetDescriptypePype LambDatype thành viênDescriptype Phương thức

Sự mô tả

BuildInfunctionType CodeType frameType functionType Generatortype getSetDescriptypePype LambDatype thành viênDescriptype Phương thức

Tạo một đối tượng chức năng mới. CodeType [argcount, nlocals, stacksize, flags, codestring, hằng số, tên, varnames, fileName, tên, firstlineno, lnotab [, freevars [, cellvars]]]

Tạo một đối tượng mã mới. MethodType [hàm, ví dụ, lớp]

Tạo một phương thức thể hiện ràng buộc mới. Moduletype [Tên [, Doc]]

H lib

loại

239

Sự mô tả

Đây là phiên bản cấp thấp của hàm WARN []. Thông điệp và danh mục có ý nghĩa tương tự như đối với Warn []. Tên tệp, Lineno và Mô -đun chỉ định rõ ràng vị trí của cảnh báo. Đăng ký là một đối tượng đại diện cho tất cả các bộ lọc hiện đang hoạt động. Nếu sổ đăng ký bị bỏ qua, thông điệp cảnh báo không bị triệt tiêu. ShowWarning [Tin nhắn, Thể loại, Tên tệp, Lineno [, Tệp]]

Viết một cảnh báo cho một tập tin. Nếu tệp bị bỏ qua, cảnh báo được in cho sys.stderr. Định dạng [tin nhắn, danh mục, tên tệp, lineno]

Tạo chuỗi được định dạng được in khi cảnh báo được đưa ra. FilterWarnings [hành động [, message [, danh mục [, mô -đun [, lineno [, append]]]]]]]

Thêm một mục vào danh sách các bộ lọc cảnh báo. Hành động là một trong những 'lỗi', 'bỏ qua', 'luôn luôn', 'mặc định', 'một lần' hoặc 'mô -đun'. Danh sách sau đây cung cấp một lời giải thích của mỗi: hành động

Sự mô tả

'Lỗi' 'bỏ qua' 'luôn luôn' 'mặc định' 'mô -đun' 'một lần'

Chuyển đổi cảnh báo thành một ngoại lệ bỏ qua cảnh báo luôn in thông báo cảnh báo in cảnh báo một lần cho từng địa điểm nơi cảnh báo xảy ra in cảnh báo một lần cho mỗi mô -đun trong đó cảnh báo xảy ra in cảnh báo một lần

thông báo là một chuỗi biểu thức thông thường được sử dụng để khớp với thông báo cảnh báo. Danh mục là một lớp cảnh báo như DEFARMERERROR. Mô -đun là một chuỗi biểu thức thông thường được khớp với tên mô -đun. Lineno là một số dòng cụ thể hoặc 0 để khớp với tất cả các dòng. Phụ lục chỉ định rằng bộ lọc phải được thêm vào danh sách tất cả các bộ lọc [đã kiểm tra lần cuối]. Theo mặc định, các bộ lọc mới được thêm vào đầu danh sách bộ lọc. Nếu bất kỳ đối số nào bị bỏ qua, nó mặc định là một giá trị phù hợp với tất cả các cảnh báo. cài đặt lại cảnh báo[]

Đặt lại tất cả các bộ lọc cảnh báo. Điều này loại bỏ tất cả các cuộc gọi trước đó cho FilterWarnings [] cũng như các tùy chọn được chỉ định với.

Ghi chú n n

Danh sách các bộ lọc hiện đang hoạt động được tìm thấy trong biến.Filters biến. Khi cảnh báo được chuyển đổi thành ngoại lệ, danh mục cảnh báo trở thành loại ngoại lệ. Chẳng hạn, một lỗi đối với DEVENTWARNING sẽ làm tăng ngoại lệ không dùng nữa.

H lib

Chương 13 Dịch vụ thời gian chạy Python

240

Tùy chọn có thể được sử dụng để chỉ định bộ lọc cảnh báo trên dòng lệnh. Định dạng chung của tùy chọn này là -waction: Tin nhắn: Thể loại: Mô -đun: Lineno

trong đó mỗi phần có cùng ý nghĩa như đối với hàm filterWarning []. Tuy nhiên, trong trường hợp này, các trường thông báo và mô -đun chỉ định các chuỗi con [thay vì các biểu thức chính quy] cho phần đầu tiên của thông báo cảnh báo và tên mô -đun được lọc, tương ứng.

yếu Mô -đun yếu được sử dụng để cung cấp hỗ trợ cho các tài liệu tham khảo yếu. Thông thường, một tham chiếu đến một đối tượng gây ra số lượng tham chiếu của nó để tăng hiệu quả giữ cho đối tượng tồn tại cho đến khi tham chiếu biến mất. Mặt khác, một tài liệu tham khảo yếu cung cấp một cách đề cập đến một đối tượng mà không tăng số lượng tham chiếu của nó. Điều này có thể hữu ích trong một số loại ứng dụng nhất định phải quản lý các đối tượng theo những cách bất thường. Ví dụ: trong một chương trình hướng đối tượng, nơi bạn có thể thực hiện một mối quan hệ như mẫu quan sát viên, một tham chiếu yếu có thể được sử dụng để tránh việc tạo các chu kỳ tham chiếu. Một ví dụ về điều này được hiển thị trong phần Quản lý bộ nhớ đối tượng của Google trong Chương 7. Một tham chiếu yếu được tạo bằng cách sử dụng hàm yếu >> ar = weakref.ref [a] # Tạo tham chiếu yếu đến a >>> in ar

Khi một tham chiếu yếu được tạo, đối tượng gốc có thể được lấy từ tham chiếu yếu bằng cách gọi nó là một hàm không có đối số. Nếu đối tượng cơ bản vẫn tồn tại, nó sẽ được trả về. Nếu không, không có gì được trả lại để chỉ ra rằng đối tượng ban đầu không còn tồn tại. Ví dụ: >>> in ar [] # in đối tượng gốc

>>> del a # xóa đối tượng gốc >>> in ar [] # a đã biến mất, vì vậy bây giờ điều này không trả về không có >>>>

Các chức năng sau được xác định bởi mô -đun yếu: Ref [Object [, Callback]]

Tạo một tham chiếu yếu đến đối tượng. Gọi lại là một chức năng tùy chọn sẽ được gọi khi đối tượng sắp bị phá hủy. Nếu được cung cấp, hàm này sẽ chấp nhận một đối số duy nhất, đó là đối tượng tham chiếu yếu tương ứng. Nhiều hơn một tham chiếu yếu có thể đề cập đến cùng một đối tượng. Trong trường hợp này, các chức năng gọi lại sẽ được gọi theo thứ tự từ tham chiếu được áp dụng gần đây nhất đến tham chiếu lâu đời nhất. Đối tượng có thể được lấy từ một tham chiếu yếu bằng cách gọi đối tượng tham chiếu yếu được trả về dưới dạng hàm không có đối số. Nếu đối tượng ban đầu không còn tồn tại, không có đối tượng nào

h Lib

weakref

241

will be returned. ref[] actually defines a type, ReferenceType, that can be used for type-checking and subclasses. proxy[object[, callback]]

Creates a proxy using a weak reference to object.The returned proxy object is really a wrapper around the original object that provides access to its attributes and methods. As long as the original object exists, manipulation of the proxy object will transparently mimic the behavior of the underlying object. On the other hand, if the original object has been destroyed, operations on the proxy will raise a weakref.ReferenceError to indicate that the object no longer exists. callback is a callback function with the same meaning as for the ref[] function.The type of a proxy object is either ProxyType or CallableProxyType, depending on whether or not the original object is callable. getweakrefcount[object]

Returns the number of weak references and proxies that refer to object. getweakrefs[object]

Returns a list of all weak reference and proxy objects that refer to object. WeakKeyDictionary[[dict]]

Creates a dictionary in which the keys are referenced weakly.When there are no more strong references to a key, the corresponding entry in the dictionary is automatically removed. If supplied, the items in dict are initially added to the returned WeakKeyDictionary object. Because only certain types of objects can be weakly referenced, there are numerous restrictions on acceptable key values. In particular, built-in strings cannot be used as weak keys. However, instances of user-defined classes that define a _ _hash_ _[] method can be used as keys. An instance of WeakKeyDictionary has two methods, iterkeyrefs[] and keyrefs[], that return the weak key references. WeakValueDictionary[[dict]]

Creates a dictionary in which the values are referenced weakly.When there are no more strong references to a value, corresponding entries in the dictionary will be discarded. If supplied, the entries in dict are added to the returned WeakValueDictionary. An instance of WeakValueDictionary has two methods, itervaluerefs[] and valuerefs[], that return the weak value references. ProxyTypes

This is a tuple [ProxyType, CallableProxyType] that can be used for testing if an object is one of the two kinds of proxy objects created by the proxy[] function—for example, isinstance[object, ProxyTypes].

h Lib

Chapter 13 Python Runtime Services

242

Example One application of weak references is to create caches of recently computed results. For instance, if a function takes a long time to compute a result, it might make sense to cache these results and to reuse them as long as they are still in use someplace in the application. For example: _resultcache = { } def foocache[x]: if resultcache.has_key[x]: r = _resultcache[x][] # Get weak ref and dereference it if r is not None: return r r = foo[x] _resultcache[x] = weakref.ref[r] return r

Notes n

Only class instances, functions, methods, sets, frozen sets, files, generators, type objects, and certain object types defined in library modules [for example, sockets, arrays, and regular expression patterns] support weak references. Built-in functions and most built-in types such as lists, dictionaries, strings, and numbers cannot be used. If iteration is ever used on a WeakKeyDictionary or WeakValueDictionary, great care should be taken to ensure that the dictionary does not change size because this may produce bizarre side effects such as items mysteriously disappearing from the dictionary for no apparent reason. If an exception occurs during the execution of a callback registered with ref[] or proxy[], the exception is printed to standard error and ignored. Weak references are hashable as long as the original object is hashable. Moreover, the weak reference will maintain its hash value after the original object has been deleted, provided that the original hash value is computed while the object still exists. Weak references can be tested for equality but not for ordering. If the objects are still alive, references are equal if the underlying objects have the same value. Otherwise, references are equal if they are the same reference.

h Lib

14 Mathematics T

his chapter describes modules for performing various kinds of mathematical operations. In addition, the decimal module, which provides generalized support for decimal floating-point numbers, is described.

decimal The Python float data type is represented using a double-precision binary floatingpoint encoding [usually as defined by the IEEE 754 standard]. A subtle consequence of this encoding is that decimal values such as 0.1 can’t be represented exactly. Instead, the closest value is 0.10000000000000001.This inexactness carries over to calculations involving floating-point numbers and can sometimes lead to unexpected results [for example, 3*0.1 == 0.3 evaluates as False]. The decimal module provides an implementation of the IBM General Decimal Arithmetic Standard, which allows for the exact representation of decimals. It also gives precise control over mathematical precision, significant digits, and rounding behavior. These features can be useful if interacting with external systems that precisely define properties of decimal numbers. For example, if writing Python programs that must interact with business applications. The decimal module defines two basic data types: a Decimal type that represents a decimal number and a Context type that represents various parameters concerning computation such as precision and round-off error-handling. Here are a few simple examples that illustrate the basics of how the module works: import decimal x = decimal.Decimal['3.4'] y = decimal.Decimal['4.5']

# Create some decimal numbers

# Perform some math calculations using the default context a = x * y # a = decimal.Decimal['15.30'] b = x / y # b = decimal.Decimal['0.7555555555555555555555555556'] # Change the precision and perform calculations decimal.getcontext[].prec = 3 c = x * y # c = decimal.Decimal['15.3'] d = x / y # d = decimal.Decimal['0.756'] # Change the precision for just a single block of statements with decimal.localcontext[decimal.Context[prec=10]]: e = x * y # e = decimal.Decimal['15.30'] f = x / y # f = decimal.Decimal['0.7555555556']

h Lib

244

Chapter 14 Mathematics

Decimal Objects Decimal numbers are represented by the following class: Decimal[[value [, context]]]

value is the value of the number specified as either an integer, a string containing a decimal value such as '4.5', or a tuple [sign, digits, exponent]. If a tuple is supplied, sign is 0 for positive, 1 for negative; digits is a tuple of digits specified as integers; and exponent is an integer exponent.The special strings 'Infinity', '-Infinity', 'NaN', and 'sNaN' may be used to specify positive and negative infinity as well as Not a Number [NaN]. 'sNaN' is a variant of NaN that results in an exception if it is ever subsequently used in a calculation. An ordinary float object may not

be used as the initial value because that value may not be exact [which defeats the purpose of using decimal in the first place].The context parameter is a Context object, which is described later. If supplied, context determines what happens if the initial value is not a valid number—raising an exception or returning a decimal with the value NaN. The following examples show how to create various decimal numbers: a b c d e

= = = = =

decimal.Decimal[42] # Creates Decimal["42"] decimal.Decimal["37.45"] # Creates Decimal["37.45"] decimal.Decimal[[1,[2,3,4,5],-2]] # Creates Decimal["-23.45"] decimal.Decimal["Infinity"] decimal.Decimal["NaN"]

Decimal objects are immutable and have all the usual numeric properties of the built-in int and float types.They can also be used as dictionary keys, placed in sets, sorted, and so forth. For the most part, you manipulate Decimal objects using the standard Python math operators. However, the methods in the following list can be used to carry out several common mathematical operations. All operations take an optional context parameter that controls the behavior of precision, rounding, and other aspects of the calculation. If omitted, the current context is used. Method

Description

x.exp[[context]] x.fma[y, z [, context]] x.ln[[context]] x.log10[[context]] x.sqrt[[context]]

Natural exponent e**d x*y + z with no rounding of x*y component Natural logarithm [base e] of x Base-10 logarithm of x Square root of x

Context Objects Various properties of decimal numbers, such as rounding and precision, are controlled through the use of a Context object:

h Lib

decimal

245

Context[prec=None, rounding=None, traps=None, flags=None, Emin=None, Emax=None, capitals=1]

This creates a new decimal context.The parameters should be specified using keyword arguments with the names shown. prec is an integer that sets the number of digits of precision for arithmetic operations, rounding determines the rounding behavior, and traps is a list of signals that produce a Python exception when certain events occur during computation [such as division by zero]. flags is a list of signals that indicate the initial state of the context [such as overflow]. Normally, flags is not specified. Emin and Emax are integers representing the minimum and maximum range for exponents, respectively. capitals is a boolean flag that indicates whether to use 'E' or 'e' for exponents.The default is 1 ['E']. Normally, new Context objects aren’t created directly. Instead, the function getcontext[] or localcontext[] is used to return the currently active Context object.That object is then modified as needed. Examples of this appear later in this section. However, in order to better understand those examples, it is necessary to explain these context parameters in further detail. Rounding behavior is determined by setting the rounding parameter to one of the following values: Constant

Description

ROUND_CEILING

Rounds toward positive infinity. For example, 2.52 rounds up to 2.6 and -2.58 rounds up to -2.5. Rounds toward zero. For example, 2.58 rounds down to 2.5 and -2.58 rounds up to -2.5. Rounds toward negative infinity. For example, 2.58 rounds down to 2.5 and -2.52 rounds down to -2.6. Rounds away from zero if the fractional part is greater than half; otherwise, rounds toward zero. For example, 2.58 rounds up to 2.6, 2.55 rounds down to 2.5 -2.55 rounds up to -2.5, and -2.58 rounds down to -2.6. The same as ROUND_HALF_DOWN except that if the fractional part is exactly half, the result is rounded down if the preceding digit is even and rounded up if the preceding digit is odd. For example, 2.65 is rounded down to 2.6 and 2.55 is rounded up to 2.6. The same as ROUND_HALF_DOWN except that if the fractional part is exactly half, it is rounded away from zero. For example 2.55 rounds up to 2.6, and -2.55 rounds down to -2.6. Rounds away from zero. For example, 2.52 rounds up to 2.6 and 2.52 rounds down to -2.6. Rounds away from zero if the last digit after toward zero would have been 0 or 5. Otherwise, rounds toward zero. For example, 2.54 rounds to 2.6 and 2.64 rounds to 2.6.

Round_down Round_Floor Round_half_down

Round_half_Even

Round_half_up

Round_Up Round_05Up

Các tham số bẫy và cờ của bối cảnh [] là danh sách các tín hiệu. Một tín hiệu đại diện cho một loại ngoại lệ số học có thể xảy ra trong quá trình tính toán. Trừ khi được liệt kê trong bẫy, tín hiệu bị bỏ qua. Mặt khác, một ngoại lệ được nâng lên. Các tín hiệu sau đây được xác định:

H lib

246

Chương 14 Toán học

Dấu hiệu

Sự mô tả

Kẹp phân chia không chính trị không chính xác

Số mũ điều chỉnh để phù hợp với phạm vi cho phép. Phân chia số không vô hạn bằng 0. Lỗi làm tròn xảy ra. Hoạt động không hợp lệ được thực hiện. Số mũ vượt quá Emax sau khi làm tròn. Cũng tạo ra không chính xác và tròn. Làm tròn xảy ra. Có thể xảy ra ngay cả khi không có thông tin nào bị mất [ví dụ: 1,00 1,00 được làm tròn đến 1.0 1.0]. Số mũ ít hơn emin trước khi làm tròn. Dòng chảy số. Kết quả được làm tròn đến 0. Cũng tạo ra không chính xác và dưới mức.

Tràn dưới dòng chảy dưới dòng

Các tên tín hiệu này tương ứng với các ngoại lệ Python có thể được sử dụng để kiểm tra lỗi. Ở đây, một ví dụ: Hãy thử: x = a/b ngoại trừ decimal.divisionbyzero: In "Division by Zero"

Giống như các trường hợp ngoại lệ, các tín hiệu được tổ chức thành một hệ thống phân cấp: arithmeticerror [ngoại lệ tích hợp] DecimalException Kẹp bộ phận tràn không chính trị

Các tín hiệu tràn và dòng chảy xuất hiện nhiều hơn một lần trong bảng vì các tín hiệu đó cũng dẫn đến tín hiệu cha mẹ [ví dụ: dòng chảy cũng báo hiệu dưới mức]. Tín hiệu thập phân.divisionbyzero cũng xuất phát từ ngoại lệ phân chia tích hợp. Trong nhiều trường hợp, các tín hiệu số học bị bỏ qua âm thầm. Chẳng hạn, một tính toán có thể tạo ra một lỗi làm tròn nhưng không tạo ra ngoại lệ. Trong trường hợp này, các tên tín hiệu có thể được sử dụng để kiểm tra một tập hợp các cờ dính biểu thị trạng thái tính toán. Ở đây, một ví dụ: ctxt = decimal.getContext [] # Nhận bối cảnh hiện tại x = a + b nếu ctxt.flags [tròn]: in "Kết quả đã được làm tròn!"

H lib

Chương 14 Toán học

247

Dấu hiệu

Sự mô tả

Kẹp phân chia không chính trị không chính xác

Tràn dưới dòng chảy dưới dòng

số thập phân

Khi các cờ được đặt, chúng được đặt cho đến khi chúng được xóa bằng phương thức Clear_flags []. Vì vậy, người ta có thể thực hiện toàn bộ chuỗi tính toán và chỉ kiểm tra các lỗi ở cuối. Các cài đặt trên đối tượng bối cảnh hiện có C có thể được thay đổi thông qua các thuộc tính và phương thức sau: C.Capitals

Cờ được đặt thành 1 hoặc 0 xác định có sử dụng E hay E làm ký tự số mũ. C.Emax

Số nguyên Chỉ định số mũ tối đa. C.Emin

Số nguyên Chỉ định số mũ tối thiểu. C.PREC

H lib

248

Chương 14 Toán học

Dấu hiệu

Sự mô tả

Kẹp phân chia không chính trị không chính xác

Tràn dưới dòng chảy dưới dòng

Giống như thập phân ["vô cực"]. NEGINF

Giống như thập phân ["-vô cực"]. Nan

Giống như thập phân ["nan"].

Ví dụ Dưới đây là một số ví dụ khác cho thấy cách sử dụng cơ bản của số thập phân: >>> A = thập phân ["42,5"] >>> B = thập phân ["37.1"] >>> A + B thập phân ["79,6"] >>>> A / B thập phân ["1.145552560646900269541778976"] >>> divmod [a, b] [thập phân ["1"], thập phân ["5,4"]] >>> tối đa [a, b] > C = [thập phân ["4,5"], thập phân ["3"], thập phân ["1.23e3"]] >>> Sum [c] thập phân ["1237.5"]

H lib

số thập phân

249

>>> [10*x cho x trong c] [thập phân ["45,0"], thập phân ["30"], thập phân ["1.230E4"]] >>> float [a] 42.5 >>> str [a] '42 .5 '

Dưới đây là một ví dụ về việc thay đổi các tham số trong bối cảnh: >>> getcontext []. Prec = 4 >>> a = thập phân ["3.4562384105"] >>> một thập phân ["3.4562384105"] >>> b = thập phân ["5.62738333333333333 "] >>> getcontext []. Cờ [tròn] 0 >>> a + b 9.084 >>> getContext []. ]: Tệp "", dòng 1, trong? decimal.divisionbyzero: x / 0 >>> getContext [].

Ghi chú n

Các đối tượng thập phân và bối cảnh có một số lượng lớn các phương pháp liên quan đến các chi tiết cấp thấp liên quan đến biểu diễn và hành vi của các hoạt động thập phân. Những điều này chưa được ghi nhận ở đây vì chúng không cần thiết cho việc sử dụng cơ bản của mô-đun này. Tuy nhiên, bạn nên tham khảo tài liệu trực tuyến tại //docs.python.org/l Library/decimal.html để biết thêm thông tin. Bối cảnh thập phân là duy nhất cho mỗi chủ đề. Thay đổi bối cảnh chỉ ảnh hưởng đến chủ đề đó chứ không phải những người khác. Một số đặc biệt, thập phân ["snan"], có thể được sử dụng làm tín hiệu-nan. Số này không bao giờ được tạo bởi bất kỳ chức năng tích hợp nào. Tuy nhiên, nếu nó xuất hiện trong một tính toán, một lỗi luôn được báo hiệu. Bạn có thể sử dụng điều này để chỉ ra các tính toán không hợp lệ phải dẫn đến lỗi và không được bỏ qua âm thầm. Ví dụ, kết quả là một hàm có thể trả về Snan. Giá trị của 0 có thể là dương hoặc âm [nghĩa là thập phân [0] và thập phân ["-0"]]. Các số không khác biệt vẫn so sánh như nhau. Mô-đun này có lẽ không phù hợp với điện toán khoa học hiệu suất cao do số lượng chi phí đáng kể liên quan đến tính toán. Ngoài ra, thường có rất ít lợi ích thực tế trong việc sử dụng điểm nổi thập phân trên điểm nổi nhị phân trong các ứng dụng như vậy. Một cuộc thảo luận toán học đầy đủ về biểu diễn dấu phẩy động và phân tích lỗi nằm ngoài phạm vi của cuốn sách này. Độc giả nên tham khảo một cuốn sách về phân tích số để biết thêm chi tiết. Bài viết về những gì mọi nhà khoa học máy tính nên

H lib

số thập phân

250

Chương 14 Toán học

Biết về số học dấu phẩy động của David Goldberg, trong các cuộc khảo sát điện toán, Hiệp hội máy tính, tháng 3 năm 1991 cũng là một bài đọc xứng đáng [bài viết này rất dễ tìm thấy trên internet nếu bạn chỉ cần tìm kiếm tiêu đề]. Thông số kỹ thuật số học thập phân chung của IBM chứa nhiều thông tin hơn và có thể dễ dàng định vị trực tuyến thông qua các công cụ tìm kiếm.

Phân số Mô -đun phân số xác định một phân số lớp đại diện cho một số hợp lý. Các thể hiện có thể được tạo theo ba cách khác nhau bằng cách sử dụng hàm tạo lớp: phân số [[Nữ số [, mẫu số]]]]

Tạo một số hợp lý mới. Tổ số và mẫu số có các giá trị tích phân và mặc định là 0 và 1, tương ứng. Phân số [phân số]

Nếu phân số là một thể hiện của các số. TUYỆT VỜI, hãy tạo một số hợp lý mới có cùng giá trị với phân số. [Các] phân số

Nếu S là một chuỗi chứa một phân số như "3/7" hoặc "-4/7", một phần có cùng giá trị được tạo. Nếu s là một số thập phân, chẳng hạn như "1.25", một phần có giá trị đó được tạo ra [ví dụ: phân số [5,4]]. Các phương thức lớp sau có thể tạo các phiên bản phân số từ các loại đối tượng khác: phân số.from_float [f]

Tạo một phân số đại diện cho giá trị chính xác của số điểm nổi f. Phân số.from_decimal [d]

Tạo một phân số đại diện cho giá trị chính xác của số thập phân d. Dưới đây là một số ví dụ về việc sử dụng các chức năng này: >>> f = phân số.fraction [3,4] >>> g = phân số. Phân số.fraction.from_float [3.1415926] Phân số [3537118815677477, 1125899906842624] >>>>

H lib

môn Toán

251

Dưới đây là một số ví dụ về việc sử dụng các phiên bản phân số [sử dụng các giá trị được tạo trong ví dụ trước]: >>> Phân số F + G [5, 2] >>> Phân số F * G [21, 16] >>> H.Limit_denominator [ 10] Phân số [22, 7] >>>

Mô -đun phân số cũng xác định một hàm duy nhất: GCD [A, B]

Tính toán ước số chung lớn nhất của các số nguyên A và B. Kết quả có cùng dấu hiệu B nếu B là không khác; Nếu không, nó có cùng một dấu hiệu như a.

Toán Mô -đun toán học xác định các hàm toán học tiêu chuẩn sau đây. Các hàm này hoạt động trên số nguyên và phao nhưng không hoạt động với các số phức tạp [một mô -đun riêng CMATH có thể được sử dụng để thực hiện các hoạt động tương tự trên các số phức tạp]. Giá trị trả về của tất cả các hàm là một chiếc phao. Tất cả các chức năng lượng giác giả định sử dụng radian. Hàm số

Sự mô tả

ACOS [x] acosh [x] asin [x] asinh [x] atan [x] atan2 [y, x] atanh [x] ceil [x] copysign [x, y] cos [x] COSH [x] độ [x] x] radian [x] exp [x] fabs [x] giai thừa [x]

Trả về cosin hồ quang của x. Trả về cosin hồ quang hyperbol của x. Trả về sin hồ quang của x. Trả về sin hồ quang hyperbol của x. Trả về tiếp tuyến hồ quang của x. Trả lại atan [y / x]. Trả về tiếp tuyến hồ quang hyperbol của x. Trả về trần của x. Trả về x với cùng một dấu với y. Trả về cosin của x. Trả về cosin hyperbol của x. Chuyển đổi X từ radian thành độ. Chuyển đổi X từ độ sang radian. Trả về e ** x. Trả về giá trị tuyệt đối của x. Trả lại x factorial. Trả lại sàn của x. Trả về x % y như được tính toán bởi hàm c fmod []. Trả về mantissa dương và số mũ của X như một tuple. Trả về tổng chính xác đầy đủ của các giá trị dấu phẩy động trong chuỗi có thể lặp lại. Xem ghi chú sau đây để biết mô tả. Trả về khoảng cách Euclide, sqrt [x * x + y * y].

Tầng [x] FMOD [X, Y] FREXP [x] FSUM [S] Hypot [X, Y]

tiếp tục

H lib

môn Toán

252

Sự mô tả

ACOS [x] acosh [x] asin [x] asinh [x] atan [x] atan2 [y, x] atanh [x] ceil [x] copysign [x, y] cos [x] COSH [x] độ [x] x] radian [x] exp [x] fabs [x] giai thừa [x]

Tầng [x] FMOD [X, Y] FREXP [x] FSUM [S] Hypot [X, Y]

tiếp tục

Sự mô tả

ACOS [x] acosh [x] asin [x] asinh [x] atan [x] atan2 [y, x] atanh [x] ceil [x] copysign [x, y] cos [x] COSH [x] độ [x] x] radian [x] exp [x] fabs [x] giai thừa [x]

Tầng [x] FMOD [X, Y] FREXP [x] FSUM [S] Hypot [X, Y]

tiếp tục

Chương 14 Toán học

Hàm số

H lib

môn Toán

253

Mô -đun phân số cũng xác định một hàm duy nhất: GCD [A, B]

Tính toán ước số chung lớn nhất của các số nguyên A và B. Kết quả có cùng dấu hiệu B nếu B là không khác; Nếu không, nó có cùng một dấu hiệu như a.

Sự mô tả

ACOS [x] acosh [x] asin [x] asinh [x] atan [x] atan2 [y, x] atanh [x] ceil [x] copysign [x, y] cos [x] COSH [x] độ [x] x] radian [x] exp [x] fabs [x] giai thừa [x]

Tầng [x] FMOD [X, Y] FREXP [x] FSUM [S] Hypot [X, Y]

# x là một giá trị tích phân

Nếu một trong các loại kiểm tra này trả về đúng, điều đó có nghĩa là X tương thích với tất cả các hoạt động toán học thông thường được liên kết với loại đó và chuyển đổi sang một trong các loại tích hợp như phức tạp [], float [] [] sẽ làm việc. Các lớp cơ sở trừu tượng cũng có thể được sử dụng làm lớp cơ sở cho các lớp do người dùng xác định nhằm mô phỏng số. Làm điều này không chỉ là một ý tưởng tốt để kiểm tra loại, mà còn bổ sung các kiểm tra an toàn bổ sung để đảm bảo bạn thực hiện tất cả các phương pháp cần thiết. Ví dụ: >>> lớp foo [số.real]: Pass ... >>> f = foo [] Traceback [cuộc gọi gần đây nhất] Foo với các phương thức trừu tượng _ _abs_ _, _ _add_ _, _ _div_ _, _ _eq_ _, _ _ _, _ _ _

Ghi chú n

Tham khảo Chương 7 [Các lớp học và lập trình hướng đối tượng] để biết thêm thông tin về các lớp cơ sở trừu tượng. PEP 3141 [//www.python.org/dev/peps/pep-3141] có thêm thông tin về hệ thống phân cấp loại và dự định sử dụng mô-đun này.

H lib

254

Chương 14 Toán học

ngẫu nhiên Mô-đun ngẫu nhiên cung cấp một loạt các hàm để tạo các số giả ngẫu nhiên cũng như các hàm để tạo các giá trị ngẫu nhiên theo các phân phối khác nhau trên các số thực. Hầu hết các hàm trong mô -đun này phụ thuộc vào hàm ngẫu nhiên [], tạo ra các số phân phối đồng đều trong phạm vi [0,0, 1.0] bằng cách sử dụng trình tạo Twister Mersenne.

Hạt giống và khởi tạo Các chức năng sau được sử dụng để kiểm soát trạng thái của bộ tạo số ngẫu nhiên cơ bản: hạt giống [[x]]

Khởi tạo trình tạo số ngẫu nhiên. Nếu X bị bỏ qua hoặc không có, thời gian hệ thống được sử dụng để gieo hạt máy phát. Mặt khác, nếu x là số nguyên hoặc số nguyên dài, giá trị của nó được sử dụng. Nếu x không phải là một số nguyên, nó phải là một đối tượng có thể băm và giá trị của băm [x] được sử dụng làm hạt giống. getstate []

Trả về một đối tượng đại diện cho trạng thái hiện tại của trình tạo. Đối tượng này sau này có thể được chuyển cho setstate [] để khôi phục trạng thái. SetState [Bang]

Khôi phục trạng thái của trình tạo số ngẫu nhiên từ một đối tượng được trả về bởi getstate []. jumpahead [n]

Nhanh chóng thay đổi trạng thái của trình tạo thành những gì nó sẽ xảy ra nếu ngẫu nhiên [] được gọi là n lần liên tiếp. n phải là một số nguyên không âm.

Số nguyên ngẫu nhiên Các hàm sau được sử dụng để thao tác các số nguyên ngẫu nhiên. getrandbits [k]

Tạo một số nguyên dài chứa K bit ngẫu nhiên. Randint [A, B]

Trả về một số nguyên ngẫu nhiên, x, trong phạm vi A -1. Cunifvariate [trung bình, cung]

Phân phối đồng đều tròn. Trung bình là góc trung bình và cung là phạm vi phân phối, tập trung xung quanh góc trung bình. Cả hai giá trị này phải được chỉ định trong radian trong phạm vi từ 0 đến PI. Các giá trị được trả về nằm trong phạm vi [trung bình - cung/2, trung bình + cung/2]. Outvariate [Lambd]

Phân phối theo cấp số nhân. Lambd là 1,0 chia cho giá trị trung bình mong muốn. Trả về các giá trị trong phạm vi [0, +vô cực]. Gammavariate [Alpha, Beta]

Phân phối Gamma. Alpha> -1, Beta> 0. Gauss [MU, Sigma]

Phân phối Gaussian với MU trung bình và độ lệch chuẩn. Nhanh hơn một chút so với bình thường []. lognormvariate [MU, Sigma]

Đăng nhập phân phối bình thường. Làm cho logarit tự nhiên của phân phối này dẫn đến phân phối bình thường với MU trung bình và độ lệch chuẩn. Bình thường [MU, Sigma]

Phân phối bình thường với MU trung bình và độ lệch chuẩn.

H lib

Chương 14 Toán học

256

Hạt giống và khởi tạo Các chức năng sau được sử dụng để kiểm soát trạng thái của bộ tạo số ngẫu nhiên cơ bản: hạt giống [[x]]

Khôi phục trạng thái của trình tạo số ngẫu nhiên từ một đối tượng được trả về bởi getstate []. jumpahead [n]

H lib

Chương 14 Toán học

259

Hạt giống và khởi tạo Các chức năng sau được sử dụng để kiểm soát trạng thái của bộ tạo số ngẫu nhiên cơ bản: hạt giống [[x]]

Loại mã

Sự mô tả

Loại c

Kích thước tối thiểu [tính bằng byte]

'c' 'b' 'b' 'u' 'h' 'h' 'i' '' i '' l '' l '' f '' d '

Ký tự 8 bit 8 bit 8 bit 8 bit không dấu số nguyên unicode ký tự 16 bit số nguyên 16-bit số nguyên không dấu số nguyên không dấu số nguyên dài không dấu phao chính xác dài

char đã ký char unsign char py_unicode ngắn không dấu ngắn int unsignt int dài không dấu phao dài đôi

1 1 1 2 2 2 4 4 4 4 4 8

hoặc 4

hoặc hoặc hoặc hoặc

8 8 8 8

Đại diện của số nguyên và số nguyên dài được xác định bởi kiến trúc máy [chúng có thể là 32 hoặc 64 bit]. Khi các giá trị được lưu trữ dưới dạng 'l' hoặc 'i' được trả về Xác định loại sau: Mảng [Typecode [, InfitorSer]]

Tạo một mảng kiểu typecode. Khởi tạo là chuỗi hoặc danh sách các giá trị được sử dụng để khởi tạo các giá trị trong mảng. Các thuộc tính và phương thức sau áp dụng cho một đối tượng mảng, A: Mục

Sự mô tả

A.TyPecode A.ItemSize A.Append [x] A.Buffer_info []

Loại mã ký tự được sử dụng để tạo mảng. Kích thước của các mục được lưu trữ trong mảng [tính bằng byte]. Nối X đến cuối mảng. Trả về [địa chỉ, độ dài], cho vị trí bộ nhớ và độ dài của bộ đệm được sử dụng để lưu trữ mảng. Trao đổi thứ tự byte của tất cả các mục trong mảng từ lớn đến Little-endian, hoặc ngược lại. Điều này chỉ được hỗ trợ cho các giá trị số nguyên.

A.BytesWap []

tiếp tục

H lib

260

Chương 15 Cấu trúc dữ liệu, thuật toán và đơn giản hóa mã

Mục

Sự mô tả

Trả về số lần xuất hiện của x trong a. Nối b đến cuối mảng a. B có thể là một mảng hoặc một đối tượng có thể đi được có cùng loại như trong a. a.fromfile [f, n] đọc n các mục [ở định dạng nhị phân] từ đối tượng tệp f và nối vào cuối mảng. f phải là một đối tượng tệp. Tăng Eoferror nếu có thể đọc ít hơn n. a.fromlist [danh sách] nối các mục từ danh sách đến cuối mảng. Danh sách có thể là bất kỳ đối tượng khác. a.fromString [s] nối các mục từ chuỗi s, trong đó s được hiểu là một chuỗi các giá trị nhị phân, tên gọi như đã được đọc bằng cách sử dụng fromfile []. a.index [x] Trả về chỉ số của lần xuất hiện đầu tiên của x trong a. Tăng giá trịerror nếu không tìm thấy. a.insert [i, x] chèn x trước vị trí i. A.Pop [[i]] loại bỏ mục I khỏi mảng và trả về nó. Nếu tôi bị bỏ qua, phần tử cuối cùng sẽ bị loại bỏ. A.Remove [x] loại bỏ lần xuất hiện đầu tiên của X khỏi mảng. Tăng giá trịerror nếu không tìm thấy. a.reverse [] đảo ngược thứ tự của mảng. A.Tofile [f] ghi tất cả các mục vào tệp f. Dữ liệu được lưu ở định dạng nhị phân gốc. a.tolist [] chuyển đổi mảng thành một danh sách các giá trị thông thường. a.tostring [] chuyển đổi thành một chuỗi dữ liệu nhị phân, cùng một dữ liệu như được viết bằng tofile []. a.tounicode [] chuyển đổi mảng thành chuỗi unicode. Tăng giá trịerror nếu mảng không thuộc loại 'u'. A.Count [x] A.Extend [b]

Khi các mục được chèn vào một mảng, ngoại lệ kiểu kiểu được tạo nếu loại mục không khớp với loại được sử dụng để tạo mảng. Mô-đun mảng rất hữu ích nếu bạn cần lưu trữ hiệu quả không gian cho danh sách dữ liệu và bạn biết rằng tất cả các mục trong danh sách sẽ giống nhau. Ví dụ, việc lưu trữ 10 triệu số nguyên trong danh sách yêu cầu khoảng 160MB bộ nhớ trong khi một mảng 10 triệu số nguyên chỉ cần 40MB. Mặc dù tiết kiệm không gian này, không có hoạt động cơ bản nào trên một mảng có xu hướng nhanh hơn so với các đối tác danh sách của họ trên thực tế, chúng có thể chậm hơn. Khi thực hiện các tính toán với các mảng, bạn sẽ muốn cẩn thận với các hoạt động tạo ra danh sách. Ví dụ: sử dụng khả năng hiểu danh sách trên một mảng sẽ chuyển đổi toàn bộ mảng thành một danh sách, đánh bại bất kỳ lợi ích tiết kiệm không gian nào. Một cách tốt hơn để xử lý điều này là tạo các mảng mới bằng cách sử dụng các biểu thức tạo. Ví dụ: a = mảng.

# Tạo một mảng mới từ b

Bởi vì điểm sử dụng một mảng là để tiết kiệm không gian, nên có thể mong muốn hơn khi thực hiện các hoạt động tại chỗ. Một cách hiệu quả để làm điều này là với mã sử dụng Enumerate [], như thế này: a = mảng.Array ["I", [1,2,3,4,5]] cho I, x trong Enumate [a]: A [i] = 2*x

H lib

Chương 15 Cấu trúc dữ liệu, thuật toán và đơn giản hóa mã

261

Mục

# Tạo một mảng mới từ b

See Also: struct [p. 290]

bisect The bisect module provides support for keeping lists in sorted order. It uses a bisection algorithm to do most of its work. bisect[list, item [, low [, high]]]

Returns the index of the insertion point for item to be placed in list in order to maintain list in sorted order. low and high are indices specifying a subset of the list to examine. If items is already in the list, the insertion point will always be to the right of existing entries in the list. bisect_left[list, item [, low [, high]]]

Returns the index of the insertion point for item to be placed in list in order to maintain list in sorted order. low and high are indices specifying a subset of the list to examine. If items is already in the list, the insertion point will always be to the left of existing entries in the list. bisect_right[list, item [, low [, high]]]

The same as bisect[]. insort[list, item [, low [, high]]]

Inserts item into list in sorted order. If item is already in the list, the new entry is inserted to the right of any existing entries. insort_left[list, item [, low [, high]]]

Inserts item into list in sorted order. If item is already in the list, the new entry is inserted to the left of any existing entries. insort_right[list, item [, low [, high]]]

The same as insort[].

h Lib

262

Chapter 15 Data Structures, Algorithms, and Code Simplification

collections The collections module contains high-performance implementations of a few useful container types, abstract base classes for various kinds of containers, and a utility function for creating name-tuple objects. Each is described in the sections that follow.

deque and defaultdict Two new containers are defined in the collections module: deque and defaultdict. deque[[iterable [, maxlen]]]

Type representing a double-ended queue [deque, pronounced “deck”] object. iterable is an iterable object used to populate the deque. A deque allows items to be inserted or removed from either end of the queue.The implementation has been optimized so that the performance of these operations is approximately the same as [O[1]].This is slightly different from a list where operations at the front of the list may require shifting of all the elements that follow. If the optional maxlen argument is supplied, the resulting deque object becomes a circular buffer of that size.That is, if new items are added, but there is no more space, items are deleted from the opposite end to make room. An instance, d, of deque has the following methods: d.append[x]

Adds x to the right side of d. d.appendleft[x]

Adds x to the left side of d. d.clear[]

Removes all items from d. d.extend[iterable]

Extends d by adding all the items in iterable on the right. d.extendleft[iterable]

Extends d by adding all the items in iterable on the left. Due to the sequence of left appends that occur, items in iterable will appear in reverse order in d. d.pop[]

Returns and removes an item from the right side of d. Raises IndexError if d is empty. d.popleft[]

Returns and removes an item from the left side of d. Raises IndexError if d is empty. d.remove[item]

Removes the first occurrence of item. Raises ValueError if no match is found.

h Lib

collections

263

d.rotate[n]

Rotates all the items n steps to the right. If n is negative, items are rotated to the left. Deques are often overlooked by many Python programmers. However, this type offers many advantages. First, the implementation is highly efficient—even to a level of using internal data structures that provide good processor cache behavior. Appending items at the end is only slightly slower than the built-in list type, whereas inserting items at the front is significantly faster. Operations that add new items to a deque are also thread-safe, making this type appropriate for implementing queues. deques can also be serialized using the pickle module. defaultdict[[default_factory], ...]

A type that is exactly the same as a dictionary except for the handling of missing keys. When a lookup occurs on a key that does not yet exist, the function supplied as default_factory is called to provide a default value which is then saved as the value of the associated key.The remaining arguments to defaultdict are exactly the same as the built-in dict[] function. An instance d of defaultdictionary has the same operations as a built-in dictionary.The attribute d.default_factory contains the function passed as the first argument and can be modified as necessary. A defaultdict object is useful if you are trying to use a dictionary as a container for tracking data. For example, suppose you wanted to keep track of the position of each word in a string s. Here is how you could use a defaultdict to do this easily: >>> from collections import defaultdict >>> s = "yeah but no but yeah but no but yeah" >>> words = s.split[] >>> wordlocations = defaultdict[list] >>> for n, w in enumerate[words]: ... wordlocations[w].append[n] ... >>> wordlocations defaultdict[, {'yeah': [0, 4, 8], 'but': [1, 3, 5, 7], 'no': [2, 6]}] >>>

Trong ví dụ này, các từ ngữ tra cứu [w] sẽ không thành công ngay lần đầu tiên gặp một từ. Tuy nhiên, thay vì nâng cao KeyError, danh sách chức năng được cung cấp dưới dạng default_factory được gọi để tạo ra một giá trị mới. Từ điển tích hợp có một phương thức setDefault [] có thể được sử dụng để đạt được kết quả tương tự, nhưng nó thường làm cho mã khó hiểu để đọc và chạy chậm hơn. Ví dụ: câu lệnh nối một mục mới được hiển thị trước đó có thể được thay thế bằng WordLocations.setDefault [w, []]. như sử dụng một đối tượng DefaultDict.

Các bộ dữ liệu được đặt tên thường xuyên được sử dụng để thể hiện các cấu trúc dữ liệu đơn giản. Ví dụ: địa chỉ mạng có thể được biểu diễn dưới dạng tuple addr = [tên máy chủ, cổng]. Một khiếu nại phổ biến với các bộ dữ liệu là các mục riêng lẻ phải được truy cập bằng chỉ mục số Trong số các giá trị chỉ số có nghĩa là [và vấn đề trở nên tồi tệ hơn, Tuple càng lớn hơn].

H lib

264

Chương 15 Cấu trúc dữ liệu, thuật toán và đơn giản hóa mã

Mô -đun bộ sưu tập chứa một hàm có tênTuple [] được sử dụng để tạo các lớp con của tuple trong đó tên thuộc tính có thể được sử dụng để truy cập các phần tử Tuple. Được đặt tênTuple [Typename, FieldName [, Verbose]]

Tạo một lớp con của tuple với tên typename. FieldNames là danh sách các tên thuộc tính được chỉ định là chuỗi. Tên trong danh sách này phải là định danh python hợp lệ, không được bắt đầu với dấu gạch dưới và được chỉ định theo cùng thứ tự như các mục xuất hiện trong Tuple, ví dụ, ['Tên máy chủ ','Hải cảng']. Ngoài ra, các tên trường có thể được chỉ định là một chuỗi, chẳng hạn như 'Cổng máy chủ' hoặc 'tên máy chủ, cổng. của Tuples. Cờ dài dòng, nếu được đặt thành True, in định nghĩa lớp kết quả thành đầu ra tiêu chuẩn. Dưới đây là một ví dụ về việc sử dụng chức năng này: >>> từ các bộ sưu tập nhập tên được đặt tên ', 80] >>> a.

>>> isinstance [a, tuple] Đúng >>>

Trong ví dụ này, theo mọi cách, NetworkAddress được đặt tên là từ một tuple bình thường ngoại trừ sự hỗ trợ bổ sung của việc có thể sử dụng Tra cứu thuộc tính như A.Hostname hoặc A.port để truy cập các thành phần Tuple. Việc triển khai cơ bản là hiệu quả Lớp học được tạo không sử dụng từ điển thể hiện hoặc thêm bất kỳ chi phí bộ nhớ bổ sung nào trong một bộ xử lý tích hợp. Tất cả các hoạt động tuple bình thường vẫn hoạt động. Một tuple được đặt tên có thể hữu ích nếu việc xác định các đối tượng thực sự chỉ phục vụ như một cấu trúc dữ liệu. Ví dụ: thay vì xác định một lớp, như thế này: class stock [object]: def _ _init_ _ [self, name, cổ phiếu, giá]: self.name = name self.shares = chia sẻ self

Thay vào đó, bạn có thể xác định một bộ tuple có tên: Bộ sưu tập nhập khẩu = bộ sưu tập.

Cả hai phiên bản sẽ hoạt động theo cách gần như giống hệt nhau. Ví dụ: trong cả hai trường hợp, bạn sẽ truy cập các trường bằng cách viết s.name, s.shares, v.v. Tuy nhiên, lợi ích của bộ tuple được đặt tên là nó hiệu quả hơn về bộ nhớ và hỗ trợ các hoạt động tuple khác nhau như giải nén [ví dụ: nếu bạn có một danh sách các bộ dữ Đối với tên, cổ phiếu,

H lib

Chương 15 Cấu trúc dữ liệu, thuật toán và đơn giản hóa mã

265

Các lớp cơ sở trừu tượng Các mô -đun bộ sưu tập xác định một loạt các lớp cơ sở trừu tượng. Mục đích của các lớp này là để mô tả các giao diện lập trình trên các loại container như danh sách, bộ và từ điển. Có hai cách sử dụng chính của các lớp này. Đầu tiên, chúng có thể được sử dụng như một lớp cơ sở cho các đối tượng do người dùng xác định muốn mô phỏng chức năng của các loại container tích hợp. Thứ hai, chúng có thể được sử dụng để kiểm tra loại. Ví dụ: nếu bạn muốn kiểm tra xem S có hoạt động như một chuỗi hay không, bạn có thể sử dụng isinstance [s, com thu. Thùng đựng hàng

Lớp cơ sở cho tất cả các container. Xác định một phương thức trừu tượng duy nhất _ _contains_ _ [], trong đó thực hiện toán tử trong. Hashable

Lớp cơ sở cho các đối tượng có thể được sử dụng làm phím bảng băm. Xác định một phương thức trừu tượng duy nhất _ _hash_ _ []. Có thể lặp lại

Lớp cơ sở cho các đối tượng hỗ trợ giao thức lặp. Xác định một phương thức trừu tượng duy nhất _ _iter_ _ []. Người lặp lại

Lớp cơ sở cho các đối tượng lặp. Xác định phương thức trừu tượng Next [] nhưng cũng kế thừa từ ITable và cung cấp một triển khai mặc định của _ _iter_ _ [] mà đơn giản là không làm gì. Có kích thước

Lớp cơ sở cho các thùng chứa có kích thước có thể được xác định. Xác định phương thức trừu tượng _ _len_ _ []. Có thể gọi được

Lớp cơ sở cho các đối tượng hỗ trợ chức năng gọi. Xác định phương thức trừu tượng _ _call_ _ [].

H lib

266

Chương 15 Cấu trúc dữ liệu, thuật toán và đơn giản hóa mã

Sự phối hợp

Lớp cơ sở cho các đối tượng trông giống như trình tự. Kế thừa từ container, có thể lặp lại và có kích thước và xác định các phương thức trừu tượng _ _getItem_ _ [] và _ _len_ _ []. Cũng cung cấp một triển khai mặc định của _ _contains_ _ [], _ _iter_ _ [], _ _Reversed_ _ [], index [] và đếm [] Phương pháp. Mutablesequence

Lớp cơ sở cho các chuỗi có thể thay đổi. Kế thừa từ chuỗi và thêm các phương thức trừu tượng _ _setItem_ _ [] và _ _delitem_ _ []. Cũng cung cấp một triển khai mặc định của append [], larter [], extend [], pop [], remove [] và _ _iadd_ _ []. Bộ

Lớp cơ sở cho các đối tượng hoạt động như bộ. Kế thừa từ container, có thể lặp lại và có kích thước và xác định các phương thức trừu tượng _ _len_ _ [], _ _iter_ _ [] và _ _contains_ _ []. Cũng cung cấp một triển khai mặc định của các toán tử đã đặt _ _le_ _ [], _ _lt_ _ [], _ _eq_ _ [], _ _ne_ _ [], _ _gt_ _ [], _ _ _ _ _ [] , _ _or_ _ [], _ _xor_ _ [], _ _sub_ _ [] và isDisjoint []. Mutableset

Lớp cơ sở cho các bộ thay đổi. Kế thừa từ SET và thêm các phương thức trừu tượng thêm [] và loại bỏ []. Cũng cung cấp một triển khai mặc định của Clear [], pop [], Remove [], _ _ior_ _ [], _ _Iand_ _ [], _ _ixor_ _ [] và _ _isub_ _ []. Lập bản đồ

Lớp cơ sở cho các đối tượng hỗ trợ tra cứu ánh xạ [từ điển]. Kế thừa từ kích thước, có thể lặp lại và container và xác định các phương thức trừu tượng _ _getItem_ _ [], _ _len_ _ [] và _ _iter_ _ []. Một triển khai mặc định của _ _contains_ _ [], các khóa [], item [], giá trị [], get [], _ _eq_ _ [] và _ _ne_ _ [] cũng được cung cấp. Đột biến

Lớp cơ sở cho các đối tượng ánh xạ đột biến. Kế thừa từ ánh xạ và thêm các phương thức trừu tượng _ _setItem_ _ [] và _ _delitem_ _ []. Việc triển khai pop [], popitem [], Clear [], Update [] và SetDefault [] cũng được thêm vào. Ánh xạview

Lớp cơ sở để lập bản đồ chế độ xem. Chế độ xem ánh xạ là một đối tượng được sử dụng để truy cập vào bên trong của đối tượng ánh xạ dưới dạng một tập hợp. Ví dụ, chế độ xem khóa là một đối tượng giống như thiết lập hiển thị các phím trong ánh xạ. Xem Phụ lục A, Hồi Python 3 3 để biết thêm chi tiết. Keysview

Lớp cơ sở cho một chế độ xem chính của một ánh xạ. Kế thừa từ LapPingView và Set. MụcView

Lớp cơ sở cho chế độ xem mục của một ánh xạ. Kế thừa từ LapPingView và Set. ValueView

Lớp cơ sở cho chế độ xem [khóa, mục] của ánh xạ. Kế thừa từ LapPingView và Set.

H lib

Chương 15 Cấu trúc dữ liệu, thuật toán và đơn giản hóa mã

267

Sự phối hợp

Một trình trang trí tạo trình quản lý bối cảnh từ một hàm tạo Func. Cách mà bạn sử dụng trình trang trí này như sau: @ContextManager def foo [args]

Khi câu lệnh với FOO [ARGS] dưới dạng giá trị xuất hiện, hàm Trình tạo được thực thi với các đối số được cung cấp cho đến khi đạt được câu lệnh năng suất đầu tiên. Giá trị được trả về bằng năng suất được đặt vào giá trị biến. Tại thời điểm này, cơ thể của tuyên bố thực thi. Sau khi hoàn thành, hàm máy phát tiếp tục. Nếu bất kỳ loại ngoại lệ nào được nâng lên bên trong cơ thể, ngoại lệ đó được nâng lên bên trong hàm máy phát, nơi nó có thể được xử lý khi thích hợp. Nếu lỗi được truyền bá, trình tạo nên sử dụng tăng để tăng cường ngoại lệ. Một ví dụ về việc sử dụng bộ trang trí này có thể được tìm thấy trong phần Quản lý bối cảnh của Chương 5. Nested [MGR1, MGR2, ..., MGRN]

Một chức năng gọi nhiều hơn một trình quản lý bối cảnh MGR1, MGR2, v.v. như là một hoạt động duy nhất. Trả về một tuple chứa các giá trị trả về khác nhau của các câu lệnh. Tuyên bố có lồng nhau [m1, m2] là [x, y]: các câu lệnh giống như

H lib

268

Chương 15 Cấu trúc dữ liệu, thuật toán và đơn giản hóa mã

Nói với M1 là X: Với M2 là Y: Tuyên bố. Xin lưu ý rằng nếu một trình quản lý bối cảnh bên trong bẫy và triệt tiêu một ngoại lệ, không có thông tin ngoại lệ nào được chuyển cho các nhà quản lý bên ngoài. Đóng [đối tượng]

Tạo trình quản lý bối cảnh tự động thực thi object.close [] khi thực thi rời khỏi phần thân của câu lệnh. Giá trị được trả về bởi câu lệnh với đối tượng.

Các chức năng Mô-đun chức năng chứa các chức năng và bộ trang trí hữu ích để tạo các chức năng bậc cao, lập trình chức năng và trang trí. một phần [hàm [, *args [, ** kwargs]]]]]

Tạo một đối tượng giống như hàm, một phần, khi được gọi, gọi chức năng với các đối số vị trí tranh luận, đối số từ khóa kwargs và bất kỳ đối số vị trí hoặc từ khóa bổ sung nào được cung cấp. Các đối số vị trí bổ sung được thêm vào cuối của ARG và các đối số từ khóa bổ sung được hợp nhất thành kwargs, ghi đè bất kỳ giá trị được xác định trước đó [nếu có]. Một cách sử dụng điển hình của một phần [] là khi thực hiện một số lượng lớn các cuộc gọi chức năng trong đó nhiều đối số được giữ cố định. Ví dụ: từ functools nhập một phần mybutton = partial [nút, root, fg = "black", bg = "white", font = "thời gian", size = "12"] b1 = mybutton [text = "ok"] # Nút gọi [] với text = "ok" và tất cả b2 = mybutton [text = "heas

Một thể hiện P của đối tượng được tạo bởi một phần có các thuộc tính sau: Mục

Sự mô tả

P.Func P.Args

Chức năng được gọi khi p được gọi. Tuple chứa các đối số vị trí ngoài cùng bên trái được cung cấp cho P.Func khi được gọi. Các đối số vị trí bổ sung được nối với cuối giá trị này. Từ điển chứa các đối số từ khóa được cung cấp cho P.Func khi được gọi. Các đối số từ khóa bổ sung được hợp nhất vào từ điển này.

P.Keywords

Sử dụng thận trọng khi sử dụng một đối tượng một phần làm đứng cho hàm chính quy. Kết quả không chính xác giống như hàm bình thường. Chẳng hạn, nếu bạn sử dụng một phần [] bên trong định nghĩa lớp, nó hoạt động giống như một phương thức tĩnh, không phải là phương thức thể hiện. Giảm [chức năng, các mục [, ban đầu]]

Áp dụng một hàm, hàm, tích lũy cho các mục trong các mục có thể lặp lại và trả về một giá trị duy nhất. Chức năng phải lấy hai đối số và đầu tiên được áp dụng cho hai mục đầu tiên của các mục. Kết quả này và các yếu tố tiếp theo của các mặt hàng sau đó được kết hợp một lần theo cách tương tự, cho đến khi tất cả các yếu tố của các mục đã được tiêu thụ. ban đầu là giá trị bắt đầu tùy chọn được sử dụng trong tính toán đầu tiên và khi các mục là

H lib

Chương 15 Cấu trúc dữ liệu, thuật toán và đơn giản hóa mã

269

Một người trang trí thực hiện nhiệm vụ tương tự như update_wrapper [] trên hàm mà nó được áp dụng. được chỉ định và cập nhật có cùng ý nghĩa. Một cách sử dụng điển hình của trang trí này là khi viết các trang trí khác. Ví dụ: từ functools nhập Wraps def Debug [func]: @Wraps [func] def wrapping [*args, ** kwargs]: in ["Gọi % s" % func._ _name_ _] r = func [*args, *s

Xem thêm: Chương 6, Chức năng và lập trình chức năng.

Heapq Mô -đun Heapq thực hiện hàng đợi ưu tiên bằng một đống. Thoát đơn giản là danh sách các mục được đặt hàng trong đó điều kiện đống đã được áp đặt. Cụ thể, Heap [N] = B Truth [A] Trả về Đúng nếu A đúng, Sai nếu không Concat [A, B] Trả về A + B cho các chuỗi lặp lại [A, B] Trả về A * B cho chuỗi A và Số nguyên B chứa . Trả về a [b] setitem [a, b, c] a [b] = c delitem [a, b] del a [b] get , c, v] đặt A [b: c] = v delslice [a, b, c] del a [b: c] is_ [a, b] a is b is_not [a, b] a không phải là b lshift [ a, b] rshift [a, b] và_ [a, b] or_ [a, b]

Thoạt nhìn, có thể không rõ ràng tại sao mọi người muốn sử dụng các chức năng này vì các hoạt động mà chúng thực hiện có thể dễ dàng được thực hiện bằng cách nhập cú pháp bình thường. Ở đâu các chức năng này rất hữu ích khi làm việc với mã sử dụng các chức năng gọi lại và nơi bạn có thể Nếu không, được xác định một chức năng ẩn danh với Lambda. Ví dụ: hãy xem xét điểm chuẩn thời gian sau sử dụng hàm functools.reduce []: >>> từ thời gian nhập thời gian >>> timeit ["Giảm [toán tử.add, a]", "toán tử nhập khẩu; A = phạm vi [100 ] "] 12.055853843688965 >>> Thời gian [" Giảm [Lambda X, Y: X+Y, A] "

Trong ví dụ, hãy chú ý cách sử dụng toán tử.ADD khi cuộc gọi lại chạy nhanh hơn gấp đôi so với phiên bản sử dụng lambda X, y: x+y.

H lib

nhà điều hành

275

Mô -đun toán tử cũng xác định các chức năng sau tạo các trình bao bọc xung quanh quyền truy cập thuộc tính, tra cứu vật phẩm và các cuộc gọi phương thức. Attrgetter [tên [, name2 [, ... [, namen]]]]]

Tạo một đối tượng có thể gọi được, F, trong đó một cuộc gọi đến f [obj] trả về obj.name. Nếu có nhiều đối số được đưa ra, một kết quả được trả về. Ví dụ, Attrgetter ['Tên', 'Chia sẻ'] trả về [obj.name, obj.shares] khi được gọi. Tên cũng có thể bao gồm tra cứu chấm bổ sung. Ví dụ: nếu tên là "địa chỉ.hostname", thì f [obj] trả về obj.address.hostname. itemgetter [item [, item2 [, ... [, itemn]]]]]

Tạo một đối tượng có thể gọi được, F, trong đó một cuộc gọi đến F [obj] trả về obj [item]. Nếu có nhiều mục được đưa ra dưới dạng đối số, một cuộc gọi đến f [obj] trả về một tuple chứa [obj [item], obj [item2], ..., obj [itemn]]. MethodCaller [name [, *args [, ** kwargs]]]]

Tạo một đối tượng có thể gọi được, f, trong đó một cuộc gọi đến f [obj] trả về obj.name [*args, ** kwargs].

Các chức năng này cũng hữu ích để tối ưu hóa hiệu suất của các hoạt động liên quan đến chức năng gọi lại, đặc biệt là các chức năng liên quan đến các hoạt động xử lý dữ liệu phổ biến như sắp xếp. Ví dụ: nếu bạn muốn sắp xếp một danh sách các hàng Tuples trên cột 2, bạn có thể sử dụng Sắp xếp [hàng, key = lambda r: r [2]] hoặc sử dụng được sắp xếp [hàng, key = itemgetter [2]]. Phiên bản thứ hai chạy nhanh hơn nhiều vì nó tránh được chi phí liên quan đến Lambda.

H lib

nhà điều hành

H lib

nhà điều hành

Tạo một đối tượng có thể gọi được, f, trong đó một cuộc gọi đến f [obj] trả về obj.name [*args, ** kwargs].

Một hàm mã hóa không trạng thái mã hóa chuỗi Unicode S và trả về một tuple [byte, length_consumed]. Byte là một chuỗi 8 bit hoặc mảng byte chứa dữ liệu được mã hóa. LEGET_CONSUMED là số lượng ký tự trong s được mã hóa. Lỗi là chính sách xử lý lỗi và được đặt thành 'nghiêm ngặt' theo mặc định. c.decode [byte [, lỗi]]

Một hàm mã hóa không trạng thái giải mã byte chuỗi byte và trả về một tuple [s, length_consumed]. s là một chuỗi unicode và lewt_consumed là số byte trong byte đã được tiêu thụ trong quá trình giải mã. Lỗi là chính sách xử lý lỗi và được đặt thành 'nghiêm ngặt theo mặc định.

H lib

278

Chương 16 Chuỗi và xử lý văn bản

C.StreamReader [byteStream [, lỗi]]

Trả về một phiên bản StreamReader được sử dụng để đọc dữ liệu được mã hóa. ByteStream là một đối tượng giống như tệp đã được mở ở chế độ nhị phân. Lỗi là chính sách xử lý lỗi và theo mặc định 'nghiêm ngặt'. Một phiên bản R của StreamReader hỗ trợ các hoạt động I/O cấp thấp sau: Phương thức

Sự mô tả

R.Read [[size [, chars [, firstline]]]] trả về hầu hết các ký tự ký tự của văn bản được giải mã. Kích thước là số lượng byte tối đa để đọc từ dòng byte cấp thấp và được sử dụng để kiểm soát bộ đệm bên trong. FirstLine là một lá cờ, nếu được đặt, trả về dòng đầu tiên ngay cả khi xảy ra lỗi giải mã sau đó trong tệp. R.Readline [[Kích thước [, Keepends]]] trả về một dòng văn bản được giải mã. Keepends là một lá cờ kiểm soát liệu các kết thúc dòng có được bảo tồn hay không [đúng theo mặc định]. R.Readlines [[kích thước [, Keepends]]] đọc tất cả các dòng vào một danh sách. R.Reset [] đặt lại bộ đệm bên trong và trạng thái.

C.StreamWriter [byteStream [, lỗi]]

Trả về một thể hiện StreamWriter được sử dụng để ghi dữ liệu được mã hóa. ByteStream là một đối tượng giống như tệp đã được mở trong chế độ byte. Lỗi là chính sách xử lý lỗi và theo mặc định 'nghiêm ngặt'. Một thể hiện W của Streamwriter hỗ trợ các hoạt động I/O cấp thấp sau: Phương thức

Sự mô tả

C.StreamWriter [byteStream [, lỗi]]

W.Write [S] W.Writelines [dòng] W.Reset []

Sự mô tả

C.StreamWriter [byteStream [, lỗi]]

H lib

Chương 16 Chuỗi và xử lý văn bản

279

C.StreamReader [byteStream [, lỗi]]

Sự mô tả

C.StreamWriter [byteStream [, lỗi]]

W.Write [S] W.Writelines [dòng] W.Reset []

Viết một biểu diễn được mã hóa của chuỗi S ghi một danh sách các chuỗi trong các dòng vào tệp đặt lại bộ đệm bên trong và trạng thái

c.incrementalencoder [[lỗi]]

Trả về một phiên bản gia tăng có thể được sử dụng để mã hóa các chuỗi trong nhiều bước. Lỗi là 'nghiêm ngặt' theo mặc định. Một thể hiện e của gia tăng có các phương pháp sau: Phương thức

E.Code [s [, cuối cùng]]

[, lỗi]]

Một hàm máy phát điện tăng dần phân giải tất cả các chuỗi byte trong ITEBLEBELDE theo mã hóa được chỉ định. Lỗi là 'nghiêm ngặt' theo mặc định.

Các hằng số hữu ích Codec định nghĩa các hằng số đánh dấu thứ tự byte sau đây có thể được sử dụng để giúp đỡ

Giải thích các tệp khi bạn không biết bất cứ điều gì về mã hóa cơ bản. Những điều này

H lib

Chương 16 Chuỗi và xử lý văn bản

280

Các điểm đánh dấu thứ tự byte đôi khi được viết ở đầu một tệp để chỉ ra mã hóa ký tự của nó và có thể được sử dụng để chọn một codec thích hợp để sử dụng. Không thay đổi

Sự mô tả

Bom Bom_be

Điểm đánh dấu thứ tự byte gốc cho máy [BOM_BE hoặc BOM_LE] Điểm đánh dấu thứ tự byte lớn ['\ xfe \ xff'] đánh dấu little-endian byte ['\ xff \ xfe'] đánh dấu utf-8 ['\ \ XEF \ xbb \ xbf '] 16 bit UTF-16 Big-Endian Mark -endian đánh dấu ['\ x00 \ x00 \ xfe \ xff'] 32 bit UTF-32 Little-Endian Mark

BOM_LE BOM_UTF8 BOM_UTF16_BE BOM_UTF16_LE BOM_UTF32_BE BOM_UTF32_LE

Mã hóa tiêu chuẩn Sau đây là danh sách một số mã hóa ký tự được sử dụng phổ biến nhất. Tên mã hóa là những gì bạn sẽ chuyển đến các hàm như Open [] hoặc Tra cứu [] khi chỉ định mã hóa. Một danh sách đầy đủ các mã hóa có thể được tìm thấy bằng cách tham khảo tài liệu trực tuyến cho mô -đun Codecs [//docs.python.org/l Library/codecs]. Tên codec

Sự mô tả

Bom Bom_be

BOM_LE BOM_UTF8 BOM_UTF16_BE BOM_UTF16_LE BOM_UTF32_BE BOM_UTF32_LE

ASCII CP437 CP1252 LATIN-1, ISO-8859-1 UTF-16 UTF-16-BE UTF-16-LE UTF-32 UTF-32-BE UTF-32-LE UTF-8

H lib

Chương 16 Chuỗi và xử lý văn bản

281

Sự mô tả

Bom Bom_be

+ ? *? +? ?? {m} {m, n}

{m, n}? [...]

[^...] A|B [...]

continues

h Lib

282

Chapter 16 String and Text Handling

Character[s]

Description

Interprets the letters "a", "i", "L", "m", "s", "u", and "x" as flag settings corresponding to the re.A, re.I, re.L, re.M, re.S, re.U, re.X flag settings given to re.compile[]. "a" only available in Python 3. [?:...] Matches the regular expression inside the parentheses but discards the matched substring. [?P...] Matches the regular expression in the parentheses and creates a named group. The group name must be a valid Python identifier. [?P=name] Matches the same text that was matched by an earlier named group. [?#...] A comment. The contents of the parentheses are ignored. [?=...] Matches the preceding expression only if followed by the pattern in the parentheses. For example, r'Hello [?=World]' matches 'Hello ' only if followed by 'World'. [?!...] Matches the preceding expression only if it’s not followed by the pattern in parentheses. For example, r'Hello [?!World]' matches 'Hello ' only if it’s not followed by 'World'. [? and . POSIX defines the following constants for name: Constant

Description

"PC_ASYNC_IO"

Indicates whether asynchronous I/O can be performed on fd. Indicates whether the chown[] function can be used. If fd refers to a directory, this applies to all files in the directory. Maximum size of a file. Maximum value of the file’s link count. Maximum length of a formatted input line. fd refers to a terminal. Maximum length of an input line. fd refers to a terminal.

"PC_CHOWN_RESTRICTED"

"PC_FILESIZEBITS" "PC_LINK_MAX" "PC_MAX_CANON" "PC_MAX_INPUT"

h Lib

383

Constant

Description

"PC_NAME_MAX" "PC_NO_TRUNC"

Maximum length of a filename in a directory. Indicates whether an attempt to create a file with a name longer than PC_NAME_MAX for a directory will fail with an ENAMETOOLONG error. Maximum length of a relative path name when the directory fd is the current working directory. Size of the pipe buffer when fd refers to a pipe or FIFO. Indicates whether priority I/O can be performed on fd. Indicates whether synchronous I/O can be performed on fd. Indicates whether fd allows special-character processing to be disabled. fd must refer to a terminal.

"PC_PATH_MAX" "PC_PIPE_BUF" "PC_PRIO_IO" "PC_SYNC_IO" "PC_VDISABLE"

Not all names are available on all platforms, and some systems may define additional configuration parameters. However, a list of the names known to the operating system can be found in the dictionary os.pathconf_names. If a known configuration name is not included in os.pathconf_names, its integer value can also be passed as name. Even if a name is recognized by Python, this function may still raise an OSError if the host operating system doesn’t recognize the parameter or associate it with the file fd.This function is only available on some versions of UNIX. fstat[fd]

Returns the status for file descriptor fd. Returns the same values as the os.stat[] function [UNIX and Windows]. fstatvfs[fd]

Returns information about the file system containing the file associated with file descriptor fd. Returns the same values as the os.statvfs[] function [UNIX]. fsync[fd]

Forces any unwritten data on fd to be written to disk. Note that if you are using an object with buffered I/O [for example, a Python file object], you should first flush the data before calling fsync[]. Available on UNIX and Windows. ftruncate[fd, length]

Truncates the file corresponding to file descriptor fd so that it’s at most length bytes in size [UNIX]. isatty[fd]

Returns True if fd is associated with a TTY-like device such as a terminal [UNIX]. lseek[fd, pos, how]

Sets the current position of file descriptor fd to position pos.Values of how are as follows: SEEK_SET sets the position relative to the beginning of the file, SEEK_CUR sets it relative to the current position, and SEEK_END sets it relative to the end of the file. In older Python code, it is common to see these constants replaced with their numeric values of 0, 1, or 2, respectively.

h Lib

384

Chapter 19 Operating System Services

open[file [, flags [, mode]]]

Opens the file file. flags is the bitwise OR of the following constant values: Value

Description

O_RDONLY O_WRONLY

Open the file for reading. Open the file for writing. Open for reading and writing [updates]. Append bytes to the end of the file. Create the file if it doesn’t exist. Don’t block on open, read, or write [UNIX]. Same as O_NONBLOCK [UNIX]. Synchronous writes [UNIX]. When opening a device, don’t set controlling terminal [UNIX]. If the file exists, truncates to zero length. Synchronous reads [UNIX]. Synchronous writes [UNIX]. Error if O_CREAT and the file already exists. Set an exclusive lock on the file. Set a shared lock on the file. Enables asynchronous input mode in which a SIGIO signal is generated with input is available. Use direct I/O mode where reads and writes go directly to the disk instead of the operating system read/write caches. Raises an error if the file is not a directory. Don’t follow symbolic links. Don’t update the last access time of the file. Text mode [Windows]. Binary mode [Windows]. File not inherited by child processes [Windows]. Hint to system that the file is used for short-term storage [Windows]. Delete file when closed [Windows]. Hint to system that file will be used for random access [Windows]. Hint to system that file will be accessed sequentially [Windows].

O_rdwr

Các chế độ I/O đồng bộ [O_Sync, O_DSYNC, O_RSYNC] Các hoạt động I/O buộc chặn cho đến khi chúng được hoàn thành ở cấp độ phần cứng [ví dụ: ghi sẽ chặn cho đến khi các byte được ghi vào đĩa]. Tham số chứa các quyền của tệp được biểu thị dưới dạng bitwise hoặc của các giá trị octal sau [được định nghĩa là hằng số trong mô -đun thống kê như đã chỉ ra]: Chế độ

Nghĩa

0100 0200 0400 0700

Người dùng người dùng người dùng

Có đã có

thực thi quyền [stat.s_ixusr]. Viết quyền [stat.s_iwusr]. Đọc quyền [stat.s_irusr]. Đọc/Viết/Quyền thực thi [Stat.S_IRWXU].

H lib

hệ điều hành

Cách thức

Nghĩa

0100 0200 0400 0700

Người dùng người dùng người dùng

Có đã có

385

thực thi quyền [stat.s_ixusr]. Viết quyền [stat.s_iwusr]. Đọc quyền [stat.s_irusr]. Đọc/Viết/Quyền thực thi [Stat.S_IRWXU].

H lib

hệ điều hành

H lib

386

hệ điều hành

Cách thức

0010 0020 0040 0070

Nhóm có quyền thực thi [stat.s_ixgrp]. Nhóm có quyền viết [Stat.S_IWGRP]. Nhóm có quyền đọc [stat.s_irgrp]. Nhóm có quyền đọc/ghi/thực thi [Stat.S_IRWXG]. Những người khác có quyền thực thi [stat.s_ixoth]. Những người khác có quyền viết [stat.s_iwoth]. Những người khác có quyền đọc [stat.s_iroth]. Những người khác có quyền đọc/viết/thực thi [Stat.S_IRWXO]. Đặt chế độ UID [Stat.S_ISUID]. Đặt chế độ GID [stat.s_isgid]. Đặt bit dính [stat.s_isvtx].

0001 0002 0004 0007 4000 2000 1000

Chế độ mặc định của một tệp là [0777 & ˜umask], trong đó cài đặt UMASK được sử dụng để xóa các quyền đã chọn. Ví dụ: UMASK của 0022 sẽ loại bỏ quyền ghi cho các nhóm và các nhóm khác. UMASK có thể được thay đổi bằng hàm os.umask []. Cài đặt UMASK không có tác dụng trên Windows. OpenPty []

Mở một thiết bị đầu cuối psuedo và trả về một cặp mô tả tệp [chủ, nô lệ] cho pty và tty. Có sẵn trên một số phiên bản của Unix. đường ống[]

Tạo một đường ống có thể được sử dụng để thiết lập giao tiếp đơn hướng với một quy trình khác. Trả về một cặp mô tả tệp [R, W] có thể sử dụng để đọc và ghi, hàm này thường được gọi trước khi thực thi hàm fork []. Sau khi nĩa [], quá trình gửi đóng đầu đọc của đường ống và quá trình nhận đóng đầu cuối của đường ống. Tại thời điểm này, đường ống được kích hoạt và dữ liệu có thể được gửi từ quy trình này sang quy trình khác bằng các hàm đọc [] và write [] [UNIX]. Đọc [FD, N]

Đọc nhiều nhất n byte từ bộ mô tả tệp fd. Trả về một chuỗi byte chứa các byte đọc. tcgetpgrp [FD]

Trả về nhóm quy trình được liên kết với thiết bị đầu cuối điều khiển được đưa ra bởi FD [UNIX]. TCSETPGRP [FD, PG]

Nghĩa

stat.uf_nodump

Không đổ tệp. Các tập tin chỉ đọc. Tệp chỉ hỗ trợ các hoạt động phụ lục. Thư mục mờ đục. Các tập tin có thể không bị xóa hoặc đổi tên. Các tập tin có thể được lưu trữ. Các tập tin chỉ đọc. Tệp chỉ hỗ trợ các hoạt động phụ lục. Các tập tin có thể không bị xóa hoặc đổi tên. Tệp là một tệp ảnh chụp nhanh.

stat.uf_immutable stat.uf_append stat.uf_opaque stat.uf_nounlink stat.sf_archived stat.sf_immutable stat.sf_append stat.sf_nounlink stat.sf_snapshot

H lib

hệ điều hành

387

Chmod [đường dẫn, chế độ]

Thay đổi chế độ của đường dẫn. Chế độ có các giá trị tương tự như được mô tả cho hàm Open [] [UNIX và Windows]. Chown [đường dẫn, uid, gid]

Thay đổi chủ sở hữu và ID nhóm của đường dẫn đến UID và GID số. Đặt UID hoặc GID thành -1 khiến tham số đó vẫn không được sửa đổi [UNIX]. LCHFLAGS [đường dẫn, cờ]

Giống như Chflags [], nhưng không theo các liên kết tượng trưng [UNIX]. LCHMOD [đường dẫn, chế độ]

Giống như chmod [] ngoại trừ nếu đường dẫn là một liên kết tượng trưng, nó sẽ tự sửa đổi liên kết, chứ không phải tệp mà liên kết đề cập đến. lchown [đường dẫn, uid, gid]

Giống như Chown [] nhưng không theo các liên kết tượng trưng [UNIX]. liên kết [SRC, DST]

Tạo một liên kết cứng có tên DST chỉ vào SRC [UNIX]. ListDir [Path]

Trả về một danh sách chứa tên của các mục trong đường dẫn thư mục. Danh sách được trả về theo thứ tự tùy ý và không bao gồm các mục đặc biệt của '.' và '..'. Nếu đường dẫn là unicode, danh sách kết quả sẽ chỉ chứa các chuỗi unicode. Xin lưu ý rằng nếu bất kỳ tên tệp nào trong thư mục có thể được mã hóa đúng vào Unicode, chúng sẽ được bỏ qua. Nếu đường dẫn được đưa ra dưới dạng chuỗi byte, thì tất cả các tên tệp được trả về làm danh sách các chuỗi byte. lstat [đường dẫn]

Giống như Stat [] nhưng không theo các liên kết tượng trưng [UNIX]. Makedev [Thiếu tá, Minor]

Tạo một số thiết bị thô được đưa ra số thiết bị chính và nhỏ [UNIX]. Thiếu tá [DeviceNum]

Trả về số thiết bị chính từ số thiết bị thô DeviceNum được tạo bởi makedev []. Minor [Devicenum]

Trả về số thiết bị nhỏ từ số thiết bị thô DeviceNum được tạo bởi makedev []. makedirs [đường dẫn [, chế độ]]

Chức năng tạo thư mục đệ quy. Giống như mkdir [] nhưng làm cho tất cả các thư mục trung gian cần thiết để chứa thư mục lá. Tăng một ngoại lệ Oserror nếu thư mục lá đã tồn tại hoặc không thể được tạo ra.

H lib

388