Python编程学习指南笔记汇总

文章目录

python是一种面向对象编程的解释性语言，很常用于机器学习、神经网络、大模型等，由于其简洁便于使用的特点，也有时被称为“傻瓜式语言”，因为别人写好的，直接拿过来用就可以，但是具体的一些算法开发，也是很不容易的。由于之前学的语言有点杂乱，所以现在整体整理一下一些常见的操作以及命令行

常见操作及命令行

1. 头文件 / 库

   语言	常用库	引入语句
   Python	numpy（数值计算）	import numpy as np
   	pandas（数据处理）	import pandas as pd
   	matplotlib.pyplot（绘图）	import matplotlib.pyplot as plt
   	requests（网络请求）	import requests
   	os（操作系统接口）	import os
   C	stdio.h（输入输出）	#include <stdio.h>
   	stdlib.h（标准库）	#include <stdlib.h>
   	string.h（字符串处理）	#include <string.h>
   	math.h（数学函数）	#include <math.h>
   	time.h（时间处理）	#include <time.h>
   Java	java.util.Scanner（输入）	import java.util.Scanner;
   	java.io.File（文件操作）	import java.io.File; import java.io.FileWriter; import java.io.IOException;
   	java.util.ArrayList（集合）	import java.util.ArrayList;
   	java.util.HashMap（映射）	import java.util.HashMap;
   	java.text.SimpleDateFormat（日期格式化）	import java.text.SimpleDateFormat;
   MATLAB	无需显式引入（内置函数）	直接使用函数，如 plot()、fopen()、load() 等

2. 注释

   语言	单行注释	多行注释
   Python	# 这是单行注释	''' 多行注释 ''' 或 """ 多行注释 """
   C	// 单行注释	/* 多行注释 */
   Java	// 单行注释	/* 多行注释 */
   MATLAB	% 单行注释	%{ ... %}%（R2016b+）

   可以看到在python的段多行注释中 """ 注释 """ 和下方多行赋值的语句 a = """第一行 （回车）第二行...""" 都使用连续的三个双引号，要进行区分

3. 缩进换行 / 代码块

   语言	代码块界定方式	缩进规范
   Python	缩进（强制）	4个空格（或1个Tab） 用冒号 : 开启代码块
   C	花括号 {}	推荐缩进2或4个空格（非强制）
   Java	花括号 {}	推荐缩进4个空格（非强制）
   MATLAB	关键字（如 end）	推荐缩进2或4个空格（非强制）

4. 差异

5. 强制缩进 vs 可选缩进：
6. Python：缩进是语法的一部分，错误的缩进会导致 IndentationError。
7. C/Java/MATLAB：缩进仅用于可读性，代码块由 {} 或 end 界定。
8. 代码块界定语法：
   – Python：使用冒号 : 和缩进。
   – C/Java：使用花括号 {}。
   – MATLAB：使用关键字（如 if/else/end、for/end）。

9. 示例对比（条件语句）：

10. python

    if x > 5:
        print("x 大于 5")  # 缩进4个空格
        y = x * 2
    else:
        print("x 小于等于 5")
        y = x / 2
    
    # 错误案例   
    if x > 5:
    	print("x 大于 5")
    print("这行不属于if块")  # 错误！缩进不一致
    

11. C

    if (x > 5) {  // 花括号开始代码块
        printf("x 大于 5\n");  // 缩进2或4个空格（可选）
        y = x * 2;
    } else {
        printf("x 小于等于 5\n");
        y = x / 2;
    }  // 花括号结束代码块
    
    // 错误案例
    if (x > 5)  // 缺少花括号，只有第一条语句属于if块
    	printf("x 大于 5\n");
    	y = x * 2;  // 这行始终会执行！
    

12. java

    if (x > 5) {  // 花括号开始
        System.out.println("x 大于 5");  // 缩进4个空格
        y = x * 2;
    } else {
        System.out.println("x 小于等于 5");
        y = x / 2;
    }  // 花括号结束
    
    // 错误案例
    if (x > 5)  // 缺少花括号，只有第一条语句属于if块
    	printf("x 大于 5\n");
    	y = x * 2;  // 这行始终会执行！
    

