- 你好世界
- 注释
- 空格和换行
- 标识符
- 变量赋值
- 变量删除
- 变量范围声明
- 空值字面量
- 布尔值字面量
- 数字字面量
- 字符串字面量
- 列表字面量
- 元组字面量
- 字典字面量
- 集合字面量
- 算术操作符
- 比特操作符
- 比较操作符
- 逻辑操作符
- 属性访问
- 索引访问
- 列表推导式
- 括号表达式
- 嘞语法糖
- 空语句
- 条件语句
- 循环语句
- 异常处理
- 上下文管理
- 生成器和协程
- 函数
- 类
- 装饰器
- 引入语句
- 断言语句
- 退出语句
- 语句分隔符
- 操作符优先级
- 关键字
开腔（‘你好，世界’）
＃ 这是单行注释
『
这是
多行
注释
』
『『
中间有』
就在两边
多加点
』』
开腔（‘你好，世界’）
和
开腔（
‘你好，世界’
）
语义一样。
但标识符和关键字的每个字之间不能有空格和换行，例如：
开腔和开 腔语义不一样。
Python 3能支持的标识符就能使用，包括中文。
标识符内不能包含四川话的关键字，除非用《》括起来。例如开腔是一个关键字，那么
你开腔噻不会被识别成一个标识符，而是你（标识符）、开腔（关键字）、噻（标识符）。
但《你开腔噻》就会被识别为一个标识符。
标识符不能以中文数字开头，除非用《》括起来。例如二叉树会被识别成二（数字）、叉树
（标识符）。但《二叉树》就会被识别为一个标识符。
＃ 甲 = 1
甲搁1
＃ del 甲
丢翻甲
＃ global 甲
甲在外头
＃ nonlocal 甲
甲在上头
＃ 甲 = None
甲搁虚嘞
＃ 甲 = True
甲搁真嘞
＃ 甲 = False
甲搁假嘞
Python支持的数字字面量可以使用，例如：
＃ 甲 = 1
甲搁1
＃ 甲 = 1.23
甲搁1.23
＃ 甲 = 1e23
甲搁1e23
＃ 甲 = 1_0000_0000
甲搁1_0000_0000
＃ 甲 = 0b10101010
甲搁0b10101010
＃ 甲 = 0o252
甲搁0o252
＃ 甲 = 0xAA
甲搁0xAA
也支持中文数字，例如：
＃ 甲 = 1000234567809
甲搁一兆二亿三千四百五十六万七千八百零九
甲搁壹兆贰億叁仟肆佰伍拾陆萬柒仟捌佰〇玖
字符串常量用一到多个中文单引号或双引号括起来。 单引号内的内容不支持转义字符。 双引号内的内容支持转义字符。 内容可以包含多行。 例如：
＃ 甲 = r'第一行\n第二行'
甲搁‘第一行\n第二行’
＃ 甲 = '第一行\n第二行'
甲搁“第一行\n第二行”
甲搁‘第一行
第二行’
甲搁“第一行
第二行”
＃ 甲 = '内容中间有引号‘’可以增加两边引号的数量'
甲搁‘‘内容中间有引号‘’可以增加两边引号的数量’’
＃ 甲 = '内容中间有引号“”可以增加两边引号的数量'
甲搁““内容中间有引号“”可以增加两边引号的数量””
＃ 甲 = '“内容两边有引号可以用\转义”'
甲搁“\“内容两边有引号可以用\转义\””
＃ 甲 = []
甲搁箱箱
＃ 甲 = [1, 2, 3]
甲搁箱箱装（一，二，三）
＃ 甲 = ()
甲搁包包
＃ 甲 = (1, 2, 3)
甲搁包包装（一，二，三）
甲搁（一，二，三）
＃ 甲 = {}
甲搁盒盒
＃ 甲 = {'a': 1, 'b': 2}
甲搁盒盒装（（‘a’，一），（‘b’，二））
＃ 甲 = set()
甲搁袋袋
＃ 甲 = {1, 2, 3}
甲搁袋袋装（一，二，三）
＃ 甲 + 乙
甲加乙
＃ 甲 += 乙
甲加搁乙
＃ 甲 += 1
甲加滴点儿
＃ 甲 - 乙
甲减乙
＃ 甲 -= 乙
甲减搁乙
＃ 甲 -= 1
甲减滴点儿
＃ -甲
负甲
＃ 甲 * 乙
甲乘乙
＃ 甲 *= 乙
甲乘搁乙
＃ 甲 / 乙
甲除乙
＃ 甲 /= 乙
甲除搁乙
＃ 甲 // 乙
甲整除乙
＃ 甲 //= 乙
甲整除搁乙
＃ 甲 % 乙
甲算余数乙
＃ 甲 %= 乙
甲算余数搁乙
＃ 甲 ** 乙
甲算指数乙
＃ 甲 **= 乙
甲算指数搁乙
＃ ~甲
比特反转甲
＃ 甲 = ~甲
比特反转搁甲
＃ 甲 & 乙
甲比特与乙
＃ 甲 &= 乙
甲比特与搁乙
＃ 甲 | 乙
甲比特或乙
＃ 甲 |= 乙
甲比特或搁乙
＃ 甲 ^ 乙
甲比特异或乙
＃ 甲 ^| 乙
甲比特异或搁乙
＃ 甲 << 乙
甲比特左移乙
＃ 甲 <<= 乙
甲比特左移搁乙
＃ 甲 >> 乙
甲比特右移乙
＃ 甲 >>= 乙
甲比特右移搁乙
＃ 甲 is 乙
甲就是乙
＃ 甲 is not 乙
甲不是乙
＃ 甲 == 乙
甲等于乙
＃ 甲 != 乙
甲不等于乙
＃ 甲 < 乙
甲小于乙
＃ 甲 <= 乙
甲小于等于乙
＃ 甲 > 乙
甲大于乙
＃ 甲 >= 乙
甲大于等于乙
＃ 甲 in 乙
甲存在于乙
＃ 甲 not in 乙
甲不存在于乙
＃ 甲 and 乙
甲并且乙
＃ 甲 or 乙
甲或者乙
＃ not 甲
并非甲
＃ 乙 if 甲 else 丙
甲？乙：丙
＃ 甲.乙.丙
甲咧乙咧丙
＃ 甲[乙]
甲第乙项
＃ 甲[乙][丙]
甲第乙项第丙项
＃ [甲 + 10 for 甲 in [1, 2, 3]]
箱箱装（一，二，三）每项交给甲生成甲加十
＃ [甲 + 10 for 甲 in [1, 2, 3] if 甲 > 1]
箱箱装（一，二，三）每项交给甲要是甲大于一生成甲加十
＃ [甲 + 乙 for 甲 in [1, 2, 3] for 乙 in [4, 5, 6]]
箱箱装（一，二，三）每项交给甲然后箱箱装（四，五，六）每项交给乙生成甲加乙
＃ [甲 + 10 async for 甲 in [1, 2, 3]]
箱箱装（一，二，三）每项慢慢交给甲生成甲加十
＃ (甲 + 10 for 甲 in [1, 2, 3])
箱箱装（一，二，三）每项交给甲慢慢生成甲加十
＃ (1 + 2) * (3 / 4)
（一加二）乘（三除四）
括号内有逗号会被识别成元组，例如：
＃ (1,)
（一，）
＃ (1, 2)
（一，二）
＃ type(甲)
甲嘞名堂
＃ bool(甲)
甲嘞真假
＃ int(甲)
甲嘞整数
＃ float(甲)
甲嘞浮点数
＃ str(甲)
甲嘞字符串
＃ repr(甲)
甲嘞表示
＃ bytes(甲)
甲嘞字节串
＃ bytearray(甲)
甲嘞字节数组
＃ chr(甲)
甲嘞字符
＃ ord(甲)
甲嘞字符序数
＃ hex(甲)
甲嘞十六进制
＃ oct(甲)
甲嘞八进制
＃ bin(甲)
甲嘞二进制
＃ list(甲)
甲嘞箱箱
＃ tuple(甲)
甲嘞包包
＃ dict(甲)
甲嘞盒盒
＃ set(甲)
甲嘞袋袋
＃ len(甲)
甲嘞长度
甲嘞总数
＃ abs(甲)
甲嘞绝对值
＃ min(甲)
甲嘞最小值
＃ max(甲)
甲嘞最大值
＃ -甲
甲嘞相反数
＃ 1/甲
甲嘞倒数
＃ sum(甲)
甲嘞和
＃ any(甲)
甲嘞任意为真
＃ all(甲)
甲嘞全部为真
＃ range(甲)
甲嘞范围内
＃ range(甲, 乙)
（甲，乙）嘞范围内
＃ range(甲, 乙, 丙)
（甲，乙，丙）嘞范围内
＃ 甲.__name__
甲嘞名字
＃ 甲.format
甲嘞格式化
＃ 甲.add
甲嘞添加
＃ 甲.append
甲嘞后加
＃ 甲.extend
甲嘞后加每项
＃ 甲.clear
甲嘞清空
＃ 甲.sort
甲嘞排序
这些语法糖只作用于最近的原子表达式，若要作用于更大的表达式，请加括号，例如：
＃ 甲 + str(乙)
甲加乙嘞字符串
＃ str(甲 + 乙)
（甲加乙）嘞字符串
＃ pass
搞空名堂
＃ if 甲:
＃ pass
＃ elif 乙
＃ pass
＃ else:
＃ pass
如果甲弄个整
搞空名堂
又如果乙弄个整
搞空名堂
要不然
搞空名堂
就弄个
弄个整在条件表达式与后续语句相连不会产生歧义时可省略，例如：
如果甲
搞空名堂
又如果乙
搞空名堂
要不然
搞空名堂
就弄个
＃ while True:
＃ pass
莽起整
搞空名堂
就弄个
＃ while 甲:
＃ pass
莽起整要是甲
搞空名堂
就弄个
＃ while not 甲:
＃ pass
莽起整直到甲
搞空名堂
就弄个
＃ while 甲:
＃ if 乙:
＃ continue
莽起整要是甲
如果乙
接倒整
就弄个
就弄个
＃ while 甲:
＃ if 乙:
＃ break
莽起整要是甲
如果乙
不整了
就弄个
就弄个
＃ while 甲:
＃ pass
＃ else:
＃ pass
莽起整要是甲
搞空名堂
要不然
搞空名堂
就弄个
＃ for 甲 in [1, 2, 3]:
＃ pass
挨倒把箱箱装（一，二，三）每项给甲弄个整
搞空名堂
就弄个
＃ for 甲 in [1, 2, 3]:
＃ pass
＃ else:
＃ pass
挨倒把箱箱装（一，二，三）每项给甲弄个整
搞空名堂
要不然
搞空名堂
就弄个
＃ async for 甲 in [1, 2, 3]:
＃ pass
挨倒慢慢把箱箱装（一，二，三）每项给甲弄个整
搞空名堂
就弄个
＃ try:
＃ pass
＃ except Exception as 甲:
＃ pass
＃ else:
＃ pass
＃ finally:
＃ pass
试一哈
搞空名堂
抓一哈Exception叫做甲
搞空名堂
要不然
搞空名堂
最后才
搞空名堂
就弄个
＃ raise
放飞
＃ raise Exception()
放飞Exception（）
＃ raise Exception() from 甲
放飞Exception（）带起甲
＃ with 甲:
＃ pass
用一哈甲弄个整
搞空名堂
就弄个
＃ with 甲 as 乙:
＃ pass
用一哈甲叫做乙弄个整
搞空名堂
就弄个
＃ with 甲 as 乙, 丙 as 丁:
＃ pass
用一哈甲叫做乙、丙叫做丁弄个整
搞空名堂
就弄个
＃ async with 甲:
＃ pass
慢慢用一哈甲弄个整
搞空名堂
就弄个
＃ yield 甲
让一哈甲
＃ yield from 甲
让一哈哈儿甲
＃ await 甲
等一哈甲
＃ def 求和(甲, 乙=1):
＃ return 甲 + 乙
过场 求和（甲，乙搁一）
爬开甲加乙
过场多
＃ 求和(1, 2)
求和（一，二）
＃ 求和(1, 乙=2)
求和（一，乙搁二）
＃ 求和(4, 求和(求和(1, 2), 3))
求和（一，二）接倒起求和（…，三）接倒起求和（四，…）
＃ def 收变长参数(*变长列表, **变长字典):
＃ pass
过场 收变长参数（收拢变长列表，收拢来变长字典）
搞空名堂
过场多
＃ 收变长参数(甲, 乙, 丙=丁)
收变长参数（甲, 乙, 丙搁丁）
＃ 收变长参数(*[甲，乙], **{丙: 丁})
收变长参数（展开箱箱装（甲，乙），展开来盒盒装（（丙，丁）））
＃ async def 等噻(甲):
＃ await 甲
过场慢 等噻（甲）
等一哈甲
过场多
＃ class 甲(object, metaclass=type):
＃ def __init__(自己, 值):
＃ 自己.值 = 值
名堂 甲（object，metaclass搁type）
过场 __init__（自己，值）
自己咧值搁值
过场多
名堂多
＃ def 装饰器(旧函数):
＃ def 新函数():
＃ print('调用前')
＃ 旧函数()
＃ print('调用后')
＃ return 新函数
过场 装饰器（旧函数）
过场 新函数（）
开腔（‘调用前’）
旧函数（）
开腔（‘调用后’）
过场多
爬开新函数
过场多
＃ @装饰器
＃ @装饰器
＃ def 搞噻():
＃ pass
装饰器打整一哈
装饰器打整一哈
过场 搞噻（）
搞空名堂
过场多
＃ import os
os来给我扎起
＃ import os.path
os咧path来给我扎起
＃ import os.path as os_path
os咧path来给我扎起叫做os_path
＃ from os.path import abspath
os咧path咧abspath出来给我扎起
＃ from . import util
屋头咧util出来给我扎起
＃ from .. import util
屋头咧屋头咧util出来给我扎起
＃ assert 甲 > 0
硬是要甲大于零
＃ assert 甲 > 0, '甲必须大于0'
硬是要甲大于零，‘甲必须大于零’
＃ sys.exit()
哦嚯
＃ sys.exit(1)
哦嚯（1）
语句结尾可额外加分号；或句号。，例如：
搞空名堂；搞空名堂。
优先级由高到低：
（）（括号表达式）负，比特反转咧，嘞，第某项，打整一哈算指数（右结合）乘，除，整除，算余数加，减比特与，比特或，比特异或，比特左移，比特右移接倒起就是，不是，等于，不等于，小于，小于等于，大于，大于等于，存在于，不存在于并非并且或者每项交给，每项慢慢交给甲？乙：丙（条件表达式）甲，乙（元组表达式）搁，加滴点儿，减滴点儿，加搁，减搁，乘搁，除搁，整除搁，算余数搁，算指数搁，
比特与搁，比特或搁，比特异或搁，比特左移搁，比特右移搁，比特反转搁，
来给我扎起，出来给我扎起
标识符请勿包含以下关键字：
虚嘞，真嘞，假嘞箱箱，箱箱装，包包，包包装，盒盒，盒盒装，袋袋，袋袋装在外头，在上头负，比特反转咧，嘞，第，项，打整一哈算指数乘，除，整除，算余数加，减比特与，比特或，比特异或，比特左移，比特右移接倒起就是，不是，等于，不等于，小于，小于等于，大于，大于等于，存在于，不存在于并非并且或者每项交给，每项慢慢交给搁，加滴点儿，减滴点儿，加搁，减搁，乘搁，除搁，整除搁，算余数搁，算指数搁，
比特与搁，比特或搁，比特异或搁，比特左移搁，比特右移搁，比特反转搁，要是，然后，生成，慢慢生成如果，又如果，要不然，弄个整，就弄个莽起整，莽起整要是，莽起整直到，挨倒把，挨倒慢慢把，每项给，接倒整，不整了试一哈，抓一哈，最后才，放飞，带起用一哈，慢慢用一哈让一哈，让一哈哈儿，等一哈过场，过场慢，过场多，收拢，收拢来，展开，展开来名堂，名堂多来给我扎起，出来给我扎起，叫做搞空名堂，丢翻，爬开，硬是要，开腔，哦嚯