python基础—python6种基本数据类型及数据类型之间转换

文章目录

  • 一、python标准数据类型
    • (一)数字类型
      • 整型:int
      • 浮点型:flaot
      • 布尔型:bool
      • 复数类型:complex
    • (二)字符串
    • (三)列表类型
    • (四)元组类型
    • (五)字典类型
    • (六)集合类型
  • 二、python数据类型转换
    • (一)自动类型转换
    • (二)强制类型转换
      • 其他类型 -> str
      • 其他类型 -> 数字型(bool/float/int/complex)
      • 其他类型 -> list
      • 其他类型 -> tuple
      • 其他类型 -> dict
      • 其他类型 -> set


一、python标准数据类型

(一)数字类型

整型:int

1)在数字中,正整数、0、负整数都称为整型。

举例1:

intvar1=100
print(type(intvar1))

运行结果:

2)二进制整型

也可以用二进制表示整型,print自动转换为十进制。

举例1:

intvar2=0b1010
print(intvar2)
print(type(intvar2))

运行结果:

10

浮点型:flaot

1)含有小数点的数据都是浮点型。

举例1:

floatvar1=3.14
print(floatvar1,type(floatvar1))

运行结果:

3.14

2)科学计数法

举例1:

floatvar2 = 3.456e5 #小数点向右移动5位
print(floatvar2,type(floatvar2))

运行结果:

345600.0

布尔型:bool

布尔型数据只有两种:True、False。表示真假。

举例1:

boolvar1 = True
print (boolvar1,type(boolvar1))

运行结果:

True

复数类型:complex

复数为实数加虚数,只要存在虚数,此数据类型就为复数类型。

表达方法1:

complexvar1 = 3-91j
print (complexvar1,type(complexvar1))

运行结果:

(3-91j)

表达方法2:
语法:complex(实数,虚数)

complexvar2 = complex(3,-91)
print (complexvar2,type(complexvar2))

运行结果:

(3-91j)

(二)字符串

1)字符串:str
用引号引起来的就是字符串。
可用:单引号、双引号、三引号

举例1:

strvar1 = 'abc'
strvar2 = "abc,文字"
strvar3 = """
转义字符:\ + 字符
  (1)把无意义的字符变的有意义
  (2)把有意义的字符变的无意义
\\n:换行
\\r\\n:换行
\\t:缩进(tab,水平制表符)
\\r:把\\r后面的字符串直接拉到当前行行首
"""

print (strvar1,type(strvar1))
print (strvar2,type(strvar2))
print (strvar3,type(strvar3))

运行结果:
python基础—python6种基本数据类型及数据类型之间转换_第1张图片

2)元字符串 r+字符串==>表示不转字符,原型化输入字符串。(相当于字符串中给所有特殊意义的字符加了转义符)

举例1:

strvar1=r"C:\Users"
print(strvar1)

运行结果:

C:\Users

(三)列表类型

1)列表:list

1.1)列表创建

  • 一维列表的创建,使用[]可以创建一个列表对象,列表可是一种有序的集合,可以随时添加和删除其中的元素。

举例1:

#创建一个空列表
list1=[]
#定义一个普通列表
list2=[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]

print("list2的元素是",list2,
     "\n显示该函数数据结构类型",type(list2))

运行结果:

list2的元素是 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
显示该函数数据结构类型

  • 多维列表的创建。尽管 list默认是一维的,在实际应用中我们可以根据需要创建多维列表。多维列表的创建可以使用[]嵌套。

举例1:

lists=[[1,2],['a','b']]
print("多维列表:",lists,
	   "\n显示该函数数据结构类型",type(list2))

运行结果:

多维列表: [[1, 2], [‘a’, ‘b’]]
显示该函数数据结构类型

1.2)列表查询

  • 正向索引下标:
    列表元素从左到右依次为:0、1、2、3……

  • 逆向索引下标
    列表元素从右向左依次为:-1、-2、-3、-4、-5……

举例1:

list2=[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]

