python常用的数据结构

2.5 在线实验-数据结构
1、练习Python内置的数据结构（元组，列表，集合和字典）；
2、练习扩展的数据结构（多维ndarray，Series和DataFrame）。
跳过此步
1、掌握Python内置数据结构
1.1 赋值生成列表
在IDLE里，输入代码：la=[1,2,3,4]
la
拷贝代码la = [1,2,3,4]
la

输出是[1, 2, 3, 4]。通过中括号赋值的方式，可以生成一个列表。这是最常用的列表生成方式。
1.2 强制转换为列表
在IDLE中，输入代码：lb=list(“Hello”)
lb
拷贝代码lb=list(“Hello”)
lb

输出是[‘H’, ‘e’, ‘l’, ‘l’, ‘o’]。list()返回一个空的列表，等价于空的[]赋值。list(iterable)可以对其中可迭代对象进行强制类型转换。str本身就是一个可迭代对象。
1.3 推导式生成列表
在IDLE中，输入代码：
s=“abc123def456end”
lc = [c for c in s if c.isdigit()]
lc
拷贝代码s=“abc123def456end”
lc = [c for c in s if c.isdigit()]
lc

输出是[‘1’, ‘2’, ‘3’, ‘4’, ‘5’, ‘6’]。列表的推导式是一个很强大很方便的工具，可以从一个序列构建出另外一个新的满足特定条件的序列。相当于在中括号内通过增加一条混合语句，就能完成一定的功能。
1.4 修改列表元素
在IDLE中，输入代码：s=list(“hello”)
s[0]=“H”
s
拷贝代码s=list(“hello”)
s[0]=“H”
s

输出是[‘H’, ‘e’, ‘l’, ‘l’, ‘o’]。字符串“hello”被list()函数强制转换成列表后，其第0个位置为“h”，对其重新赋值“H”，修改正确。对比str是只读的，无法通过赋值的方式来修改其元素。
1.5 列表切片
在IDLE中，输入type(True)
拷贝代码type(True)

输出是<class “bool”>。说明True是一种bool的类。请尝试False。
1.6 为列表增加元素
在IDLE中，输入：
s=list(“hello”)
s.append(“world”)
print(s)
拷贝代码s=list(“hello”)
s.append(“world”)
print(s)

输出是[‘h’, ‘e’, ‘l’, ‘l’, ‘o’, ‘world’]。说明列表的append()方法用于将参数表示的数据作为一个独立数据项增加的原有列表的后面。注意区分append方法和extend方法。如对于s=list(“hello”), s.append(list(“world”))和s.extend(list(“world”))的结果是不一样的。
1.7 列表元素排序
在IDLE中，输入：
ls=[3,2,6,4]
ls.sort()
ls
拷贝代码ls=[3,2,6,4]
ls.sort()
ls

结果输出：[2, 3, 4, 6]。Sort方法默认是按升序排列，如果需要降序排列，需要使用reverse参数，设置 revers =True即可：ls.sort(reverse = True)。
1.8 比较列表和字符串的内存分配
DLE中输入：
s1=“abc”
s2=“abc”
id(s1) ==id(s2)
ls1=list(“abc”)
ls2=list(“abc”)
id(ls1) == id(ls2)
拷贝代码s1=“abc”
s2=“abc”
id(s1) ==id(s2)
ls1=list(“abc”)
ls2=list(“abc”)
id(ls1) == id(ls2)

输出结果分别为True和False。Id函数为python提供的查看对象内存地址的函数。根据这个函数返回的数值可以判定两个对象是否指向同一个内存空间。字符串为不变类型，相同值指向同一内存空间。列表为可变类型，即使初始值相同，Python也需要额外分配内存空间。
1.9 元组的赋值生成
在IDLE中输入代码：
d1=(2,3)
d2=(2)
type(d1)
type(d2)
拷贝代码d1=(2,3)
d2=(2)
type(d1)
type(d2)

输出结果：<class ‘tuple’>和<class ‘int’>。元组采用逗号分割和圆括号包裹起来进行赋值。用type函数可以查看产生的对象类型。d1是一个tuple类型，而d2显示是一个int类型。当圆括号只有一个类型时，Python无法判断用户到底是要设置一个tuple还是一个int类型。因此，若需要在赋值时产生一个元组类型，需要增加个逗号分隔符。
1.10 元组的强制转换
在IDLE中输入代码：
tuple(“Hello”)
拷贝代码tuple(“Hello”)

