五、表格

表格是表示数据集的基本对象类型。 表格可以用两种方式查看：

• 具名列的序列，每列都描述数据集中所有条目的一个方面，或者
• 行的序列，每行都包含数据集中单个条目的所有信息。

为了使用表格，导入所有称为datascience的模块，这是为这篇文章创建的模块。

from datascience import *

空表格可以使用Table创建。空表格是实用的，因为他可以扩展来包含新行和新列。

Table()

表格上的with_columns方法使用带有附加标签的列，构造一个新表。 表格的每一列都是一个数组。 为了将一个新列添加到表中，请使用标签和数组调用with_columns。 （with_column方法具有相同的效果。）

下面，我们用一个没有列的空表开始每个例子。

Table().with_columns('Number of petals', make_array(8, 34, 5))

为了添加两个（或更多）新列，请为每列提供一个数组和标签。 所有列必须具有相同的长度，否则会发生错误。

Table().with_columns(
    'Number of petals', make_array(8, 34, 5),
    'Name', make_array('lotus', 'sunflower', 'rose')
)

我们可以给这个表格一个名词，之后使用另外一列扩展表格。

flowers = Table().with_columns(
    'Number of petals', make_array(8, 34, 5),
    'Name', make_array('lotus', 'sunflower', 'rose')
)

flowers.with_columns(
    'Color', make_array('pink', 'yellow', 'red')
)

with_columns方法每次调用时，都会创建一个新表，所以原始表不受影响。 例如，表an_example仍然只有它创建时的两列。

flowers

通过这种方式创建表涉及大量的输入。 如果数据已经输入到某个地方，通常可以使用 Python 将其读入表格中，而不是逐个单元格地输入。

通常，表格从包含逗号分隔值的文件创建。这些文件被称为 CSV 文件。

下面，我们使用Table的read_table方法，来读取一个 CSV 文件，它包含了一些数据，Minard 在他的拿破仑的俄罗斯战役的图片中使用。 数据放在名为minard的表中。

minard = Table.read_table('minard.csv')
minard

我们将使用这个小的表格来演示一些有用的表格方法。 然后，我们将使用这些相同的方法，并在更大的数据表上开发其他方法。

表格的大小

num_columns方法提供了表中的列数量，num_rows是行数量。

minard.num_columns
5
minard.num_rows
8

列标签

labels方法可以用来列出所有列的标签。 对于minard，并不是特别有用，但是对于那些非常大的表格，并不是所有的列都在屏幕上可见。

minard.labels
('Longitude', 'Latitude', 'City', 'Direction', 'Survivors')

我们使用relabeled修改列标签。这会创建新的表格，并保留minard不变。

minard.relabeled('City', 'City Name')

但是，这个方法并不修改原始表。

minard

常见的模式时将原始名称minard赋给新的表，以便minard未来的所有使用，都会引用修改标签的表格。

minard = minard.relabeled('City', 'City Name')
minard

访问列中的数据

我们可以使用列标签来访问列中的数据数组。

minard.column('Survivors')
array([145000, 140000, 127100, 100000,  55000,  24000,  20000,  12000])

五列的下标分别为0, 1, 2, 3, 4。Survivors列也可以使用列下标来访问。

minard.column(4)
array([145000, 140000, 127100, 100000,  55000,  24000,  20000,  12000])

数组中的八个条目下标为0, 1, 2, ..., 7。列中的条目可以使用item访问，就像任何数组那样。

minard.column(4).item(0)
145000
minard.column(4).item(5)
24000

处理列中的数据

因为列是数组，所以我们可以使用数组操作来探索新的信息。 例如，我们可以创建一个新列，其中包含 Smolensk 之后每个城市的所有幸存者的百分比。

initial = minard.column('Survivors').item(0)
minard = minard.with_columns(
    'Percent Surviving', minard.column('Survivors')/initial
)
minard

