集合语言

集合

咱俩事先多的是,去定义某一个种类的对象、定义某一个成效型函数,有试过定义对象族、函数族?而所谓泛型编程,即大家将所需定义的靶子和函数抽象出来,极大拓宽了利用情形,减弱代码的冗余!
其实,大家可能没有定义过泛型函数,但毫无疑问有拔取过 斯威·夫特(S·wift)标准库中的泛型函数: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()方法。

斯维·夫特(Sw·ift) 标准库中的泛型函数

实则,假设您熟稔函数式编程,那么你对这一个泛型函数应该了如指掌,若是您询问且喜欢上了函数式编程,何不利用
Rx斯威夫特 举办函数响应式编程呢?那里有几篇 RxSwift开发的实战,望有助于我们进一步深刻认识 Rx斯威·夫特(S·wift) 函数响应式开发:

以上皆为实战篇,未来会出其 知识点讲解篇

  由此,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()创制的集合时不可变的,其语法格式分别如下:

属性定义

概念屏幕类型(Nokia/平板电脑),而每种类型,都有例外尺寸的屏幕大小:

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))

}

从那之后,适配工具已支出成功,如若您是应用 斯维夫特开发,那么能够直接将其引入你的类型选择。假若有更好的完结格局,期待你评论告知。

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地图