Python简单的自学笔记

split方法用于将一个字符串分割成多个小的子字符串，并返回一个列表

1
2
3
persons = "Mike Jerry Tom"
result = persons.split()  # 将字符串使用默认分隔符（空格）拆分成多个小的子字符串
print(result)  # 输出: ['Mike', 'Jerry', 'Tom']

python中字符类型的数字可以直接强转为int

1
2
3
data = input().split() # 将输入字符串根据空格进行分割，得到数据列表
res = int(data[0])+int(data[1]) # 拿到元素后，进行数据类型转换，累加后赋值给变量res
print(res)

try代码块中的代码会被尝试执行，如果没有发生错误，则正常执行，否则就会由except捕获异常并执行异常处理代码

1
2
3
4
5
6
while True:
    try:
    # 尝试执行这里的程序
    except:
    # 捕获异常，执行异常处理代码
        break

多重赋值：

1
2
3
4
5
6
7
8
# 1. 多个变量同时赋相同的值
a = b = c = 42  # 变量 a、b 和 c都被赋予了相同的值 

# 2. 多个变量同时赋不同的值
x, y, z = 1, 2, 3 # 变量 x 被赋值为1，变量 y 被赋值为2，变量 z 被赋值为3

# 3. 还可以使用多重赋值获取列表中的值。
a, b = [1, 2] # 将列表中的元素按照顺序赋给 a 和 b，a 的值为 1，b 的值为 2。

range函数：生成一个数列，用法：

1
2
3
range(stop)
range(start, stop)
range(start, stop, step)

均为左闭右开

val只要是非零数值、非空字符串、非空列表等，就判断为True，否则为False

Python的逻辑运算符：and or not

三目运算符：

1
语句1 if 条件表达式 else 语句2

算术运算符

1
2
3
4
5
6
7
a = 10 - 5  # 减法运算，将10减去5，结果为5
a = 10 + 5	# 加法运算，将10和5相加，结果为15
a = 5 * 5		# 乘法运算，将5和5相乘，结果为25
a = 10 / 5	# 除法运算，将10除以5，结果为2.0，Python3中，除法总是返回浮点数，即便结果是整数
a = 5 // 2 	# 整数除法运算，将5除以2，结果为2（只保留整数部分）
a = 2 ** 2	# 幂运算，2的2次方，即2^2，结果为4
a = 10 % 4  # 取余数运算，将10除以4，返回余数，即2

[!TIP]

⚠️ 在Python3中，除法总是返回浮点数

sum函数：

1
sum(列表，初始值)

比如

1
2
3
numbers = [1, 2, 3, 4, 5]
total = sum(numbers)
print(total)  # 输出 15，因为 1 + 2 + 3 + 4 + 5 = 15

map()函数：可以将一个函数应用到序列的每个元素，并返回一个包含结果的新序列的迭代器。

常用于Python中的列表操作，可以将一个函数应用到序列的每个元素，并返回一个包含结果的新序列

1
map(function, list)

例子如下

1
2
3
4
5
string_numbers = ["1", "2", "3", "4", "5"]

# 使用 map(int, list) 将列表中的所有字符串元素全都转换成整数
# 再在外面加一层list(), 使用list()方法将map的返回结果转为列表
int_numbers = list(map(int, string_numbers))

常用的数学运算 

1
2
3
4
5
abs(x)
max(x,y,z, ...)
min(x,y,z, ...)
pow(x,y) #返回x的y次方
round(x) #四舍五入

下面这些，需要import math

  • math.ceil(x): 返回一个大于或等于 x 的最小整数。
  • math.floor(x): 向下取整，返回一个比 x 小的最大整数。
  • math.pow(x, y): 返回 x 的 y 次方, math模块会把参数转换成浮点数。
  • math.sqrt(x): 返回 x 的平方根

列表：

在Python中，使用列表替换了数组，相比于数组，列表更加灵活，它也用于存储一组有序的元素，但是列表可以包含各种不同类型的元素，包括整数、浮点数、字符串、甚至可以是其他列表，而且列表的长度是可变的，你可以根据需要向列表中添加或删除元素，从而改变列表的长度。

