1class Tone:
  2    VALID_NOTES = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"] # list to use the indexes
  3
  4    def __init__(self, tone):
  5        self.tone = tone
  6
  7    def __str__(self):
  8        return str(self.tone)
  9
 10    def __eq__(self, other):
 11        return self.VALID_NOTES.index(self.tone) == self.VALID_NOTES.index(other.tone)
 12
 13    def __hash__(self):
 14        return hash(self.tone)
 15
 16    def __and__(self, other): # using it for the major and minor functions for convenience

            
            
            
            

                

                    
    


    
    

        Виктор Бечев
        

        
04.11.2024 14:20
    
    




                
                

                    
Имай предвид, че това дефинира поведение за бинарният оператор &. За мен лично е неинтуитивно той да изчислява разстояние между тоновете.

That being said, в домашното - не пречи, просто имай предвид, че е доста нелогично да очакваш поведение на бинарен оператор между два обекта и като резултат да получиш число (разлика). За в бъдеще.
                
                

                    
                
            
        
 17        return abs(self.VALID_NOTES.index(self.tone) - self.VALID_NOTES.index(other.tone))
 18
 19    def __add__(self, other):
 20        if isinstance(other, Tone):
 21            return Chord (self, other)
 22        elif isinstance(other, Interval):
 23            new_tone_index = (self.VALID_NOTES.index(self.tone) + other.number_of_semitones) % 12
 24            new_tone = self.VALID_NOTES[new_tone_index]
 25            return Tone(new_tone)
 26        else:
 27            raise TypeError("Invalid operation")
 28
 29    def __sub__(self, other):
 30        if isinstance(other, Tone):
 31            return Interval(self&other)

            
            
            
            

                

                    
    


    
    

        Виктор Бечев
        

        
04.11.2024 14:20
    
    




                
                

                    
Хубаво е да имаш разстояние около този оператор as well (както на други места имаш около знаците за събиране / изваждане и т.н.).
                
                

                    
                
            
        
 32        elif isinstance(other, Interval):
 33            new_tone_index = (self.VALID_NOTES.index(self.tone) - other.number_of_semitones) % 12
 34            new_tone = self.VALID_NOTES[new_tone_index]
 35            return Tone(new_tone)
 36        else:
 37            raise TypeError("Invalid operation")
 38
 39
 40class Interval:
 41    SEMITONES = {

            
            
            
            

                

                    
    


    
    

        Виктор Бечев
        

        
04.11.2024 14:21
    
    




                
                

                    
Тук на практика имаш колекция, която достъпваш с число от 0 до броят на всички елементи минус 1. С други думи - имаш списък / кортеж.
                
                

                    
                
            
        
 42        0: "unison",
 43        1: "minor 2nd",
 44        2: "major 2nd",
 45        3: "minor 3rd",
 46        4: "major 3rd",
 47        5: "perfect 4th",
 48        6: "diminished 5th",
 49        7: "perfect 5th",
 50        8: "minor 6th",
 51        9: "major 6th",
 52        10: "minor 7th",
 53        11: "major 7th"
 54    }
 55
 56    def __init__(self, number_of_semitones):
 57        self.number_of_semitones = number_of_semitones % 12
 58
 59    def __str__(self):
 60        return self.SEMITONES[self.number_of_semitones]
 61
 62    def __add__(self, other):
 63        if isinstance(other, Tone):
 64            raise TypeError ("Invalid operation")
 65        elif isinstance(other, Interval):
 66            return Interval(self.number_of_semitones + other.number_of_semitones)
 67
 68    def __neg__(self):
 69        return Interval(-self.number_of_semitones)
 70
 71
 72class Chord:
 73    CHROMATIC_SCALE = Tone.VALID_NOTES
 74
 75    def __init__(self, main_tone, *tones):
 76        self.main_tone = main_tone
 77        #remove duplicates by first using a set and then back to a list
 78        unique_tones = list(set(tones) | {main_tone})
 79        if len(unique_tones) < 2:
 80            raise TypeError("Cannot have a chord made of only 1 unique tone")
 81        self.tones = unique_tones
 82
 83    def __str__(self):
 84        to_return = str(self.main_tone)
 85        main_tone_idx = self.CHROMATIC_SCALE.index(to_return)
 86        tone_str = {str(tone) for tone in self.tones}
 87        # sorting based on the main tone, NOT based on the indexation in Valid_Tones
 88        for tone in Tone.VALID_NOTES[main_tone_idx + 1:]:
 89            if tone in tone_str:
 90                to_return += "-" + tone

            
            
            
            

                

                    
    


    
    

        Виктор Бечев
        

        
04.11.2024 14:22
    
    




                
                

                    
Важи, но имай предвид, че избягваме конкатенация между стрингове, за предпочитане са f-strings или str.format.
                
                

                    
                
            
        
 91        for tone in Tone.VALID_NOTES[:main_tone_idx]:
 92            if tone in tone_str:
 93                to_return += "-" + tone
 94        return to_return
 95
 96    def is_minor(self):
 97        for t in self.tones:
 98            if self.main_tone != t and (self.main_tone & t) == 3:  # 3 is equal to the index of minor 3rd
 99                return True
100        return False
101
102    def is_major(self):
103        for t in self.tones:
104            if self.main_tone != t and (self.main_tone & t) == 4:  # 4 is equal to the index of major 3rd
105                return True
106        return False
107
108    def is_power_chord(self):
109        is_it_minor = self.is_minor()

            
            
            
            

                

                    
    


    
    

        Виктор Бечев
        

        
04.11.2024 14:23
    
    




                
                

                    
Нямаш нужда от променливите, ако ги сложиш директно в return-а редът няма да стане нито прекалено сложен, нито прекалено дълъг.
                
                

                    
                
            
        
110        is_it_major = self.is_major()
111        return not (is_it_major or is_it_minor)
112
113    def __add__(self, other):
114        if isinstance(other, Tone):
115            return Chord(self.main_tone, *(self.tones + [other]))
116        elif isinstance(other, Chord):
117            return Chord(self.main_tone, *(self.tones+other.tones))

            
            
            
            

                

                    
    


    
    

        Виктор Бечев
        

        
04.11.2024 14:24
    
    




                
                

                    
И тук отново е желателно да има интервали около оператора за събиране, както 2 реда по-нагоре.
                
                

                    
                
            
        
118
119    def __sub__(self, other):
120        if isinstance(other, Tone) and other in self.tones:
121            if len(self.tones) >= 3:
122                other_index = self.tones.index(other)
123                return Chord(self.main_tone, *(self.tones[other_index + 1:] + self.tones[:other_index]))
124            else:
125                raise TypeError("Cannot have a chord made of only 1 unique tone")
126        else:
127            raise TypeError(f"Cannot remove tone {other} from chord {self}")
128
129    def transposed(self, interval):
130        to_transpose = list()
131        to_transpose.append(self.main_tone+interval)
132        for t in self.tones:

            
            
            
            

                

                    
    


    
    

        Виктор Бечев
        

        
04.11.2024 14:25
    
    




                
                

                    
Същото нещо можеш да направиш по-кратко с един list comprehension. Не е проблем, но определено е по-идиоматично да ползваме такъв тип инструменти, които езикът ни предоставя.
                
                

                    
                
            
        
133            to_transpose.append(t + interval)
134        return Chord(*to_transpose)