Python常見內建方法與操作

整型int

1. 型別轉換

int(其它資料型別)，但只支援數字型別和小數型別

>>> num1 = input('Your age>>>:')
Your age>>>:18
>>> print(type(num1))
<class 'str'>  # 可以看到輸入的型別為字串型別
>>> num1 = int(num1)
>>> print(type(num1))
<class 'int'>  # 可以看到轉換後的型別

2. 進位制數轉換

將10進位制轉換為2、8、16進位制數，根據下面的程式碼可以看到，2進位制的以0b開頭，8進位制以0o開頭，16進位制以0x開頭。

>>> print(bin(100))  # 轉換為2進位制
0b1100100  # 轉換後的2進位制資料值
>>> print(oct(100))  # 轉換為8進位制
0o144  # 轉換後的8進位制資料值
>>> print(hex(100))  # 轉換為16進位制
0x64  # 轉換後的16進位制資料值

將2、8、16進位制數轉換為10進位制

>>> print(int(0b1100100))
100
>>> print(int(0o144))
100
>>> print(int(0x64))
100
 

如果轉換的內容帶有引號，需要告訴直譯器進位制數

>>> print(int('0b1100100'))# 加上引號後直接輸出會報錯
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: '0b1100100'

# 告訴直譯器你的進位制數就可以輸出了
>>> print(int('0b1100100',2)) 
100
>>> print(int('0o144',8))
100
>>> print(int('0x64',16))
100
 

浮點型float

1. 型別轉換

float(其它資料型別)，轉換內容中只能出現純數字，外加一個小數點。

>>> num1 = 10
>>> print(type(num1))
<class 'int'>  # 資料整形為int
>>> num1 = float(num1)  # 轉換資料型別
>>> print(type(num1))
<class 'float'>  # 資料型別為float
>>> print(num1)
10.0  # 可以看到轉換後的結果加上了小數

字串str

1. 型別轉換

str(其它資料型別)，可以轉換任意資料型別，只需要在資料值的前後新增引號即可。

>>> num1 = 10
>>> print(type(num1))
<class 'int'>
>>> print(num1)
10
>>> num1 = '10'
>>> print(type(num1))
<class 'str'>	# 資料型別為str
>>> print(num1)
10	# 雖然值也為10，但資料型別為str，這時是不可以作運算的。

>>> num2 = 5	# 定義一個num2
>>> print(num1 - num2)	# 使兩個值相減，此時的num1的值為str型別的10
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for -: 'str' and 'int'  #直接報錯

2. 操作與方法

索引取值

取索引值為1的對應的資料值

>>> s1 = 'abcde'
>>> print(s1[1])
b

取倒數第一個資料值

>>> s1 = 'abcde'
>>> print(s1[-1])
e

取出所有資料值

>>> s1 = 'abcde'
>>> print(s1[:])
abcde
>>> print(s1[::])
abcde

切片操作

注意，切片操作取值顧頭不顧尾，預設順序為從左到右取值。

取索引1至5（不包含5）對應的資料值

>>> s1 = 'abcde'
>>> print(s1[1:5])
bcde

從倒數第5個值開始，取到倒數第2個值

>>> s1 = 'abcde'
>>> print(s1[-5:-1])
abcd

輸出從索引2開始所有的數值

>>> s1 = 'abcde'
>>> print(s1[2:])
cde

從索引0開始輸出，直到索引4結束

>>> s1 = 'abcdefghijk'
>>> print(s1[:5])
abcde

從索引0開始輸出，之後每隔一個索引輸出一次資料（因為最後一個值預設是1，所以2只是增加1個數，所以是每隔一個索引輸出一次）

>>> s1 = 'abcdefghijk'
>>> print(s1[::2])
acegik

修改切片方向與間隔取值

先輸出索引1的值後，每間隔2個索引值輸出一個值。

>>> s1 = 'abcdefghijk'
>>> print(s1[1:5:2])
bd

正常取值是從左向右，通過最後一個鍵值改為-1時，取值順序變為從右向左

>>> s1 = 'abcdefghijk'
>>> print(s1[-1:-5:-1])
kjih

統計字串的個數

對應方法：len()

>>> s1 = 'abcdefghijk'
>>> print(len(s1))
11

移除字串首尾指定的字元

對應方法：strip()

使用場景：使用者在輸入使用者名稱、驗證碼等資訊時容易多輸入空格，這時候就需要把空格去除，讓使用者體驗更好。

