初学者python 整理的资料 基础语法 解释

python 基础语法

类别	关键字	说明
逻辑值	True	布尔真值
	False	布尔假值
	None	表示空值或无值
逻辑运算	and	逻辑与运算
	or	逻辑或运算
	not	逻辑非运算
条件控制	if	条件判断语句
	elif	否则如果（else if 的缩写）
	else	否则分支
循环控制	for	迭代循环
	while	条件循环
	break	跳出循环
	continue	跳过当前循环的剩余部分，进入下一次迭代
异常处理	try	尝试执行代码块
	except	捕获异常
	finally	无论是否发生异常都会执行的代码块
	raise	抛出异常
函数定义	def	定义函数
	return	从函数返回值
	lambda	创建匿名函数
类与对象	class	定义类
	del	删除对象引用
模块导入	import	导入模块
	from	从模块导入特定部分
	as	为导入的模块或对象创建别名
作用域	global	声明全局变量
	nonlocal	声明非局部变量（用于嵌套函数）
异步编程	async	声明异步函数
	await	等待异步操作完成
其他	assert	断言，用于测试条件是否为真
	in	检查成员关系
	is	检查对象身份（是否是同一个对象）
	pass	空语句，用于占位
	with	上下文管理器，用于资源管理
	yield	从生成器函数返回值

以下是Python关键字的分类总结和编程逻辑进行结构化说明：

---

一、基础逻辑与值

0. 布尔值与空值

   • True/False：布尔真/假值，用于条件判断。
   • None：表示空值或无值，常用于初始化变量或函数默认返回值。 示例：if user_logged_in is None: ...

1. 逻辑运算

   • and/or/not：组合条件判断。优先级：not > and > or。 注意：1 < 2 < 3 等价于 1 < 2 and 2 < 3（链式比较）。

---

二、流程控制

0. 条件分支

   • if/elif/else：多分支控制，elif可替代其他语言的switch-case。 优化建议：避免深层嵌套，可用字典映射替代多elif。

1. 循环与中断

   • for：遍历序列（如列表、字符串）。
   • while：条件满足时持续循环。
   • break/continue：控制循环流程，break可提前退出（如搜索到结果时）。 注意：循环中可结合else（当循环未被break终止时执行）。

---

三、函数与模块

0. 函数定义

   • def：定义函数；lambda：匿名函数（适合简单逻辑）。
   • return：返回值，无return时默认返回None。 示例：add = lambda x, y: x + y

1. 模块管理

   • import/from...import：导入模块或特定对象。
   • as：别名（如import numpy as np）。 应用场景：避免命名冲突或简化长模块名。

---

四、高级特性

0. 异常处理

   • try/except/finally：捕获异常并确保资源释放（如文件关闭）。
   • raise：主动抛出异常（如参数校验失败时）。

1. 上下文与资源管理

   • with：自动管理资源（如with open('file.txt') as f:）。 优势：替代手动try-finally，更简洁安全。

2. 生成器与异步

   • yield：生成器函数返回值（惰性计算）。
   • async/await：协程异步编程（如处理IO密集型任务）。

---

五、类与作用域

0. 面向对象

   • class：定义类；del：删除对象引用（实际少用，依赖垃圾回收）。

1. 变量作用域

   • global：修改全局变量；nonlocal：修改嵌套函数中的变量。 慎用：过度使用global可能降低代码可维护性。

---

六、其他关键字

• assert：调试时验证条件（生产环境可能被禁用）。
• in/is：成员检查（in）和对象身份比较（is）。
• pass：占位符（如未实现的函数体）。

---

附：当前日期关联示例

检查是否为周末（2025年6月14日为周六）
from datetime import datetime 
today = datetime(2025, 6, 14)
if today.weekday() >= 5:  # 5=周六, 6=周日 
    print("今天是周末！")
else:
    print("工作日")

以上关键字覆盖了Python核心语法，合理使用可提升代码效率和可读性。

以下是针对Python关键字的超详细语法解释与示例，专为初学者设计，结合今天的时间（2025年6月14日周六 16:04）和生活化场景说明：

---

一、逻辑值与运算

0. True/False/None

布尔值就像开关：True=开，False=关 
is_weekend = True  # 今天周六确实是周末 
has_homework = False 
print(is_weekend)  # 输出：True 
 
None表示"没有东西"
my_cat = None  # 暂时没有养猫 

2. and/or/not

and: 两个条件都满足 
if is_weekend and not has_homework:  # 周末且没作业 
    print("可以玩游戏！")  # 会输出 
 
