六、【Python】基础教程-【Python全掌握】六大基础数据类型：浮点、布尔、列表、元组、字典、集合的终极指南

暴躁的大熊

于 2024-07-25 08:14:31 发布

阅读量1.1k

点赞数 41

文章标签： python 开发语言 List Set Dict Tuple Float

本文链接：https://blog.csdn.net/xgq8217/article/details/140653855

版权

🌟📚【Python全掌握】六大基础数据类型：浮点、布尔、列表、元组、字典、集合的终极指南📚🌟

博主往期文章分享：

【机器学习】专栏 http://t.csdnimg.cn/sQBvw

【Python学习】专栏http://t.csdnimg.cn/ckqMs

三、基础类型“列表（list）” 处理方法

四、基础类型“元组（tuple）”处理方法

一、基础类型“浮点型”处理方法

在Python中，浮点型数据是用于表示实数的一种基本数据类型。由于浮点数的二进制表示和有限的精度，它们在进行数学运算时可能会产生一些意料之外的结果。以下是Python中处理浮点型数据的一些常见方法和技巧：

1. 使用内置函数`float()`

可以将字符串或其他数值转换为浮点数。

num = float('123.45')
print(num)  # 输出: 123.45

2. 浮点数比较

直接比较浮点数可能不准确，应使用一个很小的误差范围来判断是否接近，以下示例运算结果的错误证明了以上观点，在处理浮点型数据比较时，应避免直接使用浮点型数据直接进行运算尽可能的转换为Decimal类型记性计算。
当直接比较浮点数时，由于浮点数的二进制表示以及计算过程中的舍入误差，即使理论上两个数应该相等，在实际计算中也可能得到不精确的结果。

a = 0.1 + 0.2
b = 0.3

if a == b:
    print("Numbers are equal.")
else:
    print("Numbers are not equal.")

print(a)  # 输出: 0.30000000000000004
print(b)  # 输出: 0.3

为了避免这种问题，通常会使用一个很小的正数（称为“容差”或“epsilon”）来检查两个浮点数是否足够接近，而不是检查它们是否完全相等。


def is_close(a, b, rel_tol=1e-9, abs_tol=0.0):
# abs：返回参数的绝对值
# max：返回参数的最大值
    return abs(a-b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)

print(is_close(0.1 + 0.2, 0.3))  # 输出: True

3. 使用`decimal`模块

提供了高精度的十进制浮点算术。注意使用decimal类型进行数据计算，要统一所有数据类型均为decimal，否则会导致系统异常。

from decimal import Decimal, getcontext

getcontext().prec = 6  # 设置精度
a = Decimal('0.1')
b = Decimal('0.2')
c = Decimal('0.3')
print(a + b == c)  # 输出: True

4. 使用`fractions`模块

可以将浮点数转换为分数形式，避免精度问题。

from fractions import Fraction

f = Fraction(0.1).limit_denominator()
print(f)  # 输出: 1/10

5. 格式化输出

使用format或f-string控制浮点数的输出格式。

x = 3.141592653589793
print(f'{x:.2f}')  # 输出: 3.14

6. 四舍五入

使用round()函数对浮点数进行四舍五入。

y = round(2.675, 2)
print(y)  # 输出: 2.68

7. 使用`math`模块

提供了各种数学函数，如sqrt, log, sin, cos等。

import math

print(math.sqrt(16))  # 输出: 4.0

8. 异常处理

当操作可能导致错误时，可以使用try...except语句捕获异常。

try:
    result = 1 / 0.0
except ZeroDivisionError:
    print("Cannot divide by zero")

需要Demo源码的同学，可以前往以下地址下载学习。

链接：https://pan.baidu.com/s/1ByWLkiXO9V5N2vjjvjpDkw?pwd=ucwg
提取码：ucwg

二、基础类型“布尔型”处理方法

在Python中，布尔类型是一种基本的数据类型，用于表示逻辑值，即True和False。Python的布尔类型与C语言等其他语言中的布尔类型有些不同，它不仅限于字面量True和False，还可以从其他数据类型的值推断出布尔值。

以下是在Python中处理布尔类型的一些常见方法：

1. 直接赋值和使用

可以直接将True或False赋给变量，并在表达式中使用它们：

is_raining = False
if is_raining:
    print("Take an umbrella!")
else:
    print("No need for an umbrella.")

2. 布尔值的逻辑运算

布尔值支持逻辑运算符and, or, not：

a = True
b = False
c = not b and a  # 结果为 True
d = a or b       # 结果为 True
print(c, d)      # 输出: True True

