测试平台笔记

模块- 语法基础与算法分析

1.1:求两数之和

任务详情
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出“和”为目标值的两个整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案，数组中元素不能重复输入。
请根据上面的要求，编写相应的算法，将右边的函数 twoSum() 补充完整。
举例
给定 nums = [2, 7, 11, 15]，target = 9；
nums[0] + nums[1] = 2 + 7 = 9，返回[0, 1]。
任务要求
1. 代码编写必须在右边指定的区域编写；
2. 函数接收两个变量，一个是整数数组 nums：list，另一个是目标值 target: int；
3. 如果存在两种或以上符合目标值 target 的情况，返回下标相加之和较小的数组；

4. 函数返回的值必须为一个数组，list数据类型，元素排序为正序排序，如返回 [1, 3] 符合条件，[3, 1] 不符合条件。
测试用例
用例一
输入：[2，3，2，4], 7
输出：[1, 3]

用例二
输入：[2, 6, 7, 7], 9
输出：[0, 2]

代码

from typing import List
class Solution:
    def twoSum(self, arr:List[int],target:int) -> List[int]:
        k = len(arr)
        for i in range(0,k):
            for j in range(i+1,k):
                if arr[i] + arr[j] == target:
                    return [i,j]
        return []

arr = [2, 6, 7, 7]
target = 9
solu = Solution()
res = solu.twoSum(arr=arr, target=target)
print(res)

1.2:判断数组重复元素

任务详情
编写一个函数 arrayRepeat()，对于任意输入的一个整数数组，如果整数数组中存在重复元素且重复元素均不相邻，函数返回 字符"01"；
如果整数数组每个元素均不相同且偶数元素个数大于奇数元素个数，函数返回字符"02"；
如果整数数组均不满足上述两个条件，函数返回字符 "03"
任务要求
1. 代码编写必须在右边指定的区域编写；
2. 函数接收一个变量 arr，list 数据类型；
3. 函数返回值必须为字符串数据类型。
测试用例 
输入：[1, 2, 6, 4, 6]    输出：'01'；
输入：[2, 3, 8, 5, 6]    输出：'02'；
输入：[2, 2, 5, 3, 5]    输出：'03'；
输入：[0, 0, 0, 0, 0]    输出：'03'。

代码

from typing import List

class Solution:
    def arrayRepeat(self, arr:List[int]) -> str:
        if len(arr) == len(set(arr)): # 无重复
            o,j = 0,0
            for i in arr:
                if i % 2:
                    j += 1
                else:
                    o += 1
            if o > j: return '02'
        else: # 有重复
            # 重复元素均不相邻
            for i in range(len(arr) - 1):
                if arr[i] == arr[i+1]:
                    return '03'
            return '01'
        return '03'

test = [
    [1, 2, 6, 4, 6], # 1
    [2, 3, 8, 5, 6], # 2
    [2, 2, 5, 3, 5], # 3
    [0, 0, 0, 0, 0]  # 3
]
solu = Solution()
res = solu.arrayRepeat(test[3])
print(res)

1.3:简单数学公式

任务详情
编写Python程序计算下列数学表达式的结果并输出，结果向上取整保留整数。
res = √(( 3 ^ 4 + 5 * 6 ^ 5) / num)
程序接收变量 num，返回的是 res。
注明：
* 代表乘。如 2 * 3 代表2乘以3，结果是 6；
^ 代表次方。如2 ^ 3代表2的3次方，结果是 8。
任务要求
1. 程序接收 int 类型的变量 num，返回结果 res 数据类型是 int。
测试用例
输入：30        输出：37
解释：√((3^4+5*6^5)/30)=36.03...，向上取整结果是37。

输入：5          输出：89
解释：√((3^4+5*6^5)/5)=88.27...，向上取整结果是89。

代码

import math
class Solution:
    def function(self, num:int) -> int:
        return math.ceil(math.sqrt(( 3 ** 4 + 5 * 6 ** 5) / num))

solu = Solution()
res = solu.function(5)
print(res)

• 向上取整：math.ceil()
• 向下取整：math.floor()、整除”//“
• 四舍五入：round()——*奇数向远离0取整，偶数去尾取整；或言之：奇数进位，偶数去尾*
• 向0取整：int()

1.4:句子拼写检查(25年原题)

任务详情
给定一段英文句子，判断句中单词拼写是否满足以下规则。
除以下特殊情况外，句子中第一个单词首字母必须大写，其它所有单词小写：
1. 如果句中的某个单词或短语，字母全部为大写，则该单词或短语拼写正确。比如“USA”、“UK”、“JUST  DO  IT”等；
2. “Python”、“Java”、“MachineLearning”、“DataMining”四个单词必须为双引号中给出的形式，否则拼写不正确；
3. 如果句中单词为“数字+字母”的混合形式，比如“5G”，该单词所有字母全部大写。
任务要求
1. 输入英文句子为 str 类型，输出为 bool 类型；
2. 如果句子满足规则要求，程序返回结果为 True；否则返回 False。
测试用例
输入：'I love Python'        输出：True
输入：'python love me'        输出：False
输入： 'JUST DO IT'        输出：True
输入： 'I come from HK'        输出：True
输入： 'Machinelearning is so hot'        输出：False

1.5:重复子字符串

任务详情
给定一个字符串 s，判断它是否由它的子串重复多次构成。如果由子串重复多次构成，输出子串，否则输出整个字符串。
任务要求
给定字符串 s 为 str 类型，输出字符串为 str 类型。
测试用例
输入：'abcabc'
输出：'abc'

输入：'abefd'
输出：'abefd'


输入：''
输出：''

动态规划求解：将字符串A变换为字符串B所用的最少字符操作次数(25年原题)

问题描述：
设A 和B 是2 个字符串。要用最少的字符操作将字符串A 转换为字符串B。
这里所说的字符操作包括
(1)删除一个字符；
(2)插入一个字符；
(3)将一个字符改为另一个字符。
将字符串A变换为字符串B 所用的最少字符操作次数也称为字符串A到B 的编辑距离，记为 D(A,B)。
试设计一个有效算法，对任给的2 个字符串A和B，计算出它们的编辑距离D(A,B)。

模块二 网页处理与文本分析

2.1:选取网页表格中的数字

任务详情
给定一个由表格构成的网页，返回指定位置中的数字，数字类型要转换为 int 类型。
后台给出指定位置，位置由行（row）和列（col）构成，如 row = 2, col = 1, 表示第二行第一列，对应的数字是 249；
程序返回的数字必须是 int 类型，类型不正确将导致结果不正确；
后台给出的所有的位置都在表格中，无需考虑边界情况；
表格的第一行是列名，由 A-Z 构成，共 26 列；第一列是行索引，由 1-30 构成，共 30 行。
任务要求
程序给出 int 类型的参数 row 和 col；
程序返回参数是 int 类型。
测试用例
输入：row=29, col=20
输出：252
解释：表格第 29 行第 20 列中的数字是 252
输入：row=23, col=15
输出：582
解释：表格第 23 行第 15 列中的数字是 252
输入：row=10, col=11
输出：219

http://72.itmc.org.cn:80/JS001/open/show/random-num/index.html

import requests
from bs4 import BeautifulSoup

class Solution:
	def fun(self, row: int, col: int) -> int:
		url = 'http://72.itmc.org.cn:80/JS001/open/show/random-num/index.html'
		responese = requests.get(url=url)
		responese.encoding = 'utf-8'
		bs = BeautifulSoup(responese.text, 'lxml')
		trs = bs.select('body > table > tbody:nth-child(2) > tr')
		res = trs[row-1].select('td')[col].get_text()
		return int(res)
    
solu = Solution()
print(solu.fun(23,15))

2.2:商品信息关键词权重计算

任务详情

