python基本數據類型

python可變和不可變對象

python中所有的數據都是圍繞對象來構建，這些對象可分為兩類：可變對象和不可變對象。當變量被賦值，變量中存放的是對象引用（可以理解為C語言中的指針），指向內存中存放該對象的區域。
對于不可變對象而言，對象本身不可以改變（也可以理解為對象的值不可以改變），可以改變的是指向該對象的引用。
對于可變對象而言，對象本身的內容可以改變，指向該對象的引用不變~

不可變對象

不可變對象有：int，string，float，tuple...
不可變對象一旦創建，該對象本身就不能改變。若變量的值需要改變，只能重新創建對象，并改變變量的引用，如下圖所示：

原來的對象不再被引用，會被當做垃圾回收~，可以使用 id() 函數做如下驗證：

>>> abc = 1
>>> id(abc)
1456500192

>>> abc=2
>>> id(abc)
1456500224

可變對象

可變對象有：list，dict...
可變對象的內容可以改變，而變量的引用不會發生改變，如下圖所示：

可以看到，對于可變對象，變量值的變化不需要重新創建對象，在python中可變對象往往是容器對象（即一個對象包含對其他對象的引用）

>>> abc=['a','b']
>>> id(abc)
2768889238408

>>> abc+=['c']
>>> id(abc)
2768889238408
>>> abc
['a', 'b', 'c']

在python中可以通過 is 判斷 兩個變量是否引用自同一個對象，示例如下：

>>> a = 1
>>> b = 1
>>> a is b
True

>>> c = 2
>>> a is c
False

由于python中存在小整數對象池，[-5,257)范圍內的整數對象，python解釋器不會重復創建~

python基本數據類型

數字

python中的數字有很多種，包括：整型，長整型，布爾，浮點，復數。數字一經定義，不可更改（不可變對象）

-- 整型

python中的整型用八進制，十進制，十六進制表示：

# 環境為 python3
>>> 1                # 默認為十進制
1

>>> oct(8)        # 八進制，"0o" 為前綴，python2.7中的前綴為"0"，10表示為'010'
'0o10'

>>> hex(10)      # 十六進制，前綴為0X或0x
'0xa' 

數據類型轉換，可使用 int() 轉換為整型：

>>> a = '12'
>>> b = int(a)       # 字符串類型轉換為整型
>>> b
12

>>> int(1.2)          # 浮點數轉換為整型，小數部分會被略去
1

--長整型

python2中的整型有長度的限制，32位系統上長度為32位，取值范圍為-2**31～2**31-1；64位系統上長度為64位，取值范圍為-2**63～2**63-1。
python3中的長整型沒有長度限制，可以無限大，但是這受到內存大小的限制（就是不可能無限大）

# 環境為 python2.7
>>> a = 1              # 定義整型
>>> a   
1
>>> b = 2L            # 定義長整型
>>> b
2L

>>> a = 9999999999999999999999999999999999
>>> a
9999999999999999999999999999999999L

通過在數字后面加上 大寫L 或者 小寫l 表示長整型；在定義整型時，若數據的位數超過了限制范圍，則會默認轉換為長整型

Tip：在python3中，整型和長整型歸為一類：整數類型 int

--布爾型bool

True 和 False，或者用1和0表示：1 表示True，0表示False~
在條件判斷時，若條件語句返回為非零數值、非空字符串、非空list等，均表示為True，否則表示為False。

if []:
    print('OK')
else:
    print('NO')

結果輸出：
NO

while 1:                 # 等效于while true，無限循環
    print('hello world')

--浮點數float

python中的浮點數也就是小數，可用普通的方式表示，例如：

1.23，3.56 ...

也可以使用科學計數法表示：

1.23*10^9就是1.23e9，或者12.3e8         # 小數位數太多時，用科學計數法表示~
0.000012可以寫成1.2e-5

?

整數和浮點數在計算機內部存儲的方式是不同的，整數運算是精確的，而浮點數運算則可能會有
四舍五入的誤差。

--復數complex

復數由實數部分和虛數部分組成，一般形式為x＋yj，其中的x是復數的實數部分，y是復數的虛數部分，這里的x和y都是實數。虛數部分的字母j大小寫都可以~

>> a = 1.3 + 2.5j
>> a
(1.3+2.5j)
>> type(a)
<class 'complex'>

數值的運算這里不做介紹

字符串

字符串是一個有序的字符集合，且字符串為不可變對象，一經創建，不可更改~

