Python Training in Chennai

Python Training in Chennai

Python is one of the most important languages on the lines of Java, C and C++. Python is simple to use, versatile and powerful, making it an ideal choice even for beginners. Python’s readability makes it a great programming language and its syntax aren’t as complex as the others. If you are in Chennai and looking to learn Python to improve on your programming skills, our Python course in Chennai can guide you through. Being the best python training institute in Chennai, we offer you a comprehensive training module and sessions that are flexible.

Fill This Form For Demo Class

About Python Training Course

Here is a list of must-knows of Python which will help you on a professional scale:

  • Python has a much wider scope of use. Fields like data science, scientific computing, finance, trading, computer graphics, basic game development, mapping and system automation require Python
  • Python’s use in data science and data engineering is immense. the statistical and scientific analysis that it offers make it ideal for data science
  • The average salary of a Python professional is pretty high when compared with other programming languages
  • The general demand for Python Developers is high and recently this has sprung up
  • Python saves time and lets you accomplish a wide range of tasks
  • Python is beginner-friendly with its famously simple and readable syntax
  • Python has an amazing ecosystem with an impressive standard library

We offer a wide range of training courses and Python is easily one amongst the most famous on-demand course for us. We have a dedicated team of trainers who provide the best python training program in Chennai at flexible timings. Given the scale of growth as well as the wide areas of computing that Python provides, the job perspectives are immense if you become an expert in Python language.

Course objectives

At the end of Python training, you will be able to,

Learn how to code python.
Understand OOPS concept.
Automate your daily kinds of stuff in work.
Understand the built-in libraries and third-party tools.
Build your own applications if required.

Who can learn this course?

Python training is not restricted to people of some group. This suits well for, If you know to read English, and knowledge of mathematics with some understanding of software’s programs.

Students or fresh graduates
Testing job profile
A tech-savvy, who wants to learn a new language
At last, if you are too lazy and want to automate all stuff and your daily task, give it a shot.

Job Opportunity

Our ultimate goal is to learn this program to shape us and find a suitable place where you can upgrade more. Beat it any technologies, python could be applied over there. And it has been widely used in all technologies and almost all startups and Tier-I companies use python. So don’t worry about getting a job if you know python. Even get more by doing freelancing.

Course Duration Information

Generally, the course will be there for 30 hours. But if you are smart enough to grab it early, then 25 hours is much more sufficient to get trained in python. Weekdays: 1 hour per day. Weekend : 3 hours on Saturday/Sunday.

Python Training Syllabus:

A Python Q&A

Why Do People Use Python?
Software Quality
Developer Productivity
Is Python a “Scripting Language”?
OK, but What’s the Downside?
Who Uses Python Today?
What Can I Do with Python?
Systems Programming
Internet Scripting
Component Integration
Database Programming
Rapid Prototyping
Numeric and Scientific Programming
And More: Gaming, Images, Data Mining, Robots, Excel…
How Is Python Developed and Supported?
Open Source Tradeoffs
What Are Python’s Technical Strengths?
It’s Object-Oriented and Functional
It’s Free
It’s Portable
It’s Powerful
It’s Mixable
It’s Relatively Easy to Use
It’s Relatively Easy to Learn
It’s Named After Monty Python
How Does Python Stack Up to Language X?

Module Packages

Package Import Basics
Packages and Search Path Settings
Package Files
Package Import Example
from Versus import with Packages
Why Use Package Imports?
A Tale of Three Systems
Package Relative Imports
Changes in Python .X
Relative Import Basics
Why Relative Imports?
The Scope of Relative Imports
Module Lookup Rules Summary
Relative Imports in Action
Pitfalls of Package-Relative Imports: Mixed Use
Python . Namespace Packages
Namespace Package Semantics
Impacts on Regular Packages: Optional
Namespace Packages in Action
Namespace Package Nesting
Files Still Have Precedence over Directories

Advanced Module Topics