13. matlab

    if x > 5  % 关键字开始
        disp('x 大于 5');  % 缩进2或4个空格
        y = x * 2;
    else
        disp('x 小于等于 5');
        y = x / 2;
    end  % 关键字结束
    
    % 错误案例
    for i = 1:10
       if i > 5
           disp(i)
       % 忘记写end会导致语法错误
    end  % 必须匹配if和for的end
    

14. 数据类型

    语言	整型	浮点型	布尔型	复数型	字符串类型	特殊类型
    Python	int（动态长度）	float（双精度）	bool（True/False）	complex（a+bj）	单/双/三引号（'/"/"""）	None（空值）
    C	int, short, long	float, double	_Bool（C99+，需 stdbool.h）	无原生支持，需自定义结构体	字符数组（char[]）或指针	void（无类型）
    Java	int, short, long	float, double	boolean（true/false）	无原生支持，需 java.complex	String 类（不可变）	null（空引用）
    MATLAB	int8, uint8, int16, …	single, double	logical（true/false）	原生支持（a+bi 或 a+bj）	字符数组（'text'）或 string（R2016b+）	NaN, Inf（特殊数值）

15. 动态类型 vs 静态类型

16. Python：动态类型，无需声明类型，解释器自动推断：

    x = 10      # int
    x = "hello" # str（重新赋值后类型改变）
    

17. C/Java：静态类型，需显式声明类型，且不可更改：

    int x = 10;    // 正确
    x = "hello";   // 错误！类型不匹配
    

18. 整型范围与精度

19. Python：int 无固定范围（受内存限制），支持任意大整数：

    x = 10**100   # 合法，不会溢出
    

20. C/Java：整型有明确范围（如 int 通常为 32 位，范围 -2147483648 ~ 2147483647）：

    int x = 2147483647;
    x = x + 1;   // 溢出，结果变为 -2147483648
    

21. 字符串处理

22. Python：字符串是不可变对象，支持丰富的内置方法：

    s = "hello"
    s.upper()    # 返回 "HELLO"，原字符串不变
    

23. C：字符串用字符数组表示，需手动管理内存：

    char s[] = "hello";
    strlen(s);   // 获取长度
    

24. Java：String 类不可变，修改会创建新对象：

    String s = "hello";
    s = s.toUpperCase();  // 创建新字符串 "HELLO"
    

25. 复数支持

26. Python/MATLAB：原生支持复数，使用 j 或 i 作为虚部后缀：

    z = 1 + 2j
    print(z.real)   # 输出 1.0
    

    z = 1 + 2i;
    real(z)         % 输出 1
    

27. C/Java：无原生复数类型，需手动实现或使用第三方库：

    // Java 需自定义 Complex 类或使用 Apache Commons Math
    Complex z = new Complex(1, 2);
    

28. 布尔类型

29. Python/Java：使用 True/False（首字母大写）：

    flag = True
    

30. C：C99 引入 _Bool 类型，需包含 stdbool.h 并使用 true/false（小写）：

    #include <stdbool.h>
    bool flag = true;
    

31. 变量初始化

32. python
    python的变量初始化和其他语言的初始化不同，python的解释器做了两件事情：
    i.  在内存中创建了一个“实值”数据；
    ii. 创建一个“变量”，把“实值”数据保存在“变量”中去；
    iii. 同一个变量是可以被反复赋值的，并且可以是不同的数据类型；（改变数据类型在其他语言中基本都不支持）

     a = 666  # 初始化变量a，并初始化值赋值666
     print(a)
     a = 999  # 为变量a重新赋值999
     print(a)
     a = "www"  # 再次为变量a赋值字符串类型"www"，改变了变量a的数据类型
     print(a)
    

