基础教程

python基础博主就不做教程分享了，因为博主水平非常有限，正如我在声明中说，我本职是财务（那咋办吧…）

这里推荐大家去B站上看，由尚硅谷录制的python基础，讲师是李立超（超哥无敌的好吧）。

链接直达

风格幽默风趣，节奏适中，适合基础入门，基本上涵盖了python的全部基础，博主就是看了超哥的视频入坑python

不过我建议小白可以尝试使用pychram，超哥教程中使用的是sublime，不过无伤大雅。

python基础数据结构与方法

这里总结一些python的常用数据结构以及对应的方法，可以自查：

(点击即可跳转相应标题)

• 字符串
• 列表
• 元祖
• 集合
• 字典

字符串

字符串就是一系列用单引号或双引号包裹的字符。例如：

name = "leon" #赋值name
age = '20' #赋值age
print(f'hello {name}')  # 输出 f 字符串

Python转义字符

在需要在字符中使用特殊字符时，需要用反斜杠 \ 进行转义。

# \t：在字符串中表示制表符。
print('Hello word')    #-> Hello word
print('Hello\tword')  # 使用制表符  ->Hello    word
 #\n：在字符串中表示换行符。
print('Hello\tword')  # 使用换行符
'''
->Hello
word
'''

字符串的常用方法

name = " Leon leon "
print(name)
#将每个单词的首字母都改为大写。
print(name.title())

#将字符串全部改为大写/小写。
print(name.upper())
print(name.lower())

#移除字符串右端/左端/两端的空白。
print(name.rstrip())
print(name.lstrip())
print(name.strip())

#移除字符串中指定的前缀/后缀。
print(name.removeprefix(" Leon "))
print(name.removesuffix(" leon "))

列表

列表是由一系列按特定顺序排列的元素组成的序列，使用方括号（包裹）表示，可以使用索引来访问其中的元素。

列表的创建：

#直接赋值一个列表
info = ["name","age","gender","stature"]

列表元素的访问：

#python中的列表访问很简单，你可以直接通过索引（索引开始为0）或者通过列表的切片来访问列表
info = ["name","age","gender","stature"]
#访问列表的第一个元素（索引开始是0）即：
print(f"info的第1个元素为：{info[0]}")
#访问列表的第2个元素（索引开始是0）即：
print(f"info的第一个元素为：{info[1]}")

也可以通过切片来或许列表的子序列，切片是将指定元素复制放入新生成的子序列中，它是创建一个新的序列而非关联。

切片包括三个参数(start_index、end_index、step)，即（起始下标，结束下标，步长（省略是默认值为1）），切片是左闭右开，即包含起始下标，不包含结束下标，例如：

info = ["name","age","gender","stature"]
#生成一个切片包括列表的前三项
new_info = info[0:3]
print(new_info)

num_list = [0,1,2,3,4,5,6,7,8,9,10,11,12,13]
#以步长为3截取列表的第2项（索引为1）到第10项（索引为9），左闭右开，即：
print(num_list[1:10:3])

列表的增、删、改、查：

上面是查找列表元素的方法，下面介绍增删改：

info = ["name","age","gender","stature"]

#列表增加元素
info.append("job") #添加到列表末尾
info.insert(0,"job")    #在列表指定位置添加，第一个参数是索引

#列表删除元素
#pop
pop_info =  info.pop(0)  #通过索引删除元素，并返回删除的元素，参数为索引，默认为末尾的元素
print(f"删除的元素为：{pop_info}")
#del
del info[0]  #利用del删除对应索引的元素，无返回值
#remove
info.remove("age") #删除列表中匹配到的第一个指定元素，删除第一个元素"name"

#修改列表
#在python的列表中，可以直接通过索引修改对应位置的元素，例如
info[1] = 20   #修改列表第二项的值为20（整型）,这里注意，python允许不同数据类型的数据出现在同一列表中

#列表常用的其他方法
lst.sort()      #永久修改原列表，对其中的元素进行排序；
lst.reverse()   #永久修改原列表，对其中的元素进行翻转；
sorted(lst)     #返回排序后的列表的副本；
len(lst)        #获取列表的元素个数；
lst.extend(lst_2)	#在列表末尾添加多个值，使用extend()函数，seq是一个可迭代对象，否则报错；
lst.clear()     #清除列表；
lst.index("name",start = 0,end =-1)  #查找元素第一次出现的位置，左开右闭。

元祖

元组（tuple）是Python中另一种内置的数据类型，它与列表类似，都是用来存储一系列有序的元素。但不同于列表的是，元组一旦创建后就不能修改，也就是说元组是不可变序列。

