标签：数组 lock 虚拟 另一个 log after 集合 编写程序 自己的
编程方法大概分三种
1.面向对象
2.面向过程
3.函数式编程
这三种编程方法都有自己的特点
面向对象 类 class
面向过程 过程 def
函数式编程 函数 得分
函数的定义 ：
数学函数的定义：一般的，在一个变化过程中，如果有两个变量x和y，并且对于x的么一个确定的值，y都有唯一确定的值相对应，那么我们就把x称为自变量，y是x的函数。自变量x的取值范围叫做这个函数的定义域
编程语言中定义：函数式逻辑结构化和过程化的一种编程方法
#python中函数的定义方法 def test(x): ‘‘‘The function definitions‘‘‘ x+=1 return x #def: 定义函数的关键字 #test: 函数名 #‘‘‘ ‘‘‘:文件描述 #x+=1：代码或程序的处理逻辑 #return： 定义返回值
函数式编程：先定义一个数字函数然后按照这个数学模型用编程语言来实现它
过程是没有返回值的函数
在py中过程被隐式的返回None，也成也被当成了函数
#函数 def func1(): ‘‘‘testing‘‘‘ print(‘in the funcl‘) return 0 #过程 没有返回值的函数 def func2(): ‘‘‘testing‘‘‘ print(‘in the func2‘) x=func1() y = func2() print(‘from func1 return is %s‘ %x )#from func1 return is 0 print(‘from func1 return is %s‘ %y )#from func1 return is None
面向过程：用def定义的逻辑过程中，拼接起来 使用时调用函数名
3为什么要使用函数
没有函数的编程只是在写逻辑（功能），如果想重用你的逻辑不应函数只能是拷贝
# Author:Zhiyu Su import time def logger(): time_format = ‘%Y-%m-%d %X‘ time_current = time.strftime(time_format) with open (‘a.txt‘,‘a+‘) as f: f.write(‘%s end action\n‘ %time_current) def test1(): print( ‘tesst1 staring action...‘) logger() def test2(): print (‘test2 staring action...‘) logger() def test3(): print (‘test3 staring action...‘) logger() test1() test2() test3()
使用函数的三大优点
1.代码重用
2.保持
3.简洁
函数返回值
# Author:Zhiyu Su def test1(): print(‘in the test1‘) def test2(): print(‘in the test2‘) return 0 print(‘in the test2‘)#return返回值后面不执行 def test3(): print(‘in the test3‘) return 1,‘hello‘,[‘alex‘,‘wuqeqi‘],{‘name‘:‘alex‘} x = test1() y = test2() z = test3() print(x) #None print(y) #0 print(z) #（1,‘hello‘,[‘alex‘,‘wuqeqi‘],{‘name‘:‘alex‘}）
总结：
返回值=0；返回None
返回值=1；返回object
返回值>1；返回tuple
函数的调用
调用方法：
1.test（）执行，（）表示调用函数test，（）内可以有参数也可以没有
参数：
1.形参和实参
形参：形式参数，不是实际存在，是虚拟变量。在定义函数和函数体的时候使用形参，目的是在函数调用时接受实参（实参个数，类型应与实参一一对应）
实参：实际参数，调用函数传递给函数的参数，可以是常量，表达式，函数，传给形参
区别：形参是虚拟的，不占内存空间，形参变量只有在被调用是时才分到内存单元，实参是一个变量占用内存空间，数据传送单向，实参传给形参不能传给实参
2.位置参数和关键字（标准调用：实参与形参一一对应，关键字调用：位置无需固定）
3.默认参数：非必传参数
def test(x,y=2): #默认参数特点：调用函数的时候，默认参数非必须转递 print(x) print(y) test(1,3)
4.参数组
*args#列表形式
*arge 接受n个关键字参数 def test(*args): print(args) test(1,2,3,4,5) test (*[1,2,3,4,6]) def test1(x,*args): print(x) print(args) test1(1,2,3,45,6)
**kwargs#把N个关键资参数，转换为字典
**kwargs 把n个关键字参数，转换成字典方式 def test2(**kwargs): print(kwargs) print(kwargs[‘name‘]) test2(name=‘alex‘,age = 8,sex=‘f‘) test2(**{‘name‘:‘alex‘,‘age‘ : 8})
def test3(name,age=18,*args,**kwargs): print(name) print(age) print(args) print(kwargs) logger(‘est3‘) def logger(source): print(‘from %s‘%source) test3(‘alex‘,151,8,hobby = ‘tesla‘)
注意：关键参数必须放在位置参数之后
局部变量和全局变量
def change_name(name): print(‘before change‘,name) name = ‘Alex li‘ #这个函数就是这个变量的作用域 age = 23 print(‘after changge ‘,name) name = ‘alex‘ change_name(name) print(name)
输出
before change alex
after changge Alex li
alex #name改了为什么还是alex
全局与局部变量
school = ‘oldboy edu.‘ def change_name(name): global school school = ‘mage.edu‘ print(‘before change‘,name,school) name = ‘Alex li‘ #这个函数就是这个变量的作用域 age = 23 print(‘after changge ‘,name) name = ‘alex‘ change_name(name) print(name) print(school)
注意：尽量不要在局部里申明全局变量 程序复杂后会很难调试
列表 字典 集合 类 数据都可以在局部变量里修改（除了字符串和整数）
names = [‘alex‘,‘jack‘,‘rain‘] def change_name(): names[0]=‘金角大王‘ print(‘inside func‘,names) change_name() #inside func [‘金角大王‘, ‘jack‘, ‘rain‘]
print(names) #[‘金角大王‘, ‘jack‘, ‘rain‘]
递归
在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数
def calc(n): print(n) if int(n/2) ==0: return n return calc(int(n/2)) calc(10) 输出： 10 5 2 1
递归特性:
1. 必须有一个明确的结束条件
2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少
3. 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）
函数式编程
函数是Python内建支持的一种封装，我们通过把大段代码拆成函数，通过一层一层的函数调用，就可以把复杂任务分解成简单的任务，这种分解可以称之为面向过程的程序设计。函数就是面向过程的程序设计的基本单元。
函数式编程中的函数这个术语不是指计算机中的函数（实际上是Subroutine），而是指数学中的函数，即自变量的映射。也就是说一个函数的值仅决定于函数参数的值，不依赖其他状态。比如sqrt(x)函数计算x的平方根，只要x不变，不论什么时候调用，调用几次，值都是不变的。
Python对函数式编程提供部分支持。由于Python允许使用变量，因此，Python不是纯函数式编程语言。
一、定义
简单说，"函数式编程"是一种"编程范式"（programming paradigm），也就是如何编写程序的方法论。
主要思想是把运算过程尽量写成一系列嵌套的函数调用。举例来说，现在有这样一个数学表达式：
(1 + 2) * 3 - 4
传统的过程式编程，可能这样写：
var a = 1 + 2;
var b = a * 3;
var c = b - 4;
函数式编程要求使用函数，我们可以把运算过程定义为不同的函数，然后写成下面这样：
var result = subtract(multiply(add(1,2), 3), 4);
这段代码再演进以下，可以变成这样
add(1,2).multiply(3).subtract(4)
这基本就是自然语言的表达了。再看下面的代码，大家应该一眼就能明白它的意思吧：
(1 + 2) * 3 - 4
传统的过程式编程，可能这样写：
var a = 1 + 2;
var b = a * 3;
var c = b - 4;
函数式编程要求使用函数，我们可以把运算过程定义为不同的函数，然后写成下面这样：
var result = subtract(multiply(add(1,2), 3), 4);
这段代码再演进以下，可以变成这样
add(1,2).multiply(3).subtract(4)
这基本就是自然语言的表达了。再看下面的代码，大家应该一眼就能明白它的意思吧：
merge([1,2],[3,4]).sort().search("2")
高阶函数
变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。
def add(a,b,f): return f(a)+f(b) res=(add(3,-6,abs)) print(res)
标签：数组 lock 虚拟 另一个 log after 集合 编写程序 自己的
原文地址：http://www.cnblogs.com/szy413227820/p/7425075.html
