Python丨课程笔记Part1：Python基础入门部分

TheSumSt2025-12-30 9:38

Part 1 Python基础入门部分

1. 基础

IPO模型

计算机系统的基本工作原理可以用IPO模型来表示，即输入（Input）、处理（Process）和输出（Output）。

Python程序运行方式：

  • Interactive Mode（交互模式）
  • Script Mode（脚本模式）

2. Python快速入门

2.1. 对象基础与变量

总之Python也是一门面向对象（OOP）的编程语言。

所有数据都是对象

Object三要素：

  • id
    对象在内存中的地址
    判断：a is b判断两个变量是否指向同一地址
  • type
    决定对象的属性和方法
    判断：type(a)查看对象类型
  • value
    包含的数据内容

变量 ：变量是对象的引用，是指向对象的标签。

变量赋值：a = 10，将整数对象10的引用赋值给变量a。

python 复制代码 
"""
示例：演示 Python 中 `is` 与 `==` 的区别，以及 id()、可变/不可变对象的行为

包含演示：
- 小整数缓存（-5 到 256）导致相同小整数字面量可能共用同一对象
- 如何通过构造新对象避免编译期/常量合并优化（例如使用 int()）
- 字符串驻留（intern）与 sys.intern 的用法
- 列表（可变对象）引用与 == 对比 is
- 使用 id() 查看对象地址并展示可变对象被修改时的影响

运行：
	python a_is_b.py

作者：自动生成示例（中文注释）
"""

import sys


def int_demo():
	print('--- 整数示例（int）---')
	a = 256
	b = 256
	print('a = 256; b = 256 -> a is b:', a is b)

	# 对于较大的整数，直接写字面量有时会被编译器/解释器优化成同一对象，
	# 为确保创建不同对象可以通过运行时构造：
	x = 257
	y = int('257')
	print("x = 257; y = int('257') -> x is y:", x is y)
	print('x == y ->', x == y)
	print('id(x) =', id(x))
	print('id(y) =', id(y))
	print()


def string_demo():
	print('--- 字符串示例（str）---')
	s1 = 'hello'
	s2 = 'hello'
	print("s1 = 'hello'; s2 = 'hello' -> s1 is s2:", s1 is s2)

	# 强制创建新字符串对象（拼接或用 str()）:
	s3 = ''.join(['he', 'llo'])
	print("s3 = ''.join(['he','llo']) -> s3 is s1:", s3 is s1)
	print('s3 == s1 ->', s3 == s1)

	# 使用 sys.intern 可以确保字符串被驻留（intern）以节省内存并允许 is 比较：
	s4 = sys.intern('this_is_interned')
	s5 = sys.intern('this_is_interned')
	print('使用 sys.intern -> s4 is s5:', s4 is s5)
	print()


def list_demo():
	print('--- 列表示例（可变对象）---')
	l1 = [1, 2, 3]
	l2 = l1  # l2 引用与 l1 同一对象
	l3 = [1, 2, 3]  # 内容相同，但不同对象

	print('l1 is l2 ->', l1 is l2)
	print('l1 is l3 ->', l1 is l3)
	print('l1 == l3 ->', l1 == l3)
	print('id(l1) =', id(l1))
	print('id(l3) =', id(l3))

	# 修改 l2，会同时影响 l1，因为它们是同一对象
	l2.append(4)
	print('在 l2 上 append(4) 后: l1 =', l1)
	print()


def main():
	int_demo()
	string_demo()
	list_demo()


if __name__ == '__main__':
	main()
python 复制代码 
"""
示例：演示 Python 中变量作为对象引用的概念

包含演示：
- 变量赋值：变量是对象的引用（标签）
- 使用 id() 查看对象地址
- 使用 type() 查看对象类型
- 不可变对象（如 int）的赋值行为：修改变量不影响其他引用同一对象的变量
- 可变对象（如 list）的赋值行为：修改对象会影响所有引用该对象的变量

运行：
    python variable_demo.py

作者：自动生成示例（中文注释）
"""