3. 条件语句中的布尔值

在条件语句中，任何非零数值、非空字符串或非空列表等都会被当作True处理，而0, None, False, 空字符串(""), 空列表([])等会被当作False处理：

value = 5
if value:
    print("Value is truthy.")
else:
    print("Value is falsy.")

4. 布尔值转换

可以使用bool()函数将其他数据类型转换为布尔值：

print(bool(1))       # 输出: True
print(bool(""))      # 输出: False
print(bool([]))      # 输出: False

5. 短路逻辑

在and和or运算中，Python使用短路逻辑。这意味着在and运算中，如果第一个操作数为False，那么不会评估第二个操作数；而在or运算中，如果第一个操作数为True，则不会评估第二个操作数：

def expensive_computation():
    print("This is expensive!")
    return True

if False and expensive_computation():
    pass  # expensive_computation() 不会被调用

if True or expensive_computation():
    pass  # expensive_computation() 不会被调用

6. 在循环和迭代中的使用

布尔值也可以在循环结构中使用，如while循环：

running = True
while running:
    user_input = input("Type 'quit' to exit: ")
    if user_input == "quit":
        running = False

需要Demo源码的同学，可以前往以下地址下载学习。

链接：https://pan.baidu.com/s/1ByWLkiXO9V5N2vjjvjpDkw?pwd=ucwg
提取码：ucwg

三、基础类型“列表（list）” 处理方法

Python中的列表（list）是一种非常灵活且强大的数据结构，用于存储有序的项目集合。列表是可变的，这意味着你可以添加、删除或修改其中的元素。以下是Python列表的一些常用操作及其示例：

1. 创建列表

使用方括号[]或list()函数创建一个列表。

numbers = [1, 2, 3]
empty_list = []
letters = list('hello')

2. 访问元素

使用索引访问列表中的元素。索引从0开始。

colors = ['red', 'green', 'blue']
print(colors[0])  # 输出: red

3. 切片

切片可以获取列表的一部分。

print(colors[1:])  # 输出: ['green', 'blue']
print(colors[:2])  # 输出: ['red', 'green']

4. 修改元素

可以通过索引直接修改元素。

colors[0] = 'purple'
print(colors)  # 输出: ['purple', 'green', 'blue']

5. 列表的长度

使用len()函数获取列表长度。

print(len(colors))  # 输出: 3

6. 添加元素

使用append()添加元素到列表末尾。
使用insert()在指定位置插入元素。

colors.append('yellow')
colors.insert(1, 'orange')

7. 删除元素

使用remove()删除特定值的第一个匹配项。
使用del语句删除指定位置的元素。
使用pop()删除并返回指定位置的元素。

colors.remove('orange')
del colors[0]
last_color = colors.pop()
print(colors)#输出['green', 'blue']

8. 排序

使用sort()对列表进行排序。
使用sorted()返回一个新的排序后的列表。

numbers = [3, 1, 4, 1, 5, 9]
numbers.sort()
sorted_numbers = sorted(numbers)
print(sorted_numbers)# 输出[1, 1, 3, 4, 5, 9]

9. 反转列表

使用reverse()反转列表中的元素顺序。

numbers.reverse()
print(numbers) # 输出[9, 5, 4, 3, 1, 1]

10. 列表推导式

# 快速创建新列表。
squares = [x**2 for x in range(5)]
print(squares) # 输出[0, 1, 4, 9, 16]

11. 连接列表

使用`+`运算符或`extend()`方法合并列表。

a = [1, 2]
b = [3, 4]
c = a + b
a.extend(b)
print(a) # 输出 [1, 2, 3, 4]
print(c) # 输出 [1, 2, 3, 4]

12. 复制列表

使用切片`[:]`或`copy()`方法复制列表。

copy_of_colors = colors[:]
copy_of_colors = colors.copy()
print(copy_of_colors) # 输出 ['green', 'blue']

13. 清空列表

#使用`clear()`方法清空列表。

colors.clear()
print(colors) #

14. 查找元素

使用`in`关键字检查元素是否在列表中。

print('red' in colors)  # 输出: False

15. 计数元素

使用`count()`方法计算列表中特定元素的出现次数。

print(colors.count('blue'))  # 输出: 0

需要Demo源码的同学，可以前往以下地址下载学习。

链接：https://pan.baidu.com/s/1ByWLkiXO9V5N2vjjvjpDkw?pwd=ucwg
提取码：ucwg

四、基础类型“元组（tuple）”处理方法

