Python学习示例源码

函数和函数式编程

• 函数定义；

• 函数调用；

• 过程定义；

• 过程调用；

• 面向过程的编程方法；

"""
面向对象-----类------class
面向过程-----过程---- def
函数式编程----函数----def

函数定义：将一组语句的集合通过一个名字（即函数名）封装起来，要想执行这个函数，只需调用其函数名即可


函数和过程都是可以调用的，过程就是一个没有返回值的函数而已

面向过程的编程方法：一段一段的逻辑或者一段一段的功能包含在def定义的过程中，使用时直接调用
函数式编程：？
"""


# 语法定义
# 定义一个函数，有返回值
def func1():   # 函数名，括号里可以写入参数
    """testing"""
    print('in the func1')  # 函数体，表示复杂逻辑的代码
    return 0  # 返回值


# 定义一个过程,没有返回值
def func2():
    """testing2"""
    print("in the func2")  # 表示复杂逻辑的代码

# 调用
x = func1()
y = func2()
print('from func1 return is %s' %x)
print('from func2 return is %s' %y)  # 也被当成了一个隐式的函数

示例：使用函数减少重复代码

为什么要使用函数：

1.减少重复代码

"""
为什么要使用函数：减少重复代码;使程序变得可扩展；使程序变得易维护
日志文件处理（框架搭建必须有的）
"""
import time


def logger():

    with open('a.txt', 'a+') as f:
        f.write('end action\n')       # 类似写日志文件


# 模拟一个功能，并将日志文件写入日志文件
def test1():
    """文档描述"""
    print('in the test1')  # 日志追加
    logger()      # 写入日志


# 模拟另外一个功能
def test2():
    print('in the test2')  # 日志描述
    logger()  # 写入日志


# 模拟第三个功能
def test3():
    print('in the test3')
    logger()  # 写入日志

# 调用各个功能模块
test1()
test2()
test3()

示例：使用函数使程序变得可扩展

2.使程序变得可扩展

"""
为什么要使用函数：减少重复代码;使程序变得可扩展；使程序变得易维护
日志文件处理（框架搭建必须有的）
"""
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('in the test1')  # 日志追加
    logger()      # 写入日志


# 模拟另外一个功能
def test2():
    print('in the test2')  # 日志描述
    logger()  # 写入日志


# 模拟第三个功能
def test3():
    print('in the test3')
    logger()  # 写入日志

# 调用各个功能模块
test1()
test2()
test3()

 

示例：函数返回值

编写函数为什么要有返回值，作用：想要这个函数的执行结果。

函数体中可以是一行代码，也可以是一万行代码。这个函数执行的结果是什么，我后面的程序需要这个程序的返回结果。

"""
函数返回值
函数返回值的作用：后面的程序需要这个函数的返回结果
"""


def test1():
    """未定义返回值"""
    print('in the test1')  # 函数体


def test2():
    '''定义返回值'''
    print('in the test2')  # 函数体
    return 0  # 定义返回值，结束函数的效果


def test3():
    '''定义返回值有数字，字符，元组，字典'''
    print('in the test3')  # 函数体
    return 1, 'hello', ['zhangsan', 'lisi'], {'name': 'emy'}

x = test1()  # 函数体的返回值
y = test2()  # 函数体的返回值
z = test3()  # 函数体的返回值
print(x)
print(y)
print(z)

示例：带参数的函数

学会以下传参方法：位置参数；默认参数；参数组传参；字典参数传参

"""
带参数的函数:关键字参数和位置参数
关键参数不能写在位置参数前面
"""


def test(x, y):
    print(x)
    print(y)

test(5, 8)  # 位置参数与形参一一对应
test(x=1, y=6)  # 关键字参数与形参顺序无关
test(y=9, x=3)  # 关键字参数与形参顺序无关


# 默认参数
def test1(x, y=2):
    print(x)
    print(y)

test1(1)
test1(1, y=3)

# 默认参数特点：调用函数时默认参数可有可无，不是必传参数
# 默认参数应用场景：占位或默认初始设置路径或默认端口3306

示例：参数带参数组的函数定义方式

# 参数组*args：实参不固定的情况下，怎么定义实参，在这种情况下，采用参数组，接收N个位置参数，不是关键字方式，转换成元组的方式；
# 应用场景：给函数传不固定的参数，定义参数时，根据业务发展，可能有预想参数个数不一样的的情况下
# 规范：*args ,如果星号后面采用其他名字，程序不会报错，但是最后用规范的带args名，这样便于阅读
def test2(*args):
    print(args)

test2(1, 2, 3, 4, 5)
test2(*[1, 2, 3, 4, 5, 6])  # args=tuple(1,2,3,4,5,6)


def test3(x, *args):
    print(x)
    print(args)

test3(1, 2, 3, 4, 5, 6, 7)

示例：参数带字典的函数定义方式

# **kwargs接收N个关键字参数，转换成字典的形式


def test2(**kwargs):
    print(kwargs)
    print(kwargs['name'])
    print(kwargs['age'])
    print(kwargs['sex'])


