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} ,发现集合一个很赞的功能，可以对列表去重

标签：转换,lyq,Python,Tom,数据类型,dic,l1,print,name
来源： https://www.cnblogs.com/94xzz/p/16598690.html