Python补习
内置函数
sorted() 是 Python 中的一个内置函数，用于对可迭代对象进行排序，并返回一个新的已排序列表。
sorted(iterable, key=key, reverse=reverse)
# iterable 是需要排序的可迭代对象，比如列表、元组、字典等。
# key 是一个可选参数，用于指定一个函数（或类似函数的东西），它用来从每个元素中提取一个用于排序的键。默认为 None，即直接对元素进行排序。
# reverse 是一个可选参数，如果设置为 True，则按降序排序（默认为升序排序）。
对列表进行排序：
my_list = [4, 7, 1, 3, 9, 2]
sorted_list = sorted(my_list)
print(sorted_list) # 输出：[1, 2, 3, 4, 7, 9]
使用 key 参数按照某个函数的返回值排序：
words = ['banana', 'apple', 'orange', 'pineapple']
sorted_words = sorted(words, key=len) # 按字符串长度排序
print(sorted_words) # 输出：['apple', 'banana', 'orange', 'pineapple']
对字典进行排序：
my_dict = {'apple': 5, 'orange': 2, 'banana': 8}
sorted_dict = sorted(my_dict.items(), key=lambda x: x[1], reverse=True) # 按值降序排序
print(sorted_dict) # 输出：[('banana', 8), ('apple', 5), ('orange', 2)]
enumerate
enumerate 函数是 Python 中常用的内置函数之一，用于同时遍历索引和元素。它返回一个枚举对象，其中包含了传入可迭代对象的索引和对应的元素。
这是一个简单的例子，演示了如何使用 enumerate 函数：
fruits = ['apple', 'banana', 'orange']
for index, fruit in enumerate(fruits):
print(f"Index: {index}, Fruit: {fruit}")
输出：
Index: 0, Fruit: apple
Index: 1, Fruit: banana
Index: 2, Fruit: orange
在这个例子中，enumerate(fruits) 返回一个枚举对象，其中的 index 是索引，fruit 是对应的水果。在循环中，我们使用这些值来输出每个元素的索引和元素本身。
你还可以通过指定 start 参数来设置索引的起始值，例如：
fruits = ['apple', 'banana', 'orange']
for index, fruit in enumerate(fruits, start=1):
print(f"Index: {index}, Fruit: {fruit}")
输出：
Index: 1, Fruit: apple1.
Index: 2, Fruit: banana
Index: 3, Fruit: orange
这里，start=1 将索引的起始值设置为 1。
数据类型
列表
列表是一个有序且可更改的集合。使用方括号[] 编写。
1、创建列表
列表中元素的数据类型可以包含整数、浮点数和复数等。也可以包含列表、元组、字典和集合等。
1. 使用方括号[]创建列表
# 创建空列表
list0 = []
# 创建非空列表
list1 = ['Baidu', 'Alibaba', 'Tencent']
2. 使用list()函数创建（转换为）列表
this_list = list(('apple', 'banana', 'cherry'))
# 注意：在使用 list() 函数创建列表时，一定要注意双括号。
在Python中，我们可以使用 list() 函数将字符串、元组、字典和集合等其他类似对象转换为列表
2、访问列表
和列表一样，我们既可以使用下标索引访问列表中的某个元素（得到一个元素的值），也可以使用切片访问列表中的一组元素（得到是子列表）。
1. 下标索引访问
下标索引访问元组分为两大类，即正向索引和反向索引，格式为 list_name[i] ，其中，list_name 表示列表名，i表示索引值，i可以是正数（正向索引）也可以是负数（反向索引）。
# list_name[0]表示列表的第一个元素，list_name[-1]则表示列表的最后一个元素。
list_name = ['wzq', 'lgl', 'gz', 'whl', 'sj', 'hxw']
print(list_name[0]) #wzq
print(list_name[-1]) #hxw
正向索引：从第一个（下标0）开始、第二个（下标1）…
反向索引：从倒数第一个（下标-1）、倒数第二个（下标-2）…
2. 切片访问
使用切片访问列表的格式为 list_name[strat : end : step] ，其中，start 表示起始索引，end 表示结束索引，step 表示步长。
list_name = ['wzq', 'lgl', 'gz', 'whl', 'sj', 'hxw']
print(list_name[1:5:2]) # ['lgl', 'whl']
print(list_name[-6:-1:3]) # ['wzq', 'whl']
在使用切片访问列表元素时，list_name[strat : end : step]，[start：end] 是左闭右开区间，即访问不了 end 代表的元素
3. for循环遍历列表
可以使用 for 循环遍历列表中的项目：
fruit_list = ['apple', 'pear', 'cherry']
for i in fruit_list:
print(i)
# output： apple、pear、cherry
4. 检查项目是否存在
要确定列表中是否存在指定的项，我们可以使用 in 关键字
# 检查列表中是否存在'apple'
fruit_list = ['apple', 'pear', 'cherry']
print('apple' in fruit_list)
# output:true
使用 in 关键字检查列表中是否存在指定项时，如果存在，则返回 True ；反之，则返回 False 。
5. 更改列表值
当我们创建列表后，我们可以对列表中的数据项进行修改或更新，当然我们也可以使用 append() 方法来添加列表项。
fruit_list = ['apple', 'pear', 'cherry']
fruit_list[2] = 'banana'
print(fruit_list)
# output:['apple', 'pear', 'banana']
注意：元组一旦创建后，其值将无法被更改，但是有其他解决方法。
6. 列表连接(合并)/复制
与字符串一样，列表之间可以使用 + 号和 * 号实现元组的连接和复制，这就意味着它们可以生成一个新的列表
# 1、+连接（合并）
x = [1, 2, 3]
y = [4, 5, 6]
print(x + y)
# [1, 2, 3, 4, 5, 6]
# 2、复制
x = ['Hello']
print(x * 5)
# ['Hello', 'Hello', 'Hello', 'Hello', 'Hello']
7. 嵌套列表
使用嵌套列表即在列表里面创建其他列表
x = [1, 2, 3]
y = ['a', 'b', 'c']
z = [x, y]
print(z)
# [[1, 2, 3], ['a', 'b', 'c']]
8. 列表比较
列表比较需要引入 operator 模块的 eq 方法
# 导入 operator 模块
import operator
a = [1, 2]
b = [2, 3]
c = [2, 3]
print("operator.eq(a, b):", operator.eq(a, b))
print("operator.eq(b, c):", operator.eq(b, c))
# operator.eq(a, b): False
# operator.eq(b, c): True
3、内置函数
3.1 打印输出 print()
- print()函数
print() 函数的功能我们已经非常熟悉了，就是打印输出。
my_list = ['pink', True, 1.78, 65]
print(my_list)
['pink', True, 1.78, 65]
3.2 确定列表项目 len()
- len()函数
当我们要确定一个列表有多少项目（元素）时，可以使用len()函数。
fruit_list = ['apple', 'banana', 'cherry']
print(len(fruit_list))
3
3.3 返回变量类型 type()
- type()函数
使用 type() 函数可以确定变量是什么类型（字符串、列表、元组、字典或集合）。
info_list = ['name', 'gender', 'age', 'height', 'weight']
print(type(info_list))
<class 'list'>
当对info_list使用 type() 确定变量类型时，会返回<class 'list'>，表明这是一个列表。
3.4 转换为列表 list()
- list()函数
list() 函数的功能是，将其他类型转换为列表类型，详细用法如下：
# 将字符串转换为列表
str1 = 'Hello Python'
print(list(str1))
['H', 'e', 'l', 'l', 'o', ' ', 'P', 'y', 't', 'h', 'o', 'n']
# 将元组转换为列表
tuple1 = ('Hello', 'Python')
print(list(tuple1))
['Hello', 'Python']
# 将字典转换为列表
dict1 = {'Hello': 'Python', 'name': 'pink'}
print(list(dict1))
['Hello', 'name']
# 将集合转换为列表
set1 = {'Hello', 'Python', 'name', 'pink'}
print(list(set1))
['Python', 'name', 'pink', 'Hello']
# 将区间转换为列表
range1 = range(1, 6)
print(list(range1))
[1, 2, 3, 4, 5]
3.5 元组元素最大/小值 max()、min()
- max()函数和min()函数
max() 函数的作用是返回列表中元素最大值。min() 函数的作用是返回列表中元素最小值。
list1 = [4, 6, 2, 0, -5]
print(max(list1))
print(min(list1))
list2 = ['a', 'z', 'A', 'Z']
print(max(list2))
print(min(list2))
6
-5
z
A
3.6 删除列表 del
删除单个元素
# 我们可以使用 del list_name[i] 来删除某个指定元素，其中 list_name 表示列表名，i 表示指定值的索引值。
list_de = ['Baidu', 'Alibaba', 'Tencent', 'Bytedance']
del list_de[1]
print(list_de
['Baidu', 'Tencent', 'Bytedance']
# 删除列表
# del 函数不仅可以实现删除某个元素，还可以删除整个列表。
list_de = ['Baidu', 'Alibaba', 'Tencent', 'Bytedance']
del list_de
当我们使用 del 函数删除某列表后，再使用 print() 函数打印输出时，会报错NameError: name 'list_de' is not defined,表明该列表未被定义。
4、内置方法
4.1 添加元素 append()、insert()、extend()
- append()方法：用于在列表末尾添加新的对象
语法
list.append(element)
参数值
参数 描述
element 必需。任何类型（字符串、数字、对象等）的元素。
实例
# 添加元素
fruit_list = ['apple', 'banana', 'cherry']
fruit_list.append('pear')
print(fruit_list)
['apple', 'banana', 'cherry', 'pear']
# 添加列表
x = [1, 2, 3]
y = ['A', 'B', 'C']
x.append(y)
print(x)
[1, 2, 3, ['A', 'B', 'C']]
- insert()方法:用于将指定对象插入列表的指定位置
语法
list.insert(position, element)
参数值
参数 描述
position 必需。数字，指定在哪个位置插入值。
element 必需。元素，任何类型（字符串、数字、对象等）。
实例
# 把值 “orange” 作为第二个元素插入 fruits 列表：
fruits = ['apple', 'banana', 'cherry']
fruits.insert(1, "orange")
print(fruits)
['apple', 'orange', 'banana', 'cherry']
# 将列表 y 插入到列表 x 中
x = [1, 2, 3]
y = ['a', 'c']
x.insert(0, y)
print(x)
[['a', 'c'], 1, 2, 3]
append() 只能在末尾处添加元素或列表，insert() 可以在任意位置添加元素或列表。
3、extend()方法
extend() 方法用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）。
语法
list.extend(iterable)
参数值
参数 描述
iterable 必需。任何可迭代对象（列表、集合、元组等）。
实例
aver = ['A', 'B', 'C']
# 添加字符串元素到列表末尾
str1 = 'Hello'
aver.extend(str1)
print(aver)
['A', 'B', 'C', 'H', 'e', 'l', 'l', 'o']
# 添加列表元素到列表末尾
list1 = [1, 2, 3]
aver.extend(list1)
print(aver)
['A', 'B', 'C', 1, 2, 3]
# 添加元组元素到列表末尾
tuple1 = (1, 2, 3)
aver.extend(tuple1)
print(aver)
['A', 'B', 'C', 1, 2, 3]
# 添加字典元素到列表末尾
dict1 = {'name': 'pink', 'gender': True}
aver.extend(dict1)
print(aver)
['A', 'B', 'C', 'name', 'gender']
# 添加集合元素到列表末尾
set1 = {1, 2, 3}
aver.extend(set1)
print(aver)
['A', 'B', 'C', 1, 2, 3]
# 添加区间到列表末尾
range1 = range(1,10)
aver.extend(range1)
print(aver)
['A', 'B', 'C', 1, 2, 3, 4, 5, 6, 7, 8, 9]
4.2 元素出现次数 count()
count() 方法用于统计某个元素在列表中出现的次数。
语法
list.count(value)
参数值
参数 描述
value 必需。任何类型（字符串、数字、列表、元组等）。要搜索的值。
实例
num = [1, 4, 2, 9, 7, 8, 9, 3, 1]
print(num.count(9))
2
4.3 指定值索引 index()
index() 方法用于从列表中找出某个值第一个匹配项的索引位置。
语法
list.index(element)
参数值
参数 描述
element 必需。任何类型（字符串、数字、列表等）。要搜索的值。
实例
num = [4, 55, 64, 32, 16, 32]
print(num.index(32))
3
当被搜索值在列表中多次出现时，仅返回首次出现的位置。
4.4 对列表排序 sort()
sort() 方法用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。
语法
list.sort(reverse=True|False, key=myFunc)
参数值
参数 描述
reverse 可选。reverse=True 将对列表进行降序排序。默认是 reverse=False。
key 可选。指定排序标准的函数。
实例
# 以字母顺序对列表进行排序：
words = ['Name', 'Gender', 'Age', 'Height', 'Weight']
words.sort()
print(words)
['Age', 'Gender', 'Height', 'Name', 'Weight']
# 对列表进行降序排序：
words = ['Name', 'Gender', 'Age', 'Height', 'Weight']
words.sort(reverse=True)
print(words)
['Weight', 'Name', 'Height', 'Gender', 'Age']
# 按照值的长度对列表进行排序：
# 返回值的长度的函数：
def myfunc(e):
return len(e)
words = ['a', 'bb', 'ccc', 'dddd', '']
words.sort(key=myfunc)
print(words)
['', 'a', 'bb', 'ccc', 'dddd']
# 根据字典的 “year” 值对字典列表进行排序：
# 返回 'year' 值的函数：
def myfunc(e):
return e['year']
words = [
{'char': 'a', 'year': 1963},
{'char': 'b', 'year': 2010},
{'char': 'c', 'year': 2019}
]
words.sort(key=myfunc)
print(words)
[{'char': 'a', 'year': 1963}, {'char': 'b', 'year': 2010}, {'char': 'c', 'year': 2019}]
# 按照值的长度对列表进行降序排序：
# 返回值的长度的函数：
def myfunc(e):
return len(e)
words = ['aa', 'b', 'ccc', 'dddd']
words.sort(reverse=True, key=myfunc)
print(words)
['dddd', 'ccc', 'aa', 'b']
# 指定列表中的元素排序来输出列表：
# 获取列表的第二个元素
def takeSecond(elem):
return elem[1]
# 列表
random = [(2, 2), (3, 4), (4, 1), (1, 3)]
# 指定第二个元素排序
random.sort(key=takeSecond)
# 输出类别
print('排序列表：', random)
排序列表： [(4, 1), (2, 2), (1, 3), (3, 4)]
4.5 复制列表 copy()
copy() 方法用于复制列表，类似于 a[:]。
语法
list.copy()
参数值
无参数
实例
fruits = ['apple', 'banana', 'cherry', 'orange']
x = fruits.copy()
print(x)
['apple', 'banana', 'cherry', 'orange']
复制（制作副本）的另一种方法是使用内置函数 list() ，如下：
list1 = ['apple', 'banana', 'cherry']
list_2 = list(list1)
4.6 颠倒列表顺序 reverse()
reverse() 方法用于反向列表中元素。
语法
list.reverse()
参数值
无参数
实例
fruits = ['apple', 'banana', 'cherry']
fruits.reverse()
print(fruits)
['cherry', 'banana', 'apple']
4.7 删除元素 pop()、remove()、clear()
1、pop()方法
pop() 方法用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。
语法
list.pop(pos)
参数值
参数 描述
pos 可选。数字，指定需删除元素的位置。默认值 -1，返回最后的项目。
实例
# 当 pos 未指定时，默认删除最后的元素
fruits = ['apple', 'banana', 'cherry']
fruits.pop()
print(fruits)
['apple', 'banana']
# pos 指定要删除元素的位置
fruits = ['apple', 'banana', 'cherry']
fruits.pop(1)
print(fruits)
['apple', 'cherry']
2、remove()方法
remove() 方法用于移除列表中某个值的第一个匹配项。
语法
list.remove(element)
参数值
参数 描述
element 必需。需删除的任何类型（字符串、数字、列表等）的元素。
实例
num = [1, 3, 2, 8, 3]
num.remove(3)
print(num)
[1, 2, 8, 3]
当被删除的元素在列表中存在多个时，默认删除首次出现的那个。
3、clear()方法
clear() 方法用于清空列表，类似于 del a[:]。
语法
list.clear()
参数值
无参数
实例
word = ['A', 'B', 'C']
word.clear()
print(word)
[]
clear() 方法的作用是清空列表，执行结束后对其使用 print() 打印输出时，会输出 [] ,说明列表还存在，只是空列表而已。
del 函数的作用是删除列表，执行结束后对其使用 print() 打印输出时，会报错 NameError: name 'word' is not defined.。
5、补充
1、使用 del 语句
可以使用 del 语句删除列表中指定索引位置的元素。
my_list = ['a', 'b', 'c', 'd', 'e']
# 删除索引为 2 的元素 'c'
del my_list[2]
print(my_list) # 输出 ['a', 'b', 'd', 'e']
2、使用 pop() 方法
pop() 方法可以删除列表中指定索引位置的元素，并返回该元素的值。
my_list = ['a', 'b', 'c', 'd', 'e']
# 删除索引为 2 的元素 'c'
removed_item = my_list.pop(2)
print(removed_item) # 输出 'c'
print(my_list) # 输出 ['a', 'b', 'd', 'e']
3、使用 remove() 方法
remove() 方法用于删除列表中指定的元素（第一个匹配项）。
my_list = ['a', 'b', 'c', 'd', 'e']
# 删除值为 'c' 的元素
my_list.remove('c')
print(my_list) # 输出 ['a', 'b', 'd', 'e']
4、使用切片操作
可以利用切片操作来创建一个新的列表，不包含需要删除的元素。
my_list = ['a', 'b', 'c', 'd', 'e']
# 删除值为 'c' 的元素
my_list = [item for item in my_list if item != 'c']
print(my_list) # 输出 ['a', 'b', 'd', 'e']
Set集合
set()：创建一个无序且不重复元素的集合。
my_list = [1, 2, 2, 3, 4, 4, 5]
my_set = set(my_list)
print(my_set) # 输出 {1, 2, 3, 4, 5}
可以获得不重复元素集合。
字典
keys() 是字典对象的一个方法，用于返回字典中所有键的视图（View）
my_dict = {'a': 1, 'b': 2, 'c': 3}
# 获取所有键
keys = my_dict.keys()
print(keys) # 输出类似于 dict_keys(['a', 'b', 'c'])
# 将字典的键转换为列表
keys_list = list(keys)
print(keys_list) # 输出 ['a', 'b', 'c']
字典赋值
- 字典基础语法：Python字典(dict)详解
1. 添加新键值对或更新现有键的值：
my_dict = {}
# 添加新键值对
my_dict['key1'] = 'value1'
my_dict['key2'] = 2
# 更新现有键的值
my_dict['key1'] = 'new value'
2. 使用update()方法更新字典：
my_dict = {'a': 1, 'b': 2}
# 使用update方法添加新键值对或更新现有键的值
my_dict.update({'c': 3, 'd': 4})
3. 批量更新键值对：
my_dict = {'a': 1, 'b': 2}
new_data = {'c': 3, 'd': 4}
# 批量更新键值对
my_dict.update(new_data)
4. 使用字典解包来合并字典：
my_dict = {'a': 1, 'b': 2}
additional_data = {'c': 3, 'd': 4}
# 使用字典解包来合并字典
my_dict = {**my_dict, **additional_data}
5. 使用setdefault()方法添加默认值：
my_dict = {'a': 1, 'b': 2}
# 如果 'c' 键不存在，添加 'c': 3 键值对
my_dict.setdefault('c', 3)
字典的遍历
在 Python 中，字典的迭代默认是针对字典的键。即for key in my_dict:
遍历方式总结：
1. 遍历字典的键：
使用 for key in my_dict: 遍历字典的键：
my_dict = {'a': 1, 'b': 2, 'c': 3}
for key in my_dict:
print(key)
2. 遍历字典的键和对应的值：
使用 items() 方法遍历字典的键和值：
my_dict = {'a': 1, 'b': 2, 'c': 3}
for key, value in my_dict.items():
print(f"Key: {key}, Value: {value}")
3. 仅遍历字典的值：
使用 values() 方法遍历字典的值：
my_dict = {'a': 1, 'b': 2, 'c': 3}
for value in my_dict.values():
print(value)
4. 遍历字典的键值对（键-值元组）：
使用 items() 方法遍历字典的键值对：
my_dict = {'a': 1, 'b': 2, 'c': 3}
for item in my_dict.items():
print(item) # 输出键-值对的元组
5. 通过遍历字典的键获取对应的值：
使用键来遍历获取字典中的值：
my_dict = {'a': 1, 'b': 2, 'c': 3}
for key in my_dict:
value = my_dict[key]
print(f"Value for key {key} is {value}")
字典嵌套结构
1. 字典的嵌套结构
字典的值可以是任何数据类型，包括另一个字典。这样的嵌套结构可以创建多层次的数据结构，形成复杂的信息组织方式。
nested_dict = {
'key1': 'value1',
'key2': {
'inner_key1': 'inner_value1',
'inner_key2': 'inner_value2'
},
'key3': {
'sub_dict': {
'sub_key': 'sub_value'
}
}
}
2. 字典嵌套的访问方法
你可以通过多次索引来访问嵌套字典中的值。
print(nested_dict['key2']['inner_key1']) # 输出 'inner_value1'
print(nested_dict['key3']['sub_dict']['sub_key']) # 输出 'sub_value'
3. 更新嵌套字典中的值
更新嵌套字典中的值与更新普通字典类似。
nested_dict['key2']['inner_key1'] = 'new_value'
nested_dict['key3']['sub_dict']['sub_key'] = 'new_sub_value'
4. 向嵌套字典中添加新内容
你可以向嵌套字典中添加新的键值对。
nested_dict['key4'] = {}
nested_dict['key4']['new_key'] = 'new_value'
5. 遍历嵌套字典
通过遍历嵌套字典，你可以访问所有的键和值。
for key, value in nested_dict.items():
if isinstance(value, dict):
for inner_key, inner_value in value.items():
print(f"Inner Key: {inner_key}, Inner Value: {inner_value}")
else:
print(f"Key: {key}, Value: {value}")
Math部分
result = math.log(x, base)
x: 是要计算对数的数值。
base:是对数的底数。如果未提供 base 参数，则默认计算自然对数（底数为 e）。
Numpy部分
参考文献：
1、为什么会有numpy
在数据分析的过程中，需要接触的数据是非常多的，但是普通的python数据类型对于处理大，大量的数据可能会显得力不从心（处理数据的效率会变慢），这个时候人们就迫切的需要一种可以快速处理大量数据的数据类型，所以数组(Numpy中的一个数据类型)就诞生了.
2、基础语法
- Python基础 - NumPy数组
- NumPy 超详细教程（1）：NumPy 数组 --最全
Numpy数组属性
| 属性 | 说明 |
|---|---|
| ndarray.ndim | 秩，即轴的数量或维度的数量 |
| ndarray.shape | 数组的维度，对于矩阵，n 行 m 列 |
| ndarray.size | 数组元素的总个数，相当于 .shape 中 n*m 的值 |
| ndarray.dtype | ndarray 对象的元素类型 |
| ndarray.itemsize | ndarray 对象中每个元素的大小，以字节为单位 |
| ndarray.flags | ndarray 对象的内存信息 |
| ndarray.real | ndarray 元素的实部（复数的实部） |
| ndarray.imag | ndarray 元素的虚部（复数的虚部） |
| ndarray.data | 包含实际数组元素的缓冲区，由于一般通过数组的索引获取元素，所以通常不需要使用这个属性。 |
转换成数组
numpy.asarray(a, dtype=None, order=None)
| 参数 | 描述 |
|---|---|
| a | 输入数据，可以转换为数组的任何形式。 这包括列表，元组列表，元组，元组元组，列表元组和 ndarray。 |
| dtype | 数据类型 |
| order | 在计算机内存中的存储元素的顺序，只支持 ‘C’（按行）、‘F’（按列），默认 ‘C’ |
import numpy as np
a = np.asarray([1, 2, 3])
print(a)
//[1 2 3]
解包操作
*单星号用于解包迭代，**双星号用于解包字典
