码迷,mamicode.com
首页 > 编程语言 > 详细

python银行处理

时间:2018-08-10 23:10:06      阅读:194      评论:0      收藏:0      [点我收藏+]

标签:input   gen   stat   for   path   界面   密码加密   port   内容   

用简单的面向对象方法模拟一个银行终端处理器

首先,先处理管理员登录,在这里默认管理员登录账号为admin  密码为123456

# 管理员系统
class Admin:
    # 输入参数   管理员卡号   管理员密码
    def __init__(self, account=admin, password=123456):
        self.account = account
        self.password = password
    # 欢迎界面

    def welcome(self):
        print(+ + - * 30 + +)
        print(| +   * 30 + |)
        print(| +   * 3 + 欢迎使用xx银行操作系统 +   * 5 + |)
        print(| +   * 30 + |)
        print(+ + - * 30 + +)
    # 操作界面

    def menu(self):
        print(+ + - * 30 + +)
        print(| + 开    户[1]         销    户[2] + |)
        print(| + 查询余额[3]         取    款[4] + |)
        print(| + 存    款[5]         转    账[6] + |)
        print(| + 修改密码[7]         锁定账户[8] + |)
        print(| + 解锁账户[9]         退    出[0] + |)
        print(| +      查询所有账户信息[10]       + |)
        print(+ + - * 30 + +)
    # 管理员登录

    def login(self):
        account = input(请输入管理员账号:)
        password = input(请输入管理员密码:)

        if account == admin and password == 123456:
            return True
        return False
# 这里模拟了管理员的登录以及操作页面,接下来我们创建一个简单的用户登录的类
import os
import pickle


class User:
    def __init__(self, name, uid, card):
        self.name = name
        self.uid = uid
        self.card = card

    def __str__(self):
        return 姓名:{},身份证:{},卡号:{}.format(self.name, self.uid, self.card.cid)
    # 将用户封装到文件内:序列化

    @staticmethod
    def save_user(userinfo):
        pathname = os.path.join(os.getcwd(), userinfo.bd)
        with open(pathname, wb) as fp:
            pickle.dump(userinfo, fp)
    # 将数据读取

    @staticmethod
    def load_user():
        pathname = os.path.join(os.getcwd(), userinfo.bd)
        if os.path.exists(pathname):
            with open(pathname, rb) as fp:
                userinfo = pickle.load(fp)
                return userinfo
        else:
            return {}
# 用户类包含了用户的信息以及用户信息的打印,与上个代码里的10:查看用户信息相对应,为了更加简单的测试,后两个类函数使用静态方法,可以使银行开户时把用户信息进行简单持久化存储(在这里用的是序列化的方式)和用户登录使用系统时提取用户数据

大家众所周知当我们去银行的时候,我们需要插入银行卡,那么我们就需要一个银行卡类来储存我们的用户密码,银行卡号,卡上金额。当然,当你信誉不好时,银行同样也会锁定你的银行卡

class Card:
    def __init__(self, cid, pwd):
        self.cid = cid
        self.pwd = pwd
        self.money = 0              # 余额
        self.is_lock = False        # 是否锁定

当我们把所有的类都创建好后,我们需要把我们写的类的内容进行一个操作整理

from user import User
from admin import Admin
from operate import Operate


if __name__ == __main__:
    # 创建管理员对象
    admin = Admin()
    # 统计管理员登录次数
    count = 0
    while True:
        # 导入欢迎界面
        admin.welcome()
        # 管理员登录
        ret = admin.login()
        if ret:
            print(登录成功)
            # 加载所有用户数据
            userinfo = User.load_user()
            # 创建操作对象
            op = Operate(userinfo)
            while True:
                # 导入操作页面
                admin.menu()
                num = int(input(请输入您的操作:))
                if num == 0:
                    print(彻底退出)
                    is_quit = True
                    break
                elif num == 1:
                    op.new_user()
                elif num == 2:
                    op.del_user()
                elif num == 3:
                    op.query_money()
                elif num == 4:
                    op.get_money()
                elif num == 5:
                    op.save_money()
                elif num == 6:
                    op.pass_money()
                elif num == 7:
                    op.change_pwd()
                elif num == 8:
                    op.lock_user()
                elif num == 9:
                    op.unlock_user()
                elif num == 10:
                    op.show_users()
                else:
                    print(操作有误,请重新输入)
            if is_quit:
                break
        else:
            print(登录失败)
            count += 1
            if count >= 3:
                print(错误已达上限,禁止登录)
                break

