Task 05 排列搜索计数及集合操作

最新推荐文章于 2021-07-13 11:24:05 发布
最新推荐文章于 2021-07-13 11:24:05 发布
阅读量134 收藏
点赞数
文章标签： numpy
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/gccous/article/details/109403007
版权
本文详细介绍了NumPy库中的排序方法，包括axis、kind和order参数的使用。此外，还讲解了如何在数组中搜索非零元素的索引，以及使用argwhere获取它们的位置。计数部分涵盖了集合操作，如查找元素在列表中的位置和计数。最后，文章讨论了布尔运算在集合操作中的应用，如交集、并集、差集和异或。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1.排序，搜索和计数

排序
numpy.sort(a[, axis=-1, kind='quicksort', order=None])
a. axis：排序沿数组的（轴）方向，0表示按行，1表示按列，None表示展开来排序，默认为-1，表示沿最后的轴排序。
b. kind：排序的算法，提供了快排’quicksort’、混排’mergesort’、堆排’heapsort’， 默认为‘quicksort’。
c. order：排序的字段名，可指定字段排序，默认为None。

import numpy as np
np.random.seed(20201031)
x = np.random.rand(5, 5) * 10
x = np.around(x, 2)
print(x)
print()
y = np.sort(x)
print(y)
print()
y = np.sort(x, axis=0)
print(y)
print()
y = np.sort(x, axis=1)
print(y)
#  [[6.87 1.3  5.09 3.39 1.71]
#   [7.47 9.22 5.48 4.55 2.48]
#   [2.25 4.58 3.97 0.8  5.05]
#   [0.16 9.97 3.48 6.41 7.24]
#   [0.94 1.59 5.41 5.25 8.51]]

#  [[1.3  1.71 3.39 5.09 6.87]
#   [2.48 4.55 5.48 7.47 9.22]
#   [0.8  2.25 3.97 4.58 5.05]
#   [0.16 3.48 6.41 7.24 9.97]
#   [0.94 1.59 5.25 5.41 8.51]]

#  [[0.16 1.3  3.48 0.8  1.71]
#   [0.94 1.59 3.97 3.39 2.48]
#   [2.25 4.58 5.09 4.55 5.05]
#   [6.87 9.22 5.41 5.25 7.24]
#   [7.47 9.97 5.48 6.41 8.51]]

#  [[1.3  1.71 3.39 5.09 6.87]
#   [2.48 4.55 5.48 7.47 9.22]
#   [0.8  2.25 3.97 4.58 5.05]
#   [0.16 3.48 6.41 7.24 9.97]
#   [0.94 1.59 5.25 5.41 8.51]]

import numpy as np
dt = np.dtype([('name', 'S10'), ('age', np.int)])
a = np.array([("Li",21), ("Lin", 25), ("Chen", 17),("Ye",27)], dtype=dt)
b = np.sort(a, order='name')
print(b)
print()
b = np.sort(a, order='age')
print(b)
#  [(b'Chen', 17) (b'Li', 21) (b'Lin', 25) (b'Ye', 27)]

#  [(b'Chen', 17) (b'Li', 21) (b'Lin', 25) (b'Ye', 27)]

numpy.argsort(a[, axis=-1, kind='quicksort', order=None])

import numpy as np
np.random.seed(20200612)
x = np.random.randint(0, 10, 10)
print(x)
print()
y = np.argsort(x)
print(y)
print()
print(x[y])
print()
y = np.argsort(-x)
print(y)
print()
print(x[y])

#  [6 1 8 5 5 4 1 2 9 1]

#  [1 6 9 7 5 3 4 0 2 8]

#  [1 1 1 2 4 5 5 6 8 9]

#  [8 2 0 3 4 5 7 1 6 9]

#  [9 8 6 5 5 4 2 1 1 1]

