函数和函数式编程

最新推荐文章于 2022-04-28 23:13:32 发布
最新推荐文章于 2022-04-28 23:13:32 发布
阅读量133 收藏
点赞数
分类专栏： Python语言本身
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42006387/article/details/115004020
版权

文章目录

函数和函数式编程

函数

参数传递

不可变对象和可变对象

  • 对于不可变对象来说，实参和被修改后的形参是两个对象。**对于变量的重新的赋值操作，相当于重新生成了一个新的对象，**类似于值传递。

    • 数值类型，tuple类型，string类型**等都是不可变对象
    def fun(arg):
    print('传入参数的id：{}'.format(id(arg)))
    arg = 1 # 修改参数的值
    print('修改后参数的id：{}'.format(id(arg)))
    return arg

a = 2
print('函数被调用之前的实参的id：{}'.format(id(a)))
res = fun(a)
print('函数被调用之后的实参的id：{}'.format(id(a)))
print('函数返回的形参的id:{}'.format(id(res)))

# 结果
函数被调用之前的实参的id：1901637888
传入参数的id：1901637888
修改后参数的id：1901637856
函数被调用之后的实参的id：1901637888
函数返回的形参的id：1901637856

  • 对于可变对象来说，实参和被修改后的形参是一个对象，类似于引用传递

    • 列表list，字典dict等都是可变对象。
    def fun(arg):
    print('传入参数的id：{}'.format(id(arg)))
    arg.append(1) # 修改参数的值
    print('修改后参数的id：{}'.format(id(arg)))
    return arg

a = [2]
print('函数被调用之前的实参的id：{}'.format(id(a)))
res = fun(a)
print('函数被调用之后的实参的id：{}'.format(id(a)))
print('函数返回的形参的id:{}'.format(id(res)))

# 结果
函数被调用之前的实参的id：2180016515784
传入参数的id：2180016515784
修改后参数的id：2180016515784
函数被调用之后的实参的id：2180016515784
函数返回的形参的id：2180016515784

  • 结论：对于不可变对象，如果进行重新指向，则是生成实参和形参是两个对象；对于可变对象，形参和实参是同一个对象。

参数

必须参数
  • 略
关键字参数
  • 略
默认参数
  • 略
不定长参数
封包与解包
封包

  • 将多个值付给一个变量时，python会自动将这些值封装成元组，这个特性称为封包

    a = 1, 2, 'a'
print(a, type(a)) 

# 结果
(1, 2, 'a') <class 'tuple'>

  • 当函数有多个返回值是，封包

    def fun():
    return 1, 2, 'a'
res = fun()
print(res, type(res))

# 结果
(1, 2, 'a') <class 'tuple'>
解包

  • 接受函数返回值

    def test():
    return 1, 2, 3

a, b, c = test()
print(a, b, c) 

# 结果
1 2 3

    def test():
    return 1, 2, 3

a, *b = test()
print(a, b)

# 结果
1 [2, 3]

  • 传递参数

    def fun1(*args):
    print(type(args), args)
    
a = (2, 4, 6)
func1(*a)    # 将元组解包成可变参数

# 结果
<class 'tuple'> (2, 4, 6)

    def fun2(**kwargs):
    print(type(kwargs), kwargs)

b = {'一': 1, '二': 2}
fun2(**b)  # 将字典解包成关键字参数

# 结果
<class 'dict'> {'一': 1, '二': 2}
带一个星号*

  • 一般在函数定义时，用 *args 表示。

    • 此时args定义在函数的中的数据类型是元组tuple类型。
    def fun(*args):
    print(type(args), args)

# 方式一
fun(2, 4, 6)
# 方式二
a = (2, 4, 6)
fun(*a) # 将元组解包成可变参数

# 结果
<class 'tuple'> (2, 4, 6)
<class 'tuple'> (2, 4, 6)
带两个星号**

  • 一般在函数定义时，用 **kwargs表示

    • 此时kwargs定义咋函数中的数据类型是字典类型
    def fun(**kwargs):
    print(type(kwargs), kwargs)

