예제 #1
0
def main():
    """Guitar program, using Guitar class."""
    guitars = []

    print("My guitars!")
    name = input("Name: ")
    while name != "":
        year = int(input("Year: "))
        cost = float(input("Cost: $"))
        guitar_to_add = Guitar(name, year, cost)
        guitars.append(guitar_to_add)
        print(guitar_to_add, "added.")
        name = input("Name: ")

    guitars.append(Guitar("Gibson L-5 CES", 1922, 16035.40))
    guitars.append(Guitar("Line 6 JTV-59", 2010, 1512.9))

    if guitars:  # lists, strings and other collections are False when empty, True when non-empty
        # In order for sorting to work on Guitar objects,
        # at least the __lt__ method must be defined in Guitar class
        guitars.sort()
        print("These are my guitars:")
        for i, guitar in enumerate(guitars):
            vintage_string = ""
            if guitar.is_vintage():
                vintage_string = "(vintage)"
            print("Guitar {0}: {1.name:>30} ({1.year}), worth ${1.cost:10,.2f}\
             {2}".format(i + 1, guitar, vintage_string))
    else:
        print("No guitars :( Quick, go and buy one!")
예제 #2
0
def main():
    """Guitar program, using Guitar class."""
    guitars = []

    print("My guitars!")
    guitar_name = input("Name: ")
    while guitar_name != "":
        guitar_year = int(input("Year: "))
        guitar_cost = float(input("Cost: $"))
        guitar = Guitar(guitar_name, guitar_year, guitar_cost)
        guitars.append(guitar)
        print(str(guitar) + " added.")
        guitar_name = input("Name: ")

    guitars.append(Guitar("Gibson L-5 CES", 1922, 16035.40))
    guitars.append(Guitar("Line 6 JTV-59", 2010, 1512.9))

    if guitars:  # lists, strings and other collections are False when empty, True when non-empty
        # In order for sorting to work on Guitar objects,
        # at least the __lt__ method must be defined in Guitar class
        guitars.sort()
        print("These are my guitars:")
        i = 1
        for guitar in guitars:
            is_vintage = ""
            if guitar.is_vintage():
                is_vintage = "(vintage)"
            print("Guitar {}: {} ({}), worth $ {:.2f} {}".format(i, guitar.name, guitar.year, guitar.cost, is_vintage))
            i += 1
    else:
        print("No any guitars.")
예제 #3
0
def main():
    guitars = []

    print("My guitars!")
    name = input("Name: ")
    while name != "":
        year = int(input("Year: "))
        cost = float(input("Cost: $"))
        add_guitar = Guitar(name, year, cost)
        guitars.append(add_guitar)
        print(add_guitar, " added.")
        name = input("Name: ")

    guitars.append(Guitar("Gibson L-5 CES", 1922, 16035.40))
    guitars.append(Guitar("Line 6 JTV-59", 2010, 1512.9))

    if guitars:
        guitars.sort()
        print("These are my guitars: ")
        for index, guitar in enumerate(guitars, 1):
            is_vintage = "(vintage)" if guitar.is_vintage() else ""
            print(
                "Guitar {0}: {1.name:>10} ({1.year}), worth ${1.cost:10,.2f} {2}"
                .format(index, guitar, is_vintage))

    else:
        print("No guitars :( Quick, go and buy one!")
예제 #4
0
def main():
    guitars = []

    print("My guitars!")
    name = input("Name: ")
    while name != "":
        year = int(input("Year: "))
        cost = float(input("Cost: $"))
        guitar_to_add = Guitar(name, year, cost)
        guitars.append(guitar_to_add)
        print(guitar_to_add, "added.")
        name = input("Name: ")

    guitars.append(Guitar("Gibson L-5 CES", 1922, 16035.40))
    guitars.append(Guitar("Line 6 JTV-59", 2010, 1512.9))

    if guitars:
        guitars.sort()

        print("These are my guitars:")
        for i, guitar in enumerate(guitars):
            vintage_string = ""
            if guitar.is_vintage():
                vintage_string = "(vintage)"
            print("Guitar {0}: {1.name:>30} ({1.year}), worth ${1.cost:10,.2f}\
             {2}".format(i + 1, guitar, vintage_string))
    else:
        print("No guitars :( Quick, go and buy one!")
