python 基础

数据类型

Python 数据类型

Python 是一种动态类型语言，数据类型分为基本类型和复合类型，所有说明基于 Python 3 标准。

1. 基本数据类型

基本类型表示单一值，常用于存储简单数据。

• 整数 (int)：表示整数值，如 x = 5。支持算术操作（加、减等）。

• 二进制数只使用数字0、1表示，在Python中，二进制整数使用前缀0b表示，比如：0b0110，0b1100。

• 十六进制数除了0~9十个数字以外，还使用a、b、c、d、e、f，在Python中，十六进制使用前缀0x，比如：0x12ef，0xde2431af。

• 浮点数 (float)：表示小数或科学计数法值，如 y = 3.14 或 z = 2.5 \\times 10\^3。注意精度问题。

• 浮点数可以用数学写法，如1.23，3.14，-9.01。但是对于很大或很小的浮点数，就必须用科学计数法表示，在Python中，把10用e替代，比如：1.23x10^9就是1.23e9，或者12.3e8，0.000012可以写成1.2e-5。

• 布尔值 (bool) ：只有两个值，True 或 False，常用于逻辑判断。

• 字符串 (str) ：表示文本序列，如 s = "hello"。使用单引号或双引号定义。

• 空值 (NoneType) ：特殊类型 None，表示无值或缺失数据。

# 基本类型示例
a = 10  # int 类型
b = 3.14  # float 类型
c = True  # bool 类型
d = "Python"  # str 类型
e = None  # NoneType 类型

print(type(a))  # 输出: <class 'int'>
print(type(b))  # 输出: <class 'float'>
print(type(c))  # 输出: <class 'bool'>
print(type(d))  # 输出: <class 'str'>
print(type(e))  # 输出: <class 'NoneType'>

2. 复合数据类型

复合类型用于存储多个值，支持更复杂的数据结构。

• 列表 (list) ：有序、可变的序列，允许重复元素，如 [1, "a", True]。索引从 0 开始。
• 元组 (tuple) ：有序、不可变的序列，一旦创建不能修改，如 (1, 2, 3)。常用于固定数据。
• 字典 (dict) ：键值对集合，键唯一，值可重复，如 {"name": "Alice", "age": 30}。支持快速查找。
• 集合 (set) ：无序、不重复元素的集合，如 {1, 2, 3}。常用于去重或数学运算（如并集、交集）。

# 复合类型示例
f = [1, 2, 3]  # list 类型
g = ("apple", "banana")  # tuple 类型
h = {"name": "Bob", "score": 95}  # dict 类型
i = {1, 2, 2, 3}  # set 类型（自动去重）

print(type(f))  # 输出: <class 'list'>
print(type(g))  # 输出: <class 'tuple'>
print(type(h))  # 输出: <class 'dict'>
print(type(i))  # 输出: <class 'set'>
print(i)  # 输出: {1, 2, 3}（重复元素被移除）

3. 其他重要类型

Python 还提供一些高级或内置类型：

• 字节 (bytes) ：表示二进制数据，如 b"hello"。
• 字节数组 (bytearray)：可变的字节序列。
• 范围 (range) ：生成整数序列，常用于循环，如 range(0, 10)。
• 自定义类型 ：通过类 (class) 定义，支持面向对象编程。

# 其他类型示例
j = b"data"  # bytes 类型
k = bytearray(b"changeable")  # bytearray 类型
l = range(5)  # range 类型

print(type(j))  # 输出: <class 'bytes'>
print(type(k))  # 输出: <class 'bytearray'>
print(type(l))  # 输出: <class 'range'>
print(list(l))  # 输出: [0, 1, 2, 3, 4]（转换为列表）

4. 类型检查与转换

Python 支持动态类型检查：

• 使用 type() 函数获取变量类型。
• 使用内置函数转换类型，如 int(), float(), str(), list()。
• 注意：转换失败会引发错误（如 int("abc") 会报 ValueError）。

# 类型转换示例
num_str = "123"
num_int = int(num_str)  # 字符串转整数
num_float = float(num_int)  # 整数转浮点数
str_from_int = str(num_float)  # 浮点数转字符串

print(type(num_str))  # <class 'str'>
print(type(num_int))  # <class 'int'>
print(num_float)  # 输出: 123.0

Python的整数与浮点数

地板除

Python除了普通除法以外，还有一个特殊的除法被称为地板除，对于地板除，得到的结果会忽略纯小数的部分，得到整数的部分，地板除使用//进行。

10//4 # ==> 2
10//2.5 # ==> 4.0
10//3 # ==> 3

小数点位数

使用Python计算小数的时候，经常需要保留小数点后若干位，可以使用round()函数来处理，这里先了解round的调用方式，使用两个参数，第一个是需要保留小数点位数的数值，第二个是保留的位数。

num = 10 / 3
print(num) # ==> 3.3333333333333335
# 使用round保留两位小数
round(num, 2) # ==> 3.33

Python的布尔类型

前面我们了解到，布尔类型是Python的基础数据类型，布尔类型只有True和False两种值，本节课我们学习布尔类型的集中运算。

与运算

只有两个布尔值都为 True 时，计算结果才为 True。

True and True # ==> True
True and False # ==> False
False and True # ==> False
False and False # ==> False

或运算

只要有一个布尔值为 True，计算结果就是 True。

True or True # ==> True
True or False # ==> True
False or True # ==> True
False or False # ==> False

非运算

把True变为False，或者把False变为True：

not True # ==> False
not False # ==> True

这些运算有什么用呢？计算机程序是由无数的逻辑分支组成的，通过布尔运算，可以在计算机中实现条件判断，根据计算结果为True或者False，计算机可以自动执行不同的后续代码，因此学习布尔运算也是非常有必要的。

