Python3 | 练气期，基本数据类型，类型转换!

[ 知识是人生的灯塔，只有不断学习，才能照亮前行的道路 ]

0x00 Python3基本数据类型，类型转换

描述：上一章，我们学习了Python3基础语法，此章节我们学习Python几种基本数据类型，以及数据类型转换，希望各位看友认真学习此基础篇章，为后续的深入学习打下牢固的基础，为了不让各位看友犯困，作者也尽可能用简短的语言以及实践示例进行表达。

温馨提示：作者后续实践主要在 Ubuntu 24.04 TLS Python 3.12 Jupyter Notebook 环境中运行，若要配置为作者的学习环境，可参考《#AIGC学习之路》专栏中的流程。

温馨提示：若各位看友在其他平台看到此篇文章，一定要关注公众号【全栈工程师修炼指南】进行持续学习！我们一同学习，一起进步，关注后回复【加群】哟！

温故知新

描述：前面说过 Python 中的变量不需要声明（弱类型语言，变量赋值后类型也随之改变），每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建，这一点与 C 语言和 Java 语言是不同的，表现在它的变量不需要声明变量类型，这是因为像 C 语言和 Java 语言来说，它们是静态的，而 python 是动态的，变量的类型由赋予它的值来决定，例如：

例如，单变量赋值，及多变量赋值。

代码语言：javascript复制

#!/usr/bin/python3
# coding=utf-8

# 单变量赋值
counter = 1024             # 整型变量
miles   = 1024.0           # 浮点型变量
name    = "programmer"     # 字符串

# 多变量赋值
# - 创建一个整型对象，值为 1，从后向前赋值，三个变量被赋予相同的数值。
a = b = c = 1
# - 两个整型对象 1 和 2 的分配给变量 a 和 b，字符串对象 "programmer" 分配给变量 c。
a, b, c = 1, 2, "programmer"

# 第一次为变量 a 赋值为整型，第二次赋值是浮点数，第三次是一个字符串，最后输出时只保留了最后一次的赋值。
a = 1
a = 1.001
a = "python"
print(a)
python

# 删除单个或多个对象（变量）
del name
del a,b,c

0x01 基础数据类型

常见数据类型

Python3 常见的数据类型有：

Number（数字）：int、float、bool（0|1）、complex（复数）
String（字符串）：用单引号 ' 或双引号 " 括起来，同时使用反斜杠转义特殊字符。
bool（布尔）：True、False
List（列表）：列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套），使用中括号 [] 里，元素之间用逗号隔开。
Tuple（元组）：与列表类似，不同之处在于元组的元素不能修改，使用小括号 () 里，元素之间用逗号隔开。
Set（集合）: 是一种无序、可变的数据类型，用于存储唯一的元素,使用大括号 {} 表示，元素之间用逗号分隔。
Dictionary（字典）: 是一种映射类型，元素是通过键来存取的，而不是通过偏移存取是一种映射类型，使用{ }标识，它是一个无序的 键(key) : 值(value) 的集合。
bytes (字节数组类型)：是不可变的二进制序列（byte sequence），元素是整数值（0 到 255 之间的整数），而不是 Unicode 字符。

Python3 有六个标准的数据类型：

不可变数据（Immutable，变量重赋值等于新建）：Number（数字）、String（字符串）、Tuple（元组）
可变数据（Changeable，变量重赋值等于替换）：List（列表）、Dictionary（字典）、Set（集合）、Bytes（字节数组）

Python3 数据类型别名：

序列类型：String（字符串）、List（列表）、Tuple（元组）
映射容器：Dictionary（字典）存放对象

查看数据类型

type() 函数：是用于求一个未知数据类型对象
isinstance() 函数：是用于判断一个对象是否是已知类型。

区别：type 与 isinstance 虽然都与数据类型相关，但两者其实用法不同，type 主要用于判断未知数据类型，isinstance 主要用于判断 A 类是否继承于 B 类。

代码语言：javascript复制

#!/usr/bin/python3
# coding=utf-8

# 判断基础数据类型
a = 1024
b = 1024.0
c = 'a'
d = "公众号: 全栈工程师修炼指南"
e = ["欢迎","关注","公众号: 全栈工程师修炼指南", a]
f = ("欢迎","关注","公众号: 全栈工程师修炼指南", b)
g = {"欢迎","关注","公众号: 全栈工程师修炼指南"}
h = {"name": "weiyigeek", "age": 28}
i = True
j = 1 2j
k = b'1024'