예제 #5
0
파일: command.py 프로젝트: franckv/dischord
def do_chord(options, chord):
    g = Guitar(frets=options.frets)
    scope = get_scope(options, g)

    lines = g.get_chord(chord, scope)
    for line in lines:
        print(line)
def main():
    """Guitar program, using Guitar class."""
    guitars = []

    print("My guitars!")
    name = input("Name: ")
    while name != "":
        year = int(input("Year: "))
        cost = float(input("Cost: $"))
        guitar_to_add = Guitar(name, year, cost)
        guitars.append(guitar_to_add)
        print(guitar_to_add, "added.")
        name = input("Name: ")

    guitars.append(Guitar("Gibson L-5 CES", 1922, 16035.40))
    guitars.append(Guitar("Line 6 JTV-59", 2010, 1512.9))

    if guitars:
        guitars.sort(key=attrgetter("year"))
        print("These are my guitars:")
        for i, guitar in enumerate(guitars):
            vintage_string = ""
            if guitar.is_vintage():
                vintage_string = "(vintage)"
            print("Guitar {}: {:>20} ({}), worth ${:10,.2f}{}".format(i + 1, guitar.name, guitar.year, guitar.cost,
                                                                      vintage_string))
    else:
        print("No guitars!")
예제 #7
0
파일: guitars.py 프로젝트: tilsies/CP1404
def main():

    guitars = []
    print("My guitars!")

    name = input("Name: ")
    while name != "":
        year = int(input("Year: "))
        cost = float(input("Cost: $"))
        new_guitar = Guitar(name, year, cost)

        guitars.append(new_guitar)
        name = input("Name: ")

    guitars.append(Guitar("Gibson L-5 CES", 1922, 16035.40))
    guitars.append(Guitar("Line 6 JTV-59", 2010, 1512.9))

    if guitars:
        guitars.sort()
        print("These are my guitars: ")

        for i, guitar in enumerate(guitars, 1):
            if guitar.is_vintage():
                vintage = "(Vintage)"
            else:
                vintage = ""

            print("Guitar {}: {:<20} ({}), worth ${:10,.2f} {}".format(
                i, guitar.name, guitar.year, guitar.cost, vintage))

    else:
        print("No guitars?!")
예제 #8
0
def main():
    """Guitar program is worked by Guitar class"""

    print("My guitars!")
    name = input("Name: ")
    while name != "":
        year = int(input("year: "))
        cost = float(input("Cost: $"))
        add_information = Guitar(name, year, cost)
        guitars.append(add_information)
        print(add_information, "added.")
        name = input("Name: ")

    guitars.append(Guitar("Gibson L-5 CES", 1922, 16035.40))
    guitars.append(Guitar("Line 6 JTV-59", 2010, 1512.9))

    if guitars:
        guitars.sort(
        )  # sorting by year through the __lt__ method in Guitar class
        print("These are my guitars:")
        for thing, things in enumerate(guitars):  # display number of guitar
            vintage_string = ""
            if things.is_vintage():
                vintage_string = "(vintage)"
            print("Guitar {}: {:>20} ({}), worth ${:10,.2f}{}".format(
                thing, things.name, things.year, things.cost, vintage_string))
    else:
        print("No guitars")
예제 #9
0
def main():
    guitar1 = Guitar("Fender Stratocaster", 2014, 765.40)
    guitar2 = Guitar("Gibson", 1922, 16000)
    guitar3 = Guitar("line", 2010, 1965)
    guitars = [guitar1,guitar2,guitar3]
    for i,guitar in enumerate(guitars):
        print("Guitar {}: {}".format(i,guitar))