or: 满足任意一个 
weather = "rainy"
if weather == "sunny" or weather == "cloudy":
    print("适合外出")
else:
    print("建议宅家")  # 今天下雨，输出这个 

---

二、流程控制

3. if/elif/else

像做选择题：
time_now = 16  # 当前16点 
if time_now < 12:
    print("早上好")
elif 12 <= time_now < 18:  # 16点在这个范围 
    print("下午好")  # 输出这个 
else:
    print("晚上好")

4. for/while循环

for循环：固定次数执行 
for i in range(3):  # 循环3次(i=0,1,2)
    print(f"第{i+1}次说你好")
 
while循环：满足条件就执行 
countdown = 3 
while countdown > 0:
    print(f"倒计时：{countdown}")
    countdown -= 1  # 每次减1 

5. break/continue

break：立刻停止循环 
for num in [1, 2, 3, 4]:
    if num == 3:
        break  # 遇到3就退出 
    print(num)  # 只输出1,2 
 
continue：跳过当前 
for num in [1, 2, 3]:
    if num == 2:
        continue  # 跳过2 
    print(num)  # 输出1,3 

---

三、函数与异常

6. def/return/lambda

def：定义函数（代码打包）
def greet(name):
    return f"你好, {name}!"  # return返回结果 
 
print(greet("小明"))  # 输出：你好, 小明!
 
lambda：快速定义简单函数 
double = lambda x: x * 2 
print(double(5))  # 输出10 

7. try/except/finally

try：尝试执行可能出错的代码 
try:
    print(10 / 0)  # 这里会报错 
except ZeroDivisionError:  # 捕获特定错误 
    print("不能除以零！")  # 输出这个 
finally:  # 无论如何都会执行 
    print("计算结束") 

---

四、类与文件操作

8. class/with

class：创建对象的蓝图 
class Cat:
    def __init__(self, name):
        self.name = name  # 初始化属性 
 
my_cat = Cat("橘胖")  # 创建实例 
print(my_cat.name)  # 输出：橘胖 
 
with：安全操作文件（自动关闭）
with open('diary.txt', 'w') as f:
    f.write("2025年6月14日 下雨\n")  # 写入内容 
退出with块后文件自动关闭 

---

五、特殊技巧

9. in/is/yield

in：检查是否包含 
fruits = ["苹果", "香蕉"]
print("香蕉" in fruits)  # 输出：True 
 
is：判断是否是同一个对象 
a = [1,2]
b = a 
print(a is b)  # True（同一个列表）
 
yield：生成器函数 
def count_to_3():
    yield 1 
    yield 2 
    yield 3 
 
for num in count_to_3():  # 逐个产生数字 
    print(num)  # 输出1,2,3 

---

六、初学者常见疑问解答

0. == 和 is 的区别

   • == 比较值是否相等，is 判断是否是同一个对象

   a = [1,2]; b = [1,2]
   print(a == b)  # True（值相同）
   print(a is b)  # False（不同对象）
   

1. 什么时候用 None？

   • 明确表示"无值"时使用，比如函数默认返回值或变量初始化：

   def find_student(id):
       if id not in database:
           return None  # 明确表示没找到 
   

2. pass 的作用

   • 占位符，用于暂时不写代码的地方：

   def future_feature():
       pass  # 先占位，以后实现 
   

---

今日时间彩蛋

from datetime import datetime 
today = datetime(2025, 6, 14)
print(f"今天是{today.year}年{today.month}月{today.day}日，星期{today.weekday()+1}")
输出：今天是2025年6月14日，星期6（周六）

所有示例均可直接复制运行，建议初学者在Python交互环境中逐条尝试并观察结果！

语法命令的简单解释

• True 和 False

  • 使用方法：直接在代码里使用，常作为条件判断的结果。例如 result = 5 > 3，这里 result 的值就是 True。
  • 解释：True 代表布尔真值，False 代表布尔假值，就像开关的开和关，用来表示条件是否成立。

• None

  • 使用方法：通常用于初始化变量，表示这个变量目前没有有效的值。比如 my_variable = None。
  • 解释：None 表示空值或者无值，好比一个空盒子，里面什么都没有。

逻辑运算

• and

  • 使用方法：条件1 and 条件2，只有当两个条件都为 True 时，整个表达式才为 True。例如 (5 > 3) and (4 < 6) 结果是 True。
  • 解释：and 就像“并且”的意思，要求两边的条件都满足才行。

• or

  • 使用方法：条件1 or 条件2，只要两个条件中有一个为 True，整个表达式就为 True。例如 (5 < 3) or (4 < 6) 结果是 True。
  • 解释：or 类似“或者”的意思，只要有一边的条件满足就可以。

