python3数据类型非常全的总结，适合复习看

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
此处总结自太白金星大佬，谢谢大佬博客贡献。