在Python中，布尔类型还可以与其他数据类型（字符串，数字等）做 and、or和not运算，请看下面的代码：

a = True
print(a and 0 or 99) # ==> 99

得到的计算结果不是布尔类型，而是数字99，这是为什么呢？

因为Python把0、空字符串和None看成False，其他数值和非空字符串都看成True，所以：

True and 0计算结果是0

继续计算0 or 99计算结果是 99

因此，结果是99。

需要注意的是，not计算的优先级是高于and和or的。

True and not False # ==> True

在上述布尔计算中，先计算not False = True，然后再计算True and True，因此得到True的结果。

短路计算

1. 在计算a and b时，如果 a 是 False，则根据与运算法则，整个结果必定为 False，因此返回 a；如果 a 是 True，则整个计算结果必定取决与 b，因此返回 b。
2. 在计算a or b时，如果 a 是 True，则根据或运算法则，整个计算结果必定为 True，因此返回 a；如果 a 是 False，则整个计算结果必定取决于 b，因此返回 b。

所以Python解释器在做布尔运算时，只要能提前确定计算结果，它就不会往后算了，直接返回结果。

Python的字符串

字符串可以用' '或者" "括起来表示。

如果字符串本身包含'怎么办？比如我们要表示字符串 I'm OK ，这时，可以用" "括起来表示：

"I'm OK"

类似的，如果字符串包含"，我们就可以用' '括起来表示：

'Learn "Python" in imooc'

但是，如果字符串既包含'又包含"怎么办？

这个时候，就需要对字符串中的某些特殊字符进行"转义"，Python字符串用\进行转义。

要表示字符串Bob said "I'm OK"

由于'和"会引起歧义，因此，我们在它前面插入一个\表示这是一个普通字符，不代表字符串的起始，因此，这个字符串又可以表示为

'Bob said \"I\'m OK\".'

注意：转义字符 \不计入字符串的内容中。

常用的转义字符还有：

\n表示换行
\t 表示一个制表符
\\表示 \ 字符本身

Python中raw字符串与多行字符串

如果一个字符串包含很多需要转义的字符，对每一个字符都进行转义会很麻烦。为了避免这种情况，我们可以在字符串前面加个前缀r，表示这是一个 raw 字符串，里面的字符就不需要转义了。例如：

r'\(~_~)/ \(~_~)/'

但是r'...'表示法不能表示多行字符串，也不能表示包含'和 "的字符串。

如果要表示多行字符串，可以用'''...'''表示：

'''Line 1
Line 2
Line 3'''

上面这个字符串的表示方法和下面的是完全一样的：

'Line 1\nLine 2\nLine 3'

还可以在多行字符串前面添加r，把这个多行字符串也变成一个raw字符串：

r'''Python is created by "Guido".
It is free and easy to learn.
Let's start learn Python in imooc!'''

Python的字符串format

有时候通过字符串输出的内容不是固定的，这个时候需要使用format来处理字符串，输出不固定的内容。

字符串format由两个部分组成，字符串模板和模板数据内容组成，通过大括号{}，就可以把模板数据内容嵌到字符串模板对应的位置。

# 字符串模板
template = 'Hello {}'
# 模板数据内容
world = 'World'
result = template.format(world)
print(result) # ==> Hello World

如果模板中{}比较多，则容易错乱，那么在format的时候也可以指定模板数据内容的顺序。

# 指定顺序
template = 'Hello {0}, Hello {1}, Hello {2}, Hello {3}.'
result = template.format('World', 'China', 'Beijing', 'imooc')
print(result) # ==> Hello World, Hello China, Hello Beijing, Hello imooc.
# 调整顺序
template = 'Hello {3}, Hello {2}, Hello {1}, Hello {0}.'
result = template.format('World', 'China', 'Beijing', 'imooc')
print(result) # ==> Hello imooc, Hello Beijing, Hello China, Hello World.

除了使用顺序，还可以指定对应的名字，使得在format过程更加清晰。

# 指定{}的名字w,c,b,i
template = 'Hello {w}, Hello {c}, Hello {b}, Hello {i}.'
world = 'World'
china = 'China'
beijing = 'Beijing'
imooc = 'imooc'
# 指定名字对应的模板数据内容
result = template.format(w = world, c = china, b = beijing, i = imooc)
print(result) # ==> Hello World, Hello China, Hello Beijing, Hello imooc.

Python的字符串切片

符串由一个个字符组成，每一个字符都有一个唯一的位置。比如字符串'ABC'，第一个字符是A，第二个字符是B，第三个字符是C。

因此我们可以使用位置的方式取出字符串中特定位置的字符，按照位置取字符串的方式使用中括号[]访问，这个时候可以把字符串看作是一个列表（一种新的数据类型，在后面会继续学习），不过需要注意的是，在程序的世界中，计数是从 0开始的，使用 0来表示第一个。

s = 'ABC'
a = s[0] # 第一个
b = s[1] # 第二个
c = s[2] # 第三个
print(a) # ==> A
print(b) # ==> B
print(c) # ==> C

有时候，我们会想获取字符串的一部分（子串），这个时候我们采取切片的方式获取，切片需要在中括号[]中填入两个数字，中间用冒号分开，表示子串的开始位置和结束位置，并且这是半闭半开区间，不包括最后的位置。

ab = s[0:2] # 取字符串s中的第一个字符到第三个字符，不包括第三个字符
print(ab) # ==> AB

我们定义一个更长的字符串，了解切片更多的细节。

s = 'ABCDEFGHIJK'
abcd = s[0:4] # 取字符串s中的第一个字符到第五个字符，不包括第五个字符
print(abcd) # ==> ABCD
cdef = s[2:6] # 取字符串s中的第三个字符到第七个字符，不包括第七个字符
print(cdef) # ==> CDEF

1