Python常用数据类型新手必看超详细介绍

Elysiα

已于 2024-07-17 20:24:09 修改

阅读量1.2k

点赞数 31

文章标签： python 开发语言

于 2024-07-13 16:47:35 首次发布

本文链接：https://blog.csdn.net/2301_76730867/article/details/140399356

版权

一、Int整型

整数（int）：表示整数，如 -5, 0, 100 等，属于不可迭代对象。整型是不可变的数据类型，在内存中每个整型数据只存在唯一的地址。在代码中我们可以使用以下2种方式来表示整型数据。

方式一：直接赋值

number = 1  # 方式1  直接赋值
print(number)  # 1

方式二：用 int() 转化

number = int("1")  # 方式二  将字符串"1"转为整型
print(number)  # 1

二、Float浮点型

浮点数（float）：表示有小数部分的数值，如 3.14, -0.001, 2.0 等，属于不可迭代对象。浮点型是不可变的数据类型，在内存中每个浮点型数据只存在唯一的地址。在代码中我们可以使用以下两种方式来表示浮点型数据。

方式一：直接赋值

number = 1.0  # 方式1  直接赋值
print(number)  # 1.0

方式二：用 float() 转化

number = float("1.1")  # 方式二  将字符串"1"转为浮点型
print(number, type(number))  # 1.1 <class 'float'>

number = float(1)  # 将整型"1"转为浮点型
print(number, type(number))  # 1.0 <class 'float'>

科学计数法

在python中可以把一些很长的小数，用科学计数法的方式缩写。

a = 0.0000000000003
print(a)  # 3e-13

打印出a的值为3e-13。其中e表示10的指数函数，e-13就表示 $10^{-13}$ ，3e-13就表示 $3\ast 10^{-13}$ 。python中使用科学计数法表示的数据都属于浮点型。

举例：

a = 1e2
print(a)  # 100.0

三、Bool布尔类型

在 Python 中，也有与 0、1 表现相似的数据类型——布尔类型(bool)。布尔类型是 int 类型的延续，只有 True 与 False 两种取值： True >> 真 False >> 假

bool函数

bool()函数 Python 提供的 bool(表达式) 函数，可以用来测试一个表达式的布尔值结果。

对于数字来说，值为 0 则表示 False，值不为 0 则表示 True
对于字符串、列表、元组、字典、集合等对象，若为空则表示 False,不为空则表示 True

print(bool(True)+1)  # 2
print(bool(False)+1) # 1

四、Str字符型

用单引号或双引号引起来的字符如："a"，"1"，"*"，"abc"，'12#@'等等，是可迭代对象。是不可变的数据类型，因为当一个字符串被定义后，字符串里面任意一个字符都是确定的，我们不能在代码中去修改一个字符串，但我们可以通过拼接和切片的方式得到一个新的字符串。在代码中我们可以使用以下2种方式来表示字符串。

字符串的声明

方式一：利用引号赋值

str1 = 'abc'
str2 = "abc"
str3 = '''abc'''
str4 = """abc"""
# 三重引号可以赋值多行字符串

方式二：使用 str() 函数

str1 = str(123)
print(str1, type(str1))  # 123 <class 'str'>

字符串的常见操作

查找：

print("abcd123abcd123".index("123"))  # 找第一个出现的索引  找不到 会报错
print("abcd123abcd123".rindex("123"))  # 从右侧找第一个的索引
print("abcd123abcd123".find("123"))  # 找第一个出现的索引  找不到 返回 -1
print("abcd123abcd123".rfind("123"))  # 从右侧找第一个的索引

计数：

print("abcd123abcd123".count("123"))  # 统计目标出现的次数

大小写转换：

print("aBcd efG".capitalize())  # 首字母大写
print("aBcd".upper())  # 全大写
print("aBcd".lower())  # 全小写
print("aBcd efG".swapcase())  # 大小写转换
print("aBcd efG".title())  # 单词首字母大写

编码与解码：

bytes_result = "字符串".encode(encoding="utf8")  # 编码  encoding指明编码解码方式
print(type(bytes_result), bytes_result)  # <class 'bytes'> b'\xe5\xad\x97\xe7\xac\xa6\xe4\xb8\xb2'
str_result = bytes_result.decode(encoding="utf8")  # 解码
print(type(str_result), str_result)  # <class 'str'> 字符串

切割与拼接：

r = "abcd123abcd123abcd".split("123")  # 将字符串 切割 返回一个列表
print(type(r), r)
# <class 'list'> ['abcd', 'abcd', 'abcd']
print("++".join(r))  # 使用指定字符串将可迭代类型中每一个元素都拼接
# abcd++abcd++abcd

替换：

