Python --之练习题

一，两个小组对战，对战规则如下：
team1 = ['a','b','c']
team2 = ['x','y','z']   #a 不和x对战，b 不和y,z 对战
# for i in team1:  #法一
#     for j in team2:
#         if i == 'a' and j == 'x':
#             continue
#         elif  i == 'c' and (j == 'y' or j =='z'):
#             continue
#         else:
#             print('%s VS %s'%(i,j))

for t1 in team1:  #法二
    if t1 == 'a':
        tmp = team2[team2.index('x')+1:]  #返回x 的索引
    elif  t1 == 'b':
        tmp = team2[:team2.index('y')]  #返回 y 的索引
    else:
        tmp = team2
    for t2 in tmp:
        print('%s VS %s'%(t1,t2))

def func(x):
    if x > 0 :
        func(x-1)
        print(x)
func(5)
输出结果： 1 2 3 4 5  （递归）

二，循环删list元素

li = [1,1,2,3,4,5,6,7,8,9]

for i in li:
    if i%2!=0:
        li.remove(i)
print(li)
输出结果： [1, 2, 4, 6, 8]

 三，获取文件扩展名

import os
def file_extension(path):
    return os.path.splitext(path)[1]
print(file_extension('http://www.jb51.net/article/68958.html'))
四，获取当前系统日期的前一天或前一秒

import datetime
# now_time = datetime.date.today()
now_time = datetime.datetime.now()
yesterday = now_time + datetime.timedelta(days = -1)
second = now_time +datetime.timedelta(seconds= -1)
print(yesterday,second)
五，校验邮箱格式

'''
先看一下邮箱的一般格式：

x@x.x

x 表示一个或多个字符或数字。

1）第一个x可以字母数字

2）第二个x可以字母数字

3）第二个x可以字母，如.com,.cn,.net...等结尾

“@”和“.” 把内x拆成三部份。

整个邮箱长度最少等于5个字符
'''
import re
'''
[a-zA-Z0-9]   匹配大小写字母与数字
[a-zA-Z]      匹配大小写字母
\@    a\@b     a@b   (字符转义)
\.    a\.b     a.b   (字符转义)
'''
def emails(e):
    if len(e) >= 5:
        if re.match("[a-zA-Z0-9]+\@+[a-zA-Z0-9]+\.+[a-zA-Z]",e) !=None:
            return '邮箱格式正确。'
    return '邮箱格式错误。'
e = input('请输入email:')
print(emails(e))

六、清理日志脚本

写一个清理日志的脚本，每次运行就把三天之前的日志删除，日志名的格式是xxx-20170623.log

import os,datetime
class Clear_log(object):
    def __init__(self,path):
        self.path = path
    def clean_log(self):
        if os.path.exists(self.path) and os.path.isdir(self.path):
            today = str(datetime.date.today())  # 2017-01-02,如果没有强制字符转换，格式为datetime.date(2018, 2, 8)
            yesterday = str(datetime.date.today() + datetime.timedelta(-1))
            before_yesterday = str(datetime.date.today() + datetime.timedelta(-2))
            file_name_list = [today, yesterday, before_yesterday]
            # print(file_name_list)
            for file in os.listdir(self.path):
                file_name_sp = file.split('.')
                if len(file_name_sp) > 2:
                    file_date = file_name_sp[1]  # 取文件名里面的日期
                    if file_date not in file_name_list:#将日志文件中的日期与需保留的日期对比。大批量数据时适用
                        abs_path = os.path.join(self.path, file)
                        print('删除的文件是%s,' % abs_path)
                        os.remove(abs_path)
                    else:
                        print('没有删除的文件是%s' % file)
        else:
            print('路径不存在/不是目录')
if __name__ == '__main__':
    res = Clear_log(r'D:\BaiduNetdiskDownload\logs\logs')
    res.clean_log()

七、监控日志脚本

监控nginx日志的脚本，每分钟运行一次，如果这一分钟内同一个ip请求次数超过200次，加入黑名单

import time
class Log_script():
    def __init__(self):
        self.point = 0
    def  monitor_script(self,file_name):
        while True:
            ips = []
            blacklist_set = set()
            with open(file_name,encoding= 'utf-8') as f:
                f.seek(self.point)
                for line in f:
                    ip = line.split()[0]
                    ips.append(ip)
                    if ips.count(ip) > 200:
                        blacklist_set.add(ip)
                for ip in blacklist_set:#防止重复加入黑名单，集合天生去重
                    print('加入黑名单的 ip 是 %s'%ip)
                self.point = f.tell()  #确定下次扫描时的指针位置
                time.sleep(60)
