python编程课-总结-2025.5.20 from 黄老师

Python编程知识点总结：

一、数据类型与运算

1. 基础数据类型

  • 数值类型

    • int（整数）：如 16, -5, 1024，支持无限精度。
    • float（浮点数）：如 16.0, -5.25, 1024E3，注意浮点数精度问题（如 0.1+0.1+0.1 != 0.3）。小数精度计算，可使用Decimal 模块（Python）：用于需要高精度的金融计算
    • 运算：
      • 算术运算：+（加）、-（减）、*（乘）、/（浮点除）、//（整除）、%（取余）、**（幂运算）。
        示例：
        >>> 9 // 2  # 整除，结果为4
4
>>> 9 / 2  # 浮点除，结果为4.5
4.5
>>> 9 % 2   # 取余，结果为1
1
>>> 2 ** 3  # 幂运算，结果为8
8
      • 优先级：() > ** > * / // % > + -，可通过括号改变优先级。

  • 布尔类型（bool）

    • 值：True 和 False，注意首字母大写。
    • 转换：bool(0) → False，bool(非零数) → True，bool("") → False，bool(非空字符串) → True。

  • 字符串（str）

    • 定义：用单引号 '、双引号 " 或三引号 ''' 包裹，支持多行字符串。
      示例：
      s1 = "Hello World"
s2 = '''Line 1
Line 2'''  # 多行字符串
    • 索引与切片：
      • 索引：正向（从0开始）和反向（从-1开始）。
        示例：s = "abcde"，s[0] → 'a'，s[-1] → 'e'。
      • 切片：s[start:end:step]（左闭右开，step 为步长）。
        示例：s[1:3] → 'bc'，s[::-1] → 'edcba'（逆序）,s[3:1:-1] → 'dc'(某一段逆序)。
    • 常用方法：
      • count(x)：统计字符/子串出现次数。
      • split(sep)：按分隔符分割字符串为列表。
      • join(iterable)：用字符串连接可迭代对象。
      • replace(old, new)：替换字符串中的子串。
      • isdigit()：判断字符串是否全为数字。
        >>> "123".isdigit()  # 输出 True
True
>>> "a123".isdigit()  # 输出 False
False
      • isalpha()：判断字符串是否全为字母。
        >>> "abc".isalpha()  # 输出 True
True
>>> "abc123".isalpha()  # 输出 False
False
      • isupper()：判断字符串是否全为大写。
        >>> "ABC".isupper()  # 输出 True
True
>>> "Abc".isupper()  # 输出 False
False
      • islower()：判断字符串是否全为小写。
        >>> "abc".islower()  # 输出 True
True
>>> "Abc".islower()  # 输出 False
False
      • upper()：将字符串转换为大写。
        >>> "abc".upper()  # 输出 "ABC"
'ABC'
      • lower()：将字符串转换为小写。
        >>> "ABC".lower()  # 输出 "abc"
'abc'

2. 复合数据类型

  • 列表（list）

    • 定义：有序、可变，用 [ ] 包裹，元素可重复，支持任意数据类型。
      示例：lst = [1, "a", True, [1, 2, 3]]。
    • 操作：
      • 索引与切片：与字符串类似，但可修改元素。
        示例：lst[0] = 10（修改第一个元素）。
      • 增删改查：
        • append(x)：在末尾添加元素。
        • insert(index, x)：在指定位置插入元素。
        • pop(index)：删除并返回指定位置元素（默认删除最后一个）。
        • remove(x)：删除第一个匹配的元素。
          示例：
        lst = [1, 2, 3]
lst.append(4)       # [1, 2, 3, 4]
lst.insert(0, 0)    # [0, 1, 2, 3, 4]
lst.pop(0)          # 删除第一个元素，返回0，列表变为[1, 2, 3, 4]
      • 排序与反转：
        • sort()：原地排序（升序），仅适用于元素类型可比较的列表。
          >>> lst = [3, 1, 2]
>>> lst.sort()  # 原地排序，列表变为[1, 2, 3]
>>> print(lst)
[1, 2, 3]
        • reverse()：原地反转列表。
          >>> lst = [1, 2, 3]
>>> lst.reverse()  # 列表变为[3, 2, 1]
>>> print(lst)
[3, 2, 1]
      • 常用函数：
        • max(lst)：返回列表中的最大值（元素需可比较）。
          >>> lst = [3, 1, 2]