--創建字符串

python字符串的創建可以使用單引號，也可以使用雙引號

str1 = 'Hello'
str2 = "World"

單引號或雙引號前面加 r ，可以使字符串中的特殊字符失效，按原樣輸出：

>>> print('abc\tde')
abc     de
>>> print(r'abc\tde')
abc\tde

當 r 與 unicode字符串一起使用時，u 需要放在 r 的前面

str1 = ur'abc\tde

--常用字符串運算

var1 = 'Hello'; var2 = 'Kitty'

# 字符串拼接
var1 + var2       # 輸出：'HelloKitty'

# 重復輸出
var1 * 3            # 輸出：'HelloHelloHello'

# 成員運算，判斷字符是否存在于指定字符串中
't' in var2          # 輸出：True，存在返回True

'a' not in var2   # 輸出：True，不存在返回True

# 原始字符串輸出，字符串中的轉移字符失效，在引號前使用 R 或 r 均可~
print(r'\t\n')     # 輸出：\t\n
print(R'\t\n')    # 輸出：\t\n

--三引號（triple quotes）使用

python中的三引號，用于跨行輸出，例如要輸出如下語句：

line1---
line2---
line3---

方式一：

>>> str1 = "line1---\nline2---\nline3---"
>>> str1
'line1---\nline2---\nline3---'
>>> print(str1)
line1---
line2---
line3---

方式二（3對單引號還是3對雙引號，結果一樣）Pycharm環境：

str2 = '''line1---
line2---
line3---'''
print(str2)

輸出結果：
line1---
line2---
line3---

3對雙引號""" """ 或者 3對單引號 ''' ''' 還可以表示多行注釋（其中 # 為當行注釋）：

class Abc():
  """
    多行注釋
    多行注釋
    多行注釋
    """
  def __init__(self):
      pass
  def say_hello(self):
      # 單行注釋
      # 單行注釋
      return 'hello'

--字符串常用操作

----字符串索引

>>> my_str = 'hello'
>>> my_str[4]
'o'

>>> my_str[-3]        # 最后第3個字符
'l'

----截取字符串

>>> my_str = 'hello'
>>> my_str[1:4]        # 截取其中的 第2個到第5個 字符
'ell'

>>> my_str[:4]
'hell'                          # 截取其中的 第1個到第4個 字符，不包括 my_str[4]

>>> my_str[3:]
'lo'                            # 截取其中的 第4個到最后1個字符

>>> my_str[:-3]
'he'                           # 截取第1個到最后第3個字符（不包括最后第3個）

>>> my_str[-3:-1]
'll'                            # 截取倒數第3個到倒數第1個字符（不包括倒數第一個）

>>> my_str[-3:]
'llo'                           # 截取倒數第3個到最后一個字符

>>> my_str[::-1]
'olleh'                       # 生成一個與原字符串順序相反的字符串

----切割、合并字符串
按字符串中的字符，切割字符串

>>> my_str = 'a,b,c,d,e'
>>> my_str.split(',')
['a', 'b', 'c', 'd', 'e']             # 返回列表

合并列表或元組中的元素成字符串

>>> ':'.join(['a', 'b', 'c', 'd', 'e'])     # 列表
'a:b:c:d:e'

>>> '#'.join(('a', 'b', 'c', 'd', 'e'))   元組
'a#b#c#d#e'

----其他操作

>>> my_str = ' abc '
>>> len(my_str)       # 獲取字符串長度
5

# 移除字符串兩邊空白
>>> my_str.strip()
'abc'

# 移除字符串左邊空白
>>> my_str.lstrip()
'abc '

# 移除字符串右邊空白
>>> my_str.rstrip()
' abc'

# 查找字符
>>> my_str.index('b')    # 若字符串中沒有該字符，會返回報錯信息
2

# 查找字符串
S.find(substr, [start, [end]])     # [start, [end]] 指定起始位置和結束位置
>>> my_str.find('bc')
2                                 # 返回查找到的字符串的第一個字符的索引，若沒有找到，返回-1

# 搜索和替換
S.replace(oldstr, newstr, [count])   # count 指定替換次數
>>> my_str.replace('b','B',2)
'aBc aBc abc'

>>> my_str = 'abCD efg'
>>> my_str.lower()               # 都轉為小寫
'abcd efg'
>>> my_str.upper()              # 都轉為大寫
'ABCD EFG'
>>> my_str.swapcase()       # 大小寫互換
'ABcd EFG'
>>> my_str.capitalize()        # 首字母大寫
'Abcd efg'

