编程方法

面向对象               独门秘籍:类      class
面向过程               独门秘籍:过程    def
函数式编程             独门秘籍:函数    def

函数定义

1、数学函数:
x是自变量,y是因变量;自变量的函数x的取值范围叫做这个函数的定义域;x的变化会引起y的变动。

2、函数式编程:
函数是把逻辑结构化和过程化的一种编程方式。逻辑是指你写一个购物车作业,先画一个流程图,也就是在画逻辑。
函数式编程就是:先定义一个数学函数,然后按照这个数学模型用编程语言去实现它。
3、python中的函数定义方法:

    def test01(x):                             #def是定义函数的关键字;test是函数名;括号内是可定义形参;
            "the function definitions"  #""里边是描述
            x += 1                                  #泛指代码块或程序处理逻辑
            return x                              #定义返回值

4、面向过程和函数式编程的区别之处
定义函数

def test1():
    '''test1'''
    print("test1")
    return 0             #有返回值

定义过程

def test02():
    '''test02'''
    print("test02")             #没有返回值

函数调用

test1()    #()代表调用test1函数;括号内可以有参数 也可以没有。
x=test1()
print(x)
结果:
test1
0

过程调用

y=test02()
print(y)
结果:
test02
None

总结:面向过程和函数式编程的区别:
相同之处:都可以被调用
不通之处:过程没有返回值;函数有返回值。
python中的面向过程,系统会默认返回一个None。

函数的三个特点

为什么使用函数,没有函数的编程只是在写逻辑(功能),想脱离函数,重用逻辑,唯一的办法就是拷贝。
例1:

with open("test01","a") as f:
    f.write('this is a stop')

现在有三个函数,每个函数在处理完自己的逻辑后,都需要使用上面的逻辑,那么唯一的办法就是拷贝三次逻辑;

def test1():
    print("this is test1")
    with open("test01", "a") as f:
        f.write("stop stop")
def test02():
    print("this is test02")
    with open("test01", "a") as f:
        f.write("stop stop")
def test3():
    print("this is test3")
    with open("test01", "a") as f:
        f.write("stop stop")
执行:
test1()
test02()
test3()

例2:优化后的,重复利用逻辑

def logger():
    with open("test01","a") as f:
        f.write('this is a stop\n')
def test1():
    print("this is test1")
    logger()
def test02():
    print("this is test02")
    logger()
def test3():
    print("this is test3")
    logger()
执行:
test1()
test02()
test3()

例:3:打印的时候加上时间,可扩展

import time
time_format = "%Y-%m-%d %X"
time_now = time.strftime(time_format)
def logger():
    with open("test01","a") as f:
        f.write('\n%s this is a stop\n'%time_now)
def test1():
    print("this is test1")
    logger()
def test02():
    print("this is test02")
    logger()
def test3():
    print("this is test3")
    logger()
执行:
test1()
test02()
test3()

总结 函数的三个优点
1.代码重用
2.保持一致性
3.可扩展性

函数返回值

def abc1():
        print("aaaaaaa:")
        return 0                  #return 结束逻辑;后边的代码不执行;
        print("bbbbbbb:")
def abc2():
        print("aaaaaaa:")
def abc3():
        print("aaaaaaa:")
        return 1,"hello",["a","b","c"],{"aaa":111}

x = abc1()                   #x接收的是abc函数的返回值0;
y = abc2()
z = abc3()
print(x)                     #return 结束逻辑;后边的代码不执行;
print(y)
print(z)

'''
输出:
aaaaaaa:
aaaaaaa:
aaaaaaa:
0
None
(1, 'hello', ['a', 'b', 'c'], {'aaa': 111})
'''

函数返回值总结
1.没有return返回值:返回None
2.return返回一个值:返回object (object就是你定义的返回值;python中的所有数据类型都是对象)
3.return返回多个值:返回tuple (元组形式返回)
为什么要有返回值?
因为想知道这个函数的执行结果是否成功,然后再进行下一步操作。

函数参数

1、形参和实参
形参定义:形式参数,不是实际存在,是虚拟变量。在定义函数和函数体的时候使用形参,目的是在函数调用时候接收实参;
实参定义:实际参数,调用函数时传给函数的参数,可以是常量、变量、表达式、函数、传给形参;
2、位置参数和关键字参数
位置参数和形参要一一对应;
位置参数和关键数同时存在的时候,关键参数不能写在位置参数前面;

def test01(x,y):          #x和y是形参
    print(x)
    print(y)

test01(1,2)              #1和2是实参;位置参数和形参要一一对应;
test01(x=1,y=2)      #关键参数与形参顺序无关;
                               #位置参数和关键数同时存在的时候,关键参数不能写在位置参数前面;