# 创建一个元组
person = ("Alice", 25, "Female")

# 元组也可以使用圆括号和逗号来定义
empty_tuple = ()
single_element_tuple = ("only",) # 注意末尾的逗号，表示这是一个元组而不是字符串

# 访问元组中的元素
print(f"姓名：{person[0]}") # 输出元组的第一个元素
print(f"年龄：{person[1]}") # 输出元组的第二个元素

# 使用切片访问元组中的子序列
print(person[0:2]) # 输出('Alice', 25)

由于元组是不可变的，所以不能直接在元组上执行添加、删除或修改操作。但是可以通过将元组转换为列表，进行相应操作后再转换回元组：

# 修改元组
temp_list = list(person) # 将元组转换为列表
temp_list[1] = 26        # 修改列表中的元素
person = tuple(temp_list) # 再将列表转换回元组

# 添加到元组
temp_list.append("Engineer") # 在列表中添加新元素
person = tuple(temp_list)    # 转换回元组

# 删除元组元素
temp_list.remove("Female")   # 从列表中移除元素
person = tuple(temp_list)    # 转换回元组

元组还支持一些常用的方法，虽然由于其不可变性，这些方法的数量比列表少：

# 元组的常用方法
person.count("Alice")      # 统计元组中某个元素出现的次数
person.index("Female")     # 查找元素第一次出现的位置
len(person)                # 获取元组的元素个数

元组通常用于保存不应该被改变的数据集合，或者作为字典中的键（因为字典的键必须是不可变类型），以及函数返回多个值时。

集合

集合（set）是Python中的一种无序且不重复元素的集合数据类型。它类似于数学中的集合概念，支持成员关系测试、去重功能、以及交集、并集、差集等集合运算。

# 创建集合
# 使用花括号{}或set()函数创建集合
fruits = {"apple", "banana", "cherry"}
empty_set = set()  # 创建一个空集合，注意：{}将创建一个空字典

# 集合添加元素
fruits.add("orange")   # 添加单个元素
fruits.update(["pear", "grape"])  # 添加多个元素，参数为可迭代对象

# 集合删除元素
fruits.remove("banana")  # 如果元素不存在则会抛出KeyError异常
fruits.discard("banana") # 如果元素不存在也不会报错
popped_fruit = fruits.pop()       # 随机移除一个元素，并返回该元素
fruits.clear()                    # 清空集合

# 访问集合中的元素
# 由于集合是无序的，因此不能通过索引访问元素，但可以通过for循环遍历集合
for fruit in fruits:
    print(fruit)

# 检查成员资格
print("apple" in fruits)  # 输出True或False

# 集合运算
set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}

# 并集
union_set = set1.union(set2)      # 或者使用 | 运算符：set1 | set2
print(union_set)                  # 输出 {1, 2, 3, 4, 5, 6}

# 交集
intersection_set = set1.intersection(set2)  # 或者使用 & 运算符：set1 & set2
print(intersection_set)                      # 输出 {3, 4}

# 差集
difference_set = set1.difference(set2)       # 或者使用 - 运算符：set1 - set2
print(difference_set)                        # 输出 {1, 2}

# 对称差集（异或）
symmetric_difference_set = set1.symmetric_difference(set2)  # 或者使用 ^ 运算符：set1 ^ set2
print(symmetric_difference_set)                              # 输出 {1, 2, 5, 6}

# 子集和超集检查
subset_check = set1.issubset(set2)        # 检查set1是否是set2的子集
superset_check = set1.issuperset(set2)    # 检查set1是否是set2的超集
print(subset_check, superset_check)       # 根据实际情况输出True或False

集合非常适合用来去除重复项、进行数学集合运算，比如求两个列表的共同元素（交集）、合并两个列表（并集），或者找出在一个列表中而不在另一个列表中的元素（差集）。此外，因为集合内部的查找效率非常高，所以当需要频繁地查询某个值是否存在于集合中时，使用集合是一个不错的选择。

字典

字典（dictionary）是Python中的一种数据类型，它是一个无序的、可变的键值对集合。每个键值对由一个键和一个关联的值组成，其中键必须是唯一的且不可变（如字符串、数字或元组），而值可以是任意类型的对象。

# 创建字典
# 使用花括号{}和冒号分隔键和值来创建字典
person = {
    "name": "Alice",
    "age": 25,
    "gender": "Female"
}

# 或者使用dict()构造函数创建字典
empty_dict = dict()

# 通过键访问字典中的值
print(person["name"])  # 输出 "Alice"