我在这里描写的很清楚,管理员的登录,以及系统的退出,一系列的操作只是为了规划我们的程序,接下来大家会发现还少了一个类,那就是操作类,我们需要把操作的函数归结到一个类里,那就是操作类,在这里我们可以实行各种操作的添加:

from helper import Helper
from card import Card
from user import User
import time


class Operate:

    def __init__(self, userinfo):
        self.userinfo = userinfo

    # 开户
    def new_user(self):
        name = input(请输入您的姓名:)
        uid = input(请输入您的身份证号码:)
        while True:
            pwd = input(请输入您的密码:)
            pwd2 = input(请再次输入您的密码:)
            if pwd != pwd2:
                print(您所输入的两次密码不一致,请重新输入:)
            else:
                pwd = Helper.generate_password_hash(pwd)
                cid = Helper.generate_cid()
                card = Card(cid, pwd)
                user = User(name, uid, card)
                self.userinfo[cid] = user
                User.save_user(self.userinfo)
                time.sleep(1)
                print(开户成功)
                break

    # 销户
    def del_user(self):
        cid = input(请输入您的卡号:)
        user = self.userinfo.get(cid)
        if user:
            if user.card.is_lock:
                print(该卡已经锁定,请先去解锁)
                return
            else:
                count = 0
                while count < 3:
                    pwd = input(请输入您的密码:)
                    if Helper.check_password_hash(pwd, user.card.pwd):
                        del self.userinfo[cid]
                        time.sleep(1)
                        print(销户成功)
                        User.save_user(self.userinfo)
                        break
                    else:
                        count += 1
                        print(密码错误,请重新输入密码)
                else:
                    user.card.is_lock = True
                    User.save_user(self.userinfo)
                    print(密码错误已达上限,该卡已锁定)
        else:
            print(用户不存在)

    # 查钱
    def query_money(self):
        cid = input(请输入您的卡号:)
        user = self.userinfo.get(cid)
        if user:
            if user.card.is_lock:
                print(该卡已经锁定,请先去解锁)
                return
            else:
                count = 0
                while count < 3:
                    pwd = input(请输入您的密码:)
                    if Helper.check_password_hash(pwd, user.card.pwd):
                        time.sleep(1)
                        print(您的余额为¥{}元.format(user.card.money))
                        break
                    else:
                        count += 1
                        print(密码错误,请重新输入密码)
                else:
                    user.card.is_lock = True
                    User.save_user(self.userinfo)
                    print(密码错误已达上限,该卡已锁定)
        else:
            print(卡号不存在)

    # 取钱
    def get_money(self):
        cid = input(请输入您的卡号:)
        user = self.userinfo[cid]
        if user:
            if user.card.is_lock:
                print(该卡已经锁定,请先去解锁)
                return
            else:
                money = int(input(请输入金额))
                count = 0
                while count < 3:
                    pwd = input(请输入您的密码:)
                    if Helper.check_password_hash(pwd, user.card.pwd):
                        if user.card.money > money:
                            user.card.money -= money
                            User.save_user(self.userinfo)
                            time.sleep(1)
                            print(取款成功)
                            break
                        else:
                            print(余额不足,请及时充值)
                    else:
                        count += 1
                        print(密码错误,请重新输入密码)
                else:
                    user.card.is_lock = True
                    User.save_user(self.userinfo)
                    print(密码错误已达上限,该卡已锁定)
        else:
            print(卡号不存在)

    # 存钱
    def save_money(self):
        cid = input(请输入您的卡号:)
        user = self.userinfo[cid]
        if user:
            if user.card.is_lock:
                print(该卡已经锁定,请先去解锁)
                return
            else:
                money = int(input(请输入金额))
                count = 0
                while count < 3:
                    pwd = input(请输入您的密码:)
                    if Helper.check_password_hash(pwd, user.card.pwd):
                        user.card.money += money
                        User.save_user(self.userinfo)
                        time.sleep(1)
                        print(存款成功)
                        break
                    else:
                        count += 1
                        print(密码错误,请重新输入密码)
                else:
                    user.card.is_lock = True
                    User.save_user(self.userinfo)
                    print(密码错误已达上限,该卡已锁定)
        else:
            print(卡号不存在)

    # 转账
    def pass_money(self):
        cid = input(请输入您的卡号:)
        user = self.userinfo[cid]
        if user:
            if user.card.is_lock:
                print(该卡已经锁定,请先去解锁)
                return
            else:
                money = int(input(请输入金额))
                count = 0
                while count < 3:
                    pwd = input(请输入您的密码:)
                    if Helper.check_password_hash(pwd, user.card.pwd):
                        dist_cid = input(请输入收款人的卡号:)
                        dist_user = self.userinfo[dist_cid]
                        if dist_user:
                            if user.card.money >= money:
                                user.card.money -= money
                                dist_user.card.money += money
                                User.save_user(self.userinfo)
                                time.sleep(1)
                                print(转账成功)
                                break
                            else:
                                print(没钱你转个毛)
                        else:
                            print(收款人的卡号错误)
                    else:
                        count += 1
                        print(密码错误,请重新输入密码)
                else:
                    user.card.is_lock = True
                    User.save_user(self.userinfo)
                    print(密码错误已达上限,该卡已锁定)
        else:
            print(卡号不存在)

    # 修改密码
    def change_pwd(self):
        cid = input(请输入您的卡号:)
        user = self.userinfo.get(cid)
        if user:
            count = 0
            while count < 3:
                pwd = input(请输入原密码:)
                if Helper.check_password_hash(pwd, user.card.pwd):
                        new_pwd = input(请输入新密码:)
                        new_pwd2 = input(请再次输入新密码:)
                        if new_pwd == new_pwd2:
                            user.card.pwd = Helper.generate_password_hash(new_pwd)
                            User.save_user(self.userinfo)
                            time.sleep(1)
                            print(密码修改成功)
                        else:
                            print(您所输入的两次密码不一致)
                        break
                else:
                    count += 1
                    print(密码错误,请重新输入密码)
        else:
            print(卡号不存在)

    # 锁定账号
    def lock_user(self):
        cid = input(请输入您的卡号:)
        user = self.userinfo.get(cid)
        if user:
            uid = input(请出示您的身份证:)
            if uid == user.uid:
                user.card.is_lock = True
                User.save_user(self.userinfo)
                time.sleep(1)
                print(锁定成功)
            else:
                print(身份证是不是带错了@_@)
        else:
            print(卡是不是折了:卡号错了)

    # 解锁账号
    def unlock_user(self):
        cid = input(请输入您的卡号:)
        user = self.userinfo.get(cid)
        if user:
            uid = input(请出示您的身份证:)
            if uid == user.uid:
                user.card.is_lock = False
                User.save_user(self.userinfo)
                time.sleep(1)
                print(解锁成功)
            else:
                print(身份证是不是带错了@_@)
        else:
            print(卡是不是折了:卡号错了)

    # 查看账户信息
    def show_users(self):
        for user in self.userinfo:
            print(self.userinfo[user])
            time.sleep(1)

