GitHub - tamnd/Python-100-Days-English

19 min read Original article ↗

Original content credit: adapted from jackfrued/Python-100-Days. This repository is an English translation of that original project.

Python - 100 Days from Beginner to Master

Author: Luo Hao

Note: If GitHub access is slow, you can follow my Zhihu account (Python-Jack). The column Learn Python from Scratch, which corresponds to the first 20 days of this project, is especially suitable for beginners. Other columns such as Data Thinking and Statistical Thinking, Data Analysis with Python, and An AI Journey at a Moment's Notice are also being updated continuously. You are welcome to follow, like, and comment. The free QQ study group is already overcrowded, and the messages are too noisy for me to reply one by one. If you want to study together with daily check-ins or need paid consultation, you can join the paid study group. New users can scan the QR code below, complete the payment, add my personal WeChat (jackfrued), and I will invite you to the paid learning and check-in group. When adding me on WeChat, please include your name and your needs in the note. I will provide whatever help I can.

Some of the videos corresponding to this project have also been published on Bilibili. If you are interested, please like, support, and follow the channel.

Python Application Areas and Career Development

Simply put, Python is an "elegant", "explicit", and "simple" programming language.

  • The learning curve is gentle, and even non-specialists can get started.
  • It is open source and has a powerful ecosystem.
  • It is an interpreted language with excellent cross-platform portability.
  • It is a dynamically typed language that supports both object-oriented and functional programming.
  • Its code style is highly standardized and very readable.

Python is useful in all of the following areas.

  • Backend development - Python / Java / Go / PHP
  • DevOps - Python / Shell / Ruby
  • Data collection - Python / C++ / Java
  • Quantitative trading - Python / C++ / R
  • Data science - Python / R / Julia / Matlab
  • Machine learning - Python / R / C++ / Julia
  • Automated testing - Python / Shell

As a Python developer, depending on your interests and career planning, there are many employment directions you can choose from.

  • Python backend engineer (servers, cloud platforms, data APIs)
  • Python operations engineer (automated operations, SRE, DevOps)
  • Python data analyst (data analysis, business intelligence, digital operations)
  • Python data scientist (machine learning, deep learning, algorithm specialist)
  • Python crawler engineer (this track is not recommended!!!)
  • Python test engineer (automated testing, test development)

Note: At present, the data science track is extremely popular, because both the internet industry and traditional industries have already accumulated massive amounts of data. Every industry needs data scientists to discover more business value from existing data and provide data support for business decisions. This is what people call data-driven decision-making.

Several suggestions for beginners:

  • Make English your working language.
  • Practice makes perfect.
  • All experience comes from the mistakes you've made.
  • Don't be a freeloader.
  • Embrace AI to boost your productivity.

Day01~20 - Python Language Basics

Day01 - Getting Started with Python

  1. Introduction to Python
    • A brief history of Python
    • Pros and cons of Python
    • Python application areas
  2. Installing the Python environment
    • Windows environment
    • macOS environment

Day02 - The First Python Program

  1. Tools for writing code
  2. Hello, world
  3. Commenting your code

Day03 - Variables in Python

  1. Some basic common sense
  2. Variables and types
  3. Variable naming
  4. Using variables

Day04 - Operators in Python

  1. Arithmetic operators
  2. Assignment operators
  3. Comparison operators and logical operators
  4. Applications of operators and expressions
    • Fahrenheit and Celsius conversion
    • Calculating the circumference and area of a circle
    • Determining whether a year is a leap year

Day05 - Branching

  1. Building branching structures with if and else
  2. Building branching structures with match and case
  3. Applications of branching structures
    • Evaluating a piecewise function
    • Converting percentage grades into grade levels
    • Calculating the perimeter and area of a triangle

Day06 - Loops

  1. for-in loops
  2. while loops
  3. break and continue
  4. Nested loop structures
  5. Applications of loops
    • Determining prime numbers
    • Greatest common divisor
    • Guess-the-number game

Day07 - Branching and Loops in Practice

  1. Example 1: Prime numbers within 100
  2. Example 2: Fibonacci sequence
  3. Example 3: Finding narcissistic numbers
  4. Example 4: The hundred-chickens problem
  5. Example 5: The CRAPS gambling game

