from building import Building
from city import City
# Birth of a City
# Create a new city instance and add your building instances to it. Once all buildings are in the city, iterate the city's building collection and output the information about each building in the city.
megalopolis = City("CherkeskyLand", "Guy Cherkesky", "1980")
# Awesome code here
dwell1 = Building("1234 2nd Ave S #4", "2")
dwell1.construct()
dwell1.purchase("Bill Gates")
# dwell1.print_building()
dwell2 = Building("1234 2nd Ave S #7", "2")
dwell2.construct()
dwell2.purchase("Bill Gates")
# dwell2.print_building()
dwell3 = Building("1234 2nd Ave S #13", "2")
dwell3.construct()
dwell3.purchase("Bill Gates")
# dwell3.print_building()
dwell2 = Building("1234 2nd Ave S #7", "2")
dwell2.construct()
dwell2.purchase("Bill Gates")
# dwell2.print_building()
clifton1 = Building("620 27th Ave N", "3")
clifton1.construct()
SecondBuilding = Building("202 2nd Street", 20)
ThirdBuilding = Building("303 3rd Street", 30)
FourthBuilding = Building("404 4th Street", 40)
FifthBuilding = Building("505 5th Street", 50)
# Have each one get purchased by a real estate magnate
FirstBuilding.purchase("RealEstateMagnate1")
SecondBuilding.purchase("RealEstateMagnate2")
ThirdBuilding.purchase("RealEstateMagnate3")
FourthBuilding.purchase("RealEstateMagnate4")
FifthBuilding.purchase("RealEstateMagnate5")
# After purchased, construct each one
FirstBuilding.construct()
SecondBuilding.construct()
ThirdBuilding.construct()
FourthBuilding.construct()
FifthBuilding.construct()
# Once all building are purchased and constructed, print the address, owner, stories, and date constructed to the terminal for each one.
# Example
# 800 8th Street was purchased by Bob Builder on 03/14/2018 and has 12 stories.
print(
f'{FirstBuilding.address} was purchased by {FirstBuilding.owner} on {FirstBuilding.date_constructed} and has {FirstBuilding.stories} stories'
)
print(
f'{SecondBuilding.address} was purchased by {SecondBuilding.owner} on {SecondBuilding.date_constructed} and has {SecondBuilding.stories} stories'
)
from building import Building
from city import City
three_o_one = Building("301 Plus Park", 4)
five_hundred = Building("500 Interstate Blvd S", 5)
executive_south = Building("1 Executive South", 10)
curts_house = Building("100 Curt's House", 2)
large_skyscraper = Building("3030 Oprah Rd", 100)
three_o_one.purchase("Dr. Phil")
five_hundred.purchase("Joe Shep")
executive_south.purchase("Drew Pazola")
curts_house.purchase("Curt Cato")
large_skyscraper.purchase("Oprah")
three_o_one.construct()
five_hundred.construct()
executive_south.construct()
curts_house.construct()
large_skyscraper.construct()
megalopolis = City()
megalopolis.add_building(three_o_one)
megalopolis.add_building(five_hundred)
megalopolis.add_building(executive_south)
megalopolis.add_building(curts_house)
megalopolis.add_building(large_skyscraper)
for building in megalopolis.buildings:
print(building)
from building import Building
from city import City
eight_hundred_eighth = Building("800 8th Street", 12)
cherry_blossom = Building("Grandma's House", 3)
stillwater = Building("1755 Stillwater Circle", 3)
springHill = Building("495 Riverfront Parkway", 6)
nss = Building("301 Plus Park Blvd", 5)
eight_hundred_eighth.purchase("Roxanne Nasraty")
eight_hundred_eighth.construct()
eight_hundred_eighth.name = "Building 808"
eight_hundred_eighth.building_summary()
print()
cherry_blossom.purchase("Rachel Wohl")
cherry_blossom.construct()
cherry_blossom.name = "Cherry Blossom"
cherry_blossom.building_summary()
print()
stillwater.purchase("Katie Wohl")
stillwater.construct()
stillwater.name = "Stillwater"
stillwater.building_summary()
print()
springHill.purchase("Dwayne Massengale")
springHill.construct()
springHill.name = "SpringHill Suites"
springHill.building_summary()
print()
nss.purchase("John Wark")
nss.construct()
from building import Building
from city import City
building_one = Building("5 Pennies Ln", 5)
building_one.construct()
building_one.purchase("Mighty Man")
building_two = Building("3 Yard St", 3)
building_two.construct()
building_two.purchase("Mighty Man")
building_three = Building("0 Candy Ave", 10)
building_three.construct()
building_three.purchase("Mighty Man")
building_four = Building("6 Lap Blvd", 20)
building_four.construct()
building_four.purchase("Mighty Man")
building_five = Building("9 Freed Way", 9)
building_five.construct()
building_five.purchase("Mighty Man")
megalopolis = City("Megalopolis", "Megamind", 2020)
megalopolis.buildings.append(building_one)
megalopolis.buildings.append(building_two)
megalopolis.buildings.append(building_three)
megalopolis.buildings.append(building_four)
megalopolis.buildings.append(building_five)
for building in megalopolis.buildings:
from building import Building
from city import City
westin = Building("Westin", "807 Clark Place", 26)
jw = Building("JW", "201 8th Ave S", 28)
hilton = Building("Hilton", "121 4th Ave S", 18)
sheraton = Building("Sheraton", "623 Union St", 33)
union_station = Building("Union Station", "1001 Broadway", 9)
westin.purchase("Mama Bear")
jw.purchase("Papa Bear")
hilton.purchase("Sister Bear")
sheraton.purchase("Brother Bear")
union_station.purchase("Honey Bear")
westin.construct()
jw.construct()
hilton.construct()
sheraton.construct()
union_station.construct()
megalopolis = City("Megalopolis", "Kitty Baby", 2012)
megalopolis.add_building(westin)
megalopolis.add_building(jw)
megalopolis.add_building(hilton)
megalopolis.add_building(sheraton)
megalopolis.add_building(union_station)
print(f'{megalopolis.mayor} is the mayor of the wonderful city of {megalopolis.name}, which was founded in {megalopolis.year}. The following lavish building are located in {megalopolis.name}:')
print()
# Create 5 building instances
b1 = Building("123 Street St", 450)
b2 = Building("456 Street Ave", 3)
b3 = Building("8 Eigth Ave", 9)
b4 = Building("223 Baker St", 100)
b5 = Building("7 Wallaby Rd", 1)
# Have each one get purchased by a real estate magnate
b1.purchase("Johnny Johnson")
b2.purchase("Fred Frederickson")
b3.purchase("Natalie Nettles")
b4.purchase("George Washington III")
b5.purchase("Abe Laboriel JR")
# After purchased, construct each one
b1.construct()
b2.construct()
b3.construct()
b4.construct()
b5.construct()
# Create a new city instance and add your building instances to it. Once all buildings are in the city, iterate the city's building collection and output the information about each building in the city.
gotham = City("Gotham")
bldgs = [b1, b2, b3, b4, b5]
for bldg in bldgs:
gotham.add_building(bldg)
for building in gotham.buildings:
gotham = City("Gotham", "Mayor Pete", "1985")
# Create 5 building instances
building_1 = Building("1500 S Wacker", 25)
building_2 = Building("Elysian Fields", 47)
building_3 = Building("Versailles", 20)
building_4 = Building("Brokedown Palace", 2)
building_5 = Building("shack", 1)
# Have each one get purchased by a real estate magnate
# After purchased, construct each one
# print(building_1.name)
building_1.purchase("some rich guy")
building_1.construct()
building_2.purchase("Rich Uncle Pennybags")
building_2.construct()
building_3.purchase("Warren Buffet")
building_3.construct()
building_4.purchase("Patti Lapone")
building_4.construct()
building_5.purchase("Patti LaBelle")
building_5.construct()
# Create a new city instance and add your building instances to it. Once all buildings are in the city, iterate the city's building collection and output the information about each building in the city.
# Awesome code here
gotham.add_building(building_1)
gotham.add_building(building_2)
gotham.add_building(building_3)
gotham.add_building(building_4)
from building import Building
from city import City
# Creating a new city instance
megtropolis = City("Megtropolis", "Rob Downey Jr")
#### Creating buildings for our new city ####
batman_building = Building("123 main st", 20)
batman_building.purchase("Real estate company")
batman_building.construct()
# batman_building.print_description()
renaissance_hotel = Building("400 Carothers Blvd", 9)
renaissance_hotel.purchase("Big Brothers Group")
renaissance_hotel.construct()
# renaissance_hotel.print_description()
capital_building = Building("12 Capital Blvd", 4)
capital_building.purchase("Git-Er-Done Real Estate Group")
capital_building.construct()
# capital_building.print_description()
regions_bank = Building("8088 Regions Blvd", 3)
regions_bank.purchase("Financial Real Estate Group")
regions_bank.construct()
# regions_bank.print_description()
empire_state = Building("20 W 34th St, New York, NY 10001", 102)
empire_state.purchase("Capital Investments")
empire_state.construct()
# empire_state.print_description()
from city import City
eight_hundred_eighth = Building("800 8th Street", 12)
building_two = Building("2nd st", 17)
building_three = Building("3rd st", 5)
building_four = Building("4th ave", 23)
building_five = Building("5th blvd", 11)
building_five.purchase("Fred")
building_four.purchase("Fredward")
building_three.purchase("Freddifer")
building_two.purchase("Freddy")
eight_hundred_eighth.purchase("Fredegar")
building_five.construct()
eight_hundred_eighth.construct()
building_four.construct()
building_three.construct()
building_two.construct()
building_five.building_print()
building_four.building_print()
eight_hundred_eighth.building_print()
building_three.building_print()
building_two.building_print()
megalopolis = City()
megalopolis.add_building(building_five)
megalopolis.add_building(eight_hundred_eighth)
megalopolis.add_building(building_four)
sentence_1 = sentence[:-1]
sentence_2 = sentence_1 + "."
print(sentence_2)
veggie = Pizza()
veggie.size = "large"
veggie.crust_type = "hand-tossed"
veggie.toppings = ["spinach,", "peppers,", "cucumbers,", "olives,"]
veggie.add_toppings("onion,")
# veggie.pizza_sentence()
nss_building = Building("301 Plus Park Blvd", 5)
nss_building.designer = "Frank Lloyd Wright"
nss_building.purchase("Cohort 33")
nss_building.construct()
# nss_building.solution_sentence()
nss_building = Building("1 place drive", 653)
nss_building.designer = "bob"
nss_building.purchase("fred")
nss_building.construct()
# nss_building.solution_sentence()
nss_building = Building("2 place drive", 142)
nss_building.designer = "frank"
nss_building.purchase("jen")
nss_building.construct()
# nss_building.solution_sentence()
nss_building = Building("3 place drive", 87)
from building import Building
from city import City
megalopolis = City("Nashville", "Mayor", "1892")
waffle_house = Building("2020 Murfreesboro Pk", 1)
amazon = Building("Downtown", 24)
new_school = Building("300 Plus Park", 5)
old_school = Building("500 Interstate Blvd", 4)
pre_school = Building("123 Sesame St", 2)
waffle_house.construct()
amazon.construct()
new_school.construct()
old_school.construct()
pre_school.construct()
waffle_house.purchase("IHOP")
amazon.purchase("Dr Phil")
new_school.purchase("John Wark")
old_school.purchase("MLS")
pre_school.purchase("Barney")
megalopolis.buildings.append(waffle_house)
megalopolis.buildings.append(amazon)
megalopolis.buildings.append(new_school)
megalopolis.buildings.append(old_school)
megalopolis.buildings.append(pre_school)
for buildings in megalopolis.buildings:
print(buildings)
from building import Building
from city import City
eight_hundred_eighth = Building("800 8th Street", 12)
umpire_state_building = Building("23 Umpire Blvd", 40)
central_town_hall = Building("123 Main Ave", 3)
batman_building = Building("400 Gotham Drive", 50)
that_building = Building("45023 Madeup Pkwy", 8)
eight_hundred_eighth.purchase("Monopoly Guy")
umpire_state_building.purchase("Jane Mogul")
central_town_hall.purchase("Richie Rich")
batman_building.purchase("Trust Fund Baby")
that_building.purchase("Bucky Dollarroo")
eight_hundred_eighth.construct()
umpire_state_building.construct()
central_town_hall.construct()
batman_building.construct()
that_building.construct()
gotham = City("Gotham", "Oswald Chesterfield Cobblepot", "1635")
gotham.add_buildings([
eight_hundred_eighth,
umpire_state_building,
central_town_hall,
batman_building,
that_building,
])
from building import Building
from city import City
megalopolis = City()
eight_hundred_eighth = Building("800 8th Street", 12)
easy_street_jazz_club = Building("123 easy Street", 3)
smokey_oaks_bar_and_restaurant = Building("56 Main Street", 1)
highrise_luxury_hotel = Building("2347 Golden Glow Road", 18)
only_stairs = Building("1 long walks ave", 200)
eight_hundred_eighth.construct()
easy_street_jazz_club.construct()
smokey_oaks_bar_and_restaurant.construct()
highrise_luxury_hotel.construct()
only_stairs.construct()
eight_hundred_eighth.purchase("Bob the Builder")
easy_street_jazz_club.purchase("Smooth Jazz JJ")
smokey_oaks_bar_and_restaurant.purchase("Ol' Rick")
highrise_luxury_hotel.purchase("Marriot")
only_stairs.purchase("Anonymous Buyer")
megalopolis.construct(eight_hundred_eighth)
megalopolis.construct(easy_street_jazz_club)
megalopolis.construct(smokey_oaks_bar_and_restaurant)
megalopolis.construct(highrise_luxury_hotel)
megalopolis.construct(only_stairs)
for building in megalopolis.buildings:
# Create a new city instance and add your building
# instances to it. Once all buildings are in the city,
# iterate the city's building collection and output the
# information about each building in the city.
# megalopolis = City()
# for building in megalopolis.buildings:
# print(building)
new_york = City("New York", "Dan Jones", "1885")
Adrians_building = Building("800 Parkway Drive", 25)
Adrians_building.purchase("Adrian Reeds")
Adrians_building.construct()
new_york.add_building(Adrians_building)
Kristens_building = Building("1200 Seaway Pass", 58)
Kristens_building.purchase("Kristen Reeds")
Kristens_building.construct()
new_york.add_building(Kristens_building)
Savannahs_building = Building("P Sherman 42 Wallaby Way Sydney", 45)
Savannahs_building.purchase("Savannah Reeds")
Savannahs_building.construct()
new_york.add_building(Savannahs_building)
Matts_building = Building("23 Westwood Avenue", 25)
Matts_building.purchase("Matt Reeds")
Matts_building.construct()
from building import Building
from city import City
# import datetime
eight_hundred_eighth = Building("800 8th Street", 12)
eight_hundred_eighth.purchase("Donald Duck")
eight_hundred_eighth.construct()
print(
f'{eight_hundred_eighth.address} was purchased by {eight_hundred_eighth.owner} on {eight_hundred_eighth.date_constructed} and has {eight_hundred_eighth.stories} stories'
)
home = Building("2339 Devonshire Dr.", 2)
home.purchase("Mickey Mouse")
home.construct()
print(
f'{home.address} was purchased by {home.owner} on {home.date_constructed} and has {home.stories} stories'
)
school = Building("301 Plus Park Blvd", 5)
school.purchase("Goofy")
school.construct()
print(
f'{school.address} was purchased by {school.owner} on {school.date_constructed} and has {school.stories} stories'
)
Nashville = City("Nashville", "Jeff")
Nashville.established()
Nashville.add_building(home)
Nashville.add_building(school)
Nashville.add_building(eight_hundred_eighth)
megalopolis = City("Megalopolis", "Jimmy", 2020)
one = Building("11 1st Street", 11)
two = Building("22 2nd Street", 12)
three = Building("33 3rd Street", 13)
four = Building("44 4th Street", 14)
five = Building("55 5th Street", 17)
one.purchase("Daniel")
two.purchase("Morgan")
three.purchase("Lisa")
four.purchase("Lauren")
five.purchase("Donald")
one.construct()
two.construct()
three.construct()
four.construct()
five.construct()
megalopolis.add_building(one)
megalopolis.add_building(two)
megalopolis.add_building(three)
megalopolis.add_building(four)
megalopolis.add_building(five)
for building in megalopolis.buildings:
print(
f"{building.address} was purchased by {building.owner} on {building.date_constructed} and has {building.stories} stories."
)
Emirates_Palace = Building("Emirates Palace",
"Corniche Rd W - Abu Dhabi - United Arab Emirates",
6)
Resorts_World_Sentosa = Building("Resorts World Sentosa",
"8 Sentosa Gateway, Singapore 098269", 12)
Marina_Bay_Sands = Building(
"Marina Bay Sands",
"10 Bayfront Avenue Hotel Towers, 1 2, 3, Singapore 018956", 57)
Abraj_Al_Bait = Building(
"Abraj Al Bait",
"AL HAJLAH MAKKAH CR ABRAJ AL-BAIT MALL, Mecca Saudi Arabia", 120)
The_Cosmopolitan_Of_Las_Vegas.purchase("The Blackstone Group")
Emirates_Palace.purchase("The Government of Abu Dhabi")
Resorts_World_Sentosa.purchase("Genting Group")
Marina_Bay_Sands.purchase("Las Vegas Sands")
Abraj_Al_Bait.purchase("Saudi Overlords")
The_Cosmopolitan_Of_Las_Vegas.construct()
Emirates_Palace.construct()
Resorts_World_Sentosa.construct()
Marina_Bay_Sands.construct()
Abraj_Al_Bait.construct()
Landopolis.buildings_list.extend([
The_Cosmopolitan_Of_Las_Vegas, Emirates_Palace, Resorts_World_Sentosa,
Abraj_Al_Bait, Marina_Bay_Sands
])
for building in Landopolis.buildings_list:
print(building)
# # Awesome code here
# for building in megalopolis.buildings:
# print(building)
from building import Building
from city import City
batman_bldg = Building("333 Commerce St", 100)
my_house_bldg = Building("Anderon Ln", 1)
tAndC_ford_bldg = Building("123 Gallatin Rd", 2)
madison_commCenter_bldg = Building("345 DuPont Ave", 4)
nash_soft_school_bldg = Building("301 Plus Park", 5)
batman_bldg.construct()
my_house_bldg.construct()
tAndC_ford_bldg.construct()
madison_commCenter_bldg.construct()
nash_soft_school_bldg.construct()
batman_bldg.purchase("Jimmy Jam")
my_house_bldg.purchase("Biance")
tAndC_ford_bldg.purchase("Sam Silly")
madison_commCenter_bldg.purchase("Alan Arf")
nash_soft_school_bldg.purchase("Some Dude")
all_Bldgs = [
nash_soft_school_bldg, batman_bldg, my_house_bldg, tAndC_ford_bldg,
madison_commCenter_bldg
]
from building import Building
from city import City
eight_hundred_eighth = Building("800 8th Street", 12)
eight_hundred_eighth.purchase("Fred Flintstone")
eight_hundred_eighth.construct()
# print(eight_hundred_eighth)
three_hundred = Building("300 Plus Park Blvd", 6)
three_hundred.purchase("Barney Rubble")
three_hundred.construct()
# print(three_hundred)
five_hundred = Building("500 Interstate Blvd", 3)
five_hundred.purchase("Wilma Flintstone")
five_hundred.construct()
# print(five_hundred)
two_hundred = Building("200 28th Street", 20)
two_hundred.purchase("Betty Rubble")
two_hundred.construct()
# print(two_hundred)
megalopolis = City()
megalopolis.add_building(eight_hundred_eighth)
megalopolis.add_building(three_hundred)
megalopolis.add_building(five_hundred)
megalopolis.add_building(two_hundred)
for building in megalopolis.buildings:
print(building)
# Create 5 building instances
eight_hundred_eighth = Building("800 8th Street", 8)
nine_hundred_nine = Building("900 9th Street", 11)
ten_hundred_ten = Building("1000 10th Street", 10)
seven_hundred_seven = Building("700 7th Street", 7)
six_hundred_six = Building("600 6th Street", 6)
# Have each one get purchased by a real estate magnate
eight_hundred_eighth.purchase("Monkey Chicken")
nine_hundred_nine.purchase("Caleb R.")
ten_hundred_ten.purchase("Magnate M.")
seven_hundred_seven.purchase("James J.")
six_hundred_six.purchase("Chicken Monkey")
# After purchased, construct each one
eight_hundred_eighth.construct()
nine_hundred_nine.construct()
ten_hundred_ten.construct()
seven_hundred_seven.construct()
six_hundred_six.construct()
# Once all building are purchased and constructed, print the address, owner, stories, and date constructed to the terminal for each one.
# Example: 800 8th Street was purchased by Bob Builder on 03/14/2018 and has 12 stories.
print(
f"{eight_hundred_eighth.address} was purchased by a {eight_hundred_eighth.owner} on {eight_hundred_eighth.date_constructed.date()} and has {eight_hundred_eighth.stories} stories."
)
# Create a new city instance and add your building instances to it. Once all buildings are in the city, iterate the city's building collection and output the information about each building in the city.
megalopolis = City()
from building import Building, big_building
from city import City
# Name of the city.
# The mayor of the city.
# Year the city was established.
# A collection of all of the buildings in the city.
# A method to add a building to the city.
megalopolis = City()
# Awesome code here
for building in megalopolis.buildings:
print(building)
megalopolis.name = "Big Town"
megalopolis.city = ["Wuts up"]
megalopolis.mayor = "Bob Jones"
megalopolis.year = "1815"
small_building = Building("700 7th Street", 13)
small_building.construct()
small_building.purchase("Cob")
megalopolis.add_building(small_building)
megalopolis.add_building(big_building)
megalopolis.destroy_city()
for building in megalopolis.buildings:
print(building.address)
from building import Building
from city import City
five_hundred_fifty_five_fifth = Building("Five's", "555 5th St", 34)
four_twentieth = Building("Mary Jane's", "4 20th St", 21)
twelfth_and_jefferson = Building("Montichello", "12th and Jefferson", 100)
six_bleeker = Building("The New York Sanctum", "6 Bleeker St", 3)
stark_tower = Building("Stark Tower", "600 Broadway", 150)
stark_tower.purchase("Tony Stark")
six_bleeker.purchase("Dr. Strange")
twelfth_and_jefferson.purchase("Thomas")
five_hundred_fifty_five_fifth.purchase("Jeff Bezos")
four_twentieth.purchase("Cheech and Chong")
stark_tower.construct()
four_twentieth.construct()
six_bleeker.construct()
five_hundred_fifty_five_fifth.construct()
twelfth_and_jefferson.construct()
gothom = City("Gothom City", "Alfred")
gothom.add_building(stark_tower)
gothom.add_building(six_bleeker)
gothom.add_building(five_hundred_fifty_five_fifth)
gothom.add_building(four_twentieth)
gothom.add_building(twelfth_and_jefferson)
for building in gothom.buildings:
print(f"\n{building.name} is on {building.address}. It has {building.stories} stories and is owned by {building.owner}. It was built on {building.date_constructed.strftime('%x')} by {building.designer}.")
# Once all buildings are in the city, iterate the city's building
# collection and output the information about each building in the city.
eight_hundred_eighth = Building("800 8th Street", 12)
seven_hundred_seventh = Building("700 7th Street", 44)
six_hundred_sixth = Building("600 6th Street", 13)
five_hundred_fifth = Building("500 5th Street", 99)
four_hundred_forth = Building("400 4th Street", 88)
eight_hundred_eighth.purchase("Kid Frost")
seven_hundred_seventh.purchase("MC Eight")
six_hundred_sixth.purchase("Dr. Dre")
five_hundred_fifth.purchase("B. Real")
four_hundred_forth.purchase("Mr. Cartoon")
eight_hundred_eighth.construct()
seven_hundred_seventh.construct()
six_hundred_sixth.construct()
five_hundred_fifth.construct()
four_hundred_forth.construct()
megalopolis = City()
megalopolis.add_building(eight_hundred_eighth)
megalopolis.add_building(seven_hundred_seventh)
megalopolis.add_building(six_hundred_sixth)
megalopolis.add_building(five_hundred_fifth)
megalopolis.add_building(four_hundred_forth)
for building in megalopolis.buildings:
print(
from building import Building
from city import City
eight_hundred_eighth = Building("800 8th Street", 12)
one_hundred_one = Building("101 1st st", 2)
two_hundred_one = Building("201 2nd st", 3)
three_hundred_three = Building("303 3rd st", 4)
six_hundred_six = Building("606 12th st", 14)
eight_hundred_eighth.purchase("Trinity")
one_hundred_one.purchase("Keaton")
two_hundred_one.purchase("Roxanne")
three_hundred_three.purchase("Michael")
six_hundred_six.purchase("Alyssa")
eight_hundred_eighth.construct()
one_hundred_one.construct()
two_hundred_one.construct()
three_hundred_three.construct()
six_hundred_six.construct()
print(f"{eight_hundred_eighth.address} was purchased by {eight_hundred_eighth.owner} on {eight_hundred_eighth.date_constructed} and has {eight_hundred_eighth.stories} stories")
print(f"{one_hundred_one.address} was purchased by {one_hundred_one.owner} on {one_hundred_one.date_constructed} and has {one_hundred_one.stories}")
print(f"{two_hundred_one.address} was purchased by {two_hundred_one.owner} on {two_hundred_one.date_constructed} and has {two_hundred_one.stories}")
print(f"{three_hundred_three.address} was purchased by {three_hundred_three.owner} on {three_hundred_three.date_constructed} and has {three_hundred_three.stories}")
print(f"{six_hundred_six.address} was purchased by {six_hundred_six.owner} on {six_hundred_six.date_constructed} and has {six_hundred_six.stories}")
