Assignment: Credit Card Transaction System using Python Inheritance

[Pankaj-Str]

Objective:

Use Python classes and inheritance to model a credit card transaction system that tracks customers, their credit cards, and transaction history.

Requirements:

1 Create a base class Customer

• Attributes: customer_id, customer_name
• Method: display_customer_info() – Returns a string with customer ID and name.

2 Create a class CreditCard that inherits from Customer

• Attributes: card_type (e.g., Amex, Visa), card_number
• Method: display_card_info() – Returns a string with card type and number.

3 Create a class Transaction that inherits from CreditCard

• Attributes: transaction_id, amount
• Method: display_transaction_info() – Returns a string with transaction ID and amount.

4 Create a class TransactionSummary that inherits from Transaction

• Attributes: total_transaction_amount
• Method: calculate_total_amount() – Takes a list of transactions and sums the amounts for the customer.

Tasks:

• Create at least three transaction objects for a single customer (e.g., two for a Visa card, one for an Amex card).
• Store all details for each transaction.
• Calculate the total transaction amount for the customer using calculate_total_amount().
• Print all details: Customer Info, Card Info for each card, Transaction Info for each transaction, and Total Transaction Amount.

Example Output:

Customer ID: C301 Customer Name: Michael Brown
Card Type: Visa Card Number: 123456789012
Transaction ID: T001 Amount: 1500
Transaction ID: T002 Amount: 2200
Card Type: Amex Card Number: 987654321098
Transaction ID: T003 Amount: 1800
Total Transaction Amount: 5500

Bonus:

Add a method to update the amount for any transaction and display a confirmation message.

[GawliYash20]

from typing import List
class Customer:
    def __init__(self, customer_id=None, customer_name=None, **kwargs):
        self.customer_id = customer_id
        self.customer_name = customer_name
    
    def display_customer_info(self):
       print(f'Customer ID: {self.customer_id} Customer Name: {self.customer_name}')

class CreditCard(Customer):
    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self.dictCards = {}

    
    def setCards(self ):
        n_cards = int(input('How many cards you want to enter?: '))
        for i in range(n_cards):
            card_no = int(input('please enter your card no: '))
            card_type = input(f'What is the card type for card no:{card_no}: ')
            self.dictCards[card_no] = card_type

    def display_card_info(self):
        for card_no, card_type in self.dictCards.items():
            print(f'Card type: {card_type} Card Number: {card_no}')
    
class Transaction(CreditCard):
    def __init__(self, **kwargs):
        super().__init__(**kwargs)    
    

    def display_transaction_info(self,card_no, transaction_id, transaction_amt):
        print()
        print(f'Card no: {card_no} Card type: {self.dictCards[card_no]}')
        print(f'Transaction ID: {transaction_id} Transaction Amount: {transaction_amt}')

class TransactionSummary(Transaction):
    def __init__(self, customer_id, customer_name):
        super().__init__(
            customer_id = customer_id,
            customer_name = customer_name
        )
        self._transaction_id = 0
        self.cardTrasact = []
        self.listTransact = []
        self.listTransactAmt = []
    


    def performTranact(self):
        if len(self.dictCards) == 0:
            print('please set the card using setCard()')
            return
        self.display_card_info()
        card_no = int(input('From which card you want to transact (Enter the card_no): '))
        self.cardTrasact.append(card_no)
        self._transaction_id += 1
        self.listTransact.append(self._transaction_id)
        amt = int(input('Enter the amount: '))
        self.listTransactAmt.append(amt)

    def display_transaction_info(self):
        self.display_customer_info()
        for i in range(len(self.listTransact)):
            super().display_transaction_info(self.cardTrasact[i], self.listTransact[i], self.listTransactAmt[i])
    
    def calculate_total_amount(self):
        print(f'Total Transaction Amount: {sum(self.listTransactAmt)}')


# def main():
#     ts = TransactionSummary(customer_id=1, customer_name="Alice")
    
