使用Python玩转高等数学(1)：集合与区间

本文链接：https://blog.csdn.net/langhonglin/article/details/112340314

更多文章见微信【使用Python玩转数学】微信号：langhonglin0509

集合是数学中一个很重要的基本概念，是指具有某种特定性质的事物的总体，组成这个集合的事物称为该集合的元素。

例1 下面是一个简化的商品购买数据集T，每条数据t(i)表示一位顾客在超市一次购买商品的集合。

购买数据集T：

t(1)：{牛奶、面包、牛肉}

t(2)：{牛奶、猪肉}

t(3)：{猪肉、火腿}

t(4)：{牛奶、面包、火腿}

t(5)：{牛奶、面包、衣服、火腿、牛肉}

t(6)：{面包、衣服、牛奶}

t(7)：{面包、牛奶、衣服}

对给定的集合来说，它的元素是确定的，任何一个元素要么在集合中，要么不在集合中。例如：集合t(1)的元素为牛奶、面包、牛肉，火腿就不在集合t(1)内，它在集合t(3)、t(4)、t(5)内。

例2有甲、乙、丙、丁、戊、己7个人，其中甲、乙、丙早饭喝的豆浆、吃的油条，丁早饭喝的豆浆，戊、己早饭喝的八宝粥、吃的肉包，问：

（1）有多少人早餐喝豆浆？

（2）早餐的种类有哪些？

（3）找出甲和丁吃的不同早餐种类

可以用集合的概念来求解上面的问题，定义集合A、B、C、D、E、F，分别表示甲、乙、丙、丁、戊、己吃的早餐种类：

A = {豆浆, 油条}

B = {豆浆, 油条}

C = {豆浆, 油条}

D = {豆浆}

E = {八宝粥，肉包}

F = {八宝粥，肉包}

第1个问题是求喝豆浆的人数，该问题可以使用集合的交集运算，定义集合TEMP={豆浆}，将A、B、C、D、E、F集合分别与集合TEMP进行交集运算，若交集运算后的结果不是空集，则计入喝豆浆的人数。

# 定义早餐集合
breakfast_list =[
    {"豆浆","油条"},
    {"豆浆","油条"},
    {"豆浆","油条"},
    {"豆浆"},
    {"八宝粥","肉包"},
    {"八宝粥","肉包"}
]
 
# 计算早餐豆浆函数
defsoybean(data):
    # 计数器
    count = 0
    # 临时集合
    temp = {"豆浆"}
    # 遍历列表data
    for item in data:
        # 求两个集合的交集       
        if item & temp:
            # 若交集结果不为空，count加1  
            count = count + 1
    return count
 
# 程序入口
if __name__ =='__main__':
    count = soybean(breakfast_list)
    print("早餐喝豆浆人数：%d" % (count))

第2个问题是求早餐的种类有哪些，该问题可以使用集合的并集运算，对A、B、C、D、E、F集合连续求并集，计算的结果集合为早餐所有的种类。

# 定义早餐集合
breakfast_list =[
    {"豆浆","油条"},
    {"豆浆","油条"},
    {"豆浆","油条"},
    {"豆浆"},
    {"八宝粥","肉包"},
    {"八宝粥","肉包"}
]
 
# 计算早餐所有种类
def all(data):
    # 临时集合
    temp = set()
    # 遍历列表data
    for item in data:
        # 求两个集合的并集       
        temp = item | temp
    return temp
 
# 程序入口
if __name__ =='__main__':
 
    temp = all(breakfast_list)
    print("早餐种类：%s" % (temp))

第3个问题可以求集合A和D的差集，A和D差集内的元素即为甲和丁吃的不同早餐种类。


# 定义早餐集合
breakfast_list =[
    {"豆浆","油条"},
    {"豆浆","油条"},
    {"豆浆","油条"},
    {"豆浆"},
    {"八宝粥","肉包"},
    {"八宝粥","肉包"}
]
 