test2(name='zhangsan', age=8, sex='male')
test2(**{'name': 'zhangsan', 'age': '22', 'sex': 'male'})

示例：参数可扩展的函数定义方式

# 参数可扩展的函数


# 与位置参数一起使用
def test3(name, **kwargs):
    print(name)
    print(kwargs)

test3('zhangsan')  # 这样转参数，会接收一个name和一个空字典----->>正确
test3('lisi', age=8, sex='male')  # 与位置参数结合,以关键字方式传参------>>正确


# 与默认参数一起使用
def test4(name, age=8, **kwargs):  # 默认参数不能写在参数最后，参数组置后
    print(name)
    print(age)
    print(kwargs)

test4('wangwu', sex='male', hobby='study', age=3)   # 此处的age传参可以写在最后，也可以写在对应的位置


# 所有类型的参数结合在一起（位置参数，默认参数，带数组的参数，带字典的参数）
def test5(name, age=18, *args, **kwargs):
    print(name)
    print(age)
    print(args)
    print(kwargs)

test5('amy', age=28, sex='male', hoddy='study')  # 在这个没有位置参数，所以*args在运行的时候接收为空元组；后面两个参数为两个关键字参数。所以传给**kwargs

函数和函数式编程：不是同一种方式，了解就行，不用深究

函数式编程、面向过程、面向对象编程是三种编程范式。函数式编程是一种抽象很高的一种编程范式，输入是什么输出就是什么，函数是输入和输出可以不同。

如有疑问，可加入QQ学习群：484601288

​局部变量和与全局变量

​是否可在一个函数中引用另外一个函数呢？

示例：局部变量

# 局部变量:函数里面的变量即为局部变量，只在函数里有效
        
        
def change_name(name):
    print("befor change", name)
    name = 'San Zhang'  # 这个函数就是这个变量的作用域
    print("after change", name)
        
name = 'zhangsan'
change_name(name)
print(name)

示例：全局变量

# 全局变量：在整个程序中都生效的变量，在整个代码的顶层定义的变量就是全局变量
       
company = 'ali'
       
       
def change_name(name):
    company = 'tengxu'
    print("befor change", name, company)
    name = 'zhangsan'  # 这个函数就是这个变量的作用域
    print("after change", name)
       
print(company)
       
name = 'lisi'
change_name(name)
print(name, company)

示例：局部变量改为全局变量1

在函数里面，默认情况下“字符串”和“常量”，这两类局部变量不能更改全局变量，如果想在函数中将局部变量改为全局变量的方法：改之前申明global，不建议使用这种方法。

# 在函数里面，默认情况下局部变量不能更改全局变量，如果想在函数中将局部变量改为全局变量的方法：改之前申明global，不建议使用这种方法
       
company = 'ali'  # 全局变量
       
       
def change_name(name):
    global company
    company = 'tengxu'    # 局部变量
    print("befor change", name, company)
    name = 'zhangsan'  # 这个函数就是这个变量的作用域
    print("after change", name)
       
print('company: ', company)   # 执行查看函数调用前打印的情况
name = 'lisi'
change_name(name)
print(name)
print('company: ', company)   # 执行查看函数调用后打印的情况

示例：局部变量改为全局变量2

未像<局部变量改为全局变量1>那样申明global，也将局部变量更改为全局变量了。所以默认不能更改只针对“字符串和整数”外。复杂的数据类型：列表，类，字典，集合都是可以将局部变量改为全局变量。

# 局部变量改全局变量
    
company = 'ali'  # 全局变量
names = ['zhangsan', 'sili', 'wangwu']
    
    
def change_name():
    names[0] = '张三'
    print("inside_func: ", names)          # 运行查看执行结果
    
change_name()
print('ouside_func：', names)   # 运行查看执行结果

示例：作死的全局变量定义

或许你在其他地方也会看见这种方式，忘掉这种方式，不能使用这种方法，这种在逻辑复杂的代码中不利于调试，尽管是自己写的代码也会如此。

# 不建议使用这种方法
def chang_name():
    global name
    name = 'zhangsan'
     
chang_name()
print(name)

示例：使用递归方式实现，传一个值，每次除以2直到不能除为止

递归特性：1、必须有一个明确的结束条件；2、每次进入更深一层递归时，问题规模相比上次递归都应有减少；3、递归效率不高，可能会导致内存资源耗尽

做递归最好的运行方式，采用断点方式调试。

简单的一个递归方式实现传一个值，每次除以2直到不能除为止：

# 传一个值，每次除以2直到不能除为止
  
def calc(n):
    print(n)
    if int(n/2)>0:
        return calc(int(n/2))
    print('--->>', n)
  
calc(10)

所有示例程序均在Ubuntu16.04系统下的python3.5下成功执行。

高阶函数：变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数

# 把一个函数当成一个参数传给另一个函数，这个函数就是高阶函数


# 这是一般普通的函数
def add(a, b):
    return a + b


# 高阶函数
def add(a, b, f):
    return f(a) + f(b)

res = add(3, -6, abs)
print(res)

如有疑问，可加入QQ学习群讨论：484601288

转载于:https://www.cnblogs.com/ranxf/p/8567886.html