예제 #10
0
파일: command.py 프로젝트: franckv/dischord
def do_scale(options, scale):
    g = Guitar(frets=options.frets)
    scope = get_scope(options, g)

    if options.mode == "major":
        notes = scales.diatonic(scale)
    elif options.mode == "minor":
        notes = scales.harmonic_minor(scale)
    elif options.mode == "natural_minor":
        notes = scales.natural_minor(scale)
    elif options.mode == "harmonic_minor":
        notes = scales.harmonic_minor(scale)
    elif options.mode == "melodic_minor":
        notes = scales.melodic_minor(scale)
    elif options.mode == "ionian":
        notes = scales.ionian(scale)
    elif options.mode == "dorian":
        notes = scales.dorian(scale)
    elif options.mode == "phrygian":
        notes = scales.phrygian(scale)
    elif options.mode == "lydian":
        notes = scales.lydian(scale)
    elif options.mode == "mixolydian":
        notes = scales.mixolydian(scale)
    elif options.mode == "aeolian":
        notes = scales.aeolian(scale)
    elif options.mode == "locrian":
        notes = scales.locrian(scale)

    lines = g.get_notes(notes, scope)
    for line in lines:
        print(line)
예제 #11
0
def test_string_tab(net, test_data):
    net.load_state_dict(torch.load('2fac_checkpoint.pt'))
    net.eval()
    criterion = nn.MSELoss()

    testset = MyDataset(parameters=test_data['parameters'], cqt_spectrograms=test_data['cqt_spec'])
    testloader = torch.utils.data.DataLoader(testset, batch_size=4,
                                             shuffle=False, num_workers=2)
    
    inputs, targets = iter(testloader).next()
    inputs = inputs.to(device)
    targets = targets.to(device)
    
    gt_samples = []
    gt_stringNumbers = []
    gt_tabs = []
    
    for i in range(len(targets)):
        gt_stringNumber, gt_tab = targets.cpu().numpy()[i]
        guitar = Guitar(options=Options())
        gt_stringNumbers.append(gt_stringNumber)
        gt_tabs.append(gt_tab)
        #print("gt_stringNumber: %.3f, gt_tab: %.3f" % (gt_stringNumber, gt_tab))
        audio_buffer = sequencer.play_note(guitar, int(round(gt_stringNumber)), int(round(gt_tab)))
        #cqt_spec = cqt_transform.compute_cqt_spec(audio_buffer).T
        #padded_cqt = pad_zeros(cqt_spec, (cqt_spec.shape[1], cqt_spec.shape[1]))        
        gt_samples.append(audio_buffer)

    with open("2fac_gt_data.pkl", 'wb') as fh:
        data_dict = {'gt_samples' : np.array(gt_samples), 'gt_stringNumbers' : np.array(gt_stringNumbers), 'gt_tabs' : np.array(gt_tabs), 'gt_cqts' : inputs.cpu().numpy()}
        pkl.dump(data_dict, fh)
    fh.close()

    preds = net(inputs.unsqueeze_(1))
    preds = preds.detach().cpu().numpy()
    
    pred_samples = []
    pred_cqts = []
    pred_stringNumbers = []
    pred_tabs = []
    
    for i in range(preds.shape[0]):
        pred_stringNumber, pred_tab = preds[i]
        guitar = Guitar(options=Options())
        #print("pred_stringNumber: %d, pred_tab: %d" % (int(round(pred_stringNumber)), int(round(pred_tab))))
        pred_stringNumbers.append(pred_stringNumber)
        pred_tabs.append(pred_tab)
        audio_buffer = sequencer.play_note(guitar, int(round(pred_stringNumber)), int(round(pred_tab)))
        cqt_spec = cqt_transform.compute_cqt_spec(audio_buffer, n_bins=336, bins_per_octave=48, hop_length=256).T
        padded_cqt = pad_zeros(cqt_spec, (cqt_spec.shape[1], cqt_spec.shape[1]))      
        pred_cqts.append(padded_cqt.T)
        pred_samples.append(audio_buffer)
        
    with open("2fac_pred_data.pkl", 'wb') as fh:
        data_dict = {'pred_samples' : np.array(pred_samples), 'pred_stringNumbers' : np.array(pred_stringNumbers), 'pred_tabs' : np.array(pred_tabs), 'pred_cqts' : pred_cqts}
        pkl.dump(data_dict, fh)
    fh.close()
    
    print('test_loss: %.3f' % evaluate(net, testloader))