根据提供的商品文本信息，对商品的标题内容、属性内容和描述内容进行分词（不包含标题和商品的属性名），完成文本分析工作。
请根据以上要求，将以下所需的函数补充完整。
本任务提供了 jieba 中文分词库和 requests 库。
任务要求
1. 构建函数 wordTfidf()，对商品中关键词，计算其TF-IDF值；
2. 返回文本中 TF-IDF 最大的前5个关键词，返回结果为 list 数据类型；
3. 只保留词性为 n、nr、ns 的关键词；
4. 下方给出的文本编码为UTF-8。
测试用例
输入：任务中商品信息
输出：['裙子', '***', '***', ...]
（此处隐藏剩余四个关键词的数据）

http://72.itmc.org.cn:80/JS001/data/user/15960/61/fj_chiffon_lady_dress.txt

题目分析

对商品中关键词，计算其TF-IDF值；

返回文本中 TF-IDF 最大的前5个关键词，返回结果为 list 数据类型；

只保留词性为 n、nr、ns 的关键词；

# 1. 运行或提交代码不需要自己编写测试用例，后台自动进行测试检查。
# 2. 您编写代码的区域需要限制在Solution类或其他类和函数体内，保证输入与输出符合任务要求即可。
# 3. 点击“提交代码”按钮，系统将查看程序是否正确，并保存代码，记录任务数据。
# 4. 提交代码次数越多，任务得分越低。
# 5. 点击右上方“结束任务”按钮，系统将在后台计算任务得分，任务结束。
# -*- coding: utf-8 -*-
import requests
import jieba
from jieba import analyse


class Solution:

    def wordTfidf(self) -> list:
        url = "http://72.itmc.org.cn:80/JS001/data/user/15930/61/fj_chiffon_lady_dress.txt"
        zt = requests.get(url)
        zt.encoding = "utf-8"
        # 使用jieba的analyse模块的extract_tags函数来提取关键词
        # zt.text是从网页获取到的文本内容
        # topK=5表示只提取最重要的5个关键词
        # allowPOS=("n", "nr", "ns")表示只提取名词、人名、地名这几种词性的关键词
        jg = jieba.analyse.extract_tags(zt.text,topK=5,allowPOS=("n","nr","ns"))
        return jg

2.3:微信公众号排行榜分析(25年原题)

任务详情
下方的网页为微信公共号数据分析展示页，网页数量为1。
请根据网页给出的信息，完成以下任务，将右边的函数 weixinData() 补充完整。
给定原创排行榜里任一微信公众号的名称，请判断该公众号是否满足以下条件：
1.“头条平均阅读”数 > 90000
2.“原创平均阅读”数 > 80000
3.“预估活跃粉丝”数 < 300万
如果满足，函数 weixinData() 返回大写英文单词“YES”，否则返回“NO”。
任务要求
1. 函数接收 str 数据类型的微信公众号名称 name；
2. 函数返回为英文字符“YES”或“NO”，返回参数为 str 数据类型；
3. 不得修改函数 weixinData() 的名称；
4. 题目所需网站链接已经在下方给出，编码方式为UTF-8。
测试用例
输入：“占豪”            输出：“NO”
输入：“Vista看天下” 输出：“YES”

http://72.itmc.org.cn:80/JS001/open/show/weixindata.html

import requests
from bs4 import BeautifulSoup

class Solution:
    def weixinData(self, name:str) -> str:
        data_list = {}
        url:str = 'http://72.itmc.org.cn:80/JS001/open/show/weixindata.html'
        response = requests.get(url=url)
        response.encoding = 'utf-8'
        # print(response)
        soup = BeautifulSoup(response.text, 'lxml')
        table = soup.find_all('table', class_='table')
        trs = table[1].find_all('tr')
        for tr in trs:
            tds = tr.find_all('td')
            wxname = tds[1].select('span > span')[0].get_text()
            # 头条平均阅读 , 原创平均阅读 , 	预估活跃粉丝
            data_list[wxname] = [tds[4].get_text(), tds[7].get_text(), tds[3].get_text()]
        print(data_list)
        if name not in data_list.keys():
            return "NO"
        # 当前名字
        acdata = data_list[name]
        # print(acdata)
        for i in range(len(acdata)):
            if acdata[i][-2:] == '万+':
                acdata[i] = acdata[i].split('万')[0] + '00000'
            elif '.' in acdata[i]:
                acdata[i] = acdata[i].split('.')[0]
            acdata[i] = int(acdata[i])

        # 头条平均阅读 > 9万
        # 原创平均阅读 > 8万
        # 预估活跃粉丝 < 300万
        if (acdata[0] > 900000) and (acdata[1] > 800000) and (acdata[2] < 300):
            return "YES"
        return "NO"

solu = Solution()
res = solu.weixinData('Vista看天下')
print(res)

第二次编写

import requests
from bs4 import BeautifulSoup

class Solution:
	def weixinData(self, name: str) -> str:
		url = 'http://72.itmc.org.cn:80/JS001/open/show/weixindata.html'
		response =  requests.get(url)
		response.encoding = 'utf-8'
		bs = BeautifulSoup(response.text, 'lxml')
		trs = bs.select('#XiGuaDataPage > div.d-main.d-main-w > div.rank-industry > div.wrapper-col-right.wrapper-col-all > table > tbody > tr')
		for tr in trs:
			if tr.find('span', class_='js-rank-detail-btn').get_text() == name:
				# 头条平均阅读
				tt = tr.select_one('td:nth-child(5)').get_text()
				tt = int(tt) if tt[-2] != '万' else int(tt[:-2]) * 10000
				tt = True if tt > 90000 else False

				# 原创平均阅读
				yc = tr.select_one('td:nth-child(8)').get_text()
				yc = int(yc) if yc[-2] != '万' else int(yc[:-2]) * 10000
				yc = True if yc > 80000 else False

				# 预估活跃粉丝
				yg = tr.select_one('td:nth-child(4)').get_text()
				yg = True if int(float(yg[:-1])) < 300 else False

				if tt and yc and yg:
					return "YES"
				else:
					return "No"

		return '未找到'

solu = Solution()
print(solu.weixinData('Vista看天下'))

2.4:爱丽丝梦游仙境文本规范化

任务详情
采用Python自带的函数库进行数据操作，完成任务下方《爱丽丝梦游仙境》英文文本词频的分析。
请将右边的函数  aliceText() 补充完整，使其能够输出某个单词的词频。
任务要求
1. 不得直接使用 Jieba 库对文本进行分词；
2. 函数 aliceText() 接收一个英文单词 word，str 数据类型；返回该单词的词频，int 数据类型；
3. 只保留单词长度大于等于 3 的单词的词频统计；
4. 英文单词不区分大小写；
5. 不同时态和单复数的英文单词为不同英文单词，不需要合并词频统计。如果文本中没有该单词，词频为0；
6. 文本可以使用 requests 库进行读取，UTF-8 编码方式，否则无法正确读取文本。
测试用例
输入：'Pictures'        输出：3
输入：'nothing'        输出：13
输入：'caterpillar'     输出：14
输入：'python'          输出：0

http://72.itmc.org.cn:80/JS001/data/user/15960/76/fj_alice_adventure.txt

题目分析

• 保留单词长度 >= 3
• 不区分大小写

做题思路

• 数据清洗：清除空格、换行、单词长度< 3
• 全部转换为小写
• 使用 count 函数 统计单词出现的次数

代码实现

import requests

class Solution:
    def aliceText(self, word:str) -> int:
        url:str = 'http://72.itmc.org.cn:80/JS001/data/user/15960/76/fj_alice_adventure.txt'
        response = requests.get(url=url)
        response.encoding = "utf-8"
        data = response.text
        data = data.lower()  # 转换为小写
        # 判断字符长度
        st = data
        res = ''
        index = 0
        index_bool = True  # 判断第一次 >= 3
        for i in range(0,len(st)):
            if 'a' <= st[i] <= 'z':
                index += 1
                if index >= 3:
                    if index_bool:
                        res += st[i-2:i+1]
                        index_bool = False
                    else:
                        res += st[i]
            else:
                index = 0
                index_bool = True
                res += ' '
        # 判断出现的次数
        return res.count(word.lower(),0,len(st))

