Python各种数据类型定义及其操作方法合集

目录

一、Int（整数）

二、Float(浮点数)

三、bool（布尔值）

四、str（字符串）

五、None

六、list（列表）

七、tuple（元组）

八、dict（字典）

结论

---

一、Int（整数）

整数是 Python 中最基本的数值类型，表示整数值。它没有大小限制，可以是正数、负数或零。整数又分为二进制，八进制，十进制，十六进制数

二进制：0b开头

八进制：0o开头

十进制：1，2，3，4，5，6，7，8，9，10，11......

十六进制：0x开头

示例代码

# 二进制
print(0b110)  # 6
# 八进制
print(0o110)  # 72
# 十进制
print(100)    # 100
# 十六进制
print(0x110)  # 272

类型转换 int（）:可以数字型字符串，浮点数转换为整数

 示例代码

string = "123"
string_int = int(string)
print(string_int, type(string_int))   # 123 <class 'int'>

f = 12.35
f_int = int(f)
print(f_int, type(f_int))  # 12 <class 'int'>

二、Float(浮点数)

浮点数用于表示带有小数点的数值。在 Python 中，浮点数可以使用科学计数法表示。

# 基本浮点数定义
a = 3.14
b = 2.718

# 算术运算
print(a + b)  # 输出: 5.858
print(a * b)  # 输出: 8.53932

# 类型转换
c = float("3.5")
print(c)  # 输出: 3.5

科学计数法表示浮点数

# e代表10， e后面数代表 次方，可以为负数
a = 4e2
print(a)  # 400.0

b = 4e-2
print(b)  # 0.04

三、bool（布尔值）

布尔值表示真（True）或假（False）的逻辑值。在 Python 中，布尔值常用于控制流程和条件判断。

# 基本布尔值定义
is_true = True
is_false = False

# 逻辑运算
print(is_true and is_false)  # 输出: False
print(is_true or is_false)   # 输出: True

# 类型转换  
d = bool(1)
print(d)  # 输出: True

a = 0
b = ""
c = None
d = []  # 空列表
e = {}  # 空字典
f = ()  # 空元组
g = set()  # 空集合
print(bool(a))  # False 
print(bool(b))  # False
print(bool(c))  # False
print(bool(d))  # False
print(bool(e))  # False
print(bool(f))  # False
print(bool(g))  # False

 四、str（字符串）

字符串是 Python 中用于表示文本数据的数据类型。字符串可以使用单引号、双引号或三引号来定义。

# 基本字符串定义
str1 = "Hello"
str2 = 'World'
str3 = """hello"""

# 字符串拼接
greeting = str1 + " " + str2
print(greeting)  # 输出: Hello World

 字符串常用方法：查找，计算，大小写转换，判断开头结尾，解码与编码，填充，检查字符串......

# 字符串长度
print(len(greeting))  # 输出: 11

print("=========================查找=================================")
s = "中华人民共和国的人民共和国"
# index  打印字符串中第一次出现查找的 字符串的 索引，若不存在，则会报错
print(s.index("人民"))  # 2
# rindex 从后往前查找，但索引还是从前开始排列
print(s.rindex("人民"))  # 2
# find 打印字符串中第一次出现查找的 字符串的 索引，若不存在，则会返回  -1
print(s.find("共和国"))  # 4
print(s.find("共和国0"))  # -1
 #rfind 从后往前查找，但索引还是从前开始排列
print(s.rfind("共和国"))  # 10
print(s.rfind("共和国0"))  # -1

print("=========================计算=================================")
s = "中华人民共和国的人民共和国"
# count 返回查找的字符串出现了多少次，可以指定范围
print(s.count("人民")) # 2
print(s.count("人民", 0, 6)) # 1


print("=========================大小写转换=================================")
c = "aBcd eFg"
# 字符串的第一个字母大写
print(c.capitalize())  # Abcd efg
# 字符串全部大写
print(c.upper())  # ABCD EFG
# 字符串全部小写
print(c.lower())  # abcd efg
# 字符串的 每个单词 首字母大写
print(c.title())  # Abcd Efg
# 字符串的大小写转换  大变小，小变大
print(c.swapcase())  # AbCD EfG

