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
From: https://www.cnblogs.com/94xzz/p/16598690.html