python 实现网上商城,转账,存取款等功能的信用卡系统

一、要求

二、思路

1.购物类buy

接收 信用卡类 的信用卡可用可用余额，

返回消费金额

2.信用卡（ATM）类

接收上次操作后，信用卡可用余额，总欠款，剩余欠款，存款

其中：1.每种交易类型不单独处理金钱，也不单独记录流水账，每种交易类型调用处理金钱的函数（传入交易类型，交易金额）

2.处理金钱的函数，调用配置文件中关于每种交易类型的加减钱和利率

返回本次操作后信用卡可用余额，总欠款，剩余欠款，存款

3.客户端

银行管理员注册登陆

普通用户注册登陆

发送需求：注册、登陆、交易类型、交易金额

4.服务器端

调用购物类，创建购物对象(购物接口)

调用信用卡（ATM）类，处理还款，转账等操作，对利息按月记录，写入文件

5.定时任务

定时执行程序，以计算利息。

三、代码

3.1配置文件

import os

BASE_DIR = os.path.dirname(os.path.dirname(__file__)) #配置文件的上层目录
DB_DIR=os.path.join(BASE_DIR,'db')  #数据文件夹
ADMIN=os.path.join(DB_DIR,'admin')
ALL_USERS=os.path.join(DB_DIR,'allusrs')
A=os.path.join(BASE_DIR,'db','s')
LOG=os.path.join(BASE_DIR,'log')

TRANSACTION={
'repay':{'action':'plus','interest':0}, #还款
'withdraw':{'action':'minus','interest':0.05},#取现
'transfer':{'action':'minus','interest':0.05},#转账
'consume':{'action':'minus','interest':0},#消费
'saving':{'action':'plus','interest':0} #存款
}

3.2公共类

3.2.1购物类

class buy:
goods=[
  {"name": "电脑", "price": 1999},
  {"name": "鼠标", "price": 10},
  {"name": "游艇", "price": 20},
  {"name": "美女", "price": 998},
 ]

def __init__(self,money,consumption,shopping_cart,):
 self.money=money
 self.consumption=consumption
 self.shopping_cart=shopping_cart

def gouwu(self): #购物模块
 print('您的当前余额为：％d' ％self.money)
 num=int(input('请输入商品序号：'))
 num-=1
 if self.goods[num]["name"] in self.shopping_cart.keys():    #goods[num]["name"]取商品名
  self.shopping_cart[self.goods[num]["name"]]['n']+=1     #商品数量+1
 else:
  self.shopping_cart[self.goods[num]["name"]]={"price":self.goods[num]["price"],'n':1,} # 创建购物车字典 {keys{"price"：价格,数量：1}}
 self.money-=self.shopping_cart[self.goods[num]["name"]]["price"]*self.shopping_cart[self.goods[num]["name"]]['n']  #单价*数量
 self.consumption+=self.shopping_cart[self.goods[num]["name"]]["price"]*self.shopping_cart[self.goods[num]["name"]]['n']

def yichu(self): #移除购物车模块
 c=int(input(' 请输入0/1选择是否移除购物车商品, 移除请输入1:'))
 if c==1:
  e=int(input(' 请输入要移除的商品序号:'))
  d=self.goods[e-1]
  if d in self.shopping_cart.keys():    #判断要移除的商品是否在购物车内
   self.shopping_cart.remove(d)   #移除商品
   self.money=self.money+self.goods[self.goods.index(d)]["price"]    #余额增加
   self.consumption=self.consumption-self.goods[self.goods.index(d)]["price"] #消费总额减少
  else:
   print('商品不存在')
def chongzhi(self): #充值模块
 pay=int(input('请输入充值金额'))
 self.money=self.money+pay
 print('您的当前余额为：％d' ％ self.money) #显示当前余额

def main(self):
 print('商品清单：')
 for m,n in enumerate(self.goods,1):
  print(m)
  for v in n.values():
   print(v)
  print('=============')
 #消费总额清零
 self.consumption=0
 buy=True #定义默认一直购物
 while buy:
  price=0 #定义初始价格
  b=1 #定义默认不退出购物或充值状态
  if self.money>=price:

#消费模块；金钱大于货物价格时，才能开始购物
   while self.money>=price:
 #计价模块，有钱就可以一直购物
    self.gouwu()
 #移除购物车商品模块
    self.yichu()
    if self.money>=0:
     print('您的当前余额为：％d' ％self.money)   #显示当前余额
     b=int(input(' 请输入0/1选择是否继续购物, 购物请输入1:'))
     if b==0:  #
      break #退出计价模块
   if b==0:   #如果不购物
    break   #不购物退出整个购物程序
 #充值模块
  else:
   while self.money<price:   #金钱不足，可多次充钱，直到能买得起货物
    a=int(input(' 您的余额不足，请输入0/1选择是否充值，充值请输入1:'))
    if a==1:
     self.chongzhi()
    else:
     break   #退出充值模块
    if a==0:
     break   #不充值退出程序
 #打印购物车商品名、商品价格、消费总额、余额
 print('您的消费清单为：')
 for m,n in self.shopping_cart.items():
  print(m,n['price'],n['n'])
    #打印消费清单
  print('=============')
 print('您的当前余额为：％d,您的消费总额为：％d' ％ (self.money,self.consumption) )   #打印消费总额
 return self.consumption

3.2.2 信用卡ATM类

class Atm:
credit=15000 #信用卡额度
def __init__(self,balance,debt,remaining_debt,interest,saving,id):
 self.id=id    #信用卡id
 self.balance=balance  #信用卡可用金额
 self.debt=debt   #总欠款
 self.remaining_debt=remaining_debt #剩余欠款
 self.interest=interest  #手续费
 self.saving=saving  #存款
 self.now_time=time.strftime("％Y-％m-％d ％H:％M:％S")
 self.now_data=time.strftime("％Y-％m")
 self.struct_time=time.gmtime(time.time())
 if self.struct_time.tm_mday>22:
  self.now_data=self.struct_time.tm_year+'-'+str(int(self.struct_time.tm_mon)+1)

def account_info(self):#打印账户信息
 return '账户id％s 信用卡额度％s;信用卡可用金额％s;剩余欠款％s;'％(self.id,self.credit,self.balance,self.remaining_debt,)
def ret_account_info(self):
 return [self.id,self.credit,self.balance,self.debt,self.remaining_debt,self.interest]
def repay(self,amount):#还款
 self.handel_money('repay',amount)
def withdraw(self,amount): #取现
 self.handel_money('withdraw',amount)
def transfer(self,amount): #转账
 self.handel_money('transfer',amount)
def consume(self,amount): #消费
 self.handel_money('consume',amount)
def saves(self,amount):
 self.handel_money('saving',amount)
def transaction(self,a,amount):
 dic={
  '1':self.repay,
  '2':self.withdraw,
  '3':self.transfer,
  '4':self.consume,
  '5':self.saves
 }
 print("debug: a:",type(a),"amount:",type(amount))

print(a)
 print(dic[a])
 print(dic["5"])
 dic[a](amount)
 print("end debug")

def handel_money(self,transaction,amount): #交易类型，
 amount=int(amount)
 interest=amount*settings.TRANSACTION[transaction]['interest'] #手续费计算
 if settings.TRANSACTION[transaction]['action']=='plus':

if amount<=self.remaining_debt:
   self.remaining_debt-=amount
   self.balance+=amount
  else:
   self.balance+=self.remaining_debt
   self.remaining_debt=0
   self.saving+=amount-self.remaining_debt
 else:

if self.saving<amount:
   self.saving=0
   a=amount-self.saving
   self.balance-=a+interest-self.saving
   # self.debt+=amount+interest
   self.remaining_debt+=a+interest
 a='time:％s id:％s transaction: ％s amount:％s interest ％s \n'％(self.now_time,self.id,transaction,amount,interest)
 print(a)
 mulu=os.path.join(settings.ALL_USERS,self.id)
 path_name_liushui=os.path.join(mulu,str(self.id)+'name_liushui',str(self.now_data))

with open(path_name_liushui,'a')as f:   #记录流水信息
  f.write(a)

s=[self.balance,self.debt,self.remaining_debt,self.interest,self.saving,]  #更新基本信息
 path_name_base=os.path.join(mulu,str(self.id)+'name_base')
 pickle.dump(s,open(path_name_base,'wb'))

3.3服务器端：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import sys,os
import hashlib
import pickle
import time
import socketserver
sys.path.append(os.path.dirname(os.path.dirname(__file__)))
from config import settings
from lib import modules
from lib.modules import *

class Myserver(socketserver.BaseRequestHandler):

def md5(self,pwd):
 '''
 对密码进行加密
 :param pwd: 密码
 :return:
 '''
 hash=hashlib.md5(bytes('xx7',encoding='utf-8'))
 hash.update(bytes(pwd,encoding='utf-8'))
 return hash.hexdigest()

