Python 数据类型及转换
说明：Python每一个变量在使用前都要赋值，每个变量都有一个数据类型，之前说的type()函数可以查看变量的类型。Python常见的数据类型有：Number（数字）、String（字符串）、Tuple（元组）、List（列表）、Set（集合）、Dictionary（字典），其中前三种内容不可变，后三种是可变的。
一、Number
说明：Number包括int、float、bool、complex等类型
a,b,c,d = 20, 3.1415, True, 4+3j
print(type(a), type(b), type(c), type(d))
# 返回 <class 'int'> <class 'float'> <class 'bool'> <class 'complex'>
还可以用isinstance()函数判断类型
a=11
isinstance(a,int)
#返回 True
isinstance()和type()区别：
- type()不会认为子类是一种父类类型。
- isinstance()会认为子类是一种父类类型。比如：
class A:
pass
class B(A):
pass
>>>isinstance(A(),A) #A()是A类的实例化
# True
>>>isinstance(B(),A)
# True
>>>type(A())==A
# True
>>>type(B())==A #type函数不会认为B类是A类型
# False
可以用issubclass()函数判断是不是子类：
class A:
pass
class B(A):
pass
>>>issubclass(B,A) #这里的参数要输入类名
# True
>>>issubclass(bool,int)
# True 返回结果是True，说明bool 是int的子类，那么 True，False可以和数字运算
>>>True == 1
# True
>>>False == 0
# True
>>>True+1
# 2
当你给一个变量赋值的时候其实已经创建了一个相应类型的对象
num = 1 #相当于 num = int(1)
>>> num #返回1
num = int('222') #相当于创建了一个int类型对象，并把字符串222 转换成了 int类型
类型的显示转换：
# int -> bool
i = 100
print(bool(i)) #True
i = 0
print(bool(i)) #False
# bool ->int
t = True
print(int(t)) #1
t = False
print(int(t)) #0
# int -> str
i = 100
print(str(i)) # '100'
# str -> int
s = '100'
print(int(s)) # 100
# str -> bool
s = 'hello'
print(bool(s)) #True
s = ''
print(bool(s)) # False
# bool -> str
t = True
print(str(t)) # 'True'
二、字符串String
取值基本操作：
#索引（下标）从前向后从0开始值越来越大，索引从后向前是-1开始，越往前越小，依次是 -2，-3。。。
str = 'hello,world'
print(str[0:-1]) # hello,worl ，这是切片操作，从0（第一个开始，到-1最后一个，但是根据顾首不顾尾，最后一个不要）
print(str[0]) # h
print(str[1:4]) # ell 顾首不顾尾，从第二个字符开始连续取3个，第5个位置的不要
print(str[5:]) # ,world
print(str*2) # hello,worldhello,world
print(str+'!') # hello,world! ，字符串可以相加的，结果还是字符串
print(str[-1]) # d
如果字符串中有反斜杠，可能导致歧义，字符串前加r可以避免歧义：
str = 'hell\no'
print(str) #返回两行，第一行 hell ,第二行 o，因为\n代表换行
#可以在字符串引号前面加r避免歧义
str = r'hell\no'
print(str) # hell\no
如果更改字符串的值试试：
str = 'hello' #把o改成a
str[4] = 'a' # 会直接报错，string类型内部的内容不能直接改
报错提示：
切片补充：
#上面已经演示过切片
#切片规则是： str[索引：索引：步长],步长就是相隔几个取一个值
s = 'abcdefg'
#取第1，3，5。。的位置的值 aceg 可以这样：
print(s[::2]) # aceg 两个冒号说明最后一个数字是步长，如果一个冒号，说明是取值范围
print(s[:-1]) # abcdef 不取最后一个字符，前面的0省略了，如果取最后一个的表达式是： s[-1]
print(s[::-1]) # gfedcba 倒叙排列字符串，这个功能很巧妙，可以应用到列表list 和 元组 tuple
字符串常用方法（函数）：
s = 'hello,world'
# upper(),lower(),captalize(),swapcase(),title()
print(s.upper()) # HELLO,WORLD （大写）
print(s.lower()) # hello,world （小写）
print(s.captalize()) # Hello,world （首字母大写）
print('Hello,World'.swapcase()) # hELLO,wORLD （大小写转换）
print('hello,world'.title()) # Hello,World （每个单词首字母大写）
# count()
print(s.count('l')) # 3 ，l字符出现了3次
print(s.count('l',1,9)) # 2, l字符在1到9索引的位置出现了2次
print(s.count('l',1,10)) # 3, l字符在1到10的位置出现了3次，这里也相当于切片
# startswith(),endswith()
print(s.startswith('h')) # True, 字符串s 以h开头
print(s.startswith('l',2,9)) # True, s按照索引2，9切片后，以l开头
print(s.endswith('d')) # True
# split()
a,b = s.split(',') #分割函数
print(a) # hello 其中，a和b都是字符串str类型
print(b) # world
c = s.split(',')
print(c) # ['hello', 'world']
type(c) # <class 'list'> ,字符串分割完是个列表list
d = s.split('|') #如果按照一个不存在的字符分割呢？
print(d) # ['hello,world'] ，这里有细微的差别，只有一对单引号，说明列表list只有一个元素
type(d) #<class 'list'> ,结果类型仍然是个列表list
# strip()
print(s.strip('h')) # ello,world （开头和结尾删掉指定字符）
print(s.strip('d')) # hello,worl
lstrip() #左删除
rstrip() #右删除
# replace()
print(s.replace('o','a',1)) # o替换成a ，不超过1次，并没有改变s，可以再次print(s)看一下
# format()
print('{} {} {}'.format('lyq', 21, 'grade1')) # lyq 21 grade1 (按顺序)
print('{1} {0} {1}'.format('lyq', 21, 'grade1')) # 21 lyq 21 （按序号）
print('{name} {age} {grade}'.format(name ='lyq',age= 21,grade = 'grade1')) # lyq 21 grade1 （按键值对）
# isalnum(),isalpha() ,isdecimal()
print('lyq21'.isalnum()) # True
print('lyq21'.isalpha()) # False
pritn('3.3'.isdecimal()) # False 只允许数字
# center()
print('lyq'.center(20,'*')) #********lyq*********
# find(),index()
print(s.find('ll')) # 2 , 找到指定字符的位置，找不到返回-1
print(s.index('ll')) # 2，找不到，报错
三、元组tuple
说明：元组中的数据创建之后，不能更改，只能查（针对重要的数据），元组内元素可重复，用小括号表示，内部必须有逗号，只有一个元素也要写逗号
切片
tu = ('lyq','Tom','Lucy','Lily','Jerry')
print(tu[0]) # lyq
print(tu[-1]) # Jerry
print(tu[:2]) # ('lyq','tom') # 切片之后还是元组
print(tu[::2]) # ('lyq','Lucy','Jerry') 加上步长为2
print(tu[::-1]) # ('Jerry', 'Lily', 'Lucy', 'Tom', 'lyq') 步长为-1，倒序
for循环遍历
for name in tu:
print(name) #循环输出tu元组内元素
index()函数
print(tu.index('lyq')) # 0 返回索引值为0，那是否就是说元组内元素是有序的？
count()函数
print(tu.count('lyq')) # 1 统计指定元素在元组中出现次数，说明元组内元素可重复
元组可以直接相加+
print(('a','b')+(1,2,3)) # ('a','b',1,2,3)
len()
print(len(tu)) # 5 返回元组元素个数
max(),min()
print(max((1,2,3,44))) # 44 max()函数括号内，必须是元组
list -> tuple 转换
l1 = ['a','b',1,3,45]
tu1 = tuple(l1)
type(tu1) # <class 'tuple'> #把list类型显示转换成tuple元组
元组的拆包
四、列表list
说明：
- 为什么要出现list列表数据类型，字符串存的东西太少，太局限了，列表可以放更大更长的数据元素，而且元素可以是不同类型的，比如[12,'lyq',(1,2,3,'a','b')],这个列表里有数字，字符串，元组。
- 列表也是有序的，因此，可索引，可切片
- 列表查询速度慢，字典查询速度快
列表的创建：
#方法一
li = [1,3,4]
print(li) #[1, 3, 4]
#方法二
l2=list('hello')
print(l2) #['h', 'e', 'l', 'l', 'o']
列表list的索引和切片
li = [100,'abc',True,[1,2,3]]
print(li[0],type(li[0])) #100 <class 'int'> （不同元素的类型可以不一致），操作和string数据类型一样
print(li[3],type(li[3])) #[1, 2, 3] <class 'list'>
print(li[:3:2]) #[100, True]
print(li[1:3]) #['abc', True]
print(li[1:4:2]) #['abc', [1, 2, 3]]
列表list的增：
# append()
l1 = ['Tom','Cat','Lily']
l1.append('lucy')
print(l1) #['Tom', 'Cat', 'Lily', 'lucy'] ，加在最后
#小测试，模拟持续录入员工，按q 退出
while 1:
name = input('Entry a name:')
if name == 'q':
break
else:
l1.append(name)
print(l1)
# insert()
l1.insert(1,'Jerry')
print(l1) #['Tom', 'Jerry', 'Cat', 'Lily', 'lucy'] ,在1位置前插入一个名字
# extend()
l1 = ['Tom','Cat','Lily']
l1.extend('abc')
print(l1) #['Tom', 'Cat', 'Lily', 'a', 'b', 'c'] ,结果把字符串拆分以后逐个append到了l1上
l1.extend(['tt',3,4]) #参数还可以是列表list，然后把列表每个元素逐个append到列表里去
print(l1) #['Tom', 'Cat', 'Lily', 'a', 'b', 'c', 'tt', 3, 4]
列表的删：
# pop()
l1 = ['Tom','Cat','Lily']
name=l1.pop(-1) #pop删除返回的是索引处的元素 ,默认删除最后一个
print(name) #Lily
print(l1) #['Tom','Cat']
# remove()
l1 = ['Tom','Cat','Lily','Cat']
l1.remove('Cat')
print(l1) #['Tom', 'Lily', 'Cat'] ,如果有重名的话，删除第一个
# clear()
l1 = ['Tom','Cat','Lily','Cat']
l1.clear() # 就清空了，是个空列表
# del
l1 = ['Tom','Cat','Lily','Cat']
del l1[-1]
print(l1) #['Tom', 'Cat', 'Lily']，删除最后一个
l2 = [1,2,3,4,5,6]
del l2[1:3]
print(l2) # [1,4,5,6] ,还可以按照切片删除
列表的改：
l1 = ['Tom','Cat','Lily','Cat']
l1[0]='Jerry'
print(l1) #['Jerry', 'Cat', 'Lily', 'Cat']
列表的嵌套：
# 把abc变成大写并放回原处
l1=[1,2,'abc',[3,'hello ',4]]
l1[2]=l1[2].upper()
print(l1)
# [3,'hello ',4]中追加一个元素5
l1[3].append(5)
# 将l1中的hello 追加一个world字符串
l1[3][1] = l1[3][1]+'world'
其他操作：
# count()
l1=[1,2,'abc',[3,'hello ',1]]
l1.count(1) # 1,只计算第一个1，计数
# index()
l1.index(1) # 0, 1的位置在0（索引是0）
# reverse()
l1.reverse()
print(l1) # [[3, 'hello ', 1], 'abc', 2, 1] ,l1用了这个函数reverse()直接本身就转置了
# sort()
l1 = [3,5,7,2,9]
l1.sort()
print(l1) # [2,3,5,7,9]
列表可以和数字运算
l1 = ['Tom','Jerry']
print(l1+l1) # ['Tom', 'Jerry', 'Tom', 'Jerry']
print(l1*3) # ['Tom', 'Jerry', 'Tom', 'Jerry', 'Tom', 'Jerry']
列表推导式：
- 说明：推导式是一种特殊的数据处理方式，精简，易读，好用，其实是对列表进行了加工，生成一个新的列表，字典，元素，集合都有推导式，推导式格式如下：
# [表达式 for 变量 in 列表 ]
# 或
# [表达式 for 变量 in 列表 if 条件表达式]
- 例子：
# 获取名字列表names中名字长度为3的名字列表，并大写
names = ['lyq','Tom','Jerry','Lucy','Lily']
names_new = [name.upper() for name in names if len(name)==3] # ['LYQ', 'TOM']
#这里的推导式也是用列表的中括号，说明推导完是个列表，字符串str的大写用upper()函数
列表的函数：
# len()
names = ['lyq','Tom','Jerry','Lucy','Lily']
print(len(names)) # 5
# list() ,之前元组里用到了，可以将元组直接转化成列表的函数
print(list((1,3,4,'a'))) # [1, 3, 4, 'a'] ，元组变成了列表
# 和上面的append(),count(),sort(),reverse()的区别就是，len()函数内放的是list列表，而append()是让列表调用的，比如：l1.append(),l1.reverse()所以这些可以称作方法。len()称作函数，方便区别对待。
列表的拆包：
# 和元组拆包一样
l1 = ['lyq',21]
name,age = l1
print(name) # 'lyq'
print(age) # 21
五、字典
说明：
- 列表可以存的数据量是大，但是它的查询比较慢，而且数据与数据之间关联性不强，于是引入了字典数据类型。
- 字典以大括号｛｝括起来，里面存放的都是键值对，键值对用冒号：隔开（key:value）。
- 其中键key必须是不可变的数据类型，比如：int，str，bool，tuple。而值value可以是任意数据类型，包括对象。
- 字典3.6版本以后是有序的。
- 字典的查询速度非常快，不过内存开销比较大，用空间换了时间。
字典的创建：
# 1、最简单的
dic = {1:'lyq',2:'Tom',3:'Jerry'}
print(dic) # {1:'lyq',2:'Tom',3:'Jerry'}
dic = {1:'lyq',2:'Tom',3:'Jerry',3:'Lucy'}
print(dic) # {1: 'lyq', 2: 'Tom', 3: 'Lucy'} ,出现了2个键为3的键值对，结果以后面的键值对为准
# 2、用嵌套元组
dic = dict(((1,'lyq'),(2,'Tom'),(3,'Jerry'))) # dict()函数里面是嵌套的元组
print(dic) # {1: 'lyq', 2: 'Tom', 3: 'Jerry'}
# 3、用等式
dic = dict(lyq=1,Tom=2,Jerry=3)
print(dic) # {'lyq': 1, 'Tom': 2, 'Jerry': 3}
# 如果用下面这种方式，会报错，dic = dict(1=lyq,2=Tom,3=Jerry)，报错说明1=lyq的时候，1不能被赋值，反过来确是可以的。
# 4、大括号
dic = dict({1:'lyq',2:'Tom',3:'Jerry'})
print(dic) #{1: 'lyq', 2: 'Tom', 3: 'Jerry'} ，和方法1相似，有些画蛇添足了
# 5、zip()
dic = dict(zip([1,2,3],['lyq','Tom','Jerry']))
print(dic) #{1: 'lyq', 2: 'Tom', 3: 'Jerry'}，这里是zip函数，zip()里面是2个列表，前面的列表作为key，后面的列表作为value，zip是拉链函数，它能帮你把键值对进行匹配
# 6、字典推导式
dic = { k:v for k,v in [(1,'lyq'),(2,'Tom'),(3,'Jerry')]}
print(dic) #{1: 'lyq', 2: 'Tom', 3: 'Jerry'} ,这里in后面是个列表，列表里是3个元组，相当于，对元组逐个拆包，外面用大括号。如果是元组嵌套也行，比如：dic = { k:v for k,v in ((1,'lyq'),(2,'Tom'),(3,'Jerry'))}，就是in后面的是个嵌套的元组。和方法2类似
一个复杂的字典例子：
dic = {123:456,True:789,"name":"lyq",'course':['语文','数学','英语'],(1,3,5):'奇数元组'}
print(dic[123]) # 456
print(dic['name']) # lyq
print(dic[(1,3,5)]) # 奇数元组,访问字典value的时候用到dict[key]的方式
增：
# 直接增加
dic = {'name':'lyq','age':21}
dic['height'] = 177
print(dic) # {'name': 'lyq', 'age': 21, 'height': 177}
dic['name'] = 'Tom'
print(dic) # {'name': 'Tom', 'age': 21, 'height': 177} ,这里直接把name的值改了，说明字典是可变得
# setdefault()
dic = {'name':'lyq','age':21}
dic.setdefault('height',177)
print(dic) # {'name': 'lyq', 'age': 21, 'height': 177}
dic.setdefault('name','Tom')
print(dic) # {'name': 'lyq', 'age': 21, 'height': 177},并没有改变name的value值
删：
# pop()
dic = {'name': 'lyq', 'age': 21, 'height': 177}
ret = dic.pop('name')
print(ret) # lyq ，pop()方法的返回值是括号内，key对应的value
print(dic) # {'age': 21, 'height': 177}
# pop()可以设置默认返回值
ret1 = dic.pop('weight',None)
print(ret1) # None ,尝试删除weight键对应的value，给了一个默认返回值None，结果没有找到weight键，就把None返回了。
print(dic) # {'age': 21, 'height': 177} ，原字典内容不变
# popitem()
dic = {'name': 'lyq', 'age': 21, 'height': 177}
ret = dic.popitem()
print(ret) # ('height', 177),这里的返回值是所删除的键值对组成的元组。
print(dic) # {'name': 'lyq', 'age': 21}
# clear()
dic = {'name': 'lyq', 'age': 21, 'height': 177}
dic.clear()
print(dic) # {}
# del
dic = {'name': 'lyq', 'age': 21, 'height': 177}
del dic['name']
print(dic) # {'age': 21, 'height': 177}
del dic
print(dic) # 报错，已经删了dic了，就不存在了
改：
# 用键值对
dic = {'name': 'lyq', 'age': 21, 'height': 177}
dic['name'] = 'Tom' # {'name': 'Tom', 'age': 21, 'height': 177}
# update方法
dic = {'name': 'lyq', 'age': 21, 'height': 177}
dic.update(sex='男',height=180) # {'name': 'lyq', 'age': 21, 'height': 180, 'sex': '男'}, 改了height，增加了sex，参数表中，等式前面不用加引号
dic = {'name': 'lyq', 'age': 21, 'height': 177}
dic.update([('sex','男'),('weight',65)])
print(dic) # {'name': 'lyq', 'age': 21, 'height': 177, 'sex': '男', 'weight': 65} ,update里面是个列表，用元组也行，用集合也行，都行
dic = {'name': 'lyq', 'age': 21, 'height': 177}
dic1 = {'sex':'男','weight':65}
dic.update(dic1)
print(dic) # {'name': 'lyq', 'age': 21, 'height': 177, 'sex': '男', 'weight': 65}
print(dic1) # {'sex':'男','weight':65} ,不变
查：
# 通过键来查
dic = {'name': 'lyq', 'age': 21, 'height': 177}
print(dic['name']) # lyq
# get()方法
dic = {'name': 'lyq', 'age': 21, 'height': 177}
print(dic.get('name')) # 'lyq'
print(dic.get('sex')) # None
result = dic.get('sex','没有此键')
print(result) # 没有此键
# keys()
dic = {'name': 'lyq', 'age': 21, 'height': 177}
print(dic.keys()) # dict_keys(['name', 'age', 'height']),这里类型不是列表，类型是dict_keys,跟列表很像，可以转化成列表(下面的values(),items()也都可以)：
print(list(dic.keys())) # ['name', 'age', 'height']
# values()
print(dic.values()) # dict_values(['lyq', 21, 177])
# items()
print(dic.items()) # dict_items([('name', 'lyq'), ('age', 21), ('height', 177)])
字典的拆包：
# 拆包也叫分别赋值
a,b = {'name':'lyq','age':21}
print(a) # name,这里的结果不是{'name':'lyq'},怎么办？
print(b) # age
字典的嵌套：
dic = {
'name':'lyq',
'age':21,
'hobbies':['music','swimming','sleep']
'score':{'Python':98,'Mysql':97.5,'C++':90}
}
# 获取姓名
print(dic['name']) # lyq
# 获取Python成绩
print(dic['score']['Python']) # 98
六、集合Set
说明：
- 集合是无序的，不重复的
- 有去重的功能，把一个列表变成集合，就自动去重
- 可以测试两组数据之间是 交集、并集等关系
集合的创建：
set1 = set({1,2,'lyq'})
set2 = {1,2,'lyq'}
print(set1) # {1,2,'lyq'}
print(set2) # {1,2,'lyq'}
print(set1 == set2) # True
增：
# add()
set1 = {'lyq','Tom','Jerry'}
set1.add('Lucy')
print(set1) # {'Lucy', 'Tom', 'Jerry', 'lyq'}
print(set1[0]) # 报错，集合无序的，不能用下标来描述
# update()
set1 = {'lyq','Tom','Jerry'}
set1.update('Lucy')
print(set1) # {'Tom', 'L', 'y', 'u', 'Jerry', 'c', 'lyq'} ,把Lucy拆了居然
set1.update(['Lily','老王'])
print(set1) # {'Tom', 'L', 'y', 'u', '老王', 'Lily', 'Jerry', 'c', 'lyq'} ， 这个没有拆
删：
set1 = {'lyq','Tom','Jerry'}
set1.remove('lyq')
print(set1) # {'Tom', 'Jerry'}
set1.remove('Lucy') # 报错
set1.pop()
print(set1) # {'Jerry'} ,随机删除一个值
set1.clear()
print(set1) # set()
del set1
print(set1) # 报错，已经不存在set1了
集合的其他操作：
# 交集 (& or intersection())
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 & set2) # {4, 5}
print(set1.intersection(set2))
# 并集 (| or union())
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 | set2) # {1, 2, 3, 4, 5, 6, 7, 8}
print(set1.union(set2)) # {1, 2, 3, 4, 5, 6, 7, 8}
# 差集 (- or difference())
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1-set2) # {1, 2, 3}
print(set1.difference(set2)) # {1, 2, 3}
# 反交集 (^ or symmetric_difference)
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 ^ set2) # {1, 2, 3, 6, 7, 8}
print(set1.symmetric_difference(set2)) # {1, 2, 3, 6, 7, 8} ，其实是并集去掉交集
print((set1|set2)-(set1&set2)) # {1, 2, 3, 6, 7, 8}
# 子集 与 超集
set1 = {1,2,3}
set2 = {1,2,3,4,5}
print(set1<set2) # True
print(set1.issubset(set2)) # True
print(set2>set1) # True
print(set2.issupperset(set1)) # True
列表能不能变成集合？
l1 = [1,1,3,4,5]
set1 = set(l1) # 显式转换
print(set1) # {1, 3, 4, 5} ,发现集合一个很赞的功能，可以对列表去重