1.
Variables are identifiers and manage state.
1.1.
Reserved words (keywords) used in grammar rules
1.2.
Learn about strings that name variables
1.3.
Variable name definition rules
1.4.
Follow along: Understanding Built-in and Global Namespaces

2.
All values ​​are objects.
2.1 Literal notation for creating objects directly
2.2 Expressions, which are a group of literals and operators
2.3.
Follow along: Learn operators and special methods.

3.
Evaluates expressions and sentences.

3.1 Run it immediately and see the results
3.2 Running after creating a specific object
3.3.
Follow along: Insert a formula into a string and calculate it.

4.
The class that created the object is the data type.
4.1 Determining the data type after binding the variable to an object
4.2 Mutation of object elements
4.3 Learn about type conversion to create other objects
4.4.
Follow: Check if change is possible

5.
Decorate sentences
5.1 Lines and Indentation in Block Statements
5.2 Multi-Line Statements
5.3 Writing multiple sentences inline
5.4 Follow-up: Randomly extracting a specific number

6.
Document and annotate
6.1 Docstrings for functions and classes
6.2 Comments explaining sentences
6.3 Follow-up: Using type hints for variables

7.
Handling assignments and other statements
7.1 Statements that assign values ​​to variables
7.2 Pass statement with no function
7.3 Handling unused variables
7.4 Follow-up: Understanding the map class

8.
Selecting sentences based on conditional judgment
8.1 Simple control statements for handling simple conditions
8.2 Compound control statements that evaluate various conditions
8.3 Follow-up: Treating conditional operators as special methods

9.
Repeat execution of multiple sentences
9.1 Processing a for loop that iterates over an iterable object
9.2 Processing a while loop that evaluates a conditional expression
9.3 Eliminating circular processing
9.4 Adding an else statement to a loop
9.5 Try It Out: Extracting Elements from an Object with Multiple Elements

10.
Select features based on various conditions
10.1 Expressing ternary operations as inline control statements
10.2 Switch case statement that evaluates conditions based on specific values
10.3 Follow-up: Searching with Specific Index Information

11.
Defining a function
11.1 Function definition statement that creates a function object
11.2 Getting to Know Python Help
11.3 Functions are first-class objects.
11.4 Follow-up: Calling functions by accessing their names

12.
Processing function input data
12.1 Handling fixed and variable positional arguments
12.2 Handling mixed parameters
12.3 Follow-up: Converting an index lookup function to a method

13.
Defining a class
13.1 Statements defining a class that creates objects
13.2 Adding properties and instance methods to objects
13.3 Defining class properties within a class
13.4 Follow-up: Understanding Callable

14.
Understanding class and object structure
14.1.
Check object and class relationships
14.2.
Object introspection
14.3.
Object reference comparison method
14.4 Follow-up: Defining a class with dataclass

15.
Learn about special built-in classes
15.1 Objects managed by reserved words
15.2 Classes that handle ranges

16.
Top-level class object
16.1 Understanding Class Internal Properties
16.2 Understanding Class Internal Methods
16.3 Follow-up: Testing Documentation with DocTesting

17.
Learn about the Number class module
17.1 Learn about modules that calculate rational numbers and precise numbers.
17.2 Learn about modules that provide operators

18.
Learn about the string class
18.1 Unicode and Byte String Classes
18.2 Understanding Unicode and Byte String Encoding

19.
Learn about array-type data structures
19.1 Tuples and Named Tuples
19.2 List
19.3 Shallow copy and deep copy
19.4.
Try it out: Creating a Queue Data Structure

20.
Learn about index search and sorting
20.1 Indexing
20.2 Slicing
20.3 Sorting
20.4.
Try it out: Converting a function to a method

21.
Set and Dictionary classes
21.1 Dictionary
21.2 Set
21.3.
Try it out: Handling Heap Data Structures

22.
Learn about comprehension
22.1 List Comprehensions
22.2 Dictionaries and Set Comprehensions
22.3 Things to keep in mind when handling comprehension
22.4.
Try it out: Dynamically Processing Iterators

23.
Handling recursive and composite functions
23.1 Handling recursive functions that repeat themselves
23.2 Handling composite functions that pass functions to functions
23.3.
Try it out: Using object namespaces when executing recursive functions

24.
Treating functions as expressions
24.1 Lambda functions
24.2 Follow-up: Processing Composed Functions Using Lambda Functions

