Comprehensive Python Knowledge Summary: Language Differences, Advanced Features, Libraries, Concurrency, Testing, and System Design

This article compiles a comprehensive Python cheat‑sheet covering language differences between Python 2 and Python 3, key built‑in modules, and common pitfalls.

Py2 vs Py3 differences include print becoming a function, Unicode handling, division behavior, removal of long type, xrange replacement, advanced unpacking, keyword‑only arguments, raise from, iterator changes, asyncio support, new standard libraries (enum, mock, ipaddress, concurrent.futures, selector, etc.).

Enum usage example:

#枚举的注意事项
from enum import Enum

class COLOR(Enum):
    YELLOW = 1
    GREEN = 1  # alias, no error
    BLACK = 3
    RED = 4
print(COLOR.GREEN)  # prints COLOR.YELLOW
for i in COLOR:
    print(i)  # does not iterate over GREEN alias
for name, member in COLOR.__members__.items():
    print(name, member)

Conversion tools : six for compatibility, 2to3 for syntax migration, and __future__ imports for forward‑compatible features.

Frequently used libraries include collections, heapq, itertools, dis, inspect, cProfile, bisect, fnmatch, timeit, contextlib, types, html, mock, concurrent.futures, selector, asyncio, and more, each illustrated with short code snippets.

Advanced concurrency examples:

from multiprocessing import Manager, Process, Pipe, Queue, Pool

def add_data(p_dict, key, value):
    p_dict[key] = value

if __name__ == "__main__":
    progress_dict = Manager().dict()
    p1 = Process(target=add_data, args=(progress_dict, "bobby1", 22))
    p2 = Process(target=add_data, args=(progress_dict, "bobby2", 23))
    p1.start(); p2.start(); p1.join(); p2.join()
    print(progress_dict)

Pipe communication (higher performance than Queue) and Queue usage for producer/consumer patterns are also demonstrated, along with a process pool example.

GIL and async : explanation of the Global Interpreter Lock, its release on I/O, and how asyncio/async‑await enable native coroutine support. Code shows task creation, callbacks, and event‑loop control.

Metaclasses and duck typing :

class Yuan(type):
    def __new__(cls, name, bases, attrs, *args, **kwargs):
        return type(name, bases, attrs, *args, **kwargs)

class MyClass(metaclass=Yuan):
    pass

Duck typing is illustrated by showing that Python functions accept any object with the required interface.

Copy semantics : deep copy vs shallow copy using the copy module.

Testing : unittest TestCase with setUp/tearDown, pytest conventions, and coverage usage.

Introspection (id, type, isinstance) and attribute resolution order (LEGB) are described.

System utilities : sys.argv, sys.path, modules.keys(), exit, environment variables via os.getenv, and garbage‑collection thresholds (gc.get_threshold()).

Network fundamentals cover HTTPS, common HTTP status codes, idempotent and safe methods, WSGI application skeleton, RPC, CDN, SSL/TLS, SSH, TCP/UDP handshakes, TIME_WAIT rationale, and XSS/CSRF mitigations.

MySQL topics include index evolution (linear → B‑Tree), interview notes, InnoDB vs MyISAM delete behavior, index misuse cases (leading % LIKE, implicit casts, functions on columns), primary‑key clustering, and when indexes become ineffective.

Redis overview explains why it is fast (in‑memory, single‑threaded, event‑loop), data types (string, list, hash, set, sorted set), persistence (RDB, AOF), transactions (MULTI/EXEC), queue implementation (LPUSH/RPOP), distributed lock using SETNX/EXPIRE, cache issues (snowball, penetration, pre‑heat, downgrade), and consistent hashing.

Linux I/O models (blocking, non‑blocking, select/poll/epoll, signal‑driven, async), paging vs segmentation, memory inspection commands (top, free), and signal differences (SIGTERM vs SIGKILL).

Design patterns with code:

# Singleton (decorator style)
def Single(cls):
    instances = {}
    def get_instance(*args, **kwargs):
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]
    return get_instance

@Single
class B:
    pass

# Factory example
class Dog:
    def __init__(self):
        print("Wang Wang Wang")

class Cat:
    def __init__(self):
        print("Miao Miao Miao")

def fac(animal):
    if animal.lower() == "dog":
        return Dog()
    if animal.lower() == "cat":
        return Cat()
    print("Only dog or cat supported")

Data structures and algorithms include implementations of quick sort, selection sort, insertion sort, merge sort, heap sort (using heapq), stack and queue classes based on collections.deque, binary search, and interview‑style problems such as reversing a linked list, merging sorted lists, and building a short‑URL service.

Caching algorithms LRU and LFU are described, followed by a list of server‑side performance optimisation directions: algorithmic improvements, database indexing and slow‑query elimination, network I/O batching, Redis caching, asynchronous programming (asyncio, Celery), and concurrency (threads, gevent).

Promotional notice : the original source also contains a QR‑code invitation to a free Python public course, which is omitted from the technical summary.