>>> max(lst)  # 输出3
3
        • min(lst)：返回列表中的最小值。
          >>> lst = [3, 1, 2]
>>> min(lst)  # 输出1
1
        • sum(lst)：返回列表中所有数值的和（元素需为数值类型）。
          >>> lst = [1, 2, 3]
>>> sum(lst)  # 输出6
6

  • 元组（tuple）

    • 定义：有序、不可变，用 () 包裹，元素不可修改，适合存储固定数据。
      示例：tup = (1, "a", True)。
    • 操作：索引与切片同列表，但无法修改元素。

  • 字典（dict）

    • 定义：无序、键值对（key: value），键唯一且不可变（如字符串、数值、元组），值可任意类型。
      示例：dict = {"name": "Alice", "age": 20}。
    • 操作：
      • 访问值：dict[key]（键不存在报错）或 dict.get(key, default)（键不存在返回默认值）。
      • 增删改：dict[key] = value（新增或修改），del dict[key]（删除键值对）。
      • 遍历：
        for key in dict:
    print(key, dict[key])  # 遍历键值对

  • 集合（set）

    • 定义：无序、元素唯一，用 { } 或 set() 创建，自动去重。
      示例：s = {1, 2, 2, 3} → {1, 2, 3}。
    • 操作：
      • 增删：add(x)（添加元素）、remove(x)（删除元素，不存在报错）、discard(x)（删除元素，不存在不报错）。
      • 集合运算：s1 | s2（并集）、s1 & s2（交集）、s1 - s2（差集）。

二、控制结构

1. 顺序结构

代码按从上到下顺序执行，无分支或循环。
示例：

a = 10
b = 20
c = a + b  # 顺序执行赋值和运算
print(c)   # 输出30

2. 分支结构（if语句）

根据条件判断执行不同代码块。

  • 单分支：
    x = 5
if x > 0:
    print("Positive")  # 条件为真时执行
  • 双分支：
    x = -3
if x > 0:
    print("Positive")
else:
    print("Non-positive")  # 条件为假时执行
  • 多分支：
    score = 85
if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"  # 满足多个条件时，只执行第一个匹配的分支
else:
    grade = "C"

3. 循环结构

  • for循环：遍历可迭代对象（如列表、字符串、字典、range函数）。

    • 遍历列表：
      fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)
    • 遍历range函数：
      for i in range(1, 5):  # range(start, end)，遍历1, 2, 3, 4
    print(i)

  • while循环：条件为真时重复执行代码块。

    i = 1
while i <= 5:
    print(i)
    i += 1  # 避免死循环

  • 循环控制语句：

    • break：跳出当前循环。
    • continue：跳过当前循环的剩余代码，进入下一次循环。
      示例：
    for i in range(10):
    if i == 5:
        break  # 当i=5时跳出循环
    print(i)

  • range()函数使用讲解：

在 Python 中，range() 是一个内置函数，常用于生成不可变的整数序列，通常在循环中控制迭代次数。以下是关于 range() 函数的详细介绍：

  • 基本语法

range(stop)               # 从 0 开始，到 stop-1 结束，步长为 1
range(start, stop[, step]) # 从 start 开始，到 stop-1 结束，步长为 step（可选）

  • 参数说明：

    • start：起始值（包含），默认为 0。
    • stop：终止值（不包含），必须指定。
    • step：步长（增量），默认为 1，可为负数（表示递减）。

  • 常见用法示例

  • 1. 生成从 0 开始的序列

for i in range(5):
    print(i)  # 输出：0, 1, 2, 3, 4

  • 2. 指定起始和终止值

for i in range(2, 7):
    print(i)  # 输出：2, 3, 4, 5, 6

  • 3. 指定步长（间隔）

for i in range(1, 10, 2):
    print(i)  # 输出：1, 3, 5, 7, 9（步长为 2）

  • 4. 递减序列（负步长）

for i in range(5, 0, -1):
    print(i)  # 输出：5, 4, 3, 2, 1

  • 与 len() 结合遍历列表

常用于通过索引访问列表元素：

fruits = ["apple", "banana", "cherry"]
for i in range(len(fruits)):
    print(f"索引 {i}: {fruits[i]}")
# 输出：
# 索引 0: apple
# 索引 1: banana
# 索引 2: cherry

三、函数与模块

1. 函数定义与调用

  • 无参函数：
    def greet():
    print("Hello, World!")