元组（tuple）是Python中另一种序列类型，与列表类似，但有一个关键的区别：元组是不可变的。这意味着一旦创建了一个元组，就不能再修改其内容。下面是一些处理元组的常见方法和示例：

1. 创建元组

使用圆括号()创建元组，或者简单地列出项目并用逗号分隔。

t = (1, 2, 3)
single_item_tuple = (4,)
no_parentheses_tuple = 5, 6, 7

2. 访问元素

使用索引访问元组中的元素，与列表相同。

print(t[0])  # 输出: 1

3. 切片

和列表一样，可以使用切片操作获取元组的部分元素。

print(t[1:])  # 输出: (2, 3)

4. 元组的长度

使用len()函数获取元组的长度。

print(len(t))  # 输出: 3

5. 连接元组

使用+运算符连接两个元组。

t1 = (1, 2)
t2 = (3, 4)
combined = t1 + t2

6. 重复元组

使用*运算符重复元组。

repeated = t * 2

7. 解包元组

将元组中的元素分配给多个变量。

x, y, z = t

8. 查找元素

使用in关键字检查元素是否存在于元组中。

print(2 in t)  # 输出: True

9. 计数元素

使用count()方法来确定元素在元组中出现的次数。

print(t.count(2))  # 输出: 1

10. 查找元素的索引

使用`index()`方法找到元素首次出现的位置。

print(t.index(3))  # 输出: 2

11. 排序和反转

虽然不能直接修改元组，但可以使用`sorted()`函数对元组元素进行排序，并且可以将结果存储在一个新的元组中。

sorted_tuple = sorted(t)
reversed_tuple = tuple(reversed(t))
print(sorted_tuple,reversed_tuple) # 输出[1, 2, 3] (3, 2, 1)

12. 转换为列表

如果需要修改元组的内容，可以先将其转换为列表。

list_from_tuple = list(t)
print(list_from_tuple)# 输出[1, 2, 3]

13. 元组作为字典键

元组可以作为字典的键，因为它们是不可变的。

d = {(1, 2): 'a', (3, 4): 'b'}
print(d)#输出{(1, 2): 'a', (3, 4): 'b'}

14. 使用元组推导式

类似于列表推导式，但生成的是元组。

squares = tuple(x**2 for x in range(5))
print(squares) # 输出(0, 1, 4, 9, 16)

由于元组是不可变的，所以它们通常用于不需要改变的数据集合，比如函数参数或返回值，以及多值返回的情况。此外，元组在内存使用上通常比列表更高效，因此在性能敏感的应用场景中也是很好的选择。

需要Demo源码的同学，可以前往以下地址下载学习。

链接：https://pan.baidu.com/s/1ByWLkiXO9V5N2vjjvjpDkw?pwd=ucwg
提取码：ucwg

五、字典（dict）

字典（dict）是 Python 中一种非常强大的数据结构，它以键值对的形式存储数据。键必须是不可变类型，如字符串、数字或元组，而值可以是任何数据类型。下面列举了一些常见的字典操作方法和示例：

1. 创建字典

使用花括号 {} 或 dict() 构造函数。

d = {'name': 'Alice', 'age': 30}
empty_dict = {}
fromkeys_dict = dict.fromkeys(['key1', 'key2'], 'default')

2. 访问元素

使用键来访问字典中的值。

print(d['name'])  # 输出: Alice

3. 添加元素

直接通过键赋值添加新元素。

d['email'] = 'alice@example.com'

4. 修改元素

使用键来修改已存在的值。

d['age'] = 31

5. 删除元素

使用 del 关键字删除键值对。

del d['age']

6. 检查键是否存在

使用 in 关键字检查字典中是否存在某个键。

if 'name' in d:
    print("Key exists.")

7. 获取字典的键、值、项

使用 keys(), values(), items() 方法分别获取字典的键、值、键值对。

keys = d.keys()
values = d.values()
items = d.items()

8. 遍历字典

默认遍历字典时，会遍历其键。

for key in d:
    print(key, d[key])

遍历键值对：

for key, value in d.items():
    print(key, value)

9. 更新字典

使用 update() 方法从另一个字典中更新键值对。

new_data = {'age': 32, 'city': 'New York'}
d.update(new_data)

10. 复制字典

使用 `copy()` 方法或字典推导式。

copy_dict = d.copy()
copy_dict2 = {k: v for k, v in d.items()}

11. 字典推导式

使用字典推导式创建或修改字典。

