Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                
Scribd
Upload
3 views

TOC Python (1)

The document outlines a comprehensive curriculum for learning core and advanced Python topics, including control flow, data structures, object-oriented programming, and modules. It also covers practical applications such as Flask for web development, unit testing with Pytest, and automation testing. Additionally, it discusses code quality tools, threading, and multiprocessing, providing a well-rounded approach to mastering Python programming.

Uploaded by

prakharsingh1808
Copyright
© © All Rights Reserved
Available Formats
Download as XLSX, PDF, TXT or read online on Scribd
3 views

TOC Python (1)

The document outlines a comprehensive curriculum for learning core and advanced Python topics, including control flow, data structures, object-oriented programming, and modules. It also covers practical applications such as Flask for web development, unit testing with Pytest, and automation testing. Additionally, it discusses code quality tools, threading, and multiprocessing, providing a well-rounded approach to mastering Python programming.

Uploaded by

prakharsingh1808
Copyright
© © All Rights Reserved
Available Formats
Download as XLSX, PDF, TXT or read online on Scribd
You are on page 1/ 10

Core and advanced Python

Topics

Introduction to Python.

Control flow and loops

Data Structures – Lists and Tuples

Data Structures – Sets and Dictionaries

User defined functions


Iterators and Generators

Object-Oriented Programming (OOP)

Advanced OOP Concepts

Modules and packages (pattern matching)

Modules and packages(Cont…)

File Handling

Exceptinon handling
Flask

Unit Testing & Pytest

Automation testing
CI Testing

code coverage/format/pattern/doc
Threading and processing
Subtopics
• Introduction to Python.
• Key features: High-level, interpreted, dynamically typed, object-oriented.
• Diverse applications: Data science, web development, automation, scripting, etc.
• Installing Python:
Choosing and configuring an IDE like VS Code, PyCharm, or Jupyter Notebook.
Understanding and using virtual environments (e.g., `venv`) to isolate project dependencies.
• Basic syntax: Indentation, comments, variables, and data types (integers, floats, numbers, booleans).
• Operators: Arithmetic, comparison, logical, bitwise.
• Strings: slicing, reversing, indexing, Accessing a Docstring, raw string, string formatting

• Control flow: `if`, `elif`, `else` for making decisions in code.


• Looping constructs:
`for` loop execution in min. 10 different ways (with range, in, enumerate, with container types, decrementing, else).
`while` loop for indefinite iterations.
Understanding and using `break`, `continue`, and `pass` statements to control loop execution.
• Nested loops: Handling multiple levels of iteration.

• Lists: Ordered, mutable collections of elements.


• Creating lists in 5 different ways, accessing elements (indexing, slicing).
• List methods: `append()`, `insert()`, `remove()`, `pop()`, `sort()`, `reverse()`.
• List comprehensions: Concise way to create lists.
• Tuples: Ordered, immutable collections of elements.
• Unpacking tuples, accessing elements.
• List VS tuple

• Dictionaries: Key-value pairs for efficient data lookup.


• Creating dictionaries, accessing values, adding/updating key-value pairs.
• Dictionary methods: `keys()`, `values()`, `items()`.
• Dictionary comprehensions.
• Sets: Unordered collections of unique elements.
• Set operations: `union()`, `intersection()`, `difference()`, frozen set.
• Set comprehensions.

• Declaring, defining and calling functions to encapsulate reusable blocks of code.


• Function arguments: Positional arguments, keyword arguments, default arguments.
• Return values: Returning results from functions.
• Scope of variables: Local, global, and nonlocal variables.
• Lambda functions: Creating concise anonymous functions.
• Higher-order functions: Functions that accept other functions as arguments or return functions as results.
• Recursive functions: with recursive limits
• Iterables and iterators: Understanding the `iter()` and `next()` functions.
• Creating custom iterators.
• Generators: Functions that produce a sequence of values using the `yield` keyword.
• Lazy evaluation and memory efficiency.
• Decorators
• Decorators: Functions that modify the behavior of other functions.
• Creating and using decorators.

• Classes, objects, attributes, and methods.


• Creating classes and instantiating objects.
• Accessing attributes and calling methods.
• The `__init__` method (constructor) for object initialization.
• Class variables vs. instance variables, self-parameter.
• Inheritance: Multiple and multi-level inheritance.

• Method overriding, over loading and polymorphism.


• Abstract base classes and methods(ABCs) for defining interfaces.
• Static and class methods.
• Duck typing, inherit __init__()
• Access specifiers and why not to use them
• Set and get attributes