greet()  # 调用函数，输出"Hello, World!"
  • 有参函数：
    def add(a, b):
    return a + b  # 返回值

result = add(3, 5)
print(result)  # 输出8
  • 默认参数：
    def power(x, n=2):  # n默认值为2
    return x ** n

print(power(3))     # 输出9（3^2）
print(power(3, 3))  # 输出27（3^3）

2. 模块导入

  • 导入内置模块（如 math）或自定义模块。
    import math  # 导入math模块

print(math.sqrt(16))  # 输出4.0（平方根）
  • 从模块中导入特定函数：
    from math import sqrt  # 只导入sqrt函数
print(sqrt(25))        # 输出5.0

四、文件操作与异常处理

1. 文件读写

  • 读取文件：
    with open("file.txt", "r", encoding="utf-8") as f:
    content = f.read()  # 读取全部内容
    lines = f.readlines()  # 读取所有行，返回列表
  • 写入文件：
    with open("output.txt", "w", encoding="utf-8") as f:
    f.write("Hello, File!")  # 写入内容（覆盖原有文件）

2. 异常处理

捕获并处理程序运行中的异常，避免程序崩溃。

try:
    x = int(input("Enter a number: "))
    print(10 / x)
except ZeroDivisionError:
    print("Cannot divide by zero!")  # 处理除零错误
except ValueError:
    print("Invalid input!")         # 处理输入非数字错误

五、print 函数用法总结

在 Python 中，print() 是一个常用的内置函数，用于将对象输出到标准输出（通常是控制台）。其中，end 是 print() 的一个重要参数，用于控制输出的结束字符。以下是关于 end 参数的详细讲解：

基本语法

print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)
  • 参数说明：
    • *objects：要打印的对象（可多个，用逗号分隔）。
    • sep：多个对象之间的分隔符，默认为空格 ' '。
    • end：输出结束时的字符，默认为换行符 '\n'。
    • file：输出目标文件，默认为标准输出 sys.stdout。
    • flush：是否强制刷新输出缓冲区，默认为 False。

end 参数的作用

end 参数决定了 print() 语句执行后追加的字符。默认情况下，每次 print() 会自动在末尾添加换行符 '\n'，导致后续输出从新行开始。通过修改 end，可以自定义结束字符，实现更灵活的输出格式。

常见用法示例

1. 默认行为（换行）

print("Hello")
print("World")
# 输出：
# Hello
# World

2. 使用空字符串 '' 取消换行

print("Hello", end='')
print("World")
# 输出：HelloWorld

3. 自定义结束字符（如空格、逗号等）

for i in range(5):
    print(i, end=' ')
# 输出：0 1 2 3 4 

for i in range(5):
    print(i, end=',')
# 输出：0,1,2,3,4,

4. 组合使用 sep 和 end

print("a", "b", "c", sep='-', end='!')
print("d", "e", "f", sep='-', end='!')
# 输出：a-b-c!d-e-f!

注意事项

  1. 字符转义：
    • end='\n'：换行（默认）。
    • end='\t'：制表符（缩进）。
    • end='\r'：回车（回到行首）。
    • end=' '：空格（连续输出）。

常见错误

1. 忘记处理末尾字符

# 错误示例：末尾多余逗号
for i in range(5):
    print(i, end=',')
# 输出：0,1,2,3,4,（最后一个逗号可能不需要）

# 修正：
for i in range(5):
    print(i, end=',' if i < 4 else '\n')
# 输出：0,1,2,3,4

2. 混用不同 end 参数

print("Hello", end='  ')
print("World", end='\n')
print("Python")
# 输出：
# Hello World
# Python

总结

  • end 参数允许自定义 print() 语句的结束字符，默认是换行符 '\n'。
  • 通过修改 end，可以实现连续输出、单行刷新、表格构建等多种效果。
  • 结合 sep 参数，可进一步控制多个对象之间的分隔符，灵活调整输出格式。

合理使用 end 参数能让输出更符合需求，提升代码的可读性和用户体验。

1. 输出字符串和数字

直接打印变量或值，支持多种数据类型。

>>> print("runoob")         # 输出字符串
runoob
>>> print(100)              # 输出数字
100
>>> str = 'runoob'
>>> print(str)              # 输出变量
runoob
>>> L = [1, 2, 'a']         # 列表
>>> print(L)
[1, 2, 'a']
>>> t = (1, 2, 'a')         # 元组
>>> print(t)
(1, 2, 'a')
>>> d = {'a': 1, 'b': 2}    # 字典
>>> print(d)
{'a': 1, 'b': 2}

