Python的lambda表达式学习日记

（有任何问题欢迎留言或私聊 && 欢迎交流讨论哦

闲话:

 老是没看懂lambda是个啥东西，每次都要去百度。
 干脆自己写一个以后看自己哒。

引入:

def F(x):
  return x*x
f = lambda x: x * x

def G(x, y):
  return x+y
g = lambda x, y: x + y

print( g(f(3), 4) )  #输出13
print( G(F(3), 4) )  #输出13

 应该有个简单的印象了吧~
 lambda表达式就是简化函数的。但是仅当函数只有一行的时候
 这一行能做多少事情，就看个人能力了~

栗子:

lambda x: x*x
此表达式相当于有一个函数，它的参数是x，然后返回值是x*x
lambda x, y: x+y
此表达式相当于有一个函数，它的参数是x, y，然后返回值是x+y

一段代码:

def quadratic(a, b, c):
  return lambda x: a*x*x + b*x + c

f = quadratic(1, -1, 2)
#三种形式答案一样
print( f(5) )
print( quadratic(1, -1, 2)(5) )
print( (lambda x: 1*x*x + -1*x + 2)(5) )

这里 f 就是一个函数: f(x) = a*x^2 + b*x + c
quadratic返回的是一个lambda表达式，后面跟着的括号里的内容就是参数！

又一段代码:

countries = []
file = open("country_zw.csv","r",encoding='UTF-8')
for line in file:
  line = line.strip()  #去掉空格
  ar = line.split(',')  #分割
  name = ar[1]
  capt = ar[3]
  popu = int(ar[4])
  countries.append( (name, capt, popu) )

countries.sort(key = lambda country:country[2])  #排序参数

for country in countries:
  print(country)

提一下：

python3 取消了cmp 参数，参考：https://www.zhihu.com/question/30389643?sort=created

#元组内(e1, e2, e3)的优先级排列为: e1 > e2 > e3
sorted(s, key=lambda x: (x.isdigit(),x.isdigit() and int(x) % 2 == 0,x.isupper(),x)
#input: 'asdf234GDSdsf23'
#output: 'addffssDGS33224'

python的sort()和sorted()用法解释

Python list内置sort()方法用来排序，也可以用python内置的全局sorted()方法来对可迭代的序列排序生成新的序列。

也就是说sort()方法只有list能使用。

sort()和sorted()默认从小到大排序，也就是小的优先级比较大

key参数
从python2.4开始，list.sort()和sorted()函数增加了key参数来指定一个函数，此函数将在每个元素比较前被调用。

>>> sorted("This is a test string from Andrew".split(), key=str.lower)
['a', 'Andrew', 'from', 'is', 'string', 'test', 'This']

>>> student_tuples = [
        ('john', 'A', 15),
        ('jane', 'B', 12),
        ('dave', 'B', 10),
]
>>> sorted(student_tuples, key=lambda student: student[2])   # sort by age
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

同样的技术对拥有命名属性的复杂对象也适用，例如：

>>> class Student:
        def __init__(self, name, grade, age):
                self.name = name
                self.grade = grade
                self.age = age
        def __repr__(self):
                return repr((self.name, self.grade, self.age))
>>> student_objects = [
        Student('john', 'A', 15),
        Student('jane', 'B', 12),
        Student('dave', 'B', 10),
]
>>> sorted(student_objects, key=lambda student: student.age)   # sort by age
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

Operator 模块函数
python提供了一些方便的函数来使得访问方法更加容易和快速。
operator模块有itemgetter，attrgetter，从2.6开始还增加了methodcaller方法。
使用这些方法，上面的操作将变得更加简洁和快速：

>>> from operator import itemgetter, attrgetter
>>> sorted(student_tuples, key=itemgetter(2))
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
>>> sorted(student_objects, key=attrgetter('age'))
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

operator模块还允许多级的排序，例如，先以grade，然后再以age来排序：

>>> sorted(student_tuples, key=itemgetter(2), reverse=True)
[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
>>> sorted(student_objects, key=attrgetter('age'), reverse=True)
[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]

排序的稳定性和复杂排序
从python2.2开始，排序被保证为稳定的。意思是说多个元素如果有相同的key，则排序前后他们的先后顺序不变。
你可以构建多个步骤来进行更复杂的排序，例如对student数据先以grade降序排列，然后再以age升序排列。

>>> s = sorted(student_objects, key=attrgetter('age'))     # sort on secondary key
>>> sorted(s, key=attrgetter('grade'), reverse=True)       # now sort on primary key, descending
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]