# 判断子类对象是否继承于父类
class father(object):
    pass
class son(father):
    pass

if __name__ == '__main__':
    print ("判断基础数据类型n",type(a),'n',type(b),'n',type(c),'n',type(d),'n',type(e),'n',type(f),'n',type(g),'n',type(h),'n',type(i),'n',type(j),'n',type(k))

    print ("用 isinstance 来判断数据类型")
    print (isinstance(a,int))
    print (isinstance(b,float))
    print (isinstance(c,str))

    print ("判断子类对象是否继承于父类n", type(son())==father)
    print (isinstance(son(),father))
    print (type(son()))
    print (type(son))

执行结果:

代码语言：javascript复制

判断基础数据类型
 <class 'int'> 
 <class 'float'> 
 <class 'str'> 
 <class 'str'> 
 <class 'list'> 
 <class 'tuple'> 
 <class 'set'> 
 <class 'dict'> 
 <class 'bool'> 
 <class 'complex'> 
 <class 'bytes'>

用 isinstance 来判断数据类型
True
True
True

判断子类对象是否继承于父类
 False
True
<class '__main__.son'>
<class 'type'>

1.1 数字(Number)

Python3 中数字有四种类型：int、float、bool、complex（复数），

整型：int 表示为长整型，Py3 没有 Py2 中的 Long 类型了。
布尔：bool 是 int 的子类，True 和 False 可以和数字相加，它们的值还是 1 和 0，并可以通过 is 来判断类型
e记法：15e10 => 15*10 的10次方 = 150000000000.0; 在交互模式中最后被输出的表达式结果被赋值给变量 _ 。
复数：由实数部分和虚数部分构成，例如:a bj 或者complex(a,b) 表示, 注复数的实部a和虚部b都是浮点型;

Python整型数据变量

示例，数字类型实践记录

代码语言：javascript复制

#!/usr/bin/python3
# -*- coding:UTF-8 -*-
# 功能：基础数据类型之数字类型演示

# 接收输入
temp = input("请输入数字：")
print("输入值为 : ", temp, " | 类型:", type(temp))

# 布尔 
temp = True
print("布尔:",temp," | 类型:",type(temp))

# 复数
temp = 4 3j
print("复数:",temp," | 类型:",type(temp))

# 将字符转成整数类型
temp = '5'
number = int(temp)   
print("字符转换整数 : ",number," | 类型:",type(number))

#  _ 变量应被用户视为只读变量。 
price = 113.0625
_ = 1024
sum = price   _   
print("price   _ = ",sum," | 类型:",type(sum))

执行结果:

代码语言：javascript复制

请输入数字：1024

输入值为 :  1024  | 类型: <class 'str'>
布尔: True  | 类型: <class 'bool'>
复数: (4 3j)  | 类型: <class 'complex'>
字符转换整数 :  5  | 类型: <class 'int'>
price   _ =  1137.0625  | 类型: <class 'float'>

特别注意：

Python2 中，是没有布尔型的，它用数字 0 表示 False，用 1 表示 True。
Python3 中，把 True 和 False 定义成关键字了，它们的值还是 1 和 0，它们可以和数字相加。
Python3 中，使用十六进制和八进制来代表整数 number = 0xA0F # 十六进制 0o37 # 八进制
Python3 中，复数j可以不分大小写的。
Python3 中，在混合计算时会把整型转换成为浮点数。

1.2 字符串(String)

描述: Python中的字符串用单引号 ' 或双引号 " 括起来，使用三引号('''或""")可以指定一个多行字符串进行跨行，WYSIWYG（所见即所得）格式, 同时使用反斜杠转义特殊字符。

Python3 使用索引截取字符串中字符，语法格式如下变量[头下标:尾下标]（有两种索引方式，从左往右以0开始，从右往左以-1开始）[:] 截取字符串中的一部分，遵循左闭右开原则，例如，str[0:2] 截取是a,b，不包含第 3 个字符的。

Python字符串索引

Python3 使用反斜杠可以用来转义，使用r可以让反斜杠不发生转义，如 r"this is a line with n" 则n会显示，并不是换行。

Python字符串格式化

示例，字符串类型实践记录

代码语言：javascript复制

#!/usr/bin/python3
# coding=utf-8
# 功能：基础数据类型之字符串类型详解

# 无单独的字符类型，一个字符等于长度为1的字符串。
word = 'WeiyiGeek'
print(word[0], word[-1], word[-6])

# 字符串类型
sentence = "这是一个句子"
paragraph = """
    这是一个段落，
    可以由多行组成