33. C
    C语言是静态类型语言，变量必须先声明类型，且不能改变类型：

    int a = 666;  // 声明int类型变量a并初始化为666
    printf("%d\n", a);
    a = 999;      // 重新赋值为999（类型必须一致）
    printf("%d\n", a);
    // a = "www";  // 错误：不能将字符串赋值给int类型变量
    
    char c = 'c';
    char str[] = "hello world";
    

34. java
    Java 同样是静态类型语言，变量类型不可变：

    int a = 666;  // 声明int类型变量a并初始化为666
    System.out.println(a);
    a = 999;      // 重新赋值为999
    System.out.println(a);
    // a = "www";  // 错误：不能将String类型赋值给int变量
    

35. matlab
    MATLAB 是动态类型语言，但变量类型由赋值决定，重新赋值不同类型会覆盖原类型：

    a = 666;      % 初始化变量a为数值类型
    disp(a);
    a = 999;      % 重新赋值为数值类型
    disp(a);
    a = 'www';    % 赋值为字符串类型（单引号表示字符数组）
    disp(a);
    

36. input输入

    语言	输入函数/方法	基本语法
    Python	input()	变量 = input([提示字符串])
    C	scanf() fgets()	scanf("格式字符串", &变量); fgets(字符数组, 大小, stdin);
    Java	Scanner 类 BufferedReader	Scanner scanner = new Scanner(System.in); 变量 = scanner.数据类型();
    MATLAB	input()	变量 = input('提示字符串', '选项');

37. 差异

38. 类型处理

39. Python：input() 始终返回字符串类型，需手动转换类型：

    age = int(input("请输入年龄："))  # 若输入非数字会报错
    

40. C/Java：需指定输入格式或使用类型专用方法：

    int age;
    scanf("%d", &age);  // 指定读取整数
    

    int age = scanner.nextInt();  // 直接读取整数
    

41. MATLAB：input() 根据输入自动判断类型，加 's' 选项读取字符串：

    age = input('年龄：');      % 输入 20 → 数值类型
    name = input('姓名：', 's');  % 输入 '张三' → 字符串
    

42. 读取整行 vs 单个元素

43. Python：input() 读取整行，需分割：

    line = input("输入多个数，用空格分隔：")
    nums = line.split()  # 返回字符串列表
    

44. C：scanf() 遇空格/换行停止，fgets() 读取整行：

    char line[100];
    fgets(line, 100, stdin);  // 读取整行，包含换行符
    

45. Java：Scanner 的 nextLine() 读取整行，其他方法（如 nextInt()）遇空格/换行停止：

    String line = scanner.nextLine();  // 读取整行
    int num = scanner.nextInt();       // 读取一个整数
    

46. 输入缓冲区处理

47. C：scanf() 可能遗留换行符，需手动清除：

    scanf("%d", &age);     // 输入 20 后遗留换行符
    getchar();             // 清除换行符
    fgets(name, 50, stdin);  // 正常读取姓名
    

48. Java：nextInt() 后调用 nextLine() 需注意缓冲区：

    int age = scanner.nextInt();  // 输入 20 后遗留换行符
    scanner.nextLine();           // 清除换行符
    String name = scanner.nextLine();  // 正常读取姓名
    

49. 示例对比

50. 读取姓名和年龄

    # Python
    name = input("请输入姓名：")
    age = int(input("请输入年龄："))
    print(f"{name} 今年 {age} 岁")
    

    // C
    #include <stdio.h>
    int main() {
        char name[50];
        int age;
        printf("请输入姓名：");
        scanf("%s", name);
        printf("请输入年龄：");
        scanf("%d", &age);
        printf("%s 今年 %d 岁\n", name, age);
        return 0;
    }
    

    // Java
    import java.util.Scanner;
    public class Main {
        public static void main(String[] args) {
            Scanner scanner = new Scanner(System.in);
            System.out.print("请输入姓名：");
            String name = scanner.nextLine();
            System.out.print("请输入年龄：");
            int age = scanner.nextInt();
            System.out.printf("%s 今年 %d 岁\n", name, age);
            scanner.close();
        }
    }
    

    % MATLAB
    name = input('请输入姓名：', 's');
    age = input('请输入年龄：');
    fprintf('%s 今年 %d 岁\n', name, age);
    

