2022-1-1（定积分part2,pandas补充，leetcode35.53.58）

数学基础（定积分2）

1.1 奇偶函数和周期函数的定积分

（1）
区间对称的偶函数定积分可以归一侧
区间对称的奇函数定积分为0

（2）

例子

1.2曲线的求长

1.2.1 参数方程的曲线长

例子：

1.2.2 f(x)函数的曲线求长

1.2.3极坐标曲线求长

分形（科克曲线）

ref：http://www.math168.com/sxxs/566.htm

1.3 旋转体的体积

例子：

1.4 旋转体的侧面积

数据分析篇（pandas）

1.知识回顾

结合pandas和matplotlib

import pandas as pd
from matplotlib import pyplot as plt

# 获取电影数据
Data = pd.read_csv(
    "C:\\Users\\hamme\\Desktop\\14100_机器学习-数据科学库（HM）\\21-数据分析资料\\数据分析资料\\day04\\code\\IMDB-Movie-Data.csv")

# 获取想要的一些数据
rank_mean = Data["Rank"].mean()  # 评分的平均值
director_nums = len(Data["Director"].unique())  # 获取导演人数，unique取消重复值

temp_actors_list = Data["Actors"].str.split(", ").tolist()  # 获取演员人数，先把每部主演的人数切分
actors_list = []
for j in temp_actors_list:
    for i in j:
        actors_list.append(i)
# actors_list = [i for j in temp_actors_list for i in j]
actors_num = len(set(actors_list))  # set也是取消重复值的函数，对于list

# 对相应数据进行选取绘制直方图
select_value = Data["Rating"].values

"""
绘制直方图方法1
(1)确定组数
(2)确定组间隔（根据最大最小值确定）
"""