3、默认参数
特点:调用函数的时候,默认参数可有可无;
用途:默认安装值(例如安装软件的时候,设置默认安装路径;默认数据库端口值)

def moren(x,y=6):       #y=6 是默认参数
    print(x)
    print(y)
moren(5)
输出:
5
6

4、参数组
当实参不固定的时候,形参如何定义;
参数组1: 多个实参对应形参

def canshuzu(*args):        # *代表接收的参数是不固定的;*args把实参变成了一个元组;
    print(args)
canshuzu(1,2,3,4,5)
'''
输出:(1, 2, 3, 4, 5)
'''

参数组2:形参和参数组结合

def canshuzu2(x,*args):
    print(x)
    print(args)
canshuzu2(1,2,3,4,5)
'''
输出:
1
(2, 3, 4, 5)
'''

参数组3:把关键字参数转换成字典格式输出
#*args:接收n个位置参数,转换成元组的形成
#**kwargs: 把n个关键字参数转换成字典方式

def canshuzu4(**kwargs):
    print(kwargs)
    print(kwargs['name'])
canshuzu4(name="aaa",age=111)
输出:
{'name': 'aaa', 'age': 111}
aaa
canshuzu4(**{"name":"aaa","age":222})
输出:
{'name': 'aaa', 'age': 222}
aaa

def canshuzu5(name,age=12,*args,**kwargs):
    print(name)
    print(age)
    print(*args)
    print(kwargs)
canshuzu5("aaa",age=22,job="it",)
输出:
aaa
22
               #空的元组
{'job': 'it'}

函数局部变量和全局变量

namename = "AABBCC"                 #全局变量
def jubu(name):
    namename = "aabbcc"               #局部变量
    print("before change",name,namename)
    name = "ABC"                    #这里的name是局部变量,这个函数就是这个变量的作用域;
    print("after change",name)

name = "abc"                        #全局变量

jubu(name)                           #执行函数后的结果
print(name)                          #此处没有执行函数,直接调用变量
print(namename)                      #此处没有执行函数,直接调用变量
'''
输出:
before change abc aabbcc
after change ABC
abc
AABBCC
'''

总结

局部变量:在子程序中(函数)定义的变量称为局部变量。
                    局部变量作用域是该变量的子程序;
全局变量:在程序的一开始定义的变量称为全局变量。
                    全局变量作用域是整个程序;
当全局变量和局部变量同名时:
        当定义局部变量的子程序内,局部变量起作用;其他地方全局变量起作用。
        字符串和整数 在局部变量情况下是不能修改全局变量的值;要想改变在局部变量前加global;
        除了字符串和整数、元组以外高级点的类型(列表、字典、集合、类),局部变量可以改变全局变量的值;
 例子:设置局部变量修改全局变量
namename = "AABBCC"
def jubu(name):
    global namename                 #设置局部变量修改全局变量
    namename = "aabbcc"
    print("before change",name,namename)
    name = "ABC"                    #这里的name是局部变量,这个函数就是这个变量的作用域;
    print("after change",name)
name = "abc"
jubu(name)
print(name)
print(namename)
输出:
before change abc aabbcc
after change ABC
abc
aabbcc

函数-递归

定义
在函数内部,可以调用其他函数。如果一个函数在内部调用自己本身,这个函数就是递归函数。

递归特性
1.必须有一个明确的结束条件;
2.每次进入更深一层递归时,问题规模相比上次递归都应有所减少;
3.递归效率不高,递归层次过多会导致栈溢出(在计算机中,函数调用是通过栈(stack)这种数据结构实现的,每当进入一个函数调用,栈就会加一层栈帧,每当函数返回,栈就会减一层栈帧。由于栈的大小不是无限的,所以,递归调用的次数过多,会导致栈溢出。)
4.最大的递归层次是999层,超过 就报错;
简单的递归例子

def digui(n):
    print(n)
    return digui(n)
dict(0)                 #0是为了查看递归的次数,递归的次数最大为997次;然后就报错了

简单的递归例子2

def digui2(n):
    print(n)
    if int(n/2) >0:
        return digui2(int(n/2))
    print(n)
digui2(10)
输出:
10
5
2
1
1

高阶函数

定义
变量可以指向函数,函数的参数能接收变量,那么一个函数就可以接收另一个函数作为参数,这就叫做高阶函数。

例如:
def add(x,y,z):
    return z(x) + z(y)
result = add(3.3,-6,abs)     #abs()      查看绝对值,是一个内置函数。
print(result)
输出:
9.3

扩展:

装饰器:http://blog.51cto.com/506554897/1963710
生成器:http://blog.51cto.com/506554897/1963775
迭代器:http://blog.51cto.com/506554897/1963780