print("\n列表切分",list2[1:8],
      "\n固定步长访问",list2[::2],
      "\n从后往前访问",list2[-3])

运行结果:

列表切分 [2, 3, 4, 5, 6, 7, 8]
固定步长访问 [1, 3, 5, 7, 9, 11, 13, 15]
从后往前访问 13

举例2:当列表很长的时,要获取列表中最后一个元素,一种方法是使用逆向索引下标,另一种方法是使用len函数获取容器类型数据总长度。

list2=[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]
print("取列表中最后一个元素",list2[len(list2)-1])

运行结果:

取列表中最后一个元素 15

1.3)列表元素增加

  • 列表的增加,append()可以在列表末尾增加新的项目,可以增加一个元素,也可以增加一个list对从成为多维列表。

举例1:

#增加一个元素
list1=[1,2,3,4,5,6]
list1.append(11)
print("增加元素后的列表",list1)

#增加一个list
lists=[[1,2],['a','b']]
lists.append(["hello",5])
print("增加列表后的列表",lists)

运行结果:

增加元素后的列表 [1, 2, 3, 4, 5, 6, 11]
增加列表后的列表 [[1, 2], [‘a’, ‘b’],[‘hello’, 5]]

1.4)列表元素删除

  • 列表的删除,remove()函数可以删除指定值的元素,list.remove()会删除list对象中值为i元素,若不存在这个元素则报错;pop()函数可以删除指定下标的元组,默认为列表对象最后一个元素,list.pop(i)则删除下标为i的元素。

举例1:

#删除list1列表中的元素5
list1=[1,2,3,4,5,6]
list1.remove(5)

#删除lists列表对象的最后一个元素
lists=[[1,2],['a','b']]
lists.pop()

print("删除指定下标元素后的列表对象",list1,
     "\n删除最后一个元素的列表对象",lists)

运行结果:

删除指定下标元素后的列表对象 [1, 2, 3, 4, 6]
删除最后一个元素的列表对象 [[1, 2]]

1.5)列表元素修改

  • 列表修改,list[i]=x可以直接替换列表指定下标的元素。

举例1:

list1=[1,2,3,4,5,6]
list1[1]=100
print("修改后的列表为",list1)

运行结果:

修改后的列表为 [1, 100, 3, 4, 5, 6]

1.6)列表相关函数

  • reverse() 函数可以使列表倒置。
  • len() 函数可以返回列表的元素个数。
  • sort() 函数可以使列表元素升序排列。

举例1:

list1=[1,2,3,4,5,6]
list1.reverse()
print("倒置后的列表是",list1)

list1.sort()
print("len统计列表元素的个数",len(list1),
      "\nsort列表升序排列",list1)

运行结果:

倒置后的列表是 [6, 5, 4, 3, 2, 1]
len统计列表元素的个数 6
sort列表升序排列 None

(四)元组类型

1)元组:tuple

1.1)元组创建

  • 创建元组对象,元组一旦创建就无法对其元素进行增加,删除和修改
  • 可以使用()创建元组,元组可以为空且元素类型可以不同。但若元组中仅包含一个数字,则应该添加逗号以区别数字类型。

举例1:

tup1=('google','runoob',1997,2000)
tup2=(2,)
tup3="a","b","c","d"
tup4=()
print('tup1的元素是',tup1,
     '\n显示该数据结构类型',type(tup1),
     '\ntup2的元素是',tup2,
     '\n显示该数据结构类型',type(tup2),
     '\ntup3的元素是',tup3,
      '\n显示该数据结构类型',type(tup3),
     '\ntup4的元素是',tup4,
      '\n显示该数据结构类型',type(tup4))

运行结果:

tup1的元素是 (‘google’, ‘runoob’, 1997, 2000)
显示该数据结构类型
tup2的元素是 (2,)
显示该数据结构类型
tup3的元素是 (‘a’, ‘b’, ‘c’, ‘d’)
显示该数据结构类型
tup4的元素是 ()
显示该数据结构类型

1.2)元组查询

