PCPP1: Certified Professional in Python Programming 1 認證課程
課程簡稱：PCPP1 Training Course

PCPP1: Certified Professional in Python Programming 1 認證是 OpenEDG Python Institute 提供的專業證書之一，旨在評估個人在 Python 程式語言和相關技術方面的高級編程能力。

這個認證適用於開發人員、IT 專業人員以及希望在電腦編程和 Python 語言領域展示自己技能和專業知識的人士。這認證也是你將來考取 PCPP2: Certified Professional in Python Programming 2 認證時的先決條件。

通過考取 PCPP1 認證，可以顯示出你在 Python 程式設計中具備了以下的能力：

• 在 Python 編程上，懂得及應用高級類別和物件導向編程 (Object-oriented Programming) 方面的知識。
• 熟悉 Python 編程上的設計 / 編程慣例以及標準。
• 了解如何使用基本工具、工具包、慣例和事件驅動編程元素來建立圖像介面 (GUI) 應用程式。
• 認識網路編程的基本概念、客戶端-服務器之間的通訊形式以及網路傳送資料所用的格式，從而編寫具備網路功能的 Python 程式。
• 具備使用 Python 標準程式庫模組來進行文件及數據處理和通訊的能力。

如果你已經獲得了 PCAP (Python Certified Associate Programmer) 認證，通過獲得 PCPP 認證可以進一步提升你的 Python 編程知識和技能，從而對 Python 有更深入的理解，及擴展了你作為程序員的能力，使你能夠應對更複雜的項目並承擔更高級別的責任。

若不打算考取 PCPP1 認證，你也可以通過本課程認識 Python 語言的進階知識。除了考試範圍要求的知識外，本課程也會提及在物件導向編程的不同技術上 Python 與其他程式語言差異之處、當實際運用課堂上教授的技術時要留意的地方、以及會簡單介紹考試範圍外的一些相關技術等等，務求令你有能力在不同範疇上，更得心應手地編寫高階的 Python 程式。

本中心的 PCPP1: Certified Professional in Python Programming 1 認證課程籌備多時，精心編排。由上堂、溫習、實習、考試研習、做試題至最後考試，均為你度身訂造，作出有系統的編排。務求真正教識你，又令你考試及格。

本中心為 Open Education and Development Group 指定的考試試場。報考時請致電本中心，登記欲報考之科目、考試日期及時間 (最快可即日報考)。臨考試前考生須出示身份證及繳付考試費。

考試編號 PCPP-32-101 考試費為 HK$1,599。

考試題目由澳洲考試中心傳送到你要應考的電腦，考試時以電腦作答。所有考試題目均為英文，而大多數的考試題目為選擇題。

考試不合格便可重新報考，不限次數。欲知道作答時間、題目總數、合格分數等詳細考試資料，可瀏覽本中心網頁 "各科考試分數資料"。

1. Advanced Object-Oriented Programming

1.1 Understand and explain the basic terms and programming concepts used in the OOP paradigm

1. essential terminology: class, instance, object, attribute, method, type, instance and class variables, superclasses and subclasses
2. reflexion: isinstance(), issubclass()
3. the __init__() method
4. creating classes, methods, and class and instance variables; calling methods; accessing class and instance variables

1.2 Perform Python core syntax operations

1. Python core syntax expressions – magic methods: comparison methods (e.g. __eq__(self, other)), numeric methods (e.g. __abs__(self)), type conversion methods (e.g. __init__(self)), object intro- and retrospection (e.g. __str__(self), __instancecheck__(self, object)), object attribute access (e.g. __getattr__(self, attribute)), accessing containers (e.g. __getitem__(self, key))
2. operating with special methods
3. extending class implementations to support additional core syntax operations

1.3 Understand and use the concepts of inheritance, polymorphism, and composition

1. class hierarchies
2. single vs. multiple inheritance
3. Method Resolution Order (MRO)
4. duck typing
5. inheritance vs. composition
6. modelling real-life problems using the "is a" and "has a" relations

1.4 Understand the concept of extended function argument syntax and demonstrate proficiency in using decorators

1. special identifiers: *args, **kwargs
2. forwarding arguments to other functions
3. function parameter handling
4. closures
5. function and class decorators
6. decorating functions with classes
7. creating decorators and operating with them: implementing decorator patterns, decorator arguments, wrappers
8. decorator stacking
9. syntactic sugar
10. special methods: __call__, __init__

1.5 Design, build, and use Python static and class methods

1. implementing class and static methods
2. class vs. static methods
3. the cls parameter
4. the @classmethod and @staticmethod decorators
5. class methods: accessing and modifying the state/methods of a class, creating objects

1.6 Understand and use Python abstract classes and methods

1. abstract classes and abstract methods: defining, creating, and implementing abstract classes and abstract methods
2. overriding abstract methods
3. implementing a multiple inheritance from abstract classes
4. delivering multiple child classes

1.7 Understand and use the concept of attribute encapsulation

1. definition, meaning, usage
2. operating with the getter, setter, and deleter methods

1.8 Understand and apply the concept of subclassing built-in classes

1. inheriting properties from built-in classes
2. using the concept of subclassing the built-ins to extend class features and modify class methods and attributes

1.9 Demonstrate proficiency in the advanced techniques for creating and serving exceptions

1. exceptions as objects, named attributes of exception objects, basic terms and concepts
2. chained exceptions, the __context__ and __cause__ attributes, implicitly and explicitly chained exceptions
3. analyzing exception traceback objects, the __traceback__ attribute
4. operating with different kinds of exceptions

1.10 Demonstrate proficiency in performing shallow and deep copy operations

1. shallow and deep copies of objects
2. object: label vs. identity vs. value
3. the id() function and the is operand
4. operating with the copy() and deepcopy() methods

