python作业练习

#1、猜字游戏

用if分支完成猜数字游戏

 -- 先通过键盘输入一个数字算作出题
 -- 在键盘输入答案
 -- 正确：猜对 | 误差3以内：接近了 | 误差外小值：太小 | 误差外大值：太大

queste=int(input(\'请输入数字》：\')) #答案
enu=int(input(\'请输入答案》：\'))    #作答
erro_value=3                        #误差值
if enu == queste:
    print(\'恭喜你猜对了\')
elif  abs(enu - queste ) < 3 :
    print(\'接近了\')
elif  (enu-queste) <= -3:
    print(\'误差太小\')
else:
    print(\'误差太大\')

View Code

#2、循环完成多次猜字游戏

-- 一次循环完成一次出题和猜题
 -- 当出题输入Q或q时结束游戏

queste=input(\'请输入数字(输入Q或者q退出猜字)》：\') #答案
erro_value = 3  # 误差值
while True:
    if queste == \'Q\' or queste == \'q\':break
    #优化写法
    #if queste in [\'Q\',\'q\']:break
    queste = int(queste)
    enu = input(\'请输入答案》：\')  # 作答
    enu=int(enu)
    if enu == queste:
        print(\'恭喜你猜对了\')
        break
    elif abs(enu - queste) < 3:
        print(\'接近了\')
    elif (enu - queste) <= -3:
           print(\'误差太小\')
    else:
        print(\'误差太大\')

View Code

#3、继续优化猜字游戏

-------完成一次出题可以最多进行三次猜题
------- 一次出题，进入猜题，猜对进入下一次出题
------- 猜错进入下一次猜题，最多错三次，三次全错自动进入下一次出题

erro_value = 3  # 误差值
while  True :
    queste = input(\'请输入数字(输入Q或者q退出猜字)》：\')  # 答案
    if queste == \'Q\' or queste == \'q\': break
    queste=int(queste)
    count = 0
    while count <3:
        enu = int(input(\'请输入答案》：\'))  # 作答
        if enu == queste:
            print(\'恭喜你猜对了\')
            break
        elif abs(enu - queste) < 3:
            print(\'接近了\')
            count+=1
            continue
        elif (enu-queste) <= -3:
            print(\'误差太小\')
            count+=1
            continue
        else:
            print(\'误差太大\')
            count += 1
            continue

View Code

 #4、循环输入10条信息，如果输入的是自然数，就存放到名为nums的列表中，如果不是，就存放到名为strs列表中
 -- nums中存放的数据都是int类型
 -- strs中存放的都是字符串类型
 -- 最终打印两个列表以及个列表的中元素的个数

nums = []
# 存放str的list
strs = []
# 循环10次
for i in range(10):
    info = input(\'info:\')
    # 如果是自然数，转换成整型存放到nums列表汇总
    if info.isdigit():
        num = int(info)
        nums.append(num)
    else:  # 不是自然数，就直接存储字符串数据
        strs.append(info)
print(nums, len(nums))
print(strs, len(strs))

View Code

#5、完成用list存放注册用户信息的功能：可以循环来完成注册，先输入账号，再输入密码，密码需要二次确认，两次密码一致才能往下进行注册，如果不一致返回重新注册输入
 -- 账号输入Q或q，退出整个程序
 -- 账号成功，进行两次密码验证，验证失败直接进入下一次注册
 -- 账号必须全部是英文字母3个长度及以上，密码必须是英文或数字3个长度及以上
 -- 两次密码验证成功，就注册信息存放到列表中
 -- 假设注册成功了Owen，123 | Zero，000两个信息，最终形成的注册结果为
 [[\'Owen\', \'123\'], [\'Zero\', \'000\']]

# 存放数字的list
# 存放注册信息的列表
user_info = []
# 用来循环注册
while True:
    # 账号
    usr = input(\'usr: \')
    if usr == \'Q\' or usr == \'q\':
        break
    # 账号不合法，直接进入下一次注册循环
    if not (usr.isalpha() and len(usr) >= 3):
        print(\'账号不合法，重新输入\')
        continue
    # 账号合法，循环再输入密码，确保密码合法
    while True:
        pwd = input(\'pwd: \')
        # 密码不合法，直接进入下一次密码输入循环
        if not (pwd.isalnum() and len(pwd) >= 3):
            print(\'密码不合法，重新输入密码\')
            continue
        re_pwd = input(\'re_pwd: \')
        if pwd != re_pwd:
            print(\'两次密码不一致，重新输入密码\')
            continue
        # 走到这代表密码已合法，可以结束密码输入的循环
        break
    # 安装指定格式添加到容器里
    user_info.append([usr, pwd])
    print(\'注册成功！\')
# 当注册重新退出时，就可以打印所有结果
print(user_info)

View Code

#6、将几个指定字符串形成目标字符串
指定字符串：\'I\' | \'am\' | \'you are a good boy\' | \'!\'
目标字符串：\'I am a good boy!\'

# res = "%s %s %s%s" % (\'I\', \'am\', \'you are a good boy\'[8:], \'!\')
# print(res)

View Code

#7、写出你可以想到的所有按要求格式输出列表的解决方案
指定列表：[1, 2, 3, 4, 5]
输出结果：[5, 4, 3, 2, 1]

alist=[1,2,3,4,5]
#方法一：使用切片技术
new_alist=alist[::-1]
print(new_alist)
#方法二：使用reversed函数，返回结果是一个反转的迭代器，需要list进行转换
new_alist1=list(reversed(alist))
print(new_alist1)
#方法三：使用sorted函数，排序后生产一个新的列表，reverse等于True，则反转，默认是False
new_alist2=sorted(alist,reverse=True)
print(new_alist2)
#方法四
# ls.sort(reverse=True)
# print(ls)

View Code

#8、遍历删除包含 Bi词汇(脏话) 的目标
指定列表：[\'Owen\', \'BobSB\', \'SBen\', \'ZeroS\', \'OSBO\']
输出结果：[\'Owen\', \'ZeroS\']

source = [\'Owen\', \'BobSB\', \'SBen\', \'ZeroS\', \'OSBO\']
res = []
for i in source:
    if \'SB\' in i:
        # source.remove(i)
        continue
    res.append(i)
source = res
print(source)

View Code

#9、求得指定元组中是字符串数据的总个数
指定元组：(1, 2, \'3\', \'4\', 5, \'6\', 7, 8, 9)
求的结果：3

t1=(1, 2, \'3\', \'4\', 5, \'6\', 7, 8, 9)
count=0
for i in t1:
    if  isinstance(i,str):
        count+=1
print(count)

View Code

#10、求得指定元组中 str数据的个数 与 int数据的个数，存储到字典存放
指定元组：(1, 2, \'3\', \'4\', 5, \'6\', 7, 8, 9)
求的结果：{\'str\': 3, \'int\': 6}

c1 = 0
c2 = 0
for v in (1, 2, \'3\', \'4\', 5, \'6\', 7, 8, 9):
    if isinstance(v, str):
        c1 += 1
    elif isinstance(v, int):
        c2 += 1
res = {\'str\': c1, \'int\': c2}

res = {}.fromkeys([\'str\', \'int\'], 0)
for v in (1, 2, \'3\', \'4\', 5, \'6\', 7, 8, 9):
    if isinstance(v, str):
        res[\'str\'] += 1
    elif isinstance(v, int):
        res[\'int\'] += 1
print(res)

View Code

#11、列表数据的去重
指定列表：[3, 1, 2, 2, 1, 5, 9, 7]
求的结果：[3, 1, 2, 5, 9, 7]

#方法一：
        l=[3, 1, 2, 2, 1, 5, 9, 7]
        alist=set(l)
        alist=list(alist)
        print(alist)
#方法二：
        l=[3, 1, 2, 2, 1, 5, 9, 7]
        alist=[]
        for i in l:
            if i not in alist:
                alist.append(i)
        print(alist)

View Code

#12、修改所有以 Bi词汇(脏话) 开头或结尾的字符串，将 Bi词汇 替换为**
指定列表：[\'Owen\', \'BobSB\', \'SBen\', \'ZeroS\', \'OSBO\']
运行结果：[\'Owen\', \'Bob**\', \'**en\', \'ZeroS\', \'OSBO\']

source = [\'Owen\', \'BobSB\', \'SBen\', \'ZeroS\', \'OSBO\']
for v in source:
    if v.startswith(\'SB\') or v.endswith(\'SB\'):
        index = source.index(v)
        source[index] = source[index].replace(\'SB\', \'**\')
print(source)

View Code

 #13、判断实现将所有能转换为数字类型的字符串都转换为对应类型的数字
int: \'10\'=>10 | \'-10\'=>-10
float: \'0.1\'=>0.1 | \'-0.1\'=>-0.1 | \'.1\'=>0.1 | \'-.1\'=>-0.1

# 整数
num = \'+10\'
if num.strip().isdigit():
    print(\'int: \', int(num))
if num[0] in [\'-\', \'+\'] and num[1:].isdigit():  # \'-10\'
    print(\'int: \', int(num))
if num.isdigit():  # \'10\'
    print(\'int: \', int(num))

# num = \'-0.1\'
# nums = num.split(\'.\')
# if len(nums) == 2 and nums[0].isdigit() and nums[1].isdigit():  # 0.1
#     print(\'float: \', float(num))
# if len(nums) == 2 and nums[0] == \'\' and nums[1].isdigit():  # .1
#     print(\'float: \', float(num))
#
# # nums = ["+-0", "1"]
# if len(nums) == 2 and nums[0][0] in [\'-\', \'+\'] and nums[0][1:].isdigit() and nums[1].isdigit():  # +-0.1
#     print(\'float: \', float(num))

# 小数
num = \'1.0+5\'

temp_num = num.replace(\'.\', \'0\', 1)
if num.startswith(\'+\'):
    temp_num = temp_num.replace(\'+\', \'0\', 1)
elif num.startswith(\'-\'):
    temp_num = temp_num.replace(\'-\', \'0\', 1)

if temp_num.isdigit():
    print(\'float: \', float(num))

View Code

#14、将以下数据存储为字典类型
数据：info = "name:Owen|age:18|gender:男"
结果：{\'name\': \'Owen\', \'age\': 18, \'gender\': \'男\'}
注：年龄存储为int类型

info = "name:Owen|age:18|gender:男"
dic = {}
for k_v in info.split(\'|\'):
    k, v = k_v.split(\':\')
    if v.isdigit():
        v = int(v)
    dic[k] = v
print(dic)

View Code

#15、完成上一道题的逆运算，将字典重新转换成字符串

dic = {\'name\': \'Owen\', \'age\': 18, \'gender\': \'男\'}
#方法一
# ls = []
# for k, v in dic.items():
#     ls.append(\'%s:%s\' % (k, v))
# print(\'|\'.join(ls))
#方法二
info = \'\'
for k, v in dic.items():
    if isinstance(v, int):
        v = str(v)
    info += k + \':\' + v + \'|\'
info = info[:-1]
print(info)

View Code

#16、将字典数据转换为目标list
原数据：dic = {\'name\': \'Owen\', \'age\': 18, \'gender\': \'男\'}
处理后：info = [(\'name\', \'Owen\'), (\'age\', 18), (\'gender\', \'男\')]

dic = {\'name\': \'Owen\', \'age\': 18, \'gender\': \'男\'}
info = [(\'name\', \'Owen\'), (\'age\', 18), (\'gender\', \'男\')]
# print(list(dic.items()))
# print(dict(info))
ls = []
for k, v in dic.items():
    ls.append((k, v))
print(ls)

View Code

#17、完成100以内的大写汉字转换为对应的阿拉伯数字
可能的区间划分：
一个汉字的 - 壹~拾
二个汉字拾开头 - 拾壹~拾玖
二个汉字拾结尾 - 贰拾|叁拾|...|玖拾
三个字的

num_map = {
    "壹": 1,
    "贰": 2,
    "叁": 3,
    "肆": 4,
    "伍": 5,
    "陆": 6,
    "柒": 7,
    "捌": 8,
    "玖": 9,
    "拾": 10,
}
info = \'玖拾陆\'
if len(info) == 1 and info in num_map:
    print(num_map[info])

if len(info) == 2 and info.startswith(\'拾\') and info[1] in num_map and info[1] != \'拾\':
    b = info[1]
    res = 10 + num_map[b]
    print(res)

if len(info) == 2 and info.endswith(\'拾\') and info[0] in num_map and info[0] != \'拾\':
    a = info[0]
    res = num_map[a] * 10
    print(res)

if len(info) == 3:
    a = info[0]
    b = info[1]
    c = info[2]
    res_a = a in num_map and a != \'拾\'
    res_b = b == \'拾\'
    res_c = c in num_map and c != \'拾\'
    if res_a and res_b and res_c:
        res = num_map[a] * 10 + num_map[c]
        print(res)

View Code

#18、完成元组的去重操作，操作后得到的还是元组类型
指定列表：(3, 1, 2, 2, 1, 5, 9, 7)
要求有序、无序两种操作方式下的去重

t = (3, 1, 2, 2, 1, 5, 9, 7)
print(tuple(set(t)))
ls = []
for v in t:
    if v not in ls:
        ls.append(v)
print(tuple(ls))

View Code

#19、完成对数据的格式化
原数据：[1, 3, 2, 9, 12, 23]
运行结果：[\'奇数\', \'奇数\', \'偶数\', \'奇数\', \'偶数\',\'奇数\']

ll = [1, 3, 2, 9, 12, 23]
# ls = [\'奇数\' if v % 2 != 0 else \'偶数\' for v in ll]
# print(ls)
ls = []
for v in ll:
    if v % 2 != 0:
        ls.append(\'奇数\')
    else:
        ls.append(\'偶数\')
print(ls)

View Code

#20、完成数据格式的个数记录
原数据：[1, 3, 2, 9, 12, 23]
运行结果：{\'奇数\': 4, \'偶数\': 2}

dic = {}
for v in ll:
    if v % 2 != 0:
        dic.setdefault(\'奇数\', 0)
        dic[\'奇数\'] += 1
    else:
        dic.setdefault(\'偶数\', 0)
        dic[\'偶数\'] += 1
print(dic)

View Code

#21、打印
"今天天气真好" utf-8编码下的二进制字符串
b\'\xe5\x85\xab\xe6\x9c\x9f\xe6\x97\xa0\xe6\x95\x8c\' tf-8编码下的普通字符串

s=\'今天天气真好\'
print(s.encode(\'utf-8\'))#编码  存操作   将普通字符串转为二进制字符串
##b\'\xe4\xbb\x8a\xe5\xa4\xa9\xe5\xa4\xa9\xe6\xb0\x94\xe7\x9c\x9f\xe5\xa5\xbd\'

res=b\'\xe4\xbb\x8a\xe5\xa4\xa9\xe5\xa4\xa9\xe6\xb0\x94\xe7\x9c\x9f\xe5\xa5\xbd\'
print(res.decode(\'utf-8\'))#解码  读操作  将二进制字符串转为普通字符
##八期无敌

View Code

#22、

综合题：完成录入电话本
-- 从键盘中录入姓名(不区分大小写)：
 -- 姓名必须是全英文组成，不是则重新录入姓名，如果是q，代表退出
-- 从键盘中再录入电话：
 -- 电话必须为数字且长度必须是11位(不能转换为数字)
-- 如果出现姓名相同，则保留最后一次电话号码
-- 形成的数据是有电话分组的，如：第一次录入Owen，13355667788，则会形成
 -- {
     \'O\': {
      \'Owen\': \'13355667788\'
     }
 }

最终数据，分组名一定大写：
{
    \'E\': {
  \'egon\': \'17788990000\',
  \'engo\': \'16633445566\'
    },
    \'O\': {
     \'Owen\': \'13355667788\'
    }
}

phone_dic = {

}
while True:
    name = input(\'name: \').strip().lower()
    if name == \'q\':
        break
    if not name.isalpha():
        continue

    while True:
        phone = input(\'phone: \').strip().lower()
        if not (phone.isdigit() and len(phone) == 11):
            continue

        # 分组名：
        group = name[0].upper()
        # phone_dic[group] = {}
        phone_dic.setdefault(group, {})
        phone_dic[group][name] = phone
        # 一次录入成功
        print(\'录入成功\')
        break

print(phone_dic)

View Code

 #23、统计文件数据中字母e出现的次数(不区分大小写)
# 文件内容：hello friend, can you speak English!
# 结果：4
# 分析：将文件内容读出，然后统计读出的字符串中字符e的个数(字符串count功能)

f = open(\'info.txt\', \'r\', encoding=\'utf-8\')
s_data = f.read().lower()
f.close()
count = s_data.count(\'e\')
print(count)

View Code

#24、统计文件数据中出现的的所有字符与该字符出现的个数(不区分大小写,标点与空格也算)
# 文件内容：hello friend, can you speak English!
# 结果：
\'\'\'
{
    \'h\': 1,
    \'e\': 4,
    \'l\': 3,
    \'o\': 2,
    \' \': 5,
    ...
}

# 分析：将文件内容读出，然后统计读出的字符串中每个字符的个数，形成字段(for遍历读取的字符串)
f = open(\'info.txt\', \'r\', encoding=\'utf-8\')
s_data = f.read().lower()
f.close()
c_map = {}
for v in s_data:
    c_map.setdefault(v, 0)
    c_map[v] += 1
print(c_map)

View Code

#25、读取文件内容，分析出所有的账号及对应的密码
# 文件内容：owen:123456|egon:123qwe|liuxx:000000
# 结果：
{
    \'owen\': \'123456\',
    \'egon\': \'123qwe\',
    \'liuxx\': \'000000\'
}

# 分析：将文件内容读出，然后按|拆分出 账号:密码 格式的子字符串，再按:拆分成 账号及密码，存放到字典中
f = open(\'usr.txt\', \'r\', encoding=\'utf-8\')
s_data = f.read()
f.close()
usr_map = {}
for k_v in s_data.split(\'|\'):
    k, v = k_v.split(\':\')
    usr_map[k] = v
print(usr_map)

View Code

#26、在上题的基础上，账号密码已经被存储在文件中，完成用户登录成功或失败(只做一次性判断)
# 文件内容：owen:123456|egon:123qwe|liuxx:000000
# 需求：输入账号、密码，然后进行登录判断，账号密码均正确打印登录成功，否则打印登录失败

# 分析：先完成题3，分析出账号密码字典，然后拿输入的账号密码与字典中数据进行校验

f = open(\'usr.txt\', \'r\', encoding=\'utf-8\')
s_data = f.read()
f.close()
usr_map = {}
for k_v in s_data.split(\'|\'):
    k, v = k_v.split(\':\')
    usr_map[k] = v

usr = input(\'usr: \')
pwd = input(\'pwd: \')

if pwd == usr_map.get(usr):
    print(\'登录成功\')
else:
    print(\'登录失败\')

View Code

#27、在25题的基础上，完成用户注册的功能(只做一次性判断)
# 文件内容：owen:123456|egon:123qwe|liuxx:000000
# 需求：输入注册的账号、密码，账号已存在的打印账号已存在，注册失败，反正打印注册成功，并将新账号密码录入文件
# 结果：如果输入mac、123123 => owen:123456|egon:123qwe|liuxx:000000|mac:123123
# 分析：先完成25题，分析出账号密码字典，然后拿输入的注册账号与字典中数据进行校验，如果校验没有新账号
# -- 1.采用 w 模式写文件，可以在读取文件的内容后拼接 |mac:123123 字符串，将拼接后的总字符串一次性写入
#  -- 2.采用 a 模式写文件，可以直接追加写入 |mac:123123 字符串

方法一：
dic={}
with open(\'user.txt\',\'a+\',encoding=\'utf-8\') as rf:
    # a+模式 a规定了不能操作自身写的游标，所以永远在末尾写，但+ 可以提供度的功能，且能完成游标的移动
    #
    rf.seek(0,0)
    data_str = rf.read()
    if data_str: #data_str不等于空字符串
        for k_v in data_str.split(\'|\'):
            k,v = k_v.split(\':\')
            dic[k] = v
print(dic)
usr = input(\'usr>>:\')

if usr in dic:
    print(\'账号已存在\')
else:
    pwd = input(\'pwd>>:\')
    if not dic:
        info = \'%s:%s\' % (usr, pwd)
    else:
        info = \'|%s:%s\' % (usr, pwd)
    with open(\'usr.txt\', \'a\', encoding=\'utf-8\') as wf:
        wf.write(info)

方法二：
f = open(\'usr.txt\', \'r\', encoding=\'utf-8\')
s_data = f.read()
f.close()
usr_map = {}
for k_v in s_data.split(\'|\'):
    k, v = k_v.split(\':\')
    usr_map[k] = v

# 默认w
usr = input(\'usr: \')
pwd = input(\'pwd: \')

# if usr in usr_map:
#     print(\'账号已存在，注册失败\')
# else:
#     w = open(\'usr.txt\', \'w\', encoding=\'utf-8\')
#     w_data = \'%s|%s:%s\' % (s_data, usr, pwd)
#     w.write(w_data)
#     w.close()

if usr in usr_map:
    print(\'账号已存在，注册失败\')
else:
    w = open(\'usr.txt\', \'a\', encoding=\'utf-8\')
    w.write(\'|%s:%s\' % (usr, pwd))
    w.close()

View Code

#28、统计文件中大写字母、小写字母、数字及其他字符出现的次数
# 文件内容：Abc123,-+XYZopq000.?/
# 结果：
{
    \'大写字母\': 4,
    \'小写字母\': 5,
    \'数字\': 6,
    \'其他字符\': 6
}

# 分析：利用ASCII表，for循环遍历每一个字符value，eg：\'a\' < value < \'z\'就代表是小写字母
r = open(\'info.txt\', \'r\', encoding=\'utf-8\')
r_data = r.read()
r.close()
res_map = {}
for v in r_data:
    if \'a\' <= v <= \'z\':
        res_map.setdefault(\'小写字母\', 0)
        res_map[\'小写字母\'] += 1
    #elif ord(A) in range(97,123):
        #res_map.setdefault(\'小写字母\', 0)
        #res_map[\'小写字母\'] += 1
    elif \'A\' <= v <= \'Z\':
        res_map.setdefault(\'大写字母\', 0)
        res_map[\'大写字母\'] += 1
    elif v.isdigit():
        res_map.setdefault(\'数字\', 0)
        res_map[\'数字\'] += 1
    else:
        res_map.setdefault(\'其他字符\', 0)
        res_map[\'其他字符\'] += 1
print(res_map)

View Code

#29、完成登录注册系统(从空文件开始做)

需求分析：

1.可以循环登录注册，输入1代表选择登录功能，输入2代表注册功能，输入0代表退出，其他输入代表输入有误，重输
2.用户的账号密码信息存放在usr.txt文件中，保证用户注册成功后，重启系统，用户信息仍然保存
3.登录在账号验证通过才输入密码验证登录，账号验证三次失败自动进入注册功能，登录三次验证失败自动退出系统
4.第一次注册，文件写入 账号:密码 信息，再次注册追加写入 |账号:密码 信息

#方法一
is_over = False
while not is_over :##①层
    cmd = input(\'\'\'请输入：
    1、登录
    2、注册
    0、退出
    >>:
\'\'\')
    with open(\'user.txt\',\'r\',encoding=\'utf-8\') as read_f:
        r_data = read_f.read()
    dic = {}
    if r_data:
        for k_v in r_data.split(\'|\'):
            k,v = k_v.split(\':\')
            dic[k] = v
    if cmd == \'0\':
        print(\'退出\')
        break
    elif cmd in [\'1\',\'2\']:
        if cmd == \'1\':
            print(\'登录\')
            count = 1
            while True:##②层
                if count > 3:
                    cmd = \'2\'
                    break #结束二层
                usr = input(\'usr>>:\')
                if usr not in dic:
                    print(\'账号不存在\')
                    count += 1
                    continue
                tag = 1
                is_login = False
                while True:#③层
                    if tag > 3:
                        break #结束三层
                    pwd = input(\'pwd>>:\')
                    if dic.get(usr) != pwd:
                        print(\'密码验证失败，重输\')
                        tag += 1
                    else:
                        is_login = True #可用于打印登陆是否成功的判断条件
                        is_over = True#结束一层
                        break #结束三层
                if is_login:
                    print(\'登陆成功\')
                else:
                    print(\'登陆失败\')
                break #结束二层

        if cmd == \'2\':
            print(\'注册功能\')
            new_usr = input(\'请输入账号>>:\')
            if new_usr in dic:
                print(\'账号已存在\')
                continue
            new_pwd =input(\'请输入密码》：\')
            wf = open(\'user.txt\', \'a\', encoding=\'utf-8\')
            info= \'%s:%s\'%(new_usr,new_pwd)
            if r_data:
                info = wf.write(\'|%s\'%info)
            wf.write(\'%s\'%info)
            wf.close()
            print(\'注册成功\')
    else:
        print(\'输入有误\')
        continue

方法二：

is_over = False
while not is_over:
    tag = input(\'\'\'请输入：
1：登录
2：注册
0：退出
>>>\'\'\')
    if tag == \'0\':
        print(\'退出系统！\')
        break
    elif tag in [\'1\', \'2\']:
        # 用户信息表usr_map分析过程
        r = open(\'usr.txt\', \'r\', encoding=\'utf-8\')
        r_data = r.read()
        r.close()
        usr_map = {}
        if r_data:  # 存在用户信息才有用户信息表usr_map
            for k_v in r_data.split(\'|\'):
                k, v = k_v.split(\':\')
                usr_map[k] = v

        if tag == \'1\':
            print(\'欢迎来到登录页面\')
            # 没有任何初始用户信息
            if not usr_map:
                print(\'无用户信息，请先注册\')
                tag = \'2\'
            # 有用户信息，可以登录
            else:
                # 记录账号验证失败次数
                usr_count = 0
                # 记录登录失败次数
                login_count = 0
                while True:
                    usr = input(\'usr: \')
                    if usr not in usr_map:
                        usr_count += 1
                        if usr_count >= 3:
                            print(\'账号验证次数过多，可以注册\')
                            tag = \'2\'
                            break
                    else:
                        pwd = input(\'pwd: \')
                        if pwd != usr_map.get(usr):
                            login_count += 1
                            if login_count >= 3:
                                print(\'登录验证次数过多，可以注册\')
                                tag = \'2\'
                                break
                        else:
                            print(\'登录成功！！！\')
                            is_over = True
                            break
        # 不用elif是保证，登录中可以通过tag = \'2\'直接来到注册页面
        if tag == \'2\':
            print(\'欢迎来到注册页面\')
            new_usr = input(\'new usr: \')
            if new_usr in usr_map:
                print(\'用户已存在，无需注册\')
                continue
            new_pwd = input(\'new pwd: \')
            w = open(\'usr.txt\', \'a\', encoding=\'utf-8\')
            info = \'%s:%s\' % (new_usr, new_pwd)
            # 已有用户，不是首次添加
            if usr_map:
                info = \'|%s\' % info
            w.write(info)
            w.close()
            print(\'注册成功！！！\')
    else:
        print(\'输入有误！\')

View Code

 

 #30、定义一个函数，该函数可以实现在内部输入一个信息，如何该信息不能转换为正整数，则重新输入，直到能转换为正整数，则对外返回转换的正整数

def back_r_int():
    while True:
        num = input(\'num: \')
        if num.isdigit():
            return int(num)

res = back_r_int()
print(res)

View Code

#31、定义一个函数，该函数可以实现在内部输入一个信息，如何该信息不能转换为负整数，则重新输入，直到能转换为负整数，则对外返回转换的负整数

def back_l_int():
    while True:
        num = input(\'num: \')
        if num.startswith(\'-\') and num[1:].isdigit() and num.count(\'-\') == 1:
            r_part = num.split(\'-\')[1]
            if r_part.isdigit():
                return int(num)
res = back_l_int()
print(res)

View Code

#32、定义一个函数，实现外界传入一个信息，内部判断是否能被转换为正整数，返回True | Flase信息

def func(num):
     
     if  num.isdigit():
         return True
     return False
num = input(\'num>>:\')
res=func(num)
print(res)

View Code

#33、定义一个函数，实现外界传入一个信息，内部判断是否能被转换为负整数，返回True | Flase信息

def func(num):
        if  num.startswith(\'-\') and num[1:].isdigit() :
            return True
        return False

num = input(\'num>>:\')
res=func(num)
print(res)

View Code

#34、定义一个函数，实现传入一个整型数字，判断并直接打印该数字是否是奇数还是偶数

#方法一
def is_odd(num):
    if num % 2 == 1:
        return \'偶数\'
    return \'奇数\'
方法二：三元表达式
def is_add(num):
    return \'偶数\' if num % 2 ==0 else \'奇数\'

View Code

#35、定义一个函数，实现判断传入数据的类型(有int、float、bool、list、dict、tuple、set)，并内部直接打印传入的数据的类型

#方法一
def data_type(data):
    if isinstance(data, bool):
        print(\'type - bool\')
        return
    if isinstance(data, int):
        print(\'type - int\')
        return
    if isinstance(data, float):
        print(\'type - float\')
        return
    if isinstance(data, complex):
        print(\'type - complex\')
        return
    if isinstance(data, str):
        print(\'type - str\')
        return
    if isinstance(data, list):
        print(\'type - list\')
        return
    if isinstance(data, tuple):
        print(\'type - tuple\')
        return
    if isinstance(data, dict):
        print(\'type - dict\')
        return
    if isinstance(data, set):
        print(\'type - set\')
        return

ls = [1, \'1\', 3.14, True, [], {}, {1,}, (1,), 4+5j]
for v in ls:  # 丢进去各种功能，检测我们的功能是否能检查这些类型
    data_type(v)

方法二
def func_type(usr_input):
    type_all = [int,float,bool,str,list,dict,tuple,set]
    for i in type_all:
        if isinstance(usr_input,i):
           print(i)
func_type(2)
func_type(\'a\')

View Code

#36、定义一个函数，只要传入 "k1:v1,...,kn:vn" 这样固定格式的字符串，都可以将其转换为 {\'k1\':\'v1\',...,\'kn\':\'vn\'}这样的字典并返回

def to_dic(string):
    dic = {}
    k_v_list = string.split(\',\')
    for k_v in k_v_list:
        k, v = k_v.split(\':\')
        dic[k] = v
    return dic

res = to_dic("name:owen,age:18,gender:male")
print(res)

View Code

#37、定义一个函数，实现列表与元组类型的反转功能，传入有数据的列表返回装有同数据的元组，反之亦然

def toggle_list_tuple(target):
    if isinstance(target, tuple):
        return list(target)
    if isinstance(target, list):
        return tuple(target)
res = toggle_list_tuple([1, 2, 3])
print(res)

View Code

#38、定义一个函数，只要传入的是list、tuple、set、dict四种类型中的一种变量，内部就循环打印该数据(前三种直接循环打印内部所有值，dict循环打印key与value两个信息)，不是这四种，则打印 "暂不支持该数据的循环打印"

def for_set(data):
    if isinstance(data, (list, tuple, set)): 
        for v in data:
            print(v)
    elif isinstance(data, dict):
        for k, v in data.items():
            print(k, v)
    else:
        print(\'暂不支持该数据的循环打印\')
for_set([1, 2, 3])

View Code

#39、定义一个函数，实现对单列集合进行去除的功能，传入有数据的list、tuple、set中的一种变量，返回同类型的去重后的结果

def get_clear(data):
    if isinstance(data, set):
        return data
    temp_list = []
    for v in data:
        if v not in temp_list:
            temp_list.append(v)
    if isinstance(data, tuple):
        return tuple(temp_list)
    return temp_list

res = get_clear([3, 1, 2, 1])
print(res)
res = get_clear((3, 1, 2, 1))
print(res)
res = get_clear({3, 1, 2, 1})
print(res)

View Code

#40、定义一个函数，实现同目录下文件的复制功能：传入一个文件名规定被复制的文件名，完成文件的复制

def move_file(file, new_file):
    with open(file, \'rb\') as r, open(new_file, \'wb\') as w:
        for line in r:
            w.write(line)

View Code

#41、定义一个函数，实现外界传入一个信息，内部判断是否能被转换为整数，返回True | Flase信息

def is_r_int(num):
    if num.isdigit():
        return True
    return False
def back_l_int():
    while True:
        num = input(\'num: \')
        if num.startswith(\'-\') and num.isdigit():
                return True
        return False
def is_int(num):
    return is_r_int(num) or back_l_int(num)

View Code

#42、用函数实现判断一个字符串数据能否转换为小数：可以只考虑 0.1 -0.1 这两种为合法情况

# 正小数
def is_r_float(num_str):  
    part_list = num_str.split(\'.\')
    # 一个.，按.拆分的左右都是数字
    if len(part_list) == 2 and part_list[0].isdigit() and part_list[1].isdigit():
        return True
    return False
# 负小数
def is_l_float(num_str):  
    # "-"开头，刨除"-"后是正整数
    if num_str.startswith(\'-\') and is_r_float(num_str[1:]):
        return True
    return False
# 正或负小数
def is_float(num_str):
    return is_l_float(num_str) or is_r_float(num_str):

View Code

 #43、

实现汽车销售系统
\'\'\'
1）具有进货功能1，销售车辆功能2，展示所有库存功能3，展示销售总业绩功能4
2）用户输入0退出系统，输入提供的功能编号，完成对应的功能，否则重新输入，eg：2就进入销售撤功能
3）车辆信息具有持久化(文件永久)存储功能，车辆有奔驰|宝马|奥迪三款
文件信息：
total.txt: 就是记录了总销售额

car.txt:
宝马 120000 9
奔驰 150000 7

奥迪 100000 8

4）进货功能：选择进货的车型与数量，完成进货
5）销车功能：选择售出的车，有库存售出，更新销售总业绩，没有则进入进货功能
6）展示库存：显示所有车与库存两条信息即可
7）总业绩：显示总业绩金额即可

分析：要将total.txt与car.txt转换为合适的数据类型，操作完毕后同步到文件中即可

\'\'\'
#分析一下 ： 选择哪种读出文件的内容放到字典的格式
{
\'宝马\':[120000 9]
}
{
\'宝马\':{\'price\':120000,\'num\':9}
}


\'\'\'


# 读car.txt
def read_car():
    dic = {}
    with open(\'car.txt\', \'r\', encoding=\'utf-8\') as f:
        for n_p_n in f:
            name, price, num = n_p_n.strip().split(\' \')
            dic[name] = [int(price), int(num)]
    return dic


# print(read_car())
def write_car(dic):
    with open(\'car.txt\', \'w\', encoding=\'utf-8\') as f:
        for k, v in dic.items():  # name,[price,num]
            info = \'%s %s %s\n\' % (k, v[0], v[1])
            f.write(info)


# dic = read_car()
# dic[\'宝马\'][1] +=10
# write_car(dic)

def choose_car():
    while True:
        car = input(\'car>>:\')
        if car in [\'宝马\', \'奔驰\', \'奥迪\']:
            return car


# choose_car()

def choose_num():
    while True:
        num = input(\'num>>:\')
        if num.isdigit() and int(num) > 0:
            return int(num)


def read_total():
    with open(\'total.txt\', \'r\', encoding=\'utf-8\') as f:
        return int(f.read())


def write_total(total):
    with open(\'total.txt\', \'w\', encoding=\'utf-8\') as f:
        f.write(str(total))


# 业绩
def grade(add_total=0):
    print(\'业绩功能\')
    # 1、读写total.txt
    if add_total > 0 :
        total = read_total() + add_total
        write_total(total)
    else:
         print(read_total())

# print(grade())
# grade(12000)
# 库存
def hub():
    print(\'库存功能\')
    # 1、读car.txt
    car_dic = read_car()
    # 2、显示
    for k, v in car_dic.items():
        print(k + \':\' + str(v[1]))


# 售车
def sell():
    print(\'销售功能\')
    # 1、读car.txt
    car_dic = read_car()
    # 2、选择车型
    car = choose_car()
    # 3、选择数量
    num = choose_num()
    # 4、判断数量：是进货还是卖货
    if car_dic[car][1] < num:
        print(\'存货不足\')
        stock()

    # 5、写入car.txt文件
    car_dic[car][1] -= num
    write_car(car_dic)
    # 6、操作业绩
    add_total = car_dic[car][0] * num
    grade(add_total)
    print(\'售车成功\')
# 进货
def stock():
    print(\'进货功能\')
    # 1、读car.txt
    car_dic = read_car()
    # 2、选择车型
    car = choose_car()
    # 3、选择数量
    num = choose_num()

    car_dic[car][1] += num
    # 4、写入car.txt文件
    write_car(car_dic)
    print(\'进货成功\')


method_map = {
    \'1\': stock,
    \'2\': sell,
    \'3\': hub,
    \'4\': grade,
}


def sys_start():
    while True:
        cmd = input(\'\'\'请输入：
1、进货 | 2、售车 | 3、库存 | 4、业绩 | 0、退出
>>>:\'\'\')
        if cmd == \'0\':
            break
        if cmd in method_map:
            method_map[cmd]()
        else:
            print(\'指令有误，重来\')


sys_start()

View Code

 #44、需求

1.用户信息由user.info文件存放，内容格式：abc|123|0,qwe|123|1000   账号|密码|余额,账号|密码|余额
2.实现 登录，注册，注销，购物，充值，退出系统 六个功能

3.注册可以完成用户的注册，注册时要提供账号密码，初始财产余额为0
1）注册先输入账号，要对账号做 输入的是否为空、输入的账号是否已经存在两种判断，都通过进入输入密码，否则重新输入
2）输入密码，要对密码长度最短为3位的限制，长度3位或以上代表合法，可以完成注册
3）注册是将账号密码写入文件，财产余额初始为0，
    第一次写入格式：账号|密码|余额
    再次写入格式：,账号|密码|余额

4.用户登录状态需要保存，在程序运行的py文件最上方定义一个user字典，字典为空代表未登录，为{\'usr\': 账号, \'ps\': 密码, \'money\': 余额}代表登录，记录的就是当前登录的用户

5.完成用户登录
1）解析user.info文件，将用户信息存放到users_dic字典中，格式见下，解析的过程可以定义为方法，
{
    \'abc\': {\'ps\': \'123\', \'money\': 0},
    \'qwe\': {\'ps\': \'000\', \'money\': 1000}
}
2）判断用户是否登录了，如果登录了就提示不需要重复登录，未登录就可以往下走，完成登录
3）先输入账号，账号为空、不存在都会验证失败，继续输入，3次失败后就可以进入注册功能，验证通过进行玩下
4）再输入密码，密码必须超过3位，3次登录失败退出登录，成功的记录登录的用户信息到user字典，表示已登录

6.用户注销，就是清楚登录状态，将存放登录用户信息的user字典制空user={}

7.用购物功能完成购物，
1）必须在登录状态，未登录时，进入登录页面，已登录则可以购物
2）预定义一些商品与价格，每一次完成购物后，提示用户是否继续进行购物
3）如果余额不足则进入充值功能

8.充值功能
1）必须在登录状态才可以操作
2）充值后的金额数据要同步到user.info文件，user字段和user_dic字典中

9.退出系统，将退出系统，但注册的用户和余额都保存在文件中

# 登录认证装饰器（装饰器知识点主要用在登录认证功能）
def check_login(func):
    def inner(*args, **kwargs):
        if not user:  # 没有登陆先去登录
            login()
        res = func(*args, **kwargs)
        return res

    return inner


# 读user_info
def _read_file():
    dic = {}
    with open(\'user_info\', \'r\', encoding=\'utf-8\') as f:
        data = f.read()  # 全部都出来
        if data:  # 判断是否为空，不为空继续
            ls = data.split(\',\')  # 对字符串进行切分，得到一个列表
            for n_p_m in ls:  # 对列表进行取值
                name, pwd, money = n_p_m.split(\'|\')  # 对去除的列表值---即每个字符串进行按|切分，然后解压赋值
                dic[name] = {\'ps\': pwd, \'money\': int(money)}  # 然后按照字典的格式进行添加到字典当中,要把money转为整形，后面需要运算
    return dic  # 该函数读出来的字典，后续用到改函数功能就能得到改字典


# print(_read_file())#测试read功能{\'abc\': {\'ps\': \'123\', \'money\': \'0\'}, \'qwe\': {\'ps\': \'123\', \'money\': \'1000\'}}
# 写user_info:需要传入参数大字典dic，因为这样 不管你是修改密码还是金额，只要把这个大字典同步到文件就可以
def _write_file(dic):
    info = \'\'
    for k, v in dic.items():
        u = k
        p = v[\'ps\']
        m = v[\'money\']
        info += \'%s|%s|%s,\' % (u, p, m)  # 改格式化 是要分为首次写入还是追加进去 ，追加的话要加一个逗号分隔，可以提前在格式化后面加个逗号，后面再切片
    # print(info)
    info = info[:-1]  # 切掉最后一个逗号
    with open(\'user_info\', \'w\', encoding=\'utf-8\') as f:
        f.write(info)


# _write_file({\'abc\': {\'ps\': \'123\', \'money\': \'0\'}, \'qwe\': {\'ps\': \'123\', \'money\': \'1000\'}})#测试写功能abc|123|0,qwe|123|1000,


# 定义一个全局的当前登录用户
user = {}


# 登录功能
def login():
    print(\'登录\')
    global user
    # 1、登陆状态的状态
    if user:  # 判断账号是否存在，存在代表已登录，就退出 使用return
        print(\'账号已登陆\')
        return
    # 2获取用户信息
    user_dic = _read_file()
    # 3、账号验证，三次错误去注册
    count = 1
    while True:
        if count > 3:
            return register()  # 大于三次以后要去注册，注意注册完不能往下走了，又用到return哈，结束函数  重点哦
        usr = input(\'usr:\').strip()
        if usr not in user_dic:
            print(\'账号有误\')
            count += 1
            continue
        break
    # 3、密码验证 三次失败退出登录
    tag = 1
    while True:
        if tag > 3:
            print(\'验证超次，登陆失败\')
            return
        pwd = input(\'pwd:\').strip()
        if len(pwd) < 3:
            print(\'密码过短\')
            tag += 1
            continue
        if user_dic[usr][\'ps\'] != pwd:
            print(\'密码验证失败\')
            tag += 1
            continue
        break
    # 5、完成登录，更新登陆状态
    money = user_dic[usr][\'money\']
    user = {\'usr\': usr, \'ps\': pwd, \'money\': money}
    print(\'登陆成功\')


# 注册功能
def register():
    print(\'注册\')
    # 1、读用户
    user_dic = _read_file()  # 这里可以有一个点子，因为上面的写功能是w模式，覆盖写，所以先把所有信息读到该变量
    # 2、账号验证
    while True:
        usr = input(\'usr:\').strip()
        if not usr:
            print(\'账号不能为空\')
            continue
        if usr in user_dic:
            print(\'账号已存在\')
            continue
        break  # 账号正确了
    # 3、密码认证
    while True:
        pwd = input(\'pwd:\').strip()
        if len(pwd) < 3:
            print(\'密码太短\')
            continue

        break  # 账号正确了
    # 4、注册信息
    user_dic[usr] = {\'ps\': pwd, \'money\': 0}
    # 5、注册成功
    _write_file(user_dic)  # 更新文件用户信息
    print(\'注册成功\')


goods_map = {
    \'女朋友\': 10,
    \'男朋友\': 5,
    \'法拉利\': 3000
}


# 购物功能
@check_login
def shopping():
    print(\'购物功能\')
    for k, v in goods_map.items():
        print(k, v, end=\' \')
    goods = input(\'输入购物商品名:\').strip()
    if goods not in goods_map:
        print(\'没有该商品，请重树！\')
    money = user[\'money\']
    while goods_map[goods] > money:
        choose = int(input(\'是否去充值0|1:\'))
        if not choose:
            return
        top_up()
        money = user[\'money\']
    user[\'money\'] -= goods_map[goods]
    user_dic = _read_file()  # 调用读文件，把读出来的字典信息赋值给该变量
    usr = user[\'usr\']  # 先获取当前用户
    user_dic[usr][\'money\'] -= goods_map[goods]  ##更新字典user_dic的金额信息
    _write_file(user_dic)  # 把整个大字典的信息在更新到文件中
    print(\'购物成功\')
    goingshop =int(input(\'是否继续购物：\'))
    if goingshop:
        shopping()

# 充值功能
@check_login
def top_up():
    print(\'充值功能\')
    # 保证当前用户 user,字典user_dic, 文件user_info 同步
    money = int(input(\'money:\'))
    user[\'money\'] += money  # 更新当前用户的金额信息
    user_dic = _read_file()  # 调用读文件，把读出来的字典信息赋值给该变量
    usr = user[\'usr\']  # 先获取当前用户
    user_dic[usr][\'money\'] += money  ##更新字典user_dic的金额信息
    _write_file(user_dic)  # 把整个大字典的信息在更新到文件中
    print(\'充值成功\')


# 注销功能
def logout():
    print(\'注销功能\')
    global user
    if not user:
        print(\'未登录，无需注销\')
        return
    user.clear()
    print(\'注销成功\')


method_map = {
    \'1\': login,
    \'2\': register,
    \'3\': shopping,
    \'4\': top_up,
    \'5\': logout
}


# 程序入口
def sys_start():
    while True:
        cmd = input("""选择功能：
1、登录 | 2、注册 | 3、购物 | 4、充值 | 5、注销 | 0、退出
>>>:""")
        if cmd == \'0\':
            print(\'退出成功\')
            break
        if cmd in method_map:
            method_map[cmd]()
        else:
            print(\'输入有误，请重新输入！\')
            continue


sys_start()

View Code