练习题解答（二）

1、现有列表alist = [3,1,-4,2,-6] 按照元素的绝对值大小进行排序（注意，内置函数中也有sorted方法，但是会开辟内存，所以尽量用list自带方法sort)

alist = [3,1,-4,2,-6]
ret=sorted(alist,key=lambda x:abs(x))
print(ret)

2、5.输入某年某月某日,判断是这一年中的第几天?(用内置模块实现)

import time
input_ = input('请输入年月日：')
time_local = time.strptime(input_,'%Y-%m-%d %X')
print(time_local.tm_yday)  # 结构化时间调用里面的参数

3、一行代码实现[1,4,9,16,25,36,49,64,81,100]

print(list(map(lambda x: x**2,range(1,11))))

4、从0-99这个100个数中随机取出10个不重复的数

import random
print(list(random.sample(list(range(0,100)),10)))

5、一行代码,通过filter和lambda函数输出以下列表索引为奇数对应的元素

lis = [12,13,14,151,5,16,17,117,133,144,177]
print(list(filter(lambda x:lis.index(x)%2!=0,lis)))

  

print(list(filter(lambda x:x,(lis[i] for i in range(1,len(lis),2)))))

6、将下列数据转成想要的结果,尽量用简洁的方式实现:

　　原数据lst =[[1,2,3],[4,5,6],[7,8,9]]
　　转换后 li = [1,2,3,4,5,6,7,8,9]

lst =[[1,2,3],[4,5,6],[7,8,9]]
li = [x for i in lst for x in i]
print(li)

 

7、实现一个装饰器,通过调用一次装饰器使被装饰的函数调用5次

def warpper(f):
    def inner(arg):
        for i in range(5):
            f(arg)
            arg += 1
    return inner
@warpper
def fun(num):
    print('我被执行了%s次了'%num)
fun(1)

8、将列表内的元素,根据位数被合并成字典(升级题)lst = [1,2,3,4,12,13,14,123,124,125,1234,1235,1236,1237,12345,12346,12347]

变成
{
1:[1,2,3,4],
2:[12,13,14],
3:[123,124,125],
4:[1234,1235,1236,1237],
5:[12345,12346,12347]
}

from collections import defaultdict
d = defaultdict(list)  # 这里里面的参数可以是任何可变数据类型，可以不断往里面加值
for i in lst:
    d[len(str(i))].append(i)   # 不断地给相应的加值
d = dict(d)   # 会根据最终值工厂化这个字典
print(d)

 

9、12.输入一个不是空的字符串,判断这个字符串是不是由一个子字符重复多次组成,字符只包含小写字母,且长度不超过1000(升级题)

示例一:
输入:"abab"
这种就输出True,因为输入的是ab重复组成的字符串
示例二:
输入:"abcabcabc"
这种就输出True,因为输入的是abc重复组成的字符串
示例三:
输入:"abcdabcd"
这种就输出True,因为输入的是abcd重复组成的字符串
示例四:
输入:'abc"
这种就输出False,因为输入的没有重复组成字符串

法一 ：
def func():
    cont = input('请输入字符串：').strip()
    for i in range(1,len(cont)-1):
        for j in range(i,len(cont),i):
            if cont[0:0+i]==cont[j:j+i]:continue  # 迭代比较
            elif cont.replace(cont[0],'') =='':continue  # 排除单个字母重复奇数次
            else:break
        else:return True
    else:return False
print(func())

