Python基础题（二）

def modify_file(filename,old,new):
    import os
    with open(filename,‘r‘,encoding=‘utf-8‘) as \read_f,open(‘.bak.swap‘,‘w‘,encoding=‘utf-8‘) as write_f:
        for line in read_f:
            if old in line:
                line=line.replace(old,new)
            write_f.write(line)
    os.remove(filename)
    os.rename(‘.bak.swap‘,filename)

modify_file=input(‘请输入你要修改的文件路径====> :‘)

#字符串的操作一定要熟练，文件处理大部分都是字符串的处理工作

def check_str(msg):
    res={
        ‘num‘:0,
        ‘string‘:0,
        ‘space‘:0,
        ‘other‘:0,
    }
    for s in msg:
        if s.isdigit():
            res[‘num‘]+=1
        elif s.isalpha():
            res[‘string‘]+=1
        elif s.isspace():
            res[‘space‘]+=1
        else:
            res[‘other‘]+=1
    return res

res=check_str(‘hello name:aSB passowrd:alex3714‘)
print(res)

def obj_len(obj): 
    if len(obj)>5:
        print(‘长度大于五‘)
    else:
        print(‘长度小于五‘)      
obj=input(‘用户输入的对象===> :‘)

def list_len(list_1):
    if len(list_1)>2:
        list_1=list_1[:2]
    return list_1

print(list_len([1,2,5,8,7]))

def spe(list_old):
    list_old=list_old[::2]
    return list_old

print(spe([0,0,0,2,5,5,5,8,48,8]))

def func3(dic):
    d={}
    for k,v in dic.items():   #这一步为了更好的处理字典的键和值
        if len(v) > 2:
            d[k]=v[0:2]
    return d
print(func3({‘k1‘:‘abcdef‘,‘k2‘:[1,2,3,4],‘k3‘:(‘a‘,‘b‘,‘c‘)}))

import random
import time

def outer():
    start=time.time()
    print(‘egon dashuaibi‘)
    time.sleep(random.randint(0,3))
    stop=time.time()
    print(‘run time is %s‘%(stop-start))

outer()

import time

def index():
    print(‘egon dashuaibi‘)
    time.sleep(3)

def outter(func):
    def wrapper():
        start=time.time()
        func()
        stop=time.time()
        print(‘run time is %s‘ %(stop-start))
    return wrapper

index=outter(index)
index()

# import time
import datetime
# time.time()   # 当前时间戳
# datetime.datetime.now() # 本地之间


# 数据处理=====================================
# 全部用户数据
user_data = []
# 加载数据到内存
def load_data():
    f = open("DB/user_db.txt","rt",encoding="utf-8")
    for line in f:
        line = line.strip("\n")
        if line == "\n":continue
        ls = line.split("|")
        usr_dic = {"name":ls[0],
                   "pwd":ls[1],
                   "max": ls[2],
                   "money": ls[3],
                   "lock": ls[4]}
        user_data.append(usr_dic)
    f.close()

# 根据账户名获取一个用户
def get_usr(name):
    for usr in user_data:
        if usr["name"] == name:
            return usr

# 将内存中的数据持久存储到文件中
def save_to_file():
    f = open("DB/user_db.txt","wt",encoding="utf-8")
    for usr in user_data:
        text = "|".join(usr.values())
        text += "\n"
        f.write(text)
    f.close()


# 数据处理=====================================

# 登录验证装饰器(闭包函数) (再不改变源代码的调用方式基础上 为这个函数添加新功能)
def login_auth(func):
    def wrapper(*args,**kwargs):
        # 验证是否登陆过了
        if current_usr == None:
            print("请先登录!")
            atm_login()
            if current_usr:
                return func(*args,**kwargs)
        else:
            return func(*args,**kwargs)
    return wrapper



# 购物中心========================================
# 商品信息
products = [{"name":"挨粪叉","price":6888},
            {"name":"锤子TNT","price":10888},
            {"name":"小米mix2","price":2888}]

# 购物车
car = {}

# 购物
def shopping():
    while True:
    # 打印出所有商品信息
        count = 1
        for p in products:
            print("序号:%-3s 名称:%-10s 价格:%-6s" % (count,p["name"],p["price"]))
            count += 1
        select = input("亲输入商品的序号q退出:\n")
        if select == "q":
            return
        if select.isdigit() and int(select) >= 1 and int(select) <= len(products):
            pd = products[int(select)-1]
            print("%s已成功加入购物车!" % pd["name"])
            # 判断商品是否已经存在于购物车
            if pd["name"] in car:
                car[pd["name"]]["count"] += 1
            else:
                car[pd["name"]] = {"price":pd["price"],"count":1}
        else:
            print("输入有误请重新输入!")


