成 Swift 泛型的高阶玩家(附实战适配 Demo)

集合

俺们事先多之是,去定义有一个种类的目标、定义有一个功能型函数,有尝试了定义对象族、函数族?而所谓泛型编程,即我们将所急需定义的对象同函数抽象出来,极大拓宽了利用状况,减少代码的冗余!
其实,我们恐怕没有概念了泛型函数,但一定起利用过 Swift
标准库中之泛型函数:map()、filter()、reduce()。而这些泛型函数,众所周知,应用场合极大,基本可作用为其他参数类型。而我辈平素使用最多的
Array 和 Dictionary
也都是泛型集合,我们得于当时简单只聚众传输基本任何类型的价值,而输出的门类为鉴于我们输入的项目规定,这也是泛型的同等良特征。
如若及时篇文章将会组成一个采用泛型编程的适配工具来谈谈泛型的高阶玩法。

1.  集合的概念

悬念: 我们愿意如果下图般的,在不同尺寸的装置适配不同之封面图及文件。

  在Python中, 汇聚是核心数据列的平等种集合类型,它有可变集合set()和不可变集合frozenset()两种植。Python中之集结类似列表,但每个元素都得常常独一无二之,且是无序的。

效果图

  集合set和集合frozenset的区分如下:

而且,我们想效果代码越简单越好,可读性越强逾好,像下一样就是会上效果:

  集合set是可变的,有add(),remove()等方法。由于集合set是可变的,所以她不有哈希值。基本功能包括涉及测试与解除重元素。集合对象还支持union(联合)、
intersection(交集)、 difference(差集)和sysmmetric
difference(对如差集)等数学运算。

ScreenFeatureManager.shared
.adapt(toDevice: .iPhone(inch35: 30, inch40: 40, inch47: 50, inch55: 60))

  集合set支持 N in set, len(set),和 for N in
set。作为一个无序的联谊,集合set不记录元素位置还是插入点。因此,集合set不支持
indexing, 或外类序列的操作。

那么,我们欠怎么开呢?在此之前,先介绍下就要以及之泛型函数。

  集合frozenset()是不可变的,存在哈希值,优点是她可视作字典的key,也得当做其他集合的因素。缺点是若创立便不能够转,没有add(),remove()方法。

Swift 标准库中的泛型函数

实际,如果你熟悉函数式编程,那么您对这些泛型函数应该了如指掌,如果你打探都嗜上了函数式编程,何不利用
RxSwift 进行函数响应式编程呢?这里发生几乎首 RxSwift
开发之实战,望有助于大家更加深刻认识 RxSwift 函数响应式开发:

  • <荐> RxSwift + ReactorKit
    构建信息流框架
  • 用 RxSwift 构建不同风格的读模式(附
    Demo)
  • 平年半支经历,使用 RxSwift
    构建一个档次之为主框架,这种姿势足够优雅也?

如上皆为实战篇,往后会见出其 知识点讲解篇

  因此,Python中集的作用主要是:去又,把一个列表变成集合,就自行去重新;关系测试,测试两组数据里面的混合、差集、并汇聚等关乎。

Map:

Map
函数一般是承受一个加以的高频组,然后经过有非降维的算计处理,得到并回一个新的数组。

苹果官方概念

extension Array {
    func map<T>( transform: Element ->  T) -> [T] {
      var result: [T] = []
       for x in self {
          result.append(transform(x))
       }
       return result
    }
}

于 Map 中定义一个泛型类,经过 transform
闭包函数处理后,通过泛型数组去用到处理后的新数据,成为新的数组。

应用
拿以下数组中之每个元素增加1后输出

let objects: [Int] = [1, 2, 3]

事先采取深谙不了的 For 循环

var newObjects: [Int] = [] 
for object in objects {
   let newObject = object + 1
   newObjects.append(newObject)
}

接下来,使用 Map 函数

// objects.map { newObject in  return newObject + 1 } 
// 上面是完整的 Map 函数编写,但如果闭包中的代码比较简单,我们都会省略 return,如下:
objects.map { newObject in  newObject + 1 }