print("=========================判断开头和结尾=================================")
s = "中华人民共和国的人民共和国"
# 判断字符串是否以。。。开头
print(s.startswith("中华人"))  # True
# 判断字符串是否以。。。结尾
print(s.startswith("国0"))  # False


print("=========================解码和编码=================================")
s = "中华人民共和国的人民共和国"
# 对字符串进行编码 可以指定编码格式  utf8 / gbk   注意，解码和编码的格式需要一致
print(s.encode("utf8"))
print(s.encode("utf8").decode("utf8"))

print("=========================填充=================================")
s1 = "许老板"
# 将字符串指定长度居中填充，可以指定填充符号(单字符)
print(s1.center(20, "*"))
# 填充在最左边
print(s1.ljust(20, "*"))
# 填充在最右边
print(s1.rjust(20, "*"))
# 填充在最右边，但是填充的是0
print(s1.zfill(20))
print("=========================检查字符串=================================")
s2 = "123abc"
# 检查字符串是否只包含数字字符
print(s2.isdigit())   # False
# 用于检查字符串是否由字母和数字组成，且至少有一个字符
print(s2.isalnum())

print("=========================擦除前后字符=================================")
s = "           中华人民共和国的人民共和国               "
# 用于去除字符串两侧（开头和结尾）指定的字符（默认为空白字符）。 也可以自定义清楚的符号，比如strip("*")
print(s.strip())

print("=========================字符串分隔符=================================")
s = "hello world"
print(s.split())  # 输出: ['hello', 'world']，默认以空白字符分割
print(s.split('o'))  # 输出: ['hell', ' w', 'rld']，以字符 'o' 分割
print(s.split('l', 1))  # 输出: ['he', 'lo world']，以字符 'l' 分割，分割一次
print(s.split('x'))  # 输出: ['hello world']，分割结果为原始字符串的一个元素，因为找不到分隔符 'x'

print("=========================替换=================================")
s = "hello world"
print(s.replace("w", "123"))


print("=========================连接=================================")
# 连接列表中的字符串：
mylist = ["Hello", "World", "Python"]
result = " ".join(mylist)
print(result)  # 输出: Hello World Python
s1 = "hello world"
s2 = ",".join(s1)
print(s2)  # h,e,l,l,o, ,w,o,r,l,d
# 在这个例子中，" ".join(mylist) 将列表 mylist 中的元素用空格连接起来形成一个新的字符串。
# 连接元组中的字符串：
mytuple = ("apple", "banana", "cherry")
result = ", ".join(mytuple)
print(result)  # 输出: apple, banana, cherry
# 在这个例子中，", ".join(mytuple) 将元组 mytuple 中的元素用逗号和空格连接起来形成一个新的字符串。

# 连接生成器表达式中的字符串：
generator = (str(num) for num in range(1, 6))
result = "-".join(generator)
print(result)  # 输出: 1-2-3-4-5

五、None

None 是 Python 中表示空值或缺失值的特殊数据类型。它通常用作函数的默认返回值或变量的初始值。

# None 的基本使用
val = None

# 判断是否为 None
print(val is None)  # 输出: True

# None 不支持其他方法，因为它不是对象

 六、list（列表）

列表是 Python 中最常用的数据结构之一，用于存储有序的元素集合。列表使用方括号定义，元素之间用逗号分隔

# 列表中可以放入任意数据类型
s1 = ["123", "hello world", True, None]
print(s1)  # 输出['123', 'hello word', True, None]

# 列表的声明方式
# 如上直接声明
# 如下，使用list声明  list（）将一个可迭代数据转换成列表
s2 = list("hello world")
print(s2)  # 输出['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']
s3 = list(range(10))
print(s3)  # 输出[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

遍历列表的两种方式

# 1.for e in list 直接获取元素
s2 = list("hello world")
for e in s2:
    print(e, end="")  # 输出hello world
print()

# 根据列表元素索引来获取元素
length = len(s2)
for i in range(length):
    print(s2[i], end="")  # 输出hello world
print()

 列表常用的操作法方法

# 列表是可变数据类型
l = [1, 3, 5]
print("===================增加元素=====================")
# 在末尾插入 append(e)
l.append(2)
print(l)  # [1, 3, 5, 2]

# 指定位置插入  insert(index, e)
l.insert(1, 4)  # [1, 4, 3, 5, 2]
print(l)