# 查看购物车
def show_cars():
    if not car:
        s = input("你的购物车是空的! 你要买点什么吗? y/n")
        if s == "y":
            shopping()
            return
        else:
            return
    print("您的购物车信息:")
    for p in car:
        print("名称:%-10s 价格:%-8s 数量:%-3s 总价:%-10s" % (p,
                                                     car[p]["price"],
                                                     car[p]["count"],
                                                     car[p]["price"] * car[p]["count"]))
    select = input("输入y调整商品数量!(数量为0则删除商品!) 输入其他退出!")
    if select == "y":
        modify_count()


# 调整购物车中的商品数量
def modify_count():
    while True:
        name = input("请输入商品名称q退出:\n")
        if name == "q":
            return
        if name not in car:
            print("输入不正确请重试!")
            continue

        while True:
            count = input("输入调整后数量:\n")
            if not count.isdigit():
                print("数量不正确 必须是整数!")
                continue
            count = int(count)
            if count == 0:
                car.pop(name)
                print("%s已删除" % name)
                return
            else:
                car[name]["count"] = count
                print("修改成功!")
                return


# 结算
@login_auth
def pay_cars():
    # 计算商品总价格
    sum = 0
    for p in car:
        sum += car[p]["price"] * car[p]["count"]
    print("您的订单总价为:%s元" % sum)
    if paymoney(sum):
        print("剁手成功! 回家等着吧!")
        clear_cars()


# 清空购物车
def clear_cars():
    car.clear()
    print("购物车已清空!")


def shop_center():
    shopfuncs = {"1":shopping,"2":show_cars,"3":pay_cars,"4":clear_cars}
    while True:
        print("""
1.购物
2.查看购物车
3.结算
4.清空
q.退出""")
        index = input("请选择:\n").strip()
        if index == "q":
            return
        if index in shopfuncs:
            shopfuncs[index]()
        else:
            print("输入不正确!请重试!")


# 购物中心========================================

# ATM====================================================
# 用于保存登录成功的用户信息
current_usr = None

# 日志装饰器.
# 日志文件
atmlog_file = open("DB/log.txt","at",encoding="utf-8")

# 用户流水文件
moneyflow = None

def atm_logger(func):
    def wrapper(*args,**kwargs):
        res = func(*args,**kwargs)
        # 记录日志
        atmlog_file.write("[%s] user:%s function:%s\n" % (datetime.datetime.now(),current_usr["name"],func.__name__))
        atmlog_file.flush() # 立即刷出缓存区的数据到硬盘 如果每次write都操作一次硬盘
                            # 效率非常低 所以python内置了缓冲区  只有当缓冲区满了才会写入硬盘 一次来降低硬盘操作次数
    return wrapper


# 登录
def atm_login():
    while True:
        name = input("请输入账户名:(q退出)\n").strip()
        # 手动记录日志 因为用户还没有登陆
        atmlog_file.write("[%s] user:%s function:%s\n" % (datetime.datetime.now(), name, atm_login.__name__))
        atmlog_file.flush()
        if name == "q":
            return
        if not name:
            print("用户名不能为空!")
            continue
        usr = get_usr(name)
        if not usr:
            print("用户名不存在!")
            continue

        pwd = input("请输入密码:\n").strip()
        if not pwd:
            print("密码不能为空!")
            continue
        if name == usr["name"] and pwd == usr["pwd"]:
            print("登录成功")

            global current_usr,moneyflow
            # 打开流水文件
            moneyflow = open("DB/%s.txt" % name,"at",encoding="utf-8")
            # 记录当前登录用户信息
            current_usr = usr
            return
        else:
            print("账户名或密码不正确!请重试!")


#     提现
@login_auth
@atm_logger
def withdraw():
    while True:
        print("当前余额:%s元" % current_usr["money"])
        money = input("请输入提款金额:(整数 q退出)\n")
        if money == "q":return
        if not money.isdigit():
            print("输入有误!请重试!")
            continue
        money = int(money)
        # 手续费
        opt = money * 0.05
        print("需要手续费%s元" % opt)
        usr_moeny = float(current_usr["money"])
        if money+opt > usr_moeny:
            print("余额不足!很尴尬")
            continue
        current_usr["money"] = str(usr_moeny - money - opt)
        save_to_file()
        print("请提取你的钞票!")
        moneyflow.write("[%s] 账户:%s 提现%s元 余额%s元\n" % (datetime.datetime.now(),
                                                    current_usr["name"],
                                                    money,
                                                    current_usr["money"]))
        moneyflow.flush()
        return

