Python基础之函数介绍及使用

函数存在有什么意义？

  • 　　1、减少代码量
  • 　　2、保持一致性
  • 　　3、易维护

一、函数的定义和使用

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

1
2
3
4
5
6
def 函数名(参数):
        
    ...
    函数体
    ...
    返回值

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

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

1、返回值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
def 发送邮件():
        
    发送邮件的代码...
    
    if 发送成功:
        return True
    else:
        return False
    
    
while True:
        
    # 每次执行发送邮件函数，都会将返回值自动赋值给result
    # 之后，可以根据result来写日志，或重发等操作
    
    result = 发送邮件()
    if result == False:
        记录日志，邮件发送失败...

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')

动态参数(a,*args,**kwargs)
动态参数(a,*args,**kwargs)

#发送邮件实例

def mail(主题,邮件内容='test',收件人='630571017@qq.com'):
    import smtplib
    from email.mime.text import MIMEText
    from email.utils import formataddr

    msg = MIMEText(邮件内容, 'plain', 'utf-8')
    msg['From'] = formataddr(["发件人", '发件人地址'])
    msg['To'] = formataddr(["收件人", '630571017@qq.com'])
    msg['Subject'] = 主题

    server = smtplib.SMTP("smtp.126.com", 25)
    server.login("登录邮箱账号", "邮箱密码")
    server.sendmail('发件邮箱地址账号', [收件人地址, ], msg.as_string())
    server.quit()

mail('我是主题',收件人='630571017@qq.com',邮件内容='邮件内容')
mail(主题='我是主题',)

发送邮件实例
Ve

3、全局与局部变量

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
############### 全 局 与 局 部 变 量 ##############
#全局变量
P = 'nick'
 
def name():
    global P        #声明修改全局变量
    P = 'jenny'     #局部变量
    print(P)
 
def name2():
    print(P)
 
name()
name2()

二、匿名函数lambda

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

######## 普 通 函 数 ########
# 定义函数（普通方式）
def func(arg):
    return arg + 1
     
# 执行函数
result = func(123)
     
######## lambda 表 达 式 ########
     
# 定义函数（lambda表达式）
my_lambda = lambda arg : arg + 1
     
# 执行函数
result = my_lambda(123)
##### 列表重新判断操作排序 #####
 
li = [11,15,9,21,1,2,68,95]
 
s = sorted(map(lambda x:x if x > 11 else x * 9,li))
 
print(s)
 
######################
 
ret = sorted(filter(lambda x:x>22, [55,11,22,33,]))
 
print(ret)

lambda匿名函数优点：较少内存消耗

三、 内置函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
###### 求绝对值 #######
a = abs(-95)
print(a)
 
###### 只有一个为假就为假 ########
a = all([True,True,False])
print(a)
 
###### 只有一个为真就为真 ########
a = any([False,True,False])
print(a)
 
####### 返回一个可打印的对象字符串方式表示 ########
a = ascii('0x10000')
b = ascii('bx19')
print(a,b)
 
######### 将整数转换为二进制字符串 ############
a = bin(95)
print(a)
 
######### 将一个数字转化为8进制 ##############
a = oct(95)
print(a)
 
######### 将一个数字转化为10进制 #############
a = int(95)
print(a)
 
######### 将整数转换为16进制字符串 ##########
a = hex(95)
print(a)
 
######### 转换为布尔类型 ###########
a = bool('')
print(a)
 
######### 转换为bytes ########
a = bytes('索宁',encoding='utf-8')
print(a)
 
######## chr 返回一个字符串，其ASCII码是一个整型.比如chr(97)返回字符串'a'。参数i的范围在0-255之间。 #######
a = chr(88)
print(a)
 
######## ord 参数是一个ascii字符，返回值是对应的十进制整数 #######
a = ord('X')
print(a)
 
######## 创建数据字典 ########
dict({'one': 2, 'two': 3})
dict(zip(('one', 'two'), (2, 3)))
dict([['two', 3], ['one', 2]])
dict(one=2, two=3)
 
###### dir 列出某个类型的所有可用方法 ########
a = dir(list)
print(a)
 
###### help 查看帮助文档 #########
help(list)
 
####### 分别取商和余数 ######
a = divmod(9,5)
print(a)
 
##### 计算表达式的值 #####
a = eval('1+2*2')
print(a)
 