使用 str() 將其他類型的數據轉換成字符串

>>> str(123456)
'123456'
>>> str(['a','b','c'])
"['a', 'b', 'c']"

列表

列表兩邊使用 [] 包含，[] 中可以存放多種類型的數據，每個數據之間使用逗號（，）分隔。列表數據可變對象~

--創建列表

方式一：my_lst1 = ['a', 1, 2]
方式二：my_lst2 = list('abc')
方式三：my_lst3 = list(['a', 1, 2])

創建空列表：

my_lst = []
my_lst = list()

--列表常用操作

# 索引
>>> my_lst = ['a','b','c','d']
>>> my_lst[2]
'c'

# 搜索列表元素
>>> my_lst.index('c')
2                           # 返回index，若沒有對應元素，返回報錯信息

# 列表長度
>>> len(my_lst)
4

# 列表的切片，使用方式與字符串類似，不做意義注釋
>>> my_lst = ['a','b','c','d']
>>> my_lst[1:3]
['b', 'c']
>>> my_lst[0:3:2]     # 最后一個參數為步長
['a', 'c']
>>> my_lst[::2]         # 整個列表從開頭到結尾每隔 2 個元素取一個
['a', 'c']
>>> my_lst[:3]
['a', 'b', 'c']
>>> my_lst[2:]
['c', 'd']
>>> my_lst[:-2]
['a', 'b']
>>> my_lst[-3:-1]
['b', 'c']
>>> my_lst[-3:]
['b', 'c', 'd']
>>> my_lst[::-1]
['d', 'c', 'b', 'a']

# 追加元素（append追加）
>>> my_lst = [1,2,3]
>>> my_lst.append(4)         # [1, 2, 3, 4]

# 追加元素（extend追加）
>>> my_lst = [1,2,3]
>>> my_lst.extend([4,5])     # [1, 2, 3, 4, 5]

# append與 extend 的區別在于，append 直接追加對象，extend 會迭代對象中的每個元素，然后進行追加
>>> my_lst = [1,2,3]
>>> my_lst.append([4, 5])     # [1, 2, 3, [4, 5]]
>>> my_lst = [1,2,3]
>>> my_lst.extend([4, 5])      # [1, 2, 3, 4, 5]

# 指定索引位置插入元素
>>> my_lst = [1,2,3]
>>> my_lst.insert(-1, 'a')       # 最后一個元素前面插入
>>> my_lst
[1, 2, 'a', 3]
>>> my_lst.insert(0, 0)        # 第一個元素前面插入
>>> my_lst
[0, 1, 2, 'a', 3]

# 刪除元素
>>> a = my_lst.pop()     # 不加參數默認刪除最后一個元素，并將刪除元素返回
>>> my_lst
[0, 1, 2, 'a']
>>> a
3
# pop() 指定參數，通過所應刪除
>>> my_lst.pop(1)
1
>>> my_lst
[0, 2, 'a']

# 刪除列表中的指定值 li.remove('aa')
>>> my_lst.remove('a')     # 若列表中沒有該元素，返回報錯信息
>>> my_lst
[0, 2]

# 通過 索引和切片 刪除元素
>>> my_lst = ['a', 'b', 'c', 'd']
>>> del my_lst[0:2]
>>> my_lst
['c', 'd']

# 清空列表
>>> my_lst.clear()
>>> my_lst
[]

# 列表元素出現的次數
>>> my_lst = ['a', 'b', 'c', 'd', 'a']
>>> my_lst.count('a')
2
>>> my_lst.count('g')
0

# 翻轉列表
>>> my_lst = ['a', 'b', 'c', 'd']
>>> my_lst.reverse()
>>> my_lst
['d', 'c', 'b', 'a']

----列表中的 in 操作（返回布爾值）
判斷元素是否存在于列表中~

>>> my_lst = ['a', 'b', 'c', 'd']
>>> print('a' in my_lst)
True
>>> print('z' in my_lst)
False

--循環列表

這里僅介紹 for 循環

my_lst = ['a', 'b', 'c', 'd', 'e']
for i in my_lst:
    print(i)

for i in range(len(my_lst)):
    print(my_lst[i])

以上兩種方式的輸出結果一致~

可以使用 enumerate 函數連同 index 一起輸出，首先了解下 enumerate：

my_lst = ['a', 'b', 'c', 'd', 'e']
for i in enumerate(my_lst):
    print(i)