예제 #12
0
def main():
    gibson = Guitar("Gibson L-5 CES", 1922, 16045.40)
    another = Guitar("Another Guitar", 2013, 10904.75)

    print(f"{gibson.name} get_age() - Expected 98. Got {gibson.get_age()}")
    print(f"{another.name} get_age() - Expected 7. Got {another.get_age()}")
    print(f"{gibson.name} is_vintage() - Expected True. Got {gibson.is_vintage()}")
    print(f"{another.name} is_vintage() - Expected False. Got {another.is_vintage()}")
예제 #13
0
def main():
    """Demo a guitar"""
    guitar_a = Guitar("Gibson L-5 CES", 50, 16035.40)
    print("{} get age()-Excepted {}.got {}".format(guitar_a.name,
                                                   guitar_a.get_age(),
                                                   guitar_a.get_age()))
    print("{} get is vintage()-Excepted {}.Got {}".format(
        guitar_a.name, guitar_a.is_vintage(), not (guitar_a.is_vintage())))
 def __init__(self, **kwargs):
     """
     Construct main app.
     """
     super().__init__(**kwargs)
     # Basic data example - list of Guitar objects - could be loaded from a file or something
     self.guitars = [Guitar("Gibson L-5 CES", 1922, 16035.40),
                     Guitar("Line 6 JTV-59", 2010, 1512.9),
                     Guitar("Ukelele", 2017, 99.95)]
예제 #15
0
def main():
    """
    get information of guitars and print them
    """
    guitars = []  # create the list to store  guitar information
    # get_guitars(guitars)  # get user input of guitar information
    guitars.append(Guitar("Gibson L-5 CES", 1922, 16035.40))  # for testing
    guitars.append(Guitar("Line 6 JTV-59", 2010, 1512.9))  # for testing
    print_guitars(guitars)  # print guitar information
예제 #16
0
def main():

    gibson = Guitar("Gibson L-5 CES", 1922, 16035.40)
    another_guitar = (
        "Another Guitar",
        2013,
    )
    print(gibson.get_age())
    print(gibson.is_vintage())
예제 #17
0
def main():
    """Test guitar.py module for errors."""
    guitar_one = Guitar("Gibson L-5 CE", 1922, 16035.40)  # Expected: 99, True
    guitar_two = Guitar("Martin OM-45", 1930, 265000.00)  # Expected: 91, True
    guitar_three = Guitar("Jazzmaster Squier", 1990, 399.00)  # Expected: 31, False
    print(f"{guitar_one.name} get_age() - Expected 99. Got {guitar_one.get_age()}")
    print(f"{guitar_two.name} get_age() - Expected 91. Got {guitar_two.get_age()}")
    print(f"{guitar_three.name} get_age() - Expected 31. Got {guitar_three.get_age()}")
    print(f"{guitar_one.name} is_vintage() - Expected True. Got {guitar_one.is_vintage()}")
    print(f"{guitar_two.name} is_vintage() - Expected True. Got {guitar_two.is_vintage()}")
    print(f"{guitar_three.name} is_vintage() - Expected False. Got {guitar_three.is_vintage()}")