# 使用get()方法访问键对应的值，如果键不存在则返回None或指定的默认值
print(person.get("height", "未知"))  # 如果没有"height"这个键，则输出"未知"

字典键值对的增删改查：

# 添加新的键值对
person["job"] = "Engineer"  # 直接赋值添加新的键值对

# 修改现有键对应的值
person["age"] = 26  # 更新已有的键值对

# 删除键值对
del person["gender"]  # 使用del语句删除键值对
removed_value = person.pop("age")  # pop()方法移除键值对并返回被移除的值
person.popitem()  # 移除并返回一个键值对，默认是最后一个键值对（在Python 3.7+版本中）

# 检查键是否存在
print("name" in person)  # 输出True或False

# 清空字典
person.clear()  # 清除字典中的所有项

字典常用的方法：

# 获取字典的所有键
keys = person.keys()
print(keys)

# 获取字典的所有值
values = person.values()
print(values)

# 获取字典的所有键值对
items = person.items()
print(items)

# 合并两个字典
dict1 = {"a": 1, "b": 2}
dict2 = {"b": 3, "c": 4}
dict1.update(dict2)  # 将dict2合并到dict1中，若有相同的键则更新其值
print(dict1)

# 设置默认值
dict1.setdefault("d", 0)  # 如果键"d"不存在，则添加该键值对；如果存在，则不改变其值
print(dict1)

# 字典生成式
squares = {x: x*x for x in range(6)}
print(squares)

字典在Python中用途广泛，非常适合用来存储需要快速查找的数据，特别是当数据之间存在一对一映射关系时。由于字典内部采用了哈希表实现，因此对于大多数操作来说，它们提供了接近常数时间复杂度的性能。同时，字典也是其他高级数据结构和算法的基础，比如缓存实现等。

遍历方法对比

在Python中，列表、元组、集合和字典是四种常用的数据结构。每种数据类型都有其特定的遍历方法，以及一些特殊场景下的遍历技巧。下面将逐一介绍它们各自的遍历方式，并对比这些方法的特点。

列表遍历

列表是最常用的有序数据容器之一，支持直接通过索引或使用for循环进行遍历：

# 使用for循环遍历
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)

# 使用enumerate()获取元素及其索引
for index, fruit in enumerate(fruits):
    print(f"Index {index}: {fruit}")

元组遍历

元组与列表类似，也是有序且可以通过索引访问，但它是不可变的。因此，它的遍历方式与列表基本相同：

# 元组的遍历同样使用for循环
coordinates = (10.0, 20.0)
for coord in coordinates:
    print(coord)

# 同样可以使用enumerate()
for index, value in enumerate(coordinates):
    print(f"Coordinate {index}: {value}")

集合遍历

集合是无序且不重复元素的集合，遍历时不能保证元素的顺序，但可以通过简单的for循环来遍历：

# 集合遍历
unique_fruits = {"apple", "banana", "cherry"}
for fruit in unique_fruits:
    print(fruit)

# 注意：由于集合无序，所以每次打印的结果可能不同

字典遍历

字典是一种键值对的映射，提供了多种遍历方式，包括遍历键、遍历值以及同时遍历键和值：

# 遍历所有键
person = {"name": "Alice", "age": 25}
for key in person:
    print(key)

# 遍历所有值
for value in person.values():
    print(value)

# 遍历键值对
for key, value in person.items():
    print(f"{key} -> {value}")

# 使用items()遍历时可以直接解包为键和值

特殊遍历方法

除了上述标准的遍历方法外，还有几种特殊的遍历方法适用于特定需求：

# 列表和元组的反向遍历
for item in reversed(fruits):  # 对列表或元组进行反向遍历
    print(item)

# 字典按照键排序后遍历
for key in sorted(person):  # 按照键排序遍历字典
    print(f"{key}: {person[key]}")

# 列表推导式作为遍历的一种简洁形式
squares = [x**2 for x in range(5)]  # 创建一个包含平方数的新列表
print(squares)

综上所述，虽然列表、元组、集合和字典都支持基本的for循环遍历，但根据各自的特点和应用场景，也提供了不同的遍历方法以满足开发者的具体需求。选择合适的遍历方法不仅可以让代码更加清晰易读，还能提高程序的执行效率。

结尾

对于仅靠python写点脚本、做一些自动化任务，这些已经是足够了，在学完，python基础后，在一节，博主会继续更新pythonGUI自动化库，pyautogui。这个库还是比较有意思的，整个过程和当初用KeyMouseGO写脚本的体验是大差不差的，大家敬请期待！