username = input('username >>>:').strip()
# 使用strip後，在輸入使用者名稱的時候，輸入'abc  '的話，也會判定成功。
if username == 'abc':
 print('success!!!')

如果想要指定去除開頭結尾的指定字元的話也可以

>>> '$$abc$$'.strip('$')	# 指定去除的字串為'$'
'abc'

如果只想去除開頭或者結尾其中一個地方的字串可以使用

去除開頭也就是左側指定字串：lstrip（第一個字母l其實是left的開頭字母）

去除結尾也就是右側指定字串：rstrip（第一個字母r其實是right的開頭字母）

>>> '$$abc$$'.lstrip('$')
'abc$$'
>>> '$$abc$$'.rstrip('$')
'$$abc'

切割字串中指定的字元

切割字串：split()

被切割後的字串以列表的形式展現

>>> 'jack,18,teacher'.split(',')
['jack', '18', 'teacher']
# 使用變數的方式呼叫此方法
>>> s1 = 'jack,18,teacher'
>>> s1.split(',')
['jack', '18', 'teacher']

也可以為各個資料值指定變數

>>> s1 = 'jack,18,teacher'
>>> name, age, job = s1.split(',')
>>> print(name, age, job)
jack 18 teacher

指定切割物件數量，使用maxsplit引數

>>> s1 = 'jack,18,teacher'
>>> print(s1.split(',',maxsplit=1))
['jack', '18,teacher']	# 可以看到切割成了兩份

指定切割物件數量，並進行反向切割：rsplit()

>>> s1 = 'jack,18,teacher'
>>> print(s1.rsplit(',',maxsplit=1))
['jack,18', 'teacher']

字串格式化輸出

格式化輸出：format()

第一種使用方法：當作佔位符使用，與%s類似的使用方法

>>> res = 'The IP address is {}, Port is {}'.format('1.1.1.1','3389')
>>> print(res)
The IP address is 1.1.1.1, Port is 3389

第二種，根據索引取值，可以反覆使用

>>> res = 'The IP address is {0}, Port is {1}, The{0} cannot conmunicate!'.format('1.1.1.1','3389')
>>> print(res)
The IP address is 1.1.1.1, Port is 3389, The1.1.1.1 cannot conmunicate!

第三種，類似於字典形式呼叫，見名知意

>>> res = 'The IP address is {addr}, Port is {port}, The{addr} cannot conmunicate!'.format(addr='1.1.1.1',port='3389')
>>> print(res)
The IP address is 1.1.1.1, Port is 3389, The1.1.1.1 cannot conmunicate!

第四種，先指定變數，再進行呼叫

>>> name = input('username >>>:')	# 搭配input使用，直接給變數賦值
username >>>:abcde	# 輸入使用者名稱
>>> age = input('age >>>:')	# 輸入使用者年齡
age >>>:18	# 年齡為18
>>> res = f'my name is {name},age is {age}' # 開頭加一個f，並將內容使用引號引起來進行呼叫
>>> print(res)
my name is abcde,age is 18  # 可以看到呼叫成功

額外知識，可以讓變數補全空位，達到對齊的效果，在呼叫變數值的時候，加上 X:>N 表示向右縮排N個字元並且使用X補齊，不輸入X則預設使用空格。如果加上 X:<N表示左側的N個字元使用X補齊。

# 可以看到，輸出結果的年齡不對齊，有時候想要輸出好看一些的時候，就可以定義縮排值了。
>>> jack_age = 29
>>> jason_age = 18
>>> john_green_age = 15
>>> print(f'''jack is {jack_age} years old,
... jason is {jason_age} years old
... john green is {john_green_age} years old''')
jack is 29 years old,
jason is 18 years old
john green is 15 years old

# 不指定字元補齊
>>> jack_age = 29
>>> jason_age = 18
>>> john_green_age = 15
>>> print(f'''jack is {jack_age:>8} years old,
... jason is {jason_age:>7} years old,
... john green is {john_green_age:>2} years old.''')
jack is 29 years old,		# 變數值的左側被空格補齊
jason is18 years old,
john green is 15 years old.

# 也可以指定字元補全
>>> print(f'''jack is {jack_age:$<8} years old,
... jason is {jason_age:$<7} years old,
... john green is {john_green_age:$<2} years old.''')
jack is 29$$$$$$ years old,		# 變數值的右側被指定的$補齊
jason is 18$$$$$ years old,
john green is 15 years old.

大小寫相關

將字串中的字母，全部變為大寫：upper()

將字串中的字母，全部變為小寫：lower()