solu = Solution()
res = solu.aliceText('python')
print(res)

# 1. 运行或提交代码不需要自己编写测试用例，后台自动进行测试检查。
# 2. 您编写代码的区域需要限制在Solution类或其他类和函数体内，保证输入与输出符合任务要求即可。
# 3. 点击“提交代码”按钮，系统将查看程序是否正确，并保存代码，记录任务数据。
# 4. 提交代码次数越多，任务得分越低。
# 5. 点击右上方“结束任务”按钮，系统将在后台计算任务得分，任务结束。
# -*- coding: utf-8 -*-
import re

import requests


class Solution:
    def aliceText(self, word: str) -> int:
        response = requests.get('http://72.itmc.org.cn/JS001/data/user/16937/76/fj_alice_adventure.txt')
        response.encoding = 'utf-8'
        text = response.text
        # 使用正则表达式提取单词
        words = re.findall(r'\w+', text.lower())
        # 筛选出长度大于等于3的单词
        filtered_words = [word for word in words if len(word) >= 3]
        
        index = filtered_words.count(word.lower())
        return index

2.5:影片票房任务

任务详情
给定内地某日票房排行榜，输入指定影片名称 movie_name，如：'金刚川'。完成以下任务：
1. 任务一：获取指定影片的上映天数。如“金刚川”上映20天，返回 20；“一日成交”上映首日，返回0，“翱翔雄心”点映，返回 -1；
2. 任务二：获取指定影片的综合票房（万元）。如“金刚川”，返回 432.33；
3. 任务三：获取指定影片的排片占比。如“金刚川”，返回 0.248。
任务要求
1. 程序接收 str 类型的变量 movie_name，返回 list 类型的变量；
2. 返回列表包含参数如下：[任务一：int, 任务二：float，任务三：float]；
3. 任务一中，如果是上映天数是“上映首日”，返回0；如果上映天数是“点映”，返回 -1；
4. 任务三中需要将百分比形式转换为小数点形式。如 '24.8%' 需要转换为 0.248；如果票房 <0.1%，返回 0.001；
5. 票房信息排行榜在下方给出，utf-8编码。
测试用例
输入：'金刚川'
输出：[20, 431.33, 0.248]

输入：'半条棉被'
输出：[69, 2.54, 0.001]

http://72.itmc.org.cn:80/JS001/open/show/box_office_on_a_certain_day.html

题目分析

• 通过 电影名称
• 获取上映时间
  • 如果是上映天数是“上映首日”，返回0；如果上映天数是“点映”，返回 -1；
• 获取 综合票房（万元
  • “金刚川”，返回 432.33；
• 获取 排片占比
  • ‘24.8%’ 需要转换为 0.248；如果票房 <0.1%，返回 0.001；
  • 先判断文字 <0.1%
  • 数字处理 float(s[:-1]) / 100
• 接受 movie_name: str
• 返回
  • [任务一：int, 任务二：float，任务三：float]；

做题思路

先把所以数据获取过来

找到 电影名称 对应的 行数

找到后 单独对 各个任务 进行处理

存储到一个list 里面 最后返回

代码实现

import requests
from bs4 import BeautifulSoup

class Solution:
    def BoxOfficeSpider(self, movie_name:str) -> list:
        url = 'http://72.itmc.org.cn:80/JS001/open/show/box_office_on_a_certain_day.html'
        response = requests.get(url=url)
        response.encoding = 'uft-8'
        soup = BeautifulSoup(response.text, 'lxml')
        trs = soup.select('#app > div > div.home-content > div > div.box-table > table > tbody > tr')
        # print(trs)
        res = []

        for i in trs:
            # 找电影名字
            if movie_name == i.find('p', class_='movie-name').get_text():
                # 任务一: 上映时间
                rwone = i.find('span', class_='releaseInfo').get_text()
                if rwone == '上映首日':
                    res[0] = 0
                elif rwone == '点映':
                    res[0] = -1
                else:  # 把数字提取出来
                    numlist = [char for char in rwone if char.isdigit()]
                    resnum = ''.join(numlist)
                    res.append(int(resnum))
                
                # 任务二: 综合票房（万元
                res.append(float(i.find('div', class_='boxDesc-wrap').get_text()))

                # 任务三: 排片占比  24.8%' 需要转换为 0.248
                s = i.select_one('td:nth-child(4) > div').get_text()
                if s == '<0.1%':
                    res.append(0.001)
                else:
                    float_value = float(s[:-1]) / 100
                    res.append(float_value)
                return res
        return res

solu = Solution()
res = solu.BoxOfficeSpider("半条棉被")
print(res)

import requests
from bs4 import BeautifulSoup

class Solution:
	def BoxOfficeSpider(self, movie_name:str) -> list:
		res = [] # [任务一：int, 任务二：float，任务三：float]
		response = requests.get('http://72.itmc.org.cn/JS001/open/show/box_office_on_a_certain_day.html')
		response.encoding = 'utf-8'
		bs = BeautifulSoup(response.text, 'lxml')
		trs = bs.select('#app > div > div.home-content > div > div.box-table > table > tbody > tr')
		for tr in trs:
			# 通过电影名找打该电影
			if tr.find('p', class_='movie-name').get_text() == movie_name:
				# 任务一: 上映天数
				syts = tr.find('span', class_='releaseInfo').get_text()
				if syts == '上映首日':
					syts = 0
				elif syts == '点映':
					syts = -1
				else:
					syts = int(syts[2:-1])
				
				# 任务二: 综合票房
				zhpf = tr.find('div', class_='boxDesc-wrap').get_text()
				zhpf = round(float(zhpf), 2)
				
				# 任务三: 排片占比
				pmzb = tr.find('div', class_='countRate-wrap').get_text()
				if pmzb == '<0.1%':
					pmzb = 0.001
				else:
					pmzb = float(pmzb[:-1]) / 100

				res.append(syts)
				res.append(zhpf)
				res.append(pmzb)
				return res

solu = Solution()
print(solu.BoxOfficeSpider('半条棉被'))

2.6:商品搜系结果分析

任务详情
根据任务详情下方提供的网页（数量为1），完成商品搜索结果分析。
请将右侧的函数 itemSearch() 补充完整，使其能完成以下功能：
对于网页中出现的任一网店名称 ，函数返回以下信息，请将以上获取的信息保存在数组中，按顺序返回。
任务要求
该网店对应商品，是否参与满减促销（非满件促销），返回值为 True 或 False；
该网店对应商品的价格，是否存在会员价，如果存在，则返回会员价，返回类型为 float（保留1位小数），如果不存在，返回原始价格；
该网店对应商品的评论数，返回类型为 int；
如果该网店存在两个及以上商品，返回价格较高的商品信息；如果商品价格相同，返回搜索结果最靠前的商品信息；
链接地址在下方专题地址中给出，点击链接可以直接获取。

测试用例
输入："花花公子官方旗舰店"    输出：[False, 139.0, 4400]
解释：该网店价格最高的商品未参加满减促销活动，对应价格为139.0，商品评论数为4400

输入："陌芙丝欧旗舰店"           输出：[True, 139.0, 12000]
解释：该网店价格最高的商品参加满减促销活动，对应价格为139.0，商品评论数为12000