Module Design Concepts
Data Hiding in Modules
Minimizing from * Damage: _X and __all__
Enabling Future Language Features: __future__
Mixed Usage Modes: __name__ and __main__
Unit Tests with __name__
Example: Dual Mode Code
Currency Symbols: Unicode in Action
Docstrings: Module Documentation at Work
Changing the Module Search Path
The as Extension for import and from
Example: Modules Are Objects
Importing Modules by Name String
Running Code Strings
Direct Calls: Two Options
Example: Transitive Module Reloads
A Recursive Reloader
Alternative Codings
Module Gotchas
Module Name Clashes: Package and Package-Relative Imports
Statement Order Matters in Top-Level Code
from Copies Names but Doesn’t Link
from * Can Obscure the Meaning of Variables
reload May Not Impact from Imports
reload, from, and Interactive Testing
Recursive from Imports May Not Work
Chapter Summary
Test Your Knowledge: Quiz
Test Your Knowledge: Answers
Test Your Knowledge: Part V Exercises

Classes and OOP

Why Use Classes?
OOP from , Feet
Attribute Inheritance Search
Classes and Instances
Method Calls
Coding Class Trees
Operator Overloading
OOP Is About Code Reuse

Class Coding Basics

Classes Generate Multiple Instance Objects
Class Objects Provide Default Behavior
Instance Objects Are Concrete Items
A First Example
Classes Are Customized by Inheritance
A Second Example
Classes Are Attributes in Modules
Classes Can Intercept Python Operators
A Third Example
Why Use Operator Overloading?
The World’s Simplest Python Class
Records Revisited: Classes Versus Dictionaries

Step : Making Instances
Coding Constructors
Testing As You Go
Using Code Two Ways
Step : Adding Behavior Methods
Coding Methods
Step : Operator Overloading
Providing Print Displays
Step : Customizing Behavior by Subclassing
Coding Subclasses
Augmenting Methods: The Bad Way
Augmenting Methods: The Good Way
Polymorphism in Action
Inherit, Customize, and Extend
OOP: The Big Idea
Step : Customizing Constructors, Too
OOP Is Simpler Than You May Think
Other Ways to Combine Classes
Step : Using Introspection Tools
Special Class Attributes
A Generic Display Tool
Instance Versus Class Attributes
Name Considerations in Tool Classes
Our Classes’ Final Form
Step (Final): Storing Objects in a Database
Pickles and Shelves
Storing Objects on a Shelve Database
Exploring Shelves Interactively
Updating Objects on a Shelve
Future Directions

Class Coding Details

The class Statement
General Form
Method Example
Calling Superclass Constructors
Other Method Call Possibilities
Attribute Tree Construction
Specializing Inherited Methods
Class Interface Technique
Abstract Superclasses
Namespaces: The Conclusion
Simple Names: Global Unless Assigned
Attribute Names: Object Namespaces
The “Zen” of Namespaces: Assignments Classify Names
Nested Classes: The LEGB Scopes Rule Revisited
Namespace Dictionaries: Review
Namespace Links: A Tree Climber
Documentation Strings Revisited
Classes Versus Modules

Operator Overloading

The Basics
Constructors and Expressions: __init__ and __sub__
Common Operator Overloading Methods
Indexing and Slicing: __getitem__ and __setitem__
Intercepting Slices
Slicing and Indexing in Python .X
But .X’s __index__ Is Not Indexing!
Index Iteration: __getitem__
Iterable Objects: __iter__ and __next__
User-Defined Iterables
Multiple Iterators on One Object
Coding Alternative: __iter__ plus yield
Membership: __contains__, __iter__, and __getitem__
Attribute Access: __getattr__ and __setattr__
Attribute Reference
Attribute Assignment and Deletion
Other Attribute Management Tools
Emulating Privacy for Instance Attributes: Part
String Representation: __repr__ and __str__
Why Two Display Methods?
Display Usage Notes
Right-Side and In-Place Uses: __radd__ and __iadd__
Right-Side Addition
In-Place Addition
Call Expressions: __call__
Function Interfaces and Callback-Based Code
Comparisons: __lt__, __gt__, and Others
The __cmp__ Method in Python .X
xxii | Table of Contents
Boolean Tests: __bool__ and __len__
Boolean Methods in Python .X
Object Destruction: __del__
Destructor Usage Notes

