你需要在数据序列上执行聚集函数（比如 sum() , min() , max() ）， 但是首先你需要先转换或者过滤数据



使用一个生成器表达式参数

一个非常优雅的方式去结合数据计算与转换就是使用一个生成器表达式参数。 比如，如果你想计算平方和，可以像下面这样做：

nums = [1, 2, 3, 4, 5]
s = sum(x * x for x in nums)

下面是更多的例子：

# Determine if any .py files exist in a directory
import os
files = os.listdir('dirname')
if any(name.endswith('.py') for name in files):
    print('There be python!')
else:
    print('Sorry, no python.')
# Output a tuple as CSV
s = ('ACME', 50, 123.45)
print(','.join(str(x) for x in s))
# Data reduction across fields of a data structure
portfolio = [
    {'name':'GOOG', 'shares': 50},
    {'name':'YHOO', 'shares': 75},
    {'name':'AOL', 'shares': 20},
    {'name':'SCOX', 'shares': 65}
]
min_shares = min(s['shares'] for s in portfolio)



省略括号

上面的示例向你演示了当生成器表达式作为一个单独参数传递给函数时候的巧妙语法（你并不需要多加一个括号）。 比如，下面这些语句是等效的：

s = sum((x * x for x in nums)) # 显示的传递一个生成器表达式对象
s = sum(x * x for x in nums) # 更加优雅的实现方式，省略了括号

使用一个生成器表达式作为参数会比先创建一个临时列表更加高效和优雅。 比如，如果你不使用生成器表达式的话，你可能会考虑使用下面的实现方式：

nums = [1, 2, 3, 4, 5]
s = sum([x * x for x in nums])

这种方式同样可以达到想要的效果，但是它会多一个步骤，先创建一个额外的列表。 对于小型列表可能没什么关系，但是如果元素数量非常大的时候， 它会创建一个巨大的仅仅被使用一次就被丢弃的临时数据结构。而生成器方案会以迭代的方式转换数据，因此更省内存。

在使用一些聚集函数比如 min() 和 max() 的时候你可能更加倾向于使用生成器版本， 它们接受的一个 key 关键字参数或许对你很有帮助。 比如，在上面的证券例子中，你可能会考虑下面的实现版本：

# Original: Returns 20
min_shares = min(s['shares'] for s in portfolio)
# Alternative: Returns {'name': 'AOL', 'shares': 20}
min_shares = min(portfolio, key=lambda s: s['shares'])

12.3.1 用迭代器转换序列
 
到目前为止，我们只是用迭代器，从一段数据（如果有的话）生成序列。然而，迭代器通常用来以某种方式，进行序列的转换。作为一个简单的例子，这里有一个方法，把数字序列转换成平方序列：
 
IEnumerable<int>Squares(IEnumerable<int> numbers) {
 foreach(int i in numbers)
   yield return i * i;
}
 
我们使用的是熟悉的 foreach 结构，但是要记住，包含 yield return 语句的foreach，有了不同的含义，它不会提前进行循环，而是在需要时才计算。foreach 语句，为每次循环迭代生成元素的代码，对应于从输入序列中取出（pulling）一个元素，把零或多个元素推到（pushing）输出序列中（在前面的例子中，我们始终只生成一个元素）。如果想要实现 LINQ to Objects 中的泛型 Where 和 Select 方法，可以使用完全相同的方法。
有一个更复杂的例子，我们想实现 Zip 方法，与 F# 中的 Seq.zip 函数的功能相同；给它两个序列，将返回一个序列，包含的元素是把给定的序列连接成元组。在 .NET 4.0 的库中有这个方法，但我们要讨论一下，因为它能展示了一个有趣的问题；不能使用 foreach 同时从两个源序列取元素。从清单 12.8 中可以看到，唯一的选择是直接使用 IEnumerable<T> 和 IEnumerator<T> 接口。
 