輸出：
(0, 'a')
(1, 'b')
(2, 'c')
(3, 'd')
(4, 'e')

# 所以可以這樣使用：
my_lst = ['a', 'b', 'c', 'd', 'e']
for index, value in enumerate(my_lst):
    print('%s --> %s' % (index, value))

輸出：
0 --> a
1 --> b
2 --> c
3 --> d
4 --> e

Tip：enumerate的第二個參數，可改變起始序號，可以自己嘗試~

元組和字符串可通過 list() 轉換成列表，這也是初始化列表的方法之一

lst_1 = list((1,2,3))     # [1, 2, 3]
lst_2 = list('abc')        # ['a', 'b', 'c']

來自字典的轉換

>>> my_dict = {'a': 1, 'b': 2, 'c': 3}
>>> list(my_dict)                  # 將字典中的 keys 轉為 list
['a', 'b', 'c']
或者
>>> list(my_dict.keys())
['a', 'b', 'c']

>>> list(my_dict.values())     # 將字典中的 values 轉為list
[1, 2, 3]

元組

元組與列表類似，使用 () 包含其元素；元組與列表的最大區別在于，元組為不可變對象，一經創建，其內容無法更改。

--創建元組

tup_1 = ('a', 'b', 1, 2)
tup_2 = (1, 2, 3, 4)
tup_3 = 'a', 'b', 'c', 'd'

創建空元組

tup_4 = ()

創建僅包含一個元素的元組：

>>> tup_4 = (2)   # 這樣創建 tup_4 會被當做 int 類型，而不是 tuple；
>>> type(tup_4)
<class 'int'>

# 正確創建方式
>>> tup_4 = (2,)
>>> type(tup_4)
<class 'tuple'>

--元組常用操作

元組的索引操作（tup[index]），搜索元素（tup.index()），獲取長度（len(tup)），切片（tup[1:3]），元素出現的次數（tup.count()）等 這些操作與 list 一致~

因為 tuple 為不可變對象，所以不支持 append，insert，extend，pop，remove，del，clear 等操作

>>> tup_1 = (1,2,3)
>>> tup_1[1] = 4
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

tuple 不支持 sort 和 reverse 操作，支持 sorted 操作，返回類型為列表

>>> tup_1 = (2,3,90,6,234,1,53,2)
>>> sorted(tup_1)
[1, 2, 2, 3, 6, 53, 90, 234]

tuple同樣也支持 in 操作：

>>> my_tup = ('a','b','c','d')
>>> print('a' in my_tup)
True
>>> print('z' in my_tup)
False

上述對 list 的循環操作，同樣也適用于tuple~

tuple() 可應用于 list，字符串，將其轉換成 tuple 類型的數據

tup_1 = tuple("abcdefg")      # ('a', 'b', 'c', 'd', 'e', 'f', 'g')
tup_2 = tuple([1,2,3,4,5])     # (1, 2, 3, 4, 5)

來自字典的轉換，與list類似

list(my_dict.keys())  或者 list(my_dict)    # 將字典中的 keys 轉成tuple
list(my_dict.values())                              # 將字典中的 values 轉成tuple              

字典

字典也屬于可變對象，使用一對花括號 {} 包含元素，字典中的每個元素為一個 key->value對，key和value之間使用冒號 : 分割，每個元素之間使用逗號隔開~

Tip：dict中的key必須是不可變對象，或者說是可hash類型（例如元組可以作為key），value可以是可變對象，也可以是不可變對象~

--創建字典

d1 = {'a': 1, 'b': 2, 'c': 3}
d2 = dict({'a': 1, 'b': 2, 'c': 3})
d3 = dict(a=1, b=2, c=3)    # 這種方式定義字典，key 只能是字符串類型
d4 = dict([('a', 1), ('b', 2), ('c', 3)])

# 初始化字典
d6 = {}.fromkeys(['a', 'b'], None)  # {'a': None, 'b': None}
d7 = {}.fromkeys(['a','b'], [1, 2])   # {'a': [1, 2], 'b': [1, 2]}

創建空字典：

d1={}; 
d2=dict(); 

字典的循環（d.keys，d.values， for i in d取出的是key）
dict.get(key)
dict.setdefault()

--字典常用操作

# 獲取字典元素
>>> my_dict = {'a': 1, 'b': 2, 'c': 3}
>>> my_dict['b']
2

# 使用 get 方法獲取，若沒有指定的 key 返回為 None
>>> my_dict.get('b')
2

