编程语言
首页 > 编程语言> > Python 数据类型及转换

Python 数据类型及转换

作者:互联网

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()区别:

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

说明:

列表的创建:

#方法一
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

五、字典

说明:

字典的创建:


# 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