使用場景：使用者輸入驗證碼等場景時，可以忽略大小寫，讓使用者體驗更好。

>>> s1 = 'aAbBcC2333'
>>> s1.upper()
'AABBCC2333'
>>> s1.lower()
'aabbcc2333'

判斷字串中是否為純數字

使用方法：isdigit()

>>> s1 = 'aAbBcC2333'
>>> s1.isdigit()
False
>>> s2 = '123456'
>>> s2.isdigit()
True
>>> s3 = '123.456'	# 注意，在引號裡面的小數點也是字串，所以是False
>>> s3.isdigit()
False

替換字串中指定的內容

>>> s1 = 'aAbBcC2333'
>>> s1.replace('a','G')
'GAbBcC2333'	# 將a替換為G並輸出
>>> print(s1)
aAbBcC2333		# 注意，原來的值沒有改變，如果想要改變，需要重新賦值

字串的拼接

使用print拼接

>>> s1 = 'Hello'
>>> s2 = 'World'
>>> print(s1 + s2)
HelloWorld
>>> print(s1 * 5)	# 也支援乘法，多次輸出
HelloHelloHelloHelloHello

使用join拼接

>>> print('|'.join(['Hello','World','Welcome']))
Hello|World|Welcome

# 注意，拼接內容必須使用str型別
>>> print('|'.join(['Hello','World',12]))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: sequence item 2: expected str instance, int found

統計指定字元出現的次數

使用方法：count()

>>> s1 = 'aaaWorld'
>>> s1.count('a')
3

判斷字串開頭或者結尾

判斷開頭：startswith

判斷結尾：endswith

>>> s1 = 'aaaWorld'
>>> s1.startswith('a')
True	# 判斷成功則為真
>>> s1.startswith('b')
False	# 判斷失敗則為假
>>> s1.endswith('d')
True
>>> s1.endswith('l')
False

開頭字母大寫，其餘小寫

方法：title()

>>> s1 = 'hello world'
>>> s1.title()
'Hello World'
>>> s1 = 'helloworld'
>>> s1.title()
'Helloworld'	# 注意使用空格、標點等進行判斷
>>> s1 = 'hello world,welcome you'
>>> s1.title()
'Hello World,Welcome You'

一句話中第一個單詞的開頭字母大寫，其餘小寫

方法：capitalize()

>>> s1 = 'hello world,welcome you'
>>> s1.capitalize()
'Hello world,welcome you'

大小寫轉換

>>> s1 = 'aAbBcCdD123'
>>> s1.swapcase()
'AaBbCcDd123'

查詢關鍵字第一次出現在第幾個字元（注意從0開始）

方法1：index （如果沒有值會報錯）

方法2：find （如果沒有值會返回 -1）

>>> s1 = 'cccabacd'
>>> s1.index('a')	# 資料值在索引3的位置
3
>>> s1.find('a')	# 資料值在索引3的位置
3
>>> s1.index('e')	# 資料值中沒有e，報錯
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: substring not found
>>> s1.find('e')	# 資料值中沒有e，返回 -1
-1

列表型別

1. 型別轉換

list(其它資料型別)，通俗來說，能被for迴圈的都可以轉換成列表。

2. 操作與方法

列表之索引取值

>>> l1 = [1, 2, 3]
>>> print(l1[0])
1

列表之切片操作

>>> l1 = ['a', 'b', 'c', 'd', 'e', 'f']
>>> print(l1[0:5])
['a', 'b', 'c', 'd', 'e']
>>> print(l1[-5:-1])
['b', 'c', 'd', 'e']

列表之間隔取值

>>> l1 = ['a', 'b', 'c', 'd', 'e', 'f']
>>> print(l1[0:5:2])
['a', 'c', 'e']

列表之反向取值

>>> l1 = ['a', 'b', 'c', 'd', 'e', 'f']
>>> print(l1[::-1])
['f', 'e', 'd', 'c', 'b', 'a']
>>> print(l1[-1:-3:-1])
['f', 'e']

列表之統計列表中資料值的個數

使用方法：len()

>>> l1 = ['a', 'b', 'c', 'd', 'e', 'f']
>>> print(len(l1))
6

列表之修改列表中的值

>>> l1 = ['a', 'b', 'c', 'd', 'e', 'f']
>>> l1[0] = '666'
>>> print(l1)
['666', 'b', 'c', 'd', 'e', 'f']

列表之在列表結尾新增追加資料值