print("abcd123abcd123abcd".replace("123", "___"))  # 将指定内容替换掉字符串中的内容
# abcd___abcd___abcd

五、None

None 表示为空值，其类型为 NoneType

注意：

NoneType 只有 None 一个值
None 与其它值比较永远返回 False
None 的布尔值永远为 False

六、List列表

数据类型list，list是python内置的一种高级数据类型。list是一种有序的集合，基于链表实现在python中应用很广泛

列表的声明

声明方式一：

l0 = []
print(l0, type(l0))
l1 = [1, 2, 3.2, 'abc']
print(l1, type(l1))

声明方式二：

l2 = list()  # 只能将可迭代类型转化为列表类型
print(l2, type(l2))
l3 = list(range(5))
print(l3, type(l3))

列表的常见操作

增加元素：

l = [1, 3, 5]

l.append(7)  # 插入末尾
print(l)  # [1, 3, 5, 7]
l.insert(1, 2)  # 在指定位置插入指定元素
print(l)  # [1, 2, 3, 5, 7]
l.extend(range(10))  # 将可迭代元素的每一个元素依次放在列表末尾
print(l)  # [1, 2, 3, 5, 7, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

删除元素：

r = l.pop()  # 删除指定索引对应的元素  默认为末尾

l.remove(7)  # 删除指定的值  不存在则报错

l.clear()  # 清空列表

其他：

l.index(5)  # 查找元素的索引  找不到报错
l.count(5)  # 统计元素出现的次数
l.reverse()  # 逆序排列
l.sort(reverse=True)  # 默认升序排列  reverse=True 表示降序

七、Tuple元组

元组是一个不可改变的列表。

元组的创建很简单，使用圆括号 () 直接创建或者使用 tuple() 函数创建，只需要在圆括号中添加元素，并使用逗号隔开即可。

元组的声明

元组的定义方式一：

t1 = ()
print(t1, type(t1))  # () <class 'tuple'>
t2 = (10,)
print(t2, type(t2))  # (10,) <class 'tuple'>
t3 = 10, 20, 30
print(t3, type(t3))  # (10, 20, 30) <class 'tuple'>

注意事项：如果只有一个元素，则逗号不可以省略。

元组的定义方式二：

# tuple(可迭代)
t4 = tuple("hello")
print(t4, type(t4))  # ('h', 'e', 'l', 'l', 'o') <class 'tuple'>
t5 = tuple([1, 2, 3])
print(t5, type(t5))  # (1, 2, 3) <class 'tuple'>
t6 = tuple(range(4))
print(t6, type(t6))  # (0, 1, 2, 3) <class 'tuple'>

元组的常见操作

查找&计数

.index(value)  # 寻找目标的索引
.count(value)  # 寻找目标的各种

index(value)：返回元素对于的索引，找不到就会报错
count(value)：返回元素出现的次数，找不到就会返回0

t1 = (10, 20, 30, 40, 50)
print(t1.count(30))  # 30出现的次数为1
print(t1.index(30))  # 30所在的索引为2

八、Dict字典

Python字典是另一种可变容器模型,可存储任意类型对象。如字符串、数字、元组等其他容器模型
因为字典是无序的所以不支持索引和切片。

字典的声明

字典的定义方式一：

d0 = {}
print(d0)  # {}
d1 = {
    'name': '字典',
    "age": 18
}
print(d1)  # {'name': '字典', 'age': 18}

字典的定义方式二：

d2 = dict()
print(d2)       # {}
d3 = dict(a=10, b=20, c=30)
print(d3)       # {'a': 10, 'b': 20, 'c': 30}

字典的键与值

字典内元素以键值对存在==key(键值): value(实值)

d5 = {
    10: 40,
    3.14: "PI",
    False: "bool",
    "name": "dict",
    None: "None",
    (): "tuple",
}
print(d5)  # 键值不可变类型

key不可以重复,否则只会保留第一个;
value值可以是任意数据类型，可以重复;
key是不可变类型，保证key唯一;
key一般形式为字符串。

字典的常见操作

in成员运算符：

d6 = {
    "id": 101,
    "name": "字典"
}
print("name" in d6)  # True

查看键是否在字典中

len()：

d6 = {
    "id": 101,
    "name": "字典"
}
print(len(d6))   # 2  返回值为键值对的个数

字典的遍历：

keys():

遍历所有的键

d6 = {
    "id": 101,
    "name": "字典"
}
for k in d6.keys():
    print(k, d6[k])

# id 101
# name 字典

values():

遍历所有的值

for v in d6.values():
    print(v)
# 101
# 字典

items():

遍历所有的键值对

for k, v in d6.items():  # id 101 \n name 字典
    print(k, v)
# id 101 
# name 字典

get()：

