Python 入门 —— 基本数据结构

Python 入门 —— 基本数据结构

基本数据类型

变量值的是存储在内存中的，解释器会根据变量的数据类型来分配内存空间，不同类型的数据具有不同的存储方式。基本数据类型主要包括三类：

• 数字：整数、浮点数、复数
• 文本：字符或字符串
• 逻辑值

Python 中的基本数据类型包括 6 种，使用 type 函数返回变量的类型，使用 isinstance 函数来判断变量的类型，

• 整型（int）

a = 1000
type(a)
# int
int(1.0)
# 1
isinstance(int(1.0), int)  # 类型转换
# True

• 浮点型（float）

a = 2.5
type(a)
# float
float('-Inf')  # 负无穷大
# -inf
float('Inf') > 10**10
# True

• 复数（complex）

a = 1 + 2j
b = 3 - 4j
c = a * b
# (11+2j)
isinstance(c, complex)
# True

• 逻辑型（bool）

0 == 0.0
# True
bool('0')
# True
bool(0)
# False

• 字符串（str）

  Python 中字符串可以用单引号和双引号包裹来创建，两种方式创建的字符串没有任何区别，还可以使用三个单引号或双引号来创建字符串，三重引号的字符串可以跨越多行，其所有的空白字符都将包含在该字符串字面值当中，通常用于文档注释。

a = 'abc'
b = "ABC"
c = """matrix:
    1 2 3
    4 5 6
    7 8 9"""
a == "abc"
# True
a == b
# False
print(c)
# matrix:
#     1 2 3
#     4 5 6
#     7 8 9

字符串中某些字符具有特殊含义的，例如 '\n' 表示换行，Python 中还有一种用 r/R'' 开头的原始字符串，所有字符都按字面意思使用，不会转义，但是返回的是默认的转义模式字符串。例如 '\n' 变成了 '\\n'，在正则表达式中比较常用

r'abd\n\t'
# 'abd\\n\\t'

• 二进制类型（bytes）

# 使用构造函数创建，并指定编码方式
bytes('中国，你好', encoding='utf-8')
# b'\xe4\xb8\xad\xe5\x9b\xbd\xef\xbc\x8c\xe4\xbd\xa0\xe5\xa5\xbd'

# 使用字符串创建，只能使用 ASCII 字符
b'bcdha'
# b'bcdha'

空对象（None）

Python 中的空对象使用 None 表示，是一个 NoneType 对象，对于无返回值的函数会默认返回一个 None，记住空对象不等于空值

a = None
type(a)
# NoneType
def func():
    print("test")
a = func()
type(a)
# NoneType
a == ''
# False
a == None
# True
a is None
# True

序列结构

所谓序列，便是依次按顺序排列的多个对象构成的结构，相邻对象之间是前驱和后继的关系。栈和队列都可以看成是序列数据结构。

Python 中对应的是 list（列表）和 tuple（元组）

list

创建列表

Python 列表的创建可以使用中括号，或者使用 list 关键字强制转换，列表是一种可以容纳任意类型数据的可变容器，且不会对数据类型进行强制转换。例如

a = [1, 3, 4, 6]
b = ["a", "b", "c"]
c = list('abcd')
# ['a', 'b', 'c', 'd']
list(range(1, 10))  # 类似于 R 中的 seq，返回的是迭代器，需要使用 list 转换
# [1, 2, 3, 4, 5, 6, 7, 8, 9]
d = [1, 3, "A", "abc", a]
[1] * 4  # 元素重复
# [1, 1, 1, 1]
# 创建空列表
alist = []
blist = list()

列表索引

Python 中所有索引都是从 0 开始的，逆向索引（从后往前）是从 -1 开始

mlist = ['red', 'green', 'blue', 'white', 'black', 'orange', 'pink']
mlist[0]
# 'red'
mlist[-1]
# 'pink'

索引切片，在中括号中使用冒号分隔，形如 [start:stop:step]，三个值都可以缺省，相当于 slice 函数，但是该函数不支持关键字参数。切片索引是半开区间，即包含 start 索引出的值，但是不包含 stop 索引处的值。

mlist[0:4]  # 从 0 开始也可以省略 0，相当于 mlist[:4]，表示从第一个元素到 stop 前一个元素
# ['red', 'green', 'blue', 'white']
mlist[slice(0, 4)]
# ['red', 'green', 'blue', 'white']
mlist[1:-2]
# ['green', 'blue', 'white', 'black']

省略 stop，表示从 start 到最后一个元素。如果 slice 函数值设置一个参数，表示的是 stop 位置的索引

mlist[3:]
# ['white', 'black', 'orange', 'pink']
mlist[slice(3)]
# ['red', 'green', 'blue']
mlist[1::2]
# ['green', 'white', 'orange']

省略 start 和 stop，表示列表的一份拷贝

mlist[:]  # 或者 mlist[::]
# ['red', 'green', 'blue', 'white', 'black', 'orange', 'pink']
mlist[::2]
# ['red', 'blue', 'black', 'pink']

设置步长

# 逆序
mlist[::-1]
# ['pink', 'orange', 'black', 'white', 'blue', 'green', 'red']
mlist[2:6:2]
# ['blue', 'black']
mlist[slice(2, 6, 2)]
# ['blue', 'black']
# 如果 start > stop，返回空列表，需要再设置 step 为负值
mlist[3:1]
# []
mlist[3:1:-1]
# ['white', 'blue']
mlist[-1:-4:-1]
# ['pink', 'orange', 'black']

修改列表