输入："合众服饰专营店"           输出：[True,118.0,10000]
解释：该网店价格最高的商品参加满减促销活动，对应价格为118.0，商品评论数为10000
说明
1. 会员价格是商品价格右边小字出现的价格信息；
2. 评论数为“1万+”就代表评论数为“10000”；
3. 函数接收“网店名称”这一变量，返回类型为数组；
4. 不得修改函数的名称；
5.“满减促销”和“满件促销”是不一样的概念；
6. 网页中存在相同店铺名称的商品，请注意甄别。

http://72.itmc.org.cn:80/JS001/open/show/ecjd.html

题目分析

接受： 网店名称

• 满减促销 bool
• 是否存在会员价，如果存在，则返回会员价 float (保留1位小数)
• 评论数 int
• 如果该网店存在两个及以上商品，返回价格较高的商品信息；如果商品价格相同，返回搜索结果最靠前的商品信息；

做题思路

先判断网店 >= 2 , 如果大于等于二 进行 判断价格 选择价格较为高的 , 如果价格相同选择第一个 √

对筛选出来的数据, 进行判断 三个任务

三个任务

• 满减促销 是否参与满减促销（非满件促销） True
• 是否存在会员价，如果存在，则返回会员价 float (保留1位小数)
• 评论数 int

参数

• 接受 店铺名称
• 返回 list

代码实现

import requests
from bs4 import BeautifulSoup

class Solution:
    def itemSearch(self,name:str) -> list:
        url = 'http://72.itmc.org.cn:80/JS001/open/show/ecjd.html'
        response = requests.get(url)
        response.encoding = "utf-8"
        soup = BeautifulSoup(response.text, 'html.parser')
        lis = soup.select('#J_goodsList > ul > li')
        res = []
        li = None
        li_bool = True
        for i in lis:
            if name == i.find('span', class_='J_im_icon').get_text():
                if li_bool:  # 把第一个li 赋值过去
                    li = i
                    li_bool = False
                # 价格 
                jg = li.select_one('div.p-price i').get_text()
                # 当 后面的价格贵的时候 进行替换
                if float(jg) < float(i.select_one('div.p-price i').get_text()):
                    li = i
        # 是否参与 满减活动
        if li.find('i',{'data-tips': '本商品参与满减促销'}):
            res.append(True)
        else:
            res.append(False)
        
        # 价格标签
        price = li.find('div', class_='p-price')
        # 判断 是否存在 会员价格
        if price.find('span',{'title': "PLUS会员专享价"}):
            res.append(float(price.find('span',{'title': "PLUS会员专享价"}).get_text()[1:]))
        else: # 如果不存在会员价格
            res.append(float(price.find('i').get_text()))

        # 评论数  int
        pl = li.select_one('div.p-commit a').get_text()[:-1]  # 去掉最后一个加号
        # 判断最后面是不是 万
        if pl[-1] == '万':
            pl = float(pl[:-1]) * 10000
        
        res.append(int(pl))
        return res

solu = Solution()
res = solu.itemSearch('花花公子官方旗舰店')
print(res)

'''
先判断网店 >= 2 , 如果大于等于二 进行 判断价格 选择价格较为高的 , 如果价格相同选择第一个  √
对筛选出来的数据, 进行判断 三个任务

三个任务
- 满减促销  是否参与满减促销（非满件促销）  True
- 是否存在会员价，如果存在，则返回会员价 float (保留1位小数)
- 评论数  int

参数

- 接受 店铺名称
- 返回 list

'''
from typing import List
import requests
from bs4 import BeautifulSoup
class Solution:
	def search(self, name: str) -> list:
		url:str = 'http://72.itmc.org.cn:80/JS001/open/show/ecjd.html'
		response = requests.get(url=url)
		response.encoding = 'utf-8'
		bs = BeautifulSoup(response.text, 'lxml')
		res = []
		lis = bs.select('#J_goodsList > ul > li') # 拿到所有的商品
		lis_name = []
		max_num = []
		for li in lis:
			# 如果不是空，就是找对了
			if li.find('a', {'title': name}):
				# 价格
				lis_name.append(li)

		for i in lis_name:
			perice = i.select_one('div > div.p-price > strong > i').get_text()
			max_num.append(perice)

		# print(max(max_num))
		# val = max[0]
		# key = 0  没做 先判断网店 >= 2 ,
		
		# for i in range(1,len(max_num)):
		# 	if val > max_num:
				
			

		i = lis_name[0]
		if i.find('i', {'data-tips': '本商品参与满减促销'}):
			res.append(True)
		else:
			res.append(False)

		if i.find('span', {'title': 'PLUS会员专享价'}):
			puls_perice = i.find('span', {'title': 'PLUS会员专享价'}).get_text()[1:]
			puls_perice = round(float(puls_perice),1) # 保留一位小数
			res.append(puls_perice)
		else:
			perice = i.select_one('div.p-price > strong > i').get_text()
			perice = round(float(perice), 1)
			res.append(perice)
		
		commit = i.select_one('div.p-commit a').get_text()
		commit = int(float(commit[:-2]) * 10000) if commit[-2] == '万' else commit[:-1]
		res.append(commit)



		return res


 

solu  = Solution()
res = solu.search('陌芙丝欧旗舰店')
print(res)

2.7:商品关键词权重分析

任务详情
请使用 杭州大牌女装.txt 文本完成提取文本中权重最高的 5 个关键词的任务。
任务要求
1. 程序以数组的形式返回五个关键词，关键词类型是 str；
2. 使用结巴库内置的TextRank 算法抽取关键词，只返回关键词，不必返回权重。关键词的词性必须是名词和动词；
3. 返回的5个关键词至少要有4个关键词与系统内置的答案一致；
4. 返回关键词不需要考虑顺序；

5. 杭州大牌女装.txt使用 requests 库读取，UTF-8编码，链接在下方给出；
6. Jieba库词性表及说明.xlsx 也在下方给出，作为参考。

测试用例
输入：无
输出：['印花' ，'关键词2'，'关键词3'，'关键词4'，'关键词5']

http://72.itmc.org.cn:80/JS001/data/user/15960/77/fj_Jieba词性表及说明.xlsx
http://72.itmc.org.cn:80/JS001/data/user/15960/77/fj_5392_hangzhou_top_woman_wear.txt

模块三 数据处理与分析

3.1:电商订单数据清洗

 任务详情 
请根据系统提供的订单数据表，按要求完成以下任务：
统计订单表格中，商品描述(choice_description)中为“NaN”的数量，并将其批量替换为“banana”，
请根据以上要求，将函数 nanCount() 补充完整，函数的返回值为整数值，既为“NaN”的数量。
任务要求
1. 订单数据表为以逗号为分隔符的csv文件，编码方式为 UTF-8；
2. 注意：DataFrame 由后台生成，作为参数 order_data 传递到 nonCount() 中，不需要生成新的 DataFrame；
3. DataFrame 读取为订单数据表；
3. 返回值为 NaN 的数量，int 数据类型。


订单数据访问地址请见下方：

http://72.itmc.org.cn:80/JS001/data/user/15960/63/fj_order_data.csv

3.2:电商订单数据计算

任务详情
请根据系统提供的订单数据表，按要求完成以下三个任务：
传入一个字符串，返回订单总金额 (quantity * item_price) 最大或最小的商品，并返回商品的名称(item_name)。
请根据以上要求，将函数 salesStr() 补充完整，函数的返回值为字符(str)，比如："Steak Burrito"
订单数据访问地址请见下方：
字段名中文含义
order_id 商品编号 
quantity 数量 
item_name 商品名称 
choice_description 描述 
item_price 单价 
任务要求
1. 传入一个字符串('max' 或 'min')，返回订单总金额最大或最小的商品的名称(item_name) ；

2. 传入的字符串不区分大小写，即传入值可能是"Max"，也可能是"max"；
3. 传入"max"，返回订单总金额 (quantity * item_price) 最大的商品名称；传入“min”，返回订单总金额 (quantity * item_price) 最小的商品名称；
4. 返回字符串区分大小写，且保留字符串中间空格。