Day08 - Common Data Structure: List - 1

  1. Creating lists
  2. List operations
  3. Traversing elements

Day09 - Common Data Structure: List - 2

  1. List methods
    • Adding and deleting elements
    • Element positions and frequencies
    • Sorting and reversing elements
  2. List comprehensions
  3. Nested lists
  4. Applications of lists

Day10 - Common Data Structure: Tuple

  1. Tuple definition and operations
  2. Packing and unpacking
  3. Swapping variable values
  4. Comparing tuples and lists

Day11 - Common Data Structure: String

  1. Defining strings
    • Escape characters
    • Raw strings
    • Special character representations
  2. String operations
    • Concatenation and repetition
    • Comparison operations
    • Membership operations
    • Getting string length
    • Indexing and slicing
  3. Traversing characters
  4. String methods
    • Case conversion
    • Search operations
    • Property checks
    • Formatting
    • Trimming
    • Replacing
    • Splitting and joining
    • Encoding and decoding
    • Other methods

Day12 - Common Data Structure: Set

  1. Creating sets
  2. Variables of elements
  3. Set operations
    • Membership operations
    • Binary operations
    • Comparison operations
  4. Set methods
  5. Immutable sets

Day13 - Common Data Structure: Dictionary

  1. Creating and using dictionaries
  2. Dictionary operations
  3. Dictionary methods
  4. Applications of dictionaries

Day14 - Functions and Modules

  1. Defining functions
  2. Function parameters
    • Positional arguments and keyword arguments
    • Default values for arguments
    • Variable-length arguments
  3. Managing functions with modules
  4. Modules and functions in the standard library

Day15 - Function Practice

  1. Example 1: Random verification code
  2. Example 2: Determining prime numbers
  3. Example 3: Greatest common divisor and least common multiple
  4. Example 4: Data statistics
  5. Example 5: Random double-color ball number selection

Day16 - Advanced Function Usage

  1. Higher-order functions
  2. Lambda functions
  3. Partial functions

Day17 - Advanced Function Applications

  1. Decorators
  2. Recursive calls

Day18 - Introduction to Object-Oriented Programming

  1. Classes and objects
  2. Defining classes
  3. Creating and using objects
  4. Initialization methods
  5. The pillars of object orientation
  6. Object-oriented cases
    • Example 1: A digital clock
    • Example 2: A point on a plane

Day19 - Advanced Object-Oriented Programming

  1. Visibility and property decorators
  2. Dynamic attributes
  3. Static methods and class methods
  4. Inheritance and polymorphism

Day20 - Object-Oriented Programming in Practice

  1. Poker game
  2. Payroll settlement system

Day21~30 - Python Language Applications

Day21 - File I/O and Exception Handling

  1. Opening and closing files
  2. Reading and writing text files
  3. Exception-handling mechanisms
  4. Context-manager syntax
  5. Reading and writing binary files

Day22 - Object Serialization and Deserialization

  1. JSON overview
  2. Reading and writing JSON data
  3. The pip package-management tool
  4. Getting data through web APIs

Day23 - Reading and Writing CSV Files with Python

  1. Introduction to CSV files
  2. Writing data to CSV files
  3. Reading data from CSV files

Day24 - Reading and Writing Excel Files with Python - 1

  1. Introduction to Excel
  2. Reading Excel files
  3. Writing Excel files
  4. Adjusting styles
  5. Formula calculation

Day25 - Reading and Writing Excel Files with Python - 2

  1. Introduction to Excel
  2. Reading Excel files
  3. Writing Excel files
  4. Adjusting styles
  5. Generating statistical charts

Day26 - Working with Word and PowerPoint Files in Python

  1. Working with Word documents
  2. Generating PowerPoint presentations

Day27 - Working with PDF Files in Python

  1. Extracting text from PDF files
  2. Rotating and overlaying pages
  3. Encrypting PDF files
  4. Batch watermarking
  5. Creating PDF files

Day28 - Image Processing with Python

  1. Introductory concepts
  2. Processing images with Pillow
  3. Drawing with Pillow

