Object-Oriented Python Library Management System Guide

Crafting Realms in Object-Oriented Python

Explore our comprehensive guide on object-oriented Python for library management systems. Whether you're a novice or an experienced developer, this guide equips you with the skills needed to efficiently manage books and members while offering help with your Python assignment. Gain valuable insights into the principles of object-oriented programming, delve into the intricacies of borrowing and returning books, and discover the versatility of Python for building robust, real-world solutions. This guide is your go-to resource for enhancing your programming skills and tackling Python assignments with confidence.

Class Definitions:

`Book` class represents a book with attributes such as Number, Title, Author, Genre, SubGenre, Publisher, and availability status.
`Member` class represents a library member with attributes like ID, First Name, Last Name, Gender, Email, and a list of borrowed books.

Member and Book Initialization:

Both `Book` and `Member` classes have `__init__` methods to initialize their attributes when instances are created.

Scanning Methods:

Each class has a `scan` method to simulate scanning a book or membership card, returning relevant information.

Borrowing and Returning Books:

The `Member` class includes methods for borrowing and returning books (`borrow` and `return_book` methods, respectively).
When a member borrows a book, the book's availability is set to False, and the book is added to the member's list of borrowed books.
When a member returns a book, it checks if the book was borrowed by the member, calculates a fine for late returns, and updates book availability and the member's borrowed book list.

Creation of Book and Member Objects:

The code initializes dictionaries (`BooksDict` and `MembersDict`) where book and member objects are stored based on external data (`books_dict_json` and `membership_dict_json`).

Testing:

The code tests the `scan` methods with dummy data, creating instances of `Book` and `Member` classes and scanning them.

Now, let's split the code into smaller blocks and provide a detailed discussion of each block.

Block 1: `Book` Class Definition

```python
class Book:
#attributes associated with the book object
def __init__(self, Number, Title, Author, Genre, SubGenre, Publisher, Available=True):
self.Number = Number
self.Title = Title
self.Author = Author
self.Genre = Genre
self.SubGenre = SubGenre
self.Publisher = Publisher
self.Available = Available
self.BorrowTime = 0
```

This block defines the `Book` class, which represents a book.
The class has an `__init__` method to initialize its attributes: Number, Title, Author, Genre, SubGenre, Publisher, and Available (defaulted to True). It also initializes `BorrowTime` to 0.

Block 2: `scan` Method for `Book` Class

```python
def scan(self):
"""Simulate scanning a book's barcode.
Returns:
str: The book number.
"""
return self.Number, self.Title
```

This block defines a `scan` method for the `Book` class.
The method simulates scanning a book's barcode and returns the book's Number and Title.

Block 3: `repr` Method for `Book` Class

```python
def __repr__(self):
return f'{self.Title} By {self.Author}'
```

This block defines the `__repr__` method for the `Book` class.
The method returns a string representation of the book as its Title followed by its Author.

Block 4: `Member` Class Definition

```python
class Member:
def __init__(self, ID, FirstName, LastName, Gender, Email, CardNumber):
self.ID = ID
self.FirstName = FirstName
self.LastName = LastName
self.Gender = Gender
self.Email = Email
self.CardNumber = CardNumber
self.BorrowedBooks = []
```

This block defines the `Member` class, representing a library member.
The class has an `__init__` method to initialize attributes, including ID, First Name, Last Name, Gender, Email, CardNumber, and an empty list for borrowed books.

Block 5: `scan` Method for `Member` Class

```python
def scan(self):
"""Simulate scanning a membership card.
Returns:
str: The member ID.
"""
return self.ID, '{} {}'.format(self.FirstName, self.LastName), self.CardNumber
```

This block defines a `scan` method for the `Member` class.
The method simulates scanning a membership card and returns the member's ID, full name, and CardNumber.

Block 6: `repr` Method for `Member` Class

```python
def __repr__(self):
return f'{self.ID} - {self.FirstName} {self.LastName}'
```

This block defines the `__repr__` method for the `Member` class.
The method returns a string representation of the member with their ID and full name.

Block 7: `return_book` Method for `Member` Class

```python
def return_book(self, BookObject):
Found = False
for i in range(len(self.BorrowedBooks)):
if self.BorrowedBooks[i].Number == BookObject.Number:
Found = True
break
if Found:
BorrowTime = BookObject.BorrowTime
days = datetime.date.today() - BorrowTime
BookObject.BorrowTime = 0
BookObject.Available = True
self.BorrowedBooks.pop(i)
if days.days > 14:
fine = (days.days - 14)
print(f'The book has been returned late. The fine is £{fine:.2f}')
return fine
else:
print('The book has been returned successfully.')
return True
else:
print('The book is not borrowed by the member')
return False
```

This block defines the `return_book` method for the `Member` class, which allows a member to return a borrowed book. It checks for late returns, updates book availability, and handles the fine calculation.

Block 8: `borrow` Method for `Member` Class

```python
def borrow(self, BookObject):
if BookObject.Available:
BookObject.Available = False
BookObject.BorrowTime = datetime.date.today()
self.BorrowedBooks.append(BookObject)
print('Successfully loaned.')
return True
else:
print('Unable to loan.')
return False
```

This block defines the `borrow` method for the `Member` class, allowing members to borrow books, provided the book is available.

Block 9: Testing with Dummy Data


```python
# Create instances of Member and Book classes with dummy data
member1 = Member(35, "John", "Doe", "M", "j.doe@gmail.com", 18)
book1 = Book('22', "It Ends with Us", "Colleen Hoover", "Fiction", "Romance", "Penguin")
# Test the scan() methods and print the results
print("Scanning Member Card:")
member_scan_result = member1.scan()
print(f"Member ID: {member_scan_result[0]}, Full Name: {member_scan_result[1]}, Card Number: {member_scan_result[2]}")
print("\nScanning Book:")
book_scan_result = book1.scan()
print(f"Book Number: {book_scan_result[0]}, Title: {book_scan_result[1]}")
```

This block creates instances of the `Member` and `Book` classes with dummy data and tests their `scan` methods.

Block 10: Creating Book Objects

```python
BooksDict = {}
for i, j in books_dict_json.items():
BookObject = Book(j["Number"], j["Title"], j["Author"], j["Genre"], j["SubGenre"], j["Publisher"])
BooksDict[i] = BookObject
```

This block creates `Book` objects based on data from the `books_dict_json` dictionary and stores them in a `BooksDict` dictionary.

Block 11: Creating Member Objects

```python
MembersDict = {}
for i, j in membership_dict_json.items():
MemberObject = Member(j['ID'], j['FirstName'], j['LastName'], j['Gender'], j['Email'], j['CardNumber'])
MembersDict[i] = MemberObject
```

This block creates `Member` objects based on data from the `membership_dict_json` dictionary and stores them in a `MembersDict` dictionary.

Conclusion

In conclusion, our journey through the object-oriented Python code for the Library Management System reveals the power of OOP principles in real-world applications. By dissecting the intricacies of book and member management, we've explored the fundamental concepts of classes and methods, demonstrating how they facilitate efficient library operations. This guide serves as a valuable resource for both aspiring and seasoned programmers, highlighting the versatility of Python for creating robust, organized systems. It is a testament to the practicality and adaptability of object-oriented programming in the development of functional, real-world solutions.

Creating a Word in Object-Oriented Python: Library Management System