足见见,四实行的之代码块经 Map
函数处理下,成为了链式的代码段,借这为得以引入一个新的定义,即函数式编程:主要是以扑灭冗余且复用场景极大的代码块,抽象成复用性极强的代码段,当然以上代码还不够函数式,我们可以连续优化:

// 定义好计算函数
func addCompute(_ object: Int) -> Int {
  return object + 1
}
//进一步优化调整输出函数
objects.map { newObject in  addCompute(newObject) }

函数式编程:需要我们将函数作为其他函数的参数传递,或者当作返回值返还,有时也于称为高阶函数。

 

Filter:

Filter
函数同样是吸纳一个加以的反复组,通过加的淘标准,取得数组中符合条件的因素,并赶回一个初的数组。

苹果官方概念

extension Array {
    func  filter( includeElement: Element ->  Bool) -> [Element] {
      var result: [Element] = []
       for x in self {
          result.append(includeElement(x))
       }
       return result
    }
}

当 filter 中定义一个泛型元素 Element,经过 includeElement
闭包函数筛选处理以后,再由泛型数组拿到拍卖后底初数据,成为新的数组。

应用
俺们将到以上定义好的 objects 数组,拿到中间有着的偶数
for 循环

let newObjects: [Int] = []
for oldObject in Objects {
   if oldObject%2 == 0 {
      newObjects.append(oldObject)   
   }
}

filter 函数

 objects.filter { filterElement in  filterElement%2 == 0 }

如出一辙的,你可以感受下 filter 函数处理后,链式代码的可读性。

2.  凑的操作

Reduce

Reduce 函数接收一个输入数组,同时用吸收一个 T 类型的开始值,
经过 combine 函数处理以后,返回一个跟为 T 类型的结果。在一些像 OCaml 和
Haskell 一样的函数语言中,reduce 函数被号称 fold 或 fold_left。而
reduce
可英译为组合,简单来说就是经过我们所想的方组成一个数组中的因素。

苹果官方概念

extension Array {
    func  reduce<T>( initialValue: T, combine: (T, Element) -> T) -> [T] {
      var result = initialValue
       for x in self {
          result = combine(result, x)
       }
       return result
    }
}

于 reduce 中生出半点单泛型元素 T && Element,combine
是对准为数组的处理函数,我们输入初始值和数组中的各国一个要素之后,即可输出返回一个出色的价值。

应用
我们还以到 map 中定义好之 objects
数组,拿到中每个元素相乘后的结果。
for 循环

func reduceInstance() {
  let newObject: Int = 1
  for oldObject in Objects {
     newObject * oldObject
  }
  return newObject
}

reduce 函数

 objects.reduce(1) { result, x in  result * x }

 // 我们也可以将运算符作为最后一个参数,让这段代码更短且不影响可读性
 objects.reduce(1, combine: *)

如上,即为用 reduce 后甩卖的结果

  于Python中,集合set的常用操作包括:创建集合set、集合set增加、集合set删除、集合的搅和、集合的并集、集合的差集等。

最后

咱俩摸索着还要采取上述三单函数去意一个数组。

let lastObjects: [Int] = [2017, 10, 7, 11, 09, 6]

场景
俺们用拿一个整形数组中之素:

  • 事先以享有的要素 + 1
  • 筛选产生其中的偶数元素
  • 将持有筛选到的因素相加

lastObjects.map { element in element + 1 }
.filter { element in element%2 == 0 }
.reduce(0, combine: +)

类复杂的动场景,使用泛型函数编程是休是移得杀简短?以上气象你试试用
for 循环?

 

泛型编程:适配工具的实战开发

以上,我们讲解了苹果下泛型构建的函数,接下我们进去一个略而特别实用的泛型实战。

2.1 集合的创立

特别大的动场景

我们展示到界面上的素:图片、文字,很多辰光用在不同尺寸的设施及呈现不同的态势(大小、位置、样式),这个时候我们该怎么处置?仔细一想,其实是还是生格外多景的,可能吧会招十分多功能性冗余代码块,该怎么处置?
使用泛型编程刚好可解决了这些题材。

  在Python中,集合的创造好应用集合的厂函数set()和frozenset(),但是,set()创建的汇时不过转移的,frozenset()创建的集合时不可变的,其语法格式分别如下:

特性定义

概念屏幕类型(iPhone/iPad),而诸种档次,都有两样尺寸的屏幕大小:

enum DeviceType<T> {
    case iPhone(inch35: T, inch40: T, inch47: T, inch55: T)
    case iPad(common: T, pro: T)
}

概念屏幕的尺寸系数及当前屏幕尺寸,目的是叫外界得以经过该属性直接了解当前凡是那种尺寸的屏幕:

struct DeviceDiaonal {
    static let iPhone4: Double = 3.5
    static let iPhoneSE: Double = 4.0
    static let iPhone6: Double = 4.7
    static let iPhone6Plus: Double = 5.5
}

// 当前屏幕尺寸
var currentDiaonal: Double = DeviceDiaonal.iPhone6

概念屏幕的规范与当前屏幕规格,目的是深受外界可以透过该属性直接掌握当前凡那种屏幕规格的:

// 屏幕规格
enum ScreenSpecs {
    enum PhoneInch {
        case inch35, inch40, inch47, inch55
    }
    enum PadInch {
        case common, pro
    }
    case iPhone(PhoneInch), iPad(PadInch)
}

// 当前屏幕规格
var screenSpecs: ScreenSpecs = .iPhone(.inch47)

  集合名 = set(集合值)

初始化构造器的构建

因时工具类是一个处理接近,所以我们只是将那定义为单例类,而该初始化构造器仅限于被单例调用。那么,我们要以初始化构造器初始化什么性质为?因为当时是一个屏幕特性的单例类,毋庸置疑,我们可以一直通过此类,就足以拿到目前屏幕的具备特性,因此当初始化构造器中,我们要对当前部分屏幕特性开展初始化

// 构造单例(调用 init 构造函数)
static let shared = ScreenFeatureManager()

fileprivate init() {
    let screenWidth = UIScreen.main.bounds.width
    switch screenWidth {
    case 320:
        if screenHeight <= 480 {
            currentDiaonal = DeviceDiaonal.iPhone4
            screenSpecs = .iPhone(.inch35)
        } else {
            currentDiaonal = DeviceDiaonal.iPhoneSE
            screenSpecs = .iPhone(.inch40)
        }

    case 375:
        currentDiaonal = DeviceDiaonal.iPhone6
        screenSpecs = .iPhone(.inch47)

    case 414:
        currentDiaonal = DeviceDiaonal.iPhone6Plus
        screenSpecs = .iPhone(.inch55)

    case 768:
        screenSpecs = .iPad(.common)

    case 1024:
        screenSpecs = .iPad(.pro)

    default:
        break
    }
}

时至今日,我们初始化了一部分屏幕特性,接下,我们拿这些屏幕特性加到正菜中!

       集合名 = frozenset(集合值)  

应用泛型类构造适配函数

行使前面定义好的 DeviceType
类型,对于这个类型,我们得依据不同之种输入不同之泛型值(T),然后在函数内,拿到直达同一步就是处理好的屏幕特性,结合输入值进行判定处理,不同的屏幕会映射会产生不同之泛型值(T),并将到该映射下之泛型值输出返回。

func adapt<T>(toDevice type: DeviceType<T>) -> T {

    // 多个输入值,判断处理之后,输出一个单一的泛型值(多对一的映射)
    switch type {
    case let .iPhone(inch35, inch40, inch47, inch55):
        switch screenSpecs {
        case .iPhone(.inch35):
            return inch35
        case .iPhone(.inch40):
            return inch40
        case .iPhone(.inch47):
            return inch47
        case .iPhone(.inch55):
            return inch55
        default:
            return inch47
        }

    case let .iPad(common, pro):
        switch screenSpecs {
        case .iPad(.common):
            return common
        case .iPad(.pro):
            return pro
        default:
            return common
        }
    }
}

  

应用