访问元组可以使用下标索引来访问元组中的值

  • 正向索引下标:
    从左到右依次为:0、1、2、3……

  • 逆向索引下标
    从右向左依次为:-1、-2、-3、-4、-5……

举例1:

tup1=('google','runoob',1997,2000)

print("元组切分",tup1[1:4],
      "\n从前往后访问",tup1[0],
      "\n从后往前访问",tup1[-3])

运行结果:

元组切分 (‘runoob’, 1997, 2000)
从前往后访问 google
从后往前访问 runoob

1.3)元组删除

  • 删除元组,使用del方法可以都删除指定的元组对象,相对的我们无法删除指定下标的元组元素。

举例1:

tup1=('google','runoob',1997,2000)
del tup1[0] #报错

运行结果:
python基础—python6种基本数据类型及数据类型之间转换_第2张图片
举例2:

del tup1
print("删除后的元组 tup:")
print(tup1)

运行结果:
python基础—python6种基本数据类型及数据类型之间转换_第3张图片

1.4)元组连接与复制

  • 元组连接和复制。虽然元组中的元素值 是不允许修改的,但我们可以对元组进行连接组合,并且会返回一个新的元组对象。
  • 使用+进行操作连接
  • 使用*进行复制操作

举例1:

tup1=('google','runoob',1997,2000)
tup2=(2,3)
tup3=tup1+tup2
print("使用+进行操作连接",tup3)

tup4=tup2*3
print("使用*进行复制操作",tup4)

运行结果:

使用+进行操作连接 (‘google’, ‘runoob’, 1997, 2000, 2, 3)
使用*进行复制操作 (2, 3, 2, 3, 2, 3)

1.5)元组相关函数

  • len() 函数可以返回元组元素的个数。
  • max() 函数可以返回元组中的最大元素。
  • min() 函数可以返回元组中的最小元素

举例1:

tup1=('google','runoob',1997,2000)
tup2=(2,3,33,55,100)
print("计算元组的元素个数",len(tup1),
      "\n求元组的最大元素",max(tup2),
      "\n求元组的最小元素",min(tup2))

运行结果:

计算元组的元素个数 4
求元组的最大元素 100
求元组的最小元素 2

(五)字典类型

1)字典:dict

1.1)字典创建

  • 方法一:{键1:值1,键2:值2,键3:值3……}常规创建字典,键具有唯一性。
  • 方法二:使用zip方法创建字典。

举例1:生成一个空字典和一个普通字典。

dict1={"id":"l100","name":"cooc"}
dict2={}
print("显示该数据结构类型",type(dict1))

运行结果:

显示该数据结构类型

举例2:zip()方法可以返回元组组成的列表,这可以帮助我们快速构建字典。

demo_dict=dict(zip("abc","123"))
print("显示字典数据形式",demo_dict,
"\n显示该数据结构类型",type(demo_dict))

运行结果:

显示字典数据形式 {‘a’: ‘1’, ‘b’: ‘2’, ‘c’: ‘3’}
显示该数据结构类型

1.2)字典查询

  • 方法一:通过键获取值。
  • 方法二:使用get(key,default=None)方法获取指定键的值。

举例1:

dict1={"id":"l100","name":"cooc"}
#查找id键的值
print("常规查询:",dict1["id"])
print("根据键查询:",dict1.get("id"))

运行结果:

常规查询: l100
根据键查询: l100

1.3)字典增加

  • 方法:字典名[键]=值
  • 增加列,其实就是增加字典中一个键值对

举例1:

dict1={"id":"l100","name":"cooc"}
dict1["school"]="school1"
print("增加一个键值对:",dict1)

运行结果:

增加一个键值对: {‘id’: ‘l100’, ‘name’: ‘cooc’, ‘school’: ‘school1’}

1.4)字典删除

  • 方法一:del 字典名[键值],删除字典中一个键值对。
  • 方法二:字典名.pop[键值],删除字典中一个键值对。

举例1:

dict1={"id":"l100","name":"cooc"}
del dict1[id]
print("删除id键后字典:",dict1)

