Python青少年简明教程：数据类型和操作符

Python青少年简明教程：数据类型和操作符

编程语言中数据类型是用来分类和描述不同种类的数据的方式。每种数据类型定义了数据的性质、可以对其执行的操作，以及它在内存中的存储方式。

字面量（Literal）是指在程序中直接表示固定值的表示法——是源代码中直接出现的数据值。如：

整数字面量：如 42, -17, 1000000

浮点数字面量：如 3.14, -0.01, 2.5e-4 (科学记数法)

字符串字面量：'Hello'、"World"

数据类型简介

Python 中的常用的6种基本数据类型包括数字（Numbers）、字符串（Strings）、列表（Lists）、元组（Tuples）、字典（Dictionaries）和集合（Sets）。除此之外，还有一些。它们都是内置的类实例，因此可以被视为对象。

☆数值类型：

数值类型包括整数（int）、浮点数（float）、复数（complex）。

a) 整数 (int)：Python 的整数类型没有长度限制，只受内存限制。如 -5，0， 100。

b) 浮点数 (float)：如 3.14, -0.001, 2.0

c) 复数 (complex)： 形式为 a + bj，其中 a 和 b 是浮点数，j 表示虚数单位。如 3+4j， 2-1j。

☆字符串 (strings，str)：

字符串用于表示文本数据，可以包含字母、数字、符号以及其他字符，需要用单引号、双引号或三引号（半角引号）包起来。如：

单引号：

'Hello, world!'

双引号：

"Hello, world!"

三引号（用于多行字符串）：