常见操作：

  1. 创建列表：使用方括号 []或使用 list() 创建一个列表。

    [!TIP]

    list()函数可以将其他可迭代对象转换成列表，比如字符串。

    1
    2
    3
    4
    5
    my_list = [1, 2, 3, 4, 5]
    my_list = list()

    my_str= = "hello"
    str_list = list(my_str)

  2. 访问列表元素：使用索引来访问列表中的元素

    1
    2
    my_list = [1, 2, 3, 4, 5]
    first_element = my_list[0]

  3. 修改列表元素：直接赋值

  4. 列表长度：len()函数

  5. append()：将新的元素添加到列表的末尾

  6. insert(index, value)，在指定位置处插入元素

    1
    2
    my_list = [1, 2, 3, 4, 5]
    my_list.insert(0, 6) # [6, 1 ,2 3, 4, 5]

  7. remove(value): 移除值为value的元素，但是如果有多个时，只删除第一个。

  8. pop(index): 删除并返回指定索引index位置的元素。

    1
    2
    my_list = [1, 2, 3, 4, 5]
    popped_element = my_list.pop(1)  # 删除并返回索引1处的元素,现在是 [1, 3, 4, 5] popped_element 是 2

  9. index(value): 返回指定值value的索引位置, 如果有多个时，返回第一个。

  10. sort()

  11. reverse()

  12. 列表+列表 表示列表的拼接

    比如[1, 2, 3] + [4, 5, 6] == [1, 2, 3, 4, 5, 6]

切片：是对列表的一个连续片段的引用

1
my_list(startIndex: endIndex: step)

注意endIndex是开区间

  • 如果开始位置和结束位置都传递，表示从切片的startIndex位置切到endIndex所在的位置
  • 如果不传递开始位置，即list[ : endIndex]，表示从列表的开头切到endIndex所在的位置
  • 如果不传递结束位置，即list[startIndex : ],表明从列表的startIndex位置切到末尾
  • 如果开始位置和结束位置都不传递，即list[ : ], 表明从列表的开头切到末尾，相当于整个列表。

也可以使用负数索引：-1 表示最后一个元素，-2表示倒数第二个元素，依次类推。

给list进行初始化的例子：

dp = [[0] * (bagweight + 1) for _ in range(n)]

  1. [0] * (bagweight + 1)
    • 生成一个长度为 bagweight + 1 的列表
    • 元素全是 0
    • 例如 bagweight = 4 → [0, 0, 0, 0, 0]
  2. for _ in range(n)
    • 循环 n 次，通常代表 DP 的行数（比如 n 个物品）
    • _ 表示循环变量不使用
  3. [ ... for _ in range(n)]
    • 外层列表推导式
    • 每次循环都生成一个独立的 [0]*(bagweight+1) 列表
    • 最终得到一个 n×(bagweight+1) 的二维列表

倒序输出数组：

1
2
3
# 倒序输出元素，每个数之间用空格分隔
for i in range(n - 1, -1, -1):
    print(nums[i], end=" ")

隔位输出

1
2
3
4
# 遍历顺序从0 到 n(不包括n), 步长为 2
for i in range(0, n, 2):
      # 输出元素和空格
    print(nums[i], end=" ")

序列分为列表、元组、字符串

  • 列表：由方括号 [] 包裹起来，元素与元素之间用逗号 , 分隔。列表是可变的，可以进行增加、删除和修改操作。
  • 元组：由圆括号 () 包裹起来，元素与元素之间用逗号 , 分隔。元组是不可变的，一旦创建后，其元素不可更改。
  • 字符串：由引号（单引号或者双引号）包裹起来的字符集合，元素是字符，字符串也是不可变的。

字符串的一些操作

1
2
3
my_str  = "Hello, World!"

length = len(my_str)
  • split(): 将字符串分割成子字符串并返回一个列表，默认情况下，使用空格作为分隔符。
  • join(): 将列表中的字符串连接成一个新的字符串，你可以指定连接符号，比如下面的示例。
