本专栏系列为Pythong基础系列，每篇内容非常全面，包含全网各个知识点，非常长，请耐心看完。
每天都会更新新的内容，搜罗全网资源以及自己在学习和工作过程中的一些总结，可以说是非常详细和全面。
以至于为什么要写的这么详细：自己也是学过Python的，很多新手只是简单的过一篇语法，其实对于一个知识点的底层逻辑和其他使用方法以及参数详情根本不是很了解，这就导致学完很容易忘记，而且在实战过程中也是半知半解，所以自己就尽量写的详细些，让需要的人能更了解Python的每一个知识点，也感谢大家指正，祝大家早日从小码农变成大牛！
- 博客主页：长风清留扬-CSDN博客
- 系列专栏：Python基础专栏
- 每天更新大数据相关方面的技术，分享自己的实战工作经验和学习总结，尽量帮助大家解决更多问题和学习更多新知识，欢迎评论区分享自己的看法
- 感谢大家点赞👍收藏⭐评论
推荐阅读：
Python全网最全基础课程笔记(三)——所有运算符+运算符优先级
浮点数精度不再是困扰：Python高手的精准编程秘籍！解决Python浮点数精度问题！
惊！Python新手竟能做出这些？简易计算器、天气预报系统...你也可以！
Python编程实战营：四款实用小项目助你快速入门，从零开始打造你的个人项目集！
目录
3.8.地板除 (//=)、取模 (%=)、幂 (**=) 的赋值运算符
基本数据类型
Python是一种高级编程语言，它支持多种数据类型，用于存储和操作不同类型的数据。Python的数据类型主要分为两大类：基本数据类型和复合数据类型。下面详细解释这两大类中的常见数据类型。
本文主要介绍基本数据类型。
关于数据类型的运算推荐阅读这篇文章：
Python全网最全基础课程笔记(三)——所有运算符+运算符优先级-CSDN博客
基本数据类型
基本数据类型是Python中最基础的数据类型，它们用于存储单个值。Python中的基本数据类型包括：
-
整数（int）：用于存储整数值，可以是正数或负数，没有大小限制（在大多数现代Python实现中）。
-
浮点数（float）：用于存储带有小数点的数值，即实数。Python中的浮点数通常是双精度浮点数。
-
布尔值（bool）：用于表示真（True）或假（False）的值。布尔值常用于控制程序流程。
-
字符串（str）：用于存储文本数据，即一系列字符。Python中的字符串是不可变的，意味着一旦创建，就不能更改字符串中的字符。
-
字节串（bytes）：与字符串类似，但字节串用于存储字节数据（如二进制数据）。字节串也是不可变的。
-
NoneType（None）：表示空值或“无”的特殊数据类型。它只有一个值：None。
复合数据类型
复合数据类型比较复杂，后面会单独写几篇文章来介绍，本文主要介绍基本数据类型。
复合数据类型用于存储多个值，这些值可以是不同类型的数据。Python中的复合数据类型包括：
-
列表（list）：有序的数据集合，可以包含不同类型的元素。列表是可变的，意味着可以添加、删除或修改其中的元素。
-
元组（tuple）：与列表类似，但元组是不可变的。一旦创建，就不能更改元组中的元素。元组通常用于存储不应该改变的数据。
-
集合（set）：无序的、不包含重复元素的集合。集合主要用于数学上的集合操作，如并集、交集、差集和对称差集。
-
字典（dict）：存储键值对（key-value pairs）的集合。字典是可变的，可以添加、删除或修改键值对。键必须是唯一的，而值则可以是任何数据类型。
注意事项
- Python是动态类型语言，意味着你不需要在声明变量时指定其类型。变量的类型是在运行时根据赋给它的值自动确定的。
- 字符串、字节串、列表、元组、集合和字典都是可迭代对象，可以使用循环遍历它们的元素。
- 字符串和字节串是不可变的，而列表、集合和字典是可变的。这意味着你可以修改列表、集合和字典的内容，但不能修改字符串和字节串的内容（尽管你可以创建新的字符串或字节串来反映更改）。
整数类型
Python中的整数类型（
int）是Python基本数据类型之一，用于表示没有小数部分的数字。Python的整数类型具有一些独特的特点和强大的功能，下面将详细和全面地介绍Python中的整数类型。
1. 整数类型的表示
在Python中，整数可以直接通过数字字面量来表示，无需任何前缀或后缀。例如：
a = 10
b = -5
c = 0这里，a、b、c都是整数类型的变量。
2. 整数的大小
Python的整数类型在大多数现代Python实现（如CPython）中都是“任意精度”的，这意味着它们可以表示非常大的数，只受限于计算机的内存大小，理论上取值范围是[负无穷,正无穷]。这与一些其他编程语言（如C或Java）中的整数类型不同，后者通常有固定的位数限制（如32位或64位）。
3. 整数类型的操作
Python支持对整数进行各种算术操作，包括：
- 加法（
+）：a + b - 减法（
-）：a - b - 乘法（
*）：a * b - 除法（
/）：注意，在Python 3中，/运算符执行的是真除法，结果总是浮点数。对于整数除法，应使用//运算符。 - 整除（
//）：a // b，结果是商的整数部分，向下取整。 - 取模（
%）：a % b，结果是a除以b的余数。 - 幂运算（
**）：a ** b，表示a的b次幂。
3.1. 加法 (+)
加法运算符用于将两个或多个数值相加。
a = 5
b = 3
result = a + b # 结果为 8
print(result)3.2. 减法 (-)
减法运算符用于从一个数中减去另一个数。
a = 10
b = 4
result = a - b # 结果为 6
print(result)3.3. 乘法 (*)
乘法运算符用于将两个数相乘。
a = 5
b = 2
result = a * b # 结果为 10
print(result)3.4. 除法 (/)
除法运算符用于将一个数除以另一个数，并返回商（浮点数）。
a = 10
b = 2
result = a / b # 结果为 5.0
print(result)
# 如果除不尽，则返回带小数的结果
a = 10
b = 3
result = a / b # 结果为 3.3333333333333335（由于浮点数精度问题）
print(result)3.5. 整除 (//)
整除运算符用于将一个数除以另一个数，并返回商的整数部分（向下取整）。
a = 10
b = 3
result = a // b # 结果为 3
print(result)
# 注意，结果总是整数
a = -10
b = 3
result = a // b # 结果为 -4
print(result)3.6. 取模 (%)
取模运算符用于返回两个数相除的余数。
a = 10
b = 3
result = a % b # 结果为 1
print(result)
# 注意，结果的正负号与被除数相同
a = -10
b = 3
result = a % b # 结果为 -1
print(result)3.7. 幂 (**)
幂运算符用于计算一个数的另一个数次幂。
a = 2
b = 3
result = a ** b # 结果为 8
print(result)3.8.地板除 (//=)、取模 (%=)、幂 (**=) 的赋值运算符
这些运算符是上述算术运算符的赋值版本，它们将结果直接赋值给左侧的变量。
a = 10
b = 3
a //= b # a 现在为 3
print(a)
a = 10
b = 3
a %= b # a 现在为 1
print(a)
a = 2
b = 3
a **= b # a 现在为 8
print(a)3.9.算术运算注意事项
- 当使用除法（
/）时，结果总是浮点数，即使两个操作数都是整数。 - 整除（
//）的结果总是整数，且向下取整。 - 取模（
%）的结果的正负号与被除数相同。 - 幂（
**）运算符可以计算非常大的数，但请注意Python的整数大小限制（取决于系统架构，通常是很大的数）。
4. 位运算
Python还支持对整数进行位运算，这些运算直接操作整数的二进制表示。位运算包括：
- 按位与（
&） - 按位或（
|） - 按位异或（
^） - 按位取反（
~） - 左移（
<<） - 右移（
>>）
4.1. 按位与（&）
按位与运算符&对两个整数的二进制表示进行逐位与操作。如果两个相应的位都为1，则该位的结果为1，否则为0。
a = 6 # 二进制表示为 110
b = 3 # 二进制表示为 011
result = a & b # 结果为 2，二进制表示为 010
print(result)4.2. 按位或（|）
按位或运算符|对两个整数的二进制表示进行逐位或操作。如果两个相应的位中至少有一个为1，则该位的结果为1；如果两个位都为0，则该位的结果为0。
a = 6 # 二进制表示为 110
b = 3 # 二进制表示为 011
result = a | b # 结果为 7，二进制表示为 111
print(result)4.3. 按位异或（^）
按位异或运算符^对两个整数的二进制表示进行逐位异或操作。如果两个相应的位相同，则该位的结果为0；如果两个位不同，则该位的结果为1。
a = 6 # 二进制表示为 110
b = 3 # 二进制表示为 011
result = a ^ b # 结果为 5，二进制表示为 101
print(result)4.4. 按位取反（~）
按位取反运算符~对整数的二进制表示进行逐位取反操作。即，将所有的0变为1，所有的1变为0。注意，按位取反的结果会考虑整数的符号位（在二进制表示中，最高位为符号位，0表示正数，1表示负数），并且结果通常是一个负数（在二进制补码表示中）。
a = 6 # 二进制表示为 0000 0110（这里假设是8位表示，实际上Python中的整数是任意精度的）
result = ~a # 结果为 -7，因为二进制表示为 1111 1001（取反后，且考虑符号位和补码表示）
print(result)4.5. 左移（<<）
左移运算符<<将数的二进制表示向左移动指定的位数，右边超出的位被丢弃，左边超出的部分用0填充。左移相当于乘以2的幂次方。
a = 1 # 二进制表示为 0001
result = a << 2 # 结果为 4，二进制表示为 1000（向左移动2位）
print(result)4.6. 右移（>>）
右移运算符>>将数的二进制表示向右移动指定的位数，左边超出的位被丢弃。对于无符号数，右边超出的部分用0填充；但对于有符号数（如Python中的整数），具体行为取决于实现（Python使用补码表示负数，因此右移时左边超出的部分会用符号位填充）。右移相当于除以2的幂次方并向下取整。
a = 8 # 二进制表示为 1000
result = a >> 2 # 结果为 2，二进制表示为 0010（向右移动2位）
print(result)
# 对于负数，注意Python使用补码表示
a = -8 # 在补码表示中，可能类似于...1111 1000（这里简化了表示）
result = a >> 2 # 结果取决于具体实现，但通常会是负数，且绝对值减半
print(result) # 输出结果可能是-2，但具体取决于Python解释器的实现和整数的位数4.7.位运算注意事项
- 位运算的结果取决于操作数的二进制表示，因此在进行位运算之前，Python会先将操作数转换为整数（如果它们还不是整数的话）。
- 对于负数，按位取反和右移操作的结果可能与你直觉上的“数学”结果不同，因为Python（和大多数现代计算机）使用二进制补码来表示负数。
- 位运算在处理大数据集、优化性能或进行低级编程时非常有用，但在日常编程中可能不太常见。
5. 整数类型的转换
Python提供了内置函数来将其他数据类型转换为整数类型，如int()函数。这个函数尝试将参数转换为整数，如果参数是一个浮点数，则转换会丢弃小数部分（向下取整）：
print(int(3.14)) # 值为 3 ,向下取整
print(int('123')) # 值为 123
print(int('abc')) # 报错，无法转换：ValueError: invalid literal for int() with base 10: 'abc'但是，如果转换无法成功（例如，将字符串'abc'转换为整数），则会引发ValueError异常。
6. 整数类型的特殊值
Python的整数类型还有一些特殊值，如：
0：表示零。1和-1：分别表示正一和负一，常用于循环、条件判断等场景。None：虽然None不是整数类型，但它是一个特殊的值，表示“无”或“空”。
7. 整数类型的性能
由于Python的整数是任意精度的，因此它们在进行大数运算时非常高效，不需要担心溢出问题。然而，这也意味着在处理非常大的整数时，可能会消耗较多的内存。
8. 整数类型的应用
整数类型在Python中非常常用，几乎在所有的编程任务中都会用到。它们被用于计数、索引、循环控制、数学计算等多种场景。
浮点数类型
Python中的浮点数类型（
float）用于表示具有小数部分的实数。这些数值在内部通常以IEEE 754双精度浮点数表示，这意味着它们可以表示非常大或非常小的数值，但也存在精度限制和表示误差。下面将详细解释Python中浮点数类型的各个方面。
1. 浮点数的表示
在Python中，浮点数通过包含小数点的字面量来表示，或者通过科学记数法（使用e或E表示10的幂）来表示。
# 浮点数字面量
num1 = 3.14
num2 = 0.000001
# 科学记数法
num3 = 3.14e2 # 等于 314.0
num4 = 1.23e-3 # 等于 0.001232. 浮点数的精度
由于浮点数在内部使用二进制表示，并且基于IEEE 754标准，因此它们可能无法精确表示所有十进制小数。这种限制会导致所谓的“舍入误差”。
# 浮点数精度问题示例
print(0.1 + 0.2) # 输出可能是 0.30000000000000004 而不是 0.3这里的问题在于，0.1 和 0.2 在二进制中都是无限循环小数，计算机只能存储它们的近似值。当这两个近似值相加时，结果也是一个近似值，这个近似值可能并不完全等于我们期望的十进制结果。
这种情况在财务计算、科学计算等需要高精度的场景中尤为重要，需要特别注意或使用专门的库（如decimal）来处理。
具体关于Python浮点数精度的问题可以查看下面这篇文章：
浮点数精度不再是困扰：Python高手的精准编程秘籍！解决Python浮点数精度问题！-CSDN博客
3. 浮点数的比较
由于浮点数的精度问题，直接比较两个浮点数是否相等可能会遇到问题。因此，在比较浮点数时，通常需要检查它们是否“足够接近”而不是严格相等。
# 浮点数比较示例
def are_close(a, b, rel_tol=1e-09, abs_tol=0.0):
return abs(a-b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)
print(are_close(0.1 + 0.2, 0.3)) # 输出 True4. 浮点数的方法
Python的浮点数类型提供了多种内置方法，用于执行各种数学和格式化操作。
num = 3.14
# 转换为整数（向下取整）
print(int(num)) # 输出 3
# 四舍五入
print(round(num)) # 输出 3，也可以指定小数位数，如 round(num, 2) 输出 3.14
# 格式化输出
print(f"{num:.2f}") # 输出 '3.14'
# 获取绝对值
print(abs(num)) # 输出 3.14
# 其他数学运算（使用math模块）
import math
print(math.sqrt(num)) # 输出 num 的平方根5. 浮点数与整数的转换
浮点数和整数之间可以相互转换，但转换时可能会丢失精度（从浮点数到整数）或增加精度（从整数到浮点数）。
# 整数转浮点数
i = 3
f = float(i) # 现在是 3.0
# 浮点数转整数（向下取整）
f = 3.14
i = int(f) # 现在是 3，小数部分被丢弃6. 注意事项
- 在进行金融或需要高精度的计算时，考虑使用
decimal模块而不是浮点数。 - 注意浮点数比较中的精度问题，并考虑使用相对或绝对容差来比较浮点数。
- 浮点数运算可能会产生意外的结果，特别是在涉及非常大或非常小的数值时。在这些情况下，请考虑使用
math模块中的函数来处理特殊数值和运算。
布尔类型
在Python中，布尔类型（
bool）是一种基本的数据类型，用于表示真（True）或假（False）的逻辑状态。布尔类型在控制流程语句（如if语句）中起着至关重要的作用，也常用于表示某些操作的成功或失败。
基本用法
在Python中，布尔值True和False是布尔类型的两个实例。它们可以直接在代码中使用，也可以从比较操作、逻辑运算等表达式中得出。
示例代码：基本使用
# 直接使用布尔值
flag = True
# if判断，如果条件为True就执行if里面的语句，flag的值等于true所以print("Flag is True")
if flag:
print("Flag is True") # 输出： Flag is True
# 布尔值作为条件表达式的结果
a = 5
b = 10
# if判断，如果条件为True就执行if里面的语句，5<10是正确的所以为true，那么就走print("a is less than b") 这条语句
if a < b:
print("a is less than b") # 输出 a is less than b
else:
print("a is not less than b")布尔值的隐式转换
在Python中，很多值都可以隐式地转换为布尔值。以下是一些常见的规则：
- 数值
0、0.0、0j（复数0）以及空的数据结构（如空字符串''、空列表[]、空字典{}、空集合set()、空元组()等）被视为False。 - 所有的其他值都被视为
True。
示例代码：隐式转换
# 数值的隐式转换
if 0:
print("0=True")
else:
print("0=False")
# 输出：0=False
# 空数据结构(空字符串)的隐式转换
if '':
print("空字符串=True")
else:
print("空字符串=False")
# 输出：空字符串=False
#空数组
if []:
print("空数组=True")
else:
print("空数组=False")
# 输出：空数组=False
# 非空数据结构的隐式转换
if 'Hello':
print("非空字符串=True")
else:
print("非空字符串=False")
# 输出：非空字符串=True
#非空数组
if [1, 2, 3]:
print("非空数组=True")
else:
print("非空数组=False")
# 输出：非空数组=True逻辑运算符
Python提供了三种逻辑运算符：and、or和not，它们用于组合布尔值或表达式，并返回布尔结果。
示例代码：逻辑运算符
# and 运算符 如果 5 > 3 并且 2 < 3 那么结果就为True，就执行print("Both conditions are True")
if 5 > 3 and 2 < 3:
print("Both conditions are True")
# 输出：Both conditions are True
# or 运算符 5 > 3 或者 2 > 3 只要满足一个条件就为True
if 5 > 3 or 2 > 3:
print("At least one condition is True")
# 输出：At least one condition is True
# not 运算符 正常是5 > 3结果就是True，但是有一个not 就是这个判断结果为False才会执行print("5 is not greater than 3")
if not (5 > 3):
print("5 is not greater than 3")
else:
print("5 is greater than 3")
# 输出：5 is greater than 3进阶案例：布尔值的实际应用
在实际应用中，布尔值经常用于控制循环的继续执行、作为函数的返回值以表示成功或失败等。
示例代码：函数返回布尔值
def is_even(number):
"""检查数字是否为偶数"""
return number % 2 == 0
# 使用函数
if is_even(4):
print("4 is even")
else:
print("4 is not even")
# 在循环中使用布尔值控制执行
numbers = [1, 2, 3, 4, 5]
for number in numbers:
if is_even(number):
print(f"{number} is even")字符串类型(重点)
Python中的字符串类型（
str）是用于表示和存储文本数据的基本数据类型。字符串是不可变的，意味着一旦创建，就不能更改其内容（尽管可以创建新的字符串作为修改后的版本）。字符串在Python中广泛使用，用于存储文本信息、进行文本处理、以及与其他数据类型进行交互。
字符串的创建
字符串可以使用单引号（'）、双引号（"）或三引号（''' 或 """）来创建。单引号和双引号在功能上是等价的，而三引号通常用于创建多行字符串或包含特殊字符（如换行符）的字符串。
# 使用单引号
s1 = 'Hello, world!'
# 使用双引号
s2 = "Hello, world!"
# 使用三引号创建多行字符串
s3 = """This is a multi-line string.
It can span multiple lines."""
# 字符串中的特殊字符可以通过反斜杠转义
s4 = 'She said, "Hello, world!"'字符串的基本操作
字符串支持多种基本操作，如索引、切片、拼接、重复等。
索引：
通过索引可以访问字符串中的单个字符。索引从0开始。
s = 'Hello, world!'
print(s[0]) # 输出: H
print(s[-1]) # 输出: !（负索引从字符串末尾开始）切片：
通过切片可以获取字符串的一个子串。
s = 'Hello, world!'
print(s[7:12]) # 输出: world
print(s[:6]) # 输出: Hello,
print(s[6:]) # 输出: , world!拼接：
可以使用加号（+）来拼接字符串。
s1 = 'Hello, '
s2 = 'world!'
print(s1 + s2) # 输出: Hello, world!重复：
可以使用乘号（*）来重复字符串。
s = 'Hi '
print(s * 3) # 输出: Hi Hi Hi字符串的不可变性
字符串是不可变的，这意味着一旦字符串被创建，你就不能更改其内容。但是，你可以通过拼接、切片等操作来创建新的字符串。
s = 'Hello, world!'
# 尝试修改字符串（错误示例）
# s[0] = 'J' # 这会引发TypeError
# 正确的做法：创建一个新的字符串
new_s = 'J' + s[1:]
print(new_s) # 输出: Jello, world!字符串的方法
Python的字符串对象提供了大量的方法来执行各种操作，如查找、替换、分割、连接等。
查找
find(), index(), startswith(), endswith()等。
s = 'Hello, world!'
print(s.find('world')) # 输出: 7
print(s.index('world')) # 输出: 7，如果找不到会抛出ValueError
print(s.startswith('Hello')) # 输出: True
print(s.endswith('!')) # 输出: True替换
replace()
s = 'Hello, world!'
print(s.replace('world', 'Python')) # 输出: Hello, Python!分割
split()
s = 'apple,banana,cherry'
print(s.split(',')) # 输出: ['apple', 'banana', 'cherry']连接
join()（注意，这是将序列中的元素以指定的字符串作为分隔符连接成一个新的字符串）
words = ['Hello', 'world']
print(' '.join(words)) # 输出: Hello world进阶案例
字符串解析和处理
假设你有一个以逗号分隔的字符串，你需要将其解析成一个列表，并对列表中的每个元素进行处理。
data = 'Alice:30,Bob:25,Charlie:22'
# 使用split(',')分割字符串，然后遍历分割后的列表
for item in data.split(','):
name, age = item.split(':') # 进一步分割每个元素
print(f'Name: {name}, Age: {age}')使用正则表达式处理字符串
对于更复杂的字符串处理任务，可以使用Python的re模块来应用正则表达式。
import re
text = 'The quick brown fox jumps over the lazy dog.'
# 使用正则表达式查找所有单词
words = re.findall(r'\b\w+\b', text)
print(words) # 输出: ['The', 'quick', 'brown', 'fox', 'jumps', 'over', 'the', 'lazy', 'dog.']字节串类型
Python中的字节串类型（
bytes）是一种用于表示不可变字节序列的数据类型。与字符串（str）相似，但字节串是专门为处理二进制数据设计的。字节串的每个元素都是一个在范围0到255之间的整数，通常表示为一个8位的字节。这使得字节串非常适合处理文件I/O操作、网络通信等需要处理二进制数据的场景。
字节串的创建
字节串可以通过在字符串前加上b前缀并使用单引号或双引号来创建。字符串中的每个字符都将被转换成对应的ASCII码（或Unicode字符的UTF-8编码，如果字符不在ASCII范围内）。
# 创建一个简单的字节串
b1 = b'hello'
print(b1) # 输出: b'hello'
# 包含非ASCII字符的字节串（这里假设使用的是UTF-8编码）
b2 = b'\xe4\xbd\xa0\xe5\xa5\xbd' # 你好 的UTF-8编码
print(b2.decode('utf-8')) # 输出: 你好，这里使用decode方法将字节串解码为字符串
# 使用bytes()函数创建字节串
b3 = bytes('hello', encoding='utf-8') # 将字符串按UTF-8编码转换为字节串
print(b3) # 输出: b'hello'
# 使用bytearray对象转换为字节串（注意：bytearray是可变的）
ba = bytearray([72, 101, 108, 108, 111]) # ASCII码对应的hello
b4 = bytes(ba)
print(b4) # 输出: b'hello'字节串的基本操作
字节串支持类似于字符串的索引、切片和连接操作，但由于字节串是处理二进制数据的，因此不支持字符串的某些特定方法（如find()、replace()等，除非先将字节串解码为字符串）。
b = b'hello world'
# 索引
print(b[0]) # 输出: 104，即'h'的ASCII码
# 切片
print(b[7:]) # 输出: b'world'
# 连接
b_new = b + b'!'
print(b_new) # 输出: b'hello world!'
# 注意：不支持直接使用字符串方法与字节串，需要先解码
# 错误的用法示例：b.find(b'world') # 对于字节串，find() 是支持的
# 但下面的用法是错误的，因为 b'world' 是字节串，而 'world' 是字符串
# print(b.find('world')) # TypeError: a bytes-like object is required, not 'str'字节串与字符串的转换
由于字节串和字符串经常需要相互转换，Python提供了encode()和decode()方法来实现这一功能。
encode(encoding='utf-8', errors='strict')：将字符串编码为字节串。decode(encoding='utf-8', errors='strict')：将字节串解码为字符串。
s = 'hello'
b = s.encode('utf-8') # 字符串编码为字节串
print(b) # 输出: b'hello'
b = b'hello'
s = b.decode('utf-8') # 字节串解码为字符串
print(s) # 输出: hello字节串的注意点
- 不可变性：字节串是不可变的，与字符串相同。一旦创建，就不能更改其内容。
- 编码：处理字节串时，需要注意编码问题。不同的编码方式会导致不同的字节序列。
- 二进制数据处理：字节串特别适合于处理需要精确控制二进制数据的场景，如文件读写、网络通信等。
进阶案例
字节串在网络通信中的应用
在网络编程中，经常需要发送和接收字节串形式的数据。以下是一个简单的TCP客户端示例，展示如何发送字节串数据。
import socket
# 创建一个socket对象
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 连接到服务器
s.connect(('localhost', 12345))
# 发送字节串数据
message = b'Hello, server!'
s.sendall(message)
# 关闭连接
s.close()注意：在实际应用中，服务器也需要被相应地实现以接收和处理这些字节串数据。
字节串与文件I/O
在处理二进制文件（如图片、视频等）时，通常使用字节串来进行读写操作。
# 写入二进制文件
with open('example.bin', 'wb') as f:
f.write(b'\x00\x01\x02\x03\x04')
# 读取二进制文件
with open('example.bin', 'rb') as f:
content = f.read()
print(content) # 输出: b'\x00\x01\x02\x03\x04'以上详细介绍了Python中的字节串类型，包括其创建、基本操作、与字符串的转换、注意点以及在网络通信和文件I/O中的应用。
NoneType(None空值)
NoneType在 Python 中是一个特殊的类型，用于表示一个空值或“无”的概念。它是 Python 中的一个单例对象，意味着在整个 Python 解释器运行期间，只有一个None存在。None经常被用作函数的默认返回值，或者用来表示某些变量或参数尚未被赋予任何值。
NoneType 的基本特性
-
单例性：在 Python 中，
None是唯一的NoneType实例。任何试图创建NoneType实例的尝试都会失败，因为NoneType不能被实例化。 -
布尔值：在布尔上下文中，
None被视为False。这意呀着在需要布尔值的表达式中（如if语句），None会导致条件判断为假。 -
可比较性：
None可以与任何对象进行比较，但结果总是False，除了与另一个None比较时，结果为True。 -
不可变性和无状态性：
None是不变的，没有状态或内部数据可以修改。
代码案例
基本使用
# 检查变量是否为 None
x = None
if x is None:
print("x is None") # 输出: x is None
# 使用 None 作为函数的默认返回值
def get_value(key, dictionary):
return dictionary.get(key) # 如果 key 不在 dictionary 中，将返回 None
result = get_value('not_exist', {'a': 1, 'b': 2})
if result is None:
print("Key not found") # 输出: Key not found注意事项
-
使用
is而不是==：当检查一个变量是否为None时，应使用is而不是==。这是因为is检查两个对象的身份（即它们是否是同一个对象），而==检查两个对象的值是否相等。虽然在这个特定情况下==也会工作，但使用is更为明确且是 Pythonic 的做法。 -
不要与空数据类型混淆：
None不应与空的数据类型（如空字符串''、空列表[]、空字典{}等）混淆。这些空数据类型在布尔上下文中也被视为False，但它们与None在语义上有显著区别。
进阶案例
使用 None 进行可选参数和默认值的处理
def my_function(param=None):
if param is None:
print("No parameter provided")
else:
print(f"Parameter provided: {param}")
# 调用函数，不提供参数
my_function() # 输出: No parameter provided
# 调用函数，提供参数
my_function("Hello, world!") # 输出: Parameter provided: Hello, world!在设计模式中的应用
None 在实现某些设计模式时非常有用，特别是空对象模式（Null Object Pattern）。在这个模式中，None 或一个特殊的空对象实例被用作默认返回值，以简化对空值的检查。
class NullObject:
def __init__(self):
pass
def method(self):
# 空实现，可以添加默认行为
print("This is a null object")
# 使用 NullObject 替代 None
def get_object(condition):
if condition:
return RealObject() # 假设 RealObject 是某个类的实例
else:
return NullObject()
# 无需检查 None，可以直接调用方法
obj = get_object(False)
obj.method() # 输出: This is a null object在这个例子中，NullObject 类提供了一个默认实现，这样调用者就不需要检查返回值是否为 None，并据此决定是否调用方法或进行其他操作。这可以提高代码的清晰度和健壮性。然而，需要注意的是，过度使用这种模式可能会使代码的逻辑变得难以追踪和理解。
本文结束。
推荐阅读
Python全网最全基础课程笔记(一)——基础入门-CSDN博客
Python全网最全基础课程笔记(二)——变量-CSDN博客
Python全网最全基础课程笔记(三)——所有运算符+运算符优先级-CSDN博客
探索Python世界的趣味之旅：自制贪吃蛇游戏-CSDN博客
浮点数精度不再是困扰：Python高手的精准编程秘籍！解决Python浮点数精度问题！-CSDN博客
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