要使新列中的比例显示为百分比，我们可以使用选项PercentFormatter调用set_format方法。 set_format方法接受Formatter对象，存在日期（DateFormatter），货币（CurrencyFormatter），数字和百分比。

minard.set_format('Percent Surviving', PercentFormatter)

选择列的集合

select方法创建一个新表，仅仅包含指定的列。

minard.select('Longitude', 'Latitude')

使用列索引而不是标签，也可以执行相同选择。

minard.select(0, 1)

select的结果是个新表，即使当你选择一列时也是这样。

minard.select('Survivors')

要注意结果是个表格，不像column的结果，它是个数组。

minard.column('Survivors')
array([145000, 140000, 127100, 100000,  55000,  24000,  20000,  12000])

另一种创建新表，包含列集合的方式，是drop你不想要的列。

minard.drop('Longitude', 'Latitude', 'Direction')

select和drop都不修改原始表格。 相反，他们创建了共享相同数据的新小型表格。 保留的原始表格是实用的！ 你可以生成多个不同的表格，只考虑某些列，而不用担心会互相影响。

minard

我们用过的所有方法都可以用在任何表格上。

对行排序

CNN 在 2016 年 3 月报道说：“NBA 是全球薪水最高的职业体育联盟。”nba_salaries包含了 2015~2016 年间所有 NBA 球员的薪水。

每行表示一个球员。列为：

位置代码是 PG（控球后卫），SG（得分后卫），PF（大前锋），SF（小前锋）和 C（中锋）。 但接下来的内容并不涉及篮球运动的细节。

第一行显示，亚特兰大老鹰队（Atlanta Hawks）的大前锋保罗·米尔萨普（Paul Millsap）在 2015~2016 年间的薪水接近 1870 万美元。

# This table can be found online: https://www.statcrunch.com/app/index.php?dataid=1843341
nba_salaries = Table.read_table('nba_salaries.csv')
nba_salaries

（省略了 407 行）

该表包含 417 行，每个球员一行。 只显示了 10 行。show方法允许我们指定行数，缺省值（没有指定）是表的所有行。

nba_salaries.show(3)

（省略了 414 行）

通过浏览大约 20 行左右，你会看到行按字母顺序排列。 也可以使用sort方法，按球员姓名的字母顺序列出相同的行。 sort的参数是列标签或索引。

nba_salaries.sort('PLAYER').show(5)

（省略了 412 行）

440/5000 为了检查球员的薪水，如果数据是按薪水排序的话，会更有帮助。

为了实现它，我们首先简化薪水列的标签（只是为了方便），然后用新的标签SALARY进行排序。

这会按照薪水的升序排列表中的所有行，最低的薪水在最前面。 输出是一个新表，列与原始表格相同，但行是重新排列的。

nba = nba_salaries.relabeled("'15-'16 SALARY", 'SALARY')
nba.sort('SALARY')

（省略了 407 行）

这些数字有些难以比较，因为这些球员中的一些，在赛季中改变了球队，并从不止一支球队获得了薪水。 只有最后一支球队的薪水出现在表中。 控球后卫菲尔·普莱西（Phil Pressey）在年内从费城搬到了凤凰城，可能会再次转到金州勇士队（Golden State Warriors）。

CNN 的报道是薪酬水平的另一端 - 那些在世界上薪水最高的球员。

为了按照薪水的降序对表格的行排序，我们必须以descending=True调用sort函数。

nba.sort('SALARY', descending=True)

（省略了 407 行）

科比（Kobe Bryant）在湖人队（Lakers）的最后一个赛季是薪水最高的，2500 万美元。 请注意，MVP 斯蒂芬·库里（Stephen Curry）并没有出现在前 10 名之列。他排在后面，我们将在后面看到。

具名参数

这个调用表达式的descending = True部分称为具名参数。 调用一个函数或方法时，每个参数都有一个位置和一个名字。 从函数或方法的帮助文本中都可以看出它们。

help(nba.sort)
Help on method sort in module datascience.tables:

sort(column_or_label, descending=False, distinct=False) method of datascience.tables.Table instance
    Return a Table of rows sorted according to the values in a column.

    Args:
        ``column_or_label``: the column whose values are used for sorting.

        ``descending``: if True, sorting will be in descending, rather than
            ascending order.

        ``distinct``: if True, repeated values in ``column_or_label`` will
            be omitted.

    Returns:
        An instance of ``Table`` containing rows sorted based on the values
        in ``column_or_label``.

    >>> marbles = Table().with_columns(
    ...    "Color", make_array("Red", "Green", "Blue", "Red", "Green", "Green"),
    ...    "Shape", make_array("Round", "Rectangular", "Rectangular", "Round", "Rectangular", "Round"),
    ...    "Amount", make_array(4, 6, 12, 7, 9, 2),
    ...    "Price", make_array(1.30, 1.30, 2.00, 1.75, 1.40, 1.00))
    >>> marbles
    Color | Shape       | Amount | Price
    Red   | Round       | 4      | 1.3
    Green | Rectangular | 6      | 1.3
    Blue  | Rectangular | 12     | 2
    Red   | Round       | 7      | 1.75
    Green | Rectangular | 9      | 1.4
    Green | Round       | 2      | 1
    >>> marbles.sort("Amount")
    Color | Shape       | Amount | Price
    Green | Round       | 2      | 1
    Red   | Round       | 4      | 1.3
    Green | Rectangular | 6      | 1.3
    Red   | Round       | 7      | 1.75
    Green | Rectangular | 9      | 1.4
    Blue  | Rectangular | 12     | 2
    >>> marbles.sort("Amount", descending = True)
    Color | Shape       | Amount | Price
    Blue  | Rectangular | 12     | 2
    Green | Rectangular | 9      | 1.4
    Red   | Round       | 7      | 1.75
    Green | Rectangular | 6      | 1.3
    Red   | Round       | 4      | 1.3
    Green | Round       | 2      | 1
    >>> marbles.sort(3) # the Price column
    Color | Shape       | Amount | Price
    Green | Round       | 2      | 1
    Red   | Round       | 4      | 1.3
    Green | Rectangular | 6      | 1.3
    Green | Rectangular | 9      | 1.4
    Red   | Round       | 7      | 1.75
    Blue  | Rectangular | 12     | 2
    >>> marbles.sort(3, distinct = True)
    Color | Shape       | Amount | Price
    Green | Round       | 2      | 1
    Red   | Round       | 4      | 1.3
    Green | Rectangular | 9      | 1.4
    Red   | Round       | 7      | 1.75
    Blue  | Rectangular | 12     | 2

在help文本的最上面，出现了sort方法的签名。

sort(column_or_label, descending=False, distinct=False)

这描述了sort的三个参数的位置，名称和默认值。 调用此方法时，可以使用位置参数或具名参数，因此以下三个调用完全相同。

sort('SALARY', True)
sort('SALARY', descending=True)
sort(column_or_label='SALARY', descending=True)

当一个参数只是True或False时，包含参数名称是实用的约定，以便更明显地说明参数值的含义。

行的选取

通常，我们只想提取那些行，它们对应具有特定特征的条目。 例如，我们可能只需要对应勇士的行，或者获得超过一千万美元的球员。 或者我们可能只想要薪水前五名的人。

指定行

Table的方法就是干这个的 - 它需要一组指定的行。 它的参数是行索引或索引数组，它创建一个只包含这些行的新表。

例如，如果我们只想要nba的第一行，我们可以这样使用take。

nba

（省略了 407 行）

nba.take(0)

这是一个新表，只拥有我们指定的单个行。

通过指定一系列索引作为参数，我们还可以获得第四，第五和第六行。

nba.take(np.arange(3, 6))

如果我们想要前五个最高薪球员的表格，我们可以先按薪水排序，然后取前五行：

nba.sort('SALARY', descending=True).take(np.arange(5))

对应指定特征的行