# 将可迭代数据的每一个元素，依次添加到末尾 extend(iterable)
l.extend(range(7, 15))
print(l)  # [1, 4, 3, 5, 2, 7, 8, 9, 10, 11, 12, 13, 14]

print("===================删除元素=====================")
# l = [1, 4, 3, 5, 2, 7, 8, 9, 10, 11, 12, 13, 14]
# 默认删除末尾元素 pop()，或者删除指定索引元素pop(index)，并且返回被删除元素的值
l.pop()
print(l)  # [1, 4, 3, 5, 2, 7, 8, 9, 10, 11, 12, 13]
value = l.pop(4)
print(f"{value}被删除了", l)  # 2被删除了 [1, 4, 3, 5, 7, 8, 9, 10, 11, 12, 13]

# 删除指定元素 remove(e),如果e不存在，则会报错
value = l.remove(4)
print(l)  # [1, 3, 5, 7, 8, 9, 10, 11, 12, 13]

# 清空列表，clear(列表)
l.clear()
print(l)  # []

print("===================其他方法=====================")
l = [5, 3, 6, 9, 2, 4, 8, 5, 1, 7, 4, 3, 2]
# 查找元素的索引 index(value)，找不到则会报错
value1 = l.index(8)
print(value1) # 6

# 计算元素在列表中出现的次数并返回 count(e),
print(l.count(3))  # 2

# 将列表倒序输出 reverse()
l.reverse()
print(l)  # [2, 3, 4, 7, 1, 5, 8, 4, 2, 9, 6, 3, 5]

# 将列表排序，sort（）默认升序，sort（reverse = True）倒叙排列
l.sort()
print(l)  # [1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 7, 8, 9]
l.sort(reverse=True)
print(l)  # [9, 8, 7, 6, 5, 5, 4, 4, 3, 3, 2, 2, 1]

七、tuple（元组）

元组与列表类似，但是元组是不可变的序列。元组使用圆括号定义，一旦创建，就不能修改。

# =========================== 声明 =================================
# 标准声明方式
t1 = (1, 2, 3, 4, 5, 6)
print(t1, type(t1))  # (1, 2, 3, 4, 5, 6) <class 'tuple'>
# 如果元组中只有1个数据，则数据末尾的 "，" 不能省略
t2 = (1,)
print(t2)  # (1,)

# 利用tuple(iterable)声明元组
t3 = tuple("hello world")
print(t3, type(t3))  # ('h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd') <class 'tuple'>
t4 = tuple(range(10))
print(t4, type(t4))  # (0, 1, 2, 3, 4, 5, 6, 7, 8, 9) <class 'tuple'>

元组常用的方法

# ++++++++++++++++++++++++++++++元组操作++++++++++++++++++++++++++++++
# index  查询元素的索引
t6 = (1, 2, 3, 4, 5, 6, 7, 3, 2, 1, 6, 3, 4, 5, 3)
print(t6.index(3))  # 2
print(t6.count(3))  # 4



# 元组不支持修改元素，但可以合并和拆分
person = ("John", 30, "New York")
locations = ("Paris", "London", "New York")
all_locations = person + locations
print(all_locations)  # 输出: ('John', 30, 'New York', 'Paris', 'London', 'New York')

 八、dict（字典）

字典是 Python 中的映射数据类型，用于存储键-值对。字典使用花括号定义，键和值之间使用冒号分隔。

print("========================定义=============================")
d0 = {}
print(d0, type(d0))  # {} <class 'dict'>
d1 = {
    "name": "马云",
    "age": 18
}
print(d1, type(d1))  # {'name': '马云', 'age': 18} <class 'dict'>

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

 字典的三种遍历方式

# 方式1：遍历字典的键，通过键获取值  dict.keys()
for k in d5.keys():
    print(k, d5[k])
"""输出：
name Jeci
age 18
phone_number 11335426987
address 河南省洛阳市
hobbies ['吃饭', '逛街', '打豆豆']
"""

# 方式二：遍历字典的值，但不能通过值获取键  dict.values()
for v in d5.values():
    print(v)
"""输出：
Jeci
18
11335426987
河南省洛阳市
['吃饭', '逛街', '打豆豆']
"""
# 方式3：最常用的方法：直接获取键值对  dict.items()
for k, v in d5.items():
    print(k, v)