http://72.itmc.org.cn:80/JS001/data/user/15960/80/fj_order_data.csv

3.3:DataFrame计算平均值

任务详情
给定一个DataFrame对象 df，要求返回各行的平均值。
具体操作如下：
添加新列 'avg' 用于计算各行的平均值；
使用数组返回新列 'avg'。
任务要求
程序接收 DataFrame 对象 df，返回结果是 list 数据类型；
注意：平均值需要四舍五入保留两位小数。
测试用例
输入：

0123456
024 27 7 23 25 7 21 
116 30 8 4 26 30 8 
218 28 7 17 17 16 25 
输出：
[19.14, 17.43, 18.29]
解释：首先生成新列'avg'，需要注意平均数需要四舍五入保留小数点后两位

0123456avg
024 27 7 23 25 7 21 19.14 
116 30 8 4 26 30 8 17.43 
218 28 7 17 17 16 25 18.29 

输入：

0123
010 19 4 7 
19 5 28 14 
230 27 1 13 
321 14 19 9 
41 25 30 16 

输出：[10.0, 14.0, 17.75, 15.75, 18.0]

解释：首先生成新列'avg'，其次返回'avg'列

0123avg
010 19 4 7 10.00 
19 5 28 14 14.00 
230 27 1 13 17.75 
321 14 19 9 15.75 
41 25 30 16 18.00 

3.4:乐高商店收入计算

题目描述
我们需要完成乐高商店的分析，请你根据指引完成以下任务：
使用 Pandas 读取数据；
去掉没有价格的数据，将销量为空的数据填充为0；
计算所有产品总收入；
计算该数据中产品价格的平均值;
程序后台传入产品标题title，要求计算该产品的收入（收入总计）；
将总收入、平均价格、产品收入保存到列表里，返回给后台。
题目要求
程序传入标题title数据类型是str；
程序传出数据类型是列表类型，列表中所有元素的数据类型均是 float；
如果产品标题title存在多个，则计算相同title商品的总收入；
平均价格需要四舍五入保留小数点后2位。
测试用例
输入：’乐高旗舰店官网大电影系列70837Shimmer&Shine闪亮水疗馆玩具积木’
输出；[xxx, xxx, 1598.0]
解释：总收入和平均价格隐藏，当前产品收入总计是1598.0
输入：’乐高旗舰店幻影忍者系列70668雷电忍者杰的暴风战机’
输出：[xxx, xxx, 259073.0]
解释：总收入和平均价格隐藏，当前产品收入总计是259073.0
输入：’乐高旗舰店官网创意百变高手系列10261大型过山车积木成人送礼’
输出：[xxx, xxx, 41986.0]
数据说明
文本数据是excel文件，字段含义如下：
字段含义实例
title 商品名 乐高旗舰店官网 LEGO积木 儿童玩具男孩 积木拼装玩具益智 
age_range 商品对应的年龄等级 适用年纪6+岁 
price 商品价格 899.0 
sales_num 售卖数量 217.0 

http://72.itmc.org.cn:80/JS001/data/user/15960/241/fj_lego_tmallshop_sales_data.xlsx

3.5:部门平均薪资汇总计算

任务说明
        读取给定的职工薪酬考勤簿，职工薪酬考勤簿由两个表格组成，分别是 基本薪资 工作表和 上班通勤 工作表。要求计算每一个部门内部的平均薪资，并把结果 降序 排列，返回给判定程序。
        员工个人薪酬计算过程如下：
        1.薪资由两部分组成， 月基本薪资 和 通勤工资，另外需要扣除需要缴纳的 社保费及公积金；
        2.月基本薪资 = 基本薪资 + 岗位工资 + 绩效工资；
        3.通勤工资中计算如下：
            日薪 = (基本薪资 + 岗位工资 + 绩效工资) / 应出勤天数
            时薪 = 日薪 / 8
        4.通勤工资中，法定节假日加班薪资是工作日加班的 2 倍，周末加班工资是工作日加班的 1.5 倍，工作日加班工资与时薪 相同；
        5.通勤工资需要扣除因请假导致的缺勤，请假/小时需要扣除的工资按照时薪计算。
        6.社保费及公积金个人缴费按照社会保险缴费基数计算：
            a.养老保险个人缴费比例是 8%
            b.医疗保险个人缴费比例是 2%
            c.失业保险个人缴费比例是 1%
            d.公积金缴费比例是 10%
       
        示例：
        小王基本薪资 2000，岗位工资 2000，社会保险缴费基数是 2000。绩效工资 0，应出勤天数 20 天，请假 1 天，工作日加班 8 小时，法定节假日加班 4 小时，周末加班 4 小时。
        小王基本薪资+岗位工资+绩效工资是：2000 + 2000 = 4000；
        小王时薪：4000 / 20 / 8 = 25；
        小王加班工资：25 * 8 + 25 * 4 * 1.5 + 25 * 4 * 2 = 550；
        小王请假扣除：25 * 8 = 200；
        小王五险一金扣除：2000 * 0.08 + 2000 * 0.02 + 2000 * 0.01 + 2000 * 0.1 = 420；
        小王本月实发工资：4000 + 550 - 200 - 420 = 3930。
        假设小王所在部门有 5 个人，5 个人工资分别是 4050，4010，4120，4000，4500。小王所在部门的平均工资是：(3930+ 4010 + 4120 + 4000 + 4500) /5 = 4112。同理可算出其他部门的平均工资。

        注意：返回结果需四舍五入保留小数点后两位！  
        返回结果参数类型是 pd.Series。Series 的索引应为部门名，Series 的数据应为部门平均工资，Series 的 Name 属性应修改为 “平均薪资”。
任务要求
程序无需接收参数输入，需要返回结果参数的格式是 pd.Series；
返回结果时需要四舍五入保留小数点后两位，计算过程内保留小数点后两位可能导致最后结果不正确；
部门平均工资需要降序排列；
本题所需的基本薪资表和上班通勤表均在职工薪酬工作簿中，按需读取。
Series 数据的类型应为 float 64，Name 属性应为 “平均薪资”。
index 的属性名应为部门。
测试用例
部分返回数据：
部门  
销售部       15767.86
运营部       ****
工程部       ****  
财务部       ****  
研发部       ****  
市场部       ****  
人力资源部    4233.27  
Name: 平均薪资, dtype: float64附件信息
职工薪酬簿.xlsx，职工薪酬工作簿由 基本薪资 工作表和 上班通勤 工作表组成。
基本薪资工作表。基本薪资工作表包含个人所属部门，各部分薪资状况和社会保险缴纳基数。共 7 个部门共 50 条数据，其中只有销售部有绩效工资。
上班通勤工作表。上班通勤工作表包含本月应出勤天数，实际出勤天数。请假加班天数等。工作表中的名字与基本薪资工作表中的名字一一对应。共 50 条数据。


http://72.itmc.org.cn:80/JS001/data/user/15960/242/fj_employee_salary_work_books.xlsx

3.6:编制比较资产负债表

任务描述

“A企业资产负债表.xlsx”文件的“比较资产负债表”包含 A 企业 2020 年和 2021 年的资产负债数据，请完成以下指定任务。
使用 0 填充表格中的空值；
计算 2021 年各项目变动额和变动率并添加相关数据列；
程序接受某项目的项目名称 name，要求输出该项目对应的变动额和变动率。
任务要求

代码要编辑在 balance_sheet 函数下；
变动额需要四舍五入保留小数点后 2 位，变动率需要四舍五入保留小数点后 4 位；
变动额和变动率的数据类型都是浮点数数据类型；
程序只判定 return后的结果值，输出（print）后的结果值不作为判断依据；
程序返回结果的数据类型为列表。

测试用例

输入：name="负债总计"
输出：[26928392.51, 0.2567]
解释：负债总计变动额是 26928392.51，变动率是 0.2567