更常见的情况是，我们打算访问一组行中的数据，它们具有某种特征，但是我们并不知道其索引。 例如，我们可能想要所有薪水大于一千万美元的球员的数据，但我们不希望花费时间，对已排序的表中的行进行计数。

where方法可以做到。 它的输出是一个表格，列与原始表格相同，但只有特征出现的行。

where的第一个参数是列标签，列中包含信息，有关某行是否具有我们想要的特征。 如果特征是“薪水超过一千万美元”，那么列就是SALARY。

where的第二个参数是用于指定特征的方式。 一些例子会使指定的一般方式更容易理解。

在第一个例子中，我们提取了所有薪水超过一千万美元的人的数据。

nba.where('SALARY', are.above(10))

（省略了 59 行）

are.above(10)的参数的确保了，每个选择的行的SALARY大于 10。

新的表格有 69 行，相当于 69 个球员的薪水是一千万美元。 按顺序排列这些行使数据更易于分析。 多伦多猛龙队（Toronto Raptors）的德玛尔·德罗赞（DeMar DeRozan）是这个分组（薪水超过一千万美元）中“最穷”的一个。

nba.where('SALARY', are.above(10)).sort('SALARY')

（省略了 59 行）

斯蒂芬·库里（Stephen Curry）挣了多少？ 对于答案，我们必须访问PLAYER的值等于Stephen Curry的行。 这是一个只包含一行的表格：

nba.where('PLAYER', are.equal_to('Stephen Curry'))

库里只有不到 1140 万美元。 这是很多钱，但还不到勒布朗·詹姆斯（LeBron James）薪水的一半。 你可以在本节前面的“前 5 名”表中找到薪水，或者你可以在上面的代码中找到它，将'Stephen Curry换成'LeBron James'。

代码中再次使用了are，但这次是谓词equal_to而不是上面那个。 因此，例如，你可以得到包含所有的勇士的表格：

nba.where('TEAM', are.equal_to('Golden State Warriors')).show()

这部分表格已经按薪水排序，因为原始的表格按薪水排序，列出了同一个球队中球员。 行尾的.show()确保显示所有行，而不仅仅是前 10 行。

请求某列等于某值的行非常普遍，因此are.equal_to调用是可选的。 相反，仅仅使用列名和值来调用where方法，以达到相同的效果。

nba.where('TEAM', 'Denver Nuggets') 
# equivalent to nba.where('TEAM', are.equal_to('Denver Nuggets'))

（省略了 4 行）

多个属性

通过重复使用where，你可以访问具有多个指定特征的行。 例如，这是一种方法，提取薪水超过一千五百万美元的所有控球后卫。

nba.where('POSITION', 'PG').where('SALARY', are.above(15))

一般形式

现在你已经意识到，通过选择具有给定特征的行，来创建新表的一般方法，是使用where和are，以及适当的条件：

original_table_name.where(column_label_string, are.condition)

nba.where('SALARY', are.between(10, 10.3))

请注意，上面的表格包括赚一千万美元的 Danny Green，而不包括一千三百万美元的 Monta Ellis。 与 Python 中的其他地方一样，范围包括左端但不包括右端。

如果我们指定一个任何行都不满足的条件，我们得到一个带有列标签但没有行的表。

nba.where('PLAYER', are.equal_to('Barack Obama'))

更多条件

这里有一些谓词，你可能会觉得有用。 请注意，x和y是数字，STRING是一个字符串，Z是数字或字符串；你必须指定这些，取决于你想要的特征。

你也可以指定任何这些条件的否定，通过在条件前面使用.not_。

以及其他。通常的逻辑规则是适用的，例如，“不大于x”等价于“小于等于x”。

我们以一系列示例结束这一节。

are.containing的使用有助于少打一些字。 例如，你可以指定Warriors而不是Golden State Warriors：

nba.where('TEAM', are.containing('Warriors')).show()

你可以提取所有后卫的数据，包括控球后卫和得分后卫。