#     转账
@login_auth
@atm_logger
def transfer():
    while True:
        account = input("请输入对方的账户名:\n")
        to_usr = get_usr(account)
        if not to_usr:
            print("账户不存在 请重新输入!")
            continue
        print("当前余额:%s元" % current_usr["money"])
        money = input("请输入转账金额:(整数 q退出)\n")
        if money == "q": return
        money = str_to_num(money)
        if not money:
            print("输入有误!请重试!")
            continue
        usr_moeny = float(current_usr["money"])
        if money  > usr_moeny:
            print("余额不足!很尴尬")
            continue
        # 原始账户减去
        current_usr["money"] = str(usr_moeny - money)
        # 目标账户加上
        to_usr["money"] = str(float(to_usr["money"]) + money)
        save_to_file()
        print("转账成功!")
        moneyflow.write("[%s] 账户:%s 转账%s元 给%s 余额%s元\n" % (datetime.datetime.now(),
                                                    current_usr["name"],
                                                    money,
                                                    account,
                                                    current_usr["money"]))
        moneyflow.flush()
        return


# 将字符串转成数字 "11212101.s"
def str_to_num(text):
    if text.isdigit():
        return int(text)
    if "." in text:
        ts = text.split(".")
        if len(ts) == 2:
            if ts[0].isdigit() and ts[1].isdigit():
                return float(text)

#     还款
@login_auth
@atm_logger
def repayment():
    print("您当前欠款:%s" % (str_to_num(current_usr["max"]) - str_to_num(current_usr["money"])))
    while True:
        print("repayment")
        money = input("请输入还款金额!q退出:\n")
        if money == "q":return
        money = str_to_num(money)
        if not money:
            print("输入有误 请重试!")
            continue
        current_usr["money"] = str(str_to_num(current_usr["money"]) + money)
        save_to_file()
        print("还款成功!")
        moneyflow.write("[%s] 账户:%s 还款%s元 余额%s元\n" % (datetime.datetime.now(),
                                                    current_usr["name"],
                                                    money,
                                                    current_usr["money"]))
        moneyflow.flush()
        return

# 结算 需要传入订单总价格
@login_auth
@atm_logger
def paymoney(price):
    if price > str_to_num(current_usr["money"]):
        print("额度不足!又尴尬了")
    else:
        current_usr["money"] = str(str_to_num(current_usr["money"]) - price)
        save_to_file()
        print("结算成功!")
        moneyflow.write("[%s] 账户:%s 购物消费%s元 余额%s元\n" % (datetime.datetime.now(),
                                                    current_usr["name"],
                                                    price,
                                                    current_usr["money"]))
        moneyflow.flush()
        return True


def atm():
    atm_funcs = {"1": atm_login, "2": withdraw, "3": transfer, "4": repayment}
    while True:
        print("""
1.登录
2.提现
3.转账
4.还款
(q.退出!)""")
        index = input("请选择:\n")
        if index == "q":
            # 清空当前用户信息 关闭流水文件
            global current_usr
            if current_usr:
                current_usr = None
                moneyflow.close()

            return
        if index in atm_funcs:
            atm_funcs[index]()
        else:
            print("输入有误请重试!")

# ATM====================================================

# 管理员接口=============================================

# 显示所有的用户信息 并从中选择一个用户
def show_users_and_select():
    while True:
        for usr in user_data:
            print("%-10s %-10s %-10s %-2s" % (usr["name"],usr["max"],usr["money"],usr["lock"]))
        select = input("请选择一个用户(输入用户名:q退出)\n")
        if select == "q":
            return
        for u in user_data:
            if select == u["name"]:
                return u
        else:
            print("输入不正确 请重新输入!")


# 管理员登录
def admin_login():
    while True:
        name = input("请输入管理员账户名:(q退出)\n").strip()
        if name == "q":
            return
        if not name:
            print("用户名不能为空!")
            continue
        pwd = input("请输入管理员密码:\n").strip()
        if not pwd:
            print("密码不能为空!")
            continue
        if name == "admin" and pwd == "123":
            print("登录成功")
            return True
        else:
            print("账户名或密码不正确!请重试!")


#添加账户
def create_user():
    while True:
        name = input("请输入账户名:(q退出)\n").strip()
        if name == "q":
            return
        if not name:
            print("用户名不能为空!")
            continue
        # 获取用户 通过账户名
        usr = get_usr(name)
        if usr:
            print("用户名已经存在,请重试!")
            continue
        pwd = input("请输入密码:\n").strip()
        if not pwd:
            print("密码不能为空!")
            continue
        if pwd != input("请再次输入密码:").strip():
            print("两次密码不相同请重试!")
            continue
        # 将用户输入的信息打包成字典 存到列表中
        new_usr = {"name":name,"pwd":pwd,"max":"15000","money":"500","lock":"0"}
        user_data.append(new_usr)
        print("创建成功!")
        # 持久化存储......
        save_to_file()
        return