Day29 - Sending Email and SMS with Python

  1. Sending email
  2. Sending text messages

Day30 - Applications of Regular Expressions

  1. Knowledge related to regular expressions
  2. Python support for regular expressions
    • Example 1: Input validation
    • Example 2: Content extraction
    • Example 3: Content replacement
    • Example 4: Long-sentence splitting

Day31~35 - Other Related Content

Advanced Python

  1. Important knowledge points
  2. Data structures and algorithms
  3. Ways of using functions
  4. Object-oriented knowledge
  5. Iterators and generators
  6. Concurrent programming

Introduction to Web Frontend

  1. Using HTML tags to carry page content
  2. Rendering pages with CSS
  3. Handling interactive behavior with JavaScript
  4. Introduction to Vue.js
  5. Using Element
  6. Using Bootstrap

Playing with the Linux Operating System

  1. History of operating-system development and an overview of Linux
  2. Basic Linux commands
  3. Utilities in Linux
  4. The Linux file system
  5. Applications of the Vim editor
  6. Environment variables and shell programming
  7. Software installation and service configuration
  8. Network access and management
  9. Other related content

Day36~45 - Database Basics and Advanced Topics

Day36 - Overview of Relational Databases and MySQL

  1. Overview of relational databases
  2. Introduction to MySQL
  3. Installing MySQL
  4. Basic MySQL commands

Day37 - SQL in Detail: DDL

  1. Creating databases and tables
  2. Dropping tables and modifying tables

Day38 - SQL in Detail: DML

  1. insert operations
  2. delete operations
  3. update operations

Day39 - SQL in Detail: DQL

  1. Projection and aliases
  2. Filtering data
  3. Null handling
  4. Deduplication
  5. Sorting
  6. Aggregate functions
  7. Nested queries
  8. Grouping
  9. Table joins
    • Cartesian product
    • Inner join
    • Natural join
    • Outer join
  10. Window functions
  • Defining windows
  • Ranking functions
  • Value-retrieval functions

Day40 - SQL in Detail: DCL

  1. Creating users
  2. Granting privileges
  3. Revoking privileges

Day41 - New Features of MySQL

  • JSON type
  • Window functions
  • Common table expressions

Day42 - Views, Functions, and Procedures

  1. Views
    • Usage scenarios
    • Creating views
    • Usage restrictions
  2. Functions
    • Built-in functions
    • User-defined functions (UDF)
  3. Procedures
    • Creating procedures
    • Calling procedures

Day43 - Indexes

  1. Execution plans
  2. Principles of indexing
  3. Creating indexes
    • Regular indexes
    • Unique indexes
    • Prefix indexes
    • Composite indexes
  4. Points to note

Day44 - Python Connecting to a MySQL Database

  1. Installing third-party libraries
  2. Creating a connection
  3. Getting a cursor
  4. Executing SQL statements
  5. Fetching data through a cursor
  6. Transaction commit and rollback
  7. Releasing connections
  8. Writing ETL scripts

Day45 - Hive in Practice

  1. Overview of Hive
  2. Environment setup
  3. Common commands
  4. Basic syntax
  5. Table-creation operations
  6. Writing data
  7. Common functions
  8. Grouping and aggregation
  9. Sampling operations
  10. Sorting operations
  11. Lateral expansion
  12. Performance optimization

Day46~60 - Django in Practice

Day46 - Getting Started with Django Quickly

  1. How web applications work
  2. HTTP requests and responses
  3. Overview of the Django framework
  4. A quick start in 5 minutes

Day47 - Models in Depth

  1. Relational-database configuration
  2. Using the ORM to complete CRUD operations on models
  3. Using the admin backend
  4. Django model best practices
  5. Model-definition reference

Day48 - Static Resources and Ajax Requests

  1. Loading static resources
  2. Ajax overview
  3. Using Ajax to implement voting

Day49 - Cookie and Session

  1. Implementing user tracking
  2. The relationship between cookies and sessions
  3. Django framework support for sessions
  4. Reading and writing cookies in view functions