예제 #18
0
def sample_params_pitch_sf(size):
    freqs = np.array(utils.compute_freqs(num_frets))
    character_variation = np.array([np.random.uniform(0, 1) for _ in range(size)], dtype=np.float32)
    string_damping = np.array([np.random.uniform(0, 0.7) for _ in range(size)], dtype=np.float32)
    string_damping_variation = np.array([np.random.uniform(0, 0.5) for _ in range(size)], dtype=np.float32)
    pluck_damping = np.array([np.random.uniform(0, 0.9) for _ in range(size)], dtype=np.float32)
    pluck_damping_variation = np.array([np.random.uniform(0, 0.5) for _ in range(size)], dtype=np.float32)
    string_tension = np.array([np.random.uniform(0, 1) for _ in range(size)], dtype=np.float32)
    stereo_spread = np.array([np.random.uniform(0, 1) for _ in range(size)], dtype=np.float32)
    smoothing_factor = np.array([np.random.uniform(0.5, 1) for _ in range(size)], dtype=np.float32)
    pitch = np.array([np.random.choice(freqs) for _ in range(size)], dtype=np.float32)
    #  ipdb.set_trace()
    options = []
    guitars = []
    audio_buffers = []
    cqt_specs = []
    for i in range(size):
        options.append(Options(character_variation[i], string_damping[i], string_damping_variation[i], pluck_damping[i], pluck_damping_variation[i], 
                         string_tension[i], stereo_spread[i]))
        guitars.append(Guitar(options=options[i]))
        audio_buffers.append(sequencer.play_note(guitars[i], 0, 0, pitch[i], smoothing_factor[i]))
#        print(audio_buffers[i])
#         try:
#             cqt_spec = compute_cqt_spec(audio_buffers[i]).T
#         except ParameterError:
#             print(audio_buffers[i])
        cqt_spec = compute_cqt_spec(audio_buffers[i]).T
        padded_cqt = pad_zeros(cqt_spec, (cqt_spec.shape[1], cqt_spec.shape[1]))
        cqt_specs.append(padded_cqt)
    cqt_specs = np.array(cqt_specs, dtype=np.float32)
    print(cqt_specs.shape)
    return character_variation, string_damping, string_damping_variation, pluck_damping, pluck_damping_variation, string_tension, stereo_spread, pitch, smoothing_factor, cqt_specs
예제 #19
0
def main():
    print("My guitars!")
    name = input("Name: ")
    while name != "":
        while True:
            try:
                year = int(input("Year: "))
                break
            except ValueError:
                print("Invalid year, please try again.")
        while True:
            try:
                cost = float(input("Cost: $"))
                break
            except ValueError:
                print("Invalid cost, please try again.")
        guitars.append(Guitar(name, year, cost))
        print(f"{name} ({year}) : ${cost:.2f} added.")
        name = input("\nName: ")
    # guitars.append(Guitar("Gibson L-5 CES", 1922, 16035.40))
    # guitars.append(Guitar("Line 6 JTV-59", 2010, 1512.9))
    print("\nThese are my guitars:")
    for i, guitar in enumerate(guitars, 1):
        is_vintage = " (vintage)" if guitar.is_vintage() else ""
        print(
            f"Guitar {i}: {guitar.name} ({guitar.year}), worth $ {guitar.cost:,.2f}{is_vintage}"
        )
예제 #20
0
def get_new_guitar():
    """Get new guitar details from a user."""
    name = input("Enter the guitars name: ")
    year = int(input("What year was it made?  "))
    cost = float(input("How much does it cost? "))

    return Guitar(name, year, cost)