nba.where('POSITION', are.containing('G'))

（省略了 171 行）

你可以获取所有不是克利夫兰骑士队的球员，并且薪水不低于两千万美元：

other_than_Cavs = nba.where('TEAM', are.not_equal_to('Cleveland Cavaliers'))
other_than_Cavs.where('SALARY', are.not_below(20))

有很多方式可以创建相同的表格。这里是另一种，并且显然你可以想出来更多。

other_than_Cavs.where('SALARY', are.above_or_equal_to(20))

你可以看到，where的使用提供了很大的灵活性，来访问你感兴趣的特征。 不要犹豫，尝试它吧！

示例：人口趋势

美国人口的趋势

现在我们做好了处理大量的数据表的准备。 下面的文件包含“美国居民人口的年度估计，按年龄和性别分列”。 请注意，read_table可以直接从 URL 读取数据。

# As of Jan 2017, this census file is online here: 
data = 'http://www2.census.gov/programs-surveys/popest/datasets/2010-2015/national/asrh/nc-est2015-agesex-res.csv'

# A local copy can be accessed here in case census.gov moves the file:
# data = 'nc-est2015-agesex-res.csv'

full_census_table = Table.read_table(data)
full_census_table

（已省略 296 行）

只显示了表格的前 10 行。稍后我们将看到如何显示整个表格；但是，这通常不适用于大型表格。

表格的描述一起出现。SEX列包含数字代码：0代表总体，1代表男性，2代表女性。 AGE列包含完整年份为单位的年龄，但特殊值999是人口的总和。 其余的列包含美国人口的估计。

通常，公共表格将包含更多的信息，不仅仅是特定调查或分析所需的信息。 在这种情况下，我们假设我们只对 2010 年到 2014 年的人口变化感兴趣。让我们选择相关的列。

partial_census_table = full_census_table.select('SEX', 'AGE', 'POPESTIMATE2010', 'POPESTIMATE2014')
partial_census_table

（已省略 296 行）

我们也可以简化所选列的标签。

us_pop = partial_census_table.relabeled('POPESTIMATE2010', '2010').relabeled('POPESTIMATE2014', '2014')
us_pop

（已省略 296 行）

我们现在有了一个易于使用的表格。 表中的每一列都是一个等长的数组，因此列可以使用算术进行组合。 这是 2010 年至 2014 年的人口变化。

us_pop.column('2014') - us_pop.column('2010')
array([  -1555,   -8112, -131198, ...,    6443,   12950, 4693244])

让我们使用包含这些变化的列来扩展us_pop，一列是绝对数值，另一列是相对于 2010 年数值的百分比。

change = us_pop.column('2014') - us_pop.column('2010')
census = us_pop.with_columns(
    'Change', change,
    'Percent Change', change/us_pop.column('2010')
)
census.set_format('Percent Change', PercentFormatter)

（已省略 296 行）

将数据排序。让我们按照人口绝对变化的降序排序表格。

census.sort('Change', descending=True)

毫不奇怪，排序后表格的第一行对应整个人口：所有年龄和性别的分组。 从 2010 年到 2014 年，美国人口增加了约 950 万人，仅为 3%。

接下来的两行分别对应所有的男性和所有的女性。 以绝对数量和百分比来衡量，男性人口的增长高于女性人口。 百分比变化都在 3% 左右。

现在看看接下来的几行。 百分比变化从总人口的 3% 左右，上升到 60 年代末和 70 年代初的近 30%。 这个惊人的变化称为美国的老龄化。

到目前为止，2014 年 64~67 岁年龄段的绝对变化最大。什么可以解释这一大幅增长的原因？ 我们可以通过考察相关分组的出生年份，来探索这个问题。

那些 2010 年在 64~67 岁年龄段的人，在 1943 年到 1946 年间出生。珍珠港的袭击是在 1941 年底，美军在 1942 年发动了一场大规模战争，结束于 1945 年。

