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
   	stdlib.h（标准库）	#include
   	string.h（字符串处理）	#include
   	math.h（数学函数）	#include
   	time.h（时间处理）	#include
   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个空格（非强制）

   • 差异

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

   • 示例对比（条件语句）：

     • 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块")  # 错误！缩进不一致
       

     • 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;  // 这行始终会执行！
       

     • 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;  // 这行始终会执行！
       

     • 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
       

4. 数据类型

   语言	整型	浮点型	布尔型	复数型	字符串类型	特殊类型
   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（特殊数值）

   • 动态类型 vs 静态类型

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

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

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

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

   • 整型范围与精度

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

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

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

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

   • 字符串处理

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

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

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

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

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

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

   • 复数支持

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

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

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

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

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

   • 布尔类型

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

       flag = True
       

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

       #include 
       bool flag = true;
       

5. 变量初始化

   • 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)
     

   • 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";
     

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

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

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

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

6. input输入

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

   • 差异

     • 类型处理

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

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

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

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

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

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

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

     • 读取整行 vs 单个元素

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

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

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

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

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

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

     • 输入缓冲区处理

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

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

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

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

   • 示例对比

     • 读取姓名和年龄

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

       // C
       #include 
       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);
       

     • 读取多个数值

       # 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);
       

7. 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()（日志记录）

   • 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）
     

   • C

     #include 
     
     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;
     }
     

   • 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();
             }
         }
     }
     

   • 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'
     

8. 虚拟环境 / 环境配置

9. 函数输入输出个数

10. main

11. 运行方式

12. 字符串连接

    语言	方法/操作符	示例代码	特点与注意事项
    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()。

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

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

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

          尝试 = 'aaa'
          print(尝试)
          

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

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

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

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

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

    • 二、字符串拼接与格式化

      操作	示例代码	说明
      + 操作符	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)	通用格式化，支持位置/关键字参数。

    • 三、字符串访问与切片

      操作	示例代码	说明
      索引访问	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 表示逆序）。

    • 四、字符串查找与替换

      操作	示例代码	说明
      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（用正则表达式查找匹配项）。

    • 五、字符串大小写转换

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

    • 六、字符串分割与合并

      操作	示例代码	说明
      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"（用分隔符连接列表元素）。

    • 七、字符串修剪与填充

      操作	示例代码	说明
      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）。

    • 八、字符串判断与检查

      操作	示例代码	返回值说明
      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（是否全为小写）。

    • 九、字符串编码与解码

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

    • 十、其他常用操作

      操作	示例代码	说明
      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	- 短路版本（标量运算）：&&、|| - 非短路版本（数组运算）：&、|、~

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

    • 与运算（AND）：如果第一个操作数为 假，则整个表达式必为假，直接返回结果，不计算第二个操作数。
    • 或运算（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)

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

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

    • 双目运算符（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 |

    • 三目运算符（条件表达式）
      需要 三个操作数 的运算符，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)  # 输出: 成年人
      

    注意事项：

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

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

    • 运算符优先级：

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