d6 = {
    'id': 101,
    'name': '乔布斯',
    'addr': '杭州',
    'hobby': '睡觉'
}
print(d6)
print(d6.get("name"), d6.get("hobby", "打篮球"), d6.get("123", "打篮球"))
# {'id': 101, 'name': '乔布斯', 'addr': '杭州', 'hobby': '睡觉'}
# 乔布斯 睡觉 打篮球

获取指定键对应的值
如果键不存在返回None
也可以指定键不存在时返回默认的值

添加：

变量名 [键名] = 值

d6 = {
    'id': 101,
    'name': '乔布斯',
    'addr': '杭州'
}
d6["hobby"] = "睡觉"
print(d6)
# {'id': 101, 'name': '乔布斯', 'addr': '杭州', 'hobby': '睡觉'}

删除：

pop("")：删除指定的键，并返回对应的值

d6 = {
    'id': 101,
    'name': '字典',
    'sex': '男'
}
r = d6.pop("id")  # 删除
print(r, d6)
# 101 {'name': '字典', 'sex': '男'}

popitem()：删除并且返回（元组）最后放入的一个键值对，但是字典一般不关注先后顺序

r = d6.popitem()  # 删除并且返回（元组）最后放入的一个键值对
print(r, d6)
# ('sex', '男') {'name': '字典'}

clear()：清空

d6.clear()  # 清空
print(d6)  # {}

合并：

update(字典)：合并为一个字典到原始字典

d6 = {
    'id': 101, 
    'name': '字典', 
    'sex': '男'
}
d6.update({  # 合并一个字典到原始字典
    "addr": "杭州",  # 添加
    "name": "乔布斯"  # 更新
})
print(d6)
# {'id': 101, 'name': '乔布斯', 'sex': '男', 'addr': '杭州'}

九、Set

在 Python 中，集合（Set）是一种无序且元素唯一的数据结构。集合对象支持多种数学运算，如并集、交集、差集等。

集合的定义

可以使用花括号 {} 或者 set() 构造函数来创建集合：

# 使用花括号创建集合
set0 = {1, 2, 3, 4, 5}

# 使用 set() 构造函数创建集合
set1 = set([4, 5, 6, 7, 8])

方法一无法创建空集合，空花括号{}为字典。

方法二将可迭代类型元素依次放入集合

在集合中，重复的元素会被自动忽略，确保每个元素都是唯一的。

集合的遍历

可以使用 for 循环遍历集合中的所有元素：

set0 = {1, 2, 3, 4, 5}
for e in set0:
    print(e)

因其无序特性，无法用索引遍历。

集合的基本操作

添加元素：

可以使用 .add() 方法向集合中添加元素：

# 添加
s4 = {1, 3, 5}
s4.add(7)    # 添加元素 7

# {1, 3, 5, 7}

删除元素：

可以使用 .pop() .discard() .remove() .clear() 等方法删除元素：

s4 = {1, 3, 5, 7, 9}
s4.discard(100)  # 删除一个元素  不存在不报错

s4.remove(9)  # 删除一个元素  不存在则报错
print(s4)  # {1, 3, 5, 7}

s4.pop()  # 任意删除一个  因为本身无序
print(s4)  # {3, 5, 7}

s4.clear()  # 清空
print(s4)  # set()

合并：

可以使用 .update() 方法向集合中添加元素：

# 合并
s4 = {1, 3, 5}
s4.update({3, 5, 7, 9})
print(s4)  # {1, 3, 5, 7, 9}

集合的运算

集合支持多种数学运算，如交集、并集、差集。

s5 = {1, 3, 5}
s6 = {3, 5, 7}

交集 (`intersection`)：

返回同时在两个集合中的元素：

s7 = s5.intersection(s6)  # 交集
print(s7)  # {3, 5}

并集 (`union`)：

返回包含两个集合所有元素的新集合：

s8 = s5.union(s6)  # 并集
print(s8)  # {1, 3, 5, 7}

差集 (`difference`)：

返回存在于第一个集合但不存在于第二个集合的元素：

s9 = s5.difference(s6)  # 差集
print(s9)  # {1}
s10 = s6.difference(s5)  # 差集
print(s10)  # {7}

Elysiα

关注

31
点赞
踩
19

收藏

觉得还不错? 一键收藏
0
评论
Python常用数据类型新手必看超详细介绍

可以使用花括号{}或者set()# 使用花括号创建集合# 使用 set() 构造函数创建集合方法一无法创建空集合，空花括号{}为字典。方法二将可迭代类型元素依次放入集合在集合中，重复的元素会被自动忽略，确保每个元素都是唯一的。集合的遍历可以使用 forprint(e)因其无序特性，无法用索引遍历。
复制链接

扫一扫