#调整额度
def modify_amount():
    # 先选择一个用户
    usr = show_users_and_select()
    if not usr:
        return
    while True:
        # 输入新的额度
        new_max = input("请输入新的额度:(q退出)\n").strip()
        if new_max == "q":
            return
        if not new_max.isdigit():
            print("输入不正确 请重新输入!")
            continue
        usr["max"] = new_max
        save_to_file()
        print("修改成功!")
        return

#冻结账户
def lock_user():
    # 先选择一个用户
    usr = show_users_and_select()
    if not usr:
        print("取消操作!")
        return
    usr["lock"] = "1"
    save_to_file()
    print("冻结成功!")

#解冻账户
def unlock_user():
    # 先选择一个用户
    usr = show_users_and_select()
    if not usr:
        print("取消操作!")
        return
    usr["lock"] = "0"
    save_to_file()
    print("解冻成功!")

# 管理员接口界面
def admin_view():
    # 调用登录功能验证是否有权限执行操作
    if not admin_login():
        return
    admin_funcs = {"1":create_user,"2":modify_amount,"3":lock_user,"4":unlock_user}
    while True:
        print("""
1.添加账户
2.修改额度
3.冻结账户
4.解冻账户
(q.退出!)""")
        index = input("请选择:\n")
        if index == "q":
            return
        if index in admin_funcs:
            admin_funcs[index]()
        else:
            print("输入有误请重试!")
# 管理员接口=============================================

# 程序的入口函数
def run():
    print("welcome to oldboy ATM system!")
    # 将函数装到字典中 用序号作为key 方便判断
    funcs = {"1": shop_center, "2": atm, "3": admin_view}
    while True:
        print("""
1.购物中心
2.ATM
3.管理员接口
(q.退出!)""")
        index = input("请选择:\n")
        if index == "q":
            print("下次再见!")
            return
        if index in funcs:
            funcs[index]()
        else:
            print("输入有误请重试!")

# 启动系统
load_data()
run()
atmlog_file.close()

# print(user_data)
# print(str_to_num("100.s"))







# 只有程序时从当前文件开始运行时才进入if语句
# if __name__ == ‘__main__‘:

new_names=[i.upper() for i in names]
print(new_names)

names=[len(name) for name in names if not name.endswith(‘sb‘)]
print(names)

with open(r‘F:\python学习代码\DB\a.txt‘,mode=‘rt‘,encoding=‘utf-8‘) as f:
    print(max(len(i) for i in f ))

with open(r‘F:\python学习代码\DB\a.txt‘,mode=‘rt‘,encoding=‘utf-8‘) as f:
    print(sum(len(i) for i in f ))
    print(sum(len(i) for i in f))
在第一次打印之后，迭代器的内容就被取空了

因为生成器表达式是加载在系统空间的，文件关闭后生成器表达式的内存地址丢失

with open(‘a.txt‘,encoding=‘utf-8‘) as f:
    info=[line.split() for line in f]
    cost=sum(float(unit_price)*int(count) for _,unit_price,count in info)
    print(cost)


with open(‘a.txt‘,encoding=‘utf-8‘) as f:
    info=[{
        ‘name‘: line.split()[0],
        ‘price‘: float(line.split()[1]),
        ‘count‘: int(line.split()[2]),
    } for line in f]
    print(info)


with open(‘a.txt‘,encoding=‘utf-8‘) as f:
    info=[{
        ‘name‘: line.split()[0],
        ‘price‘: float(line.split()[1]),
        ‘count‘: int(line.split()[2]),
    } for line in f if float(line.split()[1]) > 10000]
    print(info)
每次必须重新打开文件或seek到文件开头，因为迭代完一次就结束了

nums = [1, 13, 15, 23, 27, 31, 33, 57, 73, 81, 93, 94, 97, 101]  # 从小到大排列的数字列表
def binary_search(find_num,nums):
    print(nums)
    if len(nums) == 0:
        print(‘not exists‘)
        return

    # 功能
    mid_index = len(nums) // 2
    if find_num > nums[mid_index]:
        # in the right
        nums=nums[mid_index+1:]
        # 重新运行功能,传入新列表
        binary_search(find_num,nums)
    elif find_num < nums[mid_index]:
        # in the left
        nums=nums[:mid_index]
        # 重新运行功能,传入新列表
        binary_search(find_num,nums)
    else:
        print(‘find it‘)