Designing with Classes

Python and OOP
Polymorphism Means Interfaces, Not Call Signatures
OOP and Inheritance: “Is-a” Relationships
OOP and Composition: “Has-a” Relationships
Stream Processors Revisited
OOP and Delegation: “Wrapper” Proxy Objects
Pseudoprivate Class Attributes
Name Mangling Overview
Why Use Pseudoprivate Attributes?
Methods Are Objects: Bound or Unbound
Unbound Methods Are Functions in .X
Bound Methods and Other Callable Objects
Classes Are Objects: Generic Object Factories
Why Factories?
Multiple Inheritance: “Mix-in” Classes
Coding Mix-in Display Classes
Other Design-Related Topics

Advanced Class Topics

Extending Built-in Types
Extending Types by Embedding
Extending Types by Subclassing
The “New Style” Class Model
Just How New Is New-Style?
New-Style Class Changes
Attribute Fetch for Built-ins Skips Instances
Type Model Changes
All Classes Derive from “object”
Diamond Inheritance Change
More on the MRO: Method Resolution Order
Example: Mapping Attributes to Inheritance Sources
New-Style Class Extensions
Slots: Attribute Declarations
Properties: Attribute Accessors
__getattribute__ and Descriptors: Attribute Tools
Other Class Changes and Extensions
Static and Class Methods
Why the Special Methods?
Static Methods in .X and .X
Static Method Alternatives
Using Static and Class Methods
Counting Instances with Static Methods
Counting Instances with Class Methods
Decorators and Metaclasses: Part
Function Decorator Basics
A First Look at User-Defined Function Decorators
A First Look at Class Decorators and Metaclasses
For More Details
The super Built-in Function: For Better or Worse?
The Great super Debate
Traditional Superclass Call Form: Portable, General
Basic super Usage and Its Tradeoffs
The super Upsides: Tree Changes and Dispatch
Runtime Class Changes and super
Cooperative Multiple Inheritance Method Dispatch
The super Summary
Class Gotchas
Changing Class Attributes Can Have Side Effects
Changing Mutable Class Attributes Can Have Side Effects, Too
Multiple Inheritance: Order Matters
Scopes in Methods and Classes
Miscellaneous Class Gotchas
KISS Revisited: “Overwrapping-itis”
Chapter Summary
Test Your Knowledge: Quiz
Test Your Knowledge: Answers
Test Your Knowledge: Part VI Exercises
Part VII. Exceptions and Tools

Exception Basics

Why Use Exceptions?
Exception Roles
Exceptions: The Short Story
Default Exception Handler
Catching Exceptions
Raising Exceptions
User-Defined Exceptions
Termination Actions

Exception Coding Details

The try/except/else Statement
How try Statements Work
try Statement Clauses
The try else Clause
Example: Default Behavior
Example: Catching Built-in Exceptions
The try/finally Statement
Example: Coding Termination Actions with try/finally
Unified try/except/finally
Unified try Statement Syntax
Combining finally and except by Nesting
Unified try Example
The raise Statement
Raising Exceptions
Scopes and try except Variables
Propagating Exceptions with raise
Python .X Exception Chaining: raise from
The assert Statement
Example: Trapping Constraints (but Not Errors!)
with/as Context Managers
Basic Usage
The Context Management Protocol
Multiple Context Managers in ., ., and Later

How Python Runs

Introducing the Python Interpreter
Program Execution
The Programmer’s View
Python’s View
Execution Model Variations
Python Implementation Alternatives
Execution Optimization Tools
Frozen Binaries

Types and Operations