输入：name="无形资产"
输出：[-600000.0, -0.0667]
解释：无形资产变动额是 -600000.0，变动率是 -0.0667

输入：name="负债合计"
输出：[26928392.51, 0.2567]

代码提示

我们通过将 Series 转换为列表的形式，将其中的数字提取出来。

通过如下案例，我们取出 DataFrame 中的 1。
In [1]: import pandas as pd

# 定义一个 DataFrame
In [2]: df = pd.DataFrame([[1, 2], [3, 4]], columns=['A', 'B'])

# 预览下 df
In [3]: df
Out[3]:
   A  B
0  1  2
1  3  4

# 通过列名取出 A 列
In [4]: df['A']
Out[4]:
0    1
1    3
Name: A, dtype: int64

# 取出 A 列再将 A 列转换为列表
In [5]: df['A'].tolist()
Out[5]: [1, 3]

# 取出列表中的第一个元素，就是我们想要的 1
In [6]: df['A'].tolist()[0]
Out[6]: 1

http://72.itmc.org.cn:80/JS001/data/user/15960/243/fj_Interprice_balance_data.xlsx

3.7:某店铺不同地区销售情况分析福香

题目描述
下方是某店铺在 2 月份的订单数据，共 28010 行、7 列。 在该数据中，每一行代表一笔订单，每一笔订单可以 看做是一位顾客（买家），价格相同的产品可视为同一产品；
请编写程序，完成以下任务：
程序传入参数 area（收货地址），要求计算该地区订单的’订单的付款转化率’、’买家全额支付的转化率’、’买家实际支付总金额’、’客单价’、’销量（订单量）最多的产品的价格’、’买家实际支付总金额在所有地区实际支付总金额中的占比’，并将结果以列表形式返回。
题目要求
程序接收 str 类型的 area，返回的结果为 list 数据类型；
返回的结果中，列表中各个数据的数据类型为 str，其中转化率数据及占比数据需以百分比的形式输出，并且需要保留小数点后2位，如’13.14%’，其余结果不需要以百分比形式输出，但需要保留小数点后2位；
如果某地区所有买家的买家实际支付金额为 0，即该地区没有付费行为。则该地区的’客单价’、’销量（订单量）最多的产品的价格’需返回字符串’本地区无销量’，其他结果则正常计算；
如果该产品（订单）被全额退款，那么该产品不计入销量。
参考公式
付款转化率 = 付款订单数 / 总订单数；
买家全额支付的转化率 = 买家全额支付的订单数 / 总订单数；
客单价 = 实际支付金额 / 支付买家数；
测试用例
输入：area = ‘河南省’
输出：[‘81.99%’, ‘61.18%’, ‘56354.03’, ‘92.84’, ‘37.00’, ‘2.96%’]
解释：河南省’订单的付款转化率’为’81.99%’，’买家全额支付的转化率’为’61.18%’，’买家实际支付总金额’为’56354.03’，’客单价’为’92.84’，’销量（订单量）最多的产品的价格’为’37.00’，’买家实际支付总金额在所有地区实际支付总金额中的占比’为’2.96%’

输入：area = ‘江苏省’
输出：[‘86.78%’, ‘66.75%’, ‘159359.18’, ‘109.22’, ‘37.00’, ‘8.38%’]

http://72.itmc.org.cn:80/JS001/data/user/15960/240/fj_7568_tmall_order_report.csv

3.8:用户职位信息统计

任务详情
请根据任务下方提供的用户职位统计信息表，完成以下任务：
职位表中每个字段含义如下：
字段说明

user_id 用户序号 
 
age 用户年龄 
 
gender 用户性别 
 
occupation 用户职位 
 
zip_code 用户邮编 
 
编写一个职位统计函数 jobStatistics()，给定表格里的任一职位，统计其以下信息
1. 任务一：统计该职位女性用户的百分占比（结果保留两位小数），输出数据类型为 str；
2. 任务二：统计该职位女性用户百分占比在所有职位女性用户百分占比中的排名（降序），输出数据类型为 int。
将以上2个结果保存在 数组(list) 中，按顺序返回。
任务要求
1. 程序接收一个 str 类型的变量 op，返回一个 list 类型的变量；
2. "gender" 列中，"F" 代表女性，"M" 代表男性；
3. 返回结果格式如下：[任务一: str, 任务二: int]。
测试用例
输入：'artist'
输出：[ '46.43%', 4]
解释：该职位中女性用户占据该职位所有用户的46.43%，该职位女性占比排名在所有职位女性占比排名中位列第 4

输入：'student'
输出：['30.61%', 10]
解释：该职位中女性用户占据该职位所有用户的30.61%，该职位女性占比排名在所有职位女性占比排名中位列第 10

http://72.itmc.org.cn:80/JS001/data/user/15960/67/fj_jobstatics.xlsx

3.9:某知名网站高质量视频主挖掘

任务详情
根据下方提供的某知名网站视频信息数据，构造一个打分模型，并根据分值挖掘高质量视频主，要求输入视频主的名字author，返回对应的UP主分层。

IFL模型
针对视频主的视频信息构建了IFL模型，以评估视频的质量。

I (Interaction_rate)
I 值反映的是平均每个视频的互动率，互动率越高，表明其视频更能产生用户的共鸣，使其有话题感。
I = (总弹幕数 + 总评论数) / (总播放量 * 统计范围内视频数量) * 100。

F (Frequence)
F 值表示的是每个视频的平均发布周期，每个视频之间的发布周期越短，说明内容生产者创作视频的时间也就越短，创作时间太长，不是忠实粉丝的用户可能将其遗忘。
F = (统计范围内最晚发布视频时间 - 最早发布视频时间) / 发布视频的数量。
如果 F 的值为 0，表示该视频主仅发布一条视频。那么将 F 的值重新赋值为 F 的最大值 + 1，如原有数据中，F 的最大值是 100，那么就将 F 的最大值设置为 100 + 1 = 101。

L (Like_rate)
L值表示的是统计时间内发布视频的平均点赞率，越大表示视频质量越稳定，用户对up主的认可度也就越高。
L = (点赞数 * 1 + 投币数 * 2 + 收藏数 * 3 + 分享数 * 4) / (播放量 * 发布视频数) * 100。

维度打分
维度确认的核心是分值确定，按照设定的标准，我们给每个视频主的 I/F/L 值打分，分值的大小取决于我们的偏好，
即我们越喜欢的行为，打的分数就越高 ：
- I 值。表示 up 主视频的平均评论率，这个值越大，就说明其视频越能使用户有话题，当I值越大时，分值越大。
- F 值。表示视频的平均发布周期，我们当然想要经常看到，所以这个值越大时，分值越小。
- L 值。表示发布视频的平均点赞率，S 值越大时，质量越稳定，分值也就越大。

视频主主分层 我们根据每一项指标是否高于平均值，把UP主划分为8类，我们根据案例中的情况进行划分，具体如下表

视频主分类I值是否大于平均值F值是否小于平均值L值是否大于平均值解释
高质量视频主 1 1 1 用户活跃高，更新周期短，视频质量高 
高质量拖更视频主 1 0 1 用户活跃高，更新周期长，视频质量高 
高质量内容高深视频主 0 1 1 用户活跃低，更新周期短，视频质量高 
高质量内容高深拖更视频主 0 0 1 用户活跃低，更新周期长，视频质量高 
接地气活跃视频主 1 1 0 用户活跃高，更新周期短，视频质量低 
活跃视频主 0 1 0 用户活跃低，更新周期短，视频质量低 
接地气视频主 1 0 0 用户活跃高，更新周期长，视频质量低 
还在成长的视频主 0 0 0 用户活跃低，更新周期长，视频质量低 