def immutable_demo():
    print('--- 不可变对象示例（int）---')
    a = 10
    print('a = 10')
    print('id(a) =', id(a))
    print('type(a) =', type(a))
    print('a =', a)

    # b 引用与 a 同一对象
    b = a
    print('b = a  # b 引用与 a 同一对象')
    print('id(b) =', id(b))
    print('b is a ->', b is a)

    # 修改 a
    a = 15
    print('a = 15  # 重新赋值给新对象')
    print('id(a) =', id(a))
    print('b is a ->', b is a)
    print('a =', a, '; b =', b)

    # 修改 b（重新赋值给新对象），a 不受影响
    b = 20
    print('b = 20  # 重新赋值给新对象')
    print('id(b) =', id(b))
    print('b is a ->', b is a)
    print('a =', a, '; b =', b)
    print()


def mutable_demo():
    print('--- 可变对象示例（list）---')
    l1 = [1, 2, 3]
    print('l1 = [1, 2, 3]')
    print('id(l1) =', id(l1))
    print('type(l1) =', type(l1))
    print('l1 =', l1)

    # l2 引用与 l1 同一对象
    l2 = l1
    print('l2 = l1  # l2 引用与 l1 同一对象')
    print('id(l2) =', id(l2))
    print('l2 is l1 ->', l2 is l1)

    # 修改 l2（修改对象内容），l1 受影响
    l2.append(4)
    print('l2.append(4)  # 修改对象内容')
    print('l1 =', l1, '; l2 =', l2)
    print('id(l1) =', id(l1), '; id(l2) =', id(l2))

    # 现在修改 l1，l2 也会受影响，因为它们引用同一对象
    l1.append(5)
    print('l1.append(5)  # 再次修改对象内容')
    print('l1 =', l1, '; l2 =', l2)
    print('id(l1) =', id(l1), '; id(l2) =', id(l2))

    # 现在让 l2 指向一个新对象（复制 l1 的内容，但创建新对象）
    l2 = l1.copy()
    print('l2 = l1.copy()  # l2 现在指向新对象')
    print('l2 is l1 ->', l2 is l1)
    print('l1 =', l1, '; l2 =', l2)
    print('id(l1) =', id(l1), '; id(l2) =', id(l2))

    # 现在修改 l1，l2 不受影响
    l1.append(6)
    print('l1.append(6)  # 修改 l1，l2 不受影响')
    print('l1 =', l1, '; l2 =', l2)
    print('id(l1) =', id(l1), '; id(l2) =', id(l2))
    print()

def main():
    immutable_demo()
    mutable_demo()


if __name__ == '__main__':
    main()

命名规则：

  • 变量名只能包含字母、数字和下划线，且不能以数字开头。

  • 变量名区分大小写。

  • 不能使用Python的关键字作为变量名。

    如何查看关键字？ 使用import keyword模块，然后调用keyword.kwlist查看关键字列表。

  • 变量名应具有描述性，避免使用单个字符作为变量名。

  • 避免使用Python内置函数名作为变量名。

  • 使用下划线分隔多个单词以提高可读性（如my_variable）。

  • 遵循命名约定，如使用小写字母和下划线（snake_case）来命名变量。

  • 保持变量名简洁但有意义，避免过长或过短。

  • 在不同作用域中使用不同的变量名，避免命名冲突。

python 复制代码 
import keyword
print(keyword.kwlist)
"""作者：自动生成示例（中文注释）
['False', 'None', 'True', 'and', 'as', 'assert', 'async',
'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 
'else', 'except', 'finally', 'for', 'from', 'global', 'if',
'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or',
'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
"""

2.2. 基本数据类型

重点的4种：

  • 整数（int）
    无长度限制
    除十进制外，支持二进制（0b）、八进制（0o）和十六进制（0x）表示法。
  • 浮点数（float）
    实数
    计算机内部使用二进制表示，因此运算存在精度误差
    比较浮点数，通常使用容差法
  • 布尔值（bool）
    只有True和False两个值
    可以与整数互相转换，True转换为1，False转换为0
  • 字符串（str）
    使用单引号、双引号、三引号表示字符串
    支持转义字符和原始字符串（r''）

类型转换：

显式转换（使用内置函数如int()、float()、str()等进行转换）

