python基础——数字&集合&布尔类型

Python的核心数据类型

内置对象

对象类型	例子
数字	123，3.1415，3+4j,Decimal（小数）,Fraction（分数）
字符串	‘dodo’,“guido’s”,b’a\xolc’
列表	[1,[2,’three’],4]
字典	{‘food’:’apple’,’name’:’dodo’}
元组	(1,’dodo’,’'4,’A’)
文件	fp=open(‘test’,’r’)
集合	set(‘abc’),{‘a’,’b’,’c’}
其余类型	type,None,布尔型
编程单元类型	函数、模块、类
与实现相关的类型	编译的代码堆栈跟踪

 

数字

数字类型的完整工具包括

• 整数和浮点数
• 复数
• 固定精度的十进制数
• 有理分数
• 集合
• 布尔类型
• 无穷的整数精度
• 各类数字内置函数和模块

Python中的数字支持通常的数学运算。例如：+（加）、-（减）、*（乘）、/（除）、**（乘方）等。

数字常量

数字	常量
1234，-24，0，999999999	整数（无穷大小）
1.23，1.0，3.14e-10，4e210，4.0e+210	浮点数
0177，0x9ff，0b101010	python2.6中的八进制、十六进制、二进制常量
0o177，0x199，0b101010	python3.0+的八进制、十六进制、二进制常量
3+4j，3.0+4.0j，3j	复数常量

 

• 整数和浮点数常量：整数以十进制数字的字符串写法出现。浮点数带小数点，也能够加上一个科学计数标志e或E。若是编写一个带有小数点或幂的数字，python会将它变成一个浮点数对象，而且在表达式中时，将启用浮点数（而不是整数）的运算法则。python2.0+有两种整数类型：通常整数（32位）和长整数（无穷精度），而且一个整数能够以l或L结尾，从而强迫其成为长整数。python3.0+把2.0+的两种整数类型合二为一，自动地支持2.0+的长整数类型所拥有的无穷精度，所以整数在程序中再也不用末尾的l或L表示。
• 十六进制数、八进制和二进制数常量：整数能够为十进制（以10为基数）、十六进制（以16位基数）、八进制（以8位基数）和二进制（以2位基数）形式。十六进制数以0x或0X开头，后面接十六进制的数字0~9和A~F（部分大小写）。八进制数以0o或0O开头（即数字“0”和大小写字母“o”），后面接八进制的数字0~7。二进制数以0b或0B开头，后面接二进制数字0~1。
• 复数：python中的复数常量写成实部+虚部的写法，这里虚部是以j或J结尾。其中，实部从技术上讲无关紧要。从内部上看来，复数都是经过一对浮点数来表述的，可是对复数的全部数字操做都会按照复数的运算法则进行。也能够经过内置函数complex(real,imag)来建立复数。
• 编写其余的数字类型：如上表所示，没有包含其余的、更高级的数字类型。其中的一些经过调用导入的模块中的函数来建立（例如：十进制数和分数），其余的一些拥有他们本身的常量语法（如：集合）。

内置数学工具和扩展

python提供了一系列的数字对象工具：

• 表达式操做符：+、-、*、/、>>、**、&等等。
• 内置数学函数：pow、abs、round、int、hex、bin等等。
• 公用模块：random、math等等。

数字主要是经过表达式、内置函数和模块来处理，但它们也拥有不少特定于类型的方法，例如：浮点数有一个as_integer_ratio方法，它对分数数字类型颇有用；is_integer方法能够判断数字是不是一个整数。python3.0+中发布新的bit_length方法，它给出表示对象的值所必须的位数。此外，集合既像一些集合也想一些数字，它也支持这二者的方法和表达式。

Python表达式操做符

表达式是处理数学的最近基本的工具，一般是使用数学符号和操做符好写出来。如让两个数字X和Y相加，写成X+Y,告诉Python对名为X和Y的变量值应用+的操做。像其余语言同样，python的操做符%表示计算余数，<<执行左位移，&计算位与的操做等。其余的一些不全是具有数值特征如is操做符判断对象身份，lambda建立匿名函数。

操做符	描述
yield x	生成器函数发送协议
lambda args:expression	生成匿名函数
x if y else z	三元选择表达式
x or y	逻辑或（只有x为假，才会计算y）
x and y	逻辑与（只有x为真，才会计算y）
not x	逻辑非
x in y,x not in y	成员关系（可迭代对象、集合）
x is y,x is not y	对象实体判断
x < y, x <= y, x > y . x >= y , x == y , x != y	大小比较，集合子集和超集值相等性操做符
x | y	位或，集合并集
x ^ y	位异或，集合对称差
x & y	位与，集合交集
x << y , x >> y	左移或右移y
x + y ,x - y	加法/合并，减法，集合差集
x * y ,x % y,x / y,x // y	乘法/重复，余数/格式化，除法：真除法或floor除法
-x,+x	一元减法，识别
~x	按位求补（取反）
x ** y	幂运算
x[i]	索引（序列、映射及其余）点号取属性运算，函数调用
x[i:j:k]	分片
x(…)	调用（函数、方法、类及其余可调用的）
x.attr	属性引用
(….)	元组，表达式，生成器表达式
[….]	列表，列表解析
{….}	字典、集合、集合字典解析

混合操做所遵循的操做符优先级

像大多数语言同样,python中的操做符表达式像字符串同样结合在一块儿就能编写出不少较复杂的表达式.例如:

A * B + C * D

• 就如数学计算公式同样，各操做符也有优先级，如上表所示同样，表的操做符越靠后的优先级越高
• 上表中位于同一行的表达式在组合的时候优先级是同样的，它将遵循从左到右的组合顺序（除了幂运算，它是从右向左的，还有比较运算时从左到右的运算）。

括号分组的子表达式

若是用括号将表达式各部分进行分组的话，就能够彻底忽略掉优先级的事情，将会超越python的优先级规则。例如：

1. (x + y) * z
2. x + (y * z)

第一种状况下，“+”首先做用于x和y，由于这个子表达式是包含在括号中的。第二种状况下，首先使用“*”（即便这里没括号）。通常来讲，在大型的表达式增长括号是个很好的方法，同时也是编写程序的良好习惯，它不只仅强制按照你想要的顺序进行计算，更是增长了程序的可读性。

混合类型自动升级

除了表达式中混合操做符之外，也可以混合数字的类型。例如，能够把一个整数与一个浮点数相加：

40 + 3.14

在混合表达式中，python首先将被操做的对象转换成其中最复杂的对象类型，而后再对相同类型的操做对象进行数学运算。python划分数字类型的复杂度：整数比浮点数简单，浮点数比复数简单。能够手动调用内置函数来强制转换类型：

>>> int(3.14159) #浮点数强制转换为整数
3
>>> float(3)#整数强制转换为浮点数
3.0
>>>

值得注意的是：这些混合类型转换仅仅在数字类型（整数和浮点数）混合到一个表达式中的时候才适用，这包括那些适用数字和比较操做符的表达式。python不会再其余的类型之间进行转换，如一个字符串和一个整数相加，将会发生错误，除非手动转换其中某一个类型。

变量和基本的表达式

• 变量在他第一次赋值时建立
• 变量在表达式中使用将被替换为它们的值
• 变量在表达式中使用之前必须已赋值
• 变量像对象同样不须要在一开始进行声明

>>> a = 3 #变量自动建立
>>> b = 4
>>> a + 1,a - 1 #至关于（3+1)，（3-1）
(4, 2)
>>> b * 3,b / 2#至关于(4*3)，（4/2)
(12, 2.0)
>>> a % 2,b ** 2#至关于（3%2），（4**2）
(1, 16)
>>> 2 + 4.0,2.0 ** b #混合表达式
(6.0, 16.0)
>>> c * 2 #变量c未赋值将会报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'c' is not defined
>>> b / 2 + a #至关于（4/2）+ 3
5.0
>>> print(b / (2.0 + a))#至关于4/(2.0+3)
0.8
>>> num = 1 / 3.0
>>> num #打印至屏幕
0.3333333333333333
>>> print(num) #输出至屏幕
0.3333333333333333
>>> '%e' % num #字符串格式化表达式
'3.333333e-01'
>>> '%4.2f'%num#字符串格式化浮点数
'0.33'
>>> '{0:4.2f}'.format(num)#字符串format方法格式化浮点数
'0.33'
>>> 1 < 2 #比较大小
True
>>> 2.0 >= 1#混合数字比较大小
True

除法:传统除法、floor除法和真除法

python2.0+和python3.0+的除法工做方式略有差别，实际上有3种类型的除法，有两种不一样的操做符，其中一种操做符在python3.0+中有变化：

• X / Y :传统除法和真除法。在2.0+，这个操做对于整数会省去小数部分，对于浮点数会保持小数部分。在3.0+中将会变成真除法（不管任何类型都会保持小数部分）。
• X // Y ：Floor除法。在2.0+和3.0+中均能使用。这个操做不考虑操做对象的类型，总会省略掉结果的小数部分，剩下的能整除的整数部分。

真除法是为了最初传统除法的结果依赖操做数类型（所以，其结果在python这样的动态类语言中很难预料）这一现象。这一限制在python3.0+中取消了传统除法：/ 和 // 操做符在3.0+中分别实现真除法和floor除法。

python3.0+:

>>> 10 / 4 
2.5 
>>> 10 // 4
2
>>> 10 / 4.0
2.5
>>> 10 // 4.0
2.0

python2.0+

>>> 10 / 4 
2 
>>> 10 // 4
2
>>> 10 / 4.0
2.5
>>> 10 // 4.0
2.0

注意:3.0+中,//的结果的数据类型老是依赖于操做数的类型:若是操做数中有一个是浮点数,结果就是浮点数;不然,结果是一个整数。

floor除法

floor除法把结果向下舍入，对负数有效。

>>> import math
>>> math.floor(2.5)
2
>>> math.floor(-2.5)
-3
>>> math.trunc(2.5)
2
>>> math.trunc(-2.5)
-2
>>> 5 / 2,5 / -2
(2.5, -2.5)
>>> 5 // 2, 5 // -2
(2, -3)
>>> 5 / 2.0,5 / -2.0
(2.5, -2.5)
>>> 5 // 2.0,5 // -2.0
(2.0, -3.0)

复数

在python中，复数是不一样的核心对象类型。复数表示为两个浮点数（实部+虚部）并接在虚部增长了j或J的后缀。

>>> 1j * 1J
(-1+0j)
>>> 2 + 1j * 3
(2+3j)
>>> (2 + 1j) * 3
(6+3j)

复数容许咱们分解出他们的实部和虚部做为属性，并支持全部通常的数学表达式，而且能够经过标准的cmath模块（复数版的标准数学模块）中的工具进行处理。

十六进制、八进制、二进制记数

>>> 0o1,0o20,0o377 #八进制
(1, 16, 255)
>>> 0x01,0x10,0xff #十六进制
(1, 16, 255)
>>> 0b1,0b10000,0b11111111 #二进制
(1, 16, 255)
>>> oct(64),hex(64),bin(64) #十进制转换为八进制、十六进制、二进制
('0o100', '0x40', '0b1000000')
>>> int('64'),int('100',8),int('40',16),int('1000000',2) #字符串转换为整数（十进制）
(64, 64, 64, 64)
>>> int('0x40',16),int('0b1000000',2) 
(64, 64)
>>> eval('64'),eval('0o100'),eval('0x40'),eval('0b1000000') #字符串转换为十进制，速度很慢，不建议使用
(64, 64, 64, 64)

python默认输出显示为10进制，但也能够经过内置函数oct()、hex()、bin()转换十进制数。

十进制转十六进制、八进制、二进制格式化字符串：

>>> '{0:o},{1:x},{2:b}'.format(64,64,64)
'100,40,1000000'
>>> '%o,%x,%X' % (64,255,255)
'100,ff,FF'

位操做

除了通常的数学运算（加法、减法等），python也支持C语言中的大多数数学表达式。这包括那些把整数当作二进制位串对待的操做，例如，还能够实现位移和布尔操做：

>>> x = 1         #二进制0001
>>> x << 2        #左移2位：0100
4
>>> x | 2         #布尔操做或： 0001 or 0010 获得 0011
3
>>> x & 1         #布尔操做与：0001 and 0001 获得 0001
1

在3.0+中，整数的bit_length方法也容许咱们查询以位二进制表示一个十字的值所须要的位数。经过bin和内置函数len获得二进制字符串的长度，而后在减去2，能够获得一样的效果，但这种方法效率较低。

>>> x = 99
>>> bin(x),x.bit_length()
('0b1100011', 7)
>>> bin(256),(256).bit_length()
('0b100000000', 9)
>>> len(bin(256)) - 2
9

其余的内置数学工具

除了核心对象类型之外，Python还支持用于数字处理的内置函数和内置模块。例如，内置函数pow和abs，分别计算幂和绝对值。还有一些内置math模块（包含在C语言中math库中的绝大多数工具）的例子并有一些实际中的内置函数。

>>> import math
>>> math.pi,math.e
(3.141592653589793, 2.718281828459045)
>>> math.sin(2 * math.pi / 180)
0.03489949670250097
>>> math.sqrt(144),math.sqrt(2)
(12.0, 1.4142135623730951)
>>> pow(2,4),2 ** 4
(16, 16)
>>> abs(-42.0),sum((1,2,3,4))
(42.0, 10)
>>> min(3,1,2,4),max(3,1,2,4)
(1, 4)
>>> math.floor(2.567),math.floor(-2.567)
(2, -3)
>>> math.trunc(2.567),math.trunc(-2.567)
(2, -2)
>>> int(2.567),int(-2.567)
(2, -2)
>>> round(2.567),round(2.467),round(2.567,2)
(3, 2, 2.57)
>>> '%.1f' % 2.567,'{0:.2f}'.format(2.567)
('2.6', '2.57')
>>> (1 / 3),round(1 / 3,2),('%.2f'%(1 / 3))
(0.3333333333333333, 0.33, '0.33')
>>> math.sqrt(144)
12.0
>>> 144 ** .5
12.0
>>> pow(144,.5)
12.0
>>> math.sqrt(1234567890)
35136.41828644462
>>> 1234567890 ** .5
35136.41828644462
>>> pow(1234567890,.5)
35136.41828644462
>>> import random
>>> random.random()
0.7979668825813387
>>> random.random()
0.45684004916496834
>>> random.randint(1,10)
3
>>> random.randint(1,10)
2
>>> random.choice([1,2,3,4,5,6,7,8,9,10])
5
>>> random.choice([1,2,3,4,5,6,7,8,9,10])
7

小数数字

从功能上来讲，小数对象就像浮点数，只不过它们有固定的位数和小数点，所以小数是有固定的进度的浮点值。由于实际运用中用来存储数值的空间有限，相对于浮点数类型来讲缺少精确性，但能带来必定性能提高。例如钱的总数，小数类型对表现固定精度的特性以及对实现更好的数字精度是一个理想工具。

>>> 0.1 + 0.1 + 0.1 - 0.3
5.551115123125783e-17
>>> print(0.1 + 0.1 + 0.1 - 0.3)
5.551115123125783e-17
>>> from decimal import Decimal
>>> Decimal('0.1') + Decimal('0.1') + Decimal('0.1') - Decimal('0.3')
Decimal('0.0')
>>> Decimal('0.1') + Decimal('0.10') + Decimal('0.10') - Decimal('0.30')
Decimal('0.00')

正如显示这样，浮点数结果接近0，却没有足够的位数去实现这样的精度，而打印结果会显示一个用户友好的显示格式但不能彻底解决问题，由于与硬件相关的浮点运算在精度方面有内在的缺陷。使用小数对象，结果可以改正。咱们可以经过调用在decimal模块中的Decimal的构造函数建立一个小数对象，并传入一个字符串，这个字符串有咱们但愿在结果中显示的小时位数。当不一样精度的小数在表达式中混编时，Python结果会自动升级匹配小数位数最多的数字对象。

设置全局精度

decimal模块中的其余工具能够用来设置全部小数数值的精度，设置错误处理等。如一个上下文对象容许指定精度和舍入模式。在处理货币的应用程序特别有用。

>>> import decimal
>>> decimal.Decimal(1)/decimal.Decimal(7)
Decimal('0.1428571428571428571428571429')
>>> decimal.getcontext().prec = 4
>>> decimal.Decimal(1)/decimal.Decimal(7)
Decimal('0.1429')

可使用上下文管理器语句来从新设置临时精度：

>>> import decimal
>>> decimal.Decimal('1.00')/decimal.Decimal('3.00')
Decimal('0.3333333333333333333333333333')
>>> with decimal.localcontext() as ctx:
...     ctx.prec = 2
...     decimal.Decimal('1.00') / decimal.Decimal('3.00')
...
Decimal('0.33')
>>> decimal.Decimal('1.00')/decimal.Decimal('3.00')
Decimal('0.3333333333333333333333333333')

分数类型

python引入一种新的数字类型——分数，它实现了一个有理数对象。他明确地保留一个分子和分母，从而避免浮点数学的某些不精确性和局限性。

>>> from fractions import Fraction
>>> x = Fraction(1,3)
>>> y = Fraction(4,6)
>>> x
Fraction(1, 3)
>>> y
Fraction(2, 3)
>>> print(y)
2/3
>>> x + y
Fraction(1, 1)
>>> x - y
Fraction(-1, 3)
>>> x * y
Fraction(2, 9)
>>> Fraction('.25')
Fraction(1, 4)
>>> Fraction('1.25')
Fraction(5, 4)
>>> Fraction('0.25') + Fraction('1.25')
Fraction(3, 2)

转换和混合类型

为了支持分数转换，浮点数对象有个方法，可以产生他们的分子和分母比。分数有个from_float方法，而且float接受一个Fraction做为参数。尽管能够把浮点数转换为分数，在某些状况下，这么作的时候会有不可避免的精度损失，由于这个数字在其最初的浮点形势下是不精确的。当须要的时候，咱们能够经过限制最大分母值来简化这样的结果。

>>> from fractions import Fraction
>>> (2.5).as_integer_ratio()
(5, 2)
>>> f = 2.5
>>> z = Fraction(*f.as_integer_ratio())
>>> z
Fraction(5, 2)
>>> x = Fraction(1,3)
>>> x + z
Fraction(17, 6)
>>> float(z)
2.5
>>> float(x + z)
2.8333333333333335
>>> 17 / 6
2.8333333333333335
>>> Fraction.from_float(1.75)
Fraction(7, 4)
>>> Fraction(*(1.75).as_integer_ratio())
Fraction(7, 4)
>>> x
Fraction(1, 3)
>>> x + 2
Fraction(7, 3)
>>> x + 2.0
2.3333333333333335
>>> x + (1. / 3)
0.6666666666666666
>>> x + (4. / 3)
1.6666666666666665
>>> x + Fraction(4,3)
Fraction(5, 3)
>>> 4.0 / 3
1.3333333333333333
>>> (4.0 / 3).as_integer_ratio()
(6004799503160661, 4503599627370496)
>>> x
Fraction(1, 3)
>>> a = x + Fraction(*(4.0 / 3).as_integer_ratio())
>>> a
Fraction(22517998136852479, 13510798882111488)
>>> 22517998136852479 / 13510798882111488
1.6666666666666665
>>> a.limit_denominator(10)
Fraction(5, 3)

集合

集合（set）是一些惟一的，不可变的对象的无序集合（collection），这些对象支持与数学集合理论相对应的操做。根据定义，一个项在集合中只能出现一次，无论将它添加了多少次。它具备列表和字典对象的某些共同行为。集合能够迭代的，能够根据须要增加或缩短，而且包含各类对象类型。一个集合的行为很像一个无值的字典的键，它支持额外的操做。因为集合是无序的，而且不会把键匹配到值，他们既不是序列也不是映射类型，它们自成一体的类型。集合本质上具备基本的数学特性。

集合的建立：

>>> x = set('abcde')
>>> y = set('bdxyz')
>>> x
{'b', 'a', 'd', 'e', 'c'}
>>> y
{'b', 'z', 'd', 'x', 'y'}
>>> z = {}
>>> type(z)
<class 'dict'>
>>> m = {1,}
>>> type(m)
<class 'set'>

经过表达式支持通常的数学集合运算，必须经过建立集合后才能使用这些工具，不能进行+，*，**，/等操做。

>>> 'e' in x #判断e是否为x的成员
True
>>> x - y #在x中不存在y的成员，既x中不一样于y的成员
{'a', 'e', 'c'}
>>> x | y #或，x和y合并，能够理解为x中或y中都存在的成员
{'a', 'z', 'e', 'c', 'x', 'y', 'b', 'd'}
>>> x & y # 与，x和y都相同的成员
{'b', 'd'}
>>> x ^ y #异或， x和y中剔除两个集合均有的成员
{'z', 'a', 'e', 'c', 'x', 'y'}
>>> x > y , x < y #判断x是否为y的父集，判断x是否为y的子集
(False, False)

除了表达式，集合对象还有对应的操做方法，以及更多的支持改变集合的方法，集合add方法插入一个项目，update是按位置求并集，remove根据值删除一个项目。

>>> x
{'b', 'a', 'd', 'e', 'c'}
>>> y
{'b', 'z', 'd', 'x', 'y'}
>>> z = x.intersection(y) #与x&y相同
>>> z
{'b', 'd'}
>>> z.add('SPAM') #插入成员
>>> z
{'b', 'd', 'SPAM'}
>>> z.update(set(['X','Y'])) #合并另一个集合到z中
>>> z
{'b', 'Y', 'd', 'X', 'SPAM'}
>>> z.remove('b') #删除成员b
>>> z
{'Y', 'd', 'X', 'SPAM'}

做为可迭代的容器，集合也能够用len、for循环和列表解析这样的操做中。而集合是无序的，因此不支持索引和分片操做。

>>> for item in set('abc'):print(item * 3)
...
bbb
aaa
ccc

集合基于方法的对应形式每每对任务可迭代的类型也有效：

>>> S = set([1,2,3])
>>> S | set([3,4]) #两个集合
{1, 2, 3, 4}
>>> S | [3,4]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for |: 'set' and 'list'
>>> S.union([3,4])  #此方法却容许任何可迭代的类型
{1, 2, 3, 4}
>>> S.intersection((1,3,5)) #容许元组类型
{1, 3}
>>> S.issubset(range(-5,5))#容许range
True

不可变限制和冻结集合

集合是强大而灵活的对象，但它有一个限制，必定要注意：集合只能包含不可变的对象类型。列表和字典等可变类型不能嵌入到集合中，不可变的元组类型能够嵌入。一样，不能嵌入到其余集合中，若是须要在另外一个集合中存储一个集合，能够像调用set同样调用frozenset，可是frozenset穿件一个不可变的集合，这个集合不可修改却能够嵌套到其余集合中。

>>> s = {1.23}
>>> s
{1.23}
>>> type(s)
<class 'set'>
>>> s.add([1,2,3])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
>>> s.add({'a':1})
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'dict'
>>> s.add((1,2,3))
>>> s
{1.23, (1, 2, 3)}
>>> s | {(4,5,6),(1,2,3)}
{1.23, (4, 5, 6), (1, 2, 3)}
>>> (1,2,3) in s
True
>>> (1,4,3) in s
False

python3.0+的集合解析

同列表解析同样，集合也能够解析，不一样的是编写的是花括号而不是列表的方括号。几何解析运行一个循环并在每次迭代时收集一个表达式结果，经过一个循环变量来访问当前的迭代值以用于集合表达式中，结果是经过运行代码建立一个新的集合。

>>> {x ** 2 for x in [1,2,3,4]}
{16, 1, 4, 9}
>>> {x for x in 'spam'} #与set{’spam‘}相同
{'p', 'a', 's', 'm'}
>>> {c * 4 for c in 'spam'} #解析结果保存为集合对象
{'mmmm', 'pppp', 'ssss', 'aaaa'}
>>> {c * 4 for c in 'spamham'}
{'mmmm', 'hhhh', 'pppp', 'ssss', 'aaaa'}
>>> S = {c * 4 for c in 'spam'}
>>> S | {'mmmm','xxxx'}
{'mmmm', 'pppp', 'ssss', 'aaaa', 'xxxx'}
>>> S & {'mmmm','xxxx'}
{'mmmm'}

集合的用途

集合操做有各类各样常见的用途，其中一些比数学更加实用。因为成员项在集合中只能存储一次，集合（set）能够用来把重复的项从其余集合中过滤掉。直接把序列转换为一个集合，而后再转换回来便可（由于集合是可迭代的，这里的list调用对其有效）：

>>> L = [1,2,1,3,2,4,5]
>>> set(L)
{1, 2, 3, 4, 5}
>>> L = list(set(L))
>>> L
[1, 2, 3, 4, 5]

在处理教导的数据集合的时候，如数据库查询结果。两个集合的交集包含了两个领域中共有的对象。

>>> engineers = {'bob','sue','ann','vic'} 
>>> managers = {'tom','sue'}
>>> 'bob' in engineers #判断bob是否为工程师
True
>>> engineers & managers #既是工程师又是管理者
{'sue'}
>>> engineers | managers #管理和工程师总人员
{'sue', 'tom', 'vic', 'ann', 'bob'}
>>> engineers - managers #非管理的工程师
{'ann', 'bob', 'vic'}
>>> managers - engineers#非工程师的管理
{'tom'}
>>> {'bob','sue'} < engineers #bob，sue是工程师的子集
True
>>> (managers | engineers) > managers #全部人的集合是管理的父级
True
>>> managers ^ engineers #只有一个职位的集合
{'ann', 'tom', 'bob', 'vic'}
>>> (managers | engineers) - (managers ^ engineers) #在全部人的集合里找出兼职人员
{'sue'}

 

布尔型

对于python的布尔型有些争论，bool本来是一个数字，由于它有两个值True和False,不过是整数1和0以不一样的形式显示后的定制版本而已。

Python现在正式地有了明确的布尔型数据类型，叫bool，其值为True和False，而且其值True和False是预约义的内置变量名。它们做为关键字True和Fasle显示的，而不是数字1和0。例如：一个无限循环如今可以编写成while True：而不是while 1：。相似的，经过使用flag = False，能够更清楚的设置标志位。

python还有对于其余实际的用途，可以将True和False看作是预约义的设置为整数1和0的变量。

>>> type(True)
<class 'bool'>
>>> isinstance(True,int)  #True为int的实例
True
>>> True == 1 #相同的值
True
>>> True is 1  #不一样的对象
False
>>> True or False
True
>>> True + 4 #True仅仅是定制了显示格式的整数1
5