同 R 类似，也可以根据索引来修改值，如果是范围索引，则该范围内的值会被替换为设置的列表。如果设置标量值，则会引发异常

mlist[2] = 'yellow'
mlist
# ['red', 'green', 'yellow', 'white', 'black', 'orange', 'pink']
mlist[2:5] = 'yellow'  # 字符串会转换为列表
mlist
# ['red', 'green', 'y', 'e', 'l', 'l', 'o', 'w', 'orange', 'pink']
mlist[2:5] = [0]
mlist
# ['red', 'green', 0, 'l', 'o', 'w', 'orange', 'pink']

添加元素，可以使用 append 往末尾添加，insert 往指定位置添加

mlist = ['red', 'green', 'blue', 'white', 'black', 'orange', 'pink']
# 末尾添加
mlist.append('yellow')
# 首位置添加
mlist.insert(0, 1)
mlist
# [1, 'red', 'green', 'blue', 'white', 'black', 'orange', 'pink', 'yellow']

合并两个列表

list1 = [1, 3, 5]
list2 = ['a', 'b', 'c']
list1 + list2
# [1, 3, 5, 'a', 'b', 'c']
list1.extend(list2)
list1
# [1, 3, 5, 'a', 'b', 'c']

删除元素

del mlist[0]
mlist
# ['red', 'green', 'blue', 'white', 'black', 'orange', 'pink', 'yellow']
del mlist[3:5]
mlist
['red', 'green', 'blue', 'orange', 'pink', 'yellow']

列表方法

• 自带方法

函数	描述
append(object)	在列表的末尾添加元素
clear()	情况列表中的元素
copy()	返回列表的浅拷贝
count(value)	统计列表中某一元素出现的次数
extend(iterable)	合并另一个列表
index(value, start, stop)	返回指定元素第一次出现的索引，元素不存在会抛出异常
insert(index, object)	在指定位置插入元素
pop(index=-1)	删除并返回指定索引处的元素，如果列表为空或索引超出范围会抛出异常
remove(value)	删除首次出现的指定值，值不存在会抛出异常
reverse()	将列表逆序
sort(*, key=None, reverse=False)	排序

• 内置函数

函数	描述
len(obj)	计算列表的长度
max(iterable, *[, default=obj, key=func])	计算列表中的最大值，必须是同类型的值
max(arg1, arg2, *args, *[, key=func])
min(max(iterable, *[, default=obj, key=func]))	计算列表中的最小值，必须是同类型的值
min(arg1, arg2, *args, *[, key=func])
sum(iterable, /, start=0)	计算列表的和，必须是同类型的值

• 成员判断

a = [1, 3, 9, 6, 0, 5]
3 in a
# True
3 not in a
# False

tuple

元组与列表非常相似，唯一的不同之处在于元组是不可变的，任何对元组的修改操作都会引发异常，元组使用小括号创建而不是中括号。

a = (1, 2, 3)
a[1] = 2  # 修改元组会引发异常
# ---------------------------------------------------------------------------
# TypeError                                 Traceback (most recent call last)
# <ipython-input-198-94c4449d0396> in <module>
# ----> 1 a[1] = 2
# 
# TypeError: 'tuple' object does not support item assignment

b = ('a', 'e', 'i', 'o', 'u')
b[1:4]
# ('e', 'i', 'o')
# 定义空元组
c = ()
c = tuple()

元组的自带方法只有两个：count 和 index，功能同 list。

创建单元素元组，需要在元素后面添加一个逗号 ,，否则小括号会被当做运算符

a = (1)
type(a)
# int
a = (1, )
type(a)
# tuple

虽然元组是不可变的，但是与列表类似，其可以包含任意类型的元素，如果元组中包含可变的列表，那能不能修改这个元组呢？

student = ('Tom', 22, 'male', ['English', 'Biology'])
student[-1].append('Chinese')
student
# ('Tom', 22, 'male', ['English', 'Biology', 'Chinese'])
del student[-1][0]
student
# ('Tom', 22, 'male', ['Biology', 'Chinese'])
del student[-1]
# ---------------------------------------------------------------------------
# TypeError                                 Traceback (most recent call last)
# <ipython-input-245-56f3c072cb13> in <module>
# ----> 1 del student[-1]
# 
# TypeError: 'tuple' object doesn't support item deletion
student[-1].clear()
student
# ('Tom', 22, 'male', [])

虽然可以修改元组中的列表，但是不能删除该列表，可以将列表清空。

range

range 类型表示的是不可变的数字序列，主要用在 for 循环中

# range(stop)：单个参数表示从 0 到 (stop-1) 
list(range(10))
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# range(start, stop[, step])
list(range(1, 11))
# [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
list(range(0, 30, 5))
# [0, 5, 10, 15, 20, 25]
list(range(0, -10, -1))
# [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
list(range(1, 0))
# []

range 的优势在于总是占用固定数量（较小）的内存，不论其表示的范围多大，会存储 start, stop 和 step 的值，并在需要的时候计算相应的值

r = range(0, 10, 2)
r
# range(0, 10, 2)
5 in r
# False
2 in r
# True
r[2]
# 4
r[2:]
# range(4, 10, 2)
r.index(4)
# 2
r.count(5)
# 0

str

str 也属于不可变序列类型，除了包含与元组类似的方法之外，还有许多字符串处理方法，详细内容将会在后面的章节中介绍。

迭代与解析

for i in [1, 3, 6, 9]:
    print(i, end=' ')
# 1 3 6 9
# enumerate 函数可以同时返回列表的索引及其对应的元素
for i, e in enumerate([1, 3, 6, 9]):
    print(i, e