2014 年 64 岁到 67 岁的人生于 1947 年到 1950 年，是美国二战后的生育高峰。

战后的生育高峰，是我们观察到的巨大变化的主要原因。

示例：性别趋势

性别比例的趋势

我们现在拥有了足够的编码技能，足以检查美国人群中的特征和趋势。在这个例子中，我们将查看不同年龄的男性和女性的分布情况。我们将继续使用上一节中的us_pop表。

us_pop

（已省略 296 行）

我们从之前对这个数据集的检查得知，表格的描述一起出现。 它提醒了表中包含的内容。

每一行表示一个年龄。SEX列包含数字代码：0代表总数，1代表男性，2代表女性。 年龄栏包含以完整年份为单位的年龄，但特殊值999代表整个人口，不论年龄是什么。其余的列包含美国人口的估计。

理解AGE=100

作为一个初步的例子，我们来解释一下表中最后的年龄的数据，其中年龄是100岁。下面的代码提取了男性和女性（性别代码0）的组合分组，年龄最大的行。

us_pop.where('SEX', are.equal_to(0)).where('AGE', are.between(97, 101))

不足为奇的是，年龄越大，人数越少，例如 99 岁的人数少于 98 岁。

然而，令人吃惊的是，100 岁的数值比 99 岁的数值要大得多。仔细查看文件，这是因为人口普查局使用 100 作为 100 或岁以上的每个人的代码。

年龄为 100 岁的人不仅仅代表 100 岁的人，还包括年龄在 100 岁以上的人。这就是为什么那一行的数字大于 99 岁的人的数字。

男性和女性的整体比例

我们现在开始考察 2014 年的性别比例。首先，我们一起来看看所有的年龄。 请记住，这意味着查看AGE编码为999的行。all_ages表包含此信息。其中有三行：一个是两种性别总体，一个是男性（SEX代码为1），一个是女性（SEX代码为2）。

us_pop_2014 = us_pop.drop('2010')
all_ages = us_pop_2014.where('AGE', are.equal_to(999))
all_ages

all_ages的第 0 行包含两年中每年的美国总人口。2014 年，美国人口刚刚少于 3.19 亿。

第 1 行包含男性的计数，女性是第 2 行。 比较这两行可以看到，在 2014 年，美国的女性比男性多。

第 1 行和第 2 行的人口数加起来为第 0 行的总人口数。

为了与其他数量进行比较，我们需要将这些数字转换为总人口中的百分比。 让我们访问 2014 年的总数并命名。 然后，我们将显示带有比例列的人口表格。 与我们先前观察到的，女性人数多于男性的情况一致，2014 年约有 50.8% 的人口是女性，两年的每年中，约有 49.2% 的人口是男性。

pop_2014 = all_ages.column('2014').item(0)
all_ages.with_column(
    'Proportion', all_ages.column('2014')/pop_2014
).set_format('Proportion', PercentFormatter)

新生儿中男孩和女孩的比例

但是，当我们查看婴儿时，情况正好相反。 让我们将婴儿定义为还没有完整一年的人，对应年龄为 0 的行。这里是他们的人口数量。 你可以看到男婴比女婴多。

infants = us_pop_2014.where('AGE', are.equal_to(0))
infants

像以前一样，我们可以将这些数字转换成婴儿总数中的百分比。 所得表格显示，2014 年，美国超过 51% 的婴儿是男性。

infants_2014 = infants.column('2014').item(0)
infants.with_column(
    'Proportion', infants.column('2014')/infants_2014
).set_format('Proportion', PercentFormatter)

事实上，长期以来，新生儿中男孩的比例略高于 1/2。 这个原因还没有得到彻底的理解，科学家们还在努力。

每个年龄的男女比例

我们已经看到，虽然男婴比女婴多，但女性总数比男性多。 所以很显然，性别之间的分隔在不同年龄之间必须有所不同。

为了研究这个变化，我们将女性和男性的数据分开，并消除所有年龄的组合，年龄编码为 999 的行。