>>> l1 = ['a', 'b', 'c', 'd', 'e', 'f']
>>> l1.append('666')
>>> print(l1)
['a', 'b', 'c', 'd', 'e', 'f', '666']

列表之在列表任意位置新增新的資料值

>>> l1 = ['a', 'b', 'c', 'd', 'e', 'f']
>>> l1.insert(3,'new')  # 在索引3的位置增加new字元，原來的資料索引值順延。
>>> print(l1)
['a', 'b', 'c', 'new', 'd', 'e', 'f']

列表之擴充套件列表 或 合併列表

>>> l1 = [1, 2, 3]
>>> l2 = [3, 4, 5]
>>> print(l1 + l2)  # 只是列印，並不修改原資料值
[1, 2, 3, 3, 4, 5]
>>> l1.extend(l2)	# 將l2中的資料追加到l1列表中
>>> print(l1)
[1, 2, 3, 3, 4, 5]
>>> print(l2)		# 列表l2值不變
[3, 4, 5]

列表之刪除表資料

方法1：del() 在記憶體中刪除資料值

>>> l1 = ['a', 'b', 'c', 'd', 'e', 'f']
>>> del(l1[0])
>>> print(l1)
['b', 'c', 'd', 'e', 'f']

方法2：remove() 在記憶體中刪除資料值，並且使用資料值，不使用索引。

>>> l1 = ['a', 'b', 'c', 'd', 'e', 'f']
>>> l1.remove('a')	# 將資料值為a的刪除了
>>> print(l1)
['b', 'c', 'd', 'e', 'f']
# 問題，如果有多個a，會如何刪除？
>>> l1 = ['a', 'b', 'c', 'd', 'a', 'e', 'f', 'a']
>>> l1.remove('a')
>>> print(l1)
['b', 'c', 'd', 'a', 'e', 'f', 'a']		# 只清理了按從左到右的順序第一個a

方法3：pop() 將資料彈出，可以將彈出的資料賦值給其它變數

>>> l1 = ['a', 'b', 'c', 'd', 'e', 'f']
>>> l1.pop(0)
'a'		# 這裡會輸出你要彈出的資料值，如果指定了變數，則可以賦值
>>> print(l1)
['b', 'c', 'd', 'e', 'f']	# 原列表中的a被彈出

列表之列表的排序

使用方法：sort()

>>> l1 = ['d', 'c', 'b', 'a']
>>> l1.sort()
>>> print(l1)
['a', 'b', 'c', 'd']
>>> l2 = [5, 2, 1, 6, 9]
>>> l2.sort()
>>> print(l2)
[1, 2, 5, 6, 9]

倒序排序，加引數reverse（翻譯為中文：相反、顛倒等意思）

>>> l1 = ['a', 'b', 'c', 'd']
>>> l2 = [5, 2, 1, 6, 9]
>>> l1.sort(reverse = True)
>>> l2.sort(reverse = True)
>>> print(l1)
['d', 'c', 'b', 'a']
>>> print(l2)
[9, 6, 5, 2, 1]

列表之統計列表中的資料值出現的次數

使用方法：count()

>>> l1 = ['aa', 'bc', 'cd', 'd']
>>> l1.count('d')		# 注意，是按整個字串進行匹配的，不是單個字母
1
>>> l1.count('cd')
1

列表之列表倒序輸出

>>> l2 = [5, 2, 1, 6, 9]
>>> l2.reverse()
>>> print(l2)
[9, 6, 1, 2, 5]		# 注意，只是反著輸出，並不是反向排序

字典型別

1. 型別轉換

使用dict()，但是dict非常麻煩，一般不會使用這種方法進行轉換，不如直接手寫。

>>> print(dict([('name','pwd'),('jason',123)]))
{'name': 'pwd', 'jason': 123}

2. 操作與方法

字典之查詢

按鍵取值，但有一個缺點，如果鍵在字典中不存在，則會報錯。

>>> d1 = {'username': 'jack', 'age': 18}
>>> print(d1['username'])
jack
>>> print(d1['job'])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'job'

使用方法：get()

推薦使用，如果鍵在字典中不存在，只會返回None或指定的值。

>>> d1 = {'username': 'jack', 'age': 18}
>>> print(d1.get('username'))
jack
>>> print(d1.get('job'))	# 預設返回None，不會報錯
None
>>> print(d1.get('job', 'error!!!!'))	# 第二個值定義返回的值
error!!!!

字典之修改值

通過鍵進行修改，注意，如果鍵在字典中不存在，則修改會變為增加鍵值。