# 方式一
fun(a=1, b=2)
# 方式二
b = {'a': 1, 'b': 2}
fun(**b)  # 将字典解包成关键字参数

# 结果
<class 'dict'> {'a': 1, 'b': 2}
<class 'dict'> {'a': 1, 'b': 2}

函数式编程

  • 重要特征：（1）将函数作为形参传入，（2）将函数作为返回值返回

返回函数

闭包
def outerFun(*args): # 定义外部函数，并接受不定长参数
    def innerFun(): # 定义内部函数
        ax = 0 # 定义局部变量
        for n in args: # 使用enclosing
            ax = ax + n
        return ax
    return innerFun # 返回内部函数

fun = outerFun(1, 2) # 使用返回的函数
res = fun() # 将返回的函数调用，并将函数的运行结果赋值给res
print(res)

# 结果
3

在函数outerFun中又定义了函数innerFun，并且，内部函数innerFun可以引用外部函数outerFun的参数和局部变量args，当outerFun返回函数innerFun时，相关参数和变量都保存在返回的函数中，这种称为“闭包（Closure）”

  • 注意点：返回时，写的是内部函数的函数名，而不是返回内部函数的调用。

装饰器 decorator

  • 由于函数也是一个对象，而且函数对象可以被赋值给变量，所以，通过变量也能调用该函数。

  • 基本形式，无参

    # 定义一个需要被包装的函数
def need_decorated_fun(num):
    print(num)

# 定义一个装饰器
def decorated(fun): # 装饰器的参数是一个被装饰函数的名称
    def wrapper(*args, **kwargs): # 具体的装饰实现，使用wrapper，接受不定长参数，封包
        print('function name：%s' % fun.__name__) # 打印被装饰函数的__name__属性，
                                                  # 函数增强
        return fun(*args, **kwargs) # 返回被装饰函数的运行结果，解包
    return wrapper

need_decorated_fun = decorated(need_decorated_fun)
need_decorated_fun(2)
print('修改后原需要被装饰函数的函数名为：%s' % need_decorated_fun.__name__)

# 结果
function name：need_decorated_fun
2
修改后原需要被装饰函数的函数名为：wrapper
    • 借助@符号，无参
    # 定义一个装饰器
def decorated(fun): # 装饰器的参数是一个被装饰函数的名称
    def wrapper(*args, **kwargs): # 具体的装饰实现，使用wrapper，接受不定长参数，封包
        print('function name：%s' % fun.__name__) # 打印被装饰函数的__name__属性，函数增强
        return fun(*args, **kwargs) # 返回被装饰函数的运行结果，解包
    return wrapper

# 使用@符号进行装饰需要被装饰的函数
@decorated
def need_decorated_fun(num):
    print(num)

need_decorated_fun(112)
print('修改后原需要被装饰函数的函数名为：%s' % need_decorated_fun.__name__)

# 结果
function name：need_decorated_fun
112
修改后原需要被装饰函数的函数名为：wrapper

    @decorated放在need_decorated_fun之上，相当于need_decorated_fun = decorated(need_decorated_fun)

  • 基本形式，有参

    # 定义一个需要被包装的函数
def need_decorated_fun(num):
    print(num)

# 定义一个装饰器,含参数
def para_decorated(para): # para表示需要额外传入的参数
    def decorated(fun): #装饰器的参数是一个被装饰函数的名称
        def wrapper(*args, **kwargs): # 具体的装饰实现，使用wrapper，接受不定长参数，封包
            print('additional parameter:%s' % para)
            print('function name：%s' % fun.__name__) # 打印被装饰函数的__name__属性，                                                       # 函数增强
            return fun(*args, **kwargs) # 返回被装饰函数的运行结果，解包
        return wrapper
    return decorated

need_decorated_fun = para_decorated('Para Decorated')(need_decorated_fun)

need_decorated_fun(112)
print('修改后原需要被装饰函数的函数名为：%s' % need_decorated_fun.__name__)