The Python Conceptual Hierarchy
Why Use Built-in Types?
Python’s Core Data Types
Sequence Operations
Type-Specific Methods
Getting Help
Other Ways to Code Strings
Unicode Strings
Pattern Matching
Sequence Operations
Type-Specific Operations
Bounds Checking
Mapping Operations
Nesting Revisited
Missing Keys: if Tests
Sorting Keys: for Loops
Iteration and Optimization
Why Tuples?
Binary Bytes Files
Unicode Text Files
Other File-Like Tools
Other Core Types
How to Break Your Code’s Flexibility
User-Defined Classes
And Everything Else
Numbers in Action
Variables and Basic Expressions
Numeric Display Formats
Comparisons: Normal and Chained
Division: Classic, Floor, and True
Integer Precision
Complex Numbers
Hex, Octal, Binary: Literals and Conversions
Bitwise Operations
Other Built-in Numeric Tools
Other Numeric Types
Decimal Type
Fraction Type
Numeric Extensions

Unicode and Byte Strings

String Changes in .X
String Basics
Character Encoding Schemes
How Python Stores Strings in Memory
Python’s String Types
Text and Binary Files
Coding Basic Strings
Python .X String Literals
Python .X String Literals
String Type Conversions
Coding Unicode Strings
Coding ASCII Text
Coding Non-ASCII Text
Encoding and Decoding Non-ASCII text
Other Encoding Schemes
Byte String Literals: Encoded Text
Converting Encodings
Coding Unicode Strings in Python .X
Source File Character Set Encoding Declarations
Using .X bytes Objects
Method Calls
Sequence Operations
Other Ways to Make bytes Objects
Mixing String Types
Using .X/.+ bytearray Objects
bytearrays in Action
Python .X String Types Summary
Using Text and Binary Files
Text File Basics
Text and Binary Modes in .X and .X
Type and Content Mismatches in .X
Using Unicode Files
Reading and Writing Unicode in .X
Handling the BOM in .X
Unicode Files in .X
Unicode Filenames and Streams
Other String Tool Changes in .X
The re Pattern-Matching Module
The struct Binary Data Module
The pickle Object Serialization Module
XML Parsing Tools

Assignments, Expressions, and Prints

Assignment Statements
Assignment Statement Forms
Sequence Assignments
Extended Sequence Unpacking in Python .X
Multiple-Target Assignments
Augmented Assignments
Variable Name Rules
Expression Statements
Expression Statements and In-Place Changes
Print Operations
The Python .X print Function
The Python .X print Statement
Print Stream Redirection
Version-Neutral Printing

if Tests and Syntax Rules

if Statements
General Format
Basic Examples
Multiway Branching
Python Syntax Revisited
Block Delimiters: Indentation Rules
Statement Delimiters: Lines and Continuations
A Few Special Cases
Truth Values and Boolean Tests
The if/else Ternary Expression

While and for Loops

while Loops
General Format
break, continue, pass, and the Loop else
General Loop Format
Loop else
for Loops
General Format
Loop Coding Techniques
Counter Loops: range
Sequence Scans: while and range Versus for
Sequence Shufflers: range and len
Nonexhaustive Traversals: range Versus Slices
Changing Lists: range Versus Comprehensions
Parallel Traversals: zip and map
Generating Both Offsets and Items: enumerate

Iterations and Comprehensions

Iterations: A First Look
The Iteration Protocol: File Iterators
Manual Iteration: iter and next
Other Built-in Type Iterables
List Comprehensions: A First Detailed Look
List Comprehension Basics
Using List Comprehensions on Files
Extended List Comprehension Syntax
Other Iteration Contexts

New Iterables in Python .X

Impacts on .X Code: Pros and Cons
The range Iterable
The map, zip, and filter Iterables
Multiple Versus Single Pass Iterators
Dictionary View Iterables
Other Iteration Topics
Function Basics
Why Use Functions?
Coding Functions
def Statements
def Executes at Runtime
A First Example: Definitions and Calls
Polymorphism in Python
A Second Example: Intersecting Sequences
Polymorphism Revisited
Local Variables

Modules: The Big Picture

