Python之路【第五篇】python基础 之函数

函数

一、定义和使用

函数式编程最重要的是增强代码的重用性和可读性

def 函数名(参数):
        
    ...
    函数体
    ...
    返回值

函数的定义主要有如下要点：

• def：表示函数的关键字
• 函数名：函数的名称，日后根据函数名调用函数
• 函数体：函数中进行一系列的逻辑计算
• 参数：为函数体提供数据
• 返回值：当函数执行完毕后，可以给调用者返回数据

1、返回值

函数是一个功能块，该功能到底执行成功与否，需要通过返回值来告知调用者。

以上要点中，比较重要有参数和返回值： 1 def 发送短信():

def 发送邮件():
        
    发送邮件的代码...
    
    if 发送成功:
        return True
    else:
        return False
    
    
while True:
        
    # 每次执行发送邮件函数，都会将返回值自动赋值给result
    # 之后，可以根据result来写日志，或重发等操作
    
    result = 发送邮件()
    if result == False:
        记录日志，邮件发送失败...

2、参数

• 1.形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量
• 2.实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。因此应预先用赋值，输入等办法使参数获得确定值

函数的有三中不同的参数：

• 普通参数
• 默认参数
• 动态参数

#定义函数
#n 叫做函数 name 的形式参数，简称：形参

def name(n):
    print(n)

#执行函数 
#'nick' 叫做函数 name 的实际参数，简称：实参

name('nick')

普通参数

def func(name, age = 18):
    print("%s:%s")%(name,age)

# 指定参数
func('nick', 19)
# 使用默认参数
func('nick')

注：默认参数需要放在参数列表最后

默认参数

def func(*args):
    print args

# 执行方式一
func(11,22,33,55,66)

# 执行方式二
li = [11,22,33,55,66]
func(*li)

动态参数（*args）

def func(**kwargs):
    print kwargs


# 执行方式一
func(name＝'nick',age=18)

# 执行方式二
li = {'name':'nick', age:18, 'job':'pythoner'}
func(**li)

动态参数（**kwargs）

def hi(a,*args,**kwargs):
    print(a,type(a))
    print(args,type(args))
    print(kwargs,type(kwargs))
hi(11,22,33,k1='nick',k2='jenny')
也称万能参数

3、全局与局部变量

全局变量在函数里可以随便调用，但要修改就必须用 global 声明

############### 全 局 与 局 部 变 量 ##############
#全局变量
P = 'nick'
 
def name():
    global P        #声明修改全局变量
    P = 'jenny'     #局部变量
    print(P)
 
def name2():
    print(P)
 
name()
name2()

二、内置函数

# 1. 绝对值
# i = abs(-123)
# print(i)

# 2 all 循环参数，如果每个元素都为真，那么all的返回值为真
# r = all([1,2,3,True,False])
# print(r)

# 3 any 循环参数，如果元素有一真，那么any的返回值为真
# i = any([None,'',{},[],(),0,1])
# print(i)

# 4
# bin() # 二进制 0b1011 ob 代表2进制
# print(bin(11))
# oct() # 八进制
# int() # 十进制
# hex() # 十六进制

# 5
# bool ,判断真假，把一个对象转换成布尔值

# 6
# str
# list

# bytes  字节
# bytearray  字节列表
# 字节和字符串之间的转换
# print(bytes("112",encoding="gbk"))

# 7
# chr(33)  # 查看ASCII 中对应的字符
# ord("t") #  查看字符对应的位置
# # ascii 一个字节，8位，2**8 ，256

# 8 做编译用，把一段字符串编译成一段可执行的代码
# compile()

# 9 得到商和余数商3余1
# r = divmod(10,3)
# print(r)

# 10 可以执行一个字符串形式的表达式
# ret = eval("1 + 3") # 表达式，返回值
# print(ret)
# exec 执行py代码
# evel 表达式，返回值
# compile 编译

# 11
# filter(函数，可迭代对象) 过滤
# def f(x):
#     if x >22:
#         return True
#     else:
#         return False
# ret = filter(f,[11,22,33,44,55])
# print(list(ret))
# ret = filter(lambda x:x>22,[11,22,33,44,55])
# print(list(ret))