# 结果
additional parameter:Para Decorated
function name：need_decorated_fun
112
修改后原需要被装饰函数的函数名为：wrapper

    • 借助@符号，有参

      # 定义一个装饰器,含参数
def para_decorated(para): # para表示需要额外传入的参数
    def decorated(fun): #装饰器的参数是一个被装饰函数的名称
        def wrapper(*args, **kwargs): #具体装饰实现，用wrapper，接受不定长参数，封包
            print('additional parameter:%s' % para)
            print('function name：%s' % fun.__name__) # 打印被装饰函数__name__属性                                                       # 函数增强
            return fun(*args, **kwargs) # 返回被装饰函数的运行结果，解包
        return wrapper
    return decorated

@para_decorated('Para Decorated')
def need_decorated_fun(num):
    print(num)
    
need_decorated_fun(112)
print('修改后原需要被装饰函数的函数名为：%s' % need_decorated_fun.__name__)

# 结果
additional parameter:Para Decorated
function name：need_decorated_fun
112
修改后原需要被装饰函数的函数名为：wrapper

      @para_decorated('Para Decorated')放在need_decorated_fun之前，相当于need_decorated_fun = para_decorated('Para Decorated')(need_decorated_fun)

  • 存在问题：修改后原需要被装饰函数的函数名为：wrapper，我们希望即使需要被装饰的函数在装饰完毕后仍具有原来的函数名

    • 方式一：把原始函数的__name__等属性复制到wrapper()函数中，编写wrapper.__name__ = func.__name__这样的代码
    • 方式二：使用@functools.wraps(被装饰函数名)，在functools模块中

    在不需要现实定义函数的时候，传入匿名函数更方便

装饰器完整形式，无参
import functools
# 定义一个装饰器
def decorated(fun): # 装饰器的参数是一个被装饰函数的名称
    @functools.warps(fun) # 保证被装饰的函数的函数名不变  
    def wrapper(*args, **kwargs): # 具体的装饰实现，使用wrapper，接受不定长参数，封包
        print('function name：%s' % fun.__name__) # 打印被装饰函数的__name__属性，函数增强
        return fun(*args, **kwargs) # 返回被装饰函数的运行结果，解包
    return wrapper

# 使用@符号进行装饰需要被装饰的函数
@decorated
def need_decorated_fun(num):
    print(num)

need_decorated_fun(112)
print('修改后原需要被装饰函数的函数名为：%s' % need_decorated_fun.__name__)

# 结果
function name：need_decorated_fun
112
修改后原需要被装饰函数的函数名为：need_decorated_fun
装饰器完整形式，有参
import functools
# 定义一个装饰器,含参数
def para_decorated(para): # para表示需要额外传入的参数
    def decorated(fun): #装饰器的参数是一个被装饰函数的名称
        @functools.warps(fun) # 保证被装饰的函数的函数名不变
        def wrapper(*args, **kwargs): #具体装饰实现，用wrapper，接受不定长参数，封包
            print('additional parameter:%s' % para)
            print('function name：%s' % fun.__name__) # 打印被装饰函数__name__属性                                                       # 函数增强
            return fun(*args, **kwargs) # 返回被装饰函数的运行结果，解包
        return wrapper
    return decorated

@para_decorated('Para Decorated')
def need_decorated_fun(num):
    print(num)
    
need_decorated_fun(112)
print('修改后原需要被装饰函数的函数名为：%s' % need_decorated_fun.__name__)

# 结果
additional parameter:Para Decorated
function name：need_decorated_fun
112
修改后原需要被装饰函数的函数名为：need_decorated_fun

匿名函数

  • 格式：lambda 参数列表:表达式，函数的返回值是表达式的值
  • 本质：匿名函数本质上就是个函数，完全可以用显示定义的方式给出
f = lambda x:x*x # 将一个匿名函数赋值给一个对象
res = f(3) # 调用函数
print(res)

# 结果
9
  • 匿名函数，在一些高阶函数，或其他框架的函数会被经常性的使用

高阶函数

  • 变量可以指向函数；函数名也是变量；所以变量可以指向函数名