上述泛型函数构造好以后,适配工作就变换得专程简单。
比如说有三个适配点:

  • 不同装备,拥有不同之封面图
  • 差装备,封面图的 size 是匪一致的
  • 不等装备,其标题颜色、样式、大小都未均等

咱们欠怎么适配以上的需求呢?

fileprivate func adaptiveConfiguration() {
    //适配封面图的宽度(在 storyBoard 中宽度与高度成一比例,适配了宽度,高度也会跟着变化)
    coverImageViewWidthConstraint.constant = ScreenFeatureManager.shared.adapt(toDevice: .iPhone(inch35: 150, inch40: 250, inch47: 350, inch55: 420))

    // 适配不同的设备不同的封面图
    coverImageView.image = ScreenFeatureManager.shared.adapt(toDevice: .iPhone(inch35: UIImage(named: "home_adapt_inch35"), inch40: UIImage(named: "home_adapt_inch40"), inch47: UIImage(named: "home_adapt_inch47"), inch55: UIImage(named: "home_adapt_inch55")))

    //适配主题标题内容
    themeTitleLabel.text = ScreenFeatureManager.shared.adapt(toDevice: .iPhone(inch35: "杳无音迅(inch35)", inch40: "杳无音迅(inch40)", inch47: "杳无音迅(inch47)", inch55: "杳无音迅(inch55)"))

    //适配主题标题的字体样式
    themeTitleLabel.font = ScreenFeatureManager.shared.adapt(toDevice: .iPhone(inch35: UIFont.boldSystemFont(ofSize: 15), inch40: UIFont.boldSystemFont(ofSize: 18), inch47: UIFont.boldSystemFont(ofSize: 21), inch55: UIFont.boldSystemFont(ofSize: 25)))

    //适配主题标题的字体颜色
    themeTitleLabel.textColor = ScreenFeatureManager.shared.adapt(toDevice: .iPhone(inch35: UIColor.black, inch40: UIColor.gray, inch47: UIColor.lightGray, inch55: UIColor.green))

}

至此,适配工具就开发好,如果您是利用 Swift
开发,那么好直接将该引入你的种类应用。如果产生重新好之兑现方式,期待您评论报。

Demo
https://github.com/iJudson/ScreenFeature
欢迎 stars
Thanks:多谢观看,欢迎收藏文章,欢迎关注、交流…

  (1)创建空集合

  于Python中,当不指定集合的价值经常,使用工厂函数set()和frozenset()即可创建一个缺损集合。

  例如,创建空集合。  

  代码:

1 a =set()
2 b = frozenset()
3 print(a)
4 print(b)

  运行结果:

1 set()
2 frozenset()

 

  (2)用set()方法创建集合  

  例如,用set()方法创建一个0届10之内的奇数的集合,并打印出来。

  代码:

1 number_odd = []
2 for number in range(1,11,2):
3     number_odd.append(number)
4 number_opp_set =set(number_odd)
5 print(number_opp_set)

  说明:

  第1尽,创建一个空列表。

  第2~3实行,用函数range()循环生成0到10次的奇数,然后搭及空列表中。

  第4实践,将列表中的值传于艺术set(),生成一个集聚。

 

  运行结果:

1 {1, 3, 5, 7, 9}

  以上的代码可以经过列表解析的法子优化为:

  代码1:

1 number_opp_set =set(number for number in range(1,11,2))
2 print(number_opp_set)

  说明:

  因为Python是解释性语言,代码越少,解释花费的光阴吗丢失。

 

  运行结果1:

1 {1, 3, 5, 7, 9} 

 

 (3)用frozenset()方法创建集合  

  例如,用frozenset()方法创建一个0顶10之内的奇数的集合,并打印出。

  代码:

1 number_opp_set_0 =frozenset(number for number in range(1,11,2))
2 print(number_opp_set_0)

 

  运行结果:

1 frozenset({1, 3, 5, 7, 9})

 

2.2  集合的加码

  在python中,集合的增产生个别种常用方法:add()方法及update()方法。

  (1) add()方法

  集合的add()方法是管要传播的素做呢一个一体化增加及集中,即落实单元素增加。

  例如,定义一个0至10的奇数的聚集,然后又就此add()方法向里加一个偶数2暨18,然后再次打印出。

  代码:

1 number_opp_set =set(number for number in range(1,11,2))
2 print(number_opp_set)
3 number_opp_set.add(2)
4 number_opp_set.add(18)
5 print(number_opp_set)

  说明:

  第3、4履,都是隔三差五利用add()方法分别于聚集中多偶数2跟18。

  

  运行结果:

1 {1, 3, 5, 7, 9}
2 {1, 2, 3, 5, 7, 9, 18}

 

  (2)update()方法

  集合update()方法是将要传的元素拆分,做啊单个个体增加到集结中,即多元素增加。

  例如,定义一个0交10之奇数的成团,然后再度用update()方法为中间长一个偶数2及18,然后还打印出来。

  代码:

1 number_opp_set =set(number for number in range(1,11,2))
2 print(number_opp_set)
3 number_opp_set.update('2')
4 number_opp_set.update('18')
5 print(number_opp_set)

  说明:

  第3、4实行,分别调用update()方法分别于集团中加进偶数2和18.

 

  运行结果:

1 {1, 3, 5, 7, 9}
2 {1, 3, 5, 7, 9, '2', '8', '1'}

  从以上的运行结果受但是明白,偶数18倍增拆分为1与8个别增加及集中,并且多的价都受单引号引起来,这象征增加的凡字符窜。这并无是咱用的结果。

  以Python中,如果调用update()方法为集中增加有限单或多单字符组成的价值经常,该值需要采用中括号要花括号括起来,即表示也字典或列表的花样。

  例如,定义一个0届10之奇数的集,然后再度就此update()方法向内加一个偶数2跟18,即奇数19,然后还打印出。

  代码:

1 number_opp_set =set(number for number in range(1,11,2))
2 print(number_opp_set)
3 number_opp_set.update('2')
4 number_opp_set.update(['18'])
5 number_opp_set.update({'19'})
6 print(number_opp_set)

 

  运行结果:

1 {1, 3, 5, 7, 9}
2 {1, 3, 5, 7, 9, '18', '2', '19'}

 

2.3 集合的勾

  于Python中,集合的删除分为两栽,一种植是剔除集合中的价;一栽是去所有集合。

  (1)删除所有集合

  在Python中,当我们要去所有集合中经常,可采用del 语句直接去。

  例如,将1.2.2 中创造的集删除。

  代码:

1 number_opp_set =set(number for number in range(1,11,2))
2 print("集合删除前:",number_opp_set)
3 del  number_opp_set
4 print("集合删除后:",number_opp_set)

  说明:

  第2实践,使用del语句删除集合number_opp_set。

 

  运行结果:

1 集合删除前: {1, 3, 5, 7, 9}
2 Traceback (most recent call last):
3   File "F:/PyProject/s14/day2/test_set.py", line 6, in <module>
4     print("集合删除后:",number_opp_set)
5 NameError: name 'number_opp_set' is not defined

  从以上的运转结果可知,使用del语句删除集合时一样种永久性的,删除后即使集合就非能够重叫用。

 

  (2)删除集合中之价值

  以Python中,当我们得去集合中的价经常,可应用remove()方法、discard()方法及pop()方法。

  注意:remove()方法以及discard()方法还能够去除指定的汇的价,但倘若指定的价值当聚集中摸索不顶,则会唤起错误,而discard()方法不见面;pop()方法是即兴删除集合中的妄动一个价值。

  例如,将1.2.2 中加进及聚集中的价值删除。

  代码:

 1 number_opp_set =set(number for number in range(1,11,2))
 2 print(number_opp_set)
 3 number_opp_set.update('2')
 4 number_opp_set.update(['18'])
 5 number_opp_set.update({'19'})
 6 print(number_opp_set)
 7 number_opp_set.remove('2')
 8 number_opp_set.discard('18')
 9 number_opp_set.pop()