51. 读取多个数值

    # Python
    nums = list(map(int, input("输入多个数，用空格分隔：").split()))
    print(nums)  # 输出整数列表
    

    // C（读取两个整数）
    int a, b;
    scanf("%d %d", &a, &b);
    printf("a=%d, b=%d\n", a, b);
    

    // Java
    Scanner scanner = new Scanner(System.in);
    int a = scanner.nextInt();
    int b = scanner.nextInt();
    System.out.printf("a=%d, b=%d\n", a, b);
    

    % MATLAB
    nums = input('输入多个数，用空格分隔：');  % 输入 [1 2 3] → 数值数组
    disp(nums);
    

52. print输出

    语言	输出语句 / 函数
    Python	print() sys.stdout.write() logging.info() pprint.pprint()（美化输出）
    C	printf() puts() fprintf()（标准输出/文件，将数据输出到流（stream）中） sprintf()（字符串格式化）
    Java	System.out.println() System.out.print() System.out.printf()（格式化） String.format()（返回格式化字符串）
    MATLAB	disp() fprintf() sprintf()（返回格式化字符串） diary()（日志记录）

53. python

    # Python print 输出示例
    print("Hello World")  # 输出：Hello World
    print("Hell0", "World")  # 输出：Hell0 World（多个参数默认用空格分隔）
    print("Hello", "World", sep="-")  # 输出：Hello-World（自定义分隔符）
    print("Hello", "World", end="!")  # 输出：Hello World!（自定义结束符）
    print("Hello", "World", end="\n")  # 输出：Hello World（默认换行符）
    
    # 变量输出
    name = "张三"
    age = 20
    print(f"{name} 今年 {age} 岁")  # f-字符串格式化（Python 3.6+）
    print("{} 今年 {} 岁".format(name, age))  # format 方法格式化
    print("%s 今年 %d 岁" % (name, age))  # 旧式 % 格式化
    print(name + " 今年 " + str(age) + " 岁")  # 使用 + 拼接（需手动转换类型）
    print(name, "今年", age, "岁")  # print 多个参数（自动添加空格）
    
    # 输出到文件
    with open("output.txt", "w") as f:
        print("Hello, file!", file=f)  # 输出到文件而非控制台
    
    # 输出特殊字符
    print("这是一个制表符\t这是一行新内容")  # 制表符 \t
    print("这是一个换行符\n这是一行新内容")  # 换行符 \n
    print("这是一个退格符\b这是被删除的字符")  # 退格符 \b）
    

54. C

    #include <stdio.h>
    
    int main() {
        // 基本输出
        printf("Hello World\n");  // 输出：Hello World（需手动添加换行符）
        printf("Hello %s\n", "World");  // 格式化输出字符串
        printf("整数: %d, 浮点数: %f, 字符: %c\n", 42, 3.14, 'A');  // 格式化多种类型
    
        // 变量输出
        char name[] = "张三";
        int age = 20;
        printf("%s 今年 %d 岁\n", name, age);  // 格式化输出变量
    
        // 输出到文件
        FILE *fp = fopen("output.txt", "w");
        fprintf(fp, "Hello, file!\n");  // 输出到文件
        fclose(fp);
    
        return 0;
    }
    

55. java

    // Java 输出示例
    public class Main {
        public static void main(String[] args) {
            // 基本输出
            System.out.println("Hello World");  // 输出并换行
            System.out.print("Hello ");  // 输出不换行
            System.out.println("World");  // 输出并换行
    
            // 格式化输出
            System.out.printf("Hello %s%n", "World");  // 格式化输出（类似 C 语言的 printf）
            System.out.printf("整数: %d, 浮点数: %.2f%n", 42, 3.1415);  // 格式化数值
    
            // 变量输出
            String name = "张三";
            int age = 20;
            System.out.printf("%s 今年 %d 岁%n", name, age);  // 格式化输出变量
            System.out.println(name + " 今年 " + age + " 岁");  // 使用 + 拼接
    
            // 输出到文件
            try (java.io.PrintWriter writer = new java.io.PrintWriter("output.txt")) {
                writer.println("Hello, file!");  // 输出到文件
            } catch (java.io.IOException e) {
                e.printStackTrace();
            }
        }
    }
    

