Python 入门 / Python 基础

本文介绍阅读和编写 Python 脚本所需的核心语法。建议按章节顺序运行示例，并修改输入观察结果。

1. 变量与输出

1.1 变量赋值

Python 不需要提前声明变量类型，使用 = 即可为变量赋值：

message  = 'Hello, World!'
count    = 100
is_ready = True

变量名应清楚表达用途。普通变量通常采用小写字母和下划线组成的 snake_case 风格，常量通常使用大写字母：

user_name       = 'Tom'
MAX_RETRY_COUNT = 3

不要使用 str、list、dict、type 等内置名称作为变量名，否则同名内置对象会被覆盖。

1.2 使用 print() 输出

print() 用于将内容输出到终端：

message = 'Hello, World!'
print(message)

输出：

Hello, World!

print() 可以同时接收多个值，默认使用空格分隔：

name = 'Tom'
age  = 25
print('name:', name, 'age:', age)

输出：

name: Tom age: 25

1.3 查看类型和表示形式

type() 返回对象的类型，repr() 返回适合调试的字符串表示：

value = '100'
print(type(value))
print(repr(value))

输出：

<class 'str'>
'100'

repr() 保留了字符串两侧的引号，因此调试时可以区分字符串 "100" 和整数 100。

2. 基础数据类型

常见的基础值如下：

值的类型	说明	示例
NoneType	空值类型，只有一个值 None	result = None
int	整数	count = 100
float	浮点数	price = 19.9
str	字符串	message = "Hello"
bool	布尔值	is_ready = True

2.1 空值 None

None 表示“没有值”或“值尚不存在”。判断一个值是否为 None 时，使用 is 或 is not：

result = None

print(result is None)
print(result is not None)

输出：

True
False

is 判断两个名称是否指向同一个对象，== 判断两个对象的值是否相等。除 None 等单例对象外，通常使用 == 比较值。

2.2 整数 int 和浮点数 float

数字支持常见的算术和比较运算：

a = 5
b = 3