min_value = select_value.min()
max_value = select_value.max()
num_bin = int((max_value - min_value) // 0.5)

plt.figure(figsize=(20, 8), dpi=80)
# plt.hist(select_value, num_bin)

_x = [min_value]
i = min_value
while i <= max_value + 0.5:
    i = i + 0.5
    _x.append(i)

plt.xticks(_x)

# 另一种绘制方法是直接把区间等分成list,然后用这个list去代替num_bin
num_bin_list = [min_value]
i = min_value
while i <= max_value + 0.5:
    i = i + 0.5
    num_bin_list.append(i)
plt.figure(figsize=(20, 8), dpi=80)

plt.hist(select_value, num_bin_list)
plt.xticks(num_bin_list)
plt.show()

2 pandas常用统计方法

2.1 常见的对数据分类的实例

import numpy as np
from matplotlib import pyplot as plt
import pandas as pd
from matplotlib import font_manager

Data = pd.read_csv(
    "C:\\Users\\hamme\\Desktop\\14100_机器学习-数据科学库（HM）\\21-数据分析资料\\数据分析资料\\day04\\code\\IMDB-Movie-Data.csv")

# 取出genre,然后去除重复值
Data_genre_list = Data["Genre"].str.split(",").tolist()
genre_list = list(set([i for j in Data_genre_list for i in j]))

# 根据data和genre_list的尺寸创建一个行为data.shape[0],列为len(genre_list)的zeros
genre_zero = pd.DataFrame(np.zeros(shape=(Data.shape[0], len(genre_list)), dtype=int), columns=genre_list)

# 把genre的内容进行分类
for i in range(Data.shape[0]):
    genre_zero.loc[i, Data_genre_list[i]] = 1

# 对获取的genre分类进行求和并排序
genre_count = genre_zero.sum(axis=0)
genre_count = genre_count.sort_values()

print(genre_count)

# 然后对排序后数据进行绘制条形图
my_font = font_manager.FontProperties(fname="\\Windows\\Fonts\\simfang.ttf")
_x = genre_count.index
_y = genre_count.values
plt.figure(figsize=(20, 8), dpi=80)
plt.bar(_x, _y, width=0.5)
plt.xticks(_x, fontproperties=my_font)
plt.xlabel("电影种类", fontproperties=my_font)
plt.ylabel("计数", fontproperties=my_font)
plt.title("电影数据分类图", fontproperties=my_font)
plt.show()

2.2数据合并 join和merge

2.2.1 join

join:默认情况下他是把行索引相同的数据合并到一起

如：

df1 = pd.DataFrame(np.ones(shape=(3, 3)), index=["A", "B", "c"], columns=list("abc"))
df2 = pd.DataFrame(np.zeros((2, 4)), index=["A", "B"], columns=list("xyzh"))
print(df1)
print(df2)
print(df1.join(df2))

2.2.2 merge

merge:按照指定的列把数据按照一定的方式合并到一起
(1)默认情况下：inner,取并集，主标签相同的留下

df3 = pd.DataFrame(np.arange(9).reshape(3, 3), index=["A", "B", "c"], columns=list("fax"))
df3.loc["A", "a"] = 1
df3.loc["B", "a"] = 1
# df3.loc["c", "b"] = 1
print(df1)
print(df3)
print(df1.merge(df3, on="a"))

如上图，以a列为匹配对象，df1里面有2行和df3里面的3行以匹配，所以得到一个2*3=6行的并集关系
如果不设置on,就会对相同列标签进行并集操作。
另外设置on=b，的情况下会出现a_x和a_y的情况，对a进行区分如下：

print(df1.merge(df3, on="b"))

（2）outter外连接取交集

print(df1.merge(df3, on="a", how="outer"))

（3）左右链接（left以左边df为准，right以右边df为准）
left就是左边显示全了就可以了，右边还有剩也不管了

print(df1.merge(df3, on="a", how="left"))
print(df1.merge(df3, on="a", how="right"))

（4）left_on和right_on，分别表示在两个df里面用来合并的列
即我们取on="a"的时候是两个df的a进行比较
但是我们取right_on=“b”,left_on=“a”,就是两个df的b和a比较如下：

df3 = pd.DataFrame(np.arange(9).reshape(3, 3), index=["A", "B", "c"], columns=list("fax"))
df3.loc["A", "a"] = 1
df3.loc["B", "a"] = 1
# df3.loc["c", "b"] = 1
print(df1)
print(df3)
print(df1.merge(df3, left_on="b",right_on="a", how="inner"))

2.3 数据分组聚合

分组：groupby
聚合操作的一些方法：

（1）对单个参数进行分组

grouped_country = df["Brand"].groupby(by=df["Country"]).count()

print(grouped_country)
print("US count={},CN count={}".format(grouped_country["US"], grouped_country["CN"]))

# 取出country=CN的df
df_CN = df[df["Country"] == "CN"]
grouped_Province = df_CN["Brand"].groupby(by=df_CN["State/Province"]).count()
print(df_CN)
print(grouped_Province)

（2）同时多个条件筛选，同时不同方法的返回对象不同

# 数据按多个条件分组返回不同的情况
grouped1 = df["Brand"].groupby(by=[df["Country"], df["State/Province"]]).count()
grouped2 = df.groupby(by=[df["Country"], df["State/Province"]])[["Brand"]].count()
grouped3 = df.groupby(by=[df["Country"], df["State/Province"]]).count()["Brand"]
print(grouped1, type(grouped1))
print("*" * 100)
print(grouped2, type(grouped2))
print("*" * 100)
print(grouped3, type(grouped3))

注意：上面三个方法结果是一致的，但是1，3返回的是series对象，2返回的Dataframe对象

2.4 数据索引

简单的索引操作：
（1）获取index：df.index
（2）指定index ：df.index = [‘x’,‘y’]
（3）重新设置index :df.reindex(list(“abcedf”))
（4）指定某一列作为index：df.set_index(“Country”,drop=False)
（5）返回index的唯一值：df.set_index(“Country”).index.unique()

（1）获取行索引值

# index 操作
df2 = pd.DataFrame(np.arange(12).reshape(3, 4), index=list("xyz"), columns=list("abcd"))
print("-" * 100)
print(df2)
print("-" * 100)
print(df2.index)
# 索引指定行
print("-" * 100)
print(df2.reindex(["x"]))

（2）把列设置索引项

# 以列作为索引，就是拿那一列的值作为键值
print("-" * 100)
print(df2.set_index("a"))
print(df2.set_index("a", drop=False))  # 以a列为索引值，但是不排除a列数据

（3）复合索引

# 设置复合索引操作
df3 = pd.DataFrame(
    {'a': range(7), 'b': range(7, 0, -1), 'c': ['one', 'one', 'one', 'two', 'two', 'two', 'two'], 'd': list("hjklmno")})
print(df3.set_index(["c", "d"]))
# print(df3.set_index(["c", "d"]).index)
df4 = df3.set_index(["c", "d"])
print(df4.loc["one"])
df5 = df3.set_index(["d", "c"]) 
print(df5.swaplevel().loc["one"]) #swaplevel可以交换索引列的顺序

leetcode(35 53 58 )

35.搜索插入位置

要求时间复杂度为O(logn)就是二分查找法

class Solution:
    def searchInsert(self, nums: List[int], target: int) -> int:
        #中值查找法，左闭右开区间[0,len)
        s=0       
        e=len(nums)       
        while s<e:
            mid=(s+e)//2
            #以mid为界限查找
            if nums[mid]<target:
                s=mid+1
            else:
                e=mid
        return s

53. 最大子数组和

动态规划，前项位置来决定当前位置的值

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        dp=[]
        dp.append(nums[0])
        max_value=dp[0]
        for i in range(1,len(nums)):
            dp.append(max(nums[i],dp[i-1]+nums[i]))
            if dp[i]>max_value:
                max_value=dp[i]
        return max_value

58. 最后一个单词的长度

情况分析：从后往前遍历，当遇到第一个不是“ ”的时候开始计数，开始计数后当遇到第一个“ ”或者到头，结束计数

class Solution:
    def lengthOfLastWord(self, s: str) -> int:
        count=0
        flag=False # 用来判断是否开始计数
        len_s=len(s)
        for i in range(1,len_s+1):
            if not flag and s[len_s-i]!=' ':
                flag=True
                count+=1
                #print("count=",count,"i=",i)
                continue               
            if flag :
                if s[len_s-i]==' ':
                    return count
                else:
                    count+=1
                #print("count=",count,"i=",i)
        return count