# 12 map(函数，可迭代对象)
# ret = map(lambda x:x+100,[1,2,3,4,5])
# print(list(ret))
# ret = map(lambda x:x+100 if x%2 == 0 else x ,[1,2,3,4,5])
# print(list(ret))

# 13
# globals() # 获取所有的全局变量
# locals()
# def f1():
#     name = 123
#     print(locals())
#     print(globals())
# f1()

# 14  判断某个对象是否是某个类创建的
# li = [11,22,33]
# r = isinstance(li,list)
# print(r)

# 15 创建一个可被迭代的东西
# obj = iter([11,22,33,44])
# r1 = next(obj)
# # next 调用迭代的对象的值
# print(r1)

# 16
# max()#取最大值
# min()#取最小值

# 17 求指数2的10次方
# i = pow(2,10)
# print(i)

# 18 四舍五入
# r = round(3.6)
# print(r)

# 19 求和
# sum()

# 20  一一对应
# zip()
# li = [11,22,33,44]
# l1 = ['a','b','c','d']
# r = zip(li,l1)
# print(list(r)) # 结果：[(11, 'a'), (22, 'b'), (33, 'c'), (44, 'd')]

# 21 排序，同种类型
# li = [1,211,22,3,4]
# # print(li )
# # li.sort()
# # print(li)
#
# new_li = sorted(li)
# print(new_li)

内置函数

 

一、map

遍历序列，对序列中每个元素进行操作，最终获取新的序列。

str = ['a', 'b']
 
def fun2(s):
 
    return s + "alvin"
 
ret = map(fun2, str)
 
print(ret)      #  map object的迭代器
print(list(ret))#  

li = [11, 22, 33]

new_list = map(lambda a: a + 1, li)

li = [11, 22, 33]
sl = [1, 2, 3]
new_list = map(lambda a, b: a + b, li, sl)

 

二、filter

对于序列中的元素进行筛选，最终获取符合条件的序列

str = ['a', 'b','c', 'd']
 
def fun1(s):
    if s != 'a':
        return s
 
 
ret = filter(fun1, str)

li = [11,22,33,44,55]

new_list = filter(lambda arg: arg > 22, li)

print(list(new_list))

三、reduce

对于序列内所有元素进行累计操作

from functools import reduce
 
def add1(x,y):
    return x + y
 
print (reduce(add1, range(1, 101)))## 

li = [11, 22, 33]

result = reduce(lambda arg1, arg2: arg1 + arg2, li)

三、三元运算

三元运算（三目运算），是对简单的条件语句的缩写。

result = 值1 if 条件 else 值2
  
# 如果条件成立，那么将 “值1” 赋值给result变量，否则，将“值2”赋值给result变量

########## 三 元 运 算 ############
name = "nick" if 1==1 else "jenny"
print(name)

 

四、lambda 表达式

对于简单的函数，存在一种简便的表示方式，即：lambda表达式

######## 普 通 函 数 ########
# 定义函数（普通方式）
def func(arg):
    return arg + 1
     
# 执行函数
result = func(123)
     
######## lambda 表 达 式 ########
     
# 定义函数（lambda表达式）
my_lambda = lambda arg : arg + 1 # 相当于返回值
     
# 执行函数
result = my_lambda(123)

 

五、递归

递归算法是一种直接或者间接地调用自身算法的过程。在计算机编写程序中，递归算法对解决一大类问题是十分有效的，它往往使算法的描述简洁而且易于理解。

 

递归算法解决问题的特点：

• 递归就是在过程或函数里调用自身。
• 在使用递归策略时，必须有一个明确的递归结束条件，称为递归出口。
• 递归算法解题通常显得很简洁，但递归算法解题的运行效率较低。所以一般不提倡用递归算法设计程序。
• 在递归调用的过程当中系统为每一层的返回点、局部量等开辟了栈来存储。递归次数过多容易造成栈溢出等。所以一般不提倡用递归算法设计程序。

def fact_iter(product,count,max):
    if count > max:
        return product
    return fact_iter(product * count, count+1, max)
 
print(fact_iter(1,1,5))
print(fact_iter(1,2,5))
print(fact_iter(2,3,5))
print(fact_iter(6,4,5))
print(fact_iter(24,5,5))
print(fact_iter(120,6,5))