• not

  • 使用方法：not 条件，对条件的布尔值取反。比如 not (5 < 3) 结果是 True。
  • 解释：not 就是“相反”的意思，把原来的真假情况反过来。

条件控制

• if

  • 使用方法：

if 条件: 
    代码块 

如果条件为 True，就执行代码块里的代码。例如：

if 5 > 3: 
    print("5 大于 3") 

- 解释：`if` 就像一个关卡，条件通过了，就执行里面的代码。 

• elif

  • 使用方法：

if 条件1: 
    代码块1 
elif 条件2: 
    代码块2 

如果 条件1 不成立，就检查 条件2，若 条件2 成立，就执行 代码块2。 - 解释：elif 是 else if 的缩写，在 if 条件不满足时，提供另一个检查条件的机会。

• else

  • 使用方法：

if 条件: 
    代码块1 
else: 
    代码块2 

如果 条件 不成立，就执行 代码块2。 - 解释：else 是 if 的“备胎”，当 if 的条件不满足时，就执行 else 里的代码。

循环控制

• for

  • 使用方法：

for 变量 in 可迭代对象: 
    代码块 

例如：

for i in [1, 2, 3]: 
    print(i) 

- 解释：`for` 循环就像依次从一个盒子里拿出东西，每拿一个东西就执行一次代码块。 

• while

  • 使用方法：

while 条件: 
    代码块 

只要 条件 为 True，就会一直执行 代码块。例如：

i = 0 
while i < 3: 
    print(i) 
    i = i + 1 

- 解释：`while` 循环就像一个自动门，只要条件满足，门就一直开着，人就可以不断通过。 

• break

  • 使用方法：放在循环体里，当执行到 break 时，会立即跳出循环。例如：

for i in [1, 2, 3]: 
    if i == 2: 
        break 
    print(i) 

- 解释：`break` 就像一个紧急停止按钮，按下后循环就立刻停止。 

• continue

  • 使用方法：放在循环体里，当执行到 continue 时，会跳过当前循环的剩余部分，直接进入下一次迭代。例如：

for i in [1, 2, 3]: 
    if i == 2: 
        continue 
    print(i) 

- 解释：`continue` 就像一个跳过指令，遇到它就跳过当前这一轮的剩余操作，直接开始下一轮。 

异常处理

• try

  • 使用方法：

try: 
    代码块 
except 异常类型: 
    处理代码块 

先执行 try 里的代码块，如果出现指定的异常类型，就执行 except 里的处理代码块。例如：

try: 
    result = 1 / 0 
except ZeroDivisionError: 
    print("不能除以零") 

- 解释：`try` 就像一个“试验场”，先试试代码能不能正常运行，如果出问题了，就由 `except` 来处理。 

• except

  • 使用方法：和 try 搭配使用，捕获指定类型的异常。
  • 解释：except 就像一个“故障维修员”，当 try 里的代码出现问题时，它就会出来处理。

• finally

  • 使用方法：

try: 
    代码块 
except 异常类型: 
    处理代码块 
finally: 
    无论是否异常都会执行的代码块 

不管 try 里的代码是否出现异常，finally 里的代码块都会执行。 - 解释：finally 就像一个“收尾工”，不管前面的代码运行得怎么样，它都会把收尾工作做好。

• raise

  • 使用方法：raise 异常类型("异常信息")，主动抛出一个异常。例如：

if x < 0: 
    raise ValueError("x 不能为负数") 

- 解释：`raise` 就像一个“警报器”，当满足某些条件时，主动发出警报（抛出异常）。 

函数定义

• def

  • 使用方法：

def 函数名(参数): 
    代码块 
    return 返回值 

例如：

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

- 解释：`def` 就像一个“工厂设计师”，它定义了一个函数，告诉计算机这个工厂（函数）要做什么工作。 

• return

  • 使用方法：放在函数里，将函数的结果返回。例如上面的 add 函数，调用 result = add(1, 2)，result 就会得到 3。
  • 解释：return 就像工厂的“产品输出口”，把函数计算好的结果送出来。

• lambda

  • 使用方法：lambda 参数: 表达式，创建一个匿名函数。例如：

add = lambda a, b: a + b 
result = add(1, 2) 

- 解释：`lambda` 就像一个“临时小工厂”，简单快速地创建一个函数，而且不需要给它起名字。 

类与对象

• class

  • 使用方法：

class 类名: 
    def __init__(self, 参数): 
        self.属性 = 参数 
    def 方法名(self): 
        代码块 

