python函数式编程一

一、python中or和and的使用

• 1、使用方式

    result = a or b
    result = a and b

• 2、or计算规则
  • 当a为真的时候就直接返回a的值,否则返回b的值
• 3、and计算规则
  • 当a为真的时候返回b,当a为假的时候返回a
• 4、python为False的值
  • None
  • False
  • 0
  • ''/()/[]
  • {}

二、python中的三木运算

• 1、格式

    result = 条件为真时返回的结果 if 条件 else 条件为假返回结果

• 2、使用案例

    result = '我是真的' if True else '我是假的'

三、python中函数的定义方式

• 1、常规函数定义方式

    def 函数名(参数):
        pass

• 2、lambda函数

    赋值接收的变量 = lambda 参数列表...: 函数返回值
    f = lambda x, y: x + y

四、函数传参的几种形式

• 1、无参函数

    def foo():
        pass

• 2、固定参数(形参与实参一一对应)

    def foo(name, age, gender):
        pass

    if __name__ == '__main__':
        foo('张三', 20, '男')

• 3、可变参数(python中习惯使用关键词*args来表示)
  

  在函数体中接收的是一个tuple元祖

    def foo(*args):
        print(args)

    if __name__ == '__main__':
        foo(1,2,3,4,5)

• 4、关键字参数(python中习惯使用关键词**kwargs来表示)
  

  关键字参数传递到函数中是以dict的方式展示

    def bar(**kwargs):
        print(type(kwargs))
        print(kwargs)

    if __name__ == '__main__':
        bar(name='张三', gender='男', age=20)

    # <class 'dict'>
    #{'name': '张三', 'gender': '男', 'age': 20}

• 5、固定参数、可变参数、关键字参数混合使用
  

  原理

  • 1.先会把实参不能少于形参固定参数的个数(少于会直接报错)
  • 2.把实参优先给固定参数,多余的给可变参数
  • 3.如果使用了关键词传递的参数就是关键字参数中

    def test(name, age, *args, **kwargs):
        print(name, age)
        print(args)
        print(kwargs)

    if __name__ == '__main__':
        test(1, 2, 3, 4, 5, address='广东', mobile = '110')

• 6、默认参数

    def test(name, age=20):
        print(name, age)

    if __name__ == '__main__':
        test('哈哈')

五、函数的返回值

• 1、如果没指定函数返回就返回None
• 2、函数使用return的返回值只有一个
• 3、如果一个函数可以返回一个列表、元祖、字典
• 4、函数可以使用yield返回多个值

六、python中常见的内置函数

• 1、map函数(遍历可迭代对象返回一个可迭代对象)
  • 使用格式

        map(函数, iterable...)

 *  使用案例

        list1 = [1, 2, 3, 4, 5]
        list2 = [6, 7, 8, 9, 10]

        result1 = map(lambda x: x ** 2, list1)
        print(list(result1))

        result2 = map(lambda x, y: x + y, list1, list2)
        print(list(result2))

        tuple1 = (1, 2, 3, 4)
        print(list(map(lambda x: x ** 2, tuple1)))

• 2、filter函数(过滤数据)
  • 使用格式

        filter(函数, iterable...)

 *  使用案例

        list1 = [1, 2, 3, 4, 5]
        print(list(filter(lambda x: x % 2 == 0, list1)))
        print([x for x in list1 if x % 2 == 0])

 *  过滤数据推荐使用列表推导式

        list1 = [1, 2, 3, 4, 5]
        print([x for x in list1 if x % 2 == 0])

• 3、reduce函数(连续计算)注意需要先导包
  • 1、定义格式

        from functools import reduce

        result = reduce(函数, iterable, 初始化值)

 *  2、使用案例

        from functools import reduce

        if __name__ == "__main__":
            list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9]
            result = reduce(lambda x, y: x + y, list1)
            print(result)
            result2 = reduce(lambda x, y: str(x) + str(y), list1, '==')

• 4、sorted排序函数
  • 列表排序

        sorted([36, 6, -12, 9, -22])  列表排序

 *  字符排序

        sorted(['bob', 'about', 'Zoo', 'Credit'])  #字符串排序，按照ASCII的大小排序

 *  逆向排序(相当于先升序排序后,然后在反向)

        sorted([36, 6, -12, 9, -22], reverse=True)

 *  添加函数排序使用关键参数`key`(注意这个地方的函数只能传递一个参数的函数)

        L = [{1: 5, 3: 4}, {1: 3, 6: 3}, {1: 1, 2: 4, 5: 6}]
        print(sorted(L, key=lambda x: len(x)))

 *  `key`函数需要传递多个函数的时候

        from functools import cmp_to_key

        if __name__ == "__main__":
            L = [{1: 5, 3: 4}, {1: 3, 6: 3}, {1: 1, 2: 4, 5: 6}]
            print(sorted(L, key=cmp_to_key(lambda x, y: x[1] > y[1])))

 *  元祖、字典使用排序

        a = [('b', 2), ('a', 1), ('c', 0)]
        print(sorted(a, key=lambda x: x[0]))
        print(sorted(a, key=lambda x: x[1]))

        b = [{'city': '深圳', 'tem': 40}, {'city': '广州', 'tem': 30}]
        print(sorted(b, key=lambda x: x['tem']))

七、更多关于作者文章请访问