예제 #21
0
def save_data_hdf5(fname, size):

    print('Generating {}...'.format(fname))

    freqs = np.array(utils.compute_freqs(num_frets))
    character_variation = np.array([np.random.uniform(0, 1) for _ in range(size)], dtype=np.float32)
    string_damping = np.array([np.random.uniform(0, 0.7) for _ in range(size)], dtype=np.float32)
    string_damping_variation = np.array([np.random.uniform(0, 0.5) for _ in range(size)], dtype=np.float32)
    pluck_damping = np.array([np.random.uniform(0, 0.9) for _ in range(size)], dtype=np.float32)
    pluck_damping_variation = np.array([np.random.uniform(0, 0.5) for _ in range(size)], dtype=np.float32)
    string_tension = np.array([np.random.uniform(0, 1) for _ in range(size)], dtype=np.float32)
    stereo_spread = np.array([np.random.uniform(0, 1) for _ in range(size)], dtype=np.float32)
    smoothing_factor = np.array([np.random.uniform(0.5, 1) for _ in range(size)], dtype=np.float32)
    pitch = np.array([np.random.choice(freqs) for _ in range(size)], dtype=np.float32)

    with h5py.File(fname, 'w') as f:
        dset_parameters = f.create_dataset('parameters', (size, 9), maxshape=(None, None), dtype='float32', chunks=(size, 9))
        dset_cqt_specs = f.create_dataset('cqt_spec', (size, 336, 336), maxshape=(None, None, None), dtype='float32', chunks=(1000, 336, 336))

        dset_parameters[:] = np.array([character_variation, string_damping, string_damping_variation, pluck_damping, pluck_damping_variation, string_tension, stereo_spread, pitch, smoothing_factor]).T

        for i in range(size):
            options = Options(character_variation[i], string_damping[i], string_damping_variation[i], pluck_damping[i], pluck_damping_variation[i], string_tension[i], stereo_spread[i])
            guitar = Guitar(options=options)
            audio_buffer = sequencer.play_note(guitar, 0, 0, pitch[i], smoothing_factor[i])
            cqt_spec = compute_cqt_spec(audio_buffer).T
            padded_cqt = pad_zeros(cqt_spec, (cqt_spec.shape[1], cqt_spec.shape[1]))

            dset_cqt_specs[i, :, :] = padded_cqt

    print('Finished generating {}!'.format(fname))
예제 #22
0
def main():
    done = False
    guitars = []
    print("My guitars!")
    while not done:
        name = input("Name: ")
        if not name:
            break
        else:
            try:
                year = int(input("Year: "))
                if not year:
                    raise Exception
            except:
                year = 0
            try:
                cost = float(input("Cost: $"))
                if not cost:
                    raise Exception
            except:
                cost = 0
            guitars.append(Guitar(name, year, cost))
    print("These are my guitars:")
    for i, guitar in enumerate(guitars, 1):
        print(
            f"Guitar {i:>{math.ceil(math.log(len(guitars),10))}}: {str(guitar): <{len(max(str(guitar) for guitar in guitars))}s}",
            '(vintage)' if guitar.is_vintage() else '')
예제 #23
0
파일: main.py 프로젝트: edsca/GuitarHelper
    def __init__(self, **kwargs):
        self.frets = kwargs.pop('frets')
        self.strings = kwargs.pop('strings')
        self.lefty = kwargs.pop('lefty')
        super(GuitarScreen, self).__init__(**kwargs)

        global noteButtons
        print(self.lefty)
        print(ORIENTATIONTABLE[0])
        if self.lefty == ORIENTATIONTABLE[0]:
            order = -1
        else:
            order = 1

        self.guitar = Guitar(number_of_frets=self.frets,
                             tuning=self.strings,
                             is_lefty=self.lefty)
        self.cols = self.frets
        self.rows = len(self.strings) + 2
        for string in self.guitar.strings:
            for note in string.notes[::order]:
                a = Button(text=str(note[0]))
                a.bind(on_press=self.callback)
                noteButtons.append(a)
                self.add_widget(a)

        for i in range(self.frets)[::order]:
            self.add_widget(Label(text=str(i)))
        for fret_marker in self.guitar.fret_markers:
            self.add_widget(Label(text=str(fret_marker)))
예제 #24
0
def main():
    print("My guitars!")
    guitars = []
    guitars.append(Guitar("Fender Stratocaster", 2014, 765.40))
    guitars.append(Guitar("Gibson L-5 CES", 1922, 16035.40))
    guitars.append(Guitar("Line 6 JTV-59", 2010, 1512.9))
    for i, guitar in enumerate(guitars):
        print("Name:", guitar.name)
        print("Year:", guitar.year)
        print("Cost:", guitar.cost)
        print("{} ({}) : {} added.".format(guitar.name, guitar.year,
                                           guitar.cost))
    print("These are my guitars:")
    for i, guitar in enumerate(guitars):
        print("Guitar {}: {} ({}), worth ${:10,.2f} ({})".format(
            i + 1, guitar.name, guitar.year, guitar.cost, guitar.is_vintage()))