Day50 - Reports and Logs

  1. Modifying response headers through HttpResponse
  2. Using StreamingHttpResponse to handle large files
  3. Using xlwt to generate Excel reports
  4. Using reportlab to generate PDF reports
  5. Using ECharts to generate frontend charts

Day51 - Logs and the Debug Toolbar

  1. Configuring logs
  2. Configuring Django Debug Toolbar
  3. Optimizing ORM code

Day52 - Applications of Middleware

  1. What middleware is
  2. Built-in middleware in Django
  3. Custom middleware and its application scenarios

Day53 - Introduction to Frontend-Backend Separation Development

  1. Returning JSON-format data
  2. Rendering pages with Vue.js

Day54 - RESTful Architecture and DRF Basics

  1. Overview of REST
  2. Getting started with the DRF library
  3. Frontend-backend separation development
  4. Applications of JWT

Day55 - RESTful Architecture and DRF Advanced

  1. Using CBV
  2. Data pagination
  3. Data filtering

Day56 - Using Caching

  1. The first law of website optimization
  2. Using Redis to provide caching services in Django projects
  3. Reading and writing cache in view functions
  4. Using decorators to implement page caching
  5. Providing caching services for data APIs

Day57 - Connecting Third-Party Platforms

  1. File-upload form controls and image preview
  2. How the server handles uploaded files

Day58 - Asynchronous Tasks and Scheduled Tasks

  1. The second law of website optimization
  2. Configuring a message queue service
  3. Using Celery in a project to make tasks asynchronous
  4. Using Celery in a project to implement scheduled tasks

Day59 - Unit Testing

Day60 - Project Going Online

  1. Unit testing in Python
  2. Django framework support for unit testing
  3. Using version-control systems
  4. Configuring and using uWSGI
  5. Separating dynamic and static resources and configuring Nginx
  6. Configuring HTTPS
  7. Configuring domain-name resolution

Day61~65 - Web Data Collection

Day61 - Overview of Web Data Collection

  1. The concept of web crawlers and their application areas
  2. Discussion of the legality of web crawlers
  3. Tools related to developing web crawlers
  4. The structure of a crawler program

Day62 - Data Fetching and Parsing

  1. Using the requests third-party library to fetch data
  2. Three ways to parse pages
    • Regular-expression parsing
    • XPath parsing
    • CSS-selector parsing

Day63 - Concurrent Programming in Python

  1. Multithreading
  2. Multiprocessing
  3. Asynchronous I/O

Day64 - Using Selenium to Fetch Dynamic Web Content

  1. Installing Selenium
  2. Loading pages
  3. Finding elements and simulating user behavior
  4. Implicit waits and explicit waits
  5. Executing JavaScript code
  6. Breaking anti-crawler protections with Selenium
  7. Setting up a headless browser

Day65 - Introduction to the Scrapy Crawler Framework

  1. Core Scrapy components
  2. The Scrapy workflow
  3. Installing Scrapy and creating a project
  4. Writing spider programs
  5. Writing middleware and pipeline programs
  6. Scrapy configuration files

Day66~80 - Python Data Analysis

Day66 - Overview of Data Analysis

  1. Responsibilities of a data analyst
  2. The skill stack of a data analyst
  3. Data-analysis libraries

Day67 - Environment Preparation

  1. Installing and using Anaconda
    • Commands related to conda
  2. Installing and using JupyterLab
    • Installation and startup
    • Useful tips

Day68 - Applications of NumPy - 1

  1. Creating array objects
  2. Properties of array objects
  3. Indexing operations on array objects
    • Regular indexing
    • Fancy indexing
    • Boolean indexing
    • Slice indexing
  4. Case study: using arrays to process images

Day69 - Applications of NumPy - 2

  1. Methods related to array objects
    • Obtaining descriptive statistics
    • Other related methods

Day70 - Applications of NumPy - 3

  1. Array operations
    • Operations between arrays and scalars
    • Operations between arrays
  2. Universal unary functions
  3. Universal binary functions
  4. Broadcasting
  5. Common NumPy functions

Day71 - Applications of NumPy - 4

  1. Vectors
  2. Determinants
  3. Matrices
  4. Polynomials