隐式转换（Python自动进行类型转换，如整数和浮点数混合运算时，整数会自动转换为浮点数）

python 复制代码 
"""
示例：演示 Python 中基本数据类型的特性

包含演示：
- 整数（int）：无长度限制、二进制（0b）、八进制（0o）、十六进制（0x）
- 浮点数（float）：精度误差、容差比较
- 布尔值（bool）：True/False 与整数转换
- 字符串（str）：单引号、双引号、三引号、转义字符、原始字符串（r''）
- 类型转换：显式转换（int()、float()、str()）、隐式转换（混合运算）

运行：
    python data_types_demo.py

作者：自动生成示例（中文注释）
"""


def int_demo():
    print('--- 整数（int）示例 ---')
    # 无长度限制
    big_int = 123456789012345678901234567890
    print('大整数：', big_int)

    # 不同进制表示
    decimal = 42
    binary = 0b101010  # 二进制
    octal = 0o52       # 八进制
    hexadecimal = 0x2A # 十六进制
    print('十进制：', decimal)
    print('二进制 0b101010：', binary)
    print('八进制 0o52：', octal)
    print('十六进制 0x2A：', hexadecimal)
    print('它们都相等：', decimal == binary == octal == hexadecimal)
    print()


def float_demo():
    print('--- 浮点数（float）示例 ---')
    # 精度误差
    a = 0.1 + 0.2
    print('0.1 + 0.2 =', a)  # 可能不是 0.3
    print('a == 0.3 ->', a == 0.3)

    # 使用容差比较
    tolerance = 1e-9
    print('使用容差比较：abs(a - 0.3) < 1e-9 ->', abs(a - 0.3) < tolerance)
    print()


def bool_demo():
    print('--- 布尔值（bool）示例 ---')
    true_val = True
    false_val = False
    print('True =', true_val, '; False =', false_val)

    # 与整数转换
    print('int(True) =', int(true_val))
    print('int(False) =', int(false_val))
    print('bool(1) =', bool(1))
    print('bool(0) =', bool(0))
    print('bool(5) =', bool(5))  # 非零为 True
    print()


def str_demo():
    print('--- 字符串（str）示例 ---')
    # 不同引号
    single = '单引号字符串'
    double = "双引号字符串"
    triple = '''三引号字符串
可以换行'''
    print('单引号：', single)
    print('双引号：', double)
    print('三引号：', triple)

    # 转义字符
    escaped = '使用\\n换行\\t制表'
    print('转义字符：', escaped)

    # 原始字符串
    raw = r'原始字符串：\n 不转义'
    print('原始字符串：', raw)
    print()


def conversion_demo():
    print('--- 类型转换示例 ---')
    # 显式转换
    num_str = '123'
    print('str 到 int：int("123") =', int(num_str))
    print('str 到 float：float("123.45") =', float('123.45'))
    print('int 到 str：str(456) =', str(456))

    # 隐式转换
    int_val = 5
    float_val = 2.5
    result = int_val + float_val  # int 自动转换为 float
    print('隐式转换：5 (int) + 2.5 (float) =', result, '; 类型：', type(result))
    print()


def main():
    int_demo()
    float_demo()
    bool_demo()
    str_demo()
    conversion_demo()


if __name__ == '__main__':
    main()

2.3. 运算符与表达式

运算符

  • 算术运算符：+、-、*、/、//（取整除）、%（取余）、**（幂运算）
  • 比较运算符：==、!=、>、<、>=、<=
  • 逻辑运算符：and、or、not
  • 赋值运算符：=、+=、-=、*=、/=等
  • 位运算符：&（按位与）、|（按位或）、^（按位异或）、~（按位取反）、<<（左移）、>>（右移）
  • 成员运算符：in、not in
  • 身份运算符：is、is not
  • 其他运算符：lambda（匿名函数）、if-else表达式等

运算符的优先级

运算符的优先级决定了表达式中各个运算符的计算顺序。

  1. 括号 ()
  2. 指数运算 **
  3. 正负号 +x、-x
  4. 乘法、除法、取整除、取余 *、/、//、%
  5. 加法、减法 +、-
  6. 位运算 &、|、^、~、<<、>>
  7. 比较运算 ==、!=、>、<、>=、<=
  8. 身份运算 is、is not
  9. 成员运算 in、not in
  10. 逻辑运算 not、and、or
  11. 赋值运算 =、+=、-=、*=、/=等
  12. 条件表达式 if-else
  13. Lambda表达式 lambda
  14. 逗号 ,

