你如何使一個對象返回一個排序的數組而不是python中的空的數組？

Question

我正在嘗試創建一些常用算法庫，以便人們能夠輕鬆使用它們。我創建了一個名爲Compare的對象，它有一些在這些算法中很有用的方法。

代碼比較：

class Compare(list): 
    def __init__(self,arr): 
     self.arr = arr 

    def __compare(self,u,v): 
     # Compares one item of a Compare 
     # object to another 
     if u < v: 
      return 1 
     if u == v: 
      return 0 
     if u > v: 
      return -1 

    def __swap(self,arr,i,j): 
     # Exchanges i and j 
     temp = arr[i] 
     arr[i] = arr[j] 
     a[j] = temp 

    def __determine(self,arr): 
     # Determines if the array is sorted or not 
     for i in range(0,len(array)): 
      if self.__compare(arr[i], arr[i+1]) == -1: 
       return False 
     return True 

    def __printout(self,arr): 
     for i in range(0,len(array)): 
      return arr[i] + '\n' 

    def sorted(self): 
     if self.__determine(arr): 
      return True 
     return False 

這裏的算法，一個使用這個類：

def SelectionSort(array): 
     try: 
      array = Compare(array) 
      for ix in range(0, len(array)): 
       m = ix 
       j = ix+1 
       for j in range(0,len(array)): 
        if array.__compare(array[j], array[m]) == -1: 
         m = j 
       array.__swap(arr, ix, m) 
      return array 
     except(TypeError) as error: 
      print "Must insert array for sort to work." 

我遇到的問題是，每當我嘗試使用這個或任何其他算法，它返回一個空數組而不是有序數組。我不知道如何讓Compare對象返回排序後的數組。

Answer 1

你不是返回數組，你返回Compare陣列周圍包裹。如果您打算Compare爲代理，則換行不完整，因爲您不會將標準container operations轉發給代理陣列。另外，您需要始終使用Compare實例。目前，您有時使用Compare以及其他時間使用原始序列對象，例如將序列傳遞給方法的每個位置。相反，請在其自己的方法中使用Compare對象。

但是，那是Compare做two things：是一個算法集合，併成爲一個序列。如果將對象分開並直接在列表中工作，則可以輕鬆切換算法。這是更典型的方法; list.sort這樣工作，以比較者爲參數。你還需要修正你的實現Compare，它在許多地方使用錯誤的變量名（array，當本地變量名爲arr）。如果你想要任何人使用你的圖書館，它將不得不設計得更好。

隨着進一步的原因不是爲了Compare序列，可以考慮當你需要改變比較方法會發生什麼情況：你最終包裝在另一個Compare，使包裹Compare沒用。

考慮數學中使用的方法：訂單是定義在集合上的關係，而不是集合的固有部分，它尤其不是集合中項目序列的一部分。這揭示了您的原始方法的另一個概念性錯誤：它將一個排序（這是一個集合關係）與該集合中元素序列的運算相結合。兩者應保持分開，以便您可以使用與序列操作的不同比較。

Off-Topic

代碼中有各種類型的其他錯誤。例如，在SelectionSort中，您認爲類型錯誤必須是由於作爲array傳遞了非序列。比較不可比較類型的實例（例如0和'd'）也會導致類型錯誤。又如，Compare.sorted是無用的;它的圖案：

if test: 
    return True 
return False 

這是邏輯上等同於：

return test 

這意味着Compare.sorted相當於Compare.__determine。使後者成爲前者，因爲sorted是更具描述性的名稱。 「確定」過於模糊;它引發了什麼正在被確定的問題。

您可以從codereview.stackexchange.com獲得更多的代碼評論。

Answer 2

我很確定這是發生了什麼事。當您致電：

array = Compare(array) 

您覆蓋對原始數組的引用。數組現在是對比較對象的引用。將數組替換爲array.arr（或名稱數組更好），這應該工作，我想！ :)

請記住，python是鬆散類型的，所以你的「數組」變量只是對某些數據的引用。在這種情況下，您將它從列表的引用切換到對比較對象的引用。

想想：

>>> x = 1 
>>> x 
1 
>>> x = 's' 
>>> x 
's' 

想想看會發生什麼情況1）

Answer 3

你的代碼有很多問題他們中的一些使它失敗 例如

的排序您使用的是也許全球 arr不存在的 self.arr代替 ）
• 。
• 在交換中您還使用a[j] = temp，但a是本地的方法，你不用它的任何東西
• 你正在使用兩個下劃線爲您的方法。這使得名稱無法正常工作，所以函數中的調用不會像你所做的那樣工作。可能你想要一個下劃線來表明這是私有方法。

但主要問題是比較不是returnig列表。爲此你需要：

class Compare(list): 
    def __init__(self, arr): 
     list.__init__(self, arr) 

則：

>>> print Compare([1,2,3,4]) 
[1, 2, 3, 4] 

這樣，你應該在你的方法self代替self.arr使用，因爲您的實例是一個列表（或列表的子類的實例） 。

所以下面是你的代碼修改爲實際工作。唯一的問題是，你的排序算法是錯誤的，它不是正確排序。但你可以從這裏做我想：

class Compare(list): 
    def __init__(self, arr): 
     list.__init__(self, arr) 

    def _compare(self, u, v): 
     # Compares one item of a Compare 
     # object to another 
     if u < v: 
      return 1 
     if u == v: 
      return 0 
     if u > v: 
      return -1 

    def _swap(self, i, j): 
     # Exchanges i and j 
     temp = self[i] 
     self[i] = self[j] 
     self[j] = temp 

    def _determine(self): 
     # Determines if the array is sorted or not 
     for i in range(len(array)): 
      if self._compare(self[i], self[i+1]) == -1: 
       return False 
     return True 

    def _printout(self): 
     for i in self: 
      return i + '\n' 

    def sorted(self): 
     if self._determine(): 
      return True 
     return False 


def SelectionSort(array): 
    try: 
     array = Compare(array) 
     for ix in range(len(array)): 
      m = ix 
      j = ix + 1 
      for j in range(len(array)): 
       if array._compare(array[j], array[m]) == -1: 
        m = j 
      array._swap(ix, m) 
     return array 
    except(TypeError) as error: 
     print "Must insert array for sort to work."