map

  • map(函数(仅含有一个参数)，Iterable对象)，返回值为Iterator

  • 其中传入的函数，含有一个参数，对应于Iterator中的每一个元素

  • 因为Iterator是惰性序列，可以通过list()函数将整个序列都计算出来，并返回一个list

    def fun(x):
    return  2 * x

res1 = map(fun, [1, 2])
print(type(res1))
print(res1)
res2 = list(res1) #通过list()函数将整个序列都计算出来，并返回一个list
print(res2)

# 结果
<class 'map'>
<map object at 0x000002719C6DD278>
[2, 4]

    • 使用匿名函数

      res1 = map(lambda x: 2 * x, [1, 2])
print(type(res1))
print(res1)
res2 = list(res1) #通过list()函数将整个序列都计算出来，并返回一个list
print(res2)

# 结果
<class 'map'>
<map object at 0x0000018901D5C7B8>
[2, 4]
reduce

  • reduce(函数(仅含有两个参数)，Iterable)

  • reduce把一个函数作用在一个序列[x1, x2, x3, ...]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算

  • 返回值是函数的返回值，并不是一个Iterator

    reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

  • reduce在funtools模块中

    from functools import reduce

def fun(x, y):
    return x + y

res1 = reduce(fun, [1, 2, 3, 4])
print(type(res1))
print(res1)

# 结果
<class 'int'>
10

    • 使用匿名函数

      from functools import reduce

res1 = reduce(lambda x,y: x - y, [1, 2, 3, 4])
print(type(res1))
print(res1)

# 结果
<class 'int'>
-8
filter

  • filter用于过滤序列，其中满足条件返回True的元素被保留下来，不满足条件返回False的元素不被保留

  • filter(函数(仅含一个参数), Iterable)

  • 其中函数仅含一个参数，对应Iterable中的每一个参数

  • 最终的返回值是一个Iterator，可以通过list()函数将整个序列都计算出来，并返回一个list

    def isOdd(x):
    return x % 2 == 1
res1 = filter(isOdd, [1, 2, 3, 4])#[1, 2, 3, 4] →isOdd→ [True, False, True, Flase]
								  #满足条件对应True位置上的元素被保留下来
print(type(res1))
print(res1)
res2 = list(res1) # #通过list()函数将整个惰性序列都计算出来，并返回一个list
print(res2)

# 结果
<class 'filter'>
<filter object at 0x000001A98A27D278>
[1, 3]
sorted

  • 排序的核心是比较两个元素的大小。如果是数字，我们可以直接比较；

  • 如果是字符串或者两个dict呢？直接比较数学上的大小是没有意义的，因此，比较的过程必须通过函数抽象出来

  • sorted(Iterable, key, reverse=False)，关键就是如何写这个key；其中Iterable中的每个元素之间都是应该可比较的。

    • 如数值1和字符串'1'之间不可比较，此时运用在key中的比较，会产生TypeError异常

  • 最终的返回结果是列表list类型，而不是Iterator

    • 默认情况

      res = sorted([1, 3, 2]) # 数值默认按数值由小到大排序
print(res)

# 结果
[1, 2, 3]

      res = sorted(['1', 'a', 'A']) # 字符串默认按ASCII码由小到大排序
print(res)

# 结果
['1', 'A', 'a']

    • 按照key对应的函数规则进行排序

      • key指向的函数中仅包含一个参数时，该参数对应Iterable中的每个第一级元素
      res =  sorted([6, 5, -1, 9, -11], key=abs) #在函数abs的作用下，各元素的权重为
                                        #[6, 5, 1, 9, 11],对应权重的权重越大，越靠后
print(res)   

# 结果
[-1, 5, 6, 9, -11]

      res = sorted([6, 5, -1, 9, -11], key=lambda x: -x)
                                #对应的权重变为[-6, -5, 1, -9, 11],
 								#然后按照权重排序，权重越大，越靠后
print(res)

# 结果
[9, 6, 5, -1, -11]

    • 字典按照key或value排序

      • 字典按照key排序

        my_dict = {"k2": 5, "k3": 6, "k1": 4, "k0": 3}