输出结果：(‘H’, ‘e’, ‘l’, ‘l’, ‘o’)。tuple函数可以把一个可迭代对象强制转换成元组类型。
1.11 元组元素不可修改
在IDLE中输入代码：
t=tuple(“hello”)
t[0]=“H”
拷贝代码t=tuple(“hello”)
t[0]=“H”

输出结果：
Traceback (most recent call last):
File “<pyshell#31>”, line 1, in
t[0]=“H”
TypeError: ‘tuple’ object does not support item assignment
元组是只读的，无法对其中的元素进行修改。
1.12 元组用于循环
在IDLE中输入代码：
for (x,y) in ((1,2),(1,3),(1,4)):
print(y,end="")
拷贝代码for (x,y) in ((1,2),(1,3),(1,4)):
print(y,end="")

输出结果：234。在嵌套的元组中，对其中的每一项元素（又是元组），相当于一个二维坐标，进行循环打印。打印时只打印出y坐标，并用end=“”来取代print方法默认的回车换行。
1.13 多变量同步赋值
在IDLE中输入：
name,age,gender=“David”,12,“M”
print(name+str(age)+gender)
拷贝代码name,age,gender=“David”,12,“M”
print(name+str(age)+gender)

输出结果：David12M。元组在多变量同步赋值方面给用户提供了巨大的便利。在基本的输入输出中，可以使用类似的代码来完成快速数据输入，如：name,age,gender=eval(input(“请输入数据，以逗号分隔：”))。用户可以直接输入：“David”,12,"M"来同时完成多个变量的赋值。
1.14 集合的赋值生成
在IDLE中输入：
s = {3,“3”,3.0,3}
s
拷贝代码s = {3,“3”,3.0,3}
s

结果输出：{3, ‘3’}。集合中的元素不能重复，所以两个3会只保留一个，这里能看出来Python集合中，3.0和3是按相同元素处理的。
1.15 集合的强制类型转换
在IDLE中输入：
s = set(“Hello”)
s
拷贝代码s = set(“Hello”)
s

结果输出：{‘e’, ‘H’, ‘l’, ‘o’}。集合中的元素不能重复，所以两个“l”会只保留一个。而集合是无序的，其输出顺序可以与输入顺序不一致。
1.16 创建一个空集合
在IDLE中输入代码：
s1={}
s2=set()
type(s1)
type(s2)
拷贝代码s1={}
s2=set()
type(s1)
type(s2)

输出结果：
<class ‘dict’>和<class ‘set’>。如果要生成一个空的集合，不能像列表和元组那样，因为空的大括号被Python用于生成一个空的字典。因此，如果需要生成一个空的集合，需要使用set()函数。
1.17 集合元素的增加和删除
在IDLE中输入代码：
s= set(“Hello”)
s.add(“World”)
print(s)
s.update(“China”)
print(s)
s.remove(“o”)
print(s)
拷贝代码s= set(“Hello”)
s.add(“World”)
print(s)
s.update(“China”)
print(s)
s.remove(“o”)
print(s)

输出结果：{‘e’, ‘o’, ‘l’, ‘World’, ‘h’},{‘e’, ‘o’, ‘n’, ‘a’, ‘l’, ‘World’, ‘i’, ‘C’, ‘h’},{‘e’, ‘n’, ‘a’, ‘l’, ‘World’, ‘i’, ‘C’, ‘h’}。注意：由于集合输出的无序性，实际输出时集合元素的数量可能和这个顺序不同。集合的add方法将元素作为一个整体加入集合，而update方法则将参数作为一个集合加入原集合，加入时会去掉重复元素。
检测条件：{‘e’, ‘o’, ‘l’, ‘World’, ‘h’}
{‘e’, ‘o’, ‘n’, ‘a’, ‘l’, ‘World’, ‘i’, ‘C’, ‘h’}
{‘e’, ‘n’, ‘a’, ‘l’, ‘World’, ‘i’, ‘C’, ‘h’}。注：集合中元素顺序可能不同。
1.18 赋值创建字典
在IDLE中输入代码：
d={“name”:“David”,“age”:12,“name”:“Diego”}
print(d)
拷贝代码d={“name”:“David”,“age”:12,“name”:“Diego”}
print(d)

