[toc]
一、進制
- 二進制：逢2進1，0 1 （隻有0和1兩個數）
- 八進制：逢8進1，0 1 2 3 4 5 6 7 （8個數字）
- 十進制：逢10進1，0 1 2 3 4 5 6 7 8 9 （10個數字）
- 十六進制：逢16進1，0 1 2 3 4 5 6 7 8 9 A B C D E F （16個數字，A=10，B=11，C=12，D=13，E=14，F=15）
進制對應：
|十六進制|0|1|2|3|4|5|6|7|8|9|A|B|C|D|E|F|10|
|:-:|
|十進制|0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|
|八進制|0|1|2|3|4|5|6|7|10|11|12|13|14|15|16|17|20|
|二進制|0|1|10|11|100|101|110|111|1000|1001|1010|1011|1100|1101|1110|1111|10000|
進制轉換：
線上進制轉換- 十進制轉二進制：除2取餘，不夠除，取0餘1，以53為例，如下圖： 十進制轉二進制
第2天，Python基礎 - 十進制轉八進制： 十進制轉八進制
第2天，Python基礎 - 十進制轉十六進制： Paste_Image.png
第2天，Python基礎 - 二進制轉十進制：裝水桶法：
二進制轉十進制
- 十六進制轉二進制： 十六進制轉二進制
第2天，Python基礎
二、資料類型
1、str 字元串
字元串是不可變的資料類型
1.capitalize
字元串首字母大寫
name = 'alex'
v = name.capitalize()
print(name)
print(v)
2. casefold
将所有大寫變小寫（也可以将歐洲的一些特殊大寫字母變為小寫）
name = 'AleX'
v = name.casefold() # 注意，有些python版本可能沒有這個方法，我的python3.5.2就沒有，不必太在意
print(name)
print(v)
3. swapcase
将大寫轉小寫，小寫轉大寫
name = 'AleX'
a = name.swapcase()
print(name)
print(a)
4. lower
将所有大小變小寫
name = 'AleX'
v = name.lower()
print(v)
5. upper
将所有小寫變大寫
name = 'alex'
v = name.upper()
print(v)
6. center
文本居中，兩邊用指定字元填充
# 參數1: 表示總長度
# 參數2：空白處填充的字元（長度為1）
name = 'alex'
v = name.center(20,'#')
print(v)
輸出：
########alex########
7. count
表示傳入字元或子字元串在大字元串中出現的次數
# 參數1： 要查找的值（子序列）
# 參數2： 起始位置（索引）
# 參數3： 結束位置（索引）
name = "alexasdfdsafsdfasdfaaaaaaaa"
v = name.count('a')
print(v)
v1 = name.count('df')
print(v1)
輸出：
12
3
name = "alexasdfdsafsdfasdfaaaaaaaa"
v = name.count('df',12)
print(v)
v = name.count('df',0,15)
print(v)
輸出：
2
2
8. startswith
是否以XXX開頭，傳回True 或 False
name = 'alex'
v2 = name.startswith('al')
print(v2)
9. endswith
是否以xx結尾
name = 'alex'
v1 = name.endswith('ex')
print(v1)
10. expandtabs
找到制表符\t,進行替換（包含前面的值）
name = "al\te\tx\nalex\tuu\tkkk"
v = name.expandtabs(20)
print(v)
輸出：
al e x
alex uu kkk
11. find
找到指定子序列的索引位置：不存在傳回-1
name = 'alex'
v = name.find('e')
print(v)
12. index
找到指定子序列的索引位置：不存在報錯
name = 'alex'
v = name.index('o')
print(v)
13. format
字元串格式化
- 方法1.
tpl = "我是:{0};年齡:{1};性别:{2}" #位置必須一一對應
v = tpl.format("李傑",19,'都行')
print(v)
輸出：
我是:李傑;年齡:19;性别:都行
- 方法2.
tpl = "我是:{name};年齡:{age};性别:{gender}"
v = tpl.format(name='李傑',age=19,gender='随意')
print(v)
14. format_map
字元串格式化，以字典的形式指派
tpl = "我是:{name};年齡:{age};性别:{gender}"
v = tpl.format_map({'name':"李傑",'age':19,'gender':'中'})
print(v)
輸出：
我是:李傑;年齡:19;性别:中
15. isalnum
是否是數字、漢字、字母，如果包含符号傳回False
name = 'alex8漢子'
v = name.isalnum() # 字,數字
print(v) # True
16. isalpha
是否是純字母
name = 'alex8漢子'
v2 = name.isalpha()#
print(v2) # False
17. isdecimal 、isdigit 、isnumeric
判斷是否是數字
num = '②'
v1 = num.isdecimal() # 可識别 '123'
v2 = num.isdigit() # 可識别 '123'，'②'
v3 = num.isnumeric() # 可識别 '123'，'二'，'②'
print(v1,v2,v3)
18. isidentifier
是否是符号規範的标示符（變量名）
n = 'name'
v = n.isidentifier()
print(v)
19. islower、isupper
是否全部是小寫或大寫
name = "ALEX"
v = name.islower() # 是否全是小寫
print(v)
v = name.isupper() # 是否全是大寫
print(v)
20. isprintable
判斷是否包含不可列印的字元（如: “\n”、"\t"等），包含傳回False，不包含傳回True
name = "釣魚要釣刀魚，\n刀魚要到島上釣"
v = name.isprintable()
print(v)
21. isspace
是否全部是空格
name = ' '
v = name.isspace()
print(v)
22. join
元素拼接
name = 'alex'
v = "_".join(name) # 内部循環每個元素
print(v)
輸出：
a_l_e_x
name_list = ['海峰','杠娘','李傑','李泉']
v = "搞".join(name_list)
print(v)
輸出：
海峰搞杠娘搞李傑搞李泉
23. ljust 、rjust
左右填充
name = 'alex'
v = name.rjust(20,' ')
v1 = name.ljust(20,' ')
print(v)
print(v1)
輸出：
alex
alex
24. maketrans 、translate
對應關系 + 翻譯
m = str.maketrans('aeiou','12345') # 對應關系
name = "aaeeiioouu"
v = name.translate(m) # 依照對應關系翻譯
print(v)
輸出：
1122334455
25. partition
分割，保留被當作分割符的元素 。split 方法不會保留被當作分割符的元素。
content = "李泉愛劉康愛劉一"
v = content.partition('愛') # partition
print(v)
v1 = content.split('愛')
print(v1)
輸出：
('李泉', '愛', '劉康愛劉一')
['李泉', '劉康', '劉一']
partition 分割後的值是元組類型，并且隻能以第一個分割符分割
split 分割後的值是清單類型
26. replace (替換)
content = "李泉SB劉康SB劉浩SB劉一"
v = content.replace('SB','Love')
print(v)
v = content.replace('SB','Love',1) # 隻替換第1個
print(v)
輸出：
李泉Love劉康Love劉浩Love劉一
李泉Love劉康SB劉浩SB劉一
27. zfill
填充0，包含已存在字元
name = "alex"
v = name.zfill(20)
print(v)
輸出：
0000000000000000alex
28. 額外功能：
# name = "alex"
# name[0]
# name[0:3]
# name[0:3:2]
# len(name)
# for循環，每個元素是字元
2. int 整數
1. bit_length
目前整數用二進制表示時占用幾個二進制位
age = 4 # 二進制為100
print(age.bit_length())
輸出：
3
2. to_bytes
擷取目前資料的位元組表示
age = 15
v = age.to_bytes(10,byteorder='big')
v1 = age.to_bytes(10,byteorder='little')
print(v)
print(v1)
輸出：
b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0f'
b'\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00'
3. 布爾值（bool）
布爾值隻有True和False
* 轉換
*
* 數字轉布爾值，隻有0是False，其他都為True；
* 字元串轉布爾值，隻有”“(空)是False，其他都為True；
4. list 清單
1) append (追加)
user_list = ['李泉','劉一','劉康','豆豆','小龍'] # 可變類型
user_list.append('劉銘')
print(user_list)
2) clear (清空)
user_list = ['李泉','劉一','劉康','豆豆','小龍'] # 可變類型
user_list.clear()
print(user_list)
3) copy (拷貝(淺拷貝))
user_list = ['李泉','劉一','劉康','豆豆','小龍'] # 可變類型
v = user_list.copy()
print(v)
print(user_list)
4) count (計數)
user_list = ['李泉','劉一','李泉','劉康','豆豆','小龍'] # 可變類型
v = user_list.count('李泉')
print(v)
輸出：
2
5) extend (擴充原清單)
user_list = ['李泉','劉一','李泉','劉康','豆豆','小龍']
user_list.extend(['郭少龍','郭少霞'])
print(user_list)
輸出：
['李泉', '劉一', '李泉', '劉康', '豆豆', '小龍', '郭少龍', '郭少霞']
6) index
查找元素索引，沒有會報錯
user_list = ['李泉','劉一','李泉','劉康','豆豆','小龍']
v = user_list.index('劉康')
print(v)
7) pop
通過索引删除元素，并且傳回被删除的元素
ser_list = ['李泉','劉一','李泉','劉康','豆豆','小龍'] # 可變類型
v = user_list.pop(1)
print(v)
print(user_list)
輸出：
劉一
['李泉', '李泉', '劉康', '豆豆', '小龍']
8) remove
通過指定元素來删除元素
user_list = ['李泉','劉一','李泉','劉康','豆豆','小龍'] # 可變類型
user_list.remove('劉一')
print(user_list)
9) reverse (翻轉)
user_list = ['李泉','劉一','李泉','劉康','豆豆','小龍'] # 可變類型
user_list.reverse()
print(user_list)
輸出：
['小龍', '豆豆', '劉康', '李泉', '劉一', '李泉']
10) sort (排序)
nums = [11,22,3,3,9,88]
print(nums)
# 排序，從小到大
nums.sort()
print(nums)
# 從大到小
nums.sort(reverse=True)
print(nums)
11) 額外操作
user_list = ['李泉','劉一','李泉','劉康','豆豆','小龍']
user_list[0] # 通過索引擷取值
user_list[1:5:2] # 切片，步長
del user_list[3] # 通過索引删除元素
for i in user_list: #循環清單
print(i)
user_list[1] = '姜日天' #通過索引修改元素值
5. 元組
- 元組可以看作是隻讀清單，元組内的元素不可修改
定義元組：
user_tuple = ('alex','eric','seven','alex')
1) count (計數)
user_tuple = ('alex','eric','seven','alex')
v = user_tuple.count('alex')
print(v)
2) index
擷取值的第一個索引位置
user_tuple = ('alex','eric','seven','alex')
v = user_tuple.index('alex')
print(v)
3) 額外操作
user_tuple = ('alex','eric','seven','alex')
for i in user_tuple: # 周遊元組中的元素
print(i)
v = user_tuple[0] # 擷取元組内的元素
v = user_tuple[0:2] # 切片
print(v)
4) 元組嵌套清單
user_tuple = ('alex','eric','seven',['陳濤','劉浩','趙芬芬'],'alex')
#user_tuple[0] = 123 #x錯誤
#user_tuple[3] = [11,22,33] #x錯誤，不可以修改元組中的元素本身
user_tuple[3][1] = '劉一' # 可以修改元組中嵌套的清單中的元素
print(user_tuple)
總結：元組中元素是可變的資料類型時，那麼可以修改此元素内的子元素，但是不可以替換此元素；元組中的元素是不可變的資料類型時，則不可以修改。
5) 元組注意事項
定義元組時，在元組的最後一個元素後面盡量跟一個逗号
因為當元組中隻有一個元素時，如果沒在元素後邊加逗号，則會将這個元組當成一個字元串，示例代碼：
li = ('alex')
print(li)
print(type(li))
輸出：
alex
<class 'str'>
加上逗号後：
li = ('alex',)
print(li)
print(type(li))
輸出：
('alex',)
<class 'tuple'>
6. dict 字典
字典也是可變的資料類型
字典的特性：
- dict是無序的
- key必須是唯一的,so 天生去重
1) clear (清空)
dic = {'k1':'v1','k2':'v2'}
dic.clear()
print(dic)
2) copy (淺拷貝)
dic = {'k1':'v1','k2':'v2'}
v = dic.copy()
print(v)
3) get
根據key擷取指定的value；不存在不報錯
dic = {'k1':'v1','k2':'v2'}
v = dic.get('k1111',111) # 不存在會傳回給定值111，沒有指定值會傳回None
print(v)
v = dic['k1111'] # 不存在會報錯
print(v)
4) pop
删除鍵并擷取對應的value值
dic = {'k1':'v1','k2':'v2'}
v = dic.pop('k1')
print(dic)
print(v)
輸出：
{'k2': 'v2'}
v1
5) popitem
随機删除鍵值對，并擷取到删除的鍵值
dic = {'k1':'v1','k2':'v2'}
v = dic.popitem()
print(dic)
print(v)
輸出：
{'k2': 'v2'}
('k1', 'v1')
另一種玩法：
dic = {'k1':'v1','k2':'v2'}
v = dic.popitem() # ('k2', 'v2')
print(dic)
print(v[0],v[1])
輸出：
{'k2': 'v2'}
k1 v1
dic = {'k1':'v1','k2':'v2'}
k,v = dic.popitem() # ('k2', 'v2')
print(dic)
print(k,v)
輸出：
{'k2': 'v2'}
k1 v1
6) setdefault
增加，如果存在則不做操作
dic = {'k1':'v1','k2':'v2'}
dic.setdefault('k3','v3') # 将第1個參數設為key,第2個參數設為value
print(dic)
dic.setdefault('k1','1111111') # k1是存在的，看輸出的結果是否有變化
print(dic)
輸出：
{'k2': 'v2', 'k3': 'v3', 'k1': 'v1'}
{'k2': 'v2', 'k3': 'v3', 'k1': 'v1'}
7) update
批量增加或修改；無，則增加；有，則修改
dic = {'k1':'v1','k2':'v2'}
dic.update({'k3':'v3','k1':'v24'})
print(dic)
輸出：
{'k2': 'v2', 'k3': 'v3', 'k1': 'v24'}
8) fromkeys
通過一個清單生成預設dict,有個沒辦法解釋的坑，少用這個吧
dic = dict.fromkeys(['k1','k2','k3'],123)
print(dic)
dic = dict.fromkeys(['k1','k2','k3'],123)
dic['k1'] = 'abc'
dic['k2'] = 'ABC'
print(dic)
輸出：
{'k2': 123, 'k3': 123, 'k1': 123}
{'k2': 'ABC', 'k3': 123, 'k1': 'abc'}
注意這個坑：
dic = dict.fromkeys(['k1','k2','k3'],[1,])
dic['k1'].append(222)
print(dic)
輸出：
{'k2': [1, 222], 'k3': [1, 222], 'k1': [1, 222]}
注意：以上代碼，本來我隻想對k1的value進行追加一個值222，但是從列印的結果看，k1、k2、k3的value均被追加了這個值。
9) 額外操作
- 字典可以嵌套
- 字典key: 必須是不可變類型
例：可以這樣定義一個字典，各種嵌套
dic = {
'k1': 'v1',
'k2': [1,2,3,],
(1,2): 'lllll',
1: 'fffffffff',
111: 'asdf',
}
print(dic)
輸出：
{(1, 2): 'lllll', 'k2': [1, 2, 3], 111: 'asdf', 1: 'fffffffff', 'k1': 'v1'}
# 删除key
dic = {'k1':'v1'}
del dic['k1']
7. set 集合
集合，是不可重複的清單；可變的資料類型
集合建立
# 兩種方法：
a = {1,2,3,4,5}
b = set([4,5,6,7,8])
集合運算
| 名稱 | 英文方法 | 運算符号 | 功能 | 釋義 |
|---|---|---|---|---|
| 交集 | a.intersection(b) | a & b | a與b 的交集 | a與b都存在的值 |
| 并集 | a.union(b) | a (管道符) b | a與b的并集 | 将a與b融合在一起，去除重複的值 |
| 差集 | a.difference(b) | a - b (減号) | 差集，in a but not in b | a中存在的，且b中不存在的 |
| 對稱差集 | a.symmetric_difference(b) | a ^ b | a與b 的對稱差集 | 将a和b整合,去除a與b都有的值 |
| 子集 | a.issubset(A) | 無 | 判斷a 是A 的子集 | 判斷a是否存在于A中 |
| 父集 | print(A.issuperset(a)) | 判斷A 是a 的父集 | 判斷A是否包含a |
總結：對稱差集 等于 并集 減 交集
1. isdisjoint
判斷兩個集合是否存在交集
a.isdisjoint(c) # a與c 存在交集傳回False，不存在交集傳回True
2. difference_update
擷取s1 與s2的差集，并重新指派給s1
s1 = {"alex",'eric','tony','李泉','李泉11'}
s2 = {"alex",'eric','tony','劉一'}
s1.difference_update(s2)
print(s1)
輸出：
{'李泉11', '李泉'}
3. discard（丢棄）
丢棄集合中指定的元素，如果集合中沒有此元素，則不做操作
s1 = {"alex",'eric','tony','李泉','李泉11'}
s1.discard('alex')
print(s1)
4. remove (移除)
有，則移除；沒有，則報錯
s1 = {"alex",'eric','tony','李泉','李泉11'}
s1.remove("alex")
print(s1)
5. update
更新集合，已有的元素，不變，沒有，則添加
s1 = {"alex",'eric','tony','李泉','李泉11'}
s1.update({'alex','123123','fff'})
print(s1)
輸出：
{'alex', 'tony', '123123', 'eric', 'fff', '李泉', '李泉11'}
6. pop （随機删除）
随機删除并傳回被删除的集合元素,如果集合為空，則報錯。
s1 = {"alex",'eric','tony','李泉','李泉11'}
v = s1.pop()
print(s1)
print(v)
輸出：
{'李泉11', 'alex', 'tony', '李泉'}
eric
7. add (添加)
無，則添加；有，則不做操作
s1 = {"alex",'eric','tony'}
s1.add('seven')
print(s1)
輸出：
{'seven', 'tony', 'alex', 'eric'}
8. symmetric_difference_update
取對稱差集重新指派給s1
s1 = {1,2,3,4}
s2 = {3,4,5,6}
s1.symmetric_difference_update(s2)
print(s1)
輸出：
{1, 2, 5, 6}
9. 周遊集合
s1 = {11,22,33,44}
for i in s1:
print(i)
輸出：
33
11
44
22