print('加法：', a + b)
print('减法：', a - b)
print('乘法：', a * b)
print('除法：', a / b)
print('整除：', a // b)
print('余数：', a % b)
print('幂：', a ** b)
print('保留两位小数：', round(a / b, 2))
print('相等：', a == b)
print('不相等：', a != b)
print('大于：', a > b)
print('小于等于：', a <= b)

输出：

加法： 8
减法： 2
乘法： 15
除法： 1.6666666666666667
整除： 1
余数： 2
幂： 125
保留两位小数： 1.67
相等： False
不相等： True
大于： True
小于等于： False

/ 始终执行普通除法并返回浮点数；// 执行向下取整除法。浮点数存在精度限制，金额等需要精确小数的场景应使用标准库 decimal，不要直接依赖二进制浮点数进行精确比较。

2.3 字符串 str

字符串可以使用单引号或双引号表示。三引号字符串可以跨越多行：

single_quoted = 'Hello'
double_quoted = "World"
multi_line    = """第一行
第二行"""

print(single_quoted + ', ' + double_quoted + '!')
print(multi_line)

输出：

Hello, World!
第一行
第二行

反斜杠 \ 用于转义引号、换行符等特殊字符：

print('It\'s Python.')
print('第一行\n第二行')

需要将变量写入字符串时，推荐使用格式化字符串 f-string：

name    = 'Tom'
score   = 92
message = f'{name} 的成绩是 {score} 分'
print(message)

输出：

Tom 的成绩是 92 分

f-string 的语法结构如下：

常见字符串操作包括：

text = '  Hello, Python!  '

print(text.strip())
print(text.strip().lower())
print('Python' in text)
print(text.replace('Python', 'DataFlux Func').strip())

输出：

Hello, Python!
hello, python!
True
Hello, DataFlux Func!

字符串是不可变对象，strip()、lower() 和 replace() 等方法会返回新字符串，不会修改原字符串。

2.4 布尔值 bool

布尔值只有 True 和 False，常与 and、or、not 一起构造条件：

is_enabled  = True
retry_count = 2

print(is_enabled and retry_count < 3)
print(is_enabled or retry_count == 0)
print(not is_enabled)

输出：

True
True
False

3. 容器类型

容器用于保存多个值：

类型	是否有序	是否可修改	是否允许重复元素	典型用途
list	是	是	是	保存一组按顺序处理的数据
tuple	是	否	是	保存不希望被修改的一组数据
dict	是，保留插入顺序	是	键不可重复	按键查找值，表示结构化数据
set	否	是	否	去重、成员判断和集合运算

3.1 列表 list

列表使用方括号表示，索引从 0 开始：

names = ['Tom', 'Jerry', 'Lucy']

print(names[0])
print(names[-1])
print(names[1:])

输出：

Tom
Lucy
['Jerry', 'Lucy']

切片写作 [开始索引:结束索引]，包含开始索引，不包含结束索引。开始或结束索引可以省略。

列表可以原地修改：

numbers = [3, 1, 2]

numbers.append(4)
numbers.extend([5, 6])
numbers[0] = 9
removed = numbers.pop()

print(numbers)
print('移除：', removed)
print('排序后的新列表：', sorted(numbers))
print('原列表：', numbers)

输出：

[9, 1, 2, 4, 5]
移除： 6
排序后的新列表： [1, 2, 4, 5, 9]
原列表： [9, 1, 2, 4, 5]

sorted() 返回新列表；list.sort() 会直接修改原列表，并返回 None。

3.2 元组 tuple

元组使用圆括号表示，创建后不能增加、删除或替换元素：

point = (120.1, 30.2)
print(point[0])

只有一个元素的元组必须保留结尾逗号，否则圆括号只表示普通分组：

one_item    = (1,)
not_a_tuple = (1)

print(type(one_item))
print(type(not_a_tuple))

输出：

<class 'tuple'>
<class 'int'>

3.3 字典 dict

字典以“键: 值”的形式保存数据。键必须唯一且可哈希，字符串是最常用的键类型：

user = {
    'name'      : 'Tom',
    'age'       : 25,
    'is_enabled': True,
}

print(user['name'])
print(user.get('email'))
print(user.get('email', '未填写'))

输出：

Tom
None
未填写

使用方括号读取不存在的键会抛出 KeyError；dict.get() 在键不存在时返回 None 或指定的默认值。

常见修改和遍历方式如下：

user = {'name': 'Tom', 'age': 25}

user['age'] = 26
user['city'] = 'Shanghai'
user.update({'is_enabled': True})

for key, value in user.items():
    print(f'{key}: {value}')

输出：

name: Tom
age: 26
city: Shanghai
is_enabled: True

从 Python 3.7 开始，字典保证保留键的插入顺序。

3.4 集合 set

集合保存不重复的可哈希元素，适合去重、成员判断以及交集、并集和差集运算：

left  = {1, 2, 3}
right = {3, 4, 5}

print(sorted(left & right))
print(sorted(left | right))
print(sorted(left - right))
print(2 in left)

输出：

[3]
[1, 2, 3, 4, 5]
[1, 2]
True

集合本身没有固定顺序，因此示例使用 sorted() 后再输出。创建空集合必须使用 set()，因为 {} 表示空字典。

3.5 嵌套数据

列表和字典可以相互嵌套，用于表示 JSON 风格的结构化数据：

users = [
    {
        'name'  : 'Tom',
        'roles' : ['developer', 'writer'],
        'active': True,
    },
    {
        'name'  : 'Jerry',
        'roles' : ['student'],
        'active': False,
    },
]

print(users[0]['roles'][1])

输出：

writer

4. 条件分支

Python 使用 if、elif 和 else 根据条件选择代码分支。冒号后的代码块必须缩进，通常使用 4 个空格：

score = 80

if score >= 90:
    level = '优'
elif score >= 75:
    level = '良'
elif score >= 60:
    level = '中'
else:
    level = '差'

print(level)

输出：

良

条件可以使用逻辑运算组合：

age        = 20
has_ticket = True

if age >= 18 and has_ticket:
    print('允许入场')

不要混用制表符和空格缩进，否则可能产生 IndentationError 或难以发现的层级错误。

5. 循环

5.1 for 循环

for 用于依次处理可迭代对象中的元素：

names = ['Tom', 'Jerry', 'Lucy']

for name in names:
    print(name)

需要固定次数时，可以使用 range()：

for index in range(3):
    print(index)

输出：

0
1
2

需要同时获得索引和值时，使用 enumerate()：

names = ['Tom', 'Jerry', 'Lucy']

for index, name in enumerate(names, start=1):
    print(f'{index}. {name}')

输出：

1. Tom
2. Jerry
3. Lucy

5.2 while 循环

while 在条件为真时反复执行代码：

count = 3

while count > 0:
    print(count)
    count -= 1

print('完成')

输出：

3
2
1
完成

使用 while 时必须确保循环条件最终会变为假，否则程序会陷入无限循环

5.3 continue 和 break

continue 跳过本次循环的剩余代码，break 立即结束整个循环：

for number in range(1, 20):
    if number % 2 != 0:
        continue

    if number > 10:
        break

    print(number)

输出：

2
4
6
8
10

6. 函数

函数将一段处理封装为可以重复调用的代码。使用 def 定义函数，使用 return 返回结果：

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

result = add(2, 3)
print(result)

输出：

5

6.1 参数和默认值

参数可以设置默认值。调用函数时既可以按位置传参，也可以按名称传参：

def greet(name, message='你好'):
    return f'{message}，{name}！'

print(greet('Tom'))
print(greet('Jerry', message='早上好'))

输出：

你好，Tom！
早上好，Jerry！

6.2 返回多个值

函数可以一次返回多个值。Python 实际会把这些值组成元组：

def check_score(score):
    if score >= 60:
        return True, '及格'
    return False, '不及格'

is_passed, message = check_score(80)
print(is_passed, message)

输出：

True 及格

没有显式执行 return 的函数默认返回 None。

7. 导入模块

7.1 普通 Python 模块

Python 使用 import 复用其他模块中的代码：

import math
from datetime import datetime

print(math.sqrt(16))
print(datetime.fromisoformat('2026-08-11T10:30:00'))

输出：

4.0
2026-08-11 10:30:00

自己的脚本也可以作为模块导入。假设同一目录中有 utils.py：

def greet(name):
    return f'Hello, {name}!'

在 main.py 中导入：

import utils

print(utils.greet('Tom'))

不要创建与标准库或第三方库同名的脚本，例如 json.py、requests.py，否则可能导入错误的文件。

7.2 DataFlux Func 中的脚本

DataFlux Func 的脚本保存在数据库中，不是文件系统中的普通 Python 模块。系统以“脚本集”和“脚本”两层结构管理代码；脚本集是脚本的集合，不等同于 Python 包或文件夹。

脚本 ID 格式为 {脚本集 ID}__{脚本名}，中间包含两个下划线：

假设存在如下脚本集和脚本：

在 DataFlux Func 中导入脚本时使用以下形式：

场景	导入方式
同一脚本集	import __{脚本名} 或 from __{脚本名} import {对象名}
任意脚本集	import {脚本集 ID}__{脚本名} 或 from {脚本集 ID}__{脚本名} import {对象名}

同一脚本集内推荐使用双下划线开头的简写。克隆脚本集并更改脚本集 ID 后，内部引用仍然有效：

import __utils as utils
from __formatters import format_message

被导入脚本使用的是已发布版本，而不是正在编辑的草稿版本。还应避免脚本之间产生循环引用。详细规则请参考 脚本开发 / 代码规划编排。

8. 注释与可读性

# 后的内容是单行注释：

MAX_NUMBER = 100

# 查找 100 以内第一个同时被 2、3、5 整除的正整数
for number in range(1, MAX_NUMBER):
    if number % 2 == 0 and number % 3 == 0 and number % 5 == 0:
        print(number)
        break

注释应说明代码为什么这样处理，不必逐字复述代码做了什么。变量名、函数名和清晰的代码结构通常比大量注释更容易维护。

9. 类与对象

类用于将相关的数据和行为组织在一起。以下示例定义一个基础用户类，并由教师和学生继承：

class User:
    def __init__(self, name, card_number):
        self.name        = name
        self.card_number = card_number

    def show_card(self):
        print(f'{self.name} 的门禁卡号为：{self.card_number}')

    def do_activity(self):
        e = NotImplementedError('子类必须实现 do_activity()')
        raise e


class Teacher(User):
    def do_activity(self):
        print(f'{self.name} 老师开始上课')


class Student(User):
    def do_activity(self):
        print(f'{self.name} 同学开始学习')


users = [
    Teacher(name='张华', card_number='T-001'),
    Student(name='李明', card_number='S-088'),
]

for user in users:
    user.show_card()
    user.do_activity()

输出：

张华 的门禁卡号为：T-001
张华 老师开始上课
李明 的门禁卡号为：S-088
李明 同学开始学习

__init__() 在创建对象时初始化实例属性，self 表示当前对象。子类继承父类的方法，也可以通过定义同名方法覆盖父类行为。

在 DataFlux Func 中，简单函数通常更方便单独调试。只有当一组数据和行为确实需要共同维护时，再使用类进行组织。

10. 异常处理

代码无法继续正常执行时，Python 会抛出异常：

result = 100 / 0

最后一行错误信息为：

ZeroDivisionError: division by zero

10.1 捕获可处理的异常

使用 try...except 捕获已经预见且能够处理的异常。应尽量捕获具体异常类型，并缩小 try 代码块范围：

text = 'not-a-number'

try:
    number = int(text)
except ValueError as e:
    print(f'无法转换为整数：{e}')
else:
    print(number)

输出：

无法转换为整数：invalid literal for int() with base 10: 'not-a-number'

不要使用空的 except 或随意捕获 Exception 后忽略错误，这会隐藏真正的程序缺陷。

10.2 主动抛出异常

输入不符合函数要求时，可以创建并抛出合适的异常：

def divide(a, b):
    if b == 0:
        e = ValueError('b 不能为 0')
        raise e
    return a / b


try:
    result = divide(100, 0)
except ValueError as e:
    print(e)

输出：

b 不能为 0

异常表示调用未能正常完成。只有在能够提供合理替代结果、重试或补充上下文时才捕获异常；否则应让异常继续向上抛出。

11. 下一步

掌握本篇内容后，继续阅读 Python 入门 / Python 基础补充，学习更灵活的函数参数、推导式和常用内置函数。