"""输出
name Jeci
age 18
phone_number 11335426987
address 河南省洛阳市
hobbies ['吃饭', '逛街', '打豆豆']
"""

 字典的常用方法

print("========================字典的操作=============================")
d5 = {
    "name": "Jeci",
    "age": 18,
    "phone_number": 11335426987,
    "address": "河南省洛阳市",
    "hobbies": ["吃饭", "逛街", "打豆豆"]
}
print("=================添加==================")
# 当键不存在时，会自动添加你写的键值对
d5["id"] = 101
print(d5["id"])  # 101
# 当键存在时,会修改键对应的值
d5["name"] = "luccy"
print(d5["name"])  # luccy

print("=================删除==================")
# pop（）根据键删除键值对，并返回值
r = d5.pop("age")
print(r)  # 18
print(
    d5)  # {'name': 'luccy', 'phone_number': 11335426987, 'address': '河南省洛阳市', 'hobbies': ['吃饭', '逛街', '打豆豆'], 'id': 101}

# popitem（）默认删除最后一个键值对，并返回这个键值对
r = d5.popitem()
print(r)  # ('id', 101)
print(d5)  # {'name': 'luccy', 'phone_number': 11335426987, 'address': '河南省洛阳市', 'hobbies': ['吃饭', '逛街', '打豆豆']}

# # clear（）清空字典
# d5.clear()
# print(d5)  # {}

print("=================修改==================")
# update()将另一个字典的键值对信息更新到自己的字典中，若键重复，则更新键对应的值
dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}
dict1.update(dict2)
print(dict1)  # {'a': 1, 'b': 3, 'c': 4}

print("=================查找==================")
# 获取键对应值并返回,若键不存在返回 None
print(d5.get("agg"))  # None
print(d5.get("name"))  # luccy
# 当查找的键不存在时，我们可以指定默认的返回值，键存在时，依旧返回键对应的值
print(d5.get("agg", "鸡蛋"))  # 鸡蛋
print(d5.get("name", "小米"))  # luccy

print("=================浅复制==================")
# copy（）浅复制：即复制旧的字典给到一个新的字典，当改变旧字典中的可变数据类型（list,dict）的数据时,新的字典也会随之改变
old_dict = {"my_list": [1, 2, 3], "my_dict": {"a": 1, "b": 2}}
# 将old_dict字典浅复制给new_dict
new_dict = old_dict.copy()
print(old_dict)  # {'my_list': [1, 2, 3], 'my_dict': {'a': 1, 'b': 2}}
print(new_dict)  # {'my_list': [1, 2, 3], 'my_dict': {'a': 1, 'b': 2}}
# 改变old_dict中的可变数据类型的数据
old_dict["my_list"].append(4)
old_dict["my_dict"]["c"] = 3
# new_dict也会随着改变
print(old_dict)  # {'my_list': [1, 2, 3, 4], 'my_dict': {'a': 1, 'b': 2, 'c': 3}}
print(new_dict)  # {'my_list': [1, 2, 3, 4], 'my_dict': {'a': 1, 'b': 2, 'c': 3}}

print("=================深复制==================")
# 引入 copy模块 ，使用deepcopy（）
import copy

old_dict = {"my_list": [1, 2, 3], "my_dict": {"a": 1, "b": 2}}
# 将old_dict深复制给new_dict
new_dict = copy.deepcopy(old_dict)
print(new_dict)  # {'my_list': [1, 2, 3], 'my_dict': {'a': 1, 'b': 2}}
# 改变old_dict中的可变数据类型的数据
old_dict["my_list"].append(4)
old_dict["my_dict"]["c"] = 3
# new_dict不会再随着old_dict改变
print(old_dict)  # {'my_list': [1, 2, 3, 4], 'my_dict': {'a': 1, 'b': 2, 'c': 3}}
print(new_dict)  # {'my_list': [1, 2, 3], 'my_dict': {'a': 1, 'b': 2}}

结论

本文介绍了 Python 中常见的基本数据类型及其常用方法。这些数据类型在 Python 编程中非常重要，能够帮助你处理各种类型的数据。希望本文对你理解和使用 Python 数据类型有所帮助！如有任何问题或建议，请留言讨论。