Say I have a Python class instance, here's a really simple example:

```
class Book:
    def __init__(self, genre):
        self.genre = genre
        self.author = self.title = None
        return

    def assign_author(self, author_name):
        self.author = author_name
        return

    def assign_title(self, title_name):
        self.title = title_name
        return

western_book_template = Book("Western")

```

For various reasons, I want each class instance to be able to generate a deep copy of itself, and then perform some additional manipulation on the new object.

Here's what I'd like to know:

1. What would be the most efficient way to do that?
2. What about the most Pythonic one (best practice)?
3. Does the amount of data stored in the instance, as well as the amount of computations performed to get to that data, influence the previous answers? If so, how?

I know I can use `western_book_1 = copy.deepcopy(western_book_template)`, and then perform all additional manipulation I want on `western_book_1` directly, but wouldn't it be better to do something like:

```
class Book:
    def __init__(self, genre):
        self.genre = genre
        self.author = self.title = None
        return

    def assign_author(self, author_name):
        self.author = author_name
        return

    def assign_title(self, title_name):
        self.title = title_name
        return

    def generate_specific_book(self, author_name, title_name):
        specific_book = Book(self.genre)
        specific_book.assign_author(author_name)
        specific_book.assign_title(title_name)
        return specific_book

western_book_template = Book("Western")
western_book_1 = western_book_template.generate_specific_book("John E. Williams", "Butcher's Crossing")

```

This would give me more control over what gets copied and what doesn't, as well as allowing me to perform all additional manipulation in one place. I am assuming the above is inefficient in cases where a lot of computation was needed to get to the data stored in the instance.