56. matlab

    % 基本输出
    disp('Hello World');  % 显示字符串（自动换行）
    fprintf('Hello World\n');  % 格式化输出（类似 C 语言的 printf）
    
    % 变量输出
    name = '张三';
    age = 20;
    fprintf('%s 今年 %d 岁\n', name, age);  % 格式化输出变量
    disp([name, ' 今年 ', num2str(age), ' 岁']);  % 使用 [] 拼接（需转换数值为字符串）
    
    % 输出到文件
    fileID = fopen('output.txt', 'w');
    fprintf(fileID, 'Hello, file!\n');  % 输出到文件
    fclose(fileID);
    
    % 高级格式化
    x = 3.14159;
    fprintf('%.2f\n', x);  % 保留两位小数：3.14
    fprintf('%10.4f\n', x);  % 宽度为 10，保留四位小数：'    3.1416'
    

57. 虚拟环境 / 环境配置

58. 函数输入输出个数

59. main

60. 运行方式

61. 字符串连接

    语言	方法/操作符	示例代码	特点与注意事项
    Python	+ 操作符	s = "Hello" + " " + "World"	简单直观，适合少量字符串连接；频繁使用性能较差（生成新对象）。
    	join() 方法	s = " ".join(["Hello", "World"])	推荐用于连接大量字符串（性能最优），需先将字符串放入可迭代对象（如列表、元组）。
    	f-strings（格式化）	name = "Alice"; s = f"Hello, {name}!"	Python 3.6+ 推荐，可读性强，支持表达式嵌入。
    	% 格式化	s = "Hello, %s!" % "Alice"	旧版格式化方法，兼容性好，但功能较弱。
    	format() 方法	s = "Hello, {}!".format("Alice")	通用格式化方法，支持位置参数、关键字参数。
    C	strcat() 函数	char dest[20] = "Hello"; strcat(dest, " World");	需预分配足够的目标缓冲区空间，可能导致缓冲区溢出（不安全）。
    	sprintf() 函数	char dest[20]; sprintf(dest, "%s %s", "Hello", "World");	通过格式化字符串写入缓冲区，需手动控制缓冲区大小。
    	手动遍历赋值	char dest[20]; int i, j; for(i=0; src1[i]; i++) dest[i]=src1[i]; for(j=0; src2[j]; j++) dest[i+j]=src2[j]; dest[i+j]='\0';	手动实现，灵活性高，但代码繁琐，需手动处理字符串结束符 '\0'。
    Java	+ 操作符	String s = "Hello" + " " + "World";	编译时会优化为 StringBuilder，但循环中频繁使用仍有性能问题。
    	StringBuilder 类	StringBuilder sb = new StringBuilder(); sb.append("Hello"); sb.append(" "); sb.append("World"); String s = sb.toString();	推荐用于大量字符串拼接（性能最优），线程不安全（单线程场景）。
    	StringBuffer 类	StringBuffer sb = new StringBuffer(); sb.append("Hello"); sb.append(" "); sb.append("World"); String s = sb.toString();	线程安全（多线程场景），但性能略低于 StringBuilder。
    	String.join() 方法	String s = String.join(" ", "Hello", "World");	Java 8+，适合连接多个字符串，参数为分隔符和可迭代对象/数组。
    MATLAB	[] 方括号	s = ['Hello' ' ' 'World'];	直接拼接字符数组，要求所有输入为字符数组（char 类型），结果为字符数组。
    	strcat() 函数	s = strcat('Hello', ' ', 'World');	输入可以是字符数组或字符串数组（string 类型），自动处理空格，结果为字符串数组（string）。
    	join() 函数	s = join(["Hello", "World"], " ");	MATLAB R2016b+，输入必须是字符串数组（string），使用分隔符连接。
    	sprintf() 函数	s = sprintf('%s %s', 'Hello', 'World');	通过格式化字符串生成新字符串，功能类似 C 语言的 sprintf()。