def login(self,usrname,pwd,x):
 '''
 登陆
 :param usrname: 用户名
 :param pwd: 密码
 :return:是否登陆成功
 '''
 conn=self.request
 if x=='1':
  path_name_pwd=os.path.join(settings.ADMIN,usrname)
 else:
  mulu=os.path.join(settings.ALL_USERS,usrname)
  path_name_pwd=os.path.join(mulu,usrname+'name_pwd')
 s=pickle.load(open(path_name_pwd,'rb'))
 if usrname in s:
   if s[usrname]==self.md5(pwd):  #和加密后的密码进行比较
   return True
   else:
   return False
 else:
  return False

def regist(self,usrname,pwd,x):
 '''
 注册
 :param usrname: 用户名
 :param pwd: 密码
 :return:是否注册成功
 '''

conn=self.request
 if x=='1':
  mulu=os.path.join(settings.ADMIN,usrname)
 else:
  mulu=os.path.join(settings.ALL_USERS,usrname)

if os.path.exists(mulu):
   return False
 else:
  os.mkdir(mulu)
  s={}
  s[usrname]=self.md5(pwd)
  path_name_pwd=os.path.join(mulu,usrname+'name_pwd')
  pickle.dump(s,open(path_name_pwd,'wb'))
  path_name_base=os.path.join(mulu,usrname+'name_base')
  pickle.dump([15000,{},0,0,0],open(path_name_base,'wb'))
  path_name_liushui=os.path.join(mulu,usrname+'name_liushui')
  os.mkdir(path_name_liushui)
  return True

def user_identity_authentication(self,usrname,pwd,ret,x):
 '''
 判断注册和登陆，并展示用户的详细目录信息，支持cd和ls命令
 :return:
 '''
 conn=self.request
 if ret=='1':
  r=self.login(usrname,pwd,x)
  if r:
   conn.sendall(bytes('y',encoding='utf-8'))
  else:
   conn.sendall(bytes('n',encoding='utf-8'))
 elif ret=='2':
  # print(usrname,pwd)
  if x=='1':
   r=self.regist(usrname,pwd,x)
  else: #用户注册
   s=[0,1]
   pickle.dump(s,open(settings.A,'wb'))
   while True:
    ret=pickle.load(open(settings.A,'rb'))
    if ret[0]==0:
     time.sleep(30)
     continue
    elif ret[0]==1 or ret[0]==2:
     break #默认值已更改，银行管理员已操作

if ret[0]==1: #如果管理员同意
    r=self.regist(usrname,pwd,x)
   else:
    r=0
   s=[0,0]
   pickle.dump(s,open(settings.A,'wb'))
  if r:
   conn.sendall(bytes('y',encoding='utf-8'))
  else:
   conn.sendall(bytes('n',encoding='utf-8'))
def interactive(self,usrname): #进行交互
 conn=self.request
 while True:
  c=conn.recv(1024) #接收用户交互选项
  r=str(c,encoding='utf-8')
  mulu=os.path.join(settings.ALL_USERS,usrname)
  path_name_base=os.path.join(mulu,usrname+'name_base')
  s=pickle.load(open(path_name_base,'rb'))

#打印账户信息
  obj=modules.Atm(s[0],s[1],s[2],s[3],s[4],usrname) #Atm对象
  a=obj.account_info() #接收账户信息
  conn.sendall(bytes(a,encoding='utf-8'))

b=obj.ret_account_info()

if r== '4':
   buy_obj=modules.buy(b[2],0,{})
   amount=buy_obj.main()
  elif r=='q':
   break
  else:
   s=conn.recv(1024)
   amount=str(s,encoding='utf-8')

obj.transaction(r,amount)

pass

def handle(self):
 conn=self.request
 x=conn.recv(1024)
 x=str(x,encoding='utf-8')
 conn.sendall(bytes('收到用户类别',encoding='utf-8'))
 while True:
  if x=='1' or x=='2':
   b=conn.recv(1024)
   ret=str(b,encoding='utf-8')
   conn.sendall(bytes('b ok',encoding='utf-8'))
   c=conn.recv(1024)
   r=str(c,encoding='utf-8')
   usrname,pwd=r.split(',')
   print(usrname,pwd)
   self.user_identity_authentication(usrname,pwd,ret,x) #登陆或注册验证
   if x=='2':#普通用户身份验证成功后
    self.interactive(usrname)

pass

break
  elif x=='q':
   break

if __name__=='__main__':
sever=socketserver.ThreadingTCPServer(('127.0.0.1',9999),Myserver)
sever.serve_forever()

3.4 用户端

#!/usr/bin/env python
# -*- coding: utf-8 -*-
'''
本程序作为用户或银行管理员的入口，其中c=1代表银行管理员，c=2代表普通用户
'''
import pickle
import sys
import time
import os
import socket
sys.path.append(os.path.dirname(os.path.dirname(__file__)))
from config import settings
from lib import *
from lib.modules import *