Day72 - pandas Explained in a Simple Way - 1

  1. Creating Series objects
  2. Operations on Series objects
  3. Properties and methods of Series objects

Day73 - pandas Explained in a Simple Way - 2

  1. Creating DataFrame objects
  2. Properties and methods of DataFrame objects
  3. Reading and writing data in DataFrame

Day74 - pandas Explained in a Simple Way - 3

  1. Data reshaping
    • Data concatenation
    • Data merging
  2. Data cleaning
    • Missing values
    • Duplicate values
    • Outliers
    • Preprocessing

Day75 - pandas Explained in a Simple Way - 4

  1. Data pivoting
    • Obtaining descriptive statistics
    • Sorting and top values
    • Grouping and aggregation
    • Pivot tables and crosstabs
  2. Data presentation

Day76 - pandas Explained in a Simple Way - 5

  1. Calculating year-over-year and period-over-period changes
  2. Window calculations
  3. Determining correlations

Day77 - pandas Explained in a Simple Way - 6

  1. Using indexes
    • Range indexes
    • Categorical indexes
    • Multi-level indexes
    • Interval indexes
    • Date-time indexes

Day78 - Data Visualization - 1

  1. Installing and importing matplotlib
  2. Creating the canvas
  3. Creating the axes
  4. Drawing charts
    • Line charts
    • Scatter charts
    • Bar charts
    • Pie charts
    • Histograms
    • Box plots
  5. Displaying and saving charts

Day79 - Data Visualization - 2

  1. Advanced charts
    • Bubble charts
    • Area charts
    • Radar charts
    • Rose charts
    • 3D charts

Day80 - Data Visualization - 3

  1. Seaborn
  2. Pyecharts

Day81~90 - Machine Learning

Day81 - A Brief Discussion of Machine Learning

  1. History of artificial intelligence
  2. What machine learning is
  3. Machine-learning application areas
  4. Classifications of machine learning
  5. The steps of machine learning
  6. A first machine-learning exercise

Day82 - k-Nearest Neighbors Algorithm

  1. Distance measurement
  2. Introduction to the dataset
  3. Implementing kNN classification
  4. Model evaluation
  5. Parameter tuning
  6. Implementing kNN regression

Day83 - Decision Trees and Random Forests

  1. Building decision trees
    • Feature selection
    • Data splitting
    • Tree pruning
  2. Implementing a decision-tree model
  3. Overview of random forests

Day84 - Naive Bayes Algorithm

  1. Bayes' theorem
  2. Naive Bayes
  3. Algorithm principles
    • Training stage
    • Prediction stage
    • Code implementation
  4. Advantages and disadvantages of the algorithm

Day85 - Regression Models

  1. Categories of regression models
  2. Calculating regression coefficients
  3. Introduction to a new dataset
  4. Code implementation of linear regression
  5. Evaluation of regression models
  6. Introducing regularization terms
  7. Another implementation of linear regression
  8. Polynomial regression
  9. Logistic regression

Day86 - K-Means Clustering Algorithm

  1. Algorithm principles
  2. Mathematical description
  3. Code implementation

Day87 - Ensemble Learning Algorithms

  1. Categories of algorithms
  2. AdaBoost
  3. GBDT
  4. XGBoost
  5. LightGBM

Day88 - Neural Network Models

  1. Basic composition
  2. Working principles
  3. Code implementation
  4. Advantages and disadvantages of the model

Day89 - Introduction to Natural Language Processing

  1. Bag-of-words model
  2. Word vectors
  3. NPLM and RNN
  4. Seq2Seq
  5. Transformer

Day90 - Machine Learning in Practice

  1. Data exploration
  2. Feature engineering
  3. Model training
  4. Model evaluation
  5. Model deployment

Day91~99 - Team Project Development