• Built-in modules:
• ‘re’: pattern match by match, search, findall, finditer, subn, compile & fullmatch functions, check for the correct mail id
• `os`: change the current path, know the functions modules being used, create and delete directories and more.
• `sys`:how it works with back end memory management, path changing, printing messages and errors etc.
• `math`: floor, ceil, factorial, gcd, lcm etc.
• `random`:random, randint, random choices
• `datetime`, `calendar’: datetime data type, str and different ways to take and print date and time, text and HTML calend
• Importing modules: `import`, `from ... import`.

• Create a module: __name__ and __main__()


• Creating and organizing code into packages.
• The `__init__.py` file and its significance.

• Working with files: Opening and closing files using `open()`function.


• Reading data from files: `read()`, `readline()`, `readlines()`.
• Writing data to files: `write()`, `writelines()`.
• Using `with` statement for context management (automatic file closing).
• Handling different file modes (read, write, append, binary).
• Reversing the content of file, dumping as Json file, zipping, copying and deleting the files.

• Blocks: try, except, else and finally


• Multiple exceptions
• General and specific error handling
raising an error
• Defining and raising an error
• code coverage/format/pattern (e.g pylint,isort,pytest-cov) python documents format (e.g.pydoc)
Pylint(/Flake8/mypy/Prospector/Pysa), Pydoc(Sphix/Pydoctor/pdoc) etc.
• Project allocation
• Creating your first Flask app
• Routing in Flask
• Dynamic routing and URL variables
• Core Concepts: HTTP Methods in Flask
• Handling GET and POST requests
• Using request and response objects
• Templates in Flask Rendering HTML templates

• Introduction to Unit Testing


• Designing Test Cases
• Writing effective test cases
• Test case structure: Arrange, Act, Assert
• Mocking and Stubbing:
Introduction to mocking
Using mock objects in tests
• Testing Best Practices:
Isolating test cases
Naming conventions for test methods
• Introduction to Pytest: Installation and setup
• Writing Tests in Pytest
Test function structure
Naming conventions
• Fixtures in Pytest:
Reusable setup and teardown logic
Parameterizing fixtures

• Assertions in Pytest:
Using assert statements effectively
Custom error messages
Parameterized Testing: Running tests with multiple inputs
• Markers and Tags:
Organizing and filtering tests
Built-in and custom markers
• Mocking in Pytest: Using pytest-mock or unittest.mock
• Introduction to Tox:
What is Tox and its role in automation testing
Installation and setup
• Tox Configuration:
Understanding tox.ini file
Specifying environments and dependencies
• Running Tests Across Environments
Testing on multiple Python versions
Configuring virtual environments
Testing on multiple Python versions
Configuring virtual environments
Test Automation:
Unit Testing
Integration Testing
End-to-End Testing
API Testing
UI Testing
Testing Frameworks:
Unittest (Python)
Pytest (Python)
Test Coverage Analysis:
Measuring code coverage to identify untested areas.
CI/CD Tools & Pipelines:
Jenkins
Automating Tox in CI/CD pipelines
Using Tox with Jenkins/GitHub Actions
• Custom Commands in Tox
Writing and executing custom commands
Pre- and post-test hooks
Test Reporting:
Generating and analyzing test reports (JUnit XML, Allure Reports)

• Code Coverage/format/pattern (e.g pylint,isort,pytest-cov) python documents format (e.g.pydoc)


Pylint(/Flake8/mypy/Prospector/Pysa), Pydoc(Sphix/Pydoctor/pdoc) etc .)
• Code Formatting Tools: YAPF, Autopep8, Black
Ensure consistent code style and formatting.
Automatically format Python code to adhere to PEP 8 standards.
Differences in strictness and style (e.g., Black enforces opinionated formatting).
• Code Linting Tools: Pylint, Flake8, Prospector
Analyze code for errors, style issues, and adherence to standards.
Offer suggestions to improve code quality.
Support plugin-based customization.
• Type Checking Tools: Mypy
Perform static type checking for Python code using type annotations.
Ensure type correctness during development.
• Security Analysis Tools: Pysa
Static analysis tool for identifying security vulnerabilities.
Specialized for taint analysis in Python code.
• Documentation Generation Tools: Pydoc, Sphinx, Pydoctor, pdoc
Generate API documentation from code and docstrings.
Support HTML, PDF, and other formats for documentation.
Enable interactive and detailed documentation for projects.
• Code Quality Aggregators: Prospector
Combine results from multiple linters and formatters into a single report.
Provide an overall score for code quality.
• Multi-Threading: start, stop, sleep
• Creating and starting processes
• Using Process class
• sub processing
• Using multiprocessing.Pool

You might also like