# 當只有一個參數時，setdefault的作用域get類似，查找指定的key，若沒有返回None。當指定的key沒有時，不光會返回 None ，還會在字典中添加該 key ，且值為None
>>> my_dict.setdefault('c')
3
>>> my_dict.setdefault('d')
>>> my_dict
{'a': 1, 'b': 2, 'c': 3, 'd': None}

# 添加的 key，也可以指定 value
>>> my_dict.setdefault('e', 5)
5
>>> my_dict
{'a': 1, 'b': 2, 'c': 3, 'd': None, 'e': 5}

# 添加操作
>>> my_dict = {'a': 1, 'b': 2, 'c': 3}
>>> my_dict['d'] = 4
>>> my_dict
{'a': 1, 'b': 2, 'c': 3, 'd': 4}

# 修改操作
>>> my_dict['d'] = 40
>>> my_dict
{'a': 1, 'b': 2, 'c': 3, 'd': 40}

# 刪除操作
>>> my_dict.pop('a')
1
>>> my_dict
{'b': 2, 'c': 3, 'd': 40}

# 清空字典
>>> my_dict.clear()
>>> my_dict
{}

# update操作，將 一個字典中（d_1）的元素更新到 另一個字典（d_2）中，若d_1中的key，d_2中也有，則d_1中的key更新d_2中的key，若d_1中的key，d_2中沒有，則在d_2中進行添加，示例如下：
>>> d_1 = {'a': 1, 'b': 2, 'c': 3}
>>> d_2 = {'a': 12, 'x': 10, 'y': 20, 'z': 30}
>>> d_1.update(d_2)
>>> d_1
{'a': 12, 'b': 2, 'c': 3, 'x': 10, 'y': 20, 'z': 30}

--對字典的循環操作

字典的 items() 函數以列表形式 返回可遍歷的(鍵, 值) 元組。

my_dict = {'a': 1, 'b': 2, 'c': 3}
for i in my_dict.items():
    print(i)
結果輸出：
('a', 1)
('b', 2)
('c', 3)

keys()，values()

my_dict = {'a': 1, 'b': 2, 'c': 3}
for i in my_dict.keys():                    # keys() 獲取字典的所有 key， 并以列表形式返回
    print(i)
結果輸出：
a
b
c

my_dict = {'a': 1, 'b': 2, 'c': 3}
for i in my_dict.values():                 # values() 獲取字典的所有 value， 并以列表形式返回
    print(i)
結果輸出：
1
2
3

在python2中，也有items()，keys()，values()函數，返回的是一個字典的拷貝列表（items，keys或values），對應的還有iteritems()，iterkeys()，itervalues()，返回字典所有items（key，value）的一個迭代器，前者會占用額外內存，后者不會

在python3中，廢棄了iteritems()，iterkeys()，itervalues()函數，使用items()，keys()，values()替代，其返回結果與python2中的iteritems()，iterkeys()，itervalues()一致

遍歷字典也可以不使用上述的函數：

my_dict = {'a': 1, 'b': 2, 'c': 3}
for key in my_dict:                          # 遍歷字典中的所有key
    print(my_dict[key])

--dict() 轉換的使用

列表轉字典
方式一：

>>> ls_key = ['a', 'b', 'c']
>>> ls_value = [1, 2, 3]
>>> dict(zip(ls_key, ls_value))
{'a': 1, 'b': 2, 'c': 3}

方式二：

>>> ls_key_value = [['a', 1], ['b', 2], ['c', 3]]
>>> dict(ls_key_value)
{'a': 1, 'b': 2, 'c': 3}

字符串轉為字典
方式一：

import json
user_str = '{"name" : "Kitty", "gender" : "female", "age": 18}'
# user_str = "{'name' : 'Kitty', 'gender' : 'female', 'age': 18}"   # 必須寫成上面這種形式（雙引號），不能使用單引號，這也是使用 json 方式的缺陷
user_dict = json.loads(user_str)     # {"name" : "Kitty", "gender" : "female", "age": 18}

方式二：

user_str = '{"name" : "Kitty", "gender" : "female", "age": 18}'
user_dict = eval(user_str)       # {'name': 'Kitty', 'gender': 'female', 'age': 18}

Tip：使用eval不存在向json這樣的問題，但是eval存在安全性問題，所以不建議使用~

方式三：