예제 #25
0
def main():
    """Test Guitar Class functionality."""
    first_guitar = Guitar("Gibson L-5 CES", 1922, 16035.40)
    second_guitar = Guitar("Another Guitar", 2013, 1500.12)

    print("{} get_age() - Expected {}. Got {}".format(first_guitar.name, 99, first_guitar.get_age()))
    print("{} get_age() - Expected {}. Got {}".format(second_guitar.name, 8, second_guitar.get_age()))
    print("{} is_vintage() - Expected {}. Got {}".format(first_guitar.name, True, first_guitar.is_vintage()))
    print("{} is_vintage() - Expected {}. Got {}".format(second_guitar.name, False, second_guitar.is_vintage()))
예제 #26
0
def test():
    guitar1 = Guitar('Gibson L-5 CES', 1922, 16035.40)
    guitar2 = Guitar('Another Guitar', 2013, 10000.00)
    print('{} get_age() - Expected {}. Got {}'.format(guitar1.name, 98,
                                                      guitar1.get_age()))
    print('{} get_age() - Expected {}. Got {}'.format(guitar2.name, 7,
                                                      guitar1.get_age()))
    print('{} is_vintage() - Expected {}. Got {}'.format(
        guitar1.name, True, guitar1.is_vintage()))
    print('{} is_vintage() - Expected {}. Got {}'.format(
        guitar2.name, False, guitar2.is_vintage()))
예제 #27
0
def main():
    print("My Guitars!")
    guitar_list = []
    name = input("Name: ")
    while name != "":
        year = int(input("Year: "))
        cost = float(input("Cost: $"))
        guitar = Guitar(name, year, cost)
        guitar_list.append(Guitar(name, year, cost))
        print(guitar, "added.")
        name = input("Name: ")

    for i, guitar in enumerate(guitar_list):
        if guitar.is_vintage():
            vintage_string = "(vintage)"
        else:
            vintage_string = ""
        print("Guitar {}: {:>20} ({}), worth ${:10,.2f} {}".\
              format(i+1, guitar.name, guitar.year, guitar.cost, vintage_string))
def main():
    name = "Gibson L-5 CES"
    year = 1922
    cost = 16035.40

    guitar = Guitar(name, year, cost)
    other = Guitar("Another Guitar", 2012, 1512.9)

    print("{} get_age() - Expected {}. Got {}".format(guitar.name, 97, guitar.get_age()))
    print("{} get_age() - Expected {}. Got {}".format(other.name, 7, other.get_age()))
    print("{} is_vintage - Expected {}. Got {}".format(guitar.name, True, guitar.is_vintage()))
    print("{} is_vintage - Expected {}. Got {}".format(other.name, False, other.is_vintage()))
예제 #29
0
def main():
    """Store all of input guitars in a list, then print their details."""
    guitars = []
    print("My guitars!")
    guitar_name = get_valid_string("Name: ")
    while guitar_name != "":
        guitar_year = get_valid_integer("Year: ")
        guitar_cost = get_valid_float("Cost: $")
        guitars.append(Guitar(guitar_name, guitar_year, guitar_cost))
        print(f"{guitar_name} ({guitar_year}) : ${guitar_cost:.2f} added.\n")
        guitar_name = get_valid_string("Name: ")
    print("These are my guitars:")
    display_all_guitars(guitars)
예제 #30
0
def read_guitars():
    """Open the file guitars.csv and return the contents."""
    guitars = []
    in_file = open('myguitars.csv', 'r')

    for line in in_file:
        parts = line.strip().split(',')
        year = int(parts[1])
        cost = float(parts[2])
        guitar_to_add = Guitar(parts[0], year, cost)
        guitars.append(guitar_to_add)

    return guitars
예제 #31
0
def get_guitars(guitars):
    """
    get guitar information including name, year and cost from user input
    """
    print("My guitars!")
    name = input("Name: ")
    while name != "":
        year = int(input("Year: "))
        cost = int(input("Cost: "))
        guitar = Guitar(name, year, cost)
        guitars.append(guitar)
        print("---------------------------------")
        name = input("Name: ")
