Python-入门篇

变量

变量就是存储数据的容器，用一个名字指向一块内存中的值。
在 Python 中，变量本质上是对象的引用。

变量命名规则:

只能包含字母、数字、下划线, 不能以数字开头
不能是关键字
区分大小写

推荐命名规范(PEP8):

snake_case(变量名小写，单词之间用下划线隔开) 用于 变量、函数、方法、模块。
PascalCase 专门用于类名。

示例:

标识符类型	示例
变量名	user_name, is_valid
函数名	calculate_total(), get_user_data()
方法名	class_instance.update_status()
模块名	my_module.py, data_processor.py
包名	package_name
类名	HttpRequest, User

常用的内置数据类型

Python 中常用的内置数据类型:

数据类型	中文名	示例
int	整型	10
float	浮点型	3.14
bool	布尔型	True
str	字符串	“hello word”
NoneType	空类型	None
list	列表	[1, 2, 3]
tuple	元组	(1, 2, 3)
set	集合	{1, 2, 3}
dict	字典	{“key”: “value”}

Python 是动态类型语言，不需要显式声明变量类型，解释器会根据赋值自动推断类型。
示例:

a = 1
print(type(a))
# <class 'int'>

a = 1.2 
print(type(a))
# <class 'float'>

a = "hello world"
print(type(a))
# <class 'str'>

a = True
print(type(a))
# <class 'bool'>

a = None
print(type(a))
# <class 'NoneType'>

a = [1, 2, 3, 4, 5]
print(type(a))
# <class 'list'>

a = (1, 2, 3, 4, 5)
print(type(a))
# <class 'tuple'>

a = {"name": "cx", "age": 18}
print(type(a))
# <class 'dict'>

变量赋值:

# 多变量同时赋值
a, b, c = 1, 2, 3
print(a, b, c)  # 1 2 3


# 多个变量指向同一对象
x = y = z = 100
print(x, y, z)  # 100 100 100

数字类型

整数(int)可以表示任意大小的数，精度无限制。
常用操作:

x = 10
y = 3
print(x + y)   # 13
print(x - y)   # 7
print(x * y)   # 30
print(x / y)   # 3.333...
print(x // y)  # 3 (整除)
print(x % y)   # 1 (取余)
print(x ** y)  # 1000 (幂运算)

浮点数(float)用来表示小数，有精度限制(IEEE 754 标准)。
浮点数精度问题:

print(0.1 + 0.2)  # 0.30000000000000004

解决办法:

from decimal import Decimal
print(Decimal('0.1') + Decimal('0.2'))  # 0.3

布尔类型(bool)

布尔值只有两个:

is_active = True
is_deleted = False

常见用法:

print(10 > 5)   # True
print(bool(0))  # False
print(bool("")) # False

字符串(str)

字符串是不可变对象(immutable)，用引号包裹:

# 单引号
name = 'Python'
# 双引号
msg = "Hello World"

# 三引号 (多行字符串)
str3 = '''This is
a multi-line
string'''

# 转义字符
s = 'I\'m learning Python'

常用操作:

text = "hello python"
print(text.upper())       # HELLO PYTHON
print(len(text))          # 12

# 去掉前后空格或指定字符
a = "  hello  ".strip() 
print(a)  # 'hello'

查找与判断:

# 返回子串索引，不存在返回 -1
a = "python".find("tho") 
print(a)  # 2

# 子串出现次数
a = "banana".count("a") 
print(a) # 3

# 是否以 prefix 开头
a = "python".startswith("py") 
print(a) # True

# 是否以 suffix 结尾
a = "python".endswith("on")
print(a) # True

# 判断字符串是否包含子串
s = "hello world"
print("world" in s)   # True
print("python" not in s)  # True

分割与拼接:

str1 = "Hello"
str2 = "World"
result = str1 + " " + str2
print(result) # Hello World

# 效率比 + 拼接更高
result = f"{str1} {str2}"  # 支持直接在 {} 中写表达式
print(result) # Hello World

# 序列拼接成字符串
a = ",".join(['a','b','c'])
print(a) #  'a,b,c'

# 按 分隔符 拆分成列表
text = "hello python"
print(text.split())  # ['hello', 'python']

替换:

text = "hello python"
print(text.replace("python", "world"))  # hello world

格式化字符串:

name = "Tom"
age = 20
print(f"My name is {name}, I am {age} years old.")

a = 10
b = 20
print(f"a + b = {a + b}")  # a + b = 30

字符串是有序序列，可以通过 索引和切片 操作访问.
索引:

s = "Python"
#    位置: P  y  t  h  o  n
# 正向索引: 0  1  2  3  4  5
# 反向索引: -6 -5 -4 -3 -2 -1
print(s[0])   # P
print(s[-1])  # n

切片:

# 字符串[start:end:step]
# start 包含, end 不包含

s = "Python"
print(s[0:3])   # Pyt
print(s[:4])    # Pyth
print(s[2:])    # thon
print(s[::2])   # Pto
print(s[::-1])  # nohtyP (反转字符串)

列表(list)

有序、可变、可存放任意类型:

fruits = ["apple", "banana", "cherry"]

常用操作:

fruits.append("orange")  # 添加元素
fruits.remove("banana")  # 删除指定元素
print(fruits[0])         # 访问第一个元素
print(fruits[-1])        # 访问最后一个元素

元组 (tuple)

有序、不可变:

t = (1, 2, 3)
print(t[0])  # 1

集合 (set)

无序、不重复:

s = {1, 2, 3, 3}
print(s)  # {1, 2, 3}

集合运算:

a = {1, 2, 3}
b = {3, 4, 5}
print(a | b)  # 并集 {1,2,3,4,5}
print(a & b)  # 交集 {3}
print(a - b)  # 差集 {1,2}

字典 (dict)

键值对结构，无序:

person = {"name": "Tom", "age": 20}
print(person["name"])  # Tom

常用操作:

person["age"] = 21
person["city"] = "Shanghai"
print(person.get("country", "China"))  # 默认值 China

类型转换

显式转换:

x = "123"
print(int(x))    # 123
print(float(x))  # 123.0
print(str(123))  # '123'

隐式转换:

x = 10
y = 3.5
print(x + y)  # 13.5 (自动转为 float)

变量的作用域

Python 作用域遵循 LEGB 原则:

Local: 函数内部变量
Enclosing: 外层嵌套函数变量
Global: 全局变量
Builtin: 内置变量 (如 len, print)

像洋葱一样，从最内层开始，一层层向外寻找:

Local -> Enclosing -> Global -> Built-in

一旦在某一层找到该名称，搜索就会停止。如果搜索完所有四层都没有找到，Python 就会抛出一个 NameError 异常。

示例:

x = 10  # 全局变量

def outer():
    x = 20
    def inner():
        x = 30
        print(x)
    inner()

outer()  # 输出 30

LEGB 原则默认是只读的搜索顺序。
如果你想修改外层作用域的变量，就需要使用特定的关键字。

global 用于声明并修改全局作用域的变量:

count = 0  # 全局变量

def increment():
    global count  # 声明我们要修改的是全局的 count
    count += 1    # 如果没有上一行的声明，这里会报错（UnboundLocalError）

increment()
print(count)  # 输出：1

nonlocal 用于声明并修改嵌套作用域的变量:

def outer():
    x = "old value"

    def inner():
        nonlocal x  # 声明我们要修改的是外层（Enclosing）的 x，而不是创建一个新的局部 x
        x = "new value"

    inner()
    print(x)  # 输出：new value

outer()

流程控制

Python 通过 缩进 表示代码块，推荐 4 个空格。
以冒号 : 开始一个代码块，例如 if ...:、for ...:。

条件判断

score = 86
if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
else:
    grade = "C"

条件判断中, 以下被视为 False:
0, 0.0, 0j, '' , [], {}, set(), None, False。
其余对象一般为 True

标准比较: ==, !=, <, <=, >, >=
链式比较:

x = 5
print(1 < x < 10)   # 相当于 1 < x and x < 10

逻辑运算与短路:

name = ""

# and, or, not 支持短路求值
user = name or "anonymous"   # name 为空串为假, 取右值

if user and user.startswith("a"):   # 左侧为假时 不再调用右侧; 左侧为真时 会调用右侧
    pass

条件表达式 (三元表达式):

status = "adult" if age >= 18 else "minor"

结构化模式匹配 match-case (Python 3.10+):

# 对复杂条件更优雅, 支持常量、序列、映射、类匹配与守卫条件
def http_status(code: int) -> str:
    match code:
        case 200 | 201:  # 匹配 200 或 201
            return "OK"
        case 400:
            return "Bad Request"
        case 404:
            return "Not Found"
        case 5xx if 500 <= code < 600:   # 守卫条件
            return "Server Error"
        case _:   # `_` 是通配符，总会被匹配，必须放在最后
            return "Unknown"

守卫条件：使用 if 进行细化匹配。
即使模式匹配了，你还可以使用 if 关键字添加一个额外的条件，称为守卫。
只有当模式和守卫条件都满足时，case 才会被执行。

循环

for 循环: 遍历任意可迭代对象

for ch in "python":
    print(ch)

常用工具:

# range(start, stop, step):
for i in range(1, 6):  # 1..5
    print(i)

# enumerate(iterable, start=0):
for idx, line in enumerate(lines, start=1):
    print(idx, line)

# zip(*iterables):
names = ["A", "B"]; scores = [90, 85]
for n, s in zip(names, scores):
    print(n, s)

enumerate() 函数用于将一个可迭代对象（如列表、元组、字符串）同时列出元素的下标（索引）和元素。
zip() 函数用于将多个可迭代对象中对应的元素打包成一个个元组，然后返回由这些元组组成的迭代器。

函数中的流程控制:

# return 提前返回
def safe_div(a, b):
    if b == 0:
        return None
    return a / b

# yield 与协程风格
def fib(n):
    a, b = 0, 1
    for _ in range(n):
        yield a
        a, b = b, a + b

# raise 抛出异常
def read_config(path):
    if not path.endswith(".json"):
        raise ValueError("config must be a .json file")

异常控制流:

try:
    data = load()
except FileNotFoundError as e:
    log(e)
    data = {}
except (ValueError, TypeError):
    recover()
else:
    # try 块未抛异常才会执行
    validate(data)
finally:
    # 无论是否异常都执行
    cleanup()

while 循环: 条件驱动

n = 5
while n > 0:
    print(n)
    n -= 1

# while True + break 形成事件循环
while True:
    line = input().strip()
    if not line:
        break
    process(line)

break: 立即跳出当前循环。
continue: 跳过本次迭代进入下次。
pass: 占位, 不做任何事。

循环的 else 子句:

def contains_prime(nums):
    for n in nums:
        if n > 1 and all(n % d for d in range(2, int(n**0.5)+1)):
            print("found prime:", n)
            break
    else:
        print("no prime found")

列表/集合/字典推导式:

# 列表: 平方且仅保留偶数
squares = [x*x for x in range(10) if x % 2 == 0]

# 集合: 去重后的首字母
first_letters = {w[0].lower() for w in ["Apple", "Banana", "Avocado"]}

# 字典: 键值对转换
mapping = {k: len(k) for k in ["python", "java", "go"]}

使用 any/all 简化嵌套判断:

if all(ch.isdigit() for ch in token) and any(ch != '0' for ch in token):
    ...

函数(Function)

函数(Function) 是一段可以被重复调用的代码块, 用于完成特定的任务, 可以接收输入(参数), 并返回输出(返回值)。

使用 def 关键字定义函数:

def 函数名(参数列表):
    """可选: 文档字符串，用于描述函数"""
    函数体
    return 返回值  # 可选

示例:

def greet():
    print("Hello, Python!")
    
greet()  # 调用函数

函数参数

位置参数 (Positional Arguments): 按照定义顺序传入值。

def greet(name, age):
    print(f"Hi {name}, you are {age} years old.")

greet("Tom", 18)

默认参数 (Default Arguments): 为参数设置默认值, 调用时可以省略。

def greet(name="Guest"):
    print(f"Welcome, {name}!")

greet()        # 默认参数
greet("Alice") # 传入新值

注意: 默认参数必须放在普通参数的后面。

关键字参数 (Keyword Arguments): 通过参数名=值的方式传递, 不受顺序限制。

def greet(name, age):
    print(f"{name} is {age} years old.")

greet(age=20, name="Bob")

可变参数 *args: 接收任意数量的位置参数

def add(*args):
    print(args)
    return sum(args)

print(add(1, 2, 3, 4))

可变参数 **kwargs: 接收任意数量的关键字参数

def show_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

show_info(name="Alice", age=22, city="Tokyo")

参数定义顺序建议:

位置参数 -> 默认参数 -> *args -> **kwargs

示例:

def func(a, b=2, *args, **kwargs):
    print(a, b, args, kwargs)

func(1, 3, 4, 5, name="Tom", age=18)

函数返回值

使用 return 返回结果, 如果没有写 return, 默认返回 None。

def add(a, b):
    return a + b

result = add(5, 7)
print(result)  # 12

返回多个值(其实是返回一个元组):

def calc(a, b):
    return a+b, a-b, a*b, a/b

print(calc(6, 3))

变量作用域

局部变量 (Local Variable): 定义在函数内部, 只能在函数内部访问。

def test():
    x = 10
    print(x)

test()
# print(x)  # 报错: NameError

全局变量 (Global Variable): 定义在函数外部, 可以在函数内部访问。如果需要在函数内部修改全局变量, 使用 global。

x = 100

def test():
    print(x)

test()


def change():
    global x
    x = 200

change()
print(x)  # 200

匿名函数 (lambda)

lambda 用于定义简洁的匿名函数, 适合简单逻辑。
语法:

lambda 参数: 表达式

示例:

add = lambda x, y: x + y

print(add(3, 5))  # 8

结合 map, filter, sorted 等函数使用:

nums = [1, 2, 3, 4, 5]

squares = list(map(lambda x: x**2, nums))

print(squares)  # [1, 4, 9, 16, 25]

高阶函数

Python 函数是一等公民, 可以作为参数传递或返回值。

def apply(func, value):
    return func(value)

print(apply(abs, -10))  # 10

函数的进阶用法

嵌套函数:

def outer():
    def inner():
        print("Inner function")
    inner()

outer()

闭包 (Closure): 函数中返回另一个函数, 并捕获外部变量。

def outer(x):
    def inner(y):
        return x + y
    return inner

add5 = outer(5)
print(add5(10))  # 15

装饰器 (Decorator): 用于增强函数功能。

def decorator(func):
    def wrapper():
        print("Before")
        func()
        print("After")
    return wrapper

@decorator
def say_hello():
    print("Hello!")

say_hello()

内置函数

map() 内置函数，用于对可迭代对象（如列表、元组等）中的每个元素应用一个指定的函数，并返回 一个包含所有结果的新迭代器。

# map(function, iterable, ...)

numbers = [1, 2, 3, 4, 5]

# 使用 lambda 函数
squared = map(lambda x: x**2, numbers)
print(list(squared))  # 输出: [1, 4, 9, 16, 25]

# 等价于列表推导式
squared = [x**2 for x in numbers]
print(squared)  # 输出: [1, 4, 9, 16, 25]


words = ['hello', 'world', 'python']

upper_words = map(str.upper, words)
print(list(upper_words))  # 输出: ['HELLO', 'WORLD', 'PYTHON']

对多个可迭代对象操作:

list1 = [1, 2, 3]
list2 = [4, 5, 6]

# 两个列表对应元素相加
result = map(lambda x, y: x + y, list1, list2)
print(list(result))  # 输出: [5, 7, 9]

sorted() 内置函数用于对可迭代对象进行排序，并 返回一个新的排序后的列表，不会修改原始对象。

sorted(iterable, key=None, reverse=False)

iterable: 要排序的可迭代对象（列表、元组、字符串等）
key: 排序的关键字函数（可选）
reverse: 是否反向排序（可选，默认为 False 即升序）
返回值: 一个新的已排序列表

示例:

numbers = [3, 1, 4, 1, 2]
sorted_numbers = sorted(numbers)

print(sorted_numbers)  # 输出: [1, 1, 2, 3, 4]
print(numbers)         # 输出: [3, 1, 4, 1, 2] (原列表未改变)

filter() 内置函数用于过滤可迭代对象中的元素，只保留那些使指定函数返回 True 的元素，并返回一个包含这些元素的迭代器。

filter(function, iterable)

function: 判断函数，返回 True 或 False。如果为 None，则使用身份函数（过滤掉假值）
iterable: 要过滤的可迭代对象（列表、元组、字符串等）
返回值: 一个 filter 对象（迭代器）

示例:

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

def is_even(n):
    return n % 2 == 0

even_numbers = filter(is_even, numbers)
print(list(even_numbers))  # 输出: [2, 4, 6, 8, 10]

# 使用 lambda 函数筛选奇数
odd_numbers = filter(lambda x: x % 2 != 0, numbers)
print(list(odd_numbers))  # 输出: [1, 3, 5, 7, 9]

变量#

常用的内置数据类型#

数字类型#

布尔类型(bool)#

字符串(str)#

列表(list)#

元组 (tuple)#

集合 (set)#

字典 (dict)#

类型转换#

变量的作用域#

流程控制#

条件判断#

循环#

函数(Function)#

函数参数#

函数返回值#

变量作用域#

匿名函数 (lambda)#

高阶函数#

函数的进阶用法#

内置函数#

变量

常用的内置数据类型

数字类型

布尔类型(bool)

字符串(str)

列表(list)

元组 (tuple)

集合 (set)

字典 (dict)

类型转换

变量的作用域

流程控制

条件判断

循环

函数(Function)

函数参数

函数返回值

变量作用域

匿名函数 (lambda)

高阶函数

函数的进阶用法

内置函数