1
2
3
persons = ["tom", "jerry", "mike"]
text = " ".join(persons)
# 将列表中的字符串以空格连接在一起，相当于split的反向操作，"tom jerry mike"
  • replace(): 用于替换字符串中的指定子字符串。
1
2
str1 = "Hello, World!"
str2 = str1.replace("World", "Python")  # 替换 "World" 为 "Python"

在print()中控制格式，可以使用format() 方法

format()方法通常用于字符串中的占位符替换，占位符通常用花括号 {} 表示。你可以将占位符插入到字符串中，然后使用 format() 方法来将实际值插入这些占位符。

1
2
3
4
number = 3.1415926
# {}是一个占位符，输出结果时会将format()参数里的内容替换在{}中，:.2f 表示保留两位小数
formatted_number = "{:.2f}".format(number)
print(formatted_number)

字符串格式化输出

在Python中，可以使用字符串格式化来将值插入到字符串中，从而实现特定格式的输出，字符串格式化有多种方式：

  • 使用%操作符进行格式化
1
2
3
4
5
name = "张三"
age = 20

formatted_string = "姓名：%s， 年龄：%d " % (name, age)
print(formatted_string)

使用%会将后面的变量name, age一一对应插入到对应的占位符上，其中%s表示字符串，%d表示整数, %f表示浮点数。

  • 字符串format()方法

format()方法允许使用占位符{}来插入值，并使用format()方法的参数来提供要插入的值，和上面的操作符很类似。

1
2
3
4
5
name = "张三"
age = 20

formatted_string = "姓名：{}, 年龄：{}".format(name, age)
print(formatted_string)
  • f-字符串

Python3.6及以上的版本支持f-string, 以f开头，后面跟着字符串，字符串中的表达式用大括号 {} 包起来，它会将变量或表达式计算后的值替换进去。

1
2
3
4
5
name = "张三"
age = 20

formatted_string = f"姓名: {name},年龄：{age}"
print(formatted_string)

islower()：检查字符串中的字符是否都是小写字母

isupper()：同理

upper()：把字符串中所有字符转换为大写字母。lower()同理

函数

1
2
def 函数名(形参列表):
      函数体

比如：

1
2
3
4
5
def max(a,b):
    if (a>b):
        return a
    else:
        return b

一个将小写字母转成大写字母的函数：

1
2
3
4
def changeChar(a):
    if 'a'<=a<='z':
        a=chr(ord(a)-32)
    return a

你问的这个 -> int 是 Python 中的 类型注解（type hint），表示这个函数的返回值类型是 int，即返回一个整数。

✅ 完整解释：

1
2
3
4
5
python


复制编辑
def maxVowels(self, s: str, k: int) -> int:

这里的语法是 Python 的 函数签名注解，逐部分解释如下：

部分 含义
self 表示这个函数是类的方法，第一个参数是对象自身（只能在类中定义）
s: str 表示参数 s 是一个字符串
k: int 表示参数 k 是一个整数
-> int 表示这个函数最终返回一个整数（return 的值是 int 类型）

🔁 举个对比例子：

1
2
python复制编辑def add(a: int, b: int) -> int:
    return a + b

表示 add 是一个接受两个整数并返回一个整数的函数。

等价于 Java 中的：

1
2
3
java复制编辑int add(int a, int b) {
    return a + b;
}

⚠️ 注意事项：

  • 类型注解不会强制执行类型检查（解释器不报错），但可以被静态检查工具使用，如 mypy、pyright、VSCode 提示等。
  • 也可以写更复杂的类型，比如 List[str], Optional[int], Dict[str, int]，需要导入 typing。

🧠 总结：

语法 含义
参数名: 类型 注解参数类型
-> 返回类型 注解函数的返回值类型
不强制类型检查 靠工具或开发者自行维护

是的，Python 中变量也可以使用类型注解，就像函数参数一样。这就是 Python 的 类型提示（Type Hints） 的一部分，虽然解释器不会强制检查，但它对你、IDE 和静态检查工具（如 mypy, pyright）都有很大帮助。

✅ 变量类型注解的基本语法：

1
2
3
4
5
python


复制编辑
变量名: 类型 = 值

🧪 示例：

