Python 尝试使用数组构建堆栈算法

我试图这样做，但总是错的。我不明白我该怎么做。。。这是我的代码：

class WrongStack:
def __init__(self):        
    self.__items = numpy.array([])

def push(self, item): 
    numpy.concatenate(self.__items,item)

def pop(self):  
    return numpy.delete(self.__items,0,-1)

def peek(self):  
    return self.__items[len(self.__list) - 1]

def is_empty(self):            
    return len(self.__items) == 0

def size(self):                 
    return len(self.__items)


s = WrongStack()
number = input('Choose a number, 0 to finish')
while number != '0':
  s.push(numpy.array([nmr]))
  number = input('Choose a number, 0 to finish')
while not s.is_empty():
  number = s.pop()
  print(number)

错误是：

File "C:/Users/JJ/OneDrive - ISCTE-IUL/EDA/Aula 4.py", line 55, in <module>
s.push(numpy.array([nmr]))

File "C:/Users/JJ/OneDrive - ISCTE-IUL/EDA/Aula 4.py", line 38, in push
numpy.concatenate(self.__items,item)

File "<__array_function__ internals>", line 6, in concatenate
TypeError: only integer scalar arrays can be converted to a scalar index

文件“C:/Users/JJ/OneDrive-ISCTE-IUL/EDA/Aula 4.py”，第55行，在
s、 推送（numpy.array（[nmr]））
文件“C:/Users/JJ/OneDrive-ISCTE-IUL/EDA/Aula 4.py”，第38行，在push中
numpy.concatenate（自。\u项，项）
文件“”，第6行，串联
TypeError:只能将整数标量数组转换为标量索引

---

我知道这不是如何建立一个正常的堆栈，但我必须这样做

您试图使用numpy数组作为堆栈，这可能没有您希望的那么好。Numpy阵列是为数学计算而设计的，而不是作为通用数据结构

相反，只需使用Python列表来实现堆栈。事实上，Python文档甚至包括如何做到这一点：

堆栈=[3,4,5] >>>stack.append（6） >>>stack.append（7） >>>堆叠 [3, 4, 5, 6, 7] >>>stack.pop（） 7. >>>堆叠 [3, 4, 5, 6] >>>stack.pop（） 6. >>>stack.pop（） 5. >>>堆叠 [3, 4]

---

对代码进行修改以使其正常工作

在我更改代码的地方放置“Mod”

代码

import numpy as np

class WrongStack:
  def __init__(self):        
      self.__items = np.array([])

  def push(self, item): 
      # Mod--concatenate takes list contains items to concatenate
      self.__items = np.concatenate([self.__items,item])

  def pop(self):  
      # Mod--np.delete returns a new array
            # also retrieve last element before delete
      last = self.__items[-1]
      self.__items = np.delete(self.__items,-1, 0)
      return last

  def peek(self):  
      return self.__items[len(self.__list) - 1]

  def is_empty(self): 
      # Mod--use function size    
      return self.size() == 0

  def size(self):                 
      return len(self.__items)

  def __str__(self):
    # Mod--added for display the array
    return str(self.__items)

s = WrongStack()
number = input('Choose a number, 0 to finish: ')
while len(number) > 0 and number != '0': #Mod done if no input or '0' entered
  # Mod--convert numer to integer
  s.push(np.array([number], dtype=np.int32)) # specify type (i.e. int32)
  number = input('Choose a number, 0 to finish: ')

# Mod--print array created
print('Array created:', s)

while not s.is_empty():
  number = s.pop()
  print('number: ', number)

测试

Choose a number, 0 to finish: 1
Choose a number, 0 to finish: 2
Choose a number, 0 to finish: 3
Choose a number, 0 to finish: 4
Choose a number, 0 to finish: 5
Choose a number, 0 to finish: 0
Array created: [1. 2. 3. 4. 5.]
number:  5.0
number:  4.0
number:  3.0
number:  2.0
number:  1.0

备选方案

import numpy as np

class WrongStack:
  def __init__(self):        
      self.__items = np.array([])

  def push(self, item): 
      # Mod--concatenate takes list contains items to concatenate
      self.__items = np.concatenate([self.__items,item])

  def pop(self):  
      # Mod--np.delete returns a new array
            # also retrieve last element before delete
      last = self.__items[-1]
      self.__items = np.delete(self.__items,-1, 0)
      return last

  def peek(self):  
      return self.__items[len(self.__list) - 1]

  def is_empty(self): 
      # Mod--use function size    
      return self.size() == 0

  def size(self):                 
      return len(self.__items)

  def __str__(self):
    # Mod--added for display the array
    return str(self.__items)

