Slightly changed Galey-Shapely Py implementation

Author: Amaras

CONTRIBUTORS.md

@@ -48,3 +48,4 @@ This file lists everyone, who contributed to this repo and wanted to show up her
 - dovisutu
 - Antetokounpo
 - Akash Dhiman
+- Amaras

contents/stable_marriage_problem/code/python/stable_marriage.py

@@ -1,25 +1,30 @@
 # Submitted by Marius Becker
+# Updated by Amaras
 
 import sys
 from random import shuffle
 from copy import copy
-from string import ascii_uppercase
+from string import ascii_uppercase, ascii_lowercase
+
 
 def main():
     # Set this to however many men and women you want
-    if len(sys.argv) > 1:
+    try:
         num_pairs = int(sys.argv[1])
-    else:
+    except (IndexError, ValueError):
+        # If you either did not set how many pairs you wanted or you
+        # did not set it as a number, use default value of 5
         num_pairs = 5
 
-    # There are only 26 possible names
-    if num_pairs > 13:
-        print('You can\' have more than 13 pairs.')
+
+    # There are only 26 possible names for each sex
+    if num_pairs > 26:
+        print("You can't have more than 26 pairs.")
         return
 
     # Create all Person objects
-    men = [ Person(name) for name in ascii_uppercase[0:num_pairs] ]
-    women = [ Person(name) for name in ascii_uppercase[num_pairs:num_pairs*2] ]
+    men = [Person(name) for name in ascii_uppercase[:num_pairs]]
+    women = [Person(name) for name in ascii_lowercase[:num_pairs]]
 
     # Set everyone's preferences
     for man in men:
@@ -35,49 +40,46 @@ def main():
 
     # Print preferences and the result
     for man in men:
-        print('{}: {}'.format(man.name, ', '.join([ p.name for p in man.preference ])))
+        print(f"{man.name}: {', '.join((p.name for p in man.preference))}")
+
+    print('')
 
     for woman in women:
-        print('{}: {}'.format(woman.name, ', '.join([ p.name for p in woman.preference ])))
+        print(f"{woman.name}: {', '.join((p.name for p in woman.preference))}")
 
-    print('')
+    print('\n')
 
     for man in men:
-        print('{} + {}'.format(man.name, man.partner.name))
+        print(f'{man.name} + {man.partner.name}')
 
 def resolve(men, women):
     """Finds pairs with stable marriages"""
-    cont = True
-    while cont:
+
+    while True:
         # Let every man without a partner propose to a woman
         for man in men:
-            if not man.has_partner():
+            if not man.has_partner:
                 man.propose_to_next()
 
         # Let the women pick their favorites
         for woman in women:
             woman.pick_preferred()
 
         # Continue only when someone is still left without a partner
-        cont = False
-        for man in men:
-            if not man.has_partner():
-                cont = True
-                break
+        if all((man.has_partner for man in men)):
+            return
+
 
 class Person:
-    name = None
-    preference = None
-    pref_index = 0
-    candidates = None
-    partner = None
 
     def __init__(self, name):
         self.name = name
         self.preference = []
         self.candidates = []
+        self.pref_index = 0
+        self._partner = None
 
-    def get_next_choice(self):
+    def next_choice(self):
         """Return the next person in the own preference list"""
         if self.pref_index >= len(self.preference):
             return None
@@ -86,7 +88,7 @@ def get_next_choice(self):
 
     def propose_to_next(self):
         """Propose to the next person in the own preference list"""
-        person = self.get_next_choice()
+        person = self.next_choice()
         person.candidates.append(self)
         self.pref_index += 1
 
@@ -99,33 +101,39 @@ def pick_preferred(self):
             if person == self.partner:
                 break
             elif person in self.candidates:
-                self.set_partner(person)
+                self.partner = person
                 break
 
         # Rejected candidates don't get a second chance. :(
         self.candidates.clear()
 
-    def get_partner(self):
-        """Return the current partner"""
-        return self.partner
+    @property
+    def partner(self):
+        return self._partner
+
+    # This allows one to change both self.partner and person.partner
+    # with the simple call: "self.partner = person"
+    @partner.setter
+    def partner(self, person):
+        """Set a person as the new partner and sets the partner of that
+        person as well"""
 
-    def set_partner(self, person):
-        """Set a person as the new partner and run set_partner() on that person
-           as well"""
         # Do nothing if nothing would change
         if person != self.partner:
             # Remove self from current partner
             if self.partner is not None:
-                self.partner.partner = None
+                self._partner._partner = None
 
             # Set own and the other person's partner
-            self.partner = person
+            self._partner = person
             if self.partner is not None:
-                self.partner.partner = self
+                self._partner._partner = self
 
+    # This allows use of self.has_parnter instead of self.has_partner()
+    @property
     def has_partner(self):
-        """Determine whether this person currently has a partner or not"""
-        return self.partner != None
+        """Determine whether this person currently has a partner or not."""
+        return self.partner is not None
 
 if __name__ == '__main__':
     main()