new_list = sorted(my_dict.items(), key=lambda x:x[1])
		        # my_dict.items()将键值对转为可迭代的对象，[(键，值),...]
				# x表示items中的一个元素, x[0]表示按第一个位置key排序
print(my_dict)
print(my_dict.items())
print(new_list)

# 结果
{'k2': 5, 'k3': 6, 'k1': 4, 'k0': 3}
dict_items([('k2', 5), ('k3', 6), ('k1', 4), ('k0', 3)])
[('k0', 3), ('k1', 4), ('k2', 5), ('k3', 6)]

      • 字典按照value排序

        my_dict = {"k2": 5, "k3": 6, "k1": 4, "k0": 3}
new_list = sorted(my_dict.items(), key=lambda x:x[1])
		        # my_dict.items()将键值对转为可迭代的对象，[(键，值),...]
				# x表示items中的一个元素, x[1]表示按第二个位置value排序
print(my_dict)
print(my_dict.items())
print(new_list)

# 结果
{'k2': 5, 'k3': 6, 'k1': 4, 'k0': 3}
dict_items([('k2', 5), ('k3', 6), ('k1', 4), ('k0', 3)])
[('k0', 3), ('k1', 4), ('k2', 5), ('k3', 6)]

偏函数

  • 偏函数所在模块functools

    a1 = int('123') #示123在十2进制下对应的十进制的数，1*10^2+2*10^1+3*10^0=123
a2 = int('123', base=8) #表示123在8进制下对应的十进制的数，1*8^2+2*8^1+3*8^0=83
print(a1)
print(a2)

# 结果
123
83

  • 自定义个函数

    def int2(x, base=2):
    return int(x, base) #返回一个x在2进制下表示的十进制的数

res = int2('1001')
print(res)

# 结果
9

  • 使用偏函数

    import functools
int2 = functools.partial(int, base=2)
res = int2('1001')
print(res)

# 结果
9

变量访问顺序：LEGB

  • LEGB其他python解释器查找变量的顺序：LEGB

    • Local：函数内部作用域

    • Enclosing function：内嵌函数对函数内部变量的应用，即闭包（闭合函数）

    • Global：全局作用域

    • Build-in：python解释器默认导入的一些list/tuple等

