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