Day 91: Problems and Solutions in Team Project Development

  1. Software process models

    • Classical process model (waterfall model)

      • Feasibility analysis (study whether to do it or not), output: "Feasibility Analysis Report"
      • Requirements analysis (study what to build), output: "Requirements Specification" and product-interface prototypes
      • High-level design and detailed design, output: conceptual model diagrams (ER diagrams), physical model diagrams, class diagrams, sequence diagrams, and so on
      • Coding / testing
      • Release / maintenance

      The biggest disadvantage of the waterfall model is that it cannot embrace changing requirements. You only see the product after the entire process is finished, which lowers team morale.

    • Agile development (Scrum) - product owner, Scrum Master, developers - Sprint

      • Product backlog (user stories, product prototypes)
      • Planning meetings (estimation and budgeting)
      • Daily development (stand-up meetings, Pomodoro technique, pair programming, test-first development, code refactoring, and so on)
      • Bug fixing (issue description, reproduction steps, tester, assignee)
      • Version releases
      • Review meetings (showcase, with user participation)
      • Retrospective meetings (summarize the current iteration cycle)

      Supplement: Manifesto for Agile Software Development

      • Individuals and interactions over processes and tools
      • Working software over comprehensive documentation
      • Customer collaboration over contract negotiation
      • Responding to change over following a plan

      Roles: product owner (decides what to build and has the authority to finalize requirements), team lead (solves various problems, focuses on improving the way the team works, and shields the development team from outside interference), development team (project executors, specifically developers and testers).

      Preparatory work: business case and funding, contracts, vision, initial product requirements, initial release plan, equity allocation, team formation.

      Agile teams usually have 8-10 people.

      Workload estimation: quantify development tasks, including prototypes, logo design, UI design, frontend development, and so on. Break each item down to the smallest task unit possible; the standard is that the smallest task should not take more than two days. Then estimate the total project duration. Put each task on the task board, which is divided into three parts: to do, in progress, and done.

  2. Building the project team

    • Team composition and roles

      company_architecture

    • Programming standards and code review (flake8, pylint)

    • Some "conventions" in Python (please refer to Python Programming Conventions - How to Write Pythonic Code)

    • Factors that affect code readability:

      • Too few comments or no comments
      • Code breaks the best practices of the language
      • Anti-pattern programming (spaghetti code, copy-paste programming, arrogant programming, ...)

  3. Introduction to team-development tools

    Please refer to Problems and Solutions in Team Project Development.

Project Topic Selection and Understanding the Business

  1. Defining the topic scope

    • CMS (client side): news aggregation websites, Q&A / sharing communities, movie-review / book-review websites, and so on
    • MIS (client side + admin side): KMS, KPI assessment systems, HRS, CRM systems, supply-chain systems, warehouse-management systems, and so on
    • App backends (admin side + data APIs): second-hand trading, newspapers and magazines, niche e-commerce, news and information, travel, social apps, reading apps, and so on
    • Other types: your own industry background and work experience, and business domains that are easier to understand and control

  2. Understanding requirements, dividing modules, and assigning tasks

    • Requirement understanding: brainstorming and competitor analysis
    • Module division: draw mind maps (XMind). Each module is a branch node, and each concrete function is a leaf node (expressed with verbs). Ensure that each leaf node cannot be split into new nodes. Determine the importance, priority, and workload of each leaf node.
    • Task assignment: the project lead assigns tasks to each team member based on the above indicators.

  3. Creating the project schedule (updated daily)

    Module Function Member Status Done Hours Planned Start Actual Start Planned End Actual End Notes
    Comments Add comment Wang Dachui In progress 50% 4 2018/8/7 2018/8/7
    Delete comment Wang Dachui Waiting 0% 2 2018/8/7 2018/8/7
    View comment Bai Yuanfang In progress 20% 4 2018/8/7 2018/8/7 Code review needed
    Comment voting Bai Yuanfang Waiting 0% 4 2018/8/8 2018/8/8

  4. OOAD and database design

    • UML class diagrams

      uml

    • Creating tables from models (forward engineering)

      For example, in a Django project you can create database tables with the commands below.

      python manage.py makemigrations app
python manage.py migrate

    • Using PowerDesigner to draw physical model diagrams

    • Creating models from database tables (reverse engineering)

      For example, in a Django project you can generate models with the command below.

      python manage.py inspectdb > app/models.py