"""
print("字符串段落:", paragraph)

# 拼接字符串
A = " This a"
B = "String!"
C = A   B 
print("拼接字符串", C, end="n")

# 截取字符串：变量[头下标:尾下标:步长] 
str1 = 'abcdef'
str2 = "Hello"
print(str1[0:-1])           # 输出第一个到倒数第二个的所有字符
print(str1[2:5])            # 输出从第三个开始到第五个的字符
print(str1[-2])             # 到数第二个数
print(str1 * 2)             # 输出字符串两次 (关键字 * 重复)
print('关键字拼接: '   str1)       # 连接字符串 (关键字   拼接)
print("拼接字符串: a",str2[:5] " World!")

# 字符串转义
print('hellonWeiyi')     # 使用反斜杠() n转义特殊字符
print(r'c:\windows')     # 在字符串前面添加一个 r 或者 R，表示原始字符串，也不会发生转义

# 字符串格式化
print("我叫 %s 今年 %d 岁 %#X  数值：%5.3f" % ('小明',10,255,12.85455))
print("u6211u662fu6700u559cu7231u0050u0079u0074u0068u006fu006e") #unicode 输出

执行结果：

代码语言：javascript复制

W k y
字符串段落: 
    这是一个段落，
    可以由多行组成

拼接字符串  This aString!
abcde
cde
e
abcdefabcdef

关键字拼接: abcdef
拼接字符串：Hello World!
hello
Weiyi
c:\windows

我叫 小明 今年 10 岁 0XFF  数值：12.855
我是最喜爱Python

特别注意：

Python3 不支持单字符类型, 单字符在 Python 中也是作为一个字符串使用.例如 str ='a', 字符串中可以包含换行符、制表符以及其他特殊字符。
python3 字符串可与运算符连接在一起，使用 * 运算符重复，按字面意义级联字符串，如 "this " "is " "string" 会被自动转换为this is string。
Python3 中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。
Python3 中的字符串不能改变，若向一个索引位置赋值，比如word[0] = 'm'会导致错误。
Python2 中，普通字符串是以8位ASCII码进行存储的，而在Python3中，所有的字符串都是16位Unicode字符串表示的，使用的语法是在字符串前面加上前缀u；

1.3 布尔(Bool)

在 Python3 中，True 和 False 都是关键字，由于 bool 是 int 的子类，因此布尔值可以被看作整数来使用，其中 True 等价于 1，而 False 等价于 0。

布尔类型可以和其他数据类型（如数字、字符串等）使用条件运算符（>、<、!=、==）进行比较，同时布尔类型可以和逻辑运算符（and、or 和 not）一起使用。

示例，布尔类型实践记录

代码语言：javascript复制

#!/usr/bin/python3
# coding=utf-8
# 功能：基础数据类型之布尔类型详解

# 布尔类型的值和类型
a = True
b = False
print(type(a))  # <class 'bool'>
print(type(b))  # <class 'bool'>

# 布尔类型的整数表现
print(int(True))   # 1
print(int(False))  # 0

# 使用 bool() 函数进行转换
print(bool(0))         # False
print(bool(42))        # True
print(bool(''))        # False
print(bool('Python'))  # True
print(bool([]))        # False
print(bool([1, 2, 3])) # True

# 布尔逻辑运算
print(True and False)  # False
print(True or False)   # True
print(not True)        # False

# 布尔比较运算
print(5 > 3)  # True
print(2 == 2) # True
print(2 != 2) # False
print(7 < 4)  # False

# 布尔值在控制流中的应用
if True:
    print("This will always print")
    
if not False:
    print("This will also always print")
    
x = 10
if x:
    print("x is non-zero and thus True in a boolean context")

特别注意:

Python3 中，所有非零的数字和非空的字符串、列表、元组等数据类型都被视为 True, 只有None、 0 (0、0.0、0j)、空字符串、空列表、空元组和空映射（如 {}）等被视为 False。

1.4 列表(List)

描述：List（列表）是 Python 中使用最频繁的数据类型，你可将其理解为其他编程语言中数组（Array）不过更加强大，列表的元素可以是任何数据类型，并且可以混合使用，甚至可以包含列表（所谓嵌套）。

列表是写在方括号 [] 之间、用逗号分隔开的元素列表，例如，["全栈工程师修炼指南", 1024 , True]。

和字符串一样，列表同样可以被索引（从0开始）和截取（[start:stop:step]）, 加号是列表连接运算符，星号 * 是重复操作，列表被截取后返回一个包含所需元素的新列表。

weiyigeek.top-list列表表达式

示例，列表类型实践记录

代码语言：javascript复制

#!/usr/bin/python3
# coding=utf-8
# 功能：基础数据类型之列表类型详解

# 定义三个列表
list1 = ["公众号",'全栈工程师修炼指南n',1024, 1024.1, True]
list2 = ["网站","https://blog.weiyigeek.top"]
list3 = [1, 2, 3, 4, 5, 6]

# 索引，切片，重复（*），连接（ ）
print (len(list1))        # 打印列表长度
print (list1)            # 打印整个列表
print (list1[0])         # 打印列表的第一个元素
print (list1[1:3])       # 打印列表第二到第四个元素（不包含第四个元素）
print (list1[2:])        # 打印列表从第三个元素开始到末尾
# 在索引 1 到索引 4 的位置并设置为步长为 2（间隔一个位置）来截取字符串
print (list1[1:4:2])
print (list2 * 2)        # 打印list2列表两次
print (list1   list2)   # 打印两个列表拼接在一起的结果

# 列表元素更改
list3[0] = 1024
list3[2:5] = [10, 20, 30]
print (list3)            # 打印修改后的list3列表
list3[2:5] = []           # 删除索引为2到5的元素
print (list3)            # 打印修改后的list3列表

# 翻转输入字符串
# 通过空格将字符串分隔符，把各个单词分隔为列表
input="I like Python Programming."
inputWords = input.split(" ")

# 假设列表 list = [1,2,3,4],  
# list[0]=1, list[1]=2 ，而 -1 表示最后一个元素 list[-1]=4 ( 与 list[3]=4 一样)
# inputWords[-1::-1] 有三个参数
# 第一个参数 -1 表示最后一个元素
# 第二个参数为空，表示移动到列表末尾
# 第三个参数为步长，-1 表示逆向
inputWords=inputWords[-1::-1] # 核心部分，使用切片和步长实现逆向输出

# 重新组合字符串
output = ' '.join(inputWords)
print (output)

执行结果：

代码语言：javascript复制

5
['公众号', '全栈工程师修炼指南n', 1024, 1024.1, True]
公众号
['全栈工程师修炼指南n', 1024]
[1024, 1024.1, True]
['全栈工程师修炼指南n', 1024.1]
['网站', 'https://blog.weiyigeek.top', '网站', 'https://blog.weiyigeek.top']
['公众号', '全栈工程师修炼指南n', 1024, 1024.1, True, '网站', 'https://blog.weiyigeek.top']
[1024, 2, 10, 20, 30, 6]
[1024, 2, 6]
Programming. Python like I

特别注意:

Python 3 中，List 内置了有很多方法，例如 append()、pop() 等等，这在后面会讲到。
Python 3 中，List 内置了有很多方法列表中的元素是可以改变的。

1.5 元组(Tuple)

描述：元组（tuple）与列表类似，不同之处在于元组内的元素不能修改（即戴上枷锁的列表），元组写在小括号 () 里，元素之间用逗号隔开，例如 tuple = (1,0,2,4,1024.00,"a","abc") 或者 tuple = 1,0,2,4,1024.00,"a","abc" 。

我们主要从创建和访问元组，更新和删除一个元组，元组相关的操作符进行学习：

拼接操作符
重复操作符(8 * (8,))
关系操作符(大于、小于等)
成员操作符([in] [not in])
逻辑操作符(not>and>or)

示例，元组类型实践记录

代码语言：javascript复制

#!/usr/bin/python3
# coding=utf-8
# 功能：基础数据类型之元组类型（戴上枷锁的列表）详解

# 定义两个元组
tuple1 = ('abc',789,2.23,'WEIYIGEEK',70.2)
pjtuple = ('Python','Version 3.12.4')

print(tuple1[1:3])       # 从下标索引为1到下标索引为2的元素打印出来 (元素的个数 3 -1 = 2)
print(pjtuple * 2)       # 重复元组元素
print(tuple1   pjtuple)  # 拼接

# 构造包含 0 个或 1 个元素的元组比较特殊
tup1 = ()    # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号
print("空元组",tup1)
print("一个元素",tup2)
not_a_tuple = (42) # 如果不添加逗号，它将被解释为一个普通的值而不是元组：
print("not_a_tuple:",type(not_a_tuple)) # int


# 元组 tuple 是戴上了枷锁的列表
temp = 1,2,3,4   #另外一钟方法也能定义一个元组(值得学习)
print("类型：",type(temp))  #类型： <class 'tuple'>
print("辅助元组参数：",8 * (8,)) #(两种方式必须有逗号)  tuple创建： (8, 8, 8, 8, 8, 8, 8, 8)
print("切片：",temp[1:3])  #切片slice(也可以利用此来拷贝元组) 切片： (2, 3)

# 利用切片方式分成两段加入新elements再拼接,注意逗号和类型. 
friends = ('小明','小经','小陈','小郑')
myfriends = friends[:2]   ('郑老师',)  friends[2:] 
# 拼接的元组： ('小明', '小经', '郑老师', '小陈', '小郑')
print("拼接的元组：",myfriends)

# 格式化输出元组  
print("{0} , {1} , {2}".format(friends[-1],friends[1],friends[0])) 

# 面向对象的编程语言的回收机制
del temp 
print(tuple2 * 2)   #(1, 2, 3, 4, 1, 2, 3, 4)

执行结果：

代码语言：javascript复制

(789, 2.23)
('Python', 'Version 3.12.4', 'Python', 'Version 3.12.4')
('abc', 789, 2.23, 'WEIYIGEEK', 70.2, 'Python', 'Version 3.12.4')
空元组 ()
一个元素 (20,)
not_a_tuple:int
类型： <class 'tuple'>
辅助元组参数： (8, 8, 8, 8, 8, 8, 8, 8)
切片： (2, 3)
拼接的元组： ('小明', '小经', '郑老师', '小陈', '小郑')
小郑 , 小经 , 小明

特别注意:

Python3 中元组与字符串类似，可以被索引且下标索引从0开始，-1 为从末尾开始的位置.
Python3 把字符串看作一种特殊的元组，其内部元素是不可改变的，
python3 中空元组以及包含 0 或 1 个元素的元组(1,)的特殊语法规则，若单0、1元组中无逗号，它将被解释为一个普通的值而不是元组。
Python3 中元组/列表/字符串都属于 sequence（序列） 英 / ˈsiːkwəns（序列），都是通过索引获取元素（支持负数索引），可通过分片的方法得到一个范围内的元素的集合。
Python3 中元组不存在列表推导式，而是生成器推导式 genexpr 之中。

1.6 集合(Set)

描述：Python 中的集合（Set）是一种无序、包含可变的数据类型，用于存储唯一的元素使用大括号 {} 表示，元素之间用逗号 , 分隔，另外也可以使用 set() 函数创建集合。

例如，定义集合的两种方式

代码语言：javascript复制

numberSet = {1,2,3,4,5,6}
multipleSet = {1024,"公众号","全栈工程师修炼指南"}
# 或者
set2 = set(1,2,3,4,5,6)

示例，集合类型实践记录

代码语言：javascript复制

#!/usr/bin/python3
# coding=utf-8
# 功能：基础数据类型之集合类型详解

# 集合输出随机排序，重复的元素被自动去掉
setDemo = {'weiyigeek',10.24,1024}
student = {"全栈工程师修炼指南","掌门人","海鹏","柳师傅","渣渣辉","凡哥",1024,1024,'weiyigeek'}
print(type(setDemo),setDemo)  # 输出无序
print(type(student),student)  # 输出无序

# 集合成员测试
if 'weiyigeek' in student:
  print("元素存在!")
else:
  print("元素不存在!")

# 集合运算测试
a = set('abracadabra')
b = set('alacazam')
print(a - b)     # a 和 b 的差集
print(a | b)     # a 和 b 的并集
print(a & b)     # a 和 b 的交集
print(a ^ b)     # a 和 b 中不同时存在的元素

# 集合其他特性
tuple1 = (1.1,2.2,3.3,True)  # 必须是同一类型才可相加（但Bool类型除外）
print(sum(tuple1))           # 求和

tuple2 = [23,56,2,16,96,12,14]
print(sorted(tuple2))          # 排序
print(list(reversed(tuple2)))  # 逆序
print(list(enumerate([23, 56, 2, 16, 96, 12, 14]))) # 枚举

# 类似列表推导式，同样集合支持集合推导式(Set comprehension)  
a = {x for x in 'abcasdsadsa' if x not in 'abc'}  
# 显示 {'d', 's'}字符, print(a) 集合支持集合推导式(Set comprehension)
print(a)

执行结果:

代码语言：javascript复制

<class 'set'> {'weiyigeek', 1024, 10.24}
<class 'set'> {1024, '掌门人', 'weiyigeek', '全栈工程师修炼指南', '海鹏', '渣渣辉', '柳师傅', '凡哥'}
元素存在!
{'r', 'd', 'b'}
{'z', 'c', 'd', 'b', 'm', 'l', 'a', 'r'}
{'a', 'c'}
{'m', 'z', 'l', 'd', 'r', 'b'}
7.6
[2, 12, 14, 16, 23, 56, 96]
[14, 12, 96, 16, 2, 56, 23]
[(0, 23), (1, 56), (2, 2), (3, 16), (4, 96), (5, 12), (6, 14)]
{'d', 's'}

特别注意：

Python3 中创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
Python3 中与列表推导式类似，同样集合支持集合推导式(Set comprehension)

1.7 字典(Dictionary)

Python 中的集合是一种映射类型，可存储任意类型且无序对象，字典用 { } 标识，它是一个无序的键(key) : 值(value) 的集合，还可使用构造函数 dict() 可以直接从键值对序列中构建字典, 其中键(key)必须使用不可变类型，格式如下所示：

代码语言：javascript复制

# 方式1
dict1 = {'name': '全栈工程师修炼指南', 'age': 28,'hobby': ['Python3','PHP','html5','js']}

# 方式2
dict2 = dict(name="全栈工程师修炼指南", age=28, hobby=["Python3","PHP","html5","js"])

示例，字典类型实践记录

代码语言：javascript复制

#!/usr/bin/python3
# coding=utf-8
# 功能：基础数据类型之字典类型详解

# 定义空字典
dict1 = {}

# 插入键值对元素
dict1['one'] = "1 - Python3"
dict1['two'] = "2 - Version 3.7.2"
tinydict = {'name':"weiyigeek",'age':21,'hobby':"Python3 PHP html5 js"}

print(dict1)           # 输出dict1字典
print(dict1['one'])    # 输出dict1字典中键为one的值
print(tinydict.keys()) # 输出字典所有键
print(tinydict.values(),end="n") # 输出字典键中所有值
del dict1['one']    # 删除指定键值
del dict1           # 删除字典

# 使用构造函数 dict() 可以直接从键值对序列中构建字典
cdict1 = dict(Tencent=1, Baidu=2, Alibaba=3)                   #方式1 
cdict2 = dict([('Tencent', 1), ('Baidu', 2), ('Alibaba', 3)])  #方式2 可迭代对象方式来构造字典
cdict3 = dict((['a',2],['b',3]))                             #方式3 传入内嵌列表
cdict4 = dict(zip(['one', 'two', 'three'], [1, 2, 3]))       #方式4 映射函数方式来构造字典
cdict5 = {x: x**2 for x in (2, 4, 6)}                        #方式5 字典推导式
print("cdict1: ",cdict1)
print("cdict2: ",cdict2)
print("cdict3: ",cdict3)
print("cdict4: ",cdict4)
print("cdict5: ",cdict5)

执行结果:

代码语言：javascript复制

{'one': '1 - Python3', 'two': '2 - Version 3.7.2'}
1 - Python3
dict_keys(['name', 'age', 'hobby'])
dict_values(['weiyigeek', 21, 'Python3 PHP html5 js'])
cdict1:  {'Tencent': 1, 'Baidu': 2, 'Alibaba': 3}
cdict2:  {'Tencent': 1, 'Baidu': 2, 'Alibaba': 3}
cdict3:  {'a': 2, 'b': 3}
cdict4:  {'one': 1, 'two': 2, 'three': 3}
cdict5:  {2: 4, 4: 16, 6: 36}

特别注意:

字典是集合的表亲，两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
字典与列表的区别在于：字典是无序的对象集合（类似于JSON），列表是有序的对象集合。
字典中键必须是唯一且是不可变的(字符串，数字或元组),值可以取任何数据类型。
字典不允许同一个键出现两次，创建时如果同一个键被赋值两次，后一个值会覆盖前值。
字典也有自己的推导式，例如：

代码语言：javascript复制

x = {i: i ** 2 for i in range(10)}         # 计算表达式
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}

x = {i: i % 2 for i in range(10)}          # 计算表达式
{0: 0, 1: 1, 2: 0, 3: 1, 4: 0, 5: 1, 6: 0, 7: 1, 8: 0, 9: 1}

y = {i: i % 2 == 0 for i in range(10)}   # 条件表达式
{0: True, 1: False, 2: True, 3: False, 4: True, 5: False, 6: True, 7: False, 8: True, 9: False}

1.8 字节(bytes)

在 Python3 中，bytes 类型表示的是不可变的二进制序列（byte sequence），元素为整数值（0 到 255 之间的整数），而不是 Unicode 字符。此数据类型通常用于处理二进制数据，比如图像文件、音频文件、视频文件、网络编程等等，创建 bytes 对象的方式有多种，例如：

代码语言：javascript复制

# 方式1.使用 b 前缀
x = b"hello"

# 方式2.第一个参数是要转换的对象，第二个参数是编码方式，如果省略第二个参数，则默认使用 UTF-8 编码：
x = bytes("hello", encoding="utf-8")

示例，字节类型实践记录

代码语言：javascript复制

#!/usr/bin/python3
# coding=utf-8
# 功能：基础数据类型之字节类型详解

# 定义空字典
x = b"Hello Python3!"
y = x[1:3]                # 切片操作
z = x   b"I am learning"  # 拼接操作

# bytes 类型元素是整数值,使用 ord() 函数用于将字符转换为相应的ASCII整数值。
print(x[0],ord("H"))
if x[0] == ord("H"):
  print("The first element is 'h'")

执行结果:

代码语言：javascript复制

b'Hello Python3!'
b'el'
b'Hello Python3!I am learning'
72 72
The first element is 'h'

特别注意:

bytes 类型是不可变的，在 bytes 类型是不可变的需要创建一个新的 bytes 对象。
bytes 类型也支持许多操作和方法，如切片、拼接、查找、替换等。
bytes 类型中的元素是整数值，因此在进行比较操作时需要使用相应的ASCII整数值。
bytes 类型中使用b/B前缀表示，字符串类型中使用r/B前缀输入含特殊字符的字符串, 格式化输出时使用f/F前缀输出指定变量。

0x02 数据类型转换

虽然 Python 是弱类型语言，但是在编程时常常需对数据类型进行转换，其中Python 数据类型转换可以分为两种：隐式类型转换和显式类型转换。

2.1 隐式类型转换

在隐式类型转换中，Python 会自动将一种数据类型转换为另一种数据类型，不需要我们去干预。

例如，较低数据类型（整数）与较高数据类型（浮点数）进行计算时，将结果自动转换为浮点数，即隐式类型转换。

代码语言：javascript复制

num_int = 123
num_flo = 1.23
num_new = num_int   num_flo
print("num_new 值为:",num_new)             # 输出结果为：124.23
print("num_new 数据类型为:",type(num_new)) # num_new 数据类型为: <class 'float'>

知识扩展:

在Python中，数据类型的"高"和"低"主要根据它们的精度来判断，其中精度可以理解为数据类型能够表示的信息量或详细程度，而"较高数据类型"和"较低数据类型"是在隐式类型转换中用于描述数据精度的概念。

通常情况下，Python的数据类型的"高低"可以按照如下顺序理解：布尔（bool）< 整型（int） < 浮点型（float）< 复数（complex）。

例如，浮点数比整数"高"，因为浮点数不仅可以表示整数，还可以表示小数，因此上述例子中，整数就会被自动转换为浮点数，以保证信息不丢失。

例如，复数（complex）比浮点数（float）和整数（int）"高"，因为复数可以表示实数和虚数，而浮点数和整数只能表示实数。所以在进行运算时，如果操作数包含复数，那么其他的浮点数或整数就会被转换为复数。

2.2 显式类型转换

在显式类型转换中，Python 需要手动进行转换，此时只需要将数据类型作为函数名包含需要类型转换的变量即可，然后函数将返回一个新的对象，表示转换的值；

例如，整型和字符串类型运算时，将字符串类型转换为整型，然后进行计算，否则结果会报错，输出 TypeError。

代码语言：javascript复制

num_int = 123
num_str = "456"
print("num_int 数据类型为:",type(num_int)) #  <class 'int'>
print("num_str 数据类型为:",type(num_str)) #  <class 'str'>
print(num_int int(num_str))                # 输出结果为：579

特别注意:

虽然Python提供了一些内置的函数来实现不同数据类型之间的转换，如int(), float(), str(), list(), tuple(), set()等，但并非所有类型的数据都可以被转换成其他任意类型，是否转换主要取决于数据本身是否包含足够的信息来表示目标类型。

例如，你可以将整数类型转换成字符串类型，也可以将只包含数字字符的字符串（如"1024"）转换为一个整数或浮点数。

然而，非数字字符串（如"Hello"），它无法被转换为一个整数或浮点数，因为这个字符串并不包含任何可以表示一个数字的信息。

总的来说，数据类型的转换并非无限制，它取决于原始数据是否能够提供足够的信息来表示目标类型，当你在编程中进行类型转换时，需要注意这一点。

2.3 数据类型转换函数列表

描述：在下表中，将列出Python中几个常用的内置的数据类型转换函数。

函数	描述
[int(x ,base])	将x转换为一个整数
float(x)	将x转换到一个浮点数
[complex(real ,imag])	创建一个复数，例如: complex(1) 与 complex("1") 输出都为：(1 0j)
str(x)	将对象 x 转换为字符串
repr(x)	将对象 x 转换为表达式字符串
eval(str)	用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s)	将序列 s 转换为一个元组（不可变数据）
list(s)	将序列 s 转换为一个列表（可变数据）
set(s)	转换为可变集合
dict(d)	创建一个字典,d 必须是一个 (key, value)元组序列。
frozenset(s)	转换为不可变集合
chr(x)	将一个整数转换为一个字符（ASCII，可打印字符）
ord(x)	将一个字符转换为它的整数值
hex(x)	将一个整数转换为一个十六进制字符串
oct(x)	将一个整数转换为一个八进制字符串

示例，数据类型转换函数综合示例

代码语言：javascript复制

#!/usr/bin/python3
# coding=utf-8
# 功能：基础数据类型之字节类型详解

# 1.16进制数0xa、012转换为整型,8进制数转换为整型。
print("整形 : 0xa=",int('0xa',16)," 0x12=",int('12',16)," 010=",int('10',8)) 
                  
# 2.整型转换为浮点类型                    
print("浮点 :",float('123'),float(1)) 

# 3.整型、字符串转为复数 
# 注意: 在" "号两边不能有空格，也就是不能写成"1   2j"，应该是"1 2j"，否则会报错
print("复数 :",complex(1,2),complex("1 2j")) 

# 4.映射函数方式来构造字典
cdict = dict(zip(['one', 'two', 'three'], [1, 2, 3]))   
print("str cdict: ",str(cdict))   # 将对象转化为字符串形式。
print("repr cdict: ",repr(cdict))  # 将对象转化为供解释器读取的形式。

# 5.执行一个字符串表达式,可以执行python的一些数学函数和计算，此函数黑客脚本中常用！
print(eval(' 2 ** 2'), eval('pow(2,2)'))  # 幂乘

# 6.重复的被删除
print(set(['b', 'r', 'u', 'o', 'n']), set(['e', 'o', 'g', 'l']))

# 7.生成一个新的不可变集合
print(frozenset(range(10)))  

# 8.将ASCII码转字符串类型
print(chr(48),chr(65),chr(97))   

# 9.将字符串转换为ASCII码值
print(ord('0'),ord('A'),ord('a'))

# 10.将整数转换为16进制字符串
print("hex(255) = ",hex(255)," hex(15) = ",hex(15))

# 11.将整数转换为8进制字符串
print("oct(255) = ",oct(255),"oct(10) = ",oct(10))

执行结果:

代码语言：javascript复制

整形 : 0xa= 10  0x12= 18  010= 8
浮点 : 123.0 1.0
复数 : (1 2j) (1 2j)
str cdict:  {'one': 1, 'two': 2, 'three': 3}
repr cdict:  {'one': 1, 'two': 2, 'three': 3}
4 4
{'u', 'r', 'o', 'b', 'n'} {'o', 'l', 'g', 'e'}
frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
0 A a
48 65 97
hex(255) =  0xff  hex(15) =  0xf
oct(255) =  0o377 oct(10) =  0o12

如果此篇文章对你有帮助，请你将它转发给更多的人!

变量集合数据类型字符串 python3

0 人点赞