第七个bug
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
函数式编程和响应式编程
学无止境
06-12 1万+
在程序开发中，a＝b＋c;赋值之后，b或者c的值变化后，a的值不会跟着变化。响应式编程目标就是，如果b或者c的数值发生变化，a的数值会同时发生变化。函数式编程函数式编程是一系列被不公平对待的编程思想的保护伞，它的核心思想是，它是一种将程序看成是数学方法的求值、不会改变状态、不会产生副作用（后面我们马上会谈到）的编程方式。FP 核心思想强调： 声明式代码 —— 程序员应该关心是什么，让编译器和运行环境...
Python中的匿名函数和函数式编程
12-20
在Python编程语言中，匿名函数和函数式编程是两种强大的工具，它们可以帮助程序员编写简洁而高效的代码。本文将深入探讨这两个概念。 首先，让我们来理解什么是匿名函数。在Python中，匿名函数通常被称为`lambda`...
函数相关的笔试编程题目
kaiser king的博客
12-26 333
函数相关的笔试编程题目 题目需求: 对于一个十进制的正整数， 定义f(n)为其各位数字的平方和，如: f(13) = 1** 2 + 3** 2 = 10 f(207) = 2** 2 + 0** 2 + 7** 2 = 53 下面给出三个正整数k，a, b,你需要计算有多少个正整数n满足a<=n<=b，且k*f(n)=n 输入: 第一行包含3个正整数k，a, b, k>=1, ...
函数式编程
weixin_38255079的博客
01-11 4017
什么是函数式编程 ​ 函数式编程(Functional Programming, FP)，FP 是编程范式之一，我们常听说的编程范式还有面向过程编程、面向对象编程。 面向对象编程的思维方式：把现实世界中的事物抽象成程序世界中的类和对象，通过封装、继承和多态来演示事物事件的联系 函数式编程的思维方式：把现实世界的事物和事物之间的联系抽象到程序世界（对运算过程进行抽象） 程序的本质：根据输入通过某种运算获得相应的输出，程序开发过程中会涉及很多有输入和输出的函数 x -> f(联系、映射) -&g
前端开发之函数式编程
薛定谔的猫-前端领域
04-28 1247
通用的函数式编程语言，是Haskell，被函数式原教旨主义者认为是纯函数式语言。函数式编程的思想也不断影响着传统编程语言，比如Java 8开始支持lambda表达式，而函数式编程的大厦最初就是基于lambda计算构建起来的。函数式编程对于前端来说是必选项，后端则不必。 React框架的组件从很早开始就是不仅支持类式组件，也支持函数式的组件。而后React Hooks的出现，使得函数式编程思想越来越变得不可或缺。 无副作用 这是函数式编程的精髓所在。 无副作用的函数应该符合下面的特点：
Java函数式编程和Lambda表达式
程序那些事
10-15 1万+
文章目录什么是函数式编程Lambda表达式@FunctionalInterface函数式接口Lambda表达式的格式方法引用 什么是函数式编程 相信大家都使用过面向对象的编程语言，面向对象编程是对数据进 行抽象，而函数式编程是对行为进行抽象。函数式编程让程序员能够写出更加容易阅读的代码。那什么时候函数式编程呢？ 函数式编程是一种编程的方法论，主要是将行为编写成一个个的函数。 什么是函数？ 函数就是...
什么是函数式编程？
热门推荐
Archimelan的博客
08-22 1万+
当我们说起函数式编程来说，我们会看到如下函数式编程的长相： 函数式编程的三大特性： immutable data 不可变数据：像Clojure一样，默认上变量是不可变的，如果你要改变变量，你需要把变量copy出去修改。这样一来，可以让你的程序少很多Bug。因为，程序中的状态不好维护，在并发的时候更不好维护。（你可以试想一下如果你的程序有个复杂的状态，当以后别人改你代码的时候，是很容易出bug的...
函数式编程思想概论
灵动的艺术的博客
06-26 4676
函数式编程思想概论前言函数λ 演算λ项绑定变量和自由变量约简α 变换β 约简η 变换纯函数、副作用和引用透明性函数式编程与并发编程总结 原文地址 前言 在讨论函数式编程（Functional Programming）的具体内容之前，我们首先看一下函数式编程的含义。在维基百科上，函数式编程的定义如下：“函数式编程是一种编程范式。它把计算当成是数学函数的求值，从而避免改变状态和使用可变数据。它是一种声...
什么是函数式编程？总结
weixin_44811288的博客
08-03 5252
什么是函数式编程 函数式编程(Functional Programming, FP)，FP 是编程范式之一，我们常听说的编程范式还有面向过程编程、面向对象编程。 面向对象编程的思维方式：把现实世界中的事物抽象成程序世界中的类和对象，通过封装、继承和 多态来演示事物事件的联系 函数式编程的思维方式：把现实世界的事物和事物之间的联系抽象到程序世界（对运算过程进行抽 象） 程序的本质：根据输入通过某种运算获得相应的输出，程序开发过程中会涉及很多有输入和 输出的函数 x -> f(联系、映射) ->
什么是函数式编程?
鸭梨的博客
06-19 3562
函数式编程的英文翻译是 Functional Programming。 那到底什么是函数式编程呢？ 在前面的章节中，我们讲到，面向过程、面向对象编程并没有严格的官方定义。在当时的讲解中，我也只是给出了我自己总结的定义。而且，当时给出的定义也只是对两个范式主要特性的总结，并不是很严格。实际上，函数式编程也是如此，也没有一个严格的官方定义。所以，接下来，我就从特性上来告诉你，什么是函数式编程。 严格上来讲，函数式编程中的“函数”，并不是指我们编程语言中的“函数”概念，而是指数学“函数”或者“表达式”（比如，y=
编程范式和函数式编程
幸运的拾荒者
01-06 959
编程范式 函数式编程是一种编程范式，我们常见的编程范式有 命令式编程（Imperative programming） 函数式编程 逻辑式编程 命令式编程 命令式编程是面向计算机硬件的抽象，有变量（对应着存储单元），赋值语句（获取，存储指令），表达式（内存引用和算术运算）和控制语句（跳转指令） 一句话，命令式程序就是一个冯诺依曼机的指令序列 常见的面向对象编程也是一种命令式编程
Scala函数式编程
03-18
　“Scala和Java8开发者的函数式编程指南！” 　——William E. Wheeler， TekSystems 　“本书向你展示了提升Scala技能的方法和理念，它已超过‘更好的Java’。” 　——Fernando Dobladez， Code54 　“里面的...
函数式编程思维.pdf_函数式编程_函数式编程思维_
10-03
函数式编程是一种编程范式，它强调将计算视为数学函数的评估，并避免可变状态和副作用。这种编程风格鼓励使用纯函数，即那些输入相同输出始终一致且不改变外部状态的函数。函数式编程有着深厚的理论基础，源于λ演算...
javascript指南和函数式编程
01-17
本指南将深入探讨JavaScript的高效编程和函数式编程这两个重要主题，帮助开发者提升技能，实现更优雅、更可维护的代码。 《Effective JavaScript(中文版).pdf》这本书是JavaScript编程的经典之作，它包含了68个具体...
JavaScript函数式编程
11-17
JavaScript函数式编程
常用的数字，字符和ASCII之间的转换
Tiko的博客
03-12 2761
文章目录常用的数字，字符和ASCII之间的转换 常用的数字，字符和ASCII之间的转换 整数字符串转整数 int('123') 浮点数字符串转浮点数 float('1.23') 数字转字符串 str(123) str(1.23) ASCII码转字符 chr(97) 字符转ASCII ord('a') ...
python面向对象（访问控制：public，protected，private）
Tiko的博客
03-22 998
文章目录python面向对象3面向对象（访问权限）public（没有下划线）访问控制protected访问控制private访问控制其他说明 python面向对象3 面向对象（访问权限） 与 C++、C＃、Java 等语言相似，Python 支持将类的属性和方法设置成特定的访问权限，但不是通过关键字区分，而是使用一套约定式的规则 属性或方法为公有（public）属性或方法，可在类的外部直接访问，在类内部以“self.属性名或方法名”的方式使用 在Python中可以通过在变量属性以及方法属性是否有下划线“_
文件和目录操作（os，os.path），文件读写（open，with），序列化（pickle，json）
Tiko的博客
03-20 598
文章目录IO操作目录和文件（os，os.path）操作文件和目录文件读写（open）常见格式完整格式file打开模式modefile常用的函数注意StringIO和BytesIOStringIOBytesIO序列化（pickle，json）序列化反序列化注意Json（dumps，loads）Json序列化基本数据类型序列化反序列化Json序列化实例对象需要定制Json序列化反序列化需要定制Json反序列化函数说明常见的文件操作读操作写操作 IO Input/Output，也就是输入和输出；IO编程中，St
集合set的常见操作
Tiko的博客
03-09 429
文章目录set的常见操作特点创建常见内置方法 set的常见操作 特点 以大括号{}表示 无序，无重复元素 创建 创建一个空集合 val = set() 创建含若干元素的集合 val = {elmnt1, elmnt2,...} s = {1, 2, 2, 3} print(s) # 结果 {1,2} val = set(序列) s1 = set('abbc') s2 = set([1, 2, 2, 3]) print(s) # 结果 {'a', 'b', 'c'} {1, 2
go语言的闭包函数和函数式编程
最新发布
07-27
函数式编程强调使用纯函数，即不依赖于外部状态和副作用的函数，这样可以提高代码的可读性、可维护性和并发性。 在Go语言中，闭包函数和函数式编程可以结合使用。通过闭包函数，我们可以在函数内部定义其他函数，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值