#     ts.display_customer_info()
#     print('--- Setting Cards ---')
#     ts.setCards()

#     print('\n--- Performing Transactions ---')
#     ts.performTranact()
#     ts.performTranact()

#     print('\n--- Transaction Details ---')
#     ts.display_transaction_info()

#     print('\n--- Total Amount ---')
#     ts.calculate_total_amount()

# if __name__ == "__main__":
#     main()

This is the code I came up with.

[Hritik1200]

Assignment: Credit Card Transaction System using Python Inheritance

 class customer:
    def info(id,n):
        print("Customer ID :",id,"Customer Name: ",n)

class Bank(customer):
    def bank_AC(card_type,card_number):
        print("Card Type:",card_type,"Card Number:",card_number)
        
Limit1 = 0
class Creditc1(Bank):
    def card1(tran1,limit1):
        global Limit1
        Limit1 += limit1
        print("Transaction ID:",tran1," Amount:",limit1)

class Bank1(Creditc1):
    def bank_AC1(card_type1,card_number1):
        print("Card Type:",card_type1,"Card Number:",card_number1)

class Credit_limit(Bank1):
    def All_info():
        print("Total Transaction Amount:",Limit1)


a = Credit_limit
a.info(123,"Hritik")
a.bank_AC("Visa",880567840)
a.card1("T001",6000)
a.bank_AC1("Amex",7890456738)
a.All_info()

[DeveshPatill]

credit card Transaction system using python inheritence

class Customer:
    def __init__(self, customer_id, customer_name):
        self.customer_id = customer_id
        self.customer_name = customer_name

    def display_customer_info(self):
        return f"Customer ID: {self.customer_id} Customer Name: {self.customer_name}"


class CreditCard(Customer):
    def __init__(self, customer_id, customer_name, card_type, card_number):
        super().__init__(customer_id, customer_name)
        self.card_type = card_type
        self.card_number = card_number

    def display_card_info(self):
        return f"Card Type: {self.card_type} Card Number: {self.card_number}"


class Transaction(CreditCard):
    def __init__(self, customer_id, customer_name, card_type, card_number, transaction_id, amount):
        super().__init__(customer_id, customer_name, card_type, card_number)
        self.transaction_id = transaction_id
        self.amount = amount

    def display_transaction_info(self):
        return f"Transaction ID: {self.transaction_id} Amount: {self.amount}"

    def update_amount(self, new_amount):
        self.amount = new_amount
        return f"Transaction {self.transaction_id} updated to amount {self.amount}"


class TransactionSummary(Transaction):
    def __init__(self, customer_id, customer_name):
        self.transactions = []
        self.customer_id = customer_id
        self.customer_name = customer_name

    def add_transaction(self, transaction):
        self.transactions.append(transaction)

    def calculate_total_amount(self):
        return sum(t.amount for t in self.transactions)

    def display_summary(self):
        # Display customer info
        print(f"Customer ID: {self.customer_id} Customer Name: {self.customer_name}")
        # Display details grouped by card
        for t in self.transactions:
            print(t.display_card_info())
            print(t.display_transaction_info())
        # Display total
        print(f"Total Transaction Amount: {self.calculate_total_amount()}")


# ------------------- DEMO -------------------

# Create transaction summary for one customer
summary = TransactionSummary("C301", "Michael Brown")

# Add transactions
t1 = Transaction("C301", "Michael Brown", "Visa", "123456789012", "T001", 1500)
t2 = Transaction("C301", "Michael Brown", "Visa", "123456789012", "T002", 2200)
t3 = Transaction("C301", "Michael Brown", "Amex", "987654321098", "T003", 1800)

summary.add_transaction(t1)
summary.add_transaction(t2)
summary.add_transaction(t3)

# Update one transaction (bonus feature)
print(t2.update_amount(2500))  # Increase T002 from 2200 to 2500

# Display everything
summary.display_summary()