dict1={"id":"l100","name":"cooc"}
dict1.pop('id')
print("删除id键后字典:",dict1)

运行结果:

{‘name’: ‘cooc’}

1.5)字典修改

  • 方法一:字典名[键]=值
  • 方法二:字典名.update({键:值})

举例1:

dict1={"id":"l100","name":"cooc"}
dict1["id"]="001"
print("修改id键对应的值后的dict1:",dict1)

dict1={"id":"l100","name":"cooc"}
dict1.update({"name":"lily"})
print("修改name对应的值后的后dict1:",dict1)

运行结果:

修改id键对应的值后的dict1: {‘id’: ‘001’, ‘name’: ‘cooc’}
修改name对应的值后的后dict1: {‘id’: ‘l100’, ‘name’: ‘lily’}

(六)集合类型

1)集合:set

1.1)集合创建

-集合的创建,集合是数学概念上集合,不会出现重复值,所有的元素按照一定顺序排列,若元素为数字则按照数字大小排列。使用set()函数创建集合会自动地拆分多个字母组成的字符串。

举例1:

mySet1=set("abcgefa12312123")
mySet2={"大","小","点","多"}
mySet3=set(("hello","world"))
print("集合1",mySet1,
     "\n显示该数据结构类型",type(mySet1),
     "\n集合2",mySet2,
     "\n集合3",mySet3)

运行结果:

集合1 {‘g’, ‘3’, ‘b’, ‘2’, ‘f’, ‘a’, ‘1’, ‘e’, ‘c’}
显示该数据结构类型
集合2 {‘小’, ‘点’, ‘多’, ‘大’}
集合3 {‘hello’, ‘world’}

1.2)集合查询

  • 不可以获取集合的元素,但是可以使用in判断这个元素是否在集合中,若存在为真,反之为假。

举例1:

mySet={"a","b","c","d","e","f"}
"a" in mySet

运行结果:

True

1.3)集合元素增加

  • 方法一:add()函数可以在集合对象中加入新元素,但若元素已经存在,则无效果。
  • 方法二:update表示添加(并非修改),是一个一个添加,并且按照顺序添加进集合。

举例1:

mySet={"a","b","c","d","e","f"}
mySet.add("ghk")
mySet.add("a")
print("add()后的集合",mySet)

mySet.update("tyu")
print("update()后的集合",mySet)

运行结果:

add()后的集合 {‘d’, ‘b’, ‘f’, ‘a’, ‘ghk’, ‘e’, ‘c’}
update()后的集合 {‘d’, ‘b’, ‘t’, ‘f’, ‘a’, ‘ghk’, ‘e’, ‘u’, ‘y’, ‘c’}

1.4)集合元素删除

  • remove() 函数可以将集合中的元素删除。
  • discard() 函数可以删除集合中指定元素,且元素不存在不报错。
  • pop() 函数可以随机删除集合中的一个元素(默认删除最后一个元素)
  • clear() 函数可以清空集合。

举例1:

mySet={"a","b","c","d","e","f"}
mySet.remove("a")
print("删除指定元素后的集合",mySet)

mySet.discard("x")
print("删除不存在的元素后的集合",mySet)

mySet.pop()
print("随机删除元素后的集合",mySet)

mySet.clear()
print("删除所有元素后的集合",mySet)

运行结果:

删除指定元素后的集合 {‘d’, ‘b’, ‘f’, ‘e’, ‘c’}
删除不存在的元素后的集合 {‘d’, ‘b’, ‘f’, ‘e’, ‘c’}
随机删除元素后的集合 {‘b’, ‘f’, ‘e’, ‘c’}
删除所有元素后的集合 set()

1.5)集合相关函数

  • len() 函数查询集合的长度
  • copy() 函数复制集合中的元素并生成一个新的集合。
  • 集合的运算。首先建立两个新的集合用于运算。在集合运算中,'-‘表示求差集,’&‘表示求交集,’|‘表示求并集,’^'表示两个集合的并集减去交集。

举例1:

mySet={"a","b","c","d","e","f"}
copy_mySet=mySet.copy()
print("len()返回集合的长度",len(mySet),
      "\ncopy()生成的集合",copy_mySet)

运行结果:

len()返回集合的长度 6
copy()生成的集合 {‘f’, ‘d’, ‘a’, ‘b’, ‘e’, ‘c’}

举例2:

a=set("apple")
b=set("banana")
print("求差集",a-b,
      "\n求并集",a|b,
      "\n求交集",a&b,
      "\n求非交集",a^b)

运行结果:

求差集 {‘p’, ‘e’, ‘l’}
求并集 {‘p’, ‘a’, ‘l’, ‘n’, ‘e’, ‘b’}
求交集 {‘a’}
求非交集 {‘l’, ‘b’, ‘n’, ‘p’, ‘e’}


二、python数据类型转换

Python中的数据类型转换有两种,一种是自动类型转换,即Python在计算中会自动地将不同类型的数据转换为同类型数据来进行计算;另一种是强制类型转换,即需要我们基于不同的开发需求,强制地将一个数据类型转换为另一个数据类型。

(一)自动类型转换

当两个不同类型的数据进行运算时,结果会像更高精度进行计算,精度等级:布尔<整型<浮点型<算数。

举例1:

a=10
b=True
print(a+b)
'''
在和数字运算时,True转为1,False转为0
'''

运行结果:

11

(二)强制类型转换

函数 说明
str( ) 可以把其他类型数据转化为字符串类型
int( ) 可以把其他类型数据转化为整型
float( ) 可以把其他类型数据转化为浮点型
bool( ) 可以把其他类型数据转化为布尔类型
list( ) 可以把其他类型数据转化为列表类型
tuple( ) 可以把其他类型数据转化为元组类型
dict( ) 可以把其他类型数据转化为字典类型
set( ) 可以把其他类型数据转化为集合类型

其他类型 -> str

  • int -> str

举例1:

a=123
res=str(a)
print(res,type(res))

输出结果:

123

  • bool -> str

举例1:

a=True
res=str(a)
print(res,type(res))

输出结果:

True

  • float -> str
    • float 转换 str 会去除末位为 0 的小数部分。

举例1:

a=1.23
res=str(a)
print(res,type(res))

输出结果:

1.23

  • complex -> str
    • complex 转换 str,会先将值转化为标准的 complex 表达式,然后再转换为字符串。

举例1:

a=3-91j
res=str(a)
print(res,type(res))

a=complex(3,-91)
res=str(a)
print(res,type(res))

输出结果:

(3-91j)
(3-91j)

  • list -> str

举例1:

a=[1, 2, 3]
res=str(a)
print(res,type(res))

输出结果:

[1, 2, 3]

  • tuple -> str

举例1:

a=(1, 2, 3)
res=str(a)
print(res,type(res))

输出结果:

(1, 2, 3)

  • dict -> str

举例1:

a= {1: 'a', 2: 'b'} 
res=str(a)
print(res,type(res))

输出结果:

{1: ‘a’, 2: ‘b’}

  • set -> str

举例1:

a={1, 2, 3}
res=str(a)
print(res,type(res))

输出结果:

{1, 2, 3}

总结

  • 所有类型都可以转化成str类型

其他类型 -> 数字型(bool/float/int/complex)


数字类型之间相互转换

  • int -> float/bool/complex
    • int转换成float,会自动给添加一位小数。
    • int转换成bool,0为False,其他为真。
    • int转换成complex,会自动添加虚数部分并以0j表示。

举例1:

a=123
res1=float(a)
res2=bool(a)
res3=complex(a)
print(res1,type(res1),
      "\n",res2,type(res2),
      "\n",res3,type(res3))

123.0
True
(123+0j)

  • bool -> int/float/complex
    • bool转换成int,True会转为1,False会转为0。
    • bool转换成float,True会转为1.0,False会转为0.0。
    • bool转换成complex,True实数部分会转为1,False实数部分会转为0,会自动添加虚数部分并以0j表示。