62. 程序运行顺序（主要是程序中子函数的摆放位置）

63. 标识符
    标识符的规则对于这几种语言都是类似的，有一个通用规则，不同语言可能会略有差异

64. 通用规则：
65. 允许使用 字母（A-Z, a-z）、数字（0-9）和下划线（_），且不能以数字开头。
66. 区分大小写
67. 不能是关键字，例如：if else for while…等
68. 差异：
69. python
70. 支持 Unicode 字符（Python 3+），即支持中文：

    尝试 = 'aaa'
    print(尝试)
    

71. 特殊前缀约定：
72. _single_leading_underscore：表示内部使用（弱私有）。
73. __double_leading_underscore：类私有成员（名称会被 mangled）。
74. __magic__：特殊方法或变量（如 init）
75. C
76. java
77. matlab
    允许 $ 符号

    my$Var = 10;  # 合法（但不推荐）
    

78. 字符串操作
    python中针对字符串的常见操作

79. 一、字符串创建与基本操作

    操作	示例代码	说明
    单/双引号创建	s1 = 'hello' s2 = "world"	单双引号等效，可嵌套使用（如 'She said "Hi"'）。
    三引号多行字符串	s = """line1<br>line2<br>line3"""	保留换行符，常用于文档字符串或 SQL 语句。
    转义字符	s = 'a\nb\tc'	\n（换行）、\t（制表符）、\'（单引号）等。
    原始字符串	s = r'C:\path\to\file'	忽略转义，r 前缀后的反斜杠直接作为字符。

80. 二、字符串拼接与格式化

    操作	示例代码	说明
    + 操作符	s = "Hello" + " " + "World"	连接多个字符串，生成新对象（频繁使用效率低）。
    join() 方法	s = " ".join(["Hello", "World"])	用分隔符连接可迭代对象中的字符串（性能最优）。
    f-strings（3.6+）	name = "Alice"; s = f"Hello, {name}!"	推荐格式化方式，支持表达式嵌入（如 f"{2+2}"）。
    % 格式化	s = "Hello, %s!" % "Alice"	旧版格式化，兼容性好。
    format() 方法	s = "Hello, {0}! Age: {1}".format("Bob", 25)	通用格式化，支持位置/关键字参数。

81. 三、字符串访问与切片

    操作	示例代码	说明
    索引访问	s = "hello"; print(s[0])	输出：h（索引从 0 开始）。
    负索引	s = "hello"; print(s[-1])	输出：o（-1 表示最后一个字符）。
    切片 [start:stop:step]	s = "hello"; print(s[1:3])	输出：el（截取索引 1 到 2 的字符，左闭右开）。
    逆序字符串	s = "hello"; print(s[::-1])	输出：olleh（步长为 -1 表示逆序）。

82. 四、字符串查找与替换

    操作	示例代码	说明
    in 操作符	"lo" in "hello"	返回 True（判断子串是否存在）。
    find() 方法	s = "hello"; print(s.find("ll"))	输出：2（返回首次出现的索引，不存在返回 -1）。
    index() 方法	s = "hello"; print(s.index("ll"))	输出：2（不存在则抛出 ValueError）。
    count() 方法	s = "hello"; print(s.count("l"))	输出：2（统计子串出现次数）。
    replace() 方法	s = "hello"; print(s.replace("l", "L"))	输出：heLLo（替换所有匹配项）。
    re 模块（正则）	import re; re.search(r'\d+', "a123b").group()	输出：123（用正则表达式查找匹配项）。

83. 五、字符串大小写转换

    操作	示例代码	说明
    upper()	"hello".upper()	输出：HELLO（全大写）。
    lower()	"HELLO".lower()	输出：hello（全小写）。
    title()	"hello world".title()	输出：Hello World（每个单词首字母大写）。
    capitalize()	"hello".capitalize()	输出：Hello（首字母大写，其余小写）。
    swapcase()	"Hello".swapcase()	输出：hELLO（大小写互换）。