数据链接已经在下方给出： 各字段表示含义如下：
字段名含义
pubdate 发布时间 
bv BV号 
url 视频链接 
title 标题 
author 作者 
description 视频简介 
tag 标签 
favorites 收藏 
coins 投币 
danmu 弹幕 
likes 点赞 
reply 评论 
views 播放量 
share 分享
 
任务要求
1. 程序接收 str 类型的变量 author，返回结果的数据类型是str类型；
2. 便于数据美观，IFL 的值需要保留小数点后两位（四舍五入）；
3. 数据中可能存在重复数据；
4. 某知名视频网站视频数据为逗号分割的 csv 文件，utf-8 编码。
测试用例
输入：'龙爪洪荒'
输出：'高质量拖更视频主'

输入：'AO摆渡人'
输出：'活跃视频主'

http://72.itmc.org.cn:80/JS001/data/user/15960/94/fj_B_video_web_data.csv

答案:

# 1.1：求两数之和
class Solution:

    def twoSum(self, nums: list, target: int) -> list:
        zt = []
        qc = False
        for i in nums:
            if qc == True:
                break
            for z in nums:
                if int(i) + int(z) == target:
                    qc = True
                    zt.append(nums.index(i))
                    zt.append(nums.index(z,nums.index(i)+1))
                    break
        return zt

# 1.2：判断数组重复元素
class Solution:
    def arrayRepeat(self, arr: list) -> str:
        if len(arr) != len(set(arr)):
            for i in range(len(arr)):
                if i != 0:
                    if arr[i] != arr[i - 1]:
                        pass
                    else:
                        return "03"
            return "01"
        else:
            num = 0
            zt = 0
            for i in arr:
                if i % 2 == 0:
                    num += 1
                else:
                    zt += 1
            if num > zt:
                return "02"
            else:
                return "03"

# 1.3：简单数学公式
import math

class Solution:

    def SpMtFml(self, num: int) -> int:
	    return math.ceil(math.sqrt((3**4+5*6**5)/num))

# 1.4：句子拼写检查
class Solution:
    def detectCapital(self, st: str) -> bool:
        list1 = st.split(" ")
        t=0
        ww=0
        for i in list1:
            t=t+1
            if i.upper() in ['PYTHON', 'JAVA', 'MACHINELEARNING', 'DATAMINING']:
                if i not in ["Python", "Java", "MachineLearning", "DataMining"]:
                    return False
                else:
                    continue
            if any(char.isdigit() for char in i):
                if i.upper() != i:
                    return False
            elif t == 1:
                if i.capitalize() != i:
                    return False
            elif i.lower() != i and i.upper() != i:
                return False
        return True


# 1.5：重复子字符串 100.0分

class Solution:

    def patternRepeatedSubstring(self, s: str) -> str:
        ss = ""
        for i in s:
            ss += i
            if s.count(ss) == len(s) / len(ss):
                return ss
        return s



# 2.1：选取网页表格中的数字
import requests
from bs4 import BeautifulSoup


class Solution:

    def table_num(self, row: int, col: int) -> int:
        url = "http://72.itmc.org.cn:80/JS001/open/show/random-num/index.html"
        zt = requests.get(url)
        zt.encoding= "utf-8"
        qc = BeautifulSoup(zt.text,"html.parser")
        jg = qc.find_all("td")[(row-1)*26+row-1+col].text
        return int(jg)

# 2.2：商品信息关键词权重计算
import requests
import jieba
from jieba import analyse


class Solution:

    def wordTfidf(self) -> list:
        url = "http://72.itmc.org.cn:80/JS001/data/user/15930/61/fj_chiffon_lady_dress.txt"
        zt = requests.get(url)
        zt.encoding = "utf-8"
        # 使用jieba的analyse模块的extract_tags函数来提取关键词
        # zt.text是从网页获取到的文本内容
        # topK=5表示只提取最重要的5个关键词
        # allowPOS=("n", "nr", "ns")表示只提取名词、人名、地名这几种词性的关键词
        jg = jieba.analyse.extract_tags(zt.text,topK=5,allowPOS=("n","nr","ns"))
        return jg


# 2.3：微信公众号排行榜分析
import re

import requests
from bs4 import BeautifulSoup


class Solution:
    def weixinData(self, name: str) -> str:
        url = 'http://72.itmc.org.cn:80/JS001/open/show/weixindata.html'
        zt = requests.get(url)
        zt.encoding = "utf-8"
        qc = BeautifulSoup(zt.text,"html.parser")
        for i in range(100):
            try:
                txt = qc.find_all("span",class_="js-rank-detail-btn")[i].text
                txt1 = qc.find_all("td")[i*11+4+i].text
                txt2 = qc.find_all("td")[i*11+7+i].text
                txt3 = qc.find_all("td")[i*11+3+i].text
                if txt == name :
                    if "万" in txt1 or float(txt1) > 90000:
                        if "万" in txt2 or float(txt2) >80000:
                            if float(txt3[0:-1]) < 300:
                                return "YES"
                            else:
                                return "NO"
                        else:
                            return "NO"
                    else:
                          return "NO"
            except:
                break




# 2.4：爱丽丝梦游仙境文本规范化

import re

import requests


class Solution:
    def aliceText(self, word: str) -> int:
        url = "http://72.itmc.org.cn:80/JS001/data/user/15930/76/fj_alice_adventure.txt"
        zt = requests.get(url)
        zt.encoding="utf-8"
        if len(word) < 3 :
            return 0
        qc = re.findall(word,zt.text,re.I)
        return len(qc)



# 2.5：影片票房任务
import re

from bs4 import BeautifulSoup
import requests


class Solution:
    def BoxOfficeSpider(self, movie_name: str) -> list:
	    url = "http://72.itmc.org.cn:80/JS001/open/show/box_office_on_a_certain_day.html"
	    zt = requests.get(url)
	    zt.encoding="utf-8"
	    qc = BeautifulSoup(zt.text,"html.parser")
	    name = qc.find_all("p",class_="movie-name")
	    txt1 = qc.find_all("span",class_="releaseInfo")
	    txt2 = qc.find_all("div",class_="boxDesc-wrap red-color")
	    txt3 = qc.find_all("div",class_="countRate-wrap")
	    key = {}
	    val = [[i for i in range(3)]for j in range(len(name))]
	    for i in range(len(txt1)):
	        for j in range(1):
	            if (re.findall(r"\d+",txt1[i].text)):
	                val[i][j] = int(re.findall(r"\d+",txt1[i].text)[0])
	            elif ("点映" in  txt1[i].text):
	                val[i][j] = -1
	            else:
	                val[i][j] = 0
	            val[i][j+1] = float(txt2[i].text)
	            val[i][j+2] = txt3[i].text[:-1]
	            if ("<" in val[i][j+2]):
	                val[i][j+2] = 0.001
	            else:
	                val[i][j+2] = float(val[i][j+2])*0.01
	                val[i][j+2] = float(str(val[i][j+2])[0:5])
	        key[name[i].text] = val[i]
	    return key[movie_name]



# 2.6：商品搜索结果分析
import re

import requests
from bs4 import BeautifulSoup