females和male表格分别包含两个性别的数据。

females_all_rows = us_pop_2014.where('SEX', are.equal_to(2))
females = females_all_rows.where('AGE', are.not_equal_to(999))
females

（省略了 91 行）

males_all_rows = us_pop_2014.where('SEX', are.equal_to(1))
males = males_all_rows.where('AGE', are.not_equal_to(999))
males

（省略了 91 行）

现在的计划是，比较两年中每一年的，每个年龄的女性人数和男性人数。 数组和表格的方法为我们提供了直接的方式。 这两个表格中，每个年龄都有一行。

males.column('AGE')
array([  0,   1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,
        13,  14,  15,  16,  17,  18,  19,  20,  21,  22,  23,  24,  25,
        26,  27,  28,  29,  30,  31,  32,  33,  34,  35,  36,  37,  38,
        39,  40,  41,  42,  43,  44,  45,  46,  47,  48,  49,  50,  51,
        52,  53,  54,  55,  56,  57,  58,  59,  60,  61,  62,  63,  64,
        65,  66,  67,  68,  69,  70,  71,  72,  73,  74,  75,  76,  77,
        78,  79,  80,  81,  82,  83,  84,  85,  86,  87,  88,  89,  90,
        91,  92,  93,  94,  95,  96,  97,  98,  99, 100])
females.column('AGE')
array([  0,   1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,
        13,  14,  15,  16,  17,  18,  19,  20,  21,  22,  23,  24,  25,
        26,  27,  28,  29,  30,  31,  32,  33,  34,  35,  36,  37,  38,
        39,  40,  41,  42,  43,  44,  45,  46,  47,  48,  49,  50,  51,
        52,  53,  54,  55,  56,  57,  58,  59,  60,  61,  62,  63,  64,
        65,  66,  67,  68,  69,  70,  71,  72,  73,  74,  75,  76,  77,
        78,  79,  80,  81,  82,  83,  84,  85,  86,  87,  88,  89,  90,
        91,  92,  93,  94,  95,  96,  97,  98,  99, 100])

对于任何特定年龄，我们都可以通过将女性人数除以男性人数，获的女性：男性性别比例。 为了一步完成它，我们可以使用列来提取女性数量的数组，和相应的男性数量的数组，然后简单地将一个数组除以另一个数组。 逐元素相除将为所有年份创建性别比例的数组。

ratios = Table().with_columns(
    'AGE', females.column('AGE'),
    '2014 F:M RATIO', females.column('2014')/males.column('2014')
)
ratios

（省略了 91 行）

从输出中可以看出，九岁以下儿童的比例都在 0.96 左右。 当男女比例小于 1 时，女性比男性少。 因此，我们所看到的是，在 0~9 岁的年龄段中，女孩比男孩少。此外，在每个年龄中，每 100 个男孩大约对应 96 个女孩。

那么人口中女性的整体比例为什么高于男性呢？

当我们检查年龄的另一端时，会发现一些非同寻常的事情。 以下是 75 岁以上的男女比例。

ratios.where('AGE', are.above(75)).show()

不仅所有这些比例大于 1，在所有这些年龄段中，女性比男性多，其中许多比例大于 1。

• 在 89 岁和 90 岁中，比例接近 2，这意味着 2014 年这些年龄的女性约为男性的两倍。
• 在 98 岁和 99 岁中，女性约为男性的 3.5 至 4 倍。

如果你想知道有多少高龄的人，你可以使用 Python 来发现：

males.where('AGE', are.between(98, 100))

females.where('AGE', are.between(98, 100))

下图展示了年龄相关的性别比率。 蓝色曲线显示 2014 年的比例与年龄。

从 0 岁到 60 岁，这个比例差不多是 1（表示男性和女性差不多相等），但从 65 岁开始，比例开始急剧上升（女性多于男性）。

美国女性人数多于男性，部分原因是老年妇女的显着的性别不平衡。

ratios.plot('AGE')