84. 六、字符串分割与合并

    操作	示例代码	说明
    split() 方法	"a,b,c".split(",")	输出：['a', 'b', 'c']（按分隔符分割字符串为列表）。
    rsplit() 方法	"a,b,c".rsplit(",", 1)	输出：['a,b', 'c']（从右侧开始分割，最多分割 1 次）。
    splitlines()	"a\nb\nc".splitlines()	输出：['a', 'b', 'c']（按换行符分割）。
    join() 方法	" ".join(["Hello", "World"])	输出："Hello World"（用分隔符连接列表元素）。

85. 七、字符串修剪与填充

    操作	示例代码	说明
    strip()	" hello ".strip()	输出："hello"（去除两侧空白字符）。
    lstrip()	" hello".lstrip()	输出："hello"（去除左侧空白字符）。
    rstrip()	"hello ".rstrip()	输出："hello"（去除右侧空白字符）。
    ljust(width)	"hello".ljust(10)	输出："hello "（左对齐，右侧补空格至宽度 10）。
    rjust(width)	"hello".rjust(10)	输出：" hello"（右对齐，左侧补空格至宽度 10）。
    center(width)	"hello".center(10)	输出：" hello "（居中对齐，两侧补空格至宽度 10）。
    zfill(width)	"5".zfill(3)	输出："005"（左侧补零至宽度 3）。

86. 八、字符串判断与检查

    操作	示例代码	返回值说明
    startswith(prefix)	"hello".startswith("he")	True（是否以 he 开头）。
    endswith(suffix)	"hello".endswith("lo")	True（是否以 lo 结尾）。
    isalpha()	"abc".isalpha()	True（是否全为字母）。
    isdigit()	"123".isdigit()	True（是否全为数字）。
    isalnum()	"abc123".isalnum()	True（是否全为字母或数字）。
    isspace()	" ".isspace()	True（是否全为空白字符）。
    isupper()	"ABC".isupper()	True（是否全为大写）。
    islower()	"abc".islower()	True（是否全为小写）。

87. 九、字符串编码与解码

    操作	示例代码	说明
    encode(encoding)	"你好".encode("utf-8")	输出：b'\xe4\xbd\xa0\xe5\xa5\xbd'（转为 UTF-8 字节）。
    decode(encoding)	b'\xe4\xbd\xa0'.decode("utf-8")	输出："你"（从字节解码为字符串）。

88. 十、其他常用操作

    操作	示例代码	说明
    len() 函数	len("hello")	输出：5（字符串长度）。
    ord() 函数	ord("A")	输出：65（字符的 Unicode 码点）。
    chr() 函数	chr(65)	输出："A"（从码点生成字符）。
    max()/min()	max("hello")	输出："o"（按 Unicode 顺序比较）。

总结

Python 字符串操作丰富且灵活，涵盖了创建、拼接、格式化、查找、替换、分割、大小写转换等多个方面。熟练掌握这些操作是处理文本数据的基础。建议优先使用 f-strings 和 join() 方法，以提高代码可读性和性能。
16. 占位符
|符号|用途|
|:—–😐:—–😐
|%d| 整数 |
|%4d| 整数（4位整数，超过4位正常显示，不足4位前方用空格补齐） |
|%f| 浮点数(默认小数点后6位) |
|%e| 科学计数法 |
|%s| 字符串|
|%c| 字符（单字符）|
|%.2f| 保留两位小数的浮点数|
– Python
python name = "Alice" age = 30 print("你好，我是%s，今年%d岁。" % (name, age))
– Java
java String name = "Alice"; int age = 30; System.out.printf("你好，我是%s，今年%d岁。", name, age);
– C
C char name[] = "Alice"; int age = 30; sprintf("你好，我是%s，今年%d岁。", name, age);
– matlab
matlab name = "Alice"; age = 30; fprintf("你好，我是%s，今年%d岁。", name, age);