2. 格式化输出整数

支持参数格式化，与 C 语言的 printf 类似，使用 % 操作符。

>>> str = "the length of (%s) is %d" % ('runoob', len('runoob'))
>>> print(str)
the length of (runoob) is 6

Python 字符串格式化符号：

符号 描述
%c 格式化字符及其 ASCII 码
%s 格式化字符串
%d 格式化整数
%u 格式化无符号整型
%o 格式化无符号八进制数
%x 格式化无符号十六进制数（小写）
%X 格式化无符号十六进制数（大写）
%f 格式化浮点数字，可指定小数点后的精度
%e 用科学计数法格式化浮点数
%E 作用同 %e，用科学计数法格式化浮点数
%g %f 和 %e 的简写
%G %f 和 %E 的简写
%p 用十六进制数格式化变量的地址

格式化操作符辅助指令：

符号 功能
* 定义宽度或者小数点精度
- 用做左对齐
+ 在正数前面显示加号(+)
<sp> 在正数前面显示空格
# 在八进制数前面显示零(0)，在十六进制前面显示 0x 或 0X
0 显示的数字前面填充 0 而非默认空格
% 输出一个单一的 %
(var) 映射变量（字典参数）
m.n m 是显示的最小总宽度，n 是小数点后的位数

3. 格式化输出进制转换

使用 %x（十六进制）、%d（十进制）、%o（八进制）。

>>> nHex = 0xFF
>>> print("nHex = %x, nDec = %d, nOct = %o" % (nHex, nHex, nHex))
nHex = ff, nDec = 255, nOct = 377

4. 格式化输出浮点数（float）

控制浮点数的宽度、精度、对齐方式等。

>>> pi = 3.141592653
>>> print('%10.3f' % pi)  # 字段宽10，精度3
     3.142
>>> print("pi = %.*f" % (3, pi))  # 用*从后面的元组中读取精度
pi = 3.142
>>> print('%010.3f' % pi)  # 用0填充空白
000003.142
>>> print('%-10.3f' % pi)  # 左对齐
3.142
>>> print('%+f' % pi)  # 显示正负号
+3.141593

（1） 保留2位小数的常见方法

  • 方法一：格式化字符串（%.2f）
    使用 % 操作符或 format() 方法直接指定小数位数。

    >>> pi = 3.141592653
>>> print('%.2f' % pi)  # 传统格式化
3.14
>>> print("{0:.2f}".format(pi))  # format()方法
3.14
>>> print(f"{pi:.2f}")  # f-string（Python 3.6+）
3.14

  • 方法二：round() 函数
    对浮点数进行四舍五入，返回指定精度的浮点数。

    >>> rounded_pi = round(pi, 2)
>>> print(rounded_pi)  # 输出四舍五入后的结果
3.14

（2） 四舍五入的注意事项

  • 标准四舍五入：Python 3的 round() 函数采用 “银行家舍入”（四舍六入五成双）。
    当小数位为5时，舍入到最近的偶数。

    >>> round(2.5)  # 输出2（五入到偶数）
2
>>> round(3.5)  # 输出4（五入到偶数）
4

  • 强制四舍五入：若需严格四舍五入，可结合 decimal 模块。

    from decimal import Decimal, ROUND_HALF_UP

def round_half_up(n, decimals=0):
    multiplier = Decimal(10 ** decimals)
    return float(Decimal(str(n)).quantize(multiplier, rounding=ROUND_HALF_UP))

>>> round_half_up(2.5)  # 输出3（严格四舍五入）
3.0
>>> round_half_up(2.49)  # 输出2.0
2.0

（3） 格式化与四舍五入的结合应用

  • 场景一：金额显示

    amount = 123.456
print(f"金额: {amount:.2f}元")  # 输出: 金额: 123.46元

  • 场景二：百分比计算

    rate = 0.7893
print(f"完成率: {rate:.2%}")  # 输出: 完成率: 78.93%

  • 场景三：表格对齐

    values = [1.234, 5.678, 9.012]
for v in values:
    print(f"{v:>8.2f}")  # 右对齐，总宽度8，保留2位小数
# 输出：
#    1.23
#    5.68
#    9.01