Day 92: Detailed Explanation of Docker Container Technology

  1. Introduction to Docker
  2. Installing Docker
  3. Creating containers with Docker (Nginx, MySQL, Redis, Gitlab, Jenkins)
  4. Building Docker images (writing Dockerfiles and related directives)
  5. Container orchestration (Docker Compose)
  6. Cluster management (Kubernetes)

Day 93: MySQL Performance Optimization

  1. Basic principles
  2. The InnoDB engine
  3. Using indexes and the points to note
  4. Data partitioning
  5. SQL optimization
  6. Configuration optimization
  7. Architecture optimization

Day 94: Network API Interface Design

  1. Design principles
    • Key issues
    • Other issues
  2. Writing documentation

Day 95: Developing Commercial Projects with Django

Common Issues in Project Development

  1. Database configuration (multiple databases, master-slave replication, database routing)
  2. Cache configuration (partitioned caching, key settings, timeout settings, master-slave replication, failover with Sentinel)
  3. Logging configuration
  4. Analysis and debugging (Django Debug Toolbar)
  5. Useful Python modules (date calculation, image processing, data encryption, third-party APIs)

REST API Design

  1. RESTful architecture
  2. Writing API interface documentation
  3. Applying django-REST-framework

Analysis of Key and Difficult Points in the Project

  1. Using caching to reduce database pressure - Redis
  2. Using message queues to decouple services and smooth traffic peaks - Celery + RabbitMQ

Day 96: Software Testing and Automated Testing

Unit Testing

  1. Types of testing
  2. Writing unit tests (unittest, pytest, nose2, tox, ddt, and so on)
  3. Test coverage (coverage)

Deploying Django Projects

  1. Preparations before deployment
    • Key settings (SECRET_KEY / DEBUG / ALLOWED_HOSTS / cache / database)
    • HTTPS / CSRF_COOKIE_SECURE / SESSION_COOKIE_SECURE
    • Log-related configuration
  2. Review of common Linux commands
  3. Installation and configuration of common Linux services
  4. Using uWSGI / Gunicorn and Nginx
    • Comparison between Gunicorn and uWSGI
      • For simple applications that do not need a lot of customization, Gunicorn is a good choice. The learning curve of uWSGI is much steeper than Gunicorn, and Gunicorn's default parameters can already fit most applications.
      • uWSGI supports heterogeneous deployment.
      • Because Nginx itself supports uWSGI, in production Nginx and uWSGI are usually deployed together, and uWSGI is a full-featured and highly customizable WSGI middleware.
      • In performance, Gunicorn and uWSGI are actually quite close.
  5. Deploying test and production environments with virtualization technology (Docker)

Performance Testing

  1. Using AB
  2. Using SQLslap
  3. Using sysbench

Automated Testing

  1. Using Shell and Python for automated testing
  2. Using Selenium for automated testing
    • Selenium IDE
    • Selenium WebDriver
    • Selenium Remote Control
  3. Introduction to Robot Framework

Day 97: Analysis of Key Technical Points for E-commerce Websites

  1. Business models and key requirements
  2. Physical-model design
  3. Third-party login
  4. Cache preheating and query caching
  5. Shopping-cart implementation
  6. Payment integration
  7. Flash-sale and overselling issues
  8. Static-resource management
  9. Full-text search solutions

Day 98: Project Deployment and Performance Tuning

  1. MySQL database tuning
  2. Web-server performance optimization
    • Nginx load-balancing configuration
    • Using Keepalived to achieve high availability
  3. Code performance tuning
    • Multithreading
    • Asynchronization
  4. Static-resource access optimization
    • Cloud storage
    • CDN

Day 99: Common Interview Questions

  1. Computer-science fundamentals
  2. Python fundamentals
  3. Questions related to web frameworks
  4. Questions related to crawlers
  5. Data analysis
  6. Project-related questions

Day 100 - Supplementary Content

  • Interview handbooks
    • Python interview handbook
    • SQL interview handbook (for data analysts)
    • Business-analysis interview handbook
    • Machine-learning interview handbook
  • Mathematical foundations of machine learning
  • Deep learning
    • Computer vision
    • Large language models