1
2
3
4
python复制编辑name: str = "Alice"
age: int = 30
price: float = 99.99
is_valid: bool = True

🧠 也可以只标注类型，不赋值：

1
2
3
4
5
python


复制编辑
data: list[int]

此时 data 只是被声明了类型，但还未赋值。

元组

元组也是一种序列，元组是一种不可变的结构，除此之外，它的使用几乎和列表类似。

创建元组tuple很简单，只需要在括号中添加元素，元素与元素之间使用逗号分隔。

[!TIP]

需要注意的一点是，元组中只有一个元素时，需要在元素后面添加逗号，即(1,)。

元组拆包是指将元组中的元素分别赋值给多个变量的过程，听起来很不知所云，但是示例却十分简单。

1
2
3
my_tuple = (1,2,3)
# 使用元组拆包将元组的元素分配给多个变量
a, b ,c  = my_tuple

在上面的操作中，我们使用元组拆包将元组中的每个元素分别赋值给变量 a、b 和 c，这样就可以快速访问元组中的元素。

所以a, b = b,a这种操作实际上是将，b 和 a 的值构成一个元组 (b, a)，然后使用元组解构("拆包")将这个元组中的值分别赋给 a 和 b，这样就完成了交换。

类

在类的代码块中，我们可以定义变量和函数，在类中所定义的变量，将会成为所有的实例的属性，所有实例都可以访问这些变量，在类中也可以定义函数（被称之方法），类的所有实例也可以访问这些方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Person:
    # 类中定义一个变量name, 会成为所有实例的公共属性
    name = "Tom"
    # 类中也可以定义函数，称之为方法，方法也可以通过该类的实例来访问
    def say_hello(self):
        print("Hello")
        
# 创建Person的实例    
person1 = Person()
person2 = Person()

# 实例可以调用属性
person1.name = "Jerry"
person2.name = "Mike"

# 实例可以调用方法
person1.say_hello()
person2.say_hello()

类的初始化函数：

1
2
3
4
5
class 类名:
    # 公共属性
    # init方法
    def __init__(self, 其他参数):
        # self表示实例本身，即实例.name属性 = 传递的name值

使用数组作为哈希表

统计字符串中出现最多的字母

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
n=int(input())
for _ in range(n):
    s=input()
    # 创建一个 长度为26，元素都为0的列表
    temp=[0]*26
    for c in s:
        temp[ord(c)-ord('a')]+=1
    maxFreq=0
    maxFreqChar=0
    for i in range(26):
        if temp[i]>maxFreq:
            maxFreq=temp[i]
            maxFreqChar=i
    print(chr(maxFreqChar+ord('a')))

set

在Python中，可以使用大括号{}创建集合

1
2
# 创建集合
my_set = {1, 2, 3}

或者你可以使用set()函数创建集合，或者是列表转为集合。

1
2
3
my_set1 = set([1, 2, 3])
# 创建空集合
my_set2 = set()

集合最常见的用法是判断某个元素是否在集合中和去除集合中的重复元素。

判断某个元素是否在集合中可以使用in关键字

1
2
3
4
5
6
7
8
my_set = {"Tom", "Jerry", "Mike"}
# 判断元素是否在集合中
if "Tom" in my_set:
  
# 集合用于存储一组不重复的元素，可以自动去重
my_list = [1, 2, 3, 3, 4, 5, 5]
my_set = set(my_list)  # 将列表转换为集合，去除重复元素
unique_list = list(my_set)  # 将集合转换回列表, 此时列表是[1,2,3,4,5]

类似于数学中的操作，集合还支持求并集、交集、差集。

1
2
3
4
5
set1 = {1, 2, 3}
set2 = {3, 4, 5}
u_set = set1 | set2  # 并集，现在集合是{1, 2, 3, 4, 5}
i_set = set1 & set2  # 交集, 现在集合是 {3}
d_set = set1 - set2  # 差集, 表示存在于集合1中，但不存在于集合2中的元素，{1, 2}