예제 #32
0
def main():
    guitars_list = []
    print("My guitars!")
    name = input("Name:")

    while True:
        if name != "":
            year = input("Year:")
            cost = input("Cost:")
            add_guitars = Guitar(name, year, cost)
            guitars_list.append(add_guitars)

            print(name, year, cost, "added")

            name = input("Name:")
        else:
            for i in guitars_list:
                print(i)
            break

        guitars_list.append(Guitar("Gibson L-5 CES", 1922, 16035.40))
        guitars_list.append(Guitar("Line 6 JTV-59", 2010, 1512.9))
예제 #33
0
def run_tests():
    """Tests for Guitar class."""

    guitar1 = Guitar("Guitar1", 1950, 9999.9)
    guitar2 = Guitar("Guitar2", 2002, 4999.9)

    print("{} get_age() - Expected {}. Got {}".format(guitar1.name, 67,
                                                      guitar1.get_age()))
    print("{} get_age() - Expected {}. Got {}".format(guitar2.name, 15,
                                                      guitar2.get_age()))
    print()
    print("{} is_vintage() - Expected {}. Got {}".format(
        guitar1.name, True, guitar1.is_vintage()))
    print("{} is_vintage() - Expected {}. Got {}".format(
        guitar2.name, False, guitar2.is_vintage()))
예제 #34
0
def main():

    guitar1 = Guitar("Fender Stratocaster",1923,765.4)
    print ('guitar1.get_age() - Expected 93. Got {}'.format(guitar1.get_age()))
    print ('guitar1.is_vintage - Expected True. Got {}'.format(guitar1.is_vintage()))

    print('')

    guitar2 = Guitar("Fender Stratocaster",1967,765.4)
    print ('guitar2.get_age() - Expected 49. Got {}'.format(guitar2.get_age()))
    print ('guitar2.is_vintage - Expected False. Got {}'.format(guitar2.is_vintage()))
예제 #35
0
from guitar import Guitar

Gibson = Guitar("Gibson L-5 CES" , 1922, 16035.40)
Hendjai = Guitar("Hendjai L-4 DUN", 2010, 16035.40)
print(Gibson)
print(Gibson.get_age())
print(Gibson.is_vintage())
print(Hendjai)
print(Hendjai.get_age())
print(Hendjai.is_vintage())
from guitar import Guitar

test = Guitar("test", 1992, 100)
print(test)
test.get_age()
print(test.is_vintage())

guitars = []
guitars.append(Guitar("Gibson L-5 CES", 1992, 16035.40))
guitars.append(Guitar("Line 6 JTV-59", 2010, 1512.9))

for i, guitar in enumerate(guitars):
    print("Guitar {}: {:>20} ({}), worth ${:10,.2f}".format(i + 1, guitar.name, guitar.year, guitar.cost))
예제 #37
0
from guitar import Guitar

guitar1 = Guitar("Fender Stratocaster", 2014, 765.40)
guitar2 = Guitar("Gibson L-5 CES", 1922, 16032.40)

print(guitar1.get_age())
print(guitar2.get_age())
print(guitar1.is_vintage())
print(guitar2.is_vintage())
from guitar import Guitar

my_guitar = Guitar("Fender Stratocaster", 1954, 25000)

print(my_guitar)
print(my_guitar.get_age())
print("This guitar is vintage: {}".format(my_guitar.is_vintage()))
예제 #39
0
def main():
    g1 = Guitar("abc", 1910, 65)
    g1.get_age()
    if g1.is_vintage():
        print("vintage")
    print(g1)
예제 #40
0
from guitar import Guitar

gibson = Guitar("Gibson L-5 CES", 1922, 16035.40)
new = Guitar("GG", 2010, 19000)
print(gibson)
print(gibson.get_age())
print(gibson.is_vintage())
print(new.get_age())
print(new.is_vintage())