"""This is a
multiline string.""

或

'''This is another
multiline string.'''

☆布尔类型 (bool)：

表示真或假的值，只有两个取值：True 和 False。注意写法。布尔值在条件判断和逻辑运算中非常有用。

☆列表 (list)：

有序可变序列，可以包含不同类型的元素。用方括号表示，元素之间用逗号分隔。如 ：

[1, 2, 3]

['a', 'b', 'c']

[1, 3.14, "Hello"]

可以通过索引访问和修改。

列表是可变的序列类型，用于存储一系列元素，这些元素可以是不同类型的数据。

☆元组 (tuple)：

有序不可变序列，可以包含不同类型的元素。用圆括号表示，元素之间用逗号分隔。如：

(1, 2, 3)

('x', 'y', 'z')

(2, "World", True)

元组与列表类似，但它是不可变的。一旦创建，就不能修改其元素——可以用于保护数据的完整性。

☆字典 (dict)：

键值对集合，用花括号表示。每个键值对用冒号分隔，键值对之间用逗号分隔；字典中的键必须是唯一的，而值可以是任意的数据类型。如{'name': 'John', 'age': 30}

支持通过键来访问对应的值，可以进行添加、删除和修改键值对等操作。

字典是可变的容器模型，用于存储键值对（key-value pairs）

☆集合 (set)：

无序不重复元素集，用花括号表示，元素之间用逗号分隔。如 {1, 2, 3}, {'apple', 'banana', 'cherry'}

集合（set）具有以下特点：

无序：集合中的元素没有固定的顺序，因此不能通过索引访问元素。

不包含重复元素：集合会自动去除重复的元素，确保每个元素在集合中都是唯一的。

不可变元素：集合的元素必须是不可变（可哈希hashable）类型，比如数字、字符串和元组。可变类型如列表和字典不能作为集合的元素。

此外还有

1、None 类型：

None 类型表示空值或缺少值。它只有一个取值，即None。常用于表示变量没有返回值或函数没有返回值的情况。

要注意，None 与空字符串 ""、空列表 []、空字典 {} 在逻辑上是不同的。

2、range类型

是一个不可变的序列类型。

常用于表示一个不可变的数字序列，通常用在循环中。

例如：range(5) 代表序列 [0, 1, 2, 3, 4]。

3、字节字符串（bytes）：

是一个不可变的序列，包含范围为 0 <= x < 256 的整数。

类似于字符串，但专门用于处理二进制数据。

4.字节数组（bytearray）：

是一个可变的序列，包含范围为 0 <= x < 256 的整数。

可以像处理列表一样处理字节数组，但其元素限制为 0-255 的整数，试图赋值超出这个范围的整数会引发 ValueError。

bytearray与 bytes 的对比，bytes 是不可变的字节序列，而 bytearray 是其可变版本。

5.冻结集合（frozenset）：

是不可变集合的一种变体。

一旦创建，就不能添加或删除元素。

可以用作字典的键或其他集合的元素。

这些都是 Python 的内置数据类型，可以使用内置函数type() 来检查任何对象的数据类型。type() 是 Python 中的一个内置函数，用于返回一个对象的类型。例如：

print(type(5))      # <class 'int'>

print(type("hello"))   # <class 'str'>

print(type([1, 2, 3]))   # <class 'list'>

Python的数据类型小结

1.序列类型包括：

字符串（str）：不可变序列，用于表示文本。

列表（list）：可变序列，可以包含不同类型的元素。

元组（tuple）：不可变序列，通常用于存储多个元素的组合。

range对象：不可变序列，表示一个数字范围。

【注：序列（Sequence）是指一种数据结构，用于表示一系列有序的元素，每个元素都分配了一个位置索引，通过这些索引可以访问序列中的元素。】

2.可变类型（Mutable）和不可变类型（Immutable）

可变类型是指可以在创建后改变其内容的类型。包括：

列表（list）：可以增删改元素。

字典（dict）：包含键值对，可以修改、添加和删除键值对。

集合（set）：可以增删元素，但集合本身的元素必须是不可变的。

字节数组（bytearray）：可以修改字节序列。

用户自定义的类（通常情况下）。

不可变类型是指创建后其内容不能被更改的类型。包括：

整数（int）

浮点数（float）

字符串（str）

元组（tuple）

布尔值（bool）：True 和 False。

复数（complex）：用于表示复数。

字节字符串（bytes）：不可变的字节序列。

冻结集合（frozenset）：不可变的集合。

None（NoneType）

【可变（Mutable）与不可变（Immutable）：这决定了数据类型的实例在创建后是否可以更改其内容。可变类型的内容可以更改，而不可变类型的内容一旦创建就不能更改。】

Python的这些数据类型，实际上都是内置的类实例，因此可以被视为对象（具有自己的方法和属性）。

关于数据类型更多情况可见：Python的数据类型https://blog.csdn.net/cnds123/article/details/108124459

数据类型转换

在Python中，数据类型转换是指将一种数据类型转换为另一种数据类型。Python提供了多种内置函数来实现这些转换。

存在隐式转换和显示转换两种类型的数据类型转换。隐式转换是由Python自动进行的，而显示转换是通过程序员显式调用转换函数来完成的。

隐式转换

隐式转换，也称为自动转换，是指Python在进行运算时会自动将一种数据类型转换为另一种类型，以便于运算。例如：

a = 5         # 整数

b = 2.0       # 浮点数

c = a + b     # a会被隐式转换为浮点数

print(c)      # 输出 7.0

在这个例子中，a（整数）和b（浮点数）相加时，Python会自动将a转换为浮点数，以进行运算。

显示转换

显示转换，也称为强制转换，指的是程序员显式地调用转换函数来转换数据类型。这种转换需要使用Python提供的内置函数，如int(), float(), str()等。例如：

a = "123"            # 字符串

b = int(a)          # 显示转换为整数

c = b + 5           # 进行整数运算

print(c)            # 输出 128

在这个例子中，使用int()函数将字符串"123"转换为整数。

建议：

对于简单和明显的转换，可以依赖Python的隐式转换。

对于复杂或可能引起歧义的情况，最好使用显式转换。

【隐式转换和显式转换的比较

安全性：

隐式转换可能在某些情况下导致意外结果,特别是在复杂表达式中。显式转换更安全,因为程序员明确指定了转换的意图。

可读性：

隐式转换可能使代码更简洁,但有时会降低可读性。显式转换使代码的意图更清晰,提高了可读性。】

Python提供了多种内置函数来实现不同数据类型之间的转换。以下是常见的数据类型转换函数：

1.转换为整数 (int)：

int(3.14)    # 3

int("123")   # 123

int(True)    # 1

2.转换为浮点数 (float)：

float(5)     # 5.0

float("3.14") # 3.14

float(False)  # 0.0

3.转换为字符串 (str)：

str(42)      # "42"

str(3.14)    # "3.14"

str(True)    # "True"

4.转换为布尔值 (bool)：

bool(1)      # True

bool(0)      # False

bool("hello") # True

bool("")     # False

5.转换为列表 (list)：

list("hello")  # ['h', 'e', 'l', 'l', 'o']

list((1, 2, 3)) # [1, 2, 3]

6.转换为元组 (tuple)：

tuple([1, 2, 3])  # (1, 2, 3)

tuple("hello")    # ('h', 'e', 'l', 'l', 'o')

7.转换为集合 (set)：

set([1, 2, 2, 3])  # {1, 2, 3}

set("hello")       # {'h', 'e', 'l', 'o'}

8.转换为字典 (dict)：

dict([('a', 1), ('b', 2)])  # {'a': 1, 'b': 2}

注意事项：

并非所有的转换都是可能的。例如,你不能将非数字的字符串转换为整数。

在进行转换时,要注意可能出现的数据丢失。例如,将浮点数转换为整数会丢失小数部分。

布尔值转换时,空值(如0, "", [], {})通常被视为False,非空值视为True。

运算符

Python中的运算符是用于执行各种操作的符号或组合。在Python中，运算符可分为几大类，。以下是对这些运算符的详细介绍：
1. 算术运算符
用于进行基本的数学运算。
+：加法
a = 5
b = 3
result = a + b  # 8

-：减法
a = 5
b = 3
result = a - b  # 2

*：乘法
a = 5
b = 3
result = a * b  # 15

/：除法（总是返回浮点数）
a = 5
b = 2
result = a / b  # 2.5

1/3  # 输出：0.3333333333333333
在Python中除法（/）能除尽也保留一位小数，如：
4/2  # 输出：2.0

//：整除（返回整数，向下取整）
a = 5
b = 2
result = a // b  # 2

向下取整的意思：结果是向负无穷方向舍入，如：
7 // 2  # 结果是 3
-7 // 2  # 结果是 -4，因为 -4 是不大于 -3.5 的最大整数。

%：取余（返回余数）
a = 5
b = 2
result = a % b  # 1

**：幂运算（如a**b表示a的b次幂）
a = 2
b = 3
result = a ** b  # 8

问，print(6 + 8/2)的输出结果为何是10.0？
在这个表达式中，除法（/）的优先级高于加法（+）。/ 运算符执行浮点除法，即使操作数都是整数。
8/2 = 4.0 （注意结果是浮点数）。然后进行加法：6 + 4.0。当整数（6）和浮点数（4.0）相加时，Python 会自动将结果转换为浮点数。
6 + 4.0 = 10.0。最终print() 函数输出 10.0

2. 关系（比较）运算符
用于比较两个值的运算符。
==：等于，例如：
a = 5
b = 3
result = a == b  # False
提示
print(10 == 10.0)  # 结果是True，整数 10 和浮点数 10.0 的值实际上是相同的。Python会将它们转换为相同的类型进行比较，结果是 True。
print(0 == False)  # 结果是True，Python中，False 其实等价于整数 0。所以，当你比较 0 与 False 时，它们也是相等的

!=：不等于，例如：
a = 5
b = 3
result = a != b  # True

>：大于，例如：
a = 5
b = 3
result = a > b  # True

<：小于，例如：
a = 5
b = 3
result = a < b  # False

>=：大于等于，例如：
a = 5
b = 3
result = a >= b  # True

<=：小于等于，例如：
a = 5
b = 3
result = a <= b  # False

3. 逻辑运算符
用于逻辑运算，通常用于条件判断。
and：与，返回两个表达式都是 True 时的值，例如:
a = True
b = False
result = a and b  # False

or：或，返回两个表达式有一个为 True 时的值，例如:
a = True
b = False
result = a or b  # True

not：非，返回布尔表达式的反转值，例如:
a = True
result = not a  # False

Python中的逻辑运算符 and 和 or 是惰性求值（也称为短路求值）的。这意味着这些运算符在可能的情况下会避免执行不必要的计算。and 和 or 运算符不仅仅返回布尔值（True 或 False），它们实际上返回操作数之一。
对于 and 运算符：
如果第一个操作数为假（在布尔上下文中评估为False），返回第一个操作数。
否则，返回第二个操作数。
对于 or 运算符：
如果第一个操作数为真（在布尔上下文中评估为True），返回第一个操作数。
否则，返回第二个操作数。
例如：
print(12 and 10) 结果是10
print(10 and 12) 结果是12
print(12 or 10) 结果是12
print(10 or 12) 结果是10

4. 位运算符
用于操作二进制位。
&：按位与，例如：
a = 5  # 0101
b = 3  # 0011
result = a & b  # 0001，即 1

|：按位或，例如：
a = 5  # 0101
b = 3  # 0011
result = a | b  # 0111，即 7

^：按位异或，例如：
a = 5  # 0101
b = 3  # 0011
result = a ^ b  # 0110，即 6

~：按位取反，例如：
a = 5  # 0101
result = ~a  # 1010（在二进制补码表示中为 -6）

<<：左移，例如：
a = 5  # 0101
result = a << 1  # 1010，即 10

>>：右移，例如：
a = 5  # 0101
result = a >> 1  # 0010，即 2

5. 赋值运算符
用于给变量赋值的运算符。
= : 赋值，例如：
a = 5

+= : 加并赋值，例如：
a = 5
a += 3  # a = a + 3，即 a = 8

-= : 减并赋值，例如：
a = 5
a -= 3  # a = a - 3，即 a = 2

*= : 乘并赋值，例如：
a = 5
a *= 3  # a = a * 3，即 a = 15

/= : 除并赋值，例如：
a = 5
a /= 2  # a = a / 2，即 a = 2.5

//= : 整除并赋值，例如：
a = 5
a //= 2  # a = a // 2，即 a = 2

%= : 取余并赋值，例如：
a = 5
a %= 2  # a = a % 2，即 a = 1

**= : 幂并赋值，例如：
a = 2
a **= 3  # a = a ** 3，即 a = 8

6. 身份运算符
用于比较两个对象是否相同。
is：判断两个对象是否是同一个对象，例如：
a = [1, 2, 3]
b = a
result = a is b  # True

is not：判断两个对象是否不是同一个对象，例如：
a = [1, 2, 3]
b = [1, 2, 3]
result = a is not b  # True
说明：is 运算符比较的是对象的身份（identity）实际是比较内存地址，而不是值。它检查两个变量是否指向内存中的同一个对象。因为 a 和 b 是两个独立创建的列表对象，尽管它们的内容相同，但它们在内存中是不同的对象。所以 a is not b 返回 True。
a = [1, 2, 3]
b = [1, 2, 3]
result = a == b  # True
说明：使用 == 比较两个列表的内容是否相同。

7. 成员运算符
用于测试一个值是否在序列中。
in：判断元素是否在序列中，例如：
a = 5
b = [1, 2, 3, 4, 5]
result = a in b  # True

not in：判断元素是否不在序列中，例如：
a = 5
b = [1, 2, 3, 4]
result = a not in b  # True

运算符的优先级和结合性

运算符优先级决定了复杂表达式中运算符的执行顺序。高优先级的运算符会在低优先级的运算符之前执行。例如：

result = 2 + 3 * 4

在这个表达式中，乘法(*)的优先级高于加法(+)，所以先执行3 * 4，然后再加2。结果是14，而不是20。

运算符结合性：

结合性定义了相同优先级的运算符在表达式中的执行顺序，可以是从左到右（左结合）或从右到左（右结合）。

左结合：大多数运算符都是左结合的，如加法、减法、乘法、除法等。

例如：a - b - c 等价于 (a - b) - c

右结合：少数运算符是右结合的，最常见的是指数运算符(**)。

例如：2 ** 3 ** 2 等价于 2 ** (3 ** 2)，结果是512，而不是64。

提示，在编写复杂表达式时，使用括号来明确表示运算顺序通常是一个好习惯。这不仅可以避免错误，还能使代码更容易理解。

Python 运算符优先级和结合性表
运算符说明	Python运算符	优先级	结合性
小括号	( )	19	无
索引运算符	x[i] 或 x[i1: i2 [:i3]]	18	左
属性访问	x.attribute	17	左
乘方（幂）	**	16	左
按位取反	~	15	右
符号运算符	+（正号）、-（负号）	14	右
乘除	*、/、//、%	13	左
加减	+、-	12	左
位移	>>、<<	11	左
按位与	&	10	左
按位异或	^	9	左
按位或	|	8	左
比较运算符	==、!=、>、>=、<、<=	7	左
is 运算符	is、is not	6	左
in 运算符	in、not in	5	左
逻辑非	not	4	右
逻辑与	and	3	左
逻辑或	or	2	左
逗号运算符	exp1, exp2	1	左

说明：优先级数大的优先级高。

python运算符优先级官方文档

英文https://docs.python.org/3/reference/expressions.html#operator-precedence)

中文https://docs.python.org/zh-cn/3/reference/expressions.html#operator-precedence