import numpy as np
np.random.seed(20200612)
x = np.random.rand(5, 5) * 10
x = np.around(x, 2)
print(x)
print()
y = np.argsort(x)
print(y)
print()
y = np.argsort(x, axis=0)
print(y)
print()
y = np.argsort(x, axis=1)
print(y)
print()
y = np.array([np.take(x[i], np.argsort(x[i])) for i in range(5)])
#numpy.take(a, indices, axis=None, out=None, mode='raise')沿轴从数组中获取元素
print(y)
#  [[2.32 7.54 9.78 1.73 6.22]
#   [6.93 5.17 9.28 9.76 8.25]
#   [0.01 4.23 0.19 1.73 9.27]
#  [7.99 4.97 0.88 7.32 4.29]
#   [9.05 0.07 8.95 7.9  6.99]]

#  [[3 0 4 1 2]
#   [1 0 4 2 3]
#   [0 2 3 1 4]
#   [2 4 1 3 0]
#   [1 4 3 2 0]]

#  [[2 4 2 0 3]
#   [0 2 3 2 0]
#   [1 3 4 3 4]
#   [3 1 1 4 1]
#   [4 0 0 1 2]]

#  [[3 0 4 1 2]
#   [1 0 4 2 3]
#   [0 2 3 1 4]
#   [2 4 1 3 0]
#   [1 4 3 2 0]]

#  [[1.73 2.32 6.22 7.54 9.78]
#   [5.17 6.93 8.25 9.28 9.76]
#   [0.01 0.19 1.73 4.23 9.27]
#   [0.88 4.29 4.97 7.32 7.99]
#   [0.07 6.99 7.9  8.95 9.05]]

numpy.lexsort(keys[, axis=-1]) （使用键序列执行间接稳定排序。）
给定多个可以在电子表格中解释为列的排序键，lexsort返回一个整数索引数组，该数组描述了按多个列排序的顺序。序列中的最后一个键用于主排序顺序，倒数第二个键用于辅助排序顺序，依此类推。keys参数必须是可以转换为相同形状的数组的对象序列。如果为keys参数提供了2D数组，则将其行解释为排序键，并根据最后一行，倒数第二行等进行排序。

import numpy as np

np.random.seed(20200612)
x = np.random.rand(5, 5) * 10
x = np.around(x, 2)
print(x)
print()
index = np.lexsort([x[:, 0]])
print(index)
print()
y = x[index]
print(y)
print()
index = np.lexsort([-1 * x[:, 0]])
print(index)
print()
y = x[index]
print(y)
#  [[2.32 7.54 9.78 1.73 6.22]
#   [6.93 5.17 9.28 9.76 8.25]
#   [0.01 4.23 0.19 1.73 9.27]
#   [7.99 4.97 0.88 7.32 4.29]
#   [9.05 0.07 8.95 7.9  6.99]]

#  [2 0 1 3 4]

# [[0.01 4.23 0.19 1.73 9.27]
#   [2.32 7.54 9.78 1.73 6.22]
#   [6.93 5.17 9.28 9.76 8.25]
#   [7.99 4.97 0.88 7.32 4.29]
#   [9.05 0.07 8.95 7.9  6.99]]

#  [4 3 1 0 2]

#  [[9.05 0.07 8.95 7.9  6.99]
#   [7.99 4.97 0.88 7.32 4.29]
#   [6.93 5.17 9.28 9.76 8.25]
#   [2.32 7.54 9.78 1.73 6.22]
#   [0.01 4.23 0.19 1.73 9.27]]

numpy.partition(a, kth, axis=-1, kind='introselect', order=None)

import numpy as np

np.random.seed(100)
x = np.random.randint(1, 30, [8, 3])
print(x)
print()
y = np.sort(x, axis=0)
print(y)
print()
z = np.partition(x, kth=2, axis=0)
print(z)
#  [[ 9 25  4]
#   [ 8 24 16]
#   [17 11 21]
#   [ 3 22  3]
#   [ 3 15  3]
#   [18 17 25]
#   [16  5 12]
#   [29 27 17]]

#  [[ 3  5  3]
#   [ 3 11  3]
#   [ 8 15  4]
#   [ 9 17 12]
#   [16 22 16]
#   [17 24 17]
#   [18 25 21]
#   [29 27 25]]

#  [[ 3  5  3]
#   [ 3 11  3]
#   [ 8 15  4]
#   [ 9 22 21]
#   [17 24 16]
#   [18 17 25]
#   [16 25 12]
#   [29 27 17]]

  #  选取每一列第三大的数的索引