if __name__ == '__main__':
    res = Log_script()
    res.monitor_script(r'C:xxx\access.log')

八、屏蔽敏感词汇

words = ['傻逼','傻b','煞笔','煞比','sb','傻B','shabi']
class Shield(object):
    def file_operate(self,file1,file2):
        with open(file1, encoding='utf-8') as f, open(file2, 'w', encoding='utf-8') as f2:
            for line in f:
                self.shield(line)
                f2.write(self.string)
    def shield(self,string):
        # self.string = input('input_string:')
        self.string = string
        for i in words:
            self.string = self.string.replace(i,'**')
        print(self.string)
        os.remove('file1') #删文件
        os.rename('file1','file2') #改名

t1 = Shield()
t1.file_operate('file_2.txt','file_2.gy')

九、一个列表中，按字母从小到大排列 ，数字从小到大排列，字母在前数字在后。不用内置方法

list= [1,3,'w','g',4,5,'a','b','e','ghi',4,5,76,'c','e']
str_2 = 'abcdefghigklmnopqrstuvwxyz'
list1 = []
list2 = []
for s in list:
    # print(type(s))
    if type(s) == int:
        list1.append(s)
    elif str(s).lower() in str_2:
        list2.append(s)
print(list1)
print(list2)

def bubble_sort(li):
    for i in range(len(li)-1):
        for j in range(len(li)-i-1):
            if li[j] > li[j+1]:
                li[j],li[j+1] = li[j+1],li[j]
    return li
res1 = bubble_sort(list1)
res2 = bubble_sort(list2)
print(res1)
print(res2)
for i in res1:
    res2.append(i)
print(res2)

十、查找数组中重复数字大于数组长度一半的数

list_1 = [1,2,3,4,5,5,5,5,5]
for i in list_1:
    if list_1.count(i) > len(list_1)/2:
        print(i)
        break
#可得到每个数出现的次数
tmp = {}
for i in list_1:
    tmp[i] = list_1.count(i)
print(tmp)
十一、一个json类型的数据，把每一个元素都放到一个一维的list 中

data = {'userFrom': '2', 'userMobile': '13266667777', 'userPasswd': '111111'}
list = []
for k in data.items():
    for i in k:
        list.append(i)
print(list)
输出结果：['userPasswd', '111111', 'userFrom', '2', 'userMobile', '13266667777']
十二、 取字典中最小键值对

#取最小键值对
a = {'a':'aa','b':"[{'c':'cc'},{'d':'dd'}]",'e':'ee'}
def get_kv(d):
    for k, v in d.items():
        try:
            v = eval(v)  #eval 用法
        except Exception as e:
            pass
        if type(v) == dict:
            get_kv(v)
        elif type(v) == list:
            for y in v:
                if type(y) == dict:
                    get_kv(y)
                else:
                    print('key==>{},v==>{}'.format(k, v))
        else:
            print('key==>{},v==>{}'.format(k, v))

get_kv(a)
输出结果：

key==>a,v==>aa
key==>c,v==>cc
key==>d,v==>dd
key==>e,v==>ee

十三、比较版本号

a = "5.4.5"

f = "4.0.0"

import re

def versionCompare(v1, v2):
    v1_check = re.match("\d+(\.\d+){0,2}", v1)
    v2_check = re.match("\d+(\.\d+){0,2}", v2)
    if v1_check is None or v2_check is None or v1_check.group() != v1 or v2_check.group() != v2:
        return "版本号格式不对，正确的应该是x.x.x,只能有3段"
    v1_list = v1.split(".")
    v2_list = v2.split(".")
    v1_len = len(v1_list)
    v2_len = len(v2_list)
    if v1_len > v2_len:
        for i in range(v1_len - v2_len):
            v2_list.append("0")
    elif v2_len > v1_len:
        for i in range(v2_len - v1_len):
            v1_list.append("0")
    else:
        pass
    for i in range(len(v1_list)):
        if int(v1_list[i]) > int(v2_list[i]):
            return "v1大"
        if int(v1_list[i]) < int(v2_list[i]):
            return "v2大"
    return "相等"