10 print(number_opp_set)

  说明:

  第7实践,调用remove()方法从集合中删去前面增加及聚集中的值2,并且remove()中之参数必须用引号引起来,否则Python解释器无法解析,会提醒错误。

  第8履,调用discard()方法从集合中去前面增加至集结中之值18,方法discard()中的参数如果全是数字,不用引号引起来啊非会见报错,但聚中的价18未会见为删除,不用引号引起来,Python解释器解析不顶该值。

 

  运行结果:

1 {1, 3, 5, 7, 9}
2 {1, 3, 5, '19', 7, 9, '2', '18'}
3 {3, 5, 7, 9, '19'}

  从上述之运行结果能够,由于pop()方法是即兴删除集合中的肆意一个价值,所以将原先集合中的值1删除了,但净增的价值19依旧存在集合中。

 

2.3 集合的拜会

  于Python中,集合的访主要出点儿种植,一种植是造访整个集合,一栽的成团的遍历。

  (1)访问整个集合

  以Python中,访问整个集合,可以直接以。

  例如,创建一个1及10次的数字构成的偶数的集,并访问整个集合。

  代码:

1 number_even_set =set(number for number in range(2,11,2))
2 print(number_even_set)

  说明:

  第1行,使用range()函数和for循环,从2开头,依次遍历到10,且幅度为2,再就此set()方法,将所有遍历过程被满足步长为2之数字创建为一个集。

  第2尽,直接用print打印整个集合。

 

  运行结果:

1 {2, 4, 6, 8, 10}

 

  (2)访问集合中的每个值

  在Python中,我们可以应用for循环来遍历访问集合中的每个值。

  例如,创建一个1到10中间的数字组合的偶数的集,并遍历访问集合中之每个值。

  代码:

1 number_even_set =set(number for number in range(2,11,2))
2 print(number_even_set)
3 for number_evven in number_even_set:
4     print(number_evven)

 

  运行结果:

1 {2, 4, 6, 8, 10}
2 2
3 4
4 6
5 8
6 10

 

3.  成团的涉嫌测试

  于Python中,集合的关系测试包括:并集、交集、差集等等。

3.1 并集

  集合中,并汇聚为为合集,即用一个集结和其它一个聚合并为一个集的进程。求并集使用函数union()或者运算符“|”。

  例如,创建一个1交10期间的数字组成的偶数的聚合和奇数集合,然后要其并集。

  代码:

 1 number_opp_set =set(number for number in range(1,11,2))
 2 print(number_opp_set)
 3 number_even_set =set(number for number in range(2,11,2))
 4 print(number_even_set)
 5 print("-----第一种方式:用函数union()求并集-----")
 6 number_set = number_opp_set.union(number_even_set)
 7 print(number_set)
 8 print("-----第二种方式:用运算符'|'求并集-----")
 9 _number_set = number_opp_set | number_even_set
10 print(_number_set)

 

 说明:

  第6行,用函数union()将集合number_opp_set和集合number_even_set合并后赋值给变量number_set。

  第7履,用运算符 ‘|’
将集合number_opp_set和集合number_even_set合并后赋值给变量_number_set。

  

  运行结果:

1 {1, 3, 5, 7, 9}
2 {2, 4, 6, 8, 10}
3 -----第一种方式:用函数union()求并集-----
4 {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
5 -----第二种方式:用运算符'|'求并集-----
6 {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

  从上述之运作结果可知,求少个集聚的并集可以运用函数union()或运算符
‘|’ ,其结果是同样的。

 

3.2 交集

  交集就是少数只集聚中还有的有些,用函数intersection()或运算符
‘&’求少单集聚的交集。

  例如,创建一个1顶5之数字构成的聚合,再创一个0到10的奇数组成的集聚,然后要其交集。

  代码:

 1 number_set_a =set(number for number in range(1,6))
 2 print(number_set_a)
 3 number_opp_set =set(number for number in range(1,11,2))
 4 print(number_opp_set)
 5 print("-----第一种方式:intersection()求交集-----")
 6 number_set = number_set_a.intersection(number_opp_set)
 7 print(number_set)
 8 print("-----第二种方式:用运算符 '&'求交集-----")
 9 _number_set = number_set_a & number_opp_set
10 print(_number_set)

  说明:

  第6推行,使用函数intersection()求集合number_set_a和集合number_opp_set的交集,并赋值给变量number_set。

  第9实践,使用运算符 ‘&’
求集合number_set_a和集合number_opp_set的混,并赋值给变量_number_set。 

  运行结果:

1 {1, 2, 3, 4, 5}
2 {1, 3, 5, 7, 9}
3 -----第一种方式:intersection()求交集-----
4 {1, 3, 5}
5 -----第二种方式:用运算符 '&'求交集-----
6 {1, 3, 5}

  从以上的周转结果会,通过函数intersection()或运算符 ‘&’
,都得请求少独集交集。

 

3.3 差集

  差集就是于有限独聚众中,在集合a中有,但集合b中没的一部分,或者集合b中出,但集合a中无的一些。因此我们可采用函数difference()或运算符
‘-’ 求差集。

  例如,创建一个1至5底数字组合的集结,再创一个0暨10之奇数组成的联谊,然后要其差集。

  代码:

 1 number_set_a =set(number for number in range(1,6))
 2 print(number_set_a)
 3 number_opp_set =set(number for number in range(1,11,2))
 4 print(number_opp_set)
 5 print("-----第一种方式:difference()求差集-----")
 6 number_set = number_set_a.difference(number_opp_set)
 7 print(number_set)
 8 _number_set = number_opp_set.difference(number_set_a)
 9 print(_number_set)
10 print("-----第二种方式:用运算符 '-'求差集-----")
11 _number_set_ = number_set_a- number_opp_set
12 print(_number_set_)
13 __number_set__ = number_opp_set - number_set_a
14 print(__number_set__)

  说明:

  第6履行,使用函数difference()求集合number_set_a中有,但集合number_opp_set中从不底部分,并赋值给变量number_set。

  第8执,使用函数difference()求集合number_opp_set中有,但集合number_set_a中绝非底局部,并赋值给变量_number_set。

  第11推行,使用运算符 ‘-‘
求集合number_set_a中有,但集合number_opp_set中莫底一对,并赋值给变量_number_set_。

  第13实践,使用运算符
‘-‘ 求集合number_opp_set中有,但集合number_set_a中尚无底有些,并赋值给变量__number_set__。

 

  运行结果:

1 {1, 2, 3, 4, 5}
2 {1, 3, 5, 7, 9}
3 -----第一种方式:difference()求差集-----
4 {2, 4}
5 {9, 7}
6 -----第二种方式:用运算符 '-'求差集-----
7 {2, 4}
8 {9, 7}

 

3.4 子集

  判断集合a是否是集合b的子集,使用函数issubset()或运算符 ‘<=’。

  例如,创建一个1至10之数字构成的联谊,再创一个0暨10的奇数组成的成团,然后要其子集。

  代码:

 1 number_set_a =set(number for number in range(1,11))
 2 print(number_set_a)
 3 number_opp_set =set(number for number in range(1,11,2))
 4 print(number_opp_set)
 5 print("-----第一种方式:issubset()求子集-----")
 6 number_set = number_set_a.issubset(number_opp_set)
 7 print(number_set)
 8 _number_set = number_opp_set.issubset(number_set_a)
 9 print(_number_set)
10 print("-----第二种方式:用运算符 '<='求子集-----")
11 _number_set_ = number_set_a <= number_opp_set
12 print(_number_set_)
13 __number_set__ = number_opp_set <= number_set_a
14 print(__number_set__)

 

 说明:

  第6推行,用函数issubset()判断集合number_set_a是否是集合number_opp_set的子集,判断结果赋值给变量number_set。

  第8实践,用函数issubset()判断集合number_opp_set是否是集合number_set_a的子集,判断结果赋值给变量_number_set。

  第11实行,用运算符 ‘<= ‘
判断集合number_set_a是否是集合number_opp_set的子集,判断结果赋值给变量_number_set_。

  第13实践,用运算语言符 ‘<=
‘ 判断集合number_opp_set是否是集合number_set_a的子集,判断结果赋值给变量__number_set__。

 

  运行结果:

1 {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
2 {1, 3, 5, 7, 9}
3 -----第一种方式:issubset()求子集-----
4 False
5 True
6 -----第二种方式:用运算符 '<='求子集-----
7 False
8 True

 

3.5 父集

  判断集合a是否是集合b的父集,使用函数issuperset()或运算符 ‘>=’。

  例如,创建一个1顶10底数字组成的聚合,再创一个0交10之奇数组成的集聚,然后要其父集。

  代码:

 1 number_set_a =set(number for number in range(1,11))
 2 print(number_set_a)
 3 number_opp_set =set(number for number in range(1,11,2))
 4 print(number_opp_set)
 5 print("-----第一种方式:issuperset()求父集-----")
 6 number_set = number_set_a.issuperset(number_opp_set)
 7 print(number_set)
 8 _number_set = number_opp_set.issuperset(number_set_a)
 9 print(_number_set)
10 print("-----第二种方式:用运算符 '>='求父集-----")
11 _number_set_ = number_set_a >= number_opp_set
12 print(_number_set_)
13 __number_set__ = number_opp_set >= number_set_a
14 print(__number_set__)

    说明:

  第6履行,用函数issuperset()判断集合number_set_a是否是集合number_opp_set的父集,判断结果赋值给变量number_set。

  第8执,用函数issuperset()判断集合number_opp_set是否是集合number_set_a的父集,判断结果赋值给变量_number_set。 

  第11执行,用运算符 ‘>=’
判断集合number_set_a是否是集合number_opp_set的父集,判断结果赋值给变量_number_set_。

  第13尽,用运算符
‘>=’ 判断集合number_opp_set是否是集合number_set_a的父集,判断结果赋值给变量__number_set__。

  

运行结果:

1 {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
2 {1, 3, 5, 7, 9}
3 -----第一种方式:issuperset()求父集-----
4 True
5 False
6 -----第二种方式:用运算符 '>='求父集-----
7 True
8 False

 

3.6 对如差集

  对如差集就是呼吁少独集聚中之删减公共的一部分的集。

  例如,创建一个1交5底数字组合的成团,再创一个0至10之奇数组成的集合,然后要其针对性如差集。

  代码:

 1 number_set_a =set(number for number in range(1,6))
 2 print(number_set_a)
 3 number_opp_set =set(number for number in range(1,11,2))
 4 print(number_opp_set)
 5 print("-----第一种方式:symmetric_difference()求对称差集-----")
 6 number_set = number_set_a.symmetric_difference(number_opp_set)
 7 print(number_set)
 8 _number_set = number_opp_set.symmetric_difference(number_set_a)
 9 print(_number_set)
10 print("-----第二种方式:用运算符 '^ '求对称差集-----")
11 _number_set_ = number_set_a ^  number_opp_set
12 print(_number_set_)
13 __number_set__ = number_opp_set ^  number_set_a
14 print(__number_set__)

  说明:  

  第6行,使用函数symmetric_difference()求集合number_set_a和集合number_opp_set的相得益彰差集,并赋值给变量number_set。

  第8实施,使用函数symmetric_difference()求集合number_opp_set和集合number_set_a的相辅相成差集,并赋值给变量_number_set。

  第11行,使用运算符 ‘^’
求集合number_set_a和集合number_opp_set的相辅相成差集,并赋值给变量_number_set_。

  第13实施,使用运算符
‘^’ 求集合number_opp_set和集合number_set_a的相得益彰差集,并赋值给变量__number_set__。

  

  运行结果:

1 {1, 2, 3, 4, 5}
2 {1, 3, 5, 7, 9}
3 -----第一种方式:symmetric_difference()求对称差集-----
4 {2, 4, 7, 9}
5 {2, 4, 7, 9}
6 -----第二种方式:用运算符 '^ '求对称差集-----
7 {2, 4, 7, 9}
8 {2, 4, 7, 9}

   
从上述之周转结果会,求少只聚众的对称差集时,哪个集合写于函数中或左右都施行,其结果尚且同。

 

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图