补充：
三元运算（三元表达式），是对简单的条件语句的缩写。
# 书写格式
result = 值1 if 条件 else 值2
# 如果条件成立，那么将 “值1” 赋值给result变量，否则，将“值2”赋值给result变量。
函数：
一、使用函数的好处：
1.代码重用
2.保持一致性，易维护
3.可扩展性
二、函数和过程
过程定义：过程就是简单特殊没有返回值的函数（python中过程就是没有返回值的函数）
1 1 def test01():
2 2 msg='hello The little green frog'
3 3 print msg
4 4
5 5 def test02():
6 6 msg='hello WuDaLang'
7 7 print msg
8 8 return msg
9 9
10 10
11 11 t1=test01()
12 12
13 13 t2=test02()
14 14
15 15
16 16 print 'from test01 return is [%s]' %t1
17 17 print 'from test02 return is [%s]' %t2示例
总结：当一个函数/过程没有使用return显示的定义返回值时，python解释器会隐式的返回None，
所以在python中即便是过程也可以算作函数。
1 1 def test01():
2 2 pass
3 3
4 4 def test02():
5 5 return 0
6 6
7 7 def test03():
8 8 return 0,10,'hello',['alex','lb'],{'WuDaLang':'lb'}
9 9
10 10 t1=test01()
11 11 t2=test02()
12 12 t3=test03()
13 13
14 14
15 15 print 'from test01 return is [%s]: ' %type(t1),t1
16 16 print 'from test02 return is [%s]: ' %type(t2),t2
17 17 print 'from test03 return is [%s]: ' %type(t3),t3示例
总结：
返回值数=0:返回None
返回值数=1:返回object
返回值数>1:返回tuple
三、 函数参数
1.形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量
2.实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。因此应预先用赋值，输入等办法使参数获得确定值
3.函数的三中不同的参数：
- 普通参数
- 默认参数
- 动态参数
1 # ######### 定义函数 #########
2
3 # name 叫做函数func的形式参数，简称：形参
4 def func(name):
5 print name
6
7 # ######### 执行函数 #########
8 # 'wupeiqi' 叫做函数func的实际参数，简称：实参
9 func('wupeiqi')普通参数
1 def func(name, age = 18):
2
3 print "%s:%s" %(name,age)
4
5 # 指定参数
6 func('wupeiqi', 19)
7 # 使用默认参数
8 func('alex')
9
10 注：默认参数需要放在参数列表最后默认参数
1 def func(*args):
2
3 print args
4
5
6 # 执行方式一
7 func(11,33,4,4454,5)
8
9 # 执行方式二
10 li = [11,2,2,3,3,4,54]
11 func(*li)动态参数
1 def func(**kwargs):
2
3 print args
4
5
6 # 执行方式一
7 func(name＝'wupeiqi',age=18)
8
9 # 执行方式二
10 li = {'name':'wupeiqi', age:18, 'gender':'male'}
11 func(**li)动态参数
1 def func(*args, **kwargs):
2
3 print args
4 print kwargs动态参数
扩展：发送邮件实例
1 import smtplib
2 from email.mime.text import MIMEText
3 from email.utils import formataddr
4
5
6 msg = MIMEText('邮件内容', 'plain', 'utf-8')
7 msg['From'] = formataddr(["武沛齐",'wptawy@126.com'])
8 msg['To'] = formataddr(["走人",'424662508@qq.com'])
9 msg['Subject'] = "主题"
10
11 server = smtplib.SMTP("smtp.126.com", 25)
12 server.login("wptawy@126.com", "邮箱密码")
13 server.sendmail('wptawy@126.com', ['424662508@qq.com',], msg.as_string())
14 server.quit()示例
四、 局部变量和全局变量
在子程序中定义的变量称为局部变量，在程序的一开始定义的变量称为全局变量。
全局变量作用域是整个程序，局部变量作用域是定义该变量的子程序。
当全局变量与局部变量同名时：在定义局部变量的子程序内，局部变量起作用；在其它地方全局变量起作用。
1 1 name='lhf'
2 2
3 3 def change_name():
4 4 print('我的名字',name)
5 5
6 6 change_name()
7 7
8 8
9 9 def change_name():
10 10 name='帅了一笔'
11 11 print('我的名字',name)
12 12
13 13 change_name()
14 14 print(name)
15 15
16 16
17 17
18 18 def change_name():
19 19 global name
20 20 name='帅了一笔'
21 21 print('我的名字',name)
22 22
23 23 change_name()
24 24 print(name)示例
五、前向引用之'函数即变量'
1 1 def action():
2 2 print 'in the action'
3 3 logger()
4 4 action()
5 5 报错NameError: global name 'logger' is not defined
6 6
7 7
8 8 def logger():
9 9 print 'in the logger'
10 10 def action():
11 11 print 'in the action'
12 12 logger()
13 13
14 14 action()
15 15
16 16
17 17 def action():
18 18 print 'in the action'
19 19 logger()
20 20 def logger():
21 21 print 'in the logger'
22 22
23 23 action()示例
六、 嵌套函数和作用域
1 1 name = "Alex"
2 2
3 3 def change_name():
4 4 name = "Alex2"
5 5
6 6 def change_name2():
7 7 name = "Alex3"
8 8 print("第3层打印",name)
9 9
10 10 change_name2() #调用内层函数
11 11 print("第2层打印",name)
12 12
13 13
14 14 change_name()
15 15 print("最外层打印",name)示例
此时，在最外层调用change_name2()会出现什么效果？
没错， 出错了， 为什么呢？
作用域在定义函数时就已经固定住了，不会随着调用位置的改变而改变
1 1 例一：
2 2 name='alex'
3 3
4 4 def foo():
5 5 name='lhf'
6 6 def bar():
7 7 print(name)
8 8 return bar
9 9
10 10 func=foo()
11 11 func()
12 12
13 13
14 14 例二：
15 15 name='alex'
16 16
17 17 def foo():
18 18 name='lhf'
19 19 def bar():
20 20 name='wupeiqi'
21 21 def tt():
22 22 print(name)
23 23 return tt
24 24 return bar
25 25
26 26 func=foo()
27 27 func()()示例
七、 递归调用
在函数内部，可以调用其他函数。如果在调用一个函数的过程中直接或间接调用自身本身。
1 def calc(n):
2 print(n)
3 if int(n/2) ==0:
4 return n
5 return calc(int(n/2))
6
7 calc(10)
8
9 输出：
10 10
11 5
12 2
13 1
1 #_*_coding:utf-8_*_
2 __author__ = 'Linhaifeng'
3 import time
4
5 person_list=['alex','wupeiqi','yuanhao','linhaifeng']
6 def ask_way(person_list):
7 print('-'*60)
8 if len(person_list) == 0:
9 return '没人知道'
10 person=person_list.pop(0)
11 if person == 'linhaifeng':
12 return '%s说:我知道,老男孩就在沙河汇德商厦,下地铁就是' %person
13 print('hi 美男[%s],敢问路在何方' %person)
14 print('%s回答道:我不知道,但念你慧眼识猪,你等着,我帮你问问%s...' %(person,person_list))
15 time.sleep(3)
16 res=ask_way(person_list)
17 # print('%s问的结果是: %res' %(person,res))
18 return res
19
20
21
22 res=ask_way(person_list)
23
24 print(res)递归问路
递归特性:
1. 必须有一个明确的结束条件
2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少
3. 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）
尾递归优化：http://egon09.blog.51cto.com/9161406/1842475
1 data = [1, 3, 6, 7, 9, 12, 14, 16, 17, 18, 20, 21, 22, 23, 30, 32, 33, 35]
2
3
4 def binary_search(dataset,find_num):
5 print(dataset)
6
7 if len(dataset) >1:
8 mid = int(len(dataset)/2)
9 if dataset[mid] == find_num: #find it
10 print("找到数字",dataset[mid])
11 elif dataset[mid] > find_num :# 找的数在mid左面
12 print("\033[31;1m找的数在mid[%s]左面\033[0m" % dataset[mid])
13 return binary_search(dataset[0:mid], find_num)
14 else:# 找的数在mid右面
15 print("\033[32;1m找的数在mid[%s]右面\033[0m" % dataset[mid])
16 return binary_search(dataset[mid+1:],find_num)
17 else:
18 if dataset[0] == find_num: #find it
19 print("找到数字啦",dataset[0])
20 else:
21 print("没的分了,要找的数字[%s]不在列表里" % find_num)
22
23
24 binary_search(data,66)经典二分查询
1 def func(arg1, arg2):
2 if arg1 == 0:
3 print(arg1)
4 arg3 = arg1 + arg2
5 print(arg3)
6 if arg3 >300:
7 exit()
8 func(arg2, arg3)
9 func(0, 1)递归生成斐波那契数列
八、 匿名函数
匿名函数就是不需要显式的指定函数
lambda表达式
学习条件运算时，对于简单的 if else 语句，可以使用三元运算来表示，即：
# 普通条件语句
if 1 == 1:
name = 'wupeiqi'
else:
name = 'alex'
# 三元运算
name = 'wupeiqi' if 1 == 1 else 'alex'对于简单的函数，也存在一种简便的表示方式，即：lambda表达式
# ###################### 普通函数 ######################
# 定义函数（普通方式）
def func(arg):
return arg + 1
# 执行函数
result = func(123)
# ###################### lambda ######################
# 定义函数（lambda表达式）
my_lambda = lambda arg : arg + 1
# 执行函数
result = my_lambda(123）
九、函数式编程与高阶函数
函数的参数传入，是函数吃进去的食物，而函数return的返回值，是函数拉出来的结果，面向过程的思路就是，把程序的执行当做一串首尾相连的函数，一个函数吃，拉出的东西给另外一个函数吃，另外一个函数吃了再继续拉给下一个函数吃。。。
例如：
用户登录流程：前端接收处理用户请求-》将用户信息传给逻辑层，逻辑词处理用户信息-》将用户信息写入数据库
验证用户登录流程：数据库查询/处理用户信息-》交给逻辑层，逻辑层处理用户信息-》用户信息交给前端，前端显示用户信息
函数式编程...............................
高阶函数：
满足俩个特性任意一个即为高阶函数
1.函数的传入参数是一个函数名
2.函数的返回值是一个函数名
map函数对可迭代对象中的每个元素进行一定意义的操作最终得到的还是个一模一样的可迭代对象
filter函数过滤一个可迭代对象的某类元素然后得出一个新的可迭代对象
reduce函数对一个可迭代对象的元素进行整体操作合并后得到一个新的对象
1 array=[1,3,4,71,2]
2
3 ret=[]
4 for i in array:
5 ret.append(i**2)
6 print(ret)
7
8 #如果我们有一万个列表,那么你只能把上面的逻辑定义成函数
9 def map_test(array):
10 ret=[]
11 for i in array:
12 ret.append(i**2)
13 return ret
14
15 print(map_test(array))
16
17 #如果我们的需求变了,不是把列表中每个元素都平方,还有加1,减一,那么可以这样
18 def add_num(x):
19 return x+1
20 def map_test(func,array):
21 ret=[]
22 for i in array:
23 ret.append(func(i))
24 return ret
25
26 print(map_test(add_num,array))
27 #可以使用匿名函数
28 print(map_test(lambda x:x-1,array))
29
30
31 #上面就是map函数的功能,map得到的结果是可迭代对象
32 print(map(lambda x:x-1,range(5)))map函数：map(函数，可迭代对象)处理过程就是将可迭代对象中的元素for循环遍历后拿给前面的函数处理
1 from functools import reduce
2 #合并,得一个合并的结果
3 array_test=[1,2,3,4,5,6,7]
4 array=range(100)
5
6 #报错啊,res没有指定初始值
7 def reduce_test(func,array):
8 l=list(array)
9 for i in l:
10 res=func(res,i)
11 return res
12
13 # print(reduce_test(lambda x,y:x+y,array))
14
15 #可以从列表左边弹出第一个值
16 def reduce_test(func,array):
17 l=list(array)
18 res=l.pop(0)
19 for i in l:
20 res=func(res,i)
21 return res
22
23 print(reduce_test(lambda x,y:x+y,array))
24
25 #我们应该支持用户自己传入初始值
26 def reduce_test(func,array,init=None):
27 l=list(array)
28 if init is None:
29 res=l.pop(0)
30 else:
31 res=init
32 for i in l:
33 res=func(res,i)
34 return res
35
36 print(reduce_test(lambda x,y:x+y,array))
37 print(reduce_test(lambda x,y:x+y,array,50))reduce函数：reduce（函数，可迭代对象，初始值（可以没有初始值））
1 #电影院聚集了一群看电影bb的傻逼,让我们找出他们
2 movie_people=['alex','wupeiqi','yuanhao','sb_alex','sb_wupeiqi','sb_yuanhao']
3
4 def tell_sb(x):
5 return x.startswith('sb')
6
7
8 def filter_test(func,array):
9 ret=[]
10 for i in array:
11 if func(i):
12 ret.append(i)
13 return ret
14
15 print(filter_test(tell_sb,movie_people))
16
17
18 #函数filter,返回可迭代对象
19 print(filter(lambda x:x.startswith('sb'),movie_people))filter函数：filter（map(函数，可迭代对象)处理过程就是将可迭代对象中的元素for循环遍历后拿给前面的函数处理）
1 #当然了,map,filter,reduce,可以处理所有数据类型
2
3 name_dic=[
4 {'name':'alex','age':1000},
5 {'name':'wupeiqi','age':10000},
6 {'name':'yuanhao','age':9000},
7 {'name':'linhaifeng','age':18},
8 ]
9 #利用filter过滤掉千年王八,万年龟,还有一个九千岁
10 def func(x):
11 age_list=[1000,10000,9000]
12 return x['age'] not in age_list
13
14
15 res=filter(func,name_dic)
16 for i in res:
17 print(i)
18
19 res=filter(lambda x:x['age'] == 18,name_dic)
20 for i in res:
21 print(i)
22
23
24 #reduce用来计算1到100的和
25 from functools import reduce
26 print(reduce(lambda x,y:x+y,range(100),100))
27 print(reduce(lambda x,y:x+y,range(1,101)))
28
29 #用map来处理字符串列表啊,把列表中所有人都变成sb,比方alex_sb
30 name=['alex','wupeiqi','yuanhao']
31
32 res=map(lambda x:x+'_sb',name)
33 for i in res:
34 print(i)总结
十、内置函数
1 abs（） 绝对值
2 all（[1,2,'abc',]） 把里面的每个元素拿出来做bool运算所有为真即为真（源码解释里有：如果只有一个' '或者[ ]空为真）
3 ang（） 有1个为真即为真
4 bin（） 10进制转2进制
5 bool（） 判断布尔值，空、none、0（零）的布尔值为f其他均为真
6 bytes（） 把一个字符串转为字节
7 chr（） 解析一个十进制编码整数在Ascil码表中代表啥
8 dict（） 传入关键字参数后变成字典
9 dir（） 打印某一个对象有哪些内置方法
10 divmod（10,3） 代表10/3后商3余1（用作分页功能 ）
11 enumerate（） 取一个可遍历对象的索引并列出
12 eval（） 提取一个字符串中的数据结构即去掉" " 把字符串中的数学表达式算出
13 filter（）
14 float（） 将一个数字或字符串转为浮点数值
15 format（） 格式化
16 frozenset（可迭代对象） 返回一个冻结的集合 不可编辑
17 getattr（） 面向对象讲
18 delattr（） 同上
19 globals（） 修改全局变量
20 bash（） 可bash数据类型即不可变数据类型 常常用于防止木马功能
21 help（）查看帮助 dir是光打名字的
22 hex（） 10进制转16进制
23 oct（） 10进制转8进制
24 id（） 打印一个对象的内存地址
25 input（）
26 int（）
27 isinstance（i，int） 判断一个对象是不是数字T&F
28 （'abc',str） 字符串
29 （[ ], list） 列表
30 （{ }，dict） 字典
31 inter（） 迭代器里的
32 len（）
33 list（）
34 locals（）
35 print（globals（）） 打印全局变量以字典的形式
36 print（locals（）） 打印局部变量以字典的形式
37 map（）
38 max（）
39 min（）
40 补充：zip（） 拉链
41 next（） 迭代器里的
42 open（） 文件处理时讲
43 ord（） 与chr相反，把字符转成Asica码表上对应的东西
44 pow（3,3） 相当于3**3
45 （3,3,2） 相当于3**3%2 3的3次方取余
46 property（） 面向对象讲
47 repr（） 面向对象讲
48 reversed（） 反转
49 round（） 四舍五入
50 set（） 把（）里的元素for循环变成集合
51 slice（x，y，z） 切片x开始y结束z步长
52 sorted（） 排序
53 sum（） 求和
54 tuple（） 元组
55 type（） 查看某个东西的数据类型
56 vars（） def test():
57 msg = '中华人民共和国'
58 print(locals())
59 print(vars())
60 test()内置函数解释
1、简述普通参数、指定参数、默认参数、动态参数的区别
2、写函数，计算传入字符串中【数字】、【字母】、【空格] 以及 【其他】的个数
3、写函数，判断用户传入的对象（字符串、列表、元组）长度是否大于5。
4、写函数，检查用户传入的对象（字符串、列表、元组）的每一个元素是否含有空内容。
5、写函数，检查传入列表的长度，如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。
6、写函数，检查获取传入列表或元组对象的所有奇数位索引对应的元素，并将其作为新列表返回给调用者。
7、写函数，检查传入字典的每一个value的长度,如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。
dic = {"k1": "v1v1", "k2": [11,22,33,44]}
PS:字典中的value只能是字符串或列表
8、写函数，利用递归获取斐波那契数列中的第 10 个数，并将该值返回给调用者。
补充：解压序列
a, b, c, = (1 2 3)
a = 1, b = 2, c = 3
那么有一个很大的列表要去除第一个和最后一个值
l = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 ]
a,*_,c = l (a代表第一个，c代表最后一个，*代表所有，_代表要替代的元素)
a, b,*_,c, d (取第二和倒数第二)
补充2：数据交换
f1 = 1
f2 = 2
f1, f2 = f2, f1
# 函数
'''定义：将一段具有独立功能的代码块整合到一个整体并命名，在需要的位置 函数加()调用。
作用：高效的实现代码重用。'''
# 函数名
# 参数 默认参数，位置参数，关键字参数，*args（多位置）
# **kwargs（多位置包关键字）返回的是字典
# 返回值 return a,b,c----->返回元组/结束函数（返回函数调用的地方）
# 函数调用 函数名()
# 作用域 局部变量、全局变量
# 函数嵌套 ⼀一个函数里面又调用了另外一个函数
# 递归 函数内部自己调用自己，要有出口 当前层进入下一层用栈保存（效率低）
# 解决办法尾调用优化接触别的语言时可能用到
# 匿名函数 lambda 参数 : 返回结果
# 高阶函数 1.函数的参数中包含函数 or 2.函数的返回值中包含函数满足其一即可 ---->具体利用装饰器
# 内置高阶函数map(),reduce(),filter()
# 函数
print('函数实例'.center(50,'*'))
def tes(a,b):
""" 函数说明(多行注释的语法)"""
result = '%s娃哈哈\n%s'%(a+b,a*b)
return result
help(tes) #查看函数说明
print(tes(2,3))
# 递归 （函数的return返回值返回的位置是函数调用的地方）
print('递归实例1'.center(50,'-'))
def calNum(num):
if num >= 1:
result = num * calNum(num-1)
else:
result = 1
return result
ret = calNum(4)
print(ret)
#累加
def sum_add(a):
if a<=0:
return 0
return a+sum_add(a-1)
print(sum_add(5))
print('递归实例2'.center(50,'*'))
# 定义个函数：问你是第几排 并返回排数
def where_am_i(num):
# 3. 如果是第一排，不需要向前问，直接返回1即可
if num == 1:
return 1
# 2. 求前一排的排数
qianyipai = where_am_i(num-1)
# 1. 返回我自己的排数 = 前一排 + 1
return qianyipai + 1
paishu = where_am_i(4)
print(f'我是第{paishu}排')
# 青蛙跳台阶，单次跳跃1或者2个台阶，现在有n个台阶，有多少种方法？
def frog(n):
if n<=2:
sum_n = n
else:
sum_n = frog(n-1)+frog(n-2)
return sum_n
print(frog(5))
# 匿名函数
print('lambda实例1'.center(50,'-'))
# 示例1：
def bbb(a,b):
return a+b
def aaa(func):
a=2
b=5
result = func(a,b)
return result
print(aaa(bbb))
# 示例2
def ccc(func):
a=3
b=4
result = func(a,b)
return result
print(ccc(lambda a,b:a*b))
# 函数有一个返回值，并且只有一句代码，可以使用lambda简化。
print('lambda实例2'.center(50,'*'))
def hhh(func):
a,b=3,6
result = func(a,b)
result= print(result)
return {'result':result}
hhh(lambda a,b:a+b**b)
#根据字典的某一项给其排序
list1 = [{'name':'alex','age':'19'},{'name':'lxx','age':'16'},{'name':'evaj','age':'23'},]
list1.sort(key=lambda x: x['age'],reverse=True)
print(list1)
# 高阶函数
print('高阶函数'.center(50,'-'))
map()
from functools import reduce
reduce()
filter()个人总结
# 函数
'''定义：将一段具有独立功能的代码块整合到一个整体并命名，在需要的位置 函数加()调用。
作用：高效的实现代码重用。'''
# 函数名
# 参数 默认参数，位置参数，关键字参数，*args（多位置）
# **kwargs（多位置包关键字）返回的是字典
# 返回值 return a,b,c----->返回元组/结束函数（返回函数调用的地方）
# 函数调用 函数名()
# 作用域 局部变量、全局变量
# 函数嵌套 ⼀一个函数里面又调用了另外一个函数
# 递归 函数内部自己调用自己，要有出口
# 匿名函数 lambda 参数 : 返回结果
# 高阶函数 函数可以做为参数传递给另外一个函数
# 内置高阶函数map(),reduce(),filter()
# 函数
print('函数实例'.center(50,'*'))
def tes(a,b):
""" 函数说明(多行注释的语法)"""
result = '%s娃哈哈\n%s'%(a+b,a*b)
return result
help(tes) #查看函数说明
print(tes(2,3))
# 递归 （函数的return返回值返回的位置是函数调用的地方）
print('递归实例1'.center(50,'-'))
def calNum(num):
if num >= 1:
result = num * calNum(num-1)
else:
result = 1
return result
ret = calNum(4)
print(ret)
#累加
def sum_add(a):
if a<=0:
return 0
return a+sum_add(a-1)
print(sum_add(5))
print('递归实例2'.center(50,'*'))
# 定义个函数：问你是第几排 并返回排数
def where_am_i(num):
# 3. 如果是第一排，不需要向前问，直接返回1即可
if num == 1:
return 1
# 2. 求前一排的排数
qianyipai = where_am_i(num-1)
# 1. 返回我自己的排数 = 前一排 + 1
return qianyipai + 1
paishu = where_am_i(4)
print(f'我是第{paishu}排')
# 匿名函数
print('lambda实例1'.center(50,'-'))
# 示例1：
def bbb(a,b):
return a+b
def aaa(func):
a=2
b=5
result = func(a,b)
return result
print(aaa(bbb))
# 示例2
def ccc(func):
a=3
b=4
result = func(a,b)
return result
print(ccc(lambda a,b:a*b))
# 函数有一个返回值，并且只有一句代码，可以使用lambda简化。
print('lambda实例2'.center(50,'*'))
def hhh(func):
a,b=3,6
result = func(a,b)
result= print(result)
return {'result':result}
hhh(lambda a,b:a+b**b)
# 高阶函数
print('高阶函数'.center(50,'-'))函数基础--笔记
# 1.函数中return的作用
'''将函数的运行结果返回给调用的对象。'''
# 2.函数中如果有多个return，会是什么效果
'''只执行满足其判定条件的的一个return在本函数中其后面的代码将不再执行'''
# 3.定义一个函数max1，接受的参数类型是数值，最终返回两个数中的最大值
def max1(*args):
list =[]
for i in args:
list.append(i)
print(list)
result= max(list)
print(result)
max1(2,4,6,8,12,)
print('分割线'.center(50,'-'))
# 4.定义一个函数min，接受的参数类型是数值，最终返回两个数中的最小值
def min1(*args):
list=[]
for i in args:
list.append(i)
print(list)
result = min(list)
print(result)
min1(2,8,6,7,3,4,9,1,)
print('分割线'.center(50,'*'))
# 5.定义一个函数add_two 求两个数的和
def add_two(*args):
result = 0
for i in args:
result += i
print(result)
return result
add_two(2,3)
print('分割线'.center(50,'-'))
# 6.定义一个函数add_three 在上一题的基础上求三个数的和
def add_three(*args):
result = 0
for i in args:
result+=i
print(result)
add_three(2,3,9,)
print('分割线'.center(50,'*'))
# 7.将人数平均随机分配到办公室
'''
import random
def people(p_lists,n):
print(p_lists)
o_lists = [[] for i in range(n)]
print(o_lists)
while len(p_lists)>0:
ret = len(o_lists)
for i in range(ret):
if len(p_lists)>0:
peo = random.choice(p_lists)
o_lists[i].append(peo)
print(o_lists)
p_lists.remove(peo)
print(p_lists)
else:
break
print(o_lists)
return o_lists
p = ['张三', '李四', '王五', '赵六', '陈二狗', '徐发财', '唐倒霉', '派大星', '可爱迷', '范无救', '谢必安']
o= 3
people(p,o)
print('分割线'.center(50,'-'))
'''
# 8.完成一个小型的计算器 计算连个数的加减乘除
def jisuan(a,b,c):
if c == "+":
return a + b
elif c == "-":
return a - b
elif c == "*":
return a * b
elif c == "/":
return a / b
print(jisuan(10, 5, "*"))
# 9.完成一个函数，给定三个值。判断你给的值是否可以组成一个三角形（两边之和大于第三边）
def sanjia(a,b,c):
if a + b -c > 0 and a + c - b > 0 and b +c -a > 0:
return "ok"
else:
return "no"
print(sanjia(10, 15, 14))
# 10.（选做题，这个题难度有点大）
# 定义函数findall，实现对字符串find方法的进一步封装，要求返回符合要求的所有位置的起始下标，
# 如字符串"helloworldhellopythonhelloc++hellojava"，需要找出里面所有的"hello"的位置，
# 最后将返回一个元组(0,10,21,29)，即将h的下标全部返回出来，而find方法只能返回第一个
def findall(str,s):
ret = []
len(s)
if s == '':
return ret
while True:
index = str.find(s)
if index != -1:
if len(ret) != 0:
ret.append(index+len(s)+ret[-1])
else:
ret.append(index)
str = str[index+len(s):]
else:
break
return tuple(ret)
str1 = 'helloworldhellopythonhelloc++hellojava'
s1 = 'h'
print(findall(str1,s1))函数基础--练习
# 1.函数中return的作用
'''将函数的运行结果返回给调用的对象。'''
# 2.函数中如果有多个return，会是什么效果
'''只执行满足其判定条件的的一个return在本函数中其后面的代码将不再执行'''
# 3.定义一个函数max1，接受的参数类型是数值，最终返回两个数中的最大值
def max1(*args):
list =[]
for i in args:
list.append(i)
print(list)
result= max(list)
print(result)
max1(2,4,6,8,12,)
print('分割线'.center(50,'-'))
# 4.定义一个函数min，接受的参数类型是数值，最终返回两个数中的最小值
def min1(*args):
list=[]
for i in args:
list.append(i)
print(list)
result = min(list)
print(result)
min1(2,8,6,7,3,4,9,1,)
print('分割线'.center(50,'*'))
# 5.定义一个函数add_two 求两个数的和
def add_two(*args):
result = 0
for i in args:
result += i
print(result)
return result
add_two(2,3)
print('分割线'.center(50,'-'))
# 6.定义一个函数add_three 在上一题的基础上求三个数的和
def add_three(*args):
result = 0
for i in args:
result+=i
print(result)
add_three(2,3,9,)
print('分割线'.center(50,'*'))
# 7.将人数平均随机分配到办公室
'''
import random
def people(p_lists,n):
print(p_lists)
o_lists = [[] for i in range(n)]
print(o_lists)
while len(p_lists)>0:
ret = len(o_lists)
for i in range(ret):
if len(p_lists)>0:
peo = random.choice(p_lists)
o_lists[i].append(peo)
print(o_lists)
p_lists.remove(peo)
print(p_lists)
else:
break
print(o_lists)
return o_lists
p = ['张三', '李四', '王五', '赵六', '陈二狗', '徐发财', '唐倒霉', '派大星', '可爱迷', '范无救', '谢必安']
o= 3
people(p,o)
print('分割线'.center(50,'-'))
'''
# 8.完成一个小型的计算器 计算连个数的加减乘除
def jisuan(a,b,c):
if c == "+":
return a + b
elif c == "-":
return a - b
elif c == "*":
return a * b
elif c == "/":
return a / b
print(jisuan(10, 5, "*"))
# 9.完成一个函数，给定三个值。判断你给的值是否可以组成一个三角形（两边之和大于第三边）
def sanjia(a,b,c):
if a + b -c > 0 and a + c - b > 0 and b +c -a > 0:
return "ok"
else:
return "no"
print(sanjia(10, 15, 14))
# 10.（选做题，这个题难度有点大）
# 定义函数findall，实现对字符串find方法的进一步封装，要求返回符合要求的所有位置的起始下标，
# 如字符串"helloworldhellopythonhelloc++hellojava"，需要找出里面所有的"hello"的位置，
# 最后将返回一个元组(0,10,21,29)，即将h的下标全部返回出来，而find方法只能返回第一个
def findall(str,s):
ret = []
len(s)
if s == '':
return ret
while True:
index = str.find(s)
if index != -1:
if len(ret) != 0:
ret.append(index+len(s)+ret[-1])
else:
ret.append(index)
str = str[index+len(s):]
else:
break
return tuple(ret)
str1 = 'helloworldhellopythonhelloc++hellojava'
s1 = 'h'
print(findall(str1,s1))
# def findall(string,s):
# ret = []
# n = len(s)
# if s=='':
# return ret
# while True:
# index = string.find(s)
# if index !=-1:
# if len(ret)!=0:
# ret.append(n+index+ret[-1])
# else:
# ret.append(index)
# string = string[index+len(s):]
# else:
# break
# return tuple(ret)
# str1 = 'helloworldhellopythonhelloc++hellojava'
# s1 = 'h'
# print(findall(str1,s1))
# def findall(string, s):
# ret = []
# n = len(s)
# if s=='':
# return ret
# while True:
# index = string.find(s)
# if index != -1:
# if len(ret)!=0:
# ret.append(ret[-1]+index+n)
# else:
# ret.append(index)
# string = string[index+len(s):]
# else:
# break
# return tuple(ret)
# str1 = 'helloworldhellopythonhelloc++hellojava'
# s1 = 'l'
# print(findall(str1,s1))
import string
def count_letter(str):
'''求字符串中字母的数量'''
n = 0
for i in str:
# 方法一
if i.isalpha():
n+=1
else:
continue
# 方法二
# string.ascii_letters
# string.ascii_uppercase
def count_blank():
'''求字符串中空格的数量'''
pass
def count_figure():
'''求字符串中数字的数量'''
pass函数基础练习题
Victor
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