squared_dict = {x: x**2 for x in [1, 2, 3]}

12. 获取默认值

使用 `get()` 方法安全地获取值，如果键不存在则返回默认值。

print(d.get('email', 'No email provided'))

13. 弹出元素

使用 `pop()` 方法移除并返回一个键对应的值。

email = d.pop('email')

14. 清空字典

使用 `clear()` 方法清空字典。

d.clear()

15. 字典视图对象

`keys()`, `values()`, `items()` 返回的是视图对象，这些对象会在字典变化时反映最新的状态。

view_keys = d.keys()

16. 字典合并

使用 `|` 运算符或 `**` 解包语法在 Python 3.9+ 版本中合并字典。

merged_dict = d | new_data
merged_dict2 = {**d, **new_data}

字典提供了非常灵活的方式来组织和操作数据，特别是在需要快速查找和修改数据的场景中。注意，从 Python 3.7 开始，字典保持了插入顺序，这使得字典在某些场景下更加有用。

需要Demo源码的同学，可以前往以下地址下载学习。

链接：https://pan.baidu.com/s/1ByWLkiXO9V5N2vjjvjpDkw?pwd=ucwg
提取码：ucwg

六、集合（set）

集合（set）在Python中是一种无序且不包含重复元素的数据类型。集合支持数学上的集合运算，如交集、并集、差集和对称差等。下面是一些常用的集合操作及其示例：

1. 创建集合

使用大括号 {} 或 set() 函数创建集合。

s1 = {1, 2, 3}
s2 = set([1, 2, 2, 3, 4])
empty_set = set()

2. 添加元素

使用 add() 方法向集合中添加一个元素。

s1.add(4)

3. 移除元素

使用 remove() 或 discard() 方法移除元素。

s1.remove(4)  # 如果元素不存在，会抛出 KeyError
s1.discard(5)  # 如果元素不存在，什么也不做

4. 集合的并集

使用 union() 方法或 | 运算符获取两个集合的并集。

union_set = s1.union(s2)
union_set2 = s1 | s2

5. 集合的交集

使用 intersection() 方法或 & 运算符获取两个集合的交集。

intersection_set = s1.intersection(s2)
intersection_set2 = s1 & s2

6. 集合的差集

使用 difference() 方法或 - 运算符获取两个集合的差集。

difference_set = s1.difference(s2)
difference_set2 = s1 - s2

7. 集合的对称差集

使用 symmetric_difference() 方法或 ^ 运算符获取两个集合的对称差集。

symmetric_diff_set = s1.symmetric_difference(s2)
symmetric_diff_set2 = s1 ^ s2

8. 检查子集和超集

使用 issubset() 和 issuperset() 方法检查一个集合是否是另一个集合的子集或超集。

is_subset = s1.issubset(s2)
is_superset = s2.issuperset(s1)

9. 更新集合

使用 update(), intersection_update(), difference_update(), 和 symmetric_difference_update() 方法原地修改集合。

s1.update(s2)
s1.intersection_update(s2)
s1.difference_update(s2)
s1.symmetric_difference_update(s2)

10. 集合的长度

使用 `len()` 函数获取集合的元素数量。

length = len(s1)

11. 遍历集合

使用 `for` 循环遍历集合中的元素。

for element in s1:
    print(element)

12. 判断元素是否在集合中

使用 `in` 关键字检查元素是否在集合内。

if 1 in s1:
    print("Element is in the set.")

13. 集合的不可变版本

使用 `frozenset()` 创建不可变的集合，这在需要将集合作为字典键或集合元素的场合非常有用。

frozen_set = frozenset(s1)

集合非常适合用于去除重复元素、执行集合运算和快速查找元素。由于集合内部实现为哈希表，因此元素的添加、移除和查找操作通常具有 O(1) 的平均时间复杂度，这使得集合在大数据量和高性能需求的场景中特别有用。

需要Demo源码的同学，可以前往以下地址下载学习。

链接：https://pan.baidu.com/s/1ByWLkiXO9V5N2vjjvjpDkw?pwd=ucwg
提取码：ucwg

暴躁的大熊

关注

41
点赞
踩
6

收藏

觉得还不错? 一键收藏
0
评论
六、【Python】基础教程-【Python全掌握】六大基础数据类型：浮点、布尔、列表、元组、字典、集合的终极指南

本文介绍了基础数据类型“浮点型（Float）”+“布尔型（Bool）” + “列表（List）”+“元组（Tuple）” + “字典（dict）” + “集合（set）”处理方法
复制链接

扫一扫