def login(usrname,pwd):
'''
登陆
:param usrname:用户名
:param pwd:密码
:return:是否登陆成功
'''
obj.sendall(bytes(usrname+','+pwd,encoding='utf-8'))
ret=obj.recv(1024)
r=str(ret,encoding='utf-8')
if r=='y':
 return 1
else:
 return 0

def regist(usrname,pwd,x):
'''
注册
:param usrname:用户名
:param pwd:密码
:return:是否注册成功
'''
obj.sendall(bytes(usrname+','+pwd,encoding='utf-8'))

ret=obj.recv(1024)
r=str(ret,encoding='utf-8')
if r=='y':
 return 1
else:
 return 0
def user_identity_authentication(usrname,pwd,x):
'''
选择登陆或注册，展示用户的详细目录信息，支持cd和ls命令
:return:
'''
a=input('请选择1.登陆 2.注册')
obj.sendall(bytes(a,encoding='utf-8'))
obj.recv(1024)
if a=='1':
 ret=login(usrname,pwd)
 if ret:
  print('登陆成功')
  return 1
 else:
  print('用户名或密码错误')
  return 0
elif a=='2':
 ret=regist(usrname,pwd,x)
 if ret:
  print('注册成功')
  return 1
 else:
  print('用户名已存在或银行管理员拒绝')
  return 0
def main(x):
usrname=input('请输入用户名')
pwd=input('请输入密码')
if user_identity_authentication(usrname,pwd,x): #如果验证身份成功
 if x=='1': #处理用户注册信息

while True:
   s=pickle.load(open(settings.A,'rb'))
   if s[1]==0:
    time.sleep(30)
    continue
   elif s[1]==1:
    while True:
     a=input('用户请求注册，输入1同意，2拒绝')
     if a=='1':
      s=[1,0]
      pickle.dump(s,open(settings.A,'wb'))
      break
     elif a=='2':
      s=[2,0]
      pickle.dump(s,open(settings.A,'wb'))
      break
     else:
      print('输入有误')
    break
 else: #普通用户登陆后
  interactive() #进行交互

def interactive():
while True:
 a=input('请选择 1.还款 2.取现 3.转账 4.消费 5.存钱 q退出')
 obj.sendall(bytes(a,encoding='utf-8'))
 r=obj.recv(1024) #接收账户信息
 ret=str(r,encoding='utf-8')
 print(ret)
 if a !='4'and a !='q':
  b=input('请输入金额')
  obj.sendall(bytes(b,encoding='utf-8'))
 elif a=='q':
  break

obj=socket.socket() #创建客户端socket对象
obj.connect(('127.0.0.1',9999))
while True:
x=input('请选择1.银行管理员 2.用户 q、退出')
obj.sendall(bytes(x,encoding='utf-8'))
obj.recv(1024) #确认收到用户类别
if x=='1' or x=='2':
 main(x)
 break
elif x=='q':
 break
else:
 print('输入有误请重新输入')

obj.close()

3.5定时任务

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import os,sys
import json,pickle
import time
sys.path.append(os.path.dirname(os.path.dirname(__file__)))
from config import settings

def main():
card_list = os.listdir(settings.ALL_USERS)
for card in card_list:
 basic_info = pickle.load(open(os.path.join(settings.ALL_USERS, card, card+'name_base')))
 struct_time = time.localtime()

# 循环账单列表，为每月的欠款计息。并写入到当月账单中
 for item in basic_info['debt']:
  interest = item['total_debt'] * 0.0005
  if basic_info[4] >= interest:
   basic_info[4] -= interest
  else:
   temp = interest - basic_info[4]
   basic_info[4]=0
   basic_info[0] -= temp
   pickle.dump(
     basic_info,
     open(os.path.join(settings.ALL_USERS, card, card+'name_base'),'w')
   )

# 如果当前等于10号(9号之前)
 # 当前余额为负值，则将值添加到账单列表中，开始计息，同时，本月可用额度恢复。
 date = time.strftime("％Y-％m-％d")
 if struct_time.tm_mday == 11 and basic_info[2]>0:
  dic = {'date': date,
    "total_debt": basic_info[2],
    "balance_debt": basic_info[2],
    }
  basic_info[1].append(dic)
  # 恢复可用额度
  basic_info[0] = 15000
 pickle.dump(
  basic_info,
  open(os.path.join(settings.ALL_USERS, card, card+'name_base'),'w')
   )

def run():
main()