法一：
s = input("请输入一个只包含小写字母组成的字符串：").strip()
l=len(s)
for i in range(l//2):
    j=l//(i+1)    
    if s[0:i+1]*j==s:
        print(True)
        break
else:
    print(False)

num = input('请输入一个字符:')
j = 1
while 1:
    print(num[:j])
    if (num[:j])*(num.count(num[:j])) == num and (num[:j] != num):
        print(True)
        break
    elif num[:j] == num:
        print(False)
        break
    else:
        j += 1

10、 求结果 v = [lambda :x for x in range(10)]

print(v)   #[<function <listcomp>.<lambda> at 0x02EE2F60>, ……
print(v[0])  #<function <listcomp>.<lambda> at 0x02EE2F60>
print(v[5]())  #9 全是9，应为最后一个x为9，所有的函数执行时都引用一个9的内存

11、求结果v = (lambda :x for x in range(10))

print(v)    #一个生成器地址  <generator object <genexpr> at 0x0382E870>
print(v[0])  # 注意生成器没有索引 TypeError: 'generator' object is not subscriptable
print(v[0]())  # 生成器只能send或则next调用 TypeError: 'generator' object is not subscriptable
print(next(v))   #一内存地址 <function <genexpr>.<lambda> at 0x03182F60>
print(next(v)())  #1

12、有两个字符串列表,a和b,每个字符是由逗号分隔的一些字符,(升级题)尽量做得支持扩展

a = [
'a,1',
'b,3,22',
'c,3,4',
'f,5',
]
b=[
'a,2,1',
'b,4',
'd,2',
'e,12',
'g,12,43',
'a,4354,6'
]
按每个字符串的第一个值,合并a和b到c
c = [
'a,1,2',
'b,3,22,4',
'c,3,4',
'd,2',
'e,12',
'f,5'
]

法1：
c=[]
for i in a:
    flag = False
    removes = None
    i = i.strip()
    li=[i[0],i[2:],]
    for v in b:
        v=v.strip()
        if i[0]==v[0]:
            li.append(v[2:])
            flag,removes=True,v
            break
    print(li)
    c.append(','.join(li))
    if flag:
        b.remove(removes)
else:
    c.extend(b)
print(c)

法2：
g = { i[0]:i for i in a}
for i in b:
    if i[0] in g:
        g[i[0]]=g[i[0]][2:]+i[1:]
    else:
        g[i[0]]=i

print(list(g.values()))

dic=dict([(i[0],i) for i in a])
for v in b:
    if dic.get(v[0]):dic[v[0]]=dic[v[0]]+v[1:]
    else: dic[v[0]]=v[2:]
print(list(dic.values()))

13、正则表达式例题

1、匹配整数或者小数（包括正数和负数）
        [-|+]?\d+(\.\d+)?
2、匹配年月日日期 格式2018-12-6
        \d{4}-\d+-\d+
3、匹配qq号
        ^[^0]\d{8}\d$
4、长度为8-10位的用户密码 ： 包含数字字母下划线
        \w{8}(\w{2})?
5、匹配验证码：4位数字字母组成的
        [0-9A-z]{4}
6、匹配邮箱地址
        [^0]\d{9}@[qq|126|outlook]+\.[a-z]{3}        

14、 用hashlib模块 写函数来校验两个文件是否内容一致（要考虑到文件过大，如何处理）

import hashlib
md5=hashlib.md5(b'alex')
md4=hashlib.md5(b'alex')
def read_txt(first_file,second_file):
    with open(first_file,'r',encoding='utf-8') as f,\
        open(second_file,'r',encoding='utf-8') as f2:
        targt =True
        while targt:
            i=f.readline()
            i_2 =f2.readline()
            m_info =md5.update(i.encode('utf-8'))
            m_comp = md5.hexdigest()
            m_info_2 =md4.update(i_2.encode('utf-8'))  #update方法不能累加
            m_comp_2 = md4.hexdigest()
            if m_comp !=m_comp_2:
                return False
            elif i_2 =='':
                return True
ret=read_txt('1.txt','2.txt')
print(ret)

 

# 在公司中很可能要验证一些视频文件，但是上面的代码就不行了
import os
import hashlib

def file_md5(path):
    filesize = os.path.getsize(path)   # 先获取文件大小
    md5 = hashlib.md5()      # 获取对象
    with open(path,'rb') as f:
        while filesize >= 4096:   # 判断大小，以便相减
            content = f.read(4096)
            md5.update(content)  # 每次更新对象内容
            filesize -= 4096
        else:
            content = f.read(filesize)
            if content:
                md5.update(content)
    return md5.hexdigest()  # 生成密文

def cmp_file(path1,path2):
    return file_md5(path1) == file_md5(path2)

path1 = r'D:\s20\day18\视频\4.面向对象整理.mp4'
path2 = r'D:\s20\day18\视频\tmp.mp4'
ret = cmp_file(path1,path2)
print(ret)

 15、用hashlib模块做一个密文存储密码的注册登陆程序。

import hashlib
def register():
    md5 = hashlib.md5()
    with open('register.txt','a+',encoding='utf-8') as f:
        print('欢迎注册'.center(20,'='))
        new_usr = input('新用户名：').strip()
        new_pw = input('新密码：').strip()
        md5.update(new_pw.encode('utf-8'))
        hash_pw = md5.hexdigest()
        f.write('%s|%s\n'%(new_usr,hash_pw))
    return True

def warpper(func):
    def check(usr,func_2):
        tagert_2 =False
        while not tagert_2:
            print('欢迎登陆'.center(20,'='))
            md4 = hashlib.md5()
            with open('register.txt','r',encoding='utf-8') as f2:
                usr = input('用户名：').strip()
                for i in f2:
                    i = i.strip().split('|')
                    if i[0]==usr:
                        pw = input('密码：').strip()
                        md4.update(pw.encode('utf-8'))
                        md4_info = md4.hexdigest()
                        if i[1]==md4_info:
                            return func(i[0])
                else:
                    print('<<<用户未注册>>> '.center(20,'*'))
                    targt_2 = func_2()
    return check

@warpper
def logging(usr,re=None):
    print('%s登陆成功！'%usr)

logging(None,register)

import hashlib
def md5(username,password):
    md5 = hashlib.md5(username[::-1].encode('utf-8'))
    md5.update(password.encode('utf-8'))
    return md5.hexdigest()

def get_line():
    with open('userinfo', encoding='utf-8') as f:
        for line in f:
            user, pwd = line.strip().split(',')
            yield user,pwd   #生成器 

def register():
    flag = True
    while flag:
        username = input('user :')
        password = input('passwd :')
        for user,pwd in get_line():
            if user == username:
                print('您输入的用户名已经存在')
                break
        else:
            flag = False
    password = md5(username,password)
    with open('userinfo',encoding='utf-8',mode='a') as f:
        f.write('%s,%s\n'%(username,password))

def login():
    username = input('user :')
    password = input('passwd :')
    for user,pwd in get_line():
        if username == user and pwd == md5(username,password):
            return True


ret = login()
if ret:
    print('登陆成功')

16、拼手气红包，要求每个人的概率均等。

import random
def func(money,pople):
    lst=[0,2000]
    lst.extend(random.sample(list(range(0,money*10)),pople-1))
    lst.sort()
    lst =list(map(lambda x:x/10,lst))
    g=(round(lst[i+1]-lst[i],3) for i in range(len(lst)-1))
    return g
ret=list(func(200,10))
print(ret)

# 涉及到读取文件，最好使用生成器
import random
def red_pac(money,num):
    ret = random.sample(range(1,money*100),num-1)
    ret.sort()
    ret.insert(0,0)
    ret.append(money*100)
    for i in range(len(ret)-1):
        value = ret[i+1] - ret[i]  #迭代器
        yield value/100

g = red_pac(200,10)
for i in g:
    print(i)

 

17、os模块计算文件夹总大小：（注意要考虑文件中还有多个文件夹怎么办）

　　　　1、这个文件夹里面都是文件
　　　　2、这个文件夹里还有文件

import os
def get_size(path):
    size = 0
    l = [path]
    while l:
        path = l.pop()
        lst = os.listdir(path)
        for name in lst:
            son_path = os.path.join(path,name)
            if os.path.isfile(son_path):
                size += os.path.getsize(son_path)
            else:
                l.append(son_path)
    return size

size = get_size(r'D:\s14\算法')
print(size)

 

20、计算当前月1号 的时间戳时间

import time
shi_jian_chou = time.time()
strct_time=time.localtime(shi_jian_chou) # 转化成结构化时间
new_time=shi_jian_chou-86400*strct_time.tm_mday # 打印天数
print(new_time)
print(time.localtime(new_time))

import time
现在是哪个月
def first_day():
    str_t = time.strftime('%Y-%m')
    tup_t = time.strptime(str_t,'%Y-%m')
    stamp_t = time.mktime(tup_t)
    return stamp_t
f = first_day()
print(f)

21、省、市、区三级菜单

menu = {
    '北京': {
        '海淀': {
            '五道口': {
                'soho': {},
                '网易': {},
                'google': {}
            },
            '中关村': {
                '爱奇艺': {},
                '汽车之家': {},
                'youku': {},
            },
            '上地': {
                '百度': {},
            },
        },
        '昌平': {
            '沙河': {
                '老男孩': {},
                '北航': {},
            },
            '天通苑': {},
            '回龙观': {},
        },
        '朝阳': {},
        '东城': {},
    },
    '上海': {
        '闵行': {
            "人民广场": {
                '炸鸡店': {}
            }
        },
        '闸北': {
            '火车战': {
                '携程': {}
            }
        },
        '浦东': {},
    },
    '山东': {
        '聊城':{
            '耿家庄':{},
            '耿二庄':{},
        },
    },
}
li =[]
def func(menus,parent_palce=menu):
    current_place = list(menus.keys())
    for i,v in enumerate(current_place,1):
        print(i,v)
    if current_place ==[]:
        print('已经到最底层了！！！')

    usr_choose = input('请输入相关城市(Q退出，B返回上一层)>>> ').strip()
    if usr_choose.lower()=='b':
            menus =parent_palce
            for i in range(len(li)-1,-1,-1):     # parent_palce在给了值之后要更改到上一级
                parent_palce=li[i]
            try:
                li.pop()
            except:pass
            func(menus,parent_palce)
    elif usr_choose.isdigit() and 0<int(usr_choose)<=len(current_place):
        sub_place = menus[current_place[int(usr_choose)-1]]
        li.append(menus)
        parent_palce = menus
        func(sub_place,parent_palce)
    elif usr_choose.upper() =='q':
        exit()
    else: print('输入有误！！！')
func(menu)

#递归
def threeLM(dic):
    while True:
        for k in dic:print(k)
        key = input('input>>').strip()
        if key == 'b' or key == 'q':return key
        elif key in dic.keys() and dic[key]:
            ret = threeLM(dic[key])
            if ret == 'q': return 'q'

threeLM(menu)

#压栈
l = [menu]
while l:
    for key in l[-1]:print(key)
    k = input('input>>').strip()   # 北京
    if k in l[-1].keys() and l[-1][k]:l.append(l[-1][k])
    elif k == 'b':l.pop()
    elif k == 'q':break

l = [menu]
while l:
    for k in l[-1]:
        print(k)
    key = input('>>>')
    if key.upper() == 'B':
        l.pop()
    elif key.upper() == 'Q':
        l.clear()
    elif l[-1].get(key):  #判断是否在内
        l.append(l[-1][key])

 

22、1-2*((60-30+(-40/5)*(9-2*5/3+7/3*99/4*2998+10*568/14))-(-4*3)/(16-3*2))从上面算式中匹配出最内层小括号以及小括号内的表达式

import re
print(re.findall('\([^()]+\)','1-2*((60-30+(-40/5)*(9-2*5/3+7/3*99/4*2998+10*568/14))-(-4*3)/(16-3*2))'))

23、从类似9-2*5/3+7/3*99/4*2998+10*568/14的表达式中匹配出乘法或除法

import re
print(re.findall('\d+(?:\.\d+)?[*/]\d+(?:\.\d+)?','9-2*5/3+7/3*99/4*2998+10*568/14'))

24、从lianjia.html中匹配出标题，户型和面积，结果如下：

[('金台路交通部部委楼南北大三居带客厅 单位自持物业', '3室1厅', '91.22平米'),
('西山枫林 高楼层南向两居 户型方正 采光好', '2室1厅', '94.14平米')]

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<div class="info clear">
    <div class="title">
        <a class="" href="https://bj.lianjia.com/ershoufang/101103186217.html" target="_blank" data-log_index="1"
           data-el="ershoufang" data-housecode="101103186217" data-is_focus="1" data-sl="">金台路交通部部委楼南北大三居带客厅   单位自持物业</a>
        <span class="new tagBlock">新上</span></div>
    <div class="address">
        <div class="houseInfo">
            <a href="https://bj.lianjia.com/xiaoqu/1111027381816/" target="_blank" data-log_index="1" data-el="region">延静西里 </a>
            <span class="divide">/</span>3室1厅<span class="divide">/</span>91.22平米<span class="divide">/</span>南 北<span class="divide">/</span>简装<span class="divide">/</span>有电梯
        </div>



上面是部分html文档，正则出想要的结果：
法一（笨办法）：
import re
f = open('lianjia.html','r',encoding='utf-8')
info = f.read()
ret = re.compile(r'<div class="info clear">.*?div class="title">.*?<a class=.*?>(?P<id>\w+).*?</a>'
'.*?<span class="divide">/</span>(?P<area>\w+)<span.*?</span>(?P<mian>\d+(\.\d+)?\w+)<span.*?class',re.S)
print(ret.findall(info)


法二：
with open('lianjia.html', 'r', encoding='utf-8') as f:
    file_obj = f.read()
om = re.compile(
    '<div class="info clear">.*? data-sl="">(?P<title>.*?)</a>.*?<span class="divide">/</span>(?P<house>.*?)'
    '<span class="divide">/</span>(?P<area>.*?)<span class="divide">/</span>', re.S)
res = om.findall(file_obj)
print(res)

25、匹配年月日日期 类似 2018-12-06 2018/12/06 2018.12.06

import re
ret = re.findall('\w{1,4}[-|/|\.]\w{2}[-|/|\.]\w{2}',s)
ret1 = re.findall('\w{1,4}(?:[-/\.]?\w{2}){2}',s)
print(ret,ret1)

 26、匹配一篇英文章的标题 类似 The Voice Of China

import re
ret = re.search('([A-Z]\w+[ ]?)+','adfadfafdadfThe Voice Of China adfafafx')
print(ret.group())

([A-Z][a-z]*)( [A-Z][a-z]*)*

27、用正则表达式对标签进行匹配

import re

ret = re.search("<(?P<tag_name>\w+)>\w+</(?P=tag_name)>","<h1>hello</h1>")
#还可以在分组中利用?<name>的形式给分组起名字
#获取的匹配结果可以直接用group('名字')拿到对应的值
print(ret.group('tag_name'))  #结果 ：h1
print(ret.group())  #结果 ：<h1>hello</h1>

ret = re.search(r"<(\w+)>\w+</\1>","<h1>hello</h1>")
#如果不给组起名字，也可以用\序号来找到对应的组，表示要找的内容和前面的组内容一致
#获取的匹配结果可以直接用group(序号)拿到对应的值
print(ret.group(1))
print(ret.group())  #结果 ：<h1>hello</h1>

28、对数字进行整数匹配（用到findall的优先级处理）

import re

ret=re.findall(r"\d+","1-2*(60+(-40.35/5)-(-4*3))")
print(ret) #['1', '2', '60', '40', '35', '5', '4', '3']
ret=re.findall(r"-?\d+\.\d*|(-?\d+)","1-2*(60+(-40.35/5)-(-4*3))")
print(ret) #['1', '-2', '60', '', '5', '-4', '3']  # 这里优先匹配整数，括号的用法
ret.remove("")
print(ret) #['1', '-2', '60', '5', '-4', '3']

29、对数字、年份等进行匹配

1、 匹配一段文本中的每行的邮箱
      http://blog.csdn.net/make164492212/article/details/51656638

2、 匹配一段文本中的每行的时间字符串，比如：‘1990-07-12’；

   分别取出1年的12个月（^(0?[1-9]|1[0-2])$）、
   一个月的31天：^((0?[1-9])|((1|2)[0-9])|30|31)$

3、 匹配qq号。(腾讯QQ号从10000开始)  ［1,9］[0,9]{4,}

4、 匹配一个浮点数。       ^(-?\d+)(\.\d+)?$   或者  -?\d+\.?\d*

5、 匹配汉字。             ^[\u4e00-\u9fa5]{0,}$ 

 

30、计算器

import re

count ='1-2*((60-30+(-9-2*5/3+7/3*99/4*2998+10*568/14)*(-40/5))-(-4*3)/(16-3*2))'
def atom_cal(atom_count):#计算乘除
    for i in atom_count:
        if i == '*':
            n1,n2 = atom_count.split('*')
            return float(n1)*float(n2)
        elif i == '/':
            n1,n2 = atom_count.split('/')
            return float(n1)/float(n2)
def atom_cal1(brack_ret):#计算加减
    sum = 0
    for i in brack_ret:
        sum += float(i)
    return sum
def dropbug(brack_ret):
    brack_ret = brack_ret.replace('--', '+')
    brack_ret = brack_ret.replace('-+', '-')
    brack_ret = brack_ret.replace('+-', '-')
    return brack_ret
def cal(brack_ret):
    while 1:
        brack_ret_count = re.search('\d+(\.\d+)?[*/]-?\d+(\.\d+)?',brack_ret) #匹配乘除
        if brack_ret_count:
            atom_count = brack_ret_count.group() #取值
            atom_result = atom_cal(atom_count)
            brack_ret = brack_ret.replace(atom_count,str(atom_result)) #替换新值
        else:
            break  #直到吧括号内都算完
    brack_ret = dropbug(brack_ret) #去符号
    brack_ret_2 = re.findall('(-?\d+(?:\.\d+)?)', brack_ret) # 匹配数进行加减
    if brack_ret_2:
        atom_count = brack_ret_2
        atom_result = atom_cal1(atom_count)
        brack_ret_3 = str(atom_result)
    return brack_ret_3
def main(count):
    while 1:
        ret = re.search('\([^()]+\)',count) #判断还有无括号
            if ret:
            brack_ret = ret.group()  # 获取值
            ret_1 = cal(brack_ret)  # 计算括号内值
            count = count.replace(ret.group(),ret_1.strip('()'))
        else:
            break
    return cal(count)
result_2 = main(count)
print(result_2)

 31、当前年月日的凌晨12点对应的时间戳时间是多少，当前年月日的凌晨12点对应限制的时间差了多少

import time
def now_day():
    today_time=time.strftime('%Y-%m-%d')  # 格式化时间
    locals_time=time.strptime(today_time,'%Y-%m-%d')  #  获取到结构化时间，默认返回凌晨时间
    return time.mktime(locals_time)   # 获取时间戳
ret=now_day()
print(ret)

# 当前年月日的凌晨12点对应限制的时间差了多少
def com_time(new_time):
     now_time = time.time()-now_day()
     return now_time
t=time.time()
print(com_time(t))

 32、获取最大公约数和最小公倍数

a = 36
b = 21

def maxCommon(a, b):
    while b: a,b = b, a%b
    return a

def minCommon(a, b):
    c = a*b
    while b: a,b = b, a%b
    return c//a

if __name__ == '__main__':
    print(maxCommon(a,b))
    print(minCommon(a,b))

 

33、获取中位数

def median(data):
    data.sort()  # [1, 2, 3, 4, 8, 42, 46, 53, 82]
    print(l[~3]) # 42
    print(l[:~5]) # [1, 2, 3]
    print(l[~1:3:2]) # []
    print(l[~1:3:-2]) # [53, 42]
    print(l[~1::-2]) # [53, 42, 4, 2]
    print(l[~1]) # 53  # 所以~ 再将会是倒着从0开始算索引
    half = len(data) // 2
    print(data)
    print(data[~half])
    print(data[half])
    return (data[half] + data[~half])/2

l = [1,3,4,53,2,46,8,42,82]

if __name__ == '__main__':
    print(median(l))