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