Why Use Modules?
Python Program Architecture
How to Structure a Program
Imports and Attributes
Standard Library Modules
How Imports Work
. Find It
. Compile It (Maybe)
. Run It

Byte Code Files: __pycache__ in Python .+

Byte Code File Models in Action
The Module Search Path
Configuring the Search Path
Search Path Variations
The sys.path List
Module File Selection
Module Coding Basics
Module Creation
Module Filenames
Other Kinds of Modules

Module Usage

The import Statement
The from Statement
The from * Statement
Imports Happen Only Once
import and from Are Assignments
import and from Equivalence
Potential Pitfalls of the from Statement
Module Namespaces
Files Generate Namespaces
Namespace Dictionaries: __dict__
Attribute Name Qualification
Imports Versus Scopes
Namespace Nesting
Reloading Modules
reload Basics
reload Example
How You Run
The Interactive Prompt
Starting an Interactive Session
The System Path
New Windows Options in .: PATH, Launcher
Where to Run: Code Directories
What Not to Type: Prompts and Comments
Running Code Interactively
Why the Interactive Prompt?
Usage Notes: The Interactive Prompt
System Command Lines and Files
A First Script
Running Files with Command Lines
Command-Line Usage Variations
Usage Notes: Command Lines and Files
Unix-Style Executable Scripts: #!
Unix Script Basics
The Unix env Lookup Trick
The Python . Windows Launcher: #! Comes to Windows
Clicking File Icons
Icon-Click Basics
Clicking Icons on Windows
The input Trick on Windows
Other Icon-Click Limitations
Module Imports and Reloads
Import and Reload Basics
The Grander Module Story: Attributes
Usage Notes: import and reload
Using exec to Run Module Files
The IDLE User Interface
IDLE Startup Details
IDLE Basic Usage
IDLE Usability Features
Advanced IDLE Tools
Usage Notes: IDLE
Other IDEs
Other Launch Options
Embedding Calls
Frozen Binary Executables
Text Editor Launch Options
Still Other Launch Options
Future Possibilities?
Which Option Should I Use?
Managed Attributes
Why Manage Attributes?
Inserting Code to Run on Attribute Access
The Basics
A First Example
Computed Attributes
Coding Properties with Decorators
The Basics
A First Example
Computed Attributes
Using State Information in Descriptors
How Properties and Descriptors Relate
__getattr__ and __getattribute__
The Basics
A First Example
Computed Attributes
__getattr__ and __getattribute__ Compared
Management Techniques Compared
Intercepting Built-in Operation Attributes
Example: Attribute Validations
Using Properties to Validate
Using Descriptors to Validate
Using __getattr__ to Validate
Using __getattribute__ to Validate

String Fundamentals

String Basics
String Literals
Single- and Double-Quoted Strings Are the Same
Escape Sequences Represent Special Characters
Raw Strings Suppress Escapes
Triple Quotes Code Multiline Block Strings
Strings in Action
Basic Operations
Indexing and Slicing
String Conversion Tools
Changing Strings I
String Methods
Method Call Syntax
Methods of Strings
String Method Examples: Changing Strings II
String Method Examples: Parsing Text
Other Common String Methods in Action
The Original string Module’s Functions (Gone in .X)
String Formatting Expressions
Formatting Expression Basics
Advanced Formatting Expression Syntax
Advanced Formatting Expression Examples
Dictionary-Based Formatting Expressions
String Formatting Method Calls
Formatting Method Basics
Adding Keys, Attributes, and Offsets
Advanced Formatting Method Syntax
Advanced Formatting Method Examples
Comparison to the % Formatting Expression
Why the Format Method?
General Type Categories
Types Share Operation Sets by Categories
Mutable Types Can Be Changed in Place

Lists and Dictionaries

Lists in Action
Basic List Operations
List Iteration and Comprehensions
Indexing, Slicing, and Matrixes
Changing Lists in Place
Dictionaries in Action
Basic Dictionary Operations
Dictionaries in Place
More Dictionary Methods
Example: Movie Database
Dictionary Usage Notes
Other Ways to Make Dictionaries
Dictionary Changes in Python .X and
Tuples, Files, and Everything
Tuples in Action
Why Lists and Tuples?
Records Revisited: Named Tuples