举例1:

b=True
res1=int(b)
res2=float(b)
res3=complex(b)
print(res1,type(res1),
      "\n",res2,type(res2),
      "\n",res3,type(res3))

输出结果:

1
1.0
(1+0j)

  • float -> int/bool/complex
    • float转换成int,会去掉小数点及后面的数值,仅保留整数部分。
    • float转换成bool,0为False,其他为True。
    • float转换成complex,会自动添加虚数部分并以0j表示。

举例1:

c=1.23
res1=int(c)
res2=bool(c)
res3=complex(c)
print(res1,type(res1),
      "\n",res2,type(res2),
      "\n",res3,type(res3))

输出结果:

1
True
(1.23+0j)

  • complex -> int/float/bool
    • complex不能转换成int,会报错。
    • complex不能转换成float,会报错。
    • complex转换成bool,0为False,其他为True。

举例1:

d=9-3j
res1=int(d)
#res2=float(d) #报错
#res3=bool(d)  #报错
print(res3,type(res3))

输出结果:

True

str-> 数字类型

  • str -> int
    • 如果字符串中有数字(0-9)和正负号(+/-)以外的字符,就会报错。

举例1:

#str
a="123"
res=int(a)
print(res,type(res))

输出结果:

123

  • str -> float
    • 如果字符串含有正负号(+/-)、数字(0-9)和小数点(.)以外的字符,就会报错。

举例1:

a="123"
res=float(a)
print(res,type(res))

输出结果:

123.0

  • str -> bool
    • 0为False,其他为True。

举例1:

a="123"
res=bool(a)
print(res,type(res))

输出结果:

True

  • str -> complex
    • str转换成complex,如果能转换成int或float,则会转换后再转为complex.
    • 如果str完全符合complex表达式规则,也可以转换成complex类型值。
a="123"
res=complex(a)
print(res,type(res))
 #(123+0j) 

a="1.23"
res=complex(a)
print(res,type(res))
#(1.23+0j) 

a="123.0" 
res=complex(a)
print(res,type(res))
#(123+0j) ,去掉小数部分

a="12+3j"
res=complex(a)
print(res,type(res))
#(12+3j) 

a="12.0+3.0j"
res=complex(a)
print(res,type(res))
#(12+3j) ,去掉小数部分

a="12.0+3.9j"
res=complex(a)
print(res,type(res))
#(12+3.9j) 

总结:

  • 数字型之间可以相互转换,但complex不支持转换成float、int
  • 只有str字符串类型可以转换为数字型,并且字符串的元素必须为纯数字,如果字符串中有数字(0-9)和正负号(+/-)以外的字符,就会报错。

其他类型 -> list

  • str -> list
    • 字符串转为列表时,会把字符串中的每一个字符当作列表的元素。

举例1:

a='123bcd' 
res=list(a)
print(res, type(res))

输出结果:

[‘1’, ‘2’, ‘3’, ‘b’, ‘c’, ‘d’]

  • tuple -> list
    • 元组转为列表时,会把字符串中的每一个字符当作列表的元素。

举例1:

a=(1,2,3)
res=list(a)
print(res, type(res))

输出结果:

[1, 2, 3]

  • dict -> list
    • 字典转为列表时,只保留字典的键。

举例1:

a={'name': 'Alice', 'Age': 5, 'Sex': 'Female'} 
res=list(a)
print(res, type(res))

输出结果:

[‘name’, ‘Age’, ‘Sex’]

  • set -> list
    • 集合转为列表时,结果是无序的。

举例1:

a={1,2,3,'b','c','d'}
res=list(a)
print(res, type(res))

输出结果:

[1, 2, 3, ‘d’, ‘c’, ‘b’]

总结:

  • 数字类型不能转换成为列表
  • 字符串转为列表时,会把字符串中的每一个字符当作列表的元素。
  • 元组转为列表时,会把字符串中的每一个字符当作列表的元素。
  • 字典转为列表时,只保留字典的键。
  • 集合转为列表时,结果是无序的,因为集合本身就是无序的。