简单概括常用运算符的优先级：

括号最高，指数次之，乘除高于加减，比较运算低于算术运算，逻辑运算最低。

短路求值：

逻辑运算符and和or采用短路求值策略，即在确定结果后不再计算剩余表达式。

python 复制代码 
"""
示例：演示 Python 中运算符的使用

包含演示：
- 算术运算符：+ - * / // % **
- 比较运算符：== != > < >= <=
- 逻辑运算符：and or not，短路求值
- 赋值运算符：= += -= *= /=
- 位运算符：& | ^ ~ << >>
- 成员运算符：in not in
- 身份运算符：is is not
- 其他运算符：lambda、if-else表达式
- 运算符优先级示例

运行：
    python operators_demo.py

作者：自动生成示例（中文注释）
"""


def arithmetic_demo():
    print('--- 算术运算符示例 ---')
    a = 10
    b = 3
    print('a =', a, '; b =', b)
    print('a + b =', a + b)  # 加法
    print('a - b =', a - b)  # 减法
    print('a * b =', a * b)  # 乘法
    print('a / b =', a / b)  # 除法
    print('a // b =', a // b)  # 取整除
    print('a % b =', a % b)  # 取余
    print('a ** b =', a ** b)  # 幂运算
    print()


def comparison_demo():
    print('--- 比较运算符示例 ---')
    x = 5
    y = 10
    print('x =', x, '; y =', y)
    print('x == y ->', x == y)
    print('x != y ->', x != y)
    print('x > y ->', x > y)
    print('x < y ->', x < y)
    print('x >= y ->', x >= y)
    print('x <= y ->', x <= y)
    print()


def logical_demo():
    print('--- 逻辑运算符示例 ---')
    p = True
    q = False
    print('p =', p, '; q =', q)
    print('p and q ->', p and q)
    print('p or q ->', p or q)
    print('not p ->', not p)

    # 短路求值示例
    print('--- 短路求值示例 ---')
    def func1():
        print('func1 called')
        return True
    def func2():
        print('func2 called')
        return False
    print('func1() 与 func2() 调用输出：')
    func1()
    func2()
    print('False and func1() ->', False and func1())  # func1 不调用
    print('True or func2() ->', True or func2())      # func2 不调用
    print()


def assignment_demo():
    print('--- 赋值运算符示例 ---')
    z = 5
    print('z =', z)
    z += 3  # z = z + 3
    print('z += 3 -> z =', z)
    z -= 2  # z = z - 2
    print('z -= 2 -> z =', z)
    z *= 4  # z = z * 4
    print('z *= 4 -> z =', z)
    z /= 2  # z = z / 2
    print('z /= 2 -> z =', z)
    print()


def bitwise_demo():
    print('--- 位运算符示例 ---')
    m = 12  # 二进制 1100
    n = 7   # 二进制 0111
    print('m =', m, '(二进制 1100); n =', n, '(二进制 0111)')
    print('m & n =', m & n)   # 按位与
    print('m | n =', m | n)   # 按位或
    print('m ^ n =', m ^ n)   # 按位异或
    print('~m =', ~m)         # 按位取反
    print('m << 1 =', m << 1) # 左移
    print('m >> 1 =', m >> 1) # 右移
    print()


def membership_demo():
    print('--- 成员运算符示例 ---')
    lst = [1, 2, 3, 4, 5]
    print('lst =', lst)
    print('3 in lst ->', 3 in lst)
    print('6 not in lst ->', 6 not in lst)
    print()


def identity_demo():
    print('--- 身份运算符示例 ---')
    a = [1, 2, 3]
    b = a
    c = [1, 2, 3]
    print('a = [1,2,3]; b = a; c = [1,2,3]')
    print('a is b ->', a is b)
    print('a is c ->', a is c)
    print('a is not c ->', a is not c)
    print()


def other_demo():
    print('--- 其他运算符示例 ---')
    # lambda 表达式
    square = lambda x: x ** 2
    print('lambda x: x**2; square(5) =', square(5))

    # if-else 表达式
    num = 10
    result = '正数' if num > 0 else '非正数'
    print('num =', num, '; "正数" if num > 0 else "非正数" ->', result)
    print()


def precedence_demo():
    print('--- 运算符优先级示例 ---')
    # 括号最高
    expr1 = 2 + 3 * 4  # 3*4 先算
    expr2 = (2 + 3) * 4  # 括号优先
    print('2 + 3 * 4 =', expr1)
    print('(2 + 3) * 4 =', expr2)

    # 指数高于乘除
    expr3 = 2 * 3 ** 2  # 3**2 先算
    print('2 * 3 ** 2 =', expr3)

    # 比较低于算术
    expr4 = 5 > 3 + 2  # 3+2 先算
    print('5 > 3 + 2 ->', expr4)

    # 逻辑最低
    expr5 = True and 5 > 3  # 5>3 先算
    print('True and 5 > 3 ->', expr5)
    print()


def main():
    arithmetic_demo()
    comparison_demo()
    logical_demo()
    assignment_demo()
    bitwise_demo()
    membership_demo()
    identity_demo()
    other_demo()
    precedence_demo()


if __name__ == '__main__':
    main()

2.4. 基本Input/Output

  • input()
    用于从用户输入获取数据，返回字符串类型。
    需要时可以进行类型转换。
  • print()
    用于将数据输出到控制台。
    • sep参数：指定多个值之间的分隔符，默认是空格。
    • end参数：指定输出的结尾字符，默认是换行符。
  • f-string（格式化输出）
    格式： f"文本{变量}文本"，可以在字符串中嵌入变量和表达式。
  • eval()
    将字符串作为Python表达式进行求值，并返回结果。
    常用于一次性接收多个输入并进行处理
python 复制代码 
"""
示例：演示 Python 中基本输入输出操作

包含演示：
- input()：获取用户输入，返回字符串，类型转换
- print()：输出到控制台，sep和end参数
- f-string：格式化输出，嵌入变量和表达式
- eval()：将字符串作为Python表达式求值

运行：
    python io_demo.py

注意：input() 示例中使用了预设值模拟用户输入，实际运行时可取消注释并手动输入。

作者：自动生成示例（中文注释）
"""


def input_demo():
    print('--- input() 示例 ---')
    # input() 返回字符串，需要类型转换
    # 模拟用户输入（实际运行时可取消注释下一行，并注释掉 name = 'Alice'）
    # name = input('请输入您的名字：')
    name = 'Alice'  # 模拟输入
    print('输入的名字：', name, '; 类型：', type(name))

    # 类型转换示例
    # age_str = input('请输入您的年龄：')
    age_str = '25'  # 模拟输入
    age = int(age_str)  # 转换为整数
    print('输入的年龄字符串：', age_str, '; 转换为整数：', age, '; 类型：', type(age))

    # 浮点数转换
    # height_str = input('请输入您的身高（米）：')
    height_str = '1.75'  # 模拟输入
    height = float(height_str)
    print('输入的身高字符串：', height_str, '; 转换为浮点数：', height, '; 类型：', type(height))
    print()


def print_demo():
    print('--- print() 示例 ---')
    # 基本输出
    print('Hello, World!')

    # 多个值，默认分隔符空格
    print('Python', 'is', 'fun')

    # 指定 sep 参数
    print('Python', 'is', 'fun', sep='-')

    # 指定 end 参数，默认换行
    print('这行不换行', end=' ')
    print('继续在这行')

    # 结合 sep 和 end
    print('A', 'B', 'C', sep=', ', end='!\n')
    print()


def fstring_demo():
    print('--- f-string 示例 ---')
    name = 'Bobby'
    age = 30
    height = 1.80
    pi = 3.1415926535

    # 基本嵌入变量
    print(f'名字：{name}，年龄：{age}')

    # 嵌入表达式
    print(f'明年年龄：{age + 1}')

    # 格式化数字
    print(f'身高：{height:.2f} 米')

    # 复杂表达式
    status = '成年' if age >= 18 else '未成年'
    print(f'{name} 是 {status}，身高 {height:.1f} 米')

    # 更多格式化细节
    print('--- 更多 f-string 格式化选项 ---')

    # 宽度和对齐
    print(f'左对齐10位：{"left":<10} | 右对齐10位：{"right":>10} | 居中10位：{"center":^10} | ')

    # 填充字符
    print(f'填充*左对齐：{"fill":*<10} | 填充0右对齐：{42:0>5} | 填充-居中：{"hi":-^10} | ')

    # 数字格式化
    print(f'整数：{42:d} | 浮点：{pi:.3f} | 科学计数：{12345:e} | 百分比：{0.85:.1%} | ')

    # 字符串宽度
    print(f'字符串宽度：{name:>10} | 截断：{name:.3} | ')  # 注意：.3 是精度，但对字符串是截断前3字符

    # 组合
    print(f'组合：{pi:10.2f} | {age:04d} | ')
    print()


def eval_demo():
    print('--- eval() 示例 ---')
    # eval() 将字符串作为表达式求值
    expr1 = '2 + 3 * 4'
    result1 = eval(expr1)
    print(f'eval("{expr1}") = {result1}')

    # 变量环境
    x = 10
    expr2 = 'x * 2 + 5'
    result2 = eval(expr2)
    print(f'x = {x}; eval("{expr2}") = {result2}')

    # 列表和函数
    expr3 = '[i**2 for i in range(5)]'
    result3 = eval(expr3)
    print(f'eval("{expr3}") = {result3}')

    # 更复杂的批量赋值
    p, q, r = [1, 2, 3]
    print(f'p, q, r = [1, 2, 3] 后 p = {p}, q = {q}, r = {r}')

    # 复合赋值和批量赋值示例（使用 exec() 执行语句）
    print('--- eval() 示例（用于语句执行，如赋值）---')
    a, b = eval('1, 2')  # 初始化变量
    print(f'a, b = eval("1, 2") 后 a = {a}, b = {b}')

    # 注意：eval() 和 exec() 都有安全风险，仅用于可信输入
    print('注意：eval() 和 exec() 可执行任意代码，使用时需谨慎')
    print()


def main():
    input_demo()
    print_demo()
    fstring_demo()
    eval_demo()


if __name__ == '__main__':
    main()
相关推荐
网安CILLE6 分钟前
Wireshark 抓包实战演示
linux·网络·python·测试工具·web安全·网络安全·wireshark
研☆香7 分钟前
JS中的三种显示弹窗
开发语言·前端·javascript
王夏奇12 分钟前
python中的基础知识点-1
开发语言·windows·python
叫我辉哥e113 分钟前
新手进阶Python：办公看板集成多数据源+ECharts高级可视化
开发语言·python·echarts
猛扇赵四那边好嘴.13 分钟前
Flutter 框架跨平台鸿蒙开发 - 问答社区应用开发教程
开发语言·javascript·flutter·华为·harmonyos
C_心欲无痕15 分钟前
Next.js 路由系统对比：Pages Router vs App Router
开发语言·前端·javascript
LawrenceLan18 分钟前
Flutter 零基础入门（二十二）：Text 文本组件与样式系统
开发语言·前端·flutter·dart
程序员敲代码吗19 分钟前
如何从Python初学者进阶为专家？
jvm·数据库·python
kylezhao201923 分钟前
C# 各种类型转换深入剖析
开发语言·c#
hxjhnct26 分钟前
JavaScript 的 new会发生什么
开发语言·javascript
热门推荐
01GitHub 镜像站点022025 Telegram 最新免费社工库机器人（LetsTG可[特殊字符]）搭建指南（含 Python 脚本）03OpenCode 入门教程：介绍 · 安装 · 配置第三方 API (如 Claude)04Linux下V2Ray安装配置指南05安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）06Claude Code Skills 实用使用手册07UV安装并设置国内源08BongoCat - 跨平台键盘猫动画工具09AI 规范驱动开发“三剑客”深度对比：Spec-Kit、Kiro 与 OpenSpec 实战指南10网站改了域名，如何查找？