例如：

class Person: 
    def __init__(self, name): 
        self.name = name 
    def say_hello(self): 
        print(f"你好，我是 {self.name}") 
 
p = Person("张三") 
p.say_hello() 

- 解释：`class` 就像一个“蓝图”，它定义了一类对象的属性和方法，根据这个蓝图可以创建出具体的对象。 

• del

  • 使用方法：del 对象引用，删除对象的引用。例如：

p = Person("张三") 
del p 

- 解释：`del` 就像一个“清洁工”，把对象的引用删除，让这个对象可以被计算机回收。 

模块导入

• import

  • 使用方法：import 模块名，导入整个模块。例如：

import math 
result = math.sqrt(4) 

- 解释：`import` 就像把一个“工具包”拿过来，你可以使用这个工具包里的所有工具（函数、类等）。 

• from

  • 使用方法：from 模块名 import 特定部分，从模块里导入特定的部分。例如：

from math import sqrt 
result = sqrt(4) 

- 解释：`from` 就像从工具包里只拿出你需要的某一个工具，而不是把整个工具包都拿过来。 

• as

  • 使用方法：import 模块名 as 别名 或者 from 模块名 import 特定部分 as 别名，为导入的模块或对象创建别名。例如：

import math as m 
result = m.sqrt(4) 

- 解释：`as` 就像给导入的模块或对象起了个“外号”，方便你在代码里使用。 

作用域

• global

  • 使用方法：在函数内部使用 global 变量名，声明这个变量是全局变量。例如：

x = 10 
def change_x(): 
    global x 
    x = 20 
 
change_x() 
print(x)  # 输出 20 

- 解释：`global` 就像一个“通行证”，让函数内部可以修改全局变量的值。 

• nonlocal

  • 使用方法：在嵌套函数内部使用 nonlocal 变量名，声明这个变量是上一层函数的局部变量。例如：

def outer(): 
    x = 10 
    def inner(): 
        nonlocal x 
        x = 20 
    inner() 
    print(x)  # 输出 20 
 
outer() 

- 解释：`nonlocal` 就像一个“跨层钥匙”，让嵌套函数内部可以修改上一层函数的局部变量的值。 

异步编程

• async

  • 使用方法：async def 异步函数名(参数):，声明一个异步函数。例如：

async def async_function(): 
    print("异步函数开始") 
    await asyncio.sleep(1) 
    print("异步函数结束") 

- 解释：`async` 就像给函数贴上一个“异步标签”，告诉计算机这个函数是异步的，可以和其他任务同时进行。 

• await

  • 使用方法：在异步函数内部使用 await 异步操作，等待异步操作完成。例如上面的 await asyncio.sleep(1)。
  • 解释：await 就像一个“等待信号”，让异步函数暂停执行，直到等待的异步操作完成。

其他

• assert

  • 使用方法：assert 条件, "错误信息"，用于测试条件是否为真。如果条件为 False，就会抛出 AssertionError 异常，并显示错误信息。例如：

x = 5 
assert x > 10, "x 应该大于 10" 

- 解释：`assert` 就像一个“检查官”，检查条件是否符合要求，如果不符合就发出警报。 

• in

  • 使用方法：元素 in 可迭代对象，检查元素是否在可迭代对象里。例如：

result = 2 in [1, 2, 3] 

- 解释：`in` 就像一个“查找器”，看看某个元素是否在一个集合里。 

• is

  • 使用方法：对象1 is 对象2，检查两个对象是否是同一个对象。例如：

a = [1, 2, 3] 
b = a 
result = a is b 

- 解释：`is` 就像一个“身份验证器”，检查两个对象是否是同一个“人”。 

• pass

  • 使用方法：pass，空语句，用于占位。例如：

if 5 > 3: 
    pass 

- 解释：`pass` 就像一个“占位符”，当你暂时不知道要写什么代码时，用它占个位置。 

• with

  • 使用方法：

with 上下文管理器 as 变量: 
    代码块 

例如：

with open('file.txt', 'r') as file: 
    content = file.read() 

- 解释：`with` 就像一个“自动管理员”，它会自动管理资源的打开和关闭，确保资源使用完后会被正确释放。 

• yield

  • 使用方法：在生成器函数里使用 yield 返回值。例如：

def generator_function(): 
    yield 1 
    yield 2 
    yield 3 
 
gen = generator_function() 
for value in gen: 
    print(value) 

- 解释：`yield` 就像一个“暂停按钮”，它会暂停函数的执行并返回一个值，下次调用时会从暂停的地方继续执行。