其他类型 -> tuple

  • str -> tuple
    • 字符串转为元组时,会把字符串中的每一个字符当作元组的元素。

举例1:

a='123bcd' 
res=tuple(a)
print(res, type(res))

输出结果:

(‘1’, ‘2’, ‘3’, ‘b’, ‘c’, ‘d’)

  • list -> tuple
    • 列表转为元组时,会把字符串中的每一个字符当作元组的元素。

举例1:

a=[1,2,3]
res=tuple(a)
print(res, type(res))

输出结果:

(1, 2, 3)

  • dict -> tuple
    • 字典转为元组时,只保留字典的键。

举例1:

a = {'name': 'Alice', 'Age': 5, 'Sex': 'Female'} 
res = tuple(a)
print(res, type(res))

输出结果:

(‘name’, ‘Age’, ‘Sex’)

  • set -> tuple
    • 集合转为元组时,结果是无序的。

举例1:

a={1,2,3,'b','c','d'}
res=tuple(a)
print(res, type(res))

输出结果:

(1, 2, 3, ‘d’, ‘c’, ‘b’)

总结:

  • 数字类型不能转换成为元组。
  • 字符串转为元组时,会把字符串中的每一个字符当作元组的元素。
  • 列表转为元组时,会把字符串中的每一个字符当作元组的元素。
  • 字典转为元组时,只保留字典的键。
  • 集合转为元组时,结果是无序的,因为集合本身就是无序的。

其他类型 -> dict

  • list -> dict
    • 嵌套的列表(等长二级列表)转换为字典。
    • 通过zip将2个列表映射为字典。

举例1:

a=[[1, 2], ['a','b']] # 等长二级列表
res=dict(a)
print(res, type(res)) 

输出结果:

{1: 2, ‘a’: ‘b’}

举例2:

tp1=[1,2,3]
tp2=[1,2,3,4]
res=dict(zip(tp1,tp2))
print(res, type(res)) 

输出结果:

{1: 1, 2: 2, 3: 3}

  • tuple -> dict
    • 嵌套的元组(等长二级元组)转换为字典。
    • 通过zip将2个元组映射为字典。

举例1:

a=((1, 2), (3, 4), (5, 6)) # 等长二级元组
res=dict(a)
print(res, type(res))

输出结果:

{1: 2, 3: 4, 5: 6}

举例2:

tp1=(1,2,3)
tp2=(1,2,3,4)
res=dict(zip(tp1,tp2))
print(res, type(res)) 

输出结果:

{1: 1, 2: 2, 3: 3}

总结:

  • 数字类型、字符串、集合不能转换为字典。
  • 列表、元组类型转字典类型,列表必须为等长二级容器,子容器的元素个数必须为2

其他类型 -> set

  • str -> set
    • 先将字符切割成元组,然后再去重转换成集合。

举例1:

a="hello"
res=set(a)
print(res,type(res))

输出结果:

{‘h’, ‘o’, ‘l’, ‘e’}

  • list -> set
    • 先对列表去重,再转换。

举例1:

a=[1,2,3,4]
res=set(a)
print(res,type(res))

输出结果:

{1, 2, 3, 4}

  • tuple -> set
    • 先对列表去重,再转换。

举例1:

a=(1,2,3,4)
res=set(a)
print(res,type(res))

输出结果:

{1, 2, 3, 4}

  • dict -> set
    • 会取字典的键名组合成集合。

举例1:

a={'name': 'Alice', 'Age': 5, 'Sex': 'Female'} 
res=set(a)
print(res,type(res))

输出结果:

{‘Sex’, ‘Age’, ‘name’}

总结:

  • 数字类型不转换为集合。
  • 字符串、列表、元组转集合时,结果是无序的。
  • 字典转集合时,只保留字典中的键,结果是无序的。

参考文章:
https://zhuanlan.zhihu.com/p/83086122
https://blog.csdn.net/cheuklam/article/details/120555191

你可能感兴趣的:(python基础,python,网络,开发语言)