输出结果：{‘name’: ‘Diego’, ‘age’: 12}，赋值生成字典时，键不能重名，若重名，则其值取最后的赋值。另外注意，键可以是字符串，也可以是整型浮点型，元组等这些不可变类型。而列表和字典本身都是可变的，因此不能作为键。
1.19 判断对象是否可哈希
在IDLE中输入代码：
hash(“hello”)
hash(33)
hash(22.3)
hash(tuple(“hello”))
hash(list(“hello”))
hash(set(“hello”))
拷贝代码hash(“hello”)
hash(33)
hash(22.3)
hash(tuple(“hello”))
hash(list(“hello”))
hash(set(“hello”))

输出结果：215960377
33
1503241852
546920794
ypeError: unhashable type: ‘list’
TypeError: unhashable type: ‘set’
键必须是可哈希的（即不可变的），可变类型对象如列表和字典不可哈希，所以不能作为字典的键。因此，诸如{1:2,”2”:2,3.0:3,(4,5):6}是正确的字典。而{[1,2]:3,{3,4}:5,{1:2,3:4}:6}是错误的字典定义。
1.20 列表式生成词典
在IDLE中输入代码：
students={“David”:50,“Diego”:98,“Sunny”:80}
gt={name:score for name,score in students.items() if score >60}
print(gt)
拷贝代码students={“David”:50,“Diego”:98,“Sunny”:80}
gt={name:score for name,score in students.items() if score >60}
print(gt)