import numpy as np

np.random.seed(100)
x = np.random.randint(1, 30, [8, 3])
print(x)
print()
z = np.partition(x, kth=-3, axis=0)
print(z[-3])
#  [[ 9 25  4]
#   [ 8 24 16]
#   [17 11 21]
#   [ 3 22  3]
#   [ 3 15  3]
#   [18 17 25]
#   [16  5 12]
#   [29 27 17]]

#  [17 24 17]

搜索
numpy.argmax(a[, axis=None, out=None])

import numpy as np
np.random.seed(20200612)
x = np.random.rand(5, 5) * 10
x = np.around(x, 2)
print(x)
print()
y = np.argmax(x)
print(y) 
print()
y = np.argmax(x, axis=0)
print(y)
print()
y = np.argmax(x, axis=1)
print(y)
#  [[2.32 7.54 9.78 1.73 6.22]
#   [6.93 5.17 9.28 9.76 8.25]
#   [0.01 4.23 0.19 1.73 9.27]
#   [7.99 4.97 0.88 7.32 4.29]
#   [9.05 0.07 8.95 7.9  6.99]]

#  2

#  [4 0 0 1 2]

#  [2 3 4 0 0]

numpy.argmin(a[, axis=None, out=None])

import numpy as np
np.random.seed(20200612)
x = np.random.rand(5, 5) * 10
x = np.around(x, 2)
print(x)
print()
y = np.argmin(x)
print(y) 
print()
y = np.argmin(x, axis=0)
print(y)
print()
y = np.argmin(x, axis=1)
print(y)
#  [[2.32 7.54 9.78 1.73 6.22]
#   [6.93 5.17 9.28 9.76 8.25]
#   [0.01 4.23 0.19 1.73 9.27]
#   [7.99 4.97 0.88 7.32 4.29]
#   [9.05 0.07 8.95 7.9  6.99]]

#  10

#  [2 4 2 0 3]

#  [3 1 0 2 1]

numppy.nonzero(a)
其值为非零元素的下标在对应轴上的值。

  1. 只有 a 中非零元素才会有索引值，那些零值元素没有索引值。
  2. 返回一个长度为 a.ndim 的元组（tuple），元组的每个元素都是一个整数数组（array）。
  3. 每一个array均是从一个维度上来描述其索引值。比如，如果 a 是一个二维数组，则tuple包含两个array，第一个array从行维度来描述索引
    值；第二个array从列维度来描述索引值。
  4. 该 np.transpose(np.nonzero(x)) 函数能够描述出每一个非零元素在不同维度的索引值。
  5. 通过 a[nonzero(a)] 得到所有 a 中的非零值。
  #  二维数组
import numpy as np

x = np.array([[3, 0, 0], [0, 4, 0], [5, 6, 0]])
print(x)
print()
print(x.shape)
print()
print(x.ndim) 
print()
y = np.nonzero(x)
print(y)
print()
# (array([0, 1, 2, 2], dtype=int64), array([0, 1, 0, 1], dtype=int64))
print(np.array(y))
print()
print(np.array(y).shape) 
print()
print(np.array(y).ndim) 
print()
y = x[np.nonzero(x)]
print(y) 
print()
y = np.transpose(np.nonzero(x))
print(y)
#  [[3 0 0]
#   [0 4 0]
#   [5 6 0]]

#  (3, 3)

#  2

#  (array([0, 1, 2, 2], dtype=int64), array([0, 1, 0, 1], dtype=int64))

#  [[0 1 2 2]
#   [0 1 0 1]]

#  (2, 4)

#  2

#  [3 4 5 6]

#  [[0 0]
#   [1 1]
#   [2 0]
#   [2 1]]

  #  nonzero()将布尔数组转换成整数组进行操作
import numpy as np
x = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(x)
print()
y = x > 3
print(y)
print()
y = np.nonzero(x > 3)
print(y)
print()
y = x[np.nonzero(x > 3)]
print(y)
print()
y = x[x > 3]
print(y)
[[1 2 3]
 [4 5 6]
 [7 8 9]]