>>> d1 = {'username': 'jack', 'age': 18}
>>> d1['age'] = 99
>>> print(d1)
{'username': 'jack', 'age': 99}

字典之增加值

只要字典中鍵不存在，則使用修改的方法就會變為增加鍵值。

>>> d1 = {'username': 'jack', 'age': 18}
>>> d1['job'] = 'Caption'
>>> print(d1)
{'username': 'jack', 'age': 18, 'job': 'Caption'}

字典之刪除鍵值

方法一：del()

>>> d1 = {'username': 'jason', 'job': 'Caption', 'age': 18}
>>> del d1['job']
>>> print(d1)
{'username': 'jason', 'age': 18}

方法二：pop() 注意：此方法與列表中的pop方法一樣，可以將彈出（刪除）的值賦值給新的變數

>>> d1 = {'username': 'jason', 'job': 'Caption', 'age': 18}
>>> d1.pop('job')
'Caption'	# 此時可以將這個'Caption'賦值給新的變數
>>> print(d1)
{'username': 'jason', 'age': 18}

方法三：popitem 注意：此方法只能刪除最後一個加入字典的鍵值對，無法指定刪除哪個

>>> d1 = {'username': 'jason', 'job': 'Caption', 'age': 18}
>>> d1.popitem()	# 將最後一個加入字典的鍵值刪除
('age', 18)
>>> print(d1)
{'username': 'jason', 'job': 'Caption'}

>>> d1 = {'username': 'jason', 'job': 'Caption', 'age': 18}
>>> d1.popitem('username')		# 可以看到，不可以指定刪除哪個鍵值
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: popitem() takes no arguments (1 given)

字典之統計鍵值對的個數

使用方法：len()

>>> d1 = {'username': 'jason', 'job': 'Caption', 'age': 18}
>>> print(len(d1))
3

字典之獲取字典中所有鍵

使用方法：keys()

>>> d1 = {'username': 'jason', 'job': 'Caption', 'age': 18}
>>> d1.keys()
dict_keys(['username', 'job', 'age'])

字典之獲取字典中所有值

使用方法：values()

>>> d1 = {'username': 'jason', 'job': 'Caption', 'age': 18}
>>> d1.values()
dict_values(['jason', 'Caption', 18])

字典之獲取字典中鍵值對資料

使用方法：items()

>>> d1 = {'username': 'jason', 'job': 'Caption', 'age': 18}
>>> d1.items()
dict_items([('username', 'jason'), ('job', 'Caption'), ('age', 18)])

字典之快速生成值相同的字典

使用方法：dict.fromkeys() 注意：值為三個鍵共享，所以無論為哪一個鍵增加值，其它鍵都會看到。

>>> print(dict.fromkeys(['name', 'job', 'age'], 123))
{'name': 123, 'job': 123, 'age': 123}

>>> d1 = dict.fromkeys(['name', 'job', 'age'], [])
>>> d1['name'].append('jason')		# 為name 增加一個值'jason'
>>> d1['job'].append('Caption')		# 為job 增加一個值'Caption'
>>> d1['age'].append(18)			# 為age 增加一個值18
>>> print(d1)				# 我們想要的結果應該是{'name': 'jason', 'job': 'Caption', 'age': 18}，但請看輸出的結果
{'name': ['jason', 'Caption', 18], 'job': ['jason', 'Caption', 18], 'age': ['jason', 'Caption', 18]}

元組型別

1. 型別轉換

tuple(資料值) 說明：可以被for迴圈的資料值都可以轉換為tuple

>>> s1 = 'abcde'
>>> tuple(s1)
('a', 'b', 'c', 'd', 'e')

2. 方法與操作

索引取值

>>> s1 = ('a', 'b', 'c', 'd', 'e')
>>> print(s1[0])
a

切片取值

>>> s1 = ('a', 'b', 'c', 'd', 'e')
>>> print(s1[0:1])
('a',)	# 注意取一個值的時候會有一個逗號，指定變數的時候也一樣，結尾加上逗號才算是元組，否則算是其它資料型別

間隔取值

>>> s1 = ('a', 'b', 'c', 'd', 'e')
>>> print(s1[0:4:2])
('a', 'c')

反向取值等都與列表相同

>>> s1 = ('a', 'b', 'c', 'd', 'e')
>>> print(s1[-1:-3:-1])
('e', 'd')

元組之統計元組中資料值的個數

使用方法：len()

>>> s1 = ('a', 'b', 'c', 'd', 'e')
>>> print(len(s1))
5

元組之統計一個數據值出現的次數

