Course Introduction#
Stage One: Basic to Advanced#
Three projects
- ATM + Shopping Cart: Procedural
- Course Selection System: Object-Oriented
- Computer Virus: Program, Server, Client
Stage Two: Commercial Projects#
- BBS
- Luffy Learning City
- WeChat Mini Programs
- Web Scraping
- Data Analysis: Financial Quantitative Trading
- Automated Operations: CMDB, Code Deployment
- GO Language Development
- Artificial Intelligence Direction
Computer#
Five Major Components of a Computer#
- CPU Central Processing Unit
- Controller: Controls all other components
- Arithmetic Logic Unit: Mathematical and logical operations
- Memory I/O Devices: Data access
- RAM: Based on electricity, loses data when powered off, used for temporary access
- Storage: Hard disk, based on magnetism, slow access, permanent storage
- Input Devices: Keyboard, Mouse
- Output Devices: Monitor, Printer
Operating System#
Concept#
- Controls computer hardware
- Encapsulates complex operations of hardware
Software
- Application Software
- System Software
Three-Tier Structure of Computer Architecture#
- Application Programs
- Operating System
- Computer Hardware
Platform and Cross-Platform#
Platform:
- Operating System
- Computer Hardware
Others#
Programs and Three Core Hardware#
Program: Hard Disk -> Memory
CPU reads instructions from memory for execution
CPU Detailed Explanation#
CPU Classification and Instruction Set#
- X86-32bit: Intel
- x86-64bit: AMD
Instruction Set is a collection of instructions used by the CPU to compute and control the computer system.
- Reduced Instruction Set Computer (RISC): Short instructions, stable
- Complex Instruction Set Computer (CISC): Long instructions, rich
X86-64#
-
x86: Intel invented the world's first CPU 8086, hence this architecture is collectively referred to as x86.
-
64-bit: The number of bits the CPU can fetch from memory in one go.
The CPU has downward compatibility.
Registers#
Made of the same material as the CPU, faster than memory. Stores critical data needed by the CPU, enhancing the speed of data retrieval.
Kernel Mode and User Mode#
Two types of programs
- Operating System: Kernel mode, calls the instruction set for controlling hardware and arithmetic instruction set
- Application Programs: User mode, only calls arithmetic-related instruction sets
Thus, frequent switching between the two states.
Multithreading and Multi-Core Chips#
Moore's Law.
Single-core dual-threading means one CPU performs the work of two CPUs, pseudo-parallelism, false dual-core.
4 cores 8 threads: Each CPU has 2 threads.
- Intel: All cores share one L2 cache
- AMD: Each core has its own L2 cache
Memory I/O Related#
- Register L1: 32-bit 32x32, 64-bit 64x64
- Cache L2: The CPU first looks in the cache; if a cache hit occurs, it retrieves from there; if not, it looks in memory.
- Memory
- Disk
- Tape
Speed from fast to slow
RAM#
Random Access Memory
ROM#
Read-Only Memory, speed similar to memory. Generally used for storing critical factory programs, such as BIOS.
CMOS#
Also volatile. Slow speed. Extremely low power consumption. The motherboard has a battery that powers the clock chip, storing calculations in CMOS.
Disk Structure#
Hard Disk:
- Mechanical Hard Disk, i.e., disk, relies on mechanical rotation.
- Tracks: A circle of data bits (binary) - Byte - kB; in fact, hard disk manufacturers count in 1000s.
- Sector: 512 bytes, the smallest unit of read/write for the hard disk. The operating system reads one block at a time, i.e., 8 sectors = 4096 bytes.
- Cylinder: Tracks of the same radius stacked together form a virtual cylinder.
- Partition: The section between two cylinders.
- Solid State Drive
I/O Latency#
The read/write speed of the hard disk is fast; the slowness lies in the time taken to find data.
- Average Seek Time
- Average Latency Time: Minimum is the time for the disk to rotate half a turn.
I/O latency is the sum of the above two.
The core method to optimize programs is to reduce read/write from the hard disk and try to read/write from memory as much as possible.
Virtual Memory Swap#
When physical memory is insufficient, it is allocated on the disk. This will introduce I/O latency.
I/O Devices#
Includes
- Device Control: Driver
- The device itself
Bus#
Connects various components on the motherboard for interaction.
- PCI Bridge: Northbridge, connects high-speed devices
- ISA Bridge: Southbridge, connects slow-speed devices
Operating System Boot Process#
BIOS: Basic Input Output System, written into the ROM device at the factory.
Boot Process:
- Power on the computer
- BIOS runs to check hardware status
- BIOS reads parameters from the CMOS memory, selects the boot device
- Reads the content of the first sector from the boot device (MBR Master Boot Record 512 bytes, first 446 bytes for boot information, last 64 bytes for partition information, last two are flag bits)
- Based on partition information, loads the BootLoader startup module to start the operating system
- The operating system queries BIOS for configuration information and loads drivers.
Introduction to Python#
Introduction to Programming Languages#
- Machine Language
- Assembly Language
- High-Level Language
- Compiled: c -> gcc compiler -> machine language, high execution efficiency
- Interpreted: py -> bytecode -> interpreter (line by line) -> machine, strong cross-platform capability
Introduction to Python#
- Interpreted
- Syntax Style: PEP8 Specification
Interpreter#
Interpreters can be written in any language, such as CPython, Jython.
2.6-2008
2.7-2010 Transition version released later
3.0-2008
3.1-2009
3.2-2011
Two Ways to Run Python Programs#
- Interactive
- Script
Three Steps to Run a Program#
- Start the interpreter
- The interpreter reads the .py file into memory
- The interpreter interprets and executes
Variables and Basic Data Types#
Variables#
Three Major Components#
Variable Name Assignment Symbol Variable Name
Variable Name#
Recommended to use lowercase with underscores
Three Characteristics of Variable Values#
- id: Memory address of the variable value
id()
- type
type()
- value
Mutable and Immutable Types#
- Mutable Types: Change value, memory address id remains unchanged
- set
- list
- dict
- Immutable: Change value, id also changes
- number
- bool
- string
- tuple
is and ==#
- is compares whether the memory addresses of the two variables are the same
- == compares the values of the variables
Small Integer Object Pool#
From the start of the interpreter, a series of memory spaces are pre-allocated to store commonly used integers (-5, 256)
The small integer pool in IDEs can be larger.
Constants#
Python syntax does not have the concept of constants!
All uppercase represents a constant, which is just a convention; it is still a variable in practice.
Basic Data Types#
String#
Single, double, and triple quotes can all be used for definition; when nested, the quotes should be opposite or escaped.
print('-' * 10)
# -----------
List#
Stores the memory addresses of values, not the values themselves!
If list2 = list1, both point to the same heap; changing the value will change both.
Shallow and Deep Copy:
- Shallow Copy: Copies the first layer of memory addresses, but if there are mutable types, they will still be linked.
list2 = list1.copy()
- Deep Copy: Completely independent copy; immutable types retain the same id, mutable types change id.
import copy
list3 = copy.deepcopy(list1)
Dictionary#
a = {
"key": "value",
"1": 1,
"2": "qwe"
}
Garbage Collection Mechanism (GC)#
Reference Counting#
Garbage: Variable values not bound to variable names.
Reference Counting: The number of variables bound to a certain value; Python will clear values with a count of 0.
del x # Unbinds the variable from the value
Direct reference, indirect reference.
Mark and Sweep#
Circular reference issues can lead to memory leaks.
Memory stack stores variable names, heap stores values.
Generational Collection#
Variables that have not been collected after multiple scans are considered commonly used variables, and their scanning frequency will be reduced.
User Interaction#
Input#
input() # Stored as str
# python2
raw_input() # Stored as str
input() # Requires the user to input a specific data type; the input type is the type of the variable.
Formatted Output#
- % Formatted Output
print("name: %(name)s, age:%(age)d" % {"name": "a", "age": 10})
# %s can accept any type
- str.format
print("name: {name}, age:{age}".format(name="a", age=10))
- f
print(f"name: {name}, age:{age}")
Basic Operators#
Arithmetic Operators#
10 // 3 # Only keeps the integer part, i.e., integer division
3 ** 10 # Exponentiation
10 % 3 # Modulus
Comparison Operators#
1 != 2
1 < x < 3
Assignment Operators#
- Variable Assignment
a = 1
- Increment Assignment
a += 1
b *= 1
- Chained Assignment
z = y = x = 10
- Cross Assignment
m, n = n, m
- Unpacking Assignment
list = [1, 2, 3, 4]
a, b, c, d = list
x, y, *_ = list # Take the first two
*_ , x, y = list # Take the last two
# Dictionary unpacking takes values by key
Logical Operators#
Implicit Boolean: All values, except for 0, None, False, Null, empty values are True.
Priority: not > and > or
Short-Circuit Evaluation: Conditions are read from left to right; if any condition in a series of and is false, it stops reading further and returns that value.
Membership Operator in#
"a" in "abc"
1 in [1, 2, 3]
Identity Operator is#
Flow Control#
if#
if 16 < a < 20:
elif conditions are checked from top to bottom; the next condition is checked only if the previous one is not satisfied.
while#
Conditional loop
while + else#
If the loop ends normally without being broken, run else.
while True:
...
else:
...
for#
Iterative loop
for variable in Iterable object:
...
for i in range(1, 100):
...
for + else#
range#
# py2
>>> range(0, 5)
[0, 1, 2, 3, 4]
# py3 optimized
>>> range(0, 5)
range(0, 5)
print#
print("hello", end="*") # Custom end, default is newline
Basic Data Types and Built-in Methods#
Numeric Types#
int#
Python 3 no longer has long integers.
int('10')
bin(11) # 0b1011 0b indicates binary
oct(11) # 0o13 octal
hex(11) # 0xb hexadecimal
int(int('0b1011', 2)) # Convert binary to decimal
float#
float('11')
Complex Numbers#
x = 10 + 2j
x.real # 10
x.imag # 2
String#
# Immutable, is a whole; cannot change a single character
str(10)
msg = "hello"
# Slicing
msg[0] # h
msg[-1] # o
msg[0:5] # hello (includes start, excludes end)
msg[0:5:2] # hlo
msg[5:0:-1] # olle
"alex" in "alexxxx" # true
"alex" not in "alexxxx" # false
msg = " eee "
res = msg.strip() # Default removes spaces from both ends; strings are immutable, so need to reassign
msg = "***eee***"
res = msg.strip("*") # strip only removes from both ends, not the middle
res = msg.lstrip()
res = msg.rstrip()
# Splitting: Splits the string by a character, returns a list
res = msg.split(":", 1) # Default splits by space, counts splits from left to right
res = msg.lsplit(":", 1)
res = msg.rsplit(":", 1) # From right to left
res2 = ":".join(res) # Joins with ":"
res = msg.lower() # Lowercase
res = msg.upper()
res = msg.startswith("aaa") # True, checks what it starts with
res = msg.endswith("aaa")
res = msg.replace("you", "me", 1) # String replacement, number of times
"123".isdigit() # Pure digits
msg.find("e") # Returns index, -1 if not found
msg.index("e") # Returns index, raises error if not found
msg.count("e") # Count occurrences of substring
"Divider".center(50, "*") # Fill with * on both sides
"Divider".ljust(50, "*") # Fill on the right
"Divider".rjust(50, "*")
"Divider".zfill(50) # Fill with 0 on the left
# is check series, refer to documentation
isalpha()
isdigit()
isdecimal() # Only recognizes Arabic numerals; py3 defaults to unicode
isnumeric() # Can recognize Chinese characters and Arabic numerals