# 计算两个集合不同的早餐种类
defdifferent(s1,s2):
    # 返回s1和s2的差集
    return s1 - s2
 
# 程序入口
if __name__ =='__main__':
 
    temp =different(breakfast_list[0],breakfast_list[3])
    print("甲和丁吃的不同早餐种类为：%s" % (temp))

区间是数学中最重要的数集，区间一般是指实数集合，表示一类实数的范围。设a和b是实数，且a<b，则数集：

{x | a < x< b}

称为开区间，可以记作（a，b），a和b称为开区间（a，b）的端点，a不包含在（a，b）区间内，b也不包含在（a，b）区间内。

若数集：{x | a ≤x ≤ b}

称为闭区间，记作[a,b]，a和b也称为闭区间[a,b]的端点。类似数集：

[ a,b ) = {x |a≤x <b}

( a,b ] = {x |a<x≤ b}

称为半开区间。

使用Python处理区间数据，可以使用interval库，在使用之前需要安装interval库，最简单的安装方法就是在shell窗口运行pip3 install interval命令。

例3 [0,1]闭区间内的操作


# 导入Interval库
from intervalimport Interval
# 创建[0,1]闭区间
close_interval =Interval(0,1,lower_closed=True, upper_closed=True)
# 判断0.001是否在[0,1]区间内
print(0.001 inclose_interval)
# 检验区间[0,1]左侧边界值
print(0 inclose_interval)
# 检验区间[0,1]右侧边界值
print(1 inclose_interval)

Interval类可以创建开区间、闭区间或半开区间，返回创建的区间对象，区间对象支持Python的in或not in运算符，用于判断一个给定的数值是否在区间内。

创建开区间(0,1)：

close_interval =Interval(0,1,lower_closed=False, upper_closed=False)

创建半开区间(0,1]：

close_interval =Interval(0,1,lower_closed=False, upper_closed=True)

创建半开区间[0,1)：

close_interval =Interval(0,1,lower_closed=True, upper_closed=False)

Interval类有三种区间的操作方法，分别是join方法，overlaps方法和adjacent_to方法。join方法是区间合并，将两个区间合并为一个区间，并返回新的区间对象。

例4 区间的合并操作

# 导入Interval库
from intervalimport Interval
# 创建[0,1]闭区间
interval_one =Interval(0,1,lower_closed=True, upper_closed=True)
# 创建[1,2]闭区间
interval_two =Interval(1,2,lower_closed=True, upper_closed=True)
# 区间合并
interval_merge =interval_one.join(interval_two)
print(interval_merge)

overlaps方法是判断两个区间是否有交集，若有交集则返回True。

例5 判断区间是否有交集

# 导入Interval库
from intervalimport Interval
# 创建[0,1]闭区间
interval_one =Interval(0,1,lower_closed=True, upper_closed=True)
# 创建[1,2]闭区间
interval_two =Interval(1,2,lower_closed=True, upper_closed=True)
# 判断区间是否有交集
print(interval_one.overlaps(interval_two))

interval_one的区间是[0,1]，interval_two的区间是[1,2]，两个区间存在交集，交集为数值1。

adjacent_to方法用于判断两个区间是否比邻，两个区间比邻是指即相邻又无交集。

例6 判断两个区间是否比邻


# 导入Interval库
from intervalimport Interval
# 创建[0,1)闭区间
interval_one =Interval(0,1,lower_closed=True, upper_closed=False)
# 创建[1,2]闭区间
interval_two =Interval(1,2,lower_closed=True, upper_closed=True)
# 判断区间是否比邻
print(interval_one.adjacent_to(interval_two))

区间interval_one是半开区间[0,1)，区间interval_one是闭区间[1,2]，两个区间没有交集，但这两个区间比邻，因为区间interval_one右侧端点是1，interval_two的左侧端点也是1。

编程训练营APP

创新在线学习模式，学习编程不再半途而废

安卓手机应用商店

搜索编程训练营下载