#  [[False False False]
#   [ True  True  True]
#   [ True  True  True]]

#  (array([1, 1, 1, 2, 2, 2], dtype=int64), array([0, 1, 2, 0, 1, 2], dtype=int64))

#  [4 5 6 7 8 9]

#  [4 5 6 7 8 9]

  #  满足条件 condition ，输出 x ，不满足输出 y
import numpy as np
x = np.arange(10)
print(x)
print()
y = np.where(x < 5, x, 10 * x)
print(y)
print()
x = np.array([[0, 1, 2],
[0, 2, 4],
[0, 3, 6]])
y = np.where(x < 4, x, -1)
print(y)
#  [0 1 2 3 4 5 6 7 8 9]

#  [ 0  1  2  3  4 50 60 70 80 90]

#  [[ 0  1  2]
#   [ 0  2 -1]
#   [ 0  3 -1]]

numpy.searchsorted(a, v[, side='left', sorter=None])
a. a：一维输入数组。当 sorter 参数为 None 的时候， a 必须为升序数组；否则， sorter 不能为空，存放 a 中元素的 index ，用于
反映 a 数组的升序排列方式。
b. v：插入 a 数组的值，可以为单个元素， list 或者 ndarray 。
c. side：查询方向，当为 left 时，将返回第一个符合条件的元素下标；当为 right 时，将返回最后一个符合条件的元素下标。
d. sorter：一维数组存放 a 数组元素的 index，index 对应元素为升序。

import numpy as np
x = np.array([0, 1, 5, 9, 11, 18, 26, 33])
np.random.shuffle(x)
print(x) 
print()
x_sort = np.argsort(x)
print(x_sort) 
print()
y = np.searchsorted(x, [-1, 0, 11, 15, 33, 35], sorter=x_sort)
print(y) 
print()
y = np.searchsorted(x, [-1, 0, 11, 15, 33, 35], side='right', sorter=x_sort)
print(y) 
#  [33 18  5 26 11  1  9  0]

#  [7 5 2 6 4 1 3 0]

#  [0 0 4 5 7 8]

#  [0 1 5 5 8 8]

计数
numpy.count_nonzero(a, axis=None)

  #  返回数组中的非0元素个数
import numpy as np
x = np.count_nonzero(np.eye(4))
print(x) 
print()
x = np.count_nonzero([[0, 1, 7, 0, 0], [3, 0, 0, 2, 19]])
print(x)
print()
x = np.count_nonzero([[0, 1, 7, 0, 0], [3, 0, 0, 2, 19]], axis=0)
print(x)
print()
x = np.count_nonzero([[0, 1, 7, 0, 0], [3, 0, 0, 2, 19]], axis=1)
print(x) 
#  4

#  5

#  [1 1 1 1 1]

#  [2 3]

集合操作

numpy.unique(ar, return_index=False, return_inverse=False, return_counts=False, axis=None)
a. return_index=True 表示返回新列表元素在旧列表中的位置。
b. return_inverse=True 表示返回旧列表元素在新列表中的位置。
c. return_counts=True 表示返回新列表元素在旧列表中出现的次数。

  #  找出数组中的唯一值并返回已排序的结果
import numpy as np

x = np.unique([1, 1, 3, 2, 3, 3])
print(x)
print()
x = sorted(set([1, 1, 3, 2, 3, 3]))
print(x) 
print()
x = np.array([[1, 1], [2, 3]])
u = np.unique(x)
print(u) 
print()
x = np.array([[1, 0, 0], [1, 0, 0], [2, 3, 4]])
y = np.unique(x, axis=0)
print(y)
print()
x = np.array(['a', 'b', 'b', 'c', 'a'])
u, index = np.unique(x, return_index=True)
print(u) 
print()
print(index) 
print()
print(x[index]) 
print()
x = np.array([1, 2, 6, 4, 2, 3, 2])
u, index = np.unique(x, return_inverse=True)
print(u) 
print()
print(index) 
print()
print(u[index]) 
print()
u, count = np.unique(x, return_counts=True)
print(u) 
print()
print(count)
#  [1 2 3]

#  [1, 2, 3]

#  [1 2 3]