除了以上两种常见的操作，set还提供了一些常见方法方便使用，主要包括的就是集合的增删和遍历操作。

  1. 添加元素：使用add()方法可以向集合中添加单个元素。
  2. 移除元素：使用remove()或者discard()方法可以从集合中移除指定元素， 它们之间的区别在于当移除一个集合中不存在的元素时，remove()会引起异常，而discard()不会。
  3. 集合长度：使用len()函数可以获取集合的元素个数。
  4. 清空集合：使用clear()方法可以清空集合中的所有元素。
  5. 遍历集合：使用for循环可以遍历集合中的元素。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 创建集合
set1 = {1, 2, 3}

# 向集合添加元素
set1.add(4)

# 遍历集合
for element in set1:
      print(element)
    
# 移除集合元素
set1.remove(3)

# 获取集合长度
print(len(set1))

# 清空集合中的元素
set1.clear()

map / dict

在Python中，通常用字典dict实现了映射这种数据结构。

字典也是使用{}来包裹，每个键值对用冒号:分隔，键值对与键值对之间用逗号,分隔，其具体格式如下：

1
2
3
4
5
my_dict = {
  "mike", 99,
  "tom": 98,
  "jerry": 100
}

字典中的键数据类型必须是不可变的(字符串、数字、元组等)， 但是值可以是任意的数据类型。

[!TIP]

注意：如果直接创建一个{}, 表示这是一个空字典，而并非一个空集合。

此外，也使用内置函数dict()创建字典，如果想要给字典添加键值对，可以直接通过dict[key] = value的形式。

1
2
3
4
5
6
7
8
9
10
11
# 创建一个空字典
my_dict = dict()
# 添加键值对
my_dict["mike"] = 99
my_dict["tom"] = 98
my_dict["jerry"] = 100

# 更新值
my_dict["mike"] = 100
# 访问值
print(my_dict["mike"]) # 100

如果想要删除字典中的键值对可以使用del()或者clear()方法

1
2
3
del my_dict["mike"] # 删除对应的键值对
my_dict.clear() # 清空字典
del my_dict # 删除字典

检查字典中的键是否存在也是使用in来判断， 如果键在字典中返回 true, 否则 返回 false。

字符串也可以这样判断是否是一个子字符串

1
2
3
4
if "mike" in my_dict:
      print(my_dict["mike"])
else:
      print("mike doesn't exist in the dictionary")

字典的遍历需要搭配使用for和dict.items(), items()方法返回了字典中的所有键值对的视图对象。这个视图对象可以用于迭代字典中的键值对。

1
2
for key, value in my_dict.items():
      print(f"Key: {key}, Value: {value}")

此外，还可以使用dict.keys()和dict.values()获取字典的所有键的视图对象和所有值的视图对象，视图对象可以通过list()转为列表。

栈

Python通常通过一个列表模拟来实现栈。

判断栈空：if not stack来实现，返回true则为空

1
2
3
4
5
6
7
8
9
10
11
12
13
stack = []  # 创建一个空栈

# 入栈
stack.append(1)
stack.append(2)
stack.append(3)

# 出栈
top_element = stack.pop()  # 弹出并返回栈顶元素
print(top_element)  # 输出 3

# 判断栈是否为空
if not stack:

队列

标准库中的queue模块提供了多种队列的实现，比如普通队列和优先级队列

因此可以使用queue.Queue类来创建队列，不过我们依旧可以使用列表来模拟队列的实现。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 导入queue模块
import queue

# 创建一个队列
q = queue.Queue()

# 通过put()实现入队操作
q.put(1)
q.put(2)
q.put(3)

# 通过get()实现出队操作
item = q.get()  # 出队并返回队列中的元素
print(item)  # 输出 1

使用列表来模拟：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
queue = []

# 入队操作
queue.append("Tom")
queue.append("Jerry")
queue.append("Mike")

# 出队操作
removed_person = queue.pop(0)  # 弹出并返回队列中的第一个元素

# 判断队列是否为空：
if not queue:
    print("队列为空")
else:
    print(f"队头元素: {queue[0]}")

继承

在对象中，总有一些操作是重复的，比如说Person类具有姓名、身高、年龄等特征，并具有一些行走、吃饭、睡觉的方法，而我们要实现一个Teacher类，Teacher首先也是一个人，他也基本人的特征和方法，那我们是不是也应该用代码去实现这些特征和方法呢，这就势必会产生一些重复的代码。