输出结果：{‘Diego’: 98, ‘Sunny’: 80}。词典的items()方法返回一个序列，里面是元组构成的。对其中的每个元组，用其中的score进行判断，大于60分的元组抽取出来，形成新的词典。
1.21 词典元素的遍历
在IDLE中输入代码：
students={“David”:50,“Diego”:98,“Sunny”:80}
for score in students.values():
print(score,end="😊
拷贝代码students={“David”:50,“Diego”:98,“Sunny”:80}
for score in students.values():
print(score,end="😊

输出结果：50:98:80。字典有三个重要的方法keys(), values()和items()，分别返回键、值和键值对的序列。随后既可对这些序列进行常规for循环遍历。
2、掌握多维数组ndarray
2.1 生成ndarray对象
在IDLE中，输入代码：
import numpy as np
arr=np.array([1,2.0,“3”])
print(arr)
拷贝代码import numpy as np
arr=np.array([1,2.0,“3”])
print(arr)

结果输出：[‘1’ ‘2.0’ ‘3’]。ndarray要求所有元素的数据类型必须一致，Numpy会自动识别ndarray中的数据类型，如果数据类型不一致Numpy会将所有元素自动转换成一个合适的数据类型。本例中将浮点数和整数，都转换为字符串。注意：print语句虽然输出了一个列表，但arr的类型不是一个list，而是一个ndarry对象，这个对象是numpy中定义的。通过使用type(arr)即可查看其类型为：<class ‘numpy.ndarray’>。
2.2 为ndarray指定类型
在IDLE中输入代码：
arr = np.array([1,2.0,“3”], dtype=np.float64)
print(arr)
拷贝代码arr = np.array([1,2.0,“3”], dtype=np.float64)
print(arr)

结果输出：[ 1. 2. 3.]。在生成ndarray对象的时候，如果指定其元素类型，numpy则会强制把所有的元素类型都转换为指定类型。
2.3 常用生成函数zeros()
在IDLE中输入代码：
arr1= np.zeros(5)
print(arr1)
arr2=np.zeros((2,3))
print(arr2)
拷贝代码arr1= np.zeros(5)
print(arr1)
arr2=np.zeros((2,3))
print(arr2)

结果输出：[ 0. 0. 0. 0. 0.]
[[ 0. 0. 0.]
[ 0. 0. 0.]]
numpy提供了一些快速生成特殊数据的函数，如ones()和zeros()函数，可以生成全零或全1的ndarray对象。函数可以接收一个多维元组，从而快捷生成所需要的多维数组。如zeros((2,3))生成一个2行3列的全零数组对象。
2.4 通过reshape方法重塑数组
在IDLE中输入代码：
arr = np.arange(15).reshape((3,5))
print(arr)
拷贝代码arr = np.arange(15).reshape((3,5))
print(arr)

输出结果：
[[ 0 1 2 3 4]
[ 5 6 7 8 9]
[10 11 12 13 14]]
在numpy中，提供了一个类似python中range函数的数组版arange()，用于生成从0到n的一维数组。这个维度有时候不能满足高维的需要，所以还有一个常用的reshape函数，接受一个元组，可以将一维数组转化为对应维度的数组。若执行：arr2 = arr.reshape((5,3))，则会生成一个新的5行3列的二维数组arr2，而元数组arr不变。
2.5 ndarray的基本属性
在IDLE中输入代码：
arr = np.arange(15).reshape((3,5))
print("{}:{}:{}:{}".format(arr.ndim,arr.shape,arr.dtype,arr.itemsize))
拷贝代码arr = np.arange(15).reshape((3,5))
print("{}:{}:{}:{}".format(arr.ndim,arr.shape,arr.dtype,arr.itemsize))

输出结果：2:(3, 5):int64:8。ndarry有几个常用属性，包括：ndim属性：表示数组的维度；shape属性：表示每一个维度的数量（元组）；dtype属性：描述数组元素的数据类型；itemsize属性：表示单个元素的大小（字节）；size属性：表示数据量的大小等。
2.6 ndarray的基本方法
在IDLE中输入代码：
import numpy as np
arr = np.arange(15)
arr.resize((3,5))
print(arr)
拷贝代码import numpy as np
arr = np.arange(15)
arr.resize((3,5))
print(arr)

输出结果：[[ 0 1 2 3 4]
[ 5 6 7 8 9]
[10 11 12 13 14]]
resize和reshape的区别在于，前者改变的是原对象，而后者生成一个新的对象。
此外，常用的numpy方法还包括flatten() ：降为一维数组，原数组不变；rezise(shape)，修改原数组；tolist()，将数组转换为列表等等。
2.7 多维素组的索引
在IDLE中输入代码：
arr = np.arange(8).reshape((2,2,2))
print("{}:{}:{}".format(arr[0][1][1],arr[0,1],arr[1,0,1]))
拷贝代码arr = np.arange(8).reshape((2,2,2))
print("{}:{}:{}".format(arr[0][1][1],arr[0,1],arr[1,0,1]))

输出结果：3:[2 3]:5。多维数组的索引可以使用两种方式：分别索引和集中索引。也就是每个维度的索引在一个中括号中，或者是所有的索引用逗号分开，放在一个中括号中。二维数组为平面数组，相对好理解，三维是立体，以及超过三维的维度难以理解。请理解arr的三维结构：[[[0 1] [2 3]] [[4 5] [6 7]]]。
2.8 多维数组切片
在IDLE中输入代码：
arr=np.arange(9).reshape((3,3))
print("{}:{}".format(arr[1:2,:2],arr[1,:2]))
拷贝代码arr=np.arange(9).reshape((3,3))
print("{}:{}".format(arr[1:2,:2],arr[1,:2]))

输出结果：[[3 4]]:[3 4]。对于一个3行3列的二维数组，在两个维度分别切片。行维度上取1:2，就是取第2行，列维度上取前两列。需要注意的是：切片返回的是一个维度，单索引返回一个值。所以，虽然返回的都是3和4，但是arr[1:2,:2]返回的是二维数组，arr[1,:2]返回的是一维数组。可以肯定的是，arr[1,2]返回一个值。
2.9 多维数组切片赋值
在IDLE中输入代码：
arr=np.arange(9).reshape((3,3))
arr[1:2,:2] =9
print(arr)
拷贝代码arr=np.arange(9).reshape((3,3))
arr[1:2,:2] =9
print(arr)

输出结果：
[[0 1 2]
[9 9 5]
[6 7 8]]
在对切片进行赋值的时候，会赋值给该切片范围内的所有变量。
3、了解Series和DataFrame结构
3.1 认识Series
在IDLE中输入代码：
import pandas as pd
obj = pd.Series([“a”,“b”,“c”])
print(obj)
拷贝代码import pandas as pd
obj = pd.Series([“a”,“b”,“c”])
print(obj)

输出结果：
0 a
1 b
2 c
dtype: object
每个Series对象实际上都由两个相互关联的数组组成，其中主数组用来存放数据。主数组的每个元素都有一个与之相关联的标签，这些标签存储在另外一个叫做Index的数组中。如果不指定索引，默认生成的索引是0到N-1。通过Series对象的values和index属性分别获取对应的值和索引。obj.values会返回一个列表：[‘a’ ‘b’ ‘c’]，而obj.index则返回一个索引对象：RangeIndex(start=0, stop=3, step=1)，如果用type函数来查看这个index的类型，是：<class ‘pandas.core.indexes.range.RangeIndex’>，属于pandas自定义的一个RangeIndex对象。
3.2 自定义索引及赋值
在IDLE中输入代码：
obj= pd.Series([6,2,-2,0], index=[“a”,“b”,“c”,“d”])
print(obj[‘b’])
obj[‘b’]=4
print(obj[‘b’])
拷贝代码obj= pd.Series([6,2,-2,0], index=[“a”,“b”,“c”,“d”])
print(obj[‘b’])
obj[‘b’]=4
print(obj[‘b’])

输出结果：2和4。通过使用索引来获取和设置对应的值，默认索引和自定义索引均可，但不可混合使用。不仅可以通过索引使用Series对象中的数据，还可以使用切片，或者使用二维索引，如obj[[‘a’,’b’]]，返回的依然是一个Series对象。
3.3 创建Series
在IDLE中，输入代码：
s = pd.Series(3, index=list(“abc”))
print(s)
拷贝代码s = pd.Series(3, index=list(“abc”))
print(s)

结果输出：
a 3
b 3
c 3
dtype: int64
Series的创建有很多中方法，如利用实数，如 pd.Series(3, index=list(“abc”))；利用列表，如pd.Series(list(“Hello”))；利用元组，如pd.Series(tuple(“Hello”))；利用ndarray数组，如pd.Series(np.zeros(5))；利用字典，如pd.Series({“name”:“Diego”,“age”:12})。
3.4 Series对象属性
在IDLE中输入代码：
s = pd.Series(range(5))
s.index=list(“abcde”)
s.index.name=“Myindex”
s.name=“MySerices”
print("{}:{}".format(s.name,s.index))
拷贝代码s = pd.Series(range(5))
s.index=list(“abcde”)
s.index.name=“Myindex”
s.name=“MySerices”
print("{}:{}".format(s.name,s.index))

输出结果：
MySerices:Index([‘a’, ‘b’, ‘c’, ‘d’, ‘e’], dtype=‘object’, name=‘Myindex’)。Series对象有name属性，其索引本身也有name属性，可以单独设定。可以通过给其index对象设置一个列表来改变索引值。
3.5 Series操作
在IDLE中输入代码：
obj=pd.Series(range(1,5,2))
print(obj2)
print(obj[obj>1])
拷贝代码obj=pd.Series(range(1,5,2))
print(obj2)
print(obj[obj>1])

结果输出：
0 2
1 6
dtype: int64
和：
1 3
dtype: int64
Series对象本质上是一个NumPy的数组，因此NumPy的数组处理函数可以直接对Series进行处理，比如可以使用布尔值数组进行过滤，与标量相乘，应用数学函数等。需要注意的是，默认索引值虽然是0到N-1，但不会参与运算。
3.6 构建DataFrame对象
在IDLE中输入代码：
data={‘name’:[‘Diego’,‘Anna’,‘Eugene’],
‘gender’:[‘M’,‘F’,‘M’],
‘age’:[12,23,34]}
df = pd.DataFrame(data)
print(df)
拷贝代码data={‘name’:[‘Diego’,‘Anna’,‘Eugene’],
‘gender’:[‘M’,‘F’,‘M’],
‘age’:[12,23,34]}
df = pd.DataFrame(data)
print(df)

结果输出：
age gender name
0 12 M Diego
1 23 F Anna
2 34 M Eugene
可以利用包含等长度列表/NumPy数组/Series的字典来创建DataFrame对象。如果需要调整每个Series对象的位置，需要指定columns参数。
3.7 用词典构建DataFrame
在IDLE中输入代码：
dd= {‘name’:{1:‘Diego’,2:‘Anna’,3:‘Eugene’},
‘gender’:{1:‘M’,2:‘F’},
‘age’:{1:12,2:23,3:34}}
df=pd.DataFrame(dd)
print(df)
拷贝代码dd= {‘name’:{1:‘Diego’,2:‘Anna’,3:‘Eugene’},
‘gender’:{1:‘M’,2:‘F’},
‘age’:{1:12,2:23,3:34}}
df=pd.DataFrame(dd)
print(df)

输出结果：
age gender name
1 12 M Diego
2 23 F Anna
3 34 NaN Eugene
嵌套字典构建DataFrame时，Pandas将字典的键做为列索引，将内部字典的键作为行进行索引。
3.8 检索与定位
在IDLE中输入代码：
data={‘name’:[‘Diego’,‘Anna’,‘Eugene’],
‘gender’:[‘M’,‘F’,‘M’],
‘age’:[12,23,34]}
df = pd.DataFrame(data)
print(df.name)
print(df.loc[2])
拷贝代码data={‘name’:[‘Diego’,‘Anna’,‘Eugene’],
‘gender’:[‘M’,‘F’,‘M’],
‘age’:[12,23,34]}
df = pd.DataFrame(data)
print(df.name)
print(df.loc[2])

结果输出：
0 Diego
1 Anna
2 Eugene
Name: name, dtype: object
age 34
gender M
name Eugene
Name: 2, dtype: object

DataFrame中选择某列的方法有：类似字典的标记，如df[‘name’]（任意列名）；列名为属性，如df.name(列名是有效的Python变量名）。如果需要选择一行，可以使用属性loc返回一个Series对象。如df.loc[1]，其索引的名字即为当前行的列索引“1” ，索引名字为各列的名字。
3.9 通过列修改数据
在IDLE中输入代码：
data={‘name’:[‘Diego’,‘Anna’,‘Eugene’],
‘gender’:[‘M’,‘F’,‘M’],
‘age’:[12,23,34]}
df = pd.DataFrame(data)
df.age=20
print(df.age)
拷贝代码data={‘name’:[‘Diego’,‘Anna’,‘Eugene’],
‘gender’:[‘M’,‘F’,‘M’],
‘age’:[12,23,34]}
df = pd.DataFrame(data)
df.age=20
print(df.age)

结果输出：
0 20
1 20
2 20
Name: age, dtype: int64
通过列修改数据的时候，可以使用标量值，也可以使用值数组（其长度必须匹配），或者可以使用一个Series对象进行赋值。此时其索引按DataFrame的索引重新排列，空缺处填充NaN。
3.10 重新索引
在IDLE中输入代码：
df=pd.DataFrame(np.arange(9).reshape(3,3),index=[‘a’,‘c’,‘d’],columns=[‘one’,‘two’,‘four’])
df.reindex(index=[‘a’,‘b’,‘c’,‘d’],columns=[‘one’,‘two’,‘three’,‘four’])
print(df)
拷贝代码df=pd.DataFrame(np.arange(9).reshape(3,3),index=[‘a’,‘c’,‘d’],columns=[‘one’,‘two’,‘four’])
df.reindex(index=[‘a’,‘b’,‘c’,‘d’],columns=[‘one’,‘two’,‘three’,‘four’])
print(df)

输出结果：
one two three four
a 0.0 1.0 NaN 2.0
b NaN NaN NaN NaN
c 3.0 4.0 NaN 5.0
d 6.0 7.0 NaN 8.0

重新索引方法reindex()，默认对行进行重新索引，如df1.reindex([‘a’,‘b’,‘c’,‘d’])。也可以同时对列和行进行索引，如df1.reindex(index=[‘a’,‘b’,‘c’,‘d’],columns=[‘one’,‘two’,‘three’,'four’])。缺失值自动用NaN填充，也使用参数fill_value=n，用n代替缺失值。
3.11 索引对象
在IDLE中输入代码：
data={‘name’:[‘Diego’,‘Anna’,‘Eugene’],
‘gender’:[‘M’,‘F’,‘M’],
‘age’:[12,23,34]}
df = pd.DataFrame(data)
labels = df.columns
obj = pd.Series([80,“M”,“David”],index=labels)
print(obj)
拷贝代码data={‘name’:[‘Diego’,‘Anna’,‘Eugene’],
‘gender’:[‘M’,‘F’,‘M’],
‘age’:[12,23,34]}
df = pd.DataFrame(data)
labels = df.columns
obj = pd.Series([80,“M”,“David”],index=labels)
print(obj)

输出结果：
age 80
gender M
name David
dtype: object
索引对象用于存储轴标签和其他元数据，可以用pd.index()生成索引对象，或从Series和DataFrame的行列索引。可以查看从df的columns生成的索引对象为：Index([‘age’, ‘gender’, ‘name’], dtype=‘object’)。索引对象可以被其他Series或DataFrame对象复用。