在这个类里,大家不免看到了几个helper类的方法调用,因为这些方法(随机生成卡号,登录密码加密存储)是一些辅助手段,所以我们放在了helper类里面

from random import randint
import hashlib


class Helper:
    # 生成卡号
    @staticmethod
    def generate_cid(lenght=8):
        cid = ‘‘
        for i in range(lenght):
            cid += str(randint(0, 9))
        return cid
    # 生成md5加密后的内容

    @staticmethod
    def generate_password_hash(password):
        m = hashlib.md5()
        m.update(password.encode(utf-8))
        return m.hexdigest()
    # 校验md5加密后的密码

    @staticmethod
    def check_password_hash(pwd, pwd_hash):
        m = hashlib.md5()
        m.update(pwd.encode(utf-8))
        return m.hexdigest() == pwd_hash

我们的密码加密使用的是哈希加密,而我们的生成卡号也不那么严谨,采用的是随机数方法

接下来我们就可以尽情的测试代码了,可以开户,并根据银行卡号和密码进行存取和转账,当然如果你忘了密码可是要被锁定的哦,千万别忘了去解锁账户,我们也可以更改密码呦!

当然我写的代码里还有很多漏洞,毕竟是一个初学者,我才学了两星期了,期待各位大佬的指教,谢谢!

 

python银行处理

标签:input   gen   stat   for   path   界面   密码加密   port   内容   

原文地址:https://www.cnblogs.com/sjh-python/p/9457479.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!