目录
一、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 数据类型有所帮助!如有任何问题或建议,请留言讨论。