Opening Files
Using Files
Files in Action
Text and Binary Files: The Short Story
Storing Python Objects in Files: Conversions
Storing Native Python Objects: pickle
Storing Python Objects in JSON Format
Storing Packed Binary Data: struct
File Context Managers
Other File Tools
Core Types Review and Summary
Object Flexibility
References Versus Copies
Comparisons, Equality, and Truth
The Meaning of True and False in Python
Python’s Type Hierarchies
Type Objects
Other Types in Python
Built-in Type Gotchas
Assignment Creates References, Not Copies
Repetition Adds One Level Deep
Beware of Cyclic Data Structures
Immutable Types Can’t Be Changed in Place
Handling Errors by Testing Inputs
Handling Errors with try Statements
Nesting Code Three Levels Deep


Python Scope Basics
Scope Details
Name Resolution: The LEGB Rule
Scope Example
The Built-in Scope
The global Statement
Program Design: Minimize Global Variables
Program Design: Minimize Cross-File Changes
Other Ways to Access Globals
Scopes and Nested Functions
Nested Scope Details
Nested Scope Examples
Factory Functions: Closures
Retaining Enclosing Scope State with Defaults
The nonlocal Statement in .X
nonlocal Basics
nonlocal in Action
Why nonlocal? State Retention Options
State with nonlocal: .X only
State with Globals: A Single Copy Only
State with Classes: Explicit Attributes (Preview)
State with Function Attributes: .X and .X


Argument-Passing Basics
Arguments and Shared References
Avoiding Mutable Argument Changes
Simulating Output Parameters and Multiple Results
Special Argument-Matching Modes
Argument Matching Basics
Argument Matching Syntax
The Gritty Details
Keyword and Default Examples
Arbitrary Arguments Examples
Python .X Keyword-Only Arguments
The min Wakeup Call!
Full Credit
Bonus Points
The Punch Line…
Generalized Set Functions
Emulating the Python .X print Function
Using Keyword-Only Arguments
Advanced Function Topics
Function Design Concepts
Recursive Functions
Summation with Recursion
Coding Alternatives
Loop Statements Versus Recursion
Handling Arbitrary Structures
Function Objects: Attributes and Annotations
Indirect Function Calls: “First Class” Objects
Function Introspection
Function Attributes
Function Annotations in .X

Anonymous Functions: lambda

lambda Basics
Why Use lambda?
How (Not) to Obfuscate Your Python Code
Scopes: lambdas Can Be Nested Too
Functional Programming Tools
Mapping Functions over Iterables: map
Selecting Items in Iterables: filter
Combining Items in Iterables: reduce
Comprehensions and Generations
List Comprehensions and Functional Tools
List Comprehensions Versus map
Adding Tests and Nested Loops: filter
Example: List Comprehensions and Matrixes
Don’t Abuse List Comprehensions: KISS
Generator Functions and Expressions
Generator Functions: yield Versus return
Generator Expressions: Iterables Meet Comprehensions
Generator Functions Versus Generator Expressions
Generators Are Single-Iteration Objects
Generation in Built-in Types, Tools, and Classes
Example: Generating Scrambled Sequences
Don’t Abuse Generators: EIBTI
Example: Emulating zip and map with Iteration Tools
Comprehension Syntax Summary
Scopes and Comprehension Variables
Comprehending Set and Dictionary Comprehensions
Extended Comprehension Syntax for Sets and Dictionaries

The Benchmarking Interlude

Timing Iteration Alternatives
Timing Module: Homegrown
Timing Script
Timing Results
Timing Module Alternatives
Other Suggestions
Timing Iterations and Pythons with timeit
Basic timeit Usage
Benchmark Module and Script: timeit
Benchmark Script Results
More Fun with Benchmarks
Other Benchmarking Topics: pystones
Function Gotchas
Local Names Are Detected Statically
Defaults and Mutable Objects
Functions Without returns
Miscellaneous Function Gotchas


