目錄
- 一、數列生成
- 1.按照間隔生成數列（np.array[]）
- 2.按照數列數字個數生成數列（np.linspace）
- 二、數列增刪改查
- 1.1 數組末尾添加數據（np.append）
- 1.2 數組指定索引位置添加數據（np.insert）
- 2.數列刪除元素(np.delete)
- 3. 數列修改元素(通過索引和切片得到的變量直接賦值修改 )
- **4. 數列查詢元素**
- **4.1 基礎索引與切片**
- **4.2 條件查詢（布爾索引）**
- **4.3 位置索引查詢**
- **4.4 高級索引技巧**
- **4.5 嵌套結構與對象查詢
- **4.6 性能優化建議**
- **完整代碼示例**
- **關鍵總結**
- 數據清洗 NumPy數組操作與數據清洗指南：數據去重詳解
- 一、數據去重函數：numpy.unique()
- 函數原型與參數說明
- 基本用法示例
- 高級參數應用
- 1. 獲取元素首次出現位置(`return_index`)
- 2. 重構原始數組(`return_inverse`)
- 3. 統計元素出現次數(`return_counts`)
- 多維數組按軸去重
- 二、其他去重方法對比
- 1. 集合(Set)去重
- 2. 有序字典(OrderedDict)去重
- 3. Pandas去重
- 三、性能對比與選擇建議
- 四、實用技巧與注意事項
- 五、綜合應用示例
- 總結
歡迎關注 『Python』 系列，持續更新中
歡迎關注 『Python』 系列，持續更新中
一、數列生成
1.按照間隔生成數列（np.array[]）
（行內for循環快速生成）,注意區間左閉右開 range(開始,結束,間隔)
print("1.按照間隔生成數列（行內for循環快速生成）,注意區間左閉右開 range(開始,結束,間隔)")
a=np.array([x for x in range(1,11)])
print(a)
2.按照數列數字個數生成數列（np.linspace）
注意區間左閉右閉 numpy.linspace(開始,結束,個數(默認50))
print("2.按照數列數字個數生成數列,注意區間左閉右閉 numpy.linspace(開始,結束,個數(默認50))")
b=np.linspace(1,50)
print(b)
b2=np.linspace(0,10,2)#總個數為11
print(b2)
二、數列增刪改查
1.1 數組末尾添加數據（np.append）
numpy.append(arr, values, axis=None)
- arr：輸入數組
- values：要向arr添加的值，需要和arr形狀相同（除了要添加的軸）
- axis：默認為 None。當axis無定義時，是橫向加成，返回總是為一維數組！當axis有定義的時候，分別為0和1的時候。當axis有定義的時候，分別為0和1的時候（列數要相同）。當axis為1時，數組是加在右邊（行數要相同）。
- 注意，與列表的append不同，需要用a= 來接收返回的新增元素的np數組。在數組的末尾添加值，append 函數返回的始終是一個一維數組
- 單維度
print("1.數列增加元素append")
a=np.array([])#一個空數列
print(a)#[]
a=np.append(a,1)#注意，與列表的append不同，需要用a= 來接收返回的新增元素的np數組
# 在數組的末尾添加值，append 函數返回的始終是一個一維數組
print(a)#[1.]
- 多維度示例
import numpy as np
a = np.array([[1, 2, 3], [4, 5, 6]])
print(a)
print(np.append(a, [[11, 12, 13]], axis=0))
#沿軸 0 添加元素：
#[[1 2 3]
# [4 5 6]
# [11 12 13]]1.2 數組指定索引位置添加數據（np.insert）
numpy.insert(ary, indices_or_sections, axis)
- ary：被分割的數組
- indices_or_sections：如果是一個整數，就用該數平均切分，如果是一個數組，為沿軸切分的位置（左開右閉）
- axis：設置沿著哪個方向進行切分，默認為 0，橫向切分，即水平方向。為 1 時，縱向切分，即豎直方向。
- 函數在給定索引之前，沿給定軸在輸入數組中插入值。如果值的類型轉換為要插入，則它與輸入數組不同。 插入沒有原地的，函數會返回一個新數組。 此外，如果未提供軸，則輸入數組會被展開為一維數組。
a = np.array([[1, 2], [3, 4], [5, 6]])
print(a)
print(np.insert(a, 1, 123))
print(np.insert(a, 1, 123, axis=0))
print(np.insert(a, 1, 123, axis=1))
# np.insert(a, 1, 123): array([ 1, 123, 2, 3, 4, 5, 6])
# np.insert(a, 1, 123, axis=0): array([[ 1, 2],
# [123, 123],
# [ 3, 4],
# [ 5, 6]])
# np.insert(a, 1, 123, axis=1): array([[ 1, 123, 2],
# [ 3, 123, 4],
# [ 5, 123, 6]])
2.數列刪除元素(np.delete)
numpy.delete(arr, obj, axis)
- arr：輸入數組
- obj：可以被切片，整數或者整數數組，表明要從輸入數組刪除的子數組
- axis：沿著它刪除給定子數組的軸，如果未提供，則輸入數組會被展開
- 基礎示例
print("2.數列刪除元素")
b=np.array([x for x in range(0,11)])
print(b)
b=np.delete(b,2)#刪除了從0開始索引為2的元素
print(b)
- 更多示例
a = np.arange(12).reshape(3, 4)
print(a)
print(np.delete(a, 5)) #未傳遞axis參數，再插入之前數組會被展開
print(np.delete(a, 1, axis=0)) #刪除第二行
b = np.arange(1, 11)
print(b)
print(b[np.s_[::2]]) #np.s_可以當作索引
print(np.delete(b, np.s_[::2])) #刪去索引為2的倍數的元素
# a: array([[ 0, 1, 2, 3],
# [ 4, 5, 6, 7],
# [ 8, 9, 10, 11]])
# np.delete(a, 5): array([ 0, 1, 2, 3, 4, 6, 7, 8, 9, 10, 11])
# np.delete(a, 1, axis=0): array([[ 0, 1, 2, 3],
# [ 8, 9, 10, 11]])
# b: array([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
# b[np.s_[::2]]: array([1, 3, 5, 7, 9])
# np.delete(b, np.s_[::2]): array([ 2, 4, 6, 8, 10])3. 數列修改元素(通過索引和切片得到的變量直接賦值修改 )
c=np.array([x for x in range(0,11)])
print(c)
c[2]=100#把索引2位置賦值100
print(c)
4. 數列查詢元素
4.1 基礎索引與切片
-
一維數組索引
通過整數索引直接訪問元素，支持正負索引（負數表示倒數）：import numpy as np arr = np.array([10, 20, 30, 40, 50]) print(arr[0]) # 10（首元素） print(arr[-1]) # 50（末元素）[4,5](@ref) -
多維數組索引
用逗號分隔不同維度的索引值：arr_2d = np.array([[1, 2, 3], [4, 5, 6]]) print(arr_2d[1, 0]) # 4（第1行第0列）[8](@ref) -
切片操作
語法：[start:end:step]（左閉右開區間）：arr = np.array([0, 1, 2, 3, 4, 5]) print(arr[1:4]) # [1, 2, 3]（索引1到3） print(arr[::2]) # [0, 2, 4]（步長為2）[4,8](@ref)
4.2 條件查詢（布爾索引）
通過邏輯表達式篩選滿足條件的元素：
arr = np.array([3, 5, 7, 9, 11])
mask = arr > 5
print(arr[mask]) # [7, 9, 11]（所有大于5的元素）[6,8](@ref)
復合條件：
mask = (arr > 4) & (arr < 10) # 且關系
print(arr[mask]) # [5, 7, 9][5](@ref)
4.3 位置索引查詢
-
查找單個元素位置
使用index()方法（僅適用于列表）：lst = [10, 20, 30, 20] try:idx = lst.index(20) # 返回第一個匹配項的索引print(idx) # 1 except ValueError:print("元素不存在")[3,5](@ref) -
查找所有匹配位置
結合enumerate()和列表推導式：lst = [10, 20, 30, 20] positions = [i for i, x in enumerate(lst) if x == 20] print(positions) # [1, 3][3,5](@ref) -
NumPy高效定位
使用np.where()返回滿足條件的索引數組：arr = np.array([10, 20, 30, 20]) positions = np.where(arr == 20)[0] print(positions) # [1, 3][3,6](@ref)
4.4 高級索引技巧
-
花式索引（Fancy Indexing）
用整數數組同時訪問多個不連續位置：arr = np.array([0, 10, 20, 30, 40]) print(arr[[1, 3, 4]]) # [10, 30, 40][6,7](@ref) -
多維花式索引
組合行列索引數組：arr_2d = np.array([[1, 2], [3, 4], [5, 6]]) rows = [0, 2] cols = [1, 0] print(arr_2d[rows, cols]) # [2, 5]（(0,1)和(2,0)的元素）[7](@ref)
**4.5 嵌套結構與對象查詢
-
嵌套列表查詢
逐層遍歷定位元素：nested_list = [[1, 2], [3, 4], [5, 6]] for i, sublist in enumerate(nested_list):if 4 in sublist:col_idx = sublist.index(4)print(f"位置: ({i}, {col_idx})") # (1, 1)[3](@ref) -
自定義對象查詢
根據對象屬性匹配：class Point:def __init__(self, x, y):self.x = xself.y = y points = [Point(1,2), Point(3,4)] idx = next(i for i, p in enumerate(points) if p.x == 3) print(idx) # 1[3](@ref)
4.6 性能優化建議
| 場景 | 推薦方法 | 原因 |
|---|---|---|
| 小規模列表 | index()或列表推導式 | 代碼簡潔，內存開銷小 |
| 大規模數值數組 | np.where() | 向量化操作，速度提升10倍以上 |
| 頻繁查詢 | 轉換為字典或集合 | 哈希表查詢復雜度O(1) |
| 避免修改原數據 | 使用.copy() | 防止切片視圖意外修改原數組 |
完整代碼示例
import numpy as np# 基礎索引與切片
arr = np.arange(10) # [0,1,2,...,9]
print("切片示例:", arr[3:7]) # [3,4,5,6]# 條件查詢
arr = np.array([12, 15, 18, 21])
print("大于15的元素:", arr[arr > 15]) # [18,21]# 位置索引查詢
positions = np.where(arr % 2 == 0)[0]
print("偶數索引:", positions) # [0,2]# 花式索引
data = np.array([[10,20], [30,40], [50,60]])
print("花式索引結果:", data[[0,2], [1,0]]) # [20,50]
關鍵總結
- 基礎訪問：索引和切片是核心，注意切片是視圖（共享內存）。
- 條件篩選：布爾索引是NumPy的向量化優勢，避免Python循環。
- 定位優化：小數據用
index()，大數據用np.where()。 - 嵌套結構：逐層遍歷時優先用
in判斷存在性，避免異常。 - 性能陷阱：
- 避免在循環中重復計算條件（如
arr > 5應預計算） - 超大數據考慮分塊處理（
np.memmap內存映射）
- 避免在循環中重復計算條件（如
數據清洗 NumPy數組操作與數據清洗指南：數據去重詳解
一、數據去重函數：numpy.unique()
numpy.unique()是NumPy庫中專門用于處理數組去重的核心函數，它不僅能移除重復值，還能提供多種附加功能。
函數原型與參數說明
numpy.unique(arr, return_index=False, return_inverse=False, return_counts=False, axis=None)
參數詳解：
| 參數 | 類型 | 說明 |
|---|---|---|
arr | 數組 | 輸入數組，可以是任意維度的NumPy數組 |
return_index | bool | 為True時返回去重元素在原數組的首次出現索引 |
return_inverse | bool | 為True時返回原數組元素在去重數組中的索引 |
return_counts | bool | 為True時返回去重元素在原數組的出現次數 |
axis | int | 指定操作的維度軸（0=行，1=列，None=展平為一維） |
基本用法示例
import numpy as np# 一維數組去重
arr = np.array([3, 1, 2, 2, 3, 4, 5, 4])
unique_arr = np.unique(arr)
print(unique_arr) # 輸出: [1 2 3 4 5]# 二維數組默認展平去重
arr_2d = np.array([[1, 2, 3], [3, 4, 5], [1, 2, 3]])
print(np.unique(arr_2d)) # 輸出: [1 2 3 4 5]
高級參數應用
1. 獲取元素首次出現位置(return_index)
values, indices = np.unique(arr, return_index=True)
print("去重值:", values) # [1 2 3 4 5]
print("首次出現位置:", indices) # [1 2 0 5 6]
2. 重構原始數組(return_inverse)
values, inverse = np.unique(arr, return_inverse=True)
print("去重值:", values) # [1 2 3 4 5]
print("重構索引:", inverse) # [2 0 1 1 2 3 4 3]
reconstructed = values[inverse]
print("重構數組:", reconstructed) # [3 1 2 2 3 4 5 4]
3. 統計元素出現次數(return_counts)
values, counts = np.unique(arr, return_counts=True)
print("去重值:", values) # [1 2 3 4 5]
print("出現次數:", counts) # [1 2 2 2 1]
多維數組按軸去重
# 創建三維數組
arr = np.array([[[1, 2], [3, 4], [1, 2]],[[5, 6], [1, 2], [5, 6]],[[7, 8], [3, 4], [7, 8]]
])# 沿行去重 (axis=0)
print("行去重:\n", np.unique(arr, axis=0))
# 輸出:
# [[[1 2]
# [3 4]
# [1 2]]
#
# [[5 6]
# [1 2]
# [5 6]]
#
# [[7 8]
# [3 4]
# [7 8]]]# 沿列去重 (axis=1)
print("\n列去重:\n", np.unique(arr, axis=1))
# 輸出:
# [[[1 2]
# [3 4]]
#
# [[1 2]
# [5 6]]
#
# [[3 4]
# [7 8]]]
二、其他去重方法對比
雖然numpy.unique()是NumPy中最直接的去重方法，但Python還提供了其他替代方案：
1. 集合(Set)去重
arr = [3, 1, 2, 2, 3, 4, 5, 4]
unique_list = list(set(arr))
print(unique_list) # [1, 2, 3, 4, 5]
特點：簡單高效但不保留順序
2. 有序字典(OrderedDict)去重
from collections import OrderedDict
unique_list = list(OrderedDict.fromkeys(arr))
print(unique_list) # [3, 1, 2, 4, 5]
特點：保持原始順序但需要額外導入模塊
3. Pandas去重
import pandas as pd
df = pd.DataFrame(arr, columns=['values'])
unique_df = df.drop_duplicates()
print(unique_df['values'].tolist()) # [3, 1, 2, 4, 5]
特點：適合處理DataFrame結構數據
三、性能對比與選擇建議
| 方法 | 優勢 | 劣勢 | 適用場景 |
|---|---|---|---|
numpy.unique() | 支持多維數組 返回豐富統計信息 | 結果自動排序 | 數值數據科學計算 |
| 集合(set) | 速度最快(O(n)) | 不保留順序 | 簡單快速去重 |
| 字典(dict) | 保留插入順序 | 需要額外轉換 | 需要保留順序的簡單數據 |
| Pandas | 處理DataFrame方便 | 依賴Pandas庫 | DataFrame數據處理 |
最佳實踐建議：
- 純數值數組處理優先使用
numpy.unique() - 需要保留原始順序時使用字典
dict.fromkeys() - 處理DataFrame數據時使用Pandas的
drop_duplicates() - 簡單列表去重可使用集合(set)轉換
四、實用技巧與注意事項
-
保持原始順序：使用
return_index參數arr = np.array([3, 1, 2, 2, 3, 4, 5, 4]) _, idx = np.unique(arr, return_index=True) sorted_idx = np.sort(idx) print(arr[sorted_idx]) # [3 1 2 4 5] -
處理特殊值：
# 包含NaN值的數組 arr_nan = np.array([3.0, 1.0, np.nan, 2.0, np.nan]) unique_nan = np.unique(arr_nan) print(unique_nan) # [ 1. 2. 3. nan] -
性能優化：對于超大型數組(>1e6元素)，可考慮分塊處理：
def chunked_unique(arr, chunk_size=1000000):chunks = [arr[i:i+chunk_size] for i in range(0, len(arr), chunk_size)]unique_vals = np.unique(np.concatenate([np.unique(chunk) for chunk in chunks]))return unique_vals -
內存優化：使用
return_inverse重構數組比存儲原數組更省內存
五、綜合應用示例
# 創建包含重復數據的二維數組
data = np.array([[101, 'John', 'Sales'],[102, 'Anna', 'Engineering'],[101, 'John', 'Sales'],[103, 'Peter', 'Marketing'],[102, 'Anna', 'Engineering']
])# 按員工ID去重并統計出現次數
ids = data[:, 0]
unique_ids, indices, counts = np.unique(ids, return_index=True, return_counts=True)# 創建去重后的數據表
unique_data = data[indices]# 添加出現次數列
result = np.column_stack((unique_data, counts.astype(str)))print("去重結果:")
print(result)
"""
輸出:
[['101' 'John' 'Sales' '2']['102' 'Anna' 'Engineering' '2']['103' 'Peter' 'Marketing' '1']]
"""
通過掌握numpy.unique()及其相關方法，能高效處理各種數據去重需求，為后續數據分析提供干凈、準確的數據基礎。
總結
大家喜歡的話，給個👍，點個關注！繼續跟大家分享敲代碼過程中遇到的問題！
版權聲明：
發現你走遠了@mzh原創作品，轉載必須標注原文鏈接
Copyright 2022 mzh
Crated：2022-1-10
歡迎關注 『Python』 系列，持續更新中
歡迎關注 『Python』 系列，持續更新中
【Python安裝第三方庫一行命令永久提高速度】
【使用PyInstaller打包Python文件】
【更多內容敬請期待】
——PROJECT#2-BPlusTree-Task#1)