result = versionCompare(a,f)
print(result)

设计思想： 
1.使用正则表达式判断版本号格式是否正确 
2.将字符串用”.”分隔成数组 
3.比较数组长度，将长度短的数组用“0”补齐成相等长度数组 
4.逐个遍历数组元素，比较大小
十四、n 个已经排好序的数组（数组内存放的是int 类型的数字），需要合并成一个数组，并且保证是有序的

a = [1,3,5,6,15]
b = [2,4,6,7,8]
c = []
a.extend(b)
print ("Extended List : ", a )
a.sort()
for i in a:
    if i not in c:
        c.append(i)
print(c)
十五、字符串“welcome to beijing”,期望输出结果“Beijing To Welcome”

s = "welcome to beijing"

new_s = ' '.join([i.capitalize() for i in s.split()[::-1]])
print(new_s)
十六、给一个整数数组，使得他们的和等于一个给定的数 target,你需要实现的函数需要返回这两个值的下标，并且第一个下标小于第二个下标，
注意这里的下标范围是【1，m】,不是以0开始

例如：给出numbers = [2,7,11,15],target = 9,则返回 【1，2】

numbers = [15,1,17,18]
target = 16
target_index = []
for i in numbers:
    if (target - i ) in numbers:
        target_index.append(numbers.index(i)+1)
print(target_index)
输出结果： [1, 2]
十七、有一字符串列表【'aababbc','badabcab'】,通过程序将字符串中的‘ab’移除

s= ['aababbc','badabcab']
new_s = []
for i in s:
    a = ''.join(i.split('ab'))
    new_s.append(a)
print(new_s)
输入结果： ['abc', 'badc']
十八、补充缺失的代码

def print_directory_contents(sPath):
    """
    这个函数接受文件夹的名称作为输入参数，
    返回该文件夹中文件的路径，
    以及其包含文件夹中文件的路径。

    """
    # 补充代码

def print_directory_contents(sPath):
    import os
    for sChild in os.listdir(sPath):
        sChildPath = os.path.join(sPath,sChild)
        if os.path.isdir(sChildPath):
            print_directory_contents(sChildPath)
        else:
            print sChildPath

十九、阅读下面的代码，写出A0，A1至An的最终值。

A0 = dict(zip(('a','b','c','d','e'),(1,2,3,4,5)))
A1 = range(10)
A2 = [i for i in A1 if i in A0]
A3 = [A0[s] for s in A0]
A4 = [i for i in A1 if i in A3]
A5 = {i:i*i for i in A1}
A6 = [[i,i*i] for i in A1]

答案

A0 = {'a': 1, 'c': 3, 'b': 2, 'e': 5, 'd': 4}
A1 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
A2 = []
A3 = [1, 3, 2, 5, 4]
A4 = [1, 2, 3, 4, 5]
A5 = {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}
A6 = [[0, 0], [1, 1], [2, 4], [3, 9], [4, 16], [5, 25], [6, 36], [7, 49], [8, 64], [9, 81]]
二十、删除一个list中重复的元素
list(set(l))
二十一、下面代码会输出什么？

def f(x,l=[]):
    for i in range(x):
        l.append(i*i)
    print (l)
f(2)
f(3,[3,2,1])
f(3)

[0, 1]
[3, 2, 1, 0, 1, 4]
[0, 1, 0, 1, 4]

第一个函数调用十分明显，for循环先后将0和1添加至了空列表l中。l是变量的名字，指向内存中存储的一个列表。

第二个函数调用在一块新的内存中创建了新的列表。l这时指向了新生成的列表。之后再往新列表中添加0、1、2和4。很棒吧。

第三个函数调用的结果就有些奇怪了。它使用了之前内存地址中存储的旧列表。这就是为什么它的前两个元素是0和1了。

二十二、请写一段python代码，替换掉目标字符串中的[北京市，技术，有限，公司]等字符，比如：目标字符串：北京市麦达技术数字有限公司，要求替换输出 麦达数字

str1 = "北京市麦达技术数字有限公司"

str2 = str1.replace("北京市","").replace("技术","").replace("有限","").replace("公司","")

二十三、把字符串“HELLO PYTHON”从大写字母全部转换成小写字母并换行显示，然后输出到计算机c盘的hello.txt文件中保存

str = "HELLO PYTHON"
with open(r'c://hello.txt','a') as f:
    for letter in str:
        letter = letter.lower()
        f.write(letter)
        f.write('\n')
