python基礎數據類型：
int, bool, str, list, tuple, dict, set
補充： 列表、元組、字典都可以使用拆包的方法:
1、拆包： a, b = 1, 2
2、列表：
a, b = [1, 2]
3、元組：
a, b = (1, 2)
4、字典：
a, b = {“name”: “wwq”, “age”: 22}
#這裏注意一下a, b的值爲
#a = “name”
#b = “age”
一、int: 直接使用即可
二、bool：。。。
三、str：
1、可下表索引，可使用切片。
str[0]、str[1]、str[::2]…
2、常用方法：
s.count()
s.startswith()
s.endswith()
s.split()
“…”.formt()
1）計算字符串中元素的出現次數
s = "wqreretrwtrw"
cnt = s.count("e", 1, 6) #可以取切片
2）判斷字符串的開頭和結尾, str.startswith("待檢查字符串", num1, num2), str.endswith("待檢查字符串", num1, num2)， 其中num1均爲判斷的起始位置，num2均爲判斷結束位置，且爲[num1, num2)。
s = "hellow world"
ans1 = s.startswith("el", 1， 5)
ans2 = s.endswith("ow", 1, 6)
3)str.split()分隔字符串，str.split("用於分隔字符串"，cnt) 默認從左分隔，cnt指明分隔次數，默認分隔整個字符串。
str.rsplit("用於分隔字符串", cnt) 從右邊分隔，cnt指明分隔次數，默認分隔整個字符串。
兩個分隔結果均是列表，且不含用於分隔的字符串。
4）format的三種玩法：
pstr1 = "{}, {}, {}".format("dsa", 2, "dd")
pstr2 = "{2}, {0}, {1}".format("dsa", 2, "dd")
pstr3 = "{name}, {age}, {sex}".format(name = "wwq", sex ="man", age = 20)
5)去掉字符串中的一些元素，s.strip("待去掉字符組成的字符串")，有返回值，返回值爲去掉之後的字符串，且爲原地修改
s = "*dsadsa**"
print(s.strip("*"))
print(s.lstrip("*"))
print(s.rstrip("*"))
6)replace
s = "1 2 3 4"
s.replace("1", "a", 1)
7)find() 返回找的的元素下標，找不到返回-1
s.find("dsa", 1, 6)
8)index() 返回找到元素的下標，找不到就報錯
s = "dsadfd"
s.find("dsa", 1, 6)s = "dsadfd"
9）captalize首字母大寫, swapcase大小寫翻轉,title每個單詞首字母大寫
s = "wwq say hellow"
print(s.capitalize())
print(s.swapcase())
print(s.title())
10)居中：總長度，空白處填充字符：
ans = s.center(25, "&")
四、列表list：
1、增
ll.append(待插入元素) #最後面追加
ll.insert(下標， 待插入元素) #插入在列表的任意位置,插入位置及後面元素後移
ll.extend(可迭代的) #將後面可迭代的東西每個元素迭代插入列表的後面
ll.extend()例子：
l = [1, 2, 'a']
l.extend('abc')
print(l) # [1, 2, 'a', 'a', 'b', 'c']
l.extend([0, [0, 0, 0]])
print(l) # [1, 2, 'a', 'a', 'b', 'c', 0, [0, 0, 0]]
2、刪：
ll.pop(下標) #按照下標刪除元素，且返回刪除元素值
del ll[下標] #按照下標刪除元素，無返回值，可使用切片方法
del ll[0]
del ll[1:-1:2]
...
ll.remove(待刪除元素) #按照值刪除元素
ll.clear() #清空列表
3、改：很常規：
索引改
ll[0] = 'a'
切片改：
將切片指明的位置改爲賦值內容，如果長度不同（長或者短），則完全替換爲賦值內容。
ll = [1, 2, 3, 4, 5]
ll[1:] = 'ab' ## [1, 'a', 'b']
ll = [1, 2]
ll[1:] = "abcd" #[1, 'a', 'b', 'c', 'd']
指定步長時，改變位置數和賦值的個數需要一樣
ll = [1, 2, 3]
ll[::2] = [0, ['a', 'b', 'c']] # [0, 2, ['a', 'b', 'c']]
4、查
切片或者循環查。
5、常用內置方法:
ll.count(元素) 返回查找元素出現的次數
ll.index(元素) 返回元素第一次出現的位置，無則報錯
ll.sort() 原地遞增排序，無返回值 加上關鍵字reverse=True，原地遞減排序
ll.reverse() 原地反向存放，無返回值。
6、列表可以相加，或乘以數字
lis1 = [1, 2]
lis2 = [3, 4]
lis = lis1+lis2 #[1, 2, 3, 4]
lis = lis*2 #[1, 2, 1, 2]
注意：
對循環列表，對列表大小做修改時，列表下標會發生改變
example比如：
刪除下面列表奇數下標的數
ll = [11, 22, 33, 44, 55]
使用下面的方法會出錯：
for i in range(len(ll)):
if(i%2 == 1)
ll.pop(i)
正確方法：
1) del ll[1: len(ll): 2]
2)
for i in range(len(ll)-1, -1, -1):
if(i%2 == 1:
ll.pop(i)
五、元組tuple:
最重要的一個特性是定義完成後只可以看，不可以修改
1、可索引、切片
print(tp[0])
print(tp[::2])
2、元組的其他方法：
tp.index(元素) 通過元素值查找第一次出現的下標，找不到報錯
tp.count(元素) 查找元素在元組中出現的次數
拆包
六、字典：
特點就是速度快，但是內存消耗大，原因是內部實現使用的是哈希，使用哈希表具有稀疏性。
1、創建字典的幾種方式：
# 方式1:
以元組爲元素的，列表、元組。。。
dic = dict((('one', 1),('two', 2),('three', 3)))
# dic = dict([('one', 1),('two', 2),('three', 3)])
print(dic) # {'one': 1, 'two': 2, 'three': 3}
# 方式2:
dic = dict(one=1,two=2,three=3)
print(dic) # {'one': 1, 'two': 2, 'three': 3}
# 方式3:
dic = dict({'one': 1, 'two': 2, 'three': 3})
print(dic) # {'one': 1, 'two': 2, 'three': 3}
**********# 方式5:
dic = dict(zip(['one', 'two', 'three'],[1, 2, 3]))
print(dic)
*********# 方式6: 字典推導式
# dic = { k: v for k,v in [('one', 1),('two', 2),('three', 3)]}
# print(dic)
*********# 方式7:利用fromkey
example1：
dic = dict.fromkeys('abcd','太白')
print(dic) # {'a': '太白', 'b': '太白', 'c': '太白', 'd': '太白'}
example2：
dic = dict.fromkeys([1, 2, 3], "hellow")
print(dic) #{ 1: 'hellow', 2: 'hellow', 3: 'hellow'}
#￥￥￥￥這裏的一個坑就是如果通過fromkeys得到的是一個可變類型的話，如果更改一個鍵對應的值（只在可變類型裏面添加數據的話），則其他值也跟着修改，若是直接修改類型則不會。
example1：
dic = dict.fromkeys("abc", [])
dic['a'].append(1) # {'a': [1], 'b': [1], 'c': [1]}
example2：
dic = dict.fromkeys("abc", [])
dic['a'] = '1' # {'a': '1', 'b': [], 'c': []}
2、增
1）類似於下標方式直接添加：
dic = {"name": "wwq", "age": 22}
dic["sex"] = "man"
即有則更改，無則添加。
2）setdefault
setdefault有則不更改原值，且返回原值，無則添加，
dic = {"name": "wwq", "age": 22}
temp = dic.setdefault("name", "wdj") #temp = "wwq"
3、刪
1）dic.pop(鍵) 有關鍵字對應的則刪除並返回鍵對應的值，無關鍵字對應的值則返回一個錯誤，可以設置爲None
dic = {"name": "wwq", "age": 22}
temp = dic.pop("name") ## temp = "wwq"
temp = dic.pop("sex", None) ## temp = None
2）del
del dic[鍵] 刪除對應鍵值對，若沒有對應的鍵，則會報錯
example比如：
dic = {"name": "wwq", "age": 22}
del dic["name"]
del dic #刪除整個字典。
3）clear() 清空字典
dic.clear() ## dic : {}
4)popitem 3.5版本之前爲隨機刪除，3.6之後刪除最後一個（以前的字典無序，以後的字典順序和輸入時一樣）,元組形式返回刪除的鍵值對。
dic = {"name": "wwq", "age": 22}
temp = dic.popitem() # temp = ("name", "wwq")
4、改：
1)利用鍵改
dic = {"name": "wwq", "age": 22}
dic["name"] = "wdj"
2)利用dic.update()改
01、dic.update()可更改多項
example1：
dic = {"name": "wwq", "age": 22}
dic.update(sex = "man", height = 175)
example2：
dic = {"name": "wwq", "age": 22}
dic.update([("sex", "man"), ("age", 22)])
02、dic1.update(dic2) 利用另外一個字典添加或更改：
example：
dic1 = {"name": "wwq", "age": 22, "height": 176}
dic2 = {"name": "wdj", "age": 22, "sex": "man"}
dic1.update(dic2)
#dic1 = {'name': 'wdj', 'age': 22, 'height': 176, 'sex': 'man'}
#dic2 = {"name": "wdj", "age": 22, "sex": "man"}
5、查
01、通過鍵查看 dic[鍵]： print(dic["name"])
02、dic.get(鍵 [, 返回值]) 若查找鍵在，則返回值，若不在則返回None或設定的 返回值
example1：
dic = {'name': 'wdj', 'age': 22, 'height': 176, 'sex': 'man'}
ans = dic.get("name") # ans = "wdj"
example2：
dic = {'name': 'wdj', 'age': 22, 'height': 176, 'sex': 'man'}
ans = dic.get("weight", "沒有這個鍵") #ans = "沒有這個鍵"
另：
01 dic.keys() 返回字典所有鍵組成的像列表的東西，返回: dict_keys([鍵列表])
02 dic.values() 返回所有值組成的像列表的東西，返回： dict_values([值列表])
03 dic.items() 返回所有鍵值對元組組成的像列表的東西， 返回： dict_items([(鍵值對1), (鍵值對2), (鍵值對3)...])
通過這三種方法得到的像列表的東西可以轉化成列表：
list(dic.keys()) #[鍵1， 鍵2， 鍵3， 。。。]
list(dic.values()) #[值1， 值2， 值3， 。。。]
list(dic.items()) #[(鍵， 值)， (鍵，值)， (鍵， 值)]
同時也可for循環(舉其中一個例子)：
for i in dic.keys():
print(i)
注：
字典的嵌套：
dic = {"name": "wwq"
"age": 22
"wife": [{"name": "無", "age": "None"}]
"children": {"girl": "東方不敗", "boy": "西方不輸"}
}
獲取戶主名字：
dic["name"]
獲取妻子的名字：
dic["wife"][0]["name"]
獲取男孩子的名字：
dic["children"]["boy"]
！！！！！最後： 我們知道正向遍歷列表並改變列表大小的話，會出問題，在遍歷字典並改變字典大小時會出類似的問題：
比如我們要刪除下面字典鍵中含有'a'的鍵值對：
dic = {"a1": 1, "a2": 2, "name": "wwq"}
報錯方法：
for i in dic.keys():
if 'a' in i:
dio.pop(i)
報錯信息： 在迭代期間改變了字典的大小
正確方法：
lis = lisr(dic.keys())
for k in lis:
if 'a' in k:
dic.pop()
即先把鍵值提取出來，然後遍歷提取出鍵值的列表，刪除滿足要求的鍵值對。
七、集合set:
集合的特點就是元素不重複，內部使用哈希實現。無序
可以用來將列表強制轉化爲集合，去重
可以查看兩個集合的交集、差集、並集等。
1、創建：
set1 = set({1, 2, "wwq"})
set2 = {1, 2, "wwq"}
print(set1) # {1, 2, "wwq"}
print(set2) # {1, 2, "wwq"}
2、增
1)set.add(元素)
set1.add("wdj") # {1, 2, "ww1", "wdj"}
2)set.update(迭代器)可以增加多項，增加的是迭代器的元素單位
set3 = {1, 2}
set.update("abc") #set3 = {1, 2, 'a', 'b', 'c'}
3、刪
1)set.remove(元素)
set1.remove("wwq") #set1 = {1, 2, "wdj"}
2)set.pop() 隨機刪除一個元素，且返回刪除的元素值。
ans = set1.pop() #ans = 1 或 2 或 "wdj"
3）清空集合set.clear() 和 刪除集合del set
set1.clear() #set1 = {} 空集合
del set1 #set1被刪除，沒有這個變量了。
4、判斷集合關係
set1 = {1, 2, 3}
set2 = {2, 3, 4}
1）交集 & 或者 intersection
print(set1 & set2) 或者 print(set1.intersection()) # {2, 3}
2)並集 | 或者 union
print(set1 | set2) 或者 print(set1.union(set2)) #{1, 2, 3, 4}
3)差集 - 或者 difference
print(set1 - set2) 或者 print(set1.difference(set2)) #{1}
4)反交集（就是兩個集合的並集減兩個集合交集） ^ 或者 set.symmetric_difference()
print(set1 ^ set2) 或者 print(set1.symmetric_difference(set2)) # {1, 4}
5)子集和超集（就是全集，通俗不嚴謹講成母集）
set1 = {1, 2, 3, 4, 5, 6}
print(set2 < set1) 或者 print(set2.issubset(set1)) #均表示set2是set1的子集
print(set1 > set2) 或者 print(set1.issuperset(set2)) #均表示set1是set2的超集
6）frozenset(迭代對象) 不可變集合 迭代對象可以是列表、元組、字符串、set集合
s = frozenset("abcd")
print(s, type(s)) # {'a', 'b', 'c', 'd'} <class 'frozenset'>
python的編碼問題和byte類型請看大佬連接：https://www.cnblogs.com/jin-xin/articles/10577131.html
此處總結自太白金星大佬，謝謝大佬博客貢獻。