17. 不等于 符号

    编程语言	不等于符号	示例表达式	表达式含义
    Python	!=	a != b	a不等于b时返回True
    C	!=	a != b	a不等于b时返回1（真）
    Java	!=	a != b	a不等于b时返回true
    MATLAB	~=	a ~= b 或 ne(a,b)	a不等于b时返回logical 1（真）

18. 逻辑运算符 与或非

    编程语言	与（AND）	或（OR）	非（NOT）	备注
    Python	and	or	not	– 逻辑运算符操作布尔值 – 支持短路计算（and 遇 False 即停，or 遇 True 即停）
    C	&&	||	!	– 操作整数（0 为假，非 0 为真） – 短路计算
    Java	&&	||	!	– 操作布尔类型（boolean） – 短路计算 – 非短路版本：&、|（不推荐）
    MATLAB	&&	||	~ 或 not	– 短路版本（标量运算）：&&、|| – 非短路版本（数组运算）：&、|、~

    短路运算是编程语言中一种逻辑优化机制，用于在逻辑表达式中提前确定结果，从而避免不必要的计算。核心规则：

19. 与运算（AND）：如果第一个操作数为 假，则整个表达式必为假，直接返回结果，不计算第二个操作数。
20. 或运算（OR）：如果第一个操作数为 真，则整个表达式必为真，直接返回结果，不计算第二个操作数。

操作	Python	C	Java	MATLAB
与	a and b	a && b	a && b	a && b （标量）
或	a or b	a || b	a || b	a || b （标量）
非	not a	!a	!a	~a 或 not(a)

21. 单/双/三 目运算符
    在 Python 中，运算符根据操作数的数量可分为 单目运算符、双目运算符 和 三目运算符（条件表达式）。

22. 单目运算符（Unary Operators）
    只需要 一个操作数 的运算符，用于执行基本的算术或逻辑操作。
    | 运算符 | 作用 | 示例 |
    |——–|———————-|——————–|
    | - | 取负（数值取反） | x = -5 |
    | + | 数值不变（极少使用） | x = +5 |
    | not | 逻辑非 | result = not True |
    | ~ | 按位取反 | x = ~5（二进制取反） |
    | len()| 计算长度（函数形式） | n = len([1,2,3]) |
    | abs()| 取绝对值（函数形式） | x = abs(-5) |

23. 双目运算符（Binary Operators）
    需要 两个操作数 的运算符，是最常见的运算符类型。
    | 类别 | 运算符 | 示例 |
    |————|———————–|——————-|
    | 算术运算 | +, -, *, /, //, %, ** | a + b, a ** b |
    | 比较运算 | ==, !=, >, <, >=, <= | a == b |
    | 逻辑运算 | and, or | a and b |
    | 位运算 | &, \|, ^, <<, >> | a & b（按位与） |
    | 赋值运算 | =, +=, -=, *=, /=, %=, etc. | a += 1 |
    | 成员运算 | in, not in | x in [1,2,3] |
    | 身份运算 | is, is not | a is b |

24. 三目运算符（条件表达式）
    需要 三个操作数 的运算符，Python 中使用 条件表达式 实现。

    value_if_true if condition else value_if_false
    

    先判断 condition 的真假；如果为 True，返回 value_if_true；如果为 False，返回 value_if_false。

    x = 10
    result = "偶数" if x % 2 == 0 else "奇数"
    print(result)  # 输出: 偶数
    
    # 等价于传统的 if-else 结构
    if x % 2 == 0:
        result = "偶数"
    else:
        result = "奇数"
    
    # 嵌套形式
    age = 20
    status = "成年人" if age >= 18 else "未成年人" if age < 10 else "青少年"
    print(status)  # 输出: 成年人
    

注意事项：

25. Python 没有 C 风格的三目运算符：

26. C/Java 中的三目运算符：condition ? value1 : value2
27. Python 使用 value1 if condition else value2 替代。

28. 运算符优先级：

29. 单目运算符优先级通常高于双目运算符（如 -5 + 3 先计算 -5）。
30. 三目运算符优先级较低，需注意括号的使用（如 (a if cond else b) + c）。

作者：~夕上林~