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