使用方法：count()

>>> s1 = ('a', 'b', 'c', 'd', 'e', 'a')
>>> s1.count('a')
2

元組之檢視一個數據值對應的索引值

使用方法：index() 注意：如果資料值重複的話，只能看到從左向右第一個資料值的對應索引值

>>> s1 = ('a', 'b', 'c', 'c', 'd')
>>> print(s1.index('c'))
2

集合型別

1. 型別轉換

set(資料值)

注意： 集合內資料必須是不可變型別(整型 浮點型 字串 元組)

​ 集合內的資料也是無序的，沒有索引的概念

2. 操作與方法

集合之去重

去掉資料值內重複的值，只要將資料型別轉換為set就會自動去重，但是注意：集合去重無法保留原先資料的排序順序

>>> l1 = [11, 22, 33, 11, 22, 55, 66]
>>> s1 = {11, 33, 55, 22, 99, 77, 11, 33, 22}
>>> print(set(s1))
{33, 99, 22, 55, 11, 77}
>>> print(set(l1))
{33, 66, 11, 22, 55}

集合之取兩個元組中相同的值

使用方法：兩個值之間使用'&' 或者使用方法intersection （& 等同於 intersection）

>>> s1 = {'abc', 'ccc', 'qqq', 'ddd', 'lll'}
>>> s2 = {'cba', 'ccc', 'ddd', 'qqq', 'bbb'}
>>> print(s1 & s2)
{'qqq', 'ccc', 'ddd'}
>>> print(s1.intersection(s2))
{'qqq', 'ccc', 'ddd'}

集合之取前面集合有，後面集合沒有的值

使用方法：兩個值之間使用'-' 或者使用方法difference （- 等同於 difference）

>>> s1 = {'abc', 'ccc', 'qqq', 'ddd', 'lll'}
>>> s2 = {'cba', 'ccc', 'ddd', 'qqq', 'bbb'}
>>> print(s1 - s2)
{'lll', 'abc'}
>>> print(s1.difference(s2))
{'lll', 'abc'}

集合之取兩個元組中所有的值，且去掉重複值

使用方法：兩個值之間使用 '|' 或者使用方法union （｜ 等同於 union）

>>> s1 = {'abc', 'ccc', 'qqq', 'ddd', 'lll'}
>>> s2 = {'cba', 'ccc', 'ddd', 'qqq', 'bbb'}
>>> print(s1 | s2)
{'cba', 'lll', 'bbb', 'ccc', 'ddd', 'abc', 'qqq'}
>>> print(s1.union(s2))
{'cba', 'lll', 'bbb', 'ccc', 'ddd', 'abc', 'qqq'}

元組之取兩個元組中，獨有的值（就是去掉相同的部分，輸出不同的部分）

使用方法：兩個值之間使用 '^' 或者使用方法 symmetric_difference (^ 等同於 symmetric_difference)

>>> s1 = {'abc', 'ccc', 'qqq', 'ddd', 'lll'}
>>> s2 = {'cba', 'ccc', 'ddd', 'qqq', 'bbb'}
>>> print(s1 ^ s2)
{'cba', 'abc', 'lll', 'bbb'}
>>> print(s1.symmetric_difference(s2))
{'cba', 'abc', 'lll', 'bbb'}

可變型別與不可變型別

1. 可變型別的特點：
2. 列表在呼叫內建方法之後修改的就是自身，並沒有產生一個新的結果。
3. 變數的值改變，記憶體地址不會改變

>>> l1 = [1, 2]
>>> id(l1)
2242835102344
>>> l1.append(3)  # 修改的是自身，並沒有產生一個新的結果
>>> id(l1)
2242835102344	# 記憶體不變
>>> print(l1)
[1, 2, 3]		# 在記憶體不變的情況下，資料值發生了改變

2. 不可變型別的特點：
3. 字串在呼叫內建方法之後並不會修改自己，而是產生了一個新的結果。
4. 變數的值改變，記憶體地址肯定會發生改變。

>>> s1 = '$$$abc$$$'
>>> id(s1)
2242835110960
>>> s1.strip('$')
'abc'	# 產生了一個新的結果
>>> print(s1)
$$$abc$$$	# 資料值並不會改變
>>> id(s1)
2242835110960	# 記憶體地址沒有變化
# 這個時候，如果想要改變結果，需要對變數重新賦值
>>> s1 = s1.strip('$')
>>> print(s1)
abc
>>> id(s1)
2242835112768  # 重新賦值，記憶體地址肯定會發生改變