binary_search(97,nums)
binary_search(95,nums)

l=[1,2,10,30,33,99,101,200,301,402]

def search(num,l,start=0,stop=len(l)-1):
    if start <= stop:
        mid=start+(stop-start)//2
        print(‘start:[%s] stop:[%s] mid:[%s] mid_val:[%s]‘ %(start,stop,mid,l[mid]))
        if num > l[mid]:
            start=mid+1
        elif num < l[mid]:
            stop=mid-1
        else:
            print(‘find it‘,mid)
            return
        search(num,l,start,stop)
    else: #如果stop > start则意味着列表实际上已经全部切完，即切为空
        print(‘not exists‘)
        return

search(301,l)

1. 使用python编写的.py文件

2. 已被编译为共享库或DLL的C或C++扩展

3. 把一系列模块组织到一起的文件夹（注：文件夹下有一个__init__.py文件，该文件夹称之为包）

4 .使用C编写并链接到python解释器的内置模块

包含了一组功能的python文件,比如spam.py

#cuboid.py

long=5
wide=6
hign=3

def perimeter():
    perimeter=4*(long+wide+hign)
    return perimeter

def arer():
    arer=2*(wide*long+long*hign+wide*hign)
    return arer

#stu1.py
import cuboid

# __name__=‘__main__‘
print(cuboid.long,cuboid.wide,cuboid.hign)
print(cuboid.perimeter())
print(cuboid.arer())

#stu2.py
import cuboid as f

# __name__=‘__main__‘
print(f.long,f.wide,f.hign)
print(f.perimeter())
print(f.arer())

#run.py

四种

# import sys,time,place

# import sys
# import time
# import place

# import sys as a
# import time as  b
# import place  as c


# from sys import * 
# from time import * 
# from place import * 

from cuboid import arer,perimeter,long,wide,hign


print(long,wide,hign)
print(arer())
print(perimeter())

#唯一的区别就是：使用from...import...则是将spam中的名字直接导入到当前的名称空间中，所以在当前名称空间中，直接使用名字就可以了、无需加前缀：spam.

from...import...的方式有好处也有坏处
好处：使用起来方便了
坏处：容易与当前执行文件中的名字冲突

软件目录结构规范有什么好处：
　　通过规范化，能够更好的控制软件结构，让程序具有更高的可读性。

项目目录组织结构如下：
Foo/  　　　　　　　　# 项目名
    --bin/   　　　　# 可执行文件目录
        --foo　　　　# 可执行程序
    --core/ 　　　　 # 主程序目录
        --test/　　　# 测试用例（用于对项目中功能性测试）
            --__init__.py
            --test_main.py
        --__init__.py
        --main.py　　# 主程序入口
    --conf/　　　　　# 配置文件目录
        --settings.py  #配置文件
    --logs/　　　　　# 日志文件目录
        --log　　　　# 日志文件
    --docs/ 　　　　 # 文档类目录
    --setup.py   　 # 安装部署脚本
    --requirements.txt  #依赖关系，存放依赖的软件包名称，
    --README 　　　　# 程序说明

个别说明：
README内容说明
1：软件定位，软件的基本功能
2：运行代码的方式：安装环境，启动命令等。
3：简要的使用说明。
4：代码目录结构说明，更详细可以说明软件的基本原理
5：常见问题说明。

requirements.txt
文件格式是一行包含一个包依赖的说明，要求这个格式能被pip识别，使用方式：
pip install -r requirements.txt   来安装所有依赖的包

以上各个目录模块如何动态导入，实现动态迁移。
import os
import sys
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(BASE_DIR)
这里：通过动态导入项目的当前根路径即可。

import xml.etree.ElementTree as ET

new_xml = ET.Element("周围的同学")
name = ET.SubElement(new_xml, "name")
age = ET.SubElement(name, "age")
sex = ET.SubElement(name, "sex")
name.text="张三"
age.text ="18"
sex.text = "man"

name2 = ET.SubElement(new_xml, "name")
age = ET.SubElement(name2, "age")
name2.text="李四"
age.text = "19"
sex.text="man"

et = ET.ElementTree(new_xml)  # 生成文档对象
et.write("test.xml", encoding="utf-8", xml_declaration=True)

ET.dump(new_xml)  # 打印生成的格式

import xml.etree.ElementTree as ET

res=ET.parse("test.xml")
print(res)

name=res.getiterator("name")
for i in name:
    print(i.text)

name=res.getiterator("age")
for i in name:
    print(i.text)

name=res.getiterator("sex")
for i in name:
    print(i.text)