#  [[1 0 0]
#   [2 3 4]]

#  ['a' 'b' 'c']

#  [0 1 3]

#  ['a' 'b' 'c']

#  [1 2 3 4 6]

#  [0 1 4 3 1 2 1]

#  [1 2 6 4 2 3 2]

#  [1 2 3 4 6]

#  [1 3 1 1 1]

布尔运算
numpy.in1d(ar1, ar2, assume_unique=False, invert=False)

  #  前面的数组是否包含于后面的数组，返回布尔值。返回的值是针对第一个参数的数组的，所以维数和第一个参数一致，布尔值与数组的元素位置也一一对应。
import numpy as np

test = np.array([0, 1, 2, 5, 0])
states = [0, 2]
mask = np.in1d(test, states)
print(mask)  
print()
print(test[mask])  
print()

mask = np.in1d(test, states, invert=True)
print(mask)  
print()
print(test[mask]) 
#  [ True False  True False  True]

#  [0 2 0]

#  [False  True False  True False]

#  [1 5]

求两个集合的交集
numpy.intersect1d(ar1, ar2, assume_unique=False, return_indices=False)

  #  求两个数组的唯一化+求交集+排序函数
import numpy as np
from functools import reduce

x = np.intersect1d([1, 3, 4, 3], [3, 1, 2, 1])
print(x)  

x = np.array([1, 1, 2, 3, 4])
y = np.array([2, 1, 4, 6])
xy, x_ind, y_ind = np.intersect1d(x, y, return_indices=True)
print(x_ind) 
print(y_ind) 
print(xy) 
print(x[x_ind]) 
print(y[y_ind])  

x = reduce(np.intersect1d, ([1, 3, 4, 3], [3, 1, 2, 1], [6, 3, 4, 2]))
print(x) 
#  [1 3]
#  [0 2 4]
#  [1 0 2]
#  [1 2 4]
#  [1 2 4]
#  [1 2 4]
#  [3]

求两个集合的并集
numpy.union1d(ar1, ar2)

  #  计算两个集合的并集，唯一化并排序
import numpy as np
from functools import reduce

x = np.union1d([-1, 0, 1], [-2, 0, 2])
print(x) 
print()
x = reduce(np.union1d, ([1, 3, 4, 3], [3, 1, 2, 1], [6, 3, 4, 2]))
print(x)
#  [-2 -1  0  1  2]

#  [1 2 3 4 6]
'''
functools.reduce(function, iterable[, initializer])
将两个参数的 function 从左至右积累地应用到 iterable 的条目，以便将该可迭代对象缩减为单一的值。 例如，reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) 是计算 ((((1+2)+3)+4)+5) 的值。 左边的参数 x 是积累值而右边的参数 y 则是来自 iterable 的更新值。 如果存在可选项 initializer，它会被放在参与计算的可迭代对象的条目之前，并在可迭代对象为空时作为默认值。 如果没有给出 initializer 并且 iterable 仅包含一个条目，则将返回第一项。

大致相当于：
def reduce(function, iterable, initializer=None):
    it = iter(iterable)
    if initializer is None:
        value = next(it)
    else:
        value = initializer
    for element in it:
        value = function(value, element)
    return value
'''

求两个集合的差值
numpy.setdiff1d(ar1, ar2, assume_unique=False)

  #  集合的差，即元素存在于第一个函数不存在于第二个函数中中
import numpy as np

a = np.array([1, 2, 3, 2, 4, 1])
b = np.array([3, 4, 5, 6])
x = np.setdiff1d(a, b)
print(x)  
#  【1 2】

求两个集合的异或
setxor1d(ar1, ar2, assume_unique=False)

  #  集合的对称差，即两个集合的交集的补集。简言之，就是两个数组中各自独自拥有的元素的集合。
import numpy as np