25.
Defining a function inside a function
25.1 Defining an inner function within an outer function
25.2 Understanding the Scope of Function Namespaces
25.3 Understanding the Clojure Environment
25.4 Handling Partial Functions
25.5 Follow-up: Handling Currying

26.
Using properties of function objects
26.1 Adding Properties to a Function Object
26.2 Sharing information about the function being executed
26.3 Follow-up: Handling Multi-Dispatch

27.
Learn about decorators using functions
27.1 Defining a Function Decorator
27.2 Maintaining execution function meta information
27.3 Receiving decorator parameters
27.4.
Try It Out: Updating a Class with a Decorator

28.
Learn how to write modules
28.1 Understanding Module Classes
28.2 Creating and Running a Module
28.3 Running a module with the shell

29.
Metaclass that creates classes
29.1 Metaclass
29.2 User metaclasses
29.3 Understanding Class Namespace Access Criteria
29.4 Follow-up: Using Inner Classes Within Decorator Functions

30.
Understanding the Object Lifecycle
30.1 Understanding constructors, initialization, and destructors
30.2 Using Weak References
30.3 Try it out: Singleton Pattern

31.
Understanding the different methods
31.1 Instance Methods
31.2 Class Methods
31.3 Static Methods
31.4.
Try it out: Creating a Custom Method Class

32.
Configuring a chain of continuous execution
32.1 Configuring a Function Chain
32.2 Configuring method chains
32.3.
Try it out: Handling method overloading with the same name

33.
Learn about special methods
33.1 Mathematical Operators
33.2 Object Access Operators
33.3 Index Operators

34.
Understanding Inheritance
34.1 Understanding Single and Multiple Inheritance
34.2 Understanding the Superclass (super)
34.3 Understanding Mixin Processing
34.4 Follow-up: Understanding the Factory Pattern

35.
Understanding object usage relationships
35.1 Association
35.2.
Aggregation
35.3.
Composition
35.4 Dependency
35.5 Follow-up: Understanding the Observer Pattern

36.
Learn about class polymorphism
36.1 Overloading
36.2 Method overloading
36.3 Overriding
36.4 Follow-up: Duck Typing

37.
Learn about classes that handle repetition
37.1 Understanding Iterators and Iterator Classes
37.2 Creating a repeater and iterator class
37.3. Generator

38.
Extending the Decorator
38.1 Class Decorators
38.2 Instance Decorator
38.3 Method Decorators
38.4 Decorating a Class
38.5 Follow-up: Performing calculations repeatedly

39.
Handling protected properties and descriptors
39.1 Understanding Protection Properties
39.2 Property
39.3 Understanding the Descriptor Structure
39.4 Data/Non-Data Descriptors
39.5.
Try it out: Constraining the data types of descriptor properties

40.
Understanding Abstract Classes
40.1 Abstract metaclasses and abstract classes
40.2 Handling additional inheritance relationships in abstract classes

41.
Learn about exceptions, warnings, and assertions
41.1 Handling Exceptions
41.2 Handling Warnings
41.3 Handling assertions

42.
Learn about standard input/output
42.1 Handling standard input and output
42.2 Understanding String Formatting

43.
Reading and writing files
43.1 Reading and Writing Files
43.2 Temporary file handling
43.3 Contextual Environment Handling

What should we learn now for our children, who will live alongside robots in the future? We need textbooks that lay a solid foundation, not easy ones.
'Python Advanced for Developers' explains these aspects well, and is comprised of essential information for anyone studying Python.


Python is used for a variety of purposes, from processing mathematical and scientific data to implementing machine learning and deep learning algorithms for artificial intelligence.
In other words, Python is a basic tool for creating various systems required for the 4th Industrial Revolution.

There are many Python grammar books on the market, but not many of them cover all Python-specific concepts, such as decorators and descriptors.
I've compiled content that reflects Pythonic concepts in line with the latest version of Python.

In practice, I work on machine learning and deep learning projects, using various Python libraries and frameworks.
However, simply importing and using functions or classes can often lead to undesirable results.
Based on this experience, I am explaining concepts about Python with examples.

- This is a book that easily explains the internal structure.
- This is a great book for those who are beginners in Python and want to learn properly, or have already encountered it but want to know it a little more deeply.
- This is a fairy tale-like book on Python that gathers a lot of experience in software engineering on grammar, usage, and utilization.
It will be a good guide to help you solve problems on your own by following the examples.
- This book can be helpful to those who are considering applying Python in practice.
- The author's video lectures on the textbook on Itple TV YouTube help readers understand the content.
(www.bit.ly/ITPLE_TV)