清单 12.8 实现 Zip 方法 (C#)
 
public static IEnumerable<Tuple<T1,T2>> Zip<T1, T2>
   (IEnumerable<T1> first, IEnumerable<T2> second) {
 using(var firstEn = first.GetEnumerator())        | [1]
 using(var secondEn = second.GetEnumerator()) {  |
   while (firstEn.MoveNext() && secondEn.MoveNext()) {    [2]
     yield return Tuple.Create(firstEn.Current, secondEn.Current);    [3]
    }
  }
}
 
从方法的签名可以看出，参数为两个序列；方法是泛型的，每个输入序列有单独的类型参数。我们使用的是泛型 C# 元组，因此，返回序列包含 Tuple<T1, T2> 类型的元素。在具体实现中，我们首先获得每个序列能够进行遍历元素的枚举器[1]，然后，在每个枚举上重复调用 MoveNext 方法，从两个序列中获得下一个元素[2]。如果有一个序列已经结束，我们就产生包含每个枚举器当前元素的元组[3]。
这个示例表明，有时修，处理方法需要显式使用 IEnumerator <T> 接口。foreach 循环为我们提供了从一个源中逐个提取出元素的方法，但是，如果需要从多个源中交替地提取元素，就有问题了。如果我们要在 F# 中实现 Seq.zip，就只能使用相同的方法。既可以在序列表达式中使用 while 循环，也可以使用递归的序列表达式。我们需要的大部分处理函数，在 .NET 和 F# 库中已经有了，所以，我们既可以显式使用，也可以通过使用 C# 的查询表达式语法使用。

# 如果要求一个序列的平方和（或者其他数学计算）的sum

a = [1,2,3]
sum_a = sum(x**2 for x in a)
# 直接使用生成器比下面更节约内存
s_a = sum([x*x for x in a])

# 其他的转换如求最大值
students = [
    {'name': 'zhangsan', 'id': '125605', 'score':48.5},
    {'name': 'lisi', 'id': '125612', 'score':75.2},
    {'name': 'wangwu', 'id': '125624', 'score':68.9},
    {'name': 'hansi', 'id': '125605', 'score':54.5},
    {'name': 'wangsi', 'id': '125612', 'score':89.2},
    {'name': 'leisi', 'id': '125624', 'score':36.9},
    {'name': 'qizha', 'id': '125605', 'score':53.5},
    {'name': 'renme', 'id': '125612', 'score':85.2},
    {'name': 'taingao', 'id': '125624', 'score':64.9},
]

max_score = max(stu['score'] for stu in students)

if __name__ == '__main__':
    print(sum_a)
    print(max_score)
    # 14
    # 89.2

物理学上的压力，是指发生在两个物体的接触表面的作用力，或者是气体对于固体和液体表面的垂直作用力，或者是液体对于固体表面的垂直作用力。习惯上，在力学和多数工程学科中，“压力”一词与物理学中的压强同义。
主要单位
A. 压力
国际单位：“牛顿”，简称“牛”，符号“N”；
B. 压强
国际单位：“帕斯卡”，简称“帕”，符号“Pa ”；
换算 　1帕(Pa)=1N/㎡；
1兆帕(MPa)=145磅/平方英寸(psi)=10.2千克力/平方厘米(kgf/c㎡)=10巴(bar)=9.8大气压(at m)
1磅/英寸2(psi)=0.006895兆帕(MPa)=0.0703千克/平方厘米(kg/c㎡)=0.0689巴(bar)=0.068大气压(atm)；
1巴(bar)=0.1兆帕(MPa)=14.503磅/平方英寸(psi)=1.0197千克/平方厘米(kg/c㎡)=0.987大气压(atm)；
1大气压(at m)=0.101325兆帕(MPa)=14.696磅/平方英寸(psi)=1.0333千克/平方厘米(kg/c㎡)=1.0133巴(bar)；
1毫米汞柱(mmHg)=133.33帕(Pa)；
在工程中几种常见压力单位换算关系如下：
1MPa=106Pa≈145psi≈10.2kgf/cm²
1kgf/cm²=98.067kPa≈98kPa
1psi(1bf/in²)=6.8948kPa≈6.9kPa
1mmH2O=9.8067Pa≈9.8Pa