class Solution:
    def itemSearch(self, shop_name: str) -> list:
        url = "###/open/show/ecjd.html"
        response = requests.get(url)
        if response.ok:
            response.encoding = "utf-8"
            return self.parseItem(response.text)[shop_name]

    def parseItem(self, html):
        soup = BeautifulSoup(html, 'html.parser')
        # 父目录
        temp_dict = dict()
        for child in soup.findAll(class_="gl-item"):
            # 商品名称
            item_name = child.find(class_="J_im_icon").a.text
            temp_list = []
            temp = child.find(class_="p-icons").text
            #         print(child.find("i",{"data-tips":"本商品参与满减促销"}))
            # 是否有满减活动
            temp_list.append(re.search("满\d+-\d+", temp) != None)
            # 是否有会员价
            temp_list.append(float(child.find(class_="p-price").strong.i.text))
            if child.find(class_="price-plus-1"):
                temp_list.pop()
                temp_list.append(
                    round(float(child.find(class_="price-plus-1").text[1:])))
            # 该网店对应商品的评论数
            if child.find(class_="p-commit"):
                temp_commit = child.select_one(".p-commit strong a").text
                temp_list.append(int(float(
                    temp_commit[:-2]) * 10000) if '万' in temp_commit else int(float(temp_commit[:-1])))
            # 该商品的价格
            # 如果该网店存在两个及以上商品，返回价格较高的商品信息；如果商品价格相同，返回排名最靠前的商品信息
            if item_name in temp_dict.keys() and temp_dict[item_name][1] >= temp_list[1]:
                continue
            # 保存数据
            temp_dict.update({item_name: temp_list})
        return temp_dict



# 2.7：商品关键词权重分析
import requests
from jieba.analyse import textrank


class Solution:
    def itemAnalyse(self) -> list:
        url = "http://72.itmc.org.cn:80/JS001/data/user/15930/77/fj_5392_hangzhou_top_woman_wear.txt"
        zt = requests.get(url)
        zt.encoding="utf-8"
        qc = textrank(zt.text,topK=5,allowPOS=("n","v"))
        return qc



# 3.1：电商订单数据清洗
import pandas as pd
class Solution:
    def nanCount(self, order_data:'DataFrame') -> int:
        url = "http://72.itmc.org.cn:80/JS001/data/user/15930/63/fj_order_data.csv"
        zt = pd.read_csv(url)
        mo = zt["choice_description"].isnull().sum()
        return mo


# 3.2：电商订单数据计算
import pandas as pd


class Solution:
    def salesStr(self, condition: str) -> str:
        url = "http://72.itmc.org.cn:80/JS001/data/user/15930/80/fj_order_data.csv"
        zt = pd.read_csv(url)
        zt["item_price"] = zt["item_price"].apply(lambda x:x.replace("$","")).astype(float)
        zt["总金额"] = zt["item_price"] * zt["quantity"]
        if condition.lower() == "max":
            jg = zt.groupby("item_name").sum().sort_values("总金额").index[-1]
        else:
            jg = zt.groupby("item_name").sum().sort_values("总金额").index[0]
        return jg

# 3.3：DataFrame计算平均值
class Solution:

    def CalAvg(self, df: 'pandas.DataFrame') -> list:
        df["avg"] = df.mean(axis=1).round(2)
        return df["avg"].tolist()

# 3.4：乐高商店收入计算
import pandas as pd


class Solution:
    def task(self, title):
        url = "http://72.itmc.org.cn:80/JS001/data/user/15930/241/fj_lego_tmallshop_sales_data.xlsx"
        zt = pd.read_excel(url)
        zt.dropna(subset=["price"])
        zt["sales_num"] = zt["sales_num"].fillna(0)
        mo = sum(zt["sales_num"] * zt["price"])
        age = zt["price"].mean().round(2)
        title = zt[zt["title"] == title]
        jg = sum(title["sales_num"] * title["price"])
        return [mo,age,jg]


# 3.5：部门平均薪资汇总计算
import pandas as pd


class Solution:

    def department_salary_summary(self) -> pd.Series:
        url = "http://72.itmc.org.cn:80/JS001/data/user/15930/242/fj_employee_salary_work_books.xlsx"
        zt = pd.read_excel(url, sheet_name="基本薪资")
        qc = pd.read_excel(url, sheet_name="上班通勤")
        mo = pd.merge(zt, qc, on="姓名")
        mo.fillna(0, inplace=True)
        mo["月基本薪资"] = mo["基本薪资"] + mo["岗位工资"] + mo["绩效工资"]
        mo["日薪"] = mo["月基本薪资"] / mo["应出勤天数（天）"]
        mo["时薪"] = mo["日薪"] / 8
        mo["法定节假日加班"] = mo["时薪"] * mo["法定假日加班（小时）"] * 2
        mo["周末加班"] = mo["时薪"] * mo["周末加班（小时）"] * 1.5
        mo["工作日加班"] = mo["时薪"] * mo["工作日加班（小时）"]
        mo["通勤工资"] = mo["法定节假日加班"] + mo["周末加班"] + mo["工作日加班"]
        mo["请假扣费"] = mo["时薪"] * mo["请假（小时）"]
        mo["社保缴费"] = (mo["社会保险缴费基数"] * 0.08 + mo["社会保险缴费基数"] * 0.02 + mo["社会保险缴费基数"] * 0.01 + mo["社会保险缴费基数"] * 0.10)
        mo["实发工资"] = mo["月基本薪资"] + mo["通勤工资"] - mo["请假扣费"] - mo["社保缴费"]
        jg = mo.groupby("部门")["实发工资"].mean().round(2).astype(float).sort_values(ascending=False)
        jg.name = "平均薪资"
        jg.index.name = "部门"
        return jg


# 3.6：编制比较资产负债表
import pandas as pd


class Solution:
    def balance_sheet(self, name):
        url = "http://72.itmc.org.cn:80/JS001/data/user/15930/243/fj_Interprice_balance_data.xlsx"
        zt = pd.read_excel(url,sheet_name="比较资产负债表")
        zt.fillna(0,inplace = True)
        zt["变动额"] = zt["2021.12.31"] - zt["2020.12.31"]
        zt["变动率"] = zt["变动额"] / zt["2020.12.31"]
        mo = zt[zt["项目"]==name]
        txt1 = (mo["变动额"].values[0]).round(2)
        txt2 = (mo["变动率"].values[0]).round(4)
        return [txt1,txt2]




# 3.7：某店铺不同地区销售情况分析
import pandas as pd


class Solution:
    def task(self, area: str) -> list:
        url = "http://72.itmc.org.cn:80/JS001/data/user/15930/240/fj_7568_tmall_order_report.csv"
        zt = pd.read_csv(url)
        qc = zt[zt["收货地址"] == area]
        mo = len(qc)

        fkdds = len(qc.query("买家实际支付金额 !=0 | 退款金额 != 0"))
        fkzhl = f"{(fkdds / mo) * 100:.2f}%"

        qefkdds = len(qc.query("买家实际支付金额 == 总金额"))
        qefkzhl = f"{(qefkdds / mo) * 100:.2f}%"

        zfzje = f"{sum(qc['买家实际支付金额']):.2f}"

        sjzfje = sum(qc["买家实际支付金额"])
        zfmjs = len(qc[qc["买家实际支付金额"] != 0])
        if zfmjs > 0:
            kdj = f"{sjzfje / zfmjs:.2f}"
        else:
            kdj = "本地沒有銷量"
        txt = qc[qc["买家实际支付金额"] != 0]
        if zfmjs > 0:
            po = f"{txt['买家实际支付金额'].mode()[0]:.2f}"
        else:
            po = "本地沒有銷量"
        ni = sum(zt["买家实际支付金额"])
        ll = f"{(sjzfje / ni) * 100:.2f}%"
        return [fkzhl, qefkzhl, zfzje, kdj, po, ll]






# 3.8：用户职位信息统计
import pandas as pd


class Solution:
    def jobStatistics(self, occupation: str) -> list:
        url ='http://72.itmc.org.cn:80/JS001/data/user/15930/67/fj_jobstatics.xlsx'
        chipo = pd.read_excel(url)
        chipo1 = chipo[chipo["occupation"] == occupation]
        num = "{:.2%}".format(len(chipo1[chipo1["gender"]=="F"]) / len(chipo1))
        num1 = chipo.groupby(["occupation","gender"]).count()["user_id"].unstack().fillna(0)
        num1["占比"] = num1["F"] / (num1["F"] + num1["M"])
        return [num,int(num1["占比"].rank(ascending = False)[occupation])]