###### exec 用来执行储存在字符串或文件中的Python语句 ######
exec(print("Hi,girl."))
exec("print("hello, world")")
 
####### filter 过滤 #######
li = [1,2,3,4,5,6]
a = filter(lambda x:x>3,li)
for i in a:print(i)
 
##### float 浮点型 #####
a = float(1)
print(a)
 
###### 判断对象是不是属于int实例 #########
a = 5
b = isinstance(a,int)
print(b)
 
######## globals 返回全局变量 ########
######## locals 返回当前局部变量 ######
name = 'nick'
def hi():
    a = 1
    print(locals())
hi()
print(globals())
 
########## map 遍历序列，对序列中每个元素进行操作，最终获取新的序列。 ##########
li =  [11,22,33]
def func1(arg):
    return arg + 1  #这里乘除都可以
new_list = map(func1,li)  #这里map调用函数，函数的规则你可以自己指定，你函数定义成什么他就做什么操作！
for i in new_list:print(i)
 
###### max 返回集合中的最大值 ######
###### min 返回集合中的最小值 ######
a = [1,2,3,4,5]
s = max(a)
print(s)
n = min(a)
print(n)
 
####### pow 返回x的y次幂 ########
a = pow(2,10)
print(a)
a = pow(2,10,100)   #等于2**10%100，取模
print(a)
 
######## round 四舍五入 ########
a = round(9.5)
print(a)
 
######## sorted 队集合排序 ########
char=['索',"123", "1", "25", "65","679999999999", "a","B","nick","c" ,"A", "_", "ᒲ",'a钱','孙','李',"余", '佘',"佗", "㽙", "铱", "啊啊啊啊"]
new_chat = sorted(char)
print(new_chat)
for i in new_chat:
    print(bytes(i, encoding='utf-8'))
 
######## sum 求和的内容 ########
a = sum([1,2,3,4,5])
print(a)
a = sum(range(6))
print(a)
 
######## __import__ 通过字符串的形式，导入模块 ########
# 通过字符串的形式，导入模块。起个别名ccas
comm = input("Please:")
ccas = __import__(comm)
ccas.f1()
# 需要做拼接时后加 fromlist=True
m = __import__("lib."+comm, fromlist=True)
1
2
3
4
5
6
lt(a, b) 相当于 a < b
le(a,b) 相当于 a <= b
eq(a,b) 相当于 a == b
ne(a,b) 相当于 a != b
gt(a,b) 相当于 a > b
ge(a, b)相当于 a>= b

 四、递归函数

　　递归算法是一种直接或者间接地调用自身算法的过程。在计算机编写程序中，递归算法对解决一大类问题是十分有效的，它往往使算法的描述简洁而且易于理解。
 
递归算法解决问题的特点：
  • 递归就是在过程或函数里调用自身。
  • 在使用递归策略时，必须有一个明确的递归结束条件，称为递归出口。
  • 递归算法解题通常显得很简洁，但递归算法解题的运行效率较低。所以一般不提倡用递归算法设计程序。
  • 在递归调用的过程当中系统为每一层的返回点、局部量等开辟了栈来存储。递归次数过多容易造成栈溢出等。所以一般不提倡用递归算法设计程序
def calc(n):
    print(n)
    if int(n / 2) == 0:
        return n # 当上面的条件成立后一个真值，返回到函数
    res = calc(int(n / 2))    
    print(n,res) 
    return res # 返回res的值，要将真值一层一层传递回去

calc(10)


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))

五、综合运用

1.利用函数编写如下数列：

斐波那契数列指的是这样一个数列 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233，377，610，987，1597，2584，4181，6765，10946，17711，28657，46368...

正解：

def func(arg1,arg2):
    if arg1 == 0:
        print arg1, arg2
    arg3 = arg1 + arg2
    print arg3
    func(arg2, arg3)
   
func(0,1)
View Code

 2.#写函数，利用递归获取斐波那契数列中的第 10 个数

def fie(n):
    if n == 0 or n == 1:
        return n
    else:
        return (fie(n-1)+fie(n-2))
ret = fie(10)
print(ret)
方法一
def num(a,b,n):
    if n == 10:
        return a
    print(a)
    c = a + b
    a = num(b,c,n + 1)
    return a
 
s = num(0,1,1)
print(s)
方法二

基础目录

 

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/honglingjin/p/6120603.html