六、序列的访问方式

Python中支持通过直接遍历成员或下标索引访问序列（列表、元组、字符串）。集合由于无序性，仅支持直接遍历。

方式一：直接遍历成员（foreach循环）

通过 for...in 直接遍历序列中的每个成员。
语法：

for 成员 in 序列:
    print(成员)

示例：

# 列表遍历
lst = [1, 2, 3]
for num in lst:
    print(num)  # 输出: 1, 2, 3

# 元组遍历
tup = ('a', 'b', 'c')
for char in tup:
    print(char)  # 输出: a, b, c

# 字符串遍历
s = "hello"
for c in s:
    print(c)  # 输出: h, e, l, l, o

# 集合遍历（注意：集合无序，输出顺序不固定）
st = {10, 20, 30}
for elem in st:
    print(elem)  # 可能输出: 10, 20, 30（顺序不定）

方式二：下标索引遍历（通过 range(len())）

通过 range(len(序列)) 生成索引，再用索引访问元素。
语法：

for i in range(len(序列)):
    print(序列[i])

示例：

# 列表下标遍历
lst = [1, 2, 3]
for i in range(len(lst)):
    print(lst[i])  # 输出: 1, 2, 3

# 元组下标遍历
tup = ('a', 'b', 'c')
for i in range(len(tup)):
    print(tup[i])  # 输出: a, b, c

# 字符串下标遍历
s = "hello"
for i in range(len(s)):
    print(s[i])  # 输出: h, e, l, l, o

# 集合无法使用下标（报错！）
st = {10, 20, 30}
# 以下代码会报错，因为集合不支持索引
# for i in range(len(st)):
#     print(st[i])

两种方式的对比

方式 适用场景 优点 缺点
直接遍历 仅需成员值，无需索引 语法简洁，效率高 无法获取当前元素的索引
下标遍历 需要同时使用索引和元素值（如修改元素） 可获取索引，灵活操作元素 语法较复杂，效率略低

集合的特殊性

集合（set）是无序且无重复元素的容器，因此：

  • 不支持下标索引（如 s[0] 会报错）。
  • 遍历时顺序不确定（每次输出可能不同）。
st = {3, 1, 2}
for elem in st:
    print(elem)  # 可能输出: 1, 2, 3 或其他顺序

典型应用场景

  1. 修改列表元素（需用下标）：

    lst = [1, 2, 3]
for i in range(len(lst)):
    lst[i] *= 2  # 将每个元素乘以2
print(lst)  # 输出: [2, 4, 6]

  2. 同时获取索引和元素（使用 enumerate）：

    lst = ['a', 'b', 'c']
for i, char in enumerate(lst):
    print(f"索引 {i}: {char}")
# 输出:
# 索引 0: a
# 索引 1: b
# 索引 2: c

七、典型示例

示例1：计算圆的面积

# 输入半径，计算面积并格式化输出
r = float(input("Enter radius: "))
area = 3.14 * r ** 2
print("Area: %.2f" % area)  # 保留两位小数

示例2：登录系统（字典实现）

# 存储用户账号密码
users = {}
n = int(input("Enter number of users: "))
for _ in range(n):
    username = input()
    password = input()
    users[username] = password

# 验证登录
m = int(input("Enter number of logins: "))
for _ in range(m):
    username, password = input().split()
    if users.get(username) == password:
        print("Success")
    else:
        print("Fail")

示例3：斐波那契数列（递归与循环）

  • 递归实现：
    def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

print(fibonacci(10))  # 输出55
  • 循环实现：
    n = 10
a, b = 0, 1
for _ in range(n):
    a, b = b, a + b
print(a)  # 输出55

八、注意事项

  1. 缩进规则：Python通过缩进来区分代码块，缩进必须一致（通常为4个空格或1个Tab）。
  2. 数据类型转换：使用 int()、float()、str() 等函数进行类型转换，注意处理无效输入（如 int("abc") 会报错）。
  3. 变量作用域：函数内部定义的变量为局部变量，函数外无法访问；全局变量需用 global 声明。
  4. 效率问题：递归可能导致栈溢出（如计算过大的斐波那契数），优先使用循环实现。

通过以上知识点和示例，可快速掌握Python编程的核心逻辑与实践方法。

posted @ 2025-05-20 12:57  kkman2000  阅读(72)  评论(0)    收藏  举报