因此，我们可以采用“继承”的方式使得一个类获取到其他类中的属性和方法。在定义类时，可以在类名后的括号指定当前类的父类（超类), 子类可以直接继承父类中的所有属性和方法，从而避免编写重复性的代码，此外我们还可以对子类进行扩展。

假设，我们有一个图形类Shape, 它具有两个属性和一个方法，属性为颜色和类型，方法为求图形的面积

1
2
3
4
5
6
7
8
9
10
class Shape:
    # 包含颜色和类型两个属性
    def __init__(self, shape_type, color):
        self.type = shape_type
        self.color = color
    # 计算图形面积的方法
    def calculate_area(self):
        # pass表示空语句，不需要执行任何操作
        pass
shape = Shape('shape', 'white')

我们还需要一个关于圆的类，它继承自Shape类

1
2
3
4
5
6
7
8
9
10
11
12
# 传入Shape, 表示基础自Shape类
class Circle(Shape):
    def __init__(self, shape_type, color, radius):
        super().__init__(shape_type, color)
        self.radius = radius
    # 计算圆的面积
    def calculate_area(self):
        return 3.14 * self.radius * self.radius
      
circle = Circle('circle', 'white', 10)
# 计算圆的面积
circle.calculate_area()

在上面的示例代码中，图形类拥有两个属性和一个方法，圆的类在图形类的基础上添加了半径这个属性。

1
super().__init()

父类和子类中含有一些共同属性，在重写子类时，为了省略重复的代码，可以通过super()动态的获取当前类的父类, 并调用父类的__init__()方法从而初始化父类中定义的属性。

在子类和父类中都有calculate_area这个方法，这被称为方法的重写，子类会调用自己的方法而不是父类的方法。如果子类的对象调用一个方法，发现并没有提供这个方法，就会从当前对象的父类中寻找，如果父类中有则直接调用父类中的方法，如果还没有，就从父类的父类中寻找，就好像，当父亲和儿子都拥有一样东西，会优先使用自己的，如果发现自己没有，才会使用继承的方法。

多态

多态常常和继承紧密相连，它允许不同的对象对方法调用做出不同的响应。你可以使用基类定义通用的代码，然后在派生类中提供特定的实现，从而在调用方法时调用不同的方法，比如下面的示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
class Shape:
    # 基类的计算面积的方法
    def calculate_area(self):
        pass

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius
        # Circle类的计算面积的方法
    def calculate_area(self):
        return 3.14 * self.radius * self.radius

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height
        # Rectangle类的计算面积的方法
    def calculate_area(self):
        return self.width * self.height

# 创建不同类型的图形对象
circle = Circle(2)
rectangle = Rectangle(4, 3)

# 存放图形对象的列表
shapes = [circle, rectangle]

# 计算面积
for shape in shapes:
    # 列表中的每个元素都调用计算面积的方法
    area = shape.calculate_area()
    # 输出面积
    print(f"Area: {area:.2f}")

在上面的代码示例中，基类 Shape实现了calculate_area 方法, 两个派生类 Circle 和 Rectangle则是重写了 calculate_area 方法，它们有着不同的计算逻辑。之后我们创建了一个包含不同类型的图形对象的列表 shapes，然后循环遍历该列表并调用 calculate_area 方法，尽管方法名称相同，但实际调用的方法是根据对象的类型动态确定的，这其实就是多态的概念。

这是 Python 中非常常用的一种遍历写法，使用 enumerate() 来同时获得元素的索引和值。我们来逐步解释这句：

1
for i, x in enumerate(nums):

🧠 拆解解释：

部分 含义
nums 一个可迭代对象（如列表）
enumerate(nums) 把 nums 转换成 (索引, 元素) 组成的迭代器
for i, x in ... 同时获取每一项的索引 i 和元素值 x
程设
#算法 #Python
Python简单的自学笔记
http://example.com/2025/07/26/python自学/
作者
wendaining
发布于
2025年7月26日
许可协议