二十四、给定一个值为整数的数组int_array,找出int_array中第二大的整数

说明：如果最大的整数在int_array中出现不止一次，则最大整数为第二大整数。
例：
输入：[1,2,3,4,5]
输出：4
输入：[5,5,4,4,3]
输出：5

def find_num(int_array):
    if int_array.count(max(int_array)) != 1:
        return max(int_array)
    else:
        int_array.remove(max(int_array))
        return max(int_array)

list = [1,3,22,4,7,9,0,22]
max_num = find_num(list)
print(max_num)

二十五、使用python将字符串“1.2.3.4.5”转换为字符串“5|4|3|2|1”

str = "1.2.3.4.5"
li = str.split('.')
li = li[::-1]
new_str = '|'.join(li)
print(new_str)
二十六、设计一个函数，统计一个字符串中出现频率最高的字符及其出现次数

def find_most_freq(string):
    result_dict = {}
    for ch in string:
        if ch in result_dict:
            result_dict[ch] += 1
        else:
            result_dict[ch] =1
    max_key = []
    max_value = 0
    for key,value in result_dict.items():
        if value > max_value:
            max_value = value
            max_key.clear()
            max_key.append(key)
        elif value == max_key:
            max_key.append(key)
    return max_key,max_value
string = 'abcee1233drvfegrhpjpnp3445532'
max_key,max_value = find_most_freq(string)
print('{}出现了{}次'.format(max_key,max_value))
输出结果：['3']出现了4次
二十七、设计一个函数，计算字符串中所有数字序列的和

def sum_num_seq(string):
    sum = 0
    for i in range(len(string)):
        if (string[i]>='0' and string[i]<= '9'):
            sum = sum + int(string[i])
    return sum

string = 'qwed123sfg23456dfg'
sum = sum_num_seq(string)
print(sum)
输出结果：26

 二十八、打印请求报文不一样的key-value

ok_req={
    "version": "9.0.0",
    "is_test": True,
    "store": "",
    "urs": "",
    "device": {
        "os": "android",
        "imei": "99001062198893",
        "device_id": "CQliMWEyYTEzNTYyYzk5MzJmCTJlNmY3Zjkx",
        "mac": "02:00:00:00:00:00",
        "galaxy_tag": "CQliMWEyYTEzNTYyYzk5MzJmCTJlNmY3Zjkx",
        "udid": "a34b1f67dd5797df93fdd8b072f1fb8110fd0db6",
        "network_status": "wifi"
    },
    "adunit": {
        "category": "VIDEO",
        "location": "1",
        "app": "7A16FBB6",
        "blacklist": ""
    },
    "ext_param":{
       "is_start" : 0,
       "vId":"VW0BRMTEV"
    }
}
not_ok={
   "version": "9.0.0",
   "is_test": True,
   "urs": "",
   "store": "",
   "device": {
      "os": "android",
      "imei": "99001062298893",
      "device_id": "CQliMWEyYTEzNTYyYzk5MzJmCTJlNmY3Zjkx",
      "mac": "02:00:00:00:00:00",
      "galaxy_tag": "CQliMWEyYTEzNTYyYzk5MzJmCTJlNmY3Zjkx",
      "udid": "a34b1f67dd5797da93fdd8b072f1fb8110fd0db6",
      "network_status": "wifi"
   },
   "adunit": {
      "category": "VIDEO",
      "location": "1",
      "app": "7A16FBB6",
      "blacklist": ""
   },"ext_param": {
      "is_start": 0,
      "vid": "VW0BRMTEV"
   }
}

def compare(d1,d2):
    for k in d1:
        v1 = d1.get(k)
        # v2 = d2.get(k,'get不到')
        v2 = d2.get(k)
        if type(v1) == dict:
            compare(v1,v2)   # 判断如果value 也是字典的话，递归继续循环
        else:
            # if v1 != v2  and v2 != 'get不到':
            if v1 != v2:
                print('value 不一样的:key 值是%s,v1 是%s,v2是%s'%(k,v1,v2))
    res = set(d1.keys()).symmetric_difference(set(d2.keys()))  #把两个字典的的k取一下对称差集，就说两个里面都不存在的就是两个里面都不存在的key
    if res:
        print('key不一样的：',','.join(res))

compare(ok_req,not_ok)