s = WrongStack()
number = input('Choose a number, 0 to finish: ')
while len(number) > 0 and number != '0': #Mod done if no input or '0' entered
  # Mod--convert numer to integer
  s.push(np.array([number], dtype=np.int32)) # specify type (i.e. int32)
  number = input('Choose a number, 0 to finish: ')

# Mod--print array created
print('Array created:', s)

while not s.is_empty():
  number = s.pop()
  print('number: ', number)

依赖于Numpy固定大小数组。使用切片和范围检查确保我们保持在分配的大小内

import numpy as np

class WrongStack:
  def __init__(self, maxlen=100):        
      self.__items = np.array([0]*maxlen) # Fixed size Numpy array
      self._count = 0
      self._maxlen = maxlen

  def push(self, item): 
      # Mod--concatenate takes list contains items to concatenate
      if self._count < self._maxlen:
        self.__items[self._count] = item
        self._count += 1
      else:
        print('push: no more space')


  def pop(self):  
      # Mod--np.delete returns a new array
            # also retrieve last element before delete
      if self._count > 0:
        last = self.__items[self._count-1]
        self._count -= 1
        return last
      else:
        return None

  def peek(self):
      if self._count > 0:
        return self.__items[self._count-1]
      else:
        return None

  def is_empty(self): 
      # Mod--use function size    
      return self.size() == 0

  def size(self):                 
      return self._count

  def __str__(self):
    # Mod--added for display the array
    return str(self.__items[:self._count])

s = WrongStack(10) # will handle stack with up to 10 elements
number = input('Choose a number, 0 to finish: ')
while len(number) > 0 and number != '0': #Mod done if no input or '0' entered
  # Mod--convert numer to integer
  s.push(number) # specify type (i.e. int32)
  number = input('Choose a number, 0 to finish: ')

# Mod--print array created
print('Array created:', s)

while not s.is_empty():
  number = s.pop()
  print('number: ', number)

将numpy导入为np
类别错误堆栈：
定义初始值（自，最大值=100）：
self._items=np.数组（[0]*maxlen）#固定大小Numpy数组
自计数=0
self.\u maxlen=maxlen
def推送（自身，项目）：
#Mod--concatenate takes列表包含要连接的项
如果self.\u count0：
最后一个=自我项目[自我计数-1]
自身计数-=1
最后返回
其他：
一无所获
def peek（自）：
如果自计数>0：
返回self.\u项目[self.\u计数-1]
其他：
一无所获
def为空（自身）：
#Mod——使用函数大小
返回self.size（）==0
def大小（自身）：
返回自我。\u计数
定义（自我）：
#Mod--为显示阵列而添加
返回str（self.\u项目[：self.\u计数]）
s=错误堆栈（10）#将处理多达10个元素的堆栈
数字=输入（'选择一个数字，0完成：'）
而len（number）>0且number！='0'：#如果没有输入或输入“0”，则修改完成
#Mod—将数字转换为整数
s、 推送（数字）#指定类型（即int32）
数字=输入（'选择一个数字，0完成：'）
#Mod--已创建打印数组
打印（'已创建数组：'，s）
而不是s。则为空（）
编号=s.pop（）
打印（'编号：'，编号）

使用numpy数组而不是简单列表有什么原因吗？@DarrylG这是我的数据结构和算法课程中的一个练习。我认为，在实现这个算法之后，主要的目标是判断它与普通堆栈算法（使用列表）相比是否具有良好的性能。我担心，出于这个目的，性能可能会比使用列表更差。Numpy有开销，但在计算大量数据时是值得的。对于您的简单使用，它可能会慢一些。我已经做过这种类型的堆栈。现在我需要使用数组来构建堆栈，我被触发了，因为数组不支持这种类型的“作业”，我不知道如何更正这段代码@robbritI至少有一个问题。在pop函数中，当您写入：

self.\uuuu items=np.delete（self.\uuu items，-1，0）

时，这会创建一个新数组，而不包含您删除的元素，还是会更改原始数组？我希望你明白我想说的话。原始数组在：

而不是s.is_empty（）：number=s.pop（）print（'number:'，number）

？@JoãoJúlio--根据delete返回一个新数组。@JoãoJúlio--这是一个您可以尝试的方法。@JoãoJúlio--在delete返回一个新数组后扩展我以前的评论，这意味着在原始的pop方法中

返回numpy.delete（self.\uu items，0，-1）

保持

self.\uu items不变

@JoãoJúlio——正如前面指出的那样，numpy数组的大小是固定的，因此不能更改。因此，删除操作必须创建一个新数组。没错，Numpy数组作为堆栈使用效率很低，因为我们在堆栈中添加（push）和删除（pop）元素时不断创建新数组。这就是为什么一个简单的方法更适合这个目的。