1.11 Understand and perform (de)serialization of Python objects

1. object persistence, serialization and deserialization: meaning, purpose, usage
2. serializing objects as a single byte stream: the pickle module, pickling various data types
3. the dumps() and loads functions
4. serializing objects by implementing a serialization dictionary: the shelve module, file modes, creating shelve objects

1.12 Understand and explain the concept of metaprogramming

1. metaclasses: meaning, purpose, usage
2. the type metaclass and the type() function
3. special attributes: __name__, __class__, __bases__, __dict__
4. operating with metaclasses, class variables, and class methods

2. Coding Conventions, Best Practices, and Standardization (12%) Objectives covered by the block (7 exam items)

2.1 Understand and explain the concept of Python Enhancement Proposals and Python philosophy

1. the PEP concept and selected PEPs: PEP 1, PEP 8, PEP 20, PEP 257
2. PEP 1: different types of PEPs, formats, purpose, guidelines
3. PEP 20: Python philosophy, its guiding principles, and design; the import this instruction and PEP 20 aphorisms

2.2 Employ the PEP 8 guidelines, coding conventions, and best practices

1. PEP 8 compliant checkers
2. recommendations for code layout: indentation, continuation lines, maximum line length, line breaks, blank lines (vertical whitespaces)
3. default encodings
4. module imports
5. recommendations for string quotes, whitespace, and trailing commas: single-quoted vs. double-quoted strings, whitespace in expressions and statements, whitespace and trailing commas
6. recommendations for using comments: block comments, inline comments
7. documentation strings
8. naming conventions: naming styles, recommendations
9. programming recommendations

2.3 Employ the PEP 257 guidelines, conventions, and best practices

1. docstrings: rationale, usage
2. comments vs. docstrings
3. PEP 484 and type hints
4. creating, using, and accessing docstrings
5. one-line vs. multi-line docstrings
6. documentation standards, linters, fixers

3. GUI Programming (20%) Objectives covered by the block (8 exam items)

3.1 Understand and explain the basic concepts and terminology related to GUI programming

1. GUI: meaning, rationale, basic terms and definitions
2. visual programming: examples, basic features
3. widgets/controls – basic terms: windows, title and title bars, buttons, icons, labels, etc.
4. classical vs. event-driven programming
5. events – basic terms
6. widget toolkits/GUI toolkits

3.2 Use GUI toolkits, basic blocks, and conventions to design and build simple GUI applications

1. importing tkinter components
2. creating an application's main window: the Tk(), mainloop(), and title methods
3. adding widgets to the window: buttons, labels, frames, the place() method, widget constructors, location, screen coordinates, size, etc.
4. launching the event controller: event handlers, defining and using callbacks, the destroy() method, dialog boxes
5. shaping the main window and interacting with the user
6. checking the validity of user input and handling errors
7. working with Canvas and its methods
8. using the Entry, Radiobutton, and Button widgets
9. managing widgets with the grid and place managers
10. binding events using the bind() method

3.3 Demonstrate proficiency in using widgets and handling events

1. settling widgets in the window's interior, geometry managers
2. coloring widgets, color modes: RGB, HEX
3. event handling: writing event handlers and assigning them to widgets
4. event-driven programming: implementing interfaces using events and callbacks
5. widget properties and methods
6. variables: observable variables and adding observers to variables
7. using selected clickable and non-clickable widgets
8. identifying and servicing GUI events

4. Network Programming (18%) Objectives covered by the block (8 exam items)

4.1 Understand and explain the basic concepts of network programming

1. REST
2. network sockets
3. Domains, addresses, ports, protocols, and services
4. Network communication: connection-oriented vs. connectionless communication, clients and servers

4.2 Demonstrate proficiency in working with sockets in Python

1. the socket module: importing and creating sockets
2. connecting sockets to HTTP servers, closing connections with servers
3. sending requests to servers, the send() method
4. receiving responses from servers, the recv() method
5. exception handling mechanisms and exception types

4.3 Employ data transfer mechanisms for network communication

1. JSON: syntax, structure, data types (numbers, strings, Boolean values, null), compound data (arrays and objects), sample JSON documents and their anatomies
2. the json module: serialization and deserialization, serializing Python data/deserializing JSON (the dumps() and loads methods), serializing and deserializing Python objects
3. XML: syntax, structure, sample xml documents and their anatomies, DTD, XML as a tree
4. processing xml files

4.4 Design, develop, and improve a simple REST client

1. the request module
2. designing, building, and using testing environments
3. HTTP methods: GET, POST, PUT, DELETE
4. CRUD
5. adding and updating data
6. fetching and removing data from servers
7. analyzing the server's response
8. response status codes

5. File Processing and Communicating with a Program’s Environment (15%) Objectives covered by the block (7 exam items)

5.1 Demonstrate proficiency in database programming in Python

1. the sqlite module
2. creating and closing database connection using the connect and close methods
3. creating tables
4. inserting, reading, updating, and deleting data
5. transaction demarcation
6. cursor methods: execute, executemany, fetchone, fetchall
7. creating basic SQL statements (SELECT, INSERT INTO, UPDATE, DELETE, etc.)

5.2 Demonstrate proficiency in processing different file formats in Python

1. parsing XML documents
2. searching data in XML documents using the find and findall methods
3. building XML documents using the Element class and the SubElement function
4. reading and writing CSV data using functions and classes: reader, writer, DictReader, DictWriter
5. logging events in applications
6. working with different levels of logging
7. using LogRecord attributes to create log formats
8. creating custom handlers and formatters
9. parsing and creating configuration files using the ConfigParser object
10. interpolating values in .ini files

※ The course content above may change at any time without notice in order to better reflect the content of the examination.