What’s a Decorator?
Managing Calls and Instances
Managing Functions and Classes
Using and Defining Decorators
Why Decorators?
The Basics
Function Decorators
Class Decorators
Decorator Nesting
Decorator Arguments
Decorators Manage Functions and Classes, Too
Coding Function Decorators
Tracing Calls
Decorator State Retention Options
Class Blunders I: Decorating Methods
Timing Calls
Adding Decorator Arguments
Coding Class Decorators
Singleton Classes
Tracing Object Interfaces
Class Blunders II: Retaining Multiple Instances
Decorators Versus Manager Functions
Why Decorators? (Revisited)
Managing Functions and Classes Directly
Example: “Private” and “Public” Attributes
Implementing Private Attributes
Implementation Details I
Generalizing for Public Declarations, Too
Implementation Details II
Open Issues
Python Isn’t About Control
Example: Validating Function Arguments
The Goal
A Basic Range-Testing Decorator for Positional Arguments
Generalizing for Keywords and Defaults, Too
Implementation Details
Open Issues
Decorator Arguments Versus Function Annotations
Other Applications: Type Testing (If You Insist!)
To Metaclass or Not to Metaclass
Increasing Levels of “Magic”
A Language of Hooks
The Downside of “Helper” Functions
Metaclasses Versus Class Decorators: Round
The Metaclass Model
Classes Are Instances of type
Metaclasses Are Subclasses of Type
Class Statement Protocol
Declaring Metaclasses
Declaration in .X
Metaclass Dispatch in Both .X and .X
Coding Metaclasses
A Basic Metaclass
Customizing Construction and Initialization
Other Metaclass Coding Techniques
Inheritance and Instance
Metaclass Versus Superclass
Inheritance: The Full Story
Metaclass Methods
Metaclass Methods Versus Class Methods
Operator Overloading in Metaclass Methods
Example: Adding Methods to Classes
Manual Augmentation
Metaclass-Based Augmentation
Metaclasses Versus Class Decorators: Round
Example: Applying Decorators to Methods
Tracing with Decoration Manually
Tracing with Metaclasses and Decorators
Applying Any Decorator to Methods
Metaclasses Versus Class Decorators: Round (and Last)
The Dynamic Typing Interlude
The Case of the Missing Declaration Statements
Variables, Objects, and References
Types Live with Objects, Not Variables
Objects Are Garbage-Collected
Shared References
Shared References and In-Place Changes
Shared References and Equality
Dynamic Typing Is Everywhere
Chapter Summary
Test Your Knowledge: Quiz
Test Your Knowledge: Answers
Exception Objects
Exceptions: Back to the Future
String Exceptions Are Right Out!

Class-Based Exceptions

Coding Exceptions Classes
Why Exception Hierarchies?
Built-in Exception Classes
Built-in Exception Categories
Default Printing and State
Custom Print Displays
Custom Data and Behavior
Providing Exception Details
Providing Exception Methods
Designing with Exceptions
Nesting Exception Handlers
Example: Control-Flow Nesting
Example: Syntactic Nesting
Exception Idioms
Breaking Out of Multiple Nested Loops: “go to”
Exceptions Aren’t Always Errors
Functions Can Signal Conditions with raise
Closing Files and Server Connections
Debugging with Outer try Statements
Running In-Process Tests
More on sys.exc_info
Displaying Errors and Tracebacks
Exception Design Tips and Gotchas
What Should Be Wrapped
Catching Too Much: Avoid Empty except and Exception
Catching Too Little: Use Class-Based Categories
Core Language Summary
The Python Toolset
Development Tools for Larger Projects

Good place to learn selenium. Found them online and joined classroom training. Trainers are experienced working professionals, explained all syllabus and nice environment to learn

Gayathri Kumar

Selenium Training, Working in CTS

Our Trending Courses

WhatsApp Chat

Fill this form for call back