a = np.array([1, 2, 3, 2, 4, 1])
b = np.array([3, 4, 5, 6])
x = np.setxor1d(a, b)
print(x) 
#  [1 2 5 6]
gccous
关注
Multitask learning techniques for natural language processing
AI天才研究院
07-31 3152
作者：禅与计算机程序设计艺术Multitask learning is a machine learning technique that allows multiple related tasks to be learned simultaneously from the same data and then used together for better performance in each task. In recent years, multitask learning has emerged
TASK05 排序搜索计数及集合操作
Tracey的博客
10-31 95
一、排序 参数axis=0，按列排列，axis=1，按行排列。 np.random.seed(20201031) a=np.random.rand(3,3)*10 a=np.around(a,2) print(a) b=np.sort(a,axis=1) print(b) c=np.sort(a,axis=0) print(c) d=np.sort(a) print(d) [[6.87 1.3 5.09] [3.39 1.71 7.47] [9.22 5.48 4.55]] [[1.3 5.09
numpy task5排序搜索计数及集合操作
BigCabbageFy的博客
10-31 423
排序，搜索和计数 排序 numpy.sort(a[, axis=-1, kind=‘quicksort’, order=None])； axis：排序沿数组的轴方向； kind：排序的算法（快排，混排，堆排）； order：排序的字段名 import numpy as np # np.random.seed() x= np.random.rand(5,5)*10 x = np.around(x,2) print(x) print('+++++++++++') y = np.sort(x) pri
task5 排序搜索计数及集合操作
sbjmf的博客
10-31 390
学习目标： task5 排序搜索计数及集合操作 学习产出： 排序，搜索和计数 排序 numpy.sort() numpy.sort(a[, axis=-1, kind='quicksort', order=None]) Return a sorted copy of an array. axis：排序沿数组的（轴）方向，0表示按行，1表示按列，None表示展开来排序，默认为-1，表示沿最后的轴排序。 kind：排序的算法，提供了快排’quicksort’、混排’mergesort’、堆排’heapso
task 05: 排序，搜索,计数和集合
weixin_46402229的博客
10-29 393
排序 numpy.sort(a[, axis=-1, kind=‘quicksort’, order=None]) Return a sorted copy of an array. a. axis：排序沿数组的（轴）方向，0表示按行，1表示按列，None表示展开来排序，默认为-1，表示沿最后的轴排序。 b. kind：排序的算法，提供了快排’quicksort’、混排’mergesort’、堆排’heapsort’， 默认为‘quicksort’。 c. order：排序的字段名，可指定字段排序，默认为N
numpy TASK5 排序搜索和计数
m0_49190544的博客
10-31 212
TASK5 排序搜索和计数5.1 排序5.1.1 numpy.sort（）5.1.2 numpy.argsort()5.2 搜索5.2.1 numpy.argmax()5.2.2 numpy.argmin()5.2.3 numppy.nonzero()5.2.4 numpy.where()5.2.5 numpy.searchsorted()5.3 计数5.3.1 numpy.count_nonzero()5.4 集合5.4.1 numpy.unique()5.4.2 numpy.intersectld()5
Task01：数据载入及初步观察
dhdbzhsj的博客
07-13 330
Task01：数据载入及初步观察1.数据载入及初步观察1.1载入数据1.1.1导入numpy和pandas1.1.2载入数据1.1.3逐块读取1.1.4修改表头、索引1.2初步观察1.2.1查看数据的基本信息1.2.2观察表格前10行的数据和后15行的数据1.2.3判断数据是否为空1.3保存数据1.3.1将你加载并做出改变的数据，在工作目录下保存为一个新文件train_chinese.csv2.pandas基础2.1你的数据叫什么2.1.1pandas的数据类型2.1.2查看DataFrame数据的每列的名
numpy基础用法-学习笔记-task05
qq_42225861的博客
10-30 252
1.排序，搜索和计数 1）排序 numpy.sort(a[, axis=-1, kind=‘quicksort’, order=None]) Return a sorted copy of an array. a. axis：排序沿数组的（轴）方向，0表示按行，1表示按列，None表示展开来排序，默认为-1，表示沿最后的轴排序。 b. kind：排序的算法，提供了快排’quicksort’、混排’mergesort’、堆排’heapsort’， 默认为‘quicksort’。 c. order：排序的字段名
C#集合操作黑科技：LINQ魔法在集合处理中的秘密
LINQ简介与集合处理基础 在当今的软件开发领域中，数据处理已经成为一个不可或缺的组成部分。当涉及到在内存中处理数据时，微软的 LINQ（Language Integrated Query）技术提供了一种优雅且高效的方法来查询和操作...
自定义方法,以代码形式使用冒泡排序的思路完成对ArrayList集合存整数的降序排列;
09-05
可以使用冒泡排序的思路来对ArrayList集合中的整数进行降序排列。以下是一个自定义的方法，使用代码形式实现： ```java import java.util.ArrayList; public class BubbleSort { public static void ...
JAVA集合和guava集合使用和原理解析
深藏功与名
11-06 1447
一：总体介绍： Java集合框架介绍 集合可以看作是一种容器，用来存储对象信息。所有集合类都位于java.util包下，但支持多线程的集合类位于java.util.concurrent包下。 Java集合类主要由两个根接口Collection和Map派生出来的，Collection派生出了三个子接口：List、Set、Queue（Java5新增的队列），因此Java集合大致也可分成List、Set、Queue、Map四种接口体系，（注意：Map不是Collection的子接口）。 其中L...
C# ConcurrentBag并发操作秘技：无序集合的高效处理
![ConcurrentBag]...它能够保证在并发访问时操作的原子性和一致性，从而让开发者在编写代码时无需担心复杂的锁机制。 ## 1.2 为何需要ConcurrentBag？ 在高并发的环境下，传统的集合如List或D
【KUKA 机器人资料】：激光跟踪焊接机器人系统技术方案.pdf
04-26
KUKA机器人相关资料
基于Matlab的模拟退火算法在旅行商问题(TSP)优化中的应用及其实现
04-26
内容概要：本文详细介绍了利用Matlab实现模拟退火算法来优化旅行商问题（TSP）。首先阐述了TSP的基本概念及其在路径规划、物流配送等领域的重要性和挑战。接着深入讲解了模拟退火算法的工作原理，包括高温状态下随机探索、逐步降温过程中选择较优解或以一定概率接受较差解的过程。随后展示了具体的Matlab代码实现步骤，涵盖城市坐标的定义、路径长度的计算方法、模拟退火主循环的设计等方面。并通过多个实例演示了不同参数配置下的优化效果，强调了参数调优的重要性。最后讨论了该算法的实际应用场景，如物流配送路线优化，并提供了实用技巧和注意事项。 适合人群：对路径规划、物流配送优化感兴趣的科研人员、工程师及高校学生。 使用场景及目标：适用于需要解决复杂路径规划问题的场合，特别是涉及多个节点间最优路径选择的情况。通过本算法可以有效地减少路径长度，提高配送效率，降低成本。 其他说明：文中不仅给出了完整的Matlab代码，还包括了一些优化建议和技术细节，帮助读者更好地理解和应用这一算法。此外，还提到了一些常见的陷阱和解决方案，有助于初学者避开常见错误。
基于STM32的永磁同步电机Simulink代码生成与57次谐波抑制的霍尔FOC控制
04-26
内容概要：本文详细介绍了如何利用Simulink进行自动代码生成，在STM32平台上实现带57次谐波抑制功能的霍尔场定向控制（FOC）。首先，文章讲解了所需的软件环境准备，包括MATLAB/Simulink及其硬件支持包的安装。接着，阐述了构建永磁同步电机（PMSM）霍尔FOC控制模型的具体步骤，涵盖电机模型、坐标变换模块（如Clark和Park变换）、PI调节器、SVPWM模块以及用于抑制特定谐波的陷波器的设计。随后，描述了硬件目标配置、代码生成过程中的注意事项，以及生成后的C代码结构。此外，还讨论了霍尔传感器的位置估算、谐波补偿器的实现细节、ADC配置技巧、PWM死区时间和换相逻辑的优化。最后，分享了一些实用的工程集成经验，并推荐了几篇有助于深入了解相关技术和优化控制效果的研究论文。 适合人群：从事电机控制系统开发的技术人员，尤其是那些希望掌握基于Simulink的自动代码生成技术，以提高开发效率和控制精度的专业人士。 使用场景及目标：适用于需要精确控制永磁同步电机的应用场合，特别是在面对高次谐波干扰导致的电流波形失真问题时。通过采用文中提供的解决方案，可以显著改善系统的稳定性和性能，降低噪声水平，提升用户体验。 其他说明：文中不仅提供了详细的理论解释和技术指导，还包括了许多实践经验教训，如霍尔传感器处理、谐波抑制策略的选择、代码生成配置等方面的实际案例。这对于初学者来说是非常宝贵的参考资料。
基于S7-200 PLC和组态王的机械手搬运控制系统设计与调试
04-26
内容概要：本文详细介绍了基于西门子S7-200 PLC和组态王的机械手搬运控制系统的实现方案。首先，文章展示了梯形图程序的关键逻辑，如急停连锁保护、水平移动互锁以及定时器的应用。接着，详细解释了IO分配的具体配置，包括数字输入、数字输出和模拟量接口的功能划分。此外，还讨论了接线图的设计注意事项，强调了电磁阀供电和继电器隔离的重要性。组态王的画面设计部分涵盖了三层画面结构（总览页、参数页、调试页）及其动画脚本的编写。最后，分享了调试过程中遇到的问题及解决方案，如传感器抖动、输出互锁设计等。 适合人群：从事自动化控制领域的工程师和技术人员，尤其是对PLC编程和组态软件有一定基础的读者。 使用场景及目标：适用于自动化生产线中机械手搬运控制系统的开发与调试。目标是帮助读者掌握从硬件接线到软件逻辑的完整实现过程，提高系统的稳定性和可靠性。 其他说明：文中提供了大量实践经验，包括常见的错误和解决方案，有助于读者在实际工作中少走弯路。
西门子1200PLC污水处理项目：PLC程序、通讯配置与HMI设计详解
最新发布
04-26
内容概要：本文详细介绍了基于西门子1200PLC的污水处理项目，涵盖了PLC程序结构、通信配置、HMI设计以及CAD原理图等多个方面。PLC程序采用梯形图和SCL语言相结合的方式，实现了复杂的控制逻辑，如水位控制、曝气量模糊控制等。通讯配置采用了Modbus TCP和Profinet双协议，确保了设备间高效稳定的通信。HMI设计则注重用户体验，提供了详细的报警记录和趋势图展示。此外，CAD图纸详尽标注了设备位号，便于后期维护。操作说明书中包含了应急操作流程和定期维护建议，确保系统的长期稳定运行。 适合人群：从事工业自动化领域的工程师和技术人员，尤其是对PLC编程、HMI设计和通信配置感兴趣的从业者。 使用场景及目标：适用于污水处理厂及其他类似工业控制系统的设计、实施和维护。目标是帮助工程师掌握完整的项目开发流程，提高系统的可靠性和效率。 其他说明：文中提供的具体代码片段和设计思路对于理解和解决实际问题非常有价值，建议读者结合实际项目进行深入学习和实践。
5电平三相MMC的VSG控制与MATLAB-Simulink仿真：调频调压效果验证
04-26
内容概要：本文详细介绍了基于5电平三相模块化多电平变流器(MMC)的虚拟同步发电机(VSG)控制系统的构建与仿真。首先，文章描述了MMC的基本结构和参数设置，包括子模块电容电压均衡策略和载波移相策略。接着，深入探讨了VSG控制算法的设计，特别是有功-频率和无功-电压下垂控制的具体实现方法。文中还展示了通过MATLAB-Simulink进行仿真的具体步骤，包括设置理想的直流电源和可编程三相源来模拟电网扰动。仿真结果显示，VSG控制系统能够在面对频率和电压扰动时迅速恢复稳定，表现出良好的调频调压性能。 适合人群：从事电力电子、电力系统自动化及相关领域的研究人员和技术人员。 使用场景及目标：适用于研究和开发新型电力电子设备，特别是在新能源接入电网时提高系统的稳定性。目标是通过仿真验证VSG控制的有效性，为实际应用提供理论支持和技术指导。 其他说明：文章提供了详细的代码片段和仿真配置，帮助读者更好地理解和重现实验结果。此外，还提到了一些常见的调试技巧和注意事项，如选择合适的仿真步长和参数配对调整。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值