import ast
user_str = '{"name" : "Kitty", "gender" : "female", "age": 18}'
user_dict = ast.literal_eval(user_str)    # {'name': 'Kitty', 'gender': 'female', 'age': 18}

Tip：ast.literal_eval 不存在 json 的問題，也沒有安全性問題，推薦使用~

集合

集合（set）是一個無序不重復元素的序列。集合中只能存放不可變對象（可hash的）~

--創建集合

使用 {} 或者 set() 創建集合

my_set = {'python', 'ruby', 'java', 'python', 'go'}      # 推薦使用
# 或者
my_set = set(['python', 'ruby', 'java', 'python', 'go'])
my_set = set({'python', 'ruby', 'java', 'python', 'go'})
my_set = set(('python', 'ruby', 'java', 'python', 'go'))

# 創建的集合為：{'python', 'java', 'go', 'ruby'}

# 集合中不可存放可變對象
>>> my_set = {[1,2,3], 'abc'}
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

Tip：由于集合中的元素不可重復，重復的元素僅保留一個

創建空集合

my_set = set()      # 不能使用 {}，{} 會創建一個空的字典

--集合常用操作

# 添加元素，add() 操作，若元素已經存在，則不進行任何操作
>>> my_set = {'python', 'ruby', 'java', 'python', 'go'}
>>> my_set.add('c')
>>> my_set
{'go', 'ruby', 'c', 'python', 'java'}

# 更新集合，update操作，已存在的元素，不進行操作，不存在的元素進行添加
>>> my_set = {'python', 'ruby', 'java', 'python', 'go'}
>>> my_set.update({'go','php','c'})
>>> my_set
{'go', 'ruby', 'c', 'python', 'php', 'java'}

# 刪除元素
# remove，從集合中移除元素，若不存在，報錯~
>>> my_set = {'python', 'ruby', 'java', 'python', 'go'}
>>> my_set.remove('python')
>>> my_set
{'go', 'ruby', 'java'}
>>> my_set.remove('php')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'php'

# discard，從集合中移除元素，元素不存在不會報錯
>>> my_set = {'python', 'ruby', 'java', 'python', 'go'}
>>> my_set.discard('ruby')
>>> my_set.discard('php')
>>> my_set
{'go', 'python', 'java'}

# pop，隨機從集合中刪除一個元素，并返回被刪除的元素
>>> my_set = {'python', 'ruby', 'java', 'python', 'go'}
>>> my_set.pop()
'go'
>>> my_set
{'python', 'ruby', 'java'}

# 計算集合中元素個數
>>> len(my_set)
3

# 清空集合
>>> my_set.clear()
>>> my_set
set()

# 判斷集合是否包含某個元素，存在返回True，否則返回False~；對應的還有not in
>>> my_set = {'python', 'ruby', 'java', 'python', 'go'}
>>> 'java' in my_set
True
>>> 'erlang' in my_set
False

--集合運算

>>> my_set_1 = {'Apple', 'Facebook', 'Amazon'}
>>> my_set_2 = {'Apple', 'Google', 'Alibaba'}

----并集 union

>>> my_set_1 | my_set_2
{'Apple', 'Amazon', 'Google', 'Alibaba', 'Facebook'}

# 對應方法
>>> my_set_1.union(my_set_2)
{'Apple', 'Amazon', 'Google', 'Alibaba', 'Facebook'}

----交集 intersection

>>> my_set_1 & my_set_2
{'Apple'}

# 對應方法
>>> my_set_1.intersection(my_set_2)
{'Apple'}

----差集 difference

>>> my_set_1 - my_set_2
{'Amazon', 'Facebook'}

# 對應方法
>>> my_set_1.difference(my_set_2)
{'Amazon', 'Facebook'}

----對稱差集 sysmmetric difference

>>> my_set_1 ^ my_set_2
{'Alibaba', 'Amazon', 'Google', 'Facebook'}

# 對應方法
>>> my_set_1.symmetric_difference(my_set_2)
{'Alibaba', 'Amazon', 'Google', 'Facebook'}

可使用 set() 將list，tuple，dict，字符串 轉換成集合

my_set = set(['python', 'ruby', 'java', 'python', 'go'])
my_set = set(('python', 'ruby', 'java', 'python', 'go'))
my_set = set({'a':1, 'b':2, 'c':3})       # 僅獲取 keys，轉換后的集合 {'a', 'c', 'b'}
my_set = set('abcdefg')                  # {'e', 'c', 'f', 'd', 'b', 'a', 'g'}

.................^_^