python中的函数的完整介绍，很全很全（第一部分）！！！

函数作用：实现代码的复用
函数概念：函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。
函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。
系统的几个内建函数：现成的函数，不需要定义def
# 1、绝对值：abs(-1)
# 2、最大最小值：max([1,2,3])、min([1,2,3])，对序列进行操作
# 3、序列长度：len('abc')、len([1,2,3])、len((1,2,3))
# 4、乘方：pow(2,3,4) // (2**3) % 4

# 5、浮点数：round(3.1415926, 2) //3.14 四舍五入 ,比较重要，

f=11.0/3
print round(f,3)  #科学的四舍五入

返回：3.667# 6、类型转换函数：int()、str()....
 

======================================================

四种函数的类型：函数根据有无参数，有无返回值，可以相互组合，一共有4中

1. 无参数、无返回值
2. 无参数、有返回值
3. 有参数、无返回值
4. 有参数，有返回值                                                                                      =====================================================

<1> 无参数，无返回值的函数，此类函数，不能接受参数，也没有返回值，一般情况下，打印提示类共能

def printMenu():
    print("===========")
    print("点菜系统")
    print("1,羊肉火锅")


printMenu()

<2>无参数、有返回值的函数，不接受参数，但是可以返回某个数据，一般情况下，采集数据

def getTempar():
    return 24


tem = getTempar()
print(tem)

打印：

<3> 有参数、无返回值的函数，对于接受数据，但是不需要结果的

def getTempar(a):
    listnew = []
    listnew.append(a)


tem = getTempar(1)
print(tem)

 结果：None

<4>有参数，有返回值   ，处理数据并且需要结果的函数

def calculateNum(num):
    result = 0
    i = 1
    while i <= num:
        result = result + i
        i += 1
    return result


result = calculateNum(100)
print(f'1到100的累计和为：{result}')

结果： 1到100的累计和为：5050

# 7、比较函数cmp()
还有一个重要的函数：匿名函数，lambda表达式，通常是在需要一个函数，但是又不想费神去命名一个函数的场合下使用，也就是指匿名函数。 

def func(x,y):

return x+y
func = lambda x,y:x+y  #上面这个函数就可以直接用lambda函数写出来，是两个等价的函数
创建函数语法
def 函数名(参数列表)：
函数语句/函数体

函数的命名规则：驼峰命名：每个单词首字母要大写

小驼峰命名规则，一个单词直接小写   # 多个单词，每个单词小写，以下划线分隔 ge_student_name

大驼峰：单词首字母大写

类名，文件名，首字母大写，每个单词首字母大写

方法名：首字母小写，每个单词首字母大写 ，中间可能会加下划线

文档化说明的函数：注意：函数首行加 ''  或 ''' '''使用函数名.__doc__属性 可以查看函数文档

def sum():
    '''
这是第一个函数
    '''
    pass                            ####pass是用来占位的

print sum.__doc__  #内置变量，双下划线，内置的固定参数，输出函数说明

输出函数说明： 这是第一个函数help(函数名),例子：

callable(函数名) --判断函数是否可以被调用：debug的时候经常报错，xx is not callable --说明你应该在报错的地方给一个函数，结果你给的xxx不能当函数用

判断a=0，是否是函数

 

a=0
print callable(a)

返回结果：False

例子：因为key后面要加一个函数，但是a不是函数，所以就会报错，截图错误，就表示a不能当函数用

dic=[1,2,3]
a=0
print sorted(dic,key=a)

控制台输出：

函数的参数：参数可以指定参数名，也可以不指定参数名，下面是两个例子：

#不指定参数名
def my_function(a,b):
    print a+b
my_function(1,2)
#可以指定参数名
def my_function(name,age):
    print '姓名：%s，年龄：%s'%(name,age)
my_function(name='zhangsan',age=12)

默认参数的使用 

  *顺序：带默认值的参数往后放，后面不能再有必填参数，带有默认值的参数后面一定不能再有参数了

def function(age=6,name):   #后面不能再有必填参数的，这种写法就是错误的
    print name,age
function(6,'zhangsan')
function('zhangsan')

*初始化逻辑：默认值最好是不可变数据类型：如果是不可变数据类型，默认为空最好用None，别用[]，因为第第一次赋值的值，会一直记录

def extendList(val, list=[]):
    list.append(val)
    return list
list1 = extendList(10)
list2 = extendList(123, [])
list3 = extendList('a')
print "list1 = %s" % list1
print "list2 = %s" % list2
print "list3 = %s" % list3

结果：

list1 = [10, 'a']
list2 = [123]
list3 = [10, 'a']

例子：直接给age指定了年龄18

#使用默认值
def my_function2(name,age=18):
    print '姓名：%s，年龄：%s'%(name,age)
my_function2('zhangsan')

可变参数：传递参数的个数是可变的，参数是不定的，在参数后面加 * ，表示后面有若干个参数，当元祖来处理的      语法：def checkin(name, id, *other):  other  函数是是当元组来处理的

def checkin(name, id, *other):
    print '姓名：%s, 工号：%s, 其他信息：%s' % (name, id, other)
#
checkin('梁水', '12341', 1231231232, '山西省太原市','water')

也支持多个*号，两个*的不可变数据类型，在函数内部是当字典来处理的 ，选填参数

 

def checkin2(name, id, **other):
    print '姓名：%s, 工号：%s, 其他信息：%s' % (name, id, other)

checkin2('water', '1234', phone = 13800000000, address = '北京哇哈哈')

**参数定义的顺序必须是：必选参数、默认参数、可变参数（name,age=6,**other）

函数的作用域的问题

关于函数返回的几种理解： return的优先级高于一切

见到return 函数就结束，即使函数里面有多个return，程序不会出错，但是函数结束，也不会运行return后面的代码

函数返回值 ，如果有return，return 后面的值就有返回的值

所谓返回值：就是程序中函数完成一件事情后，最后给调用者的结果！！

举例说明：  带有2个参数的函数，

# 定义函数： 
def jian(a, b):
    c = a - b
    return c


# 调用函数，顺便保存函数的返回值
result = jian(90, 9)

# 因为result已经保存了函数的返回值，所以接下来可以使用了
print(result)

结果： 81  

def a():
    print '能打印吗？'
    return 0,1
print a()    
#结果就是： 能打印吗？
            (0, 1)

下面这种：

def a():
    return 0, 1
    print '能打印吗？'

print a()

#结果就是 (0, 1)

不写return无返回--None

只写return 返回None

 

def my_function2(name):
    print '姓名：%s,' % (name)
    return 
print my_function2('beijing')   #返回 None

return里面有多个值--实际返回的是元祖，如图

 

def my_function2(name):
    print '姓名：%s,' % (name)
    return 1,2,4,5,6
print my_function2('beijing')       #执行结果：姓名：beijing,     (1, 2, 4, 5, 6)

递归：函数自己调自己，如果一个函数在内部调用自身，这个函数叫做递归函数，递归调用的次数过多，会导致栈溢出 ：要慎重

def a():
    print 'a'
    a()

a()

递归函数的两个练习：回声练习和阶乘

 

1.求一个数n的阶乘

def fact(n):
    if n == 1:
        return 1
    return n * fact(n - 1)

print fact(5)

 

2.编写一个递归函数，达到回声的效果
比如：同志们你们好吗
输出：同志们你们好吗 志们你们好吗 们你们好吗 你们好吗 们好吗 好吗 吗

 

 

def fact_voice(context):
    if len(context) == 0:
        return 0
    print context,
    context = context[1:]
    return fact_voice(context)

fact_voice(u'同志们你们好吗')

高阶函数：可以理解为函数套函数，函数的参数里面也带一个函数，最基本的几个高阶函数的应用，函数的参数是函数

map():函数接收两个参数，一个是函数，一个是序列，将传入的函数依次作用到序列的每个元素，并把结果作为新的list返回
应用：并行遍历--序列合并

a = [1, 2, 3, 4, 5]
print map(lambda x:x**2,a)  #序列的每一项都2次方

reduce():把一个函数作用在一个序列上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算

a = [1, 2, 3, 4, 5]
print reduce(lambda x,y:x*y,a)   #求乘积

filter():“筛选”函数
·和一个序列

把传入的函数依次作用于每个元素，根据返回值是True还是False决定保留还是丢弃该元素

 

a = [1, 2, 3, 4, 5]
print filter(lambda x:x%2==0,a)  #筛选偶数

"""1.利用map()函数，把用户输入的不规范的英文名字，变为首字母大写，其他小写的规范名字。
输入：['adam', 'LISA', 'barT']，输出：['Adam', 'Lisa', 'Bart']"""
data = ['adam', 'LISA', 'barT']

print map(lambda x:x.capitalize(), data)

下面这个函数是自己刚开始学习不太懂，老公给我出的一个题目，哈哈哈哈，让我明白了函数与函数之间的调用：

# 题目# 想和史华涛结婚， 他必须满足几个条件， 如果满足 （每个条件就是一个函数）， 输出结婚的时间# 1. 必须在24-27 之间# 2. 必须爱我

# 3. 必须有money，

哈哈，竟然暴露了自己的结婚日期

 

def andShtsGetMarry(age,islove,ismoney):
    if isageok(age) and isloveme(islove) and hasmoney(ismoney):
        return '2016-12-24'
    else:
        return ''

def isageok(age):
    if age in [24,25,26,27]:
        return True
    else:
        return False


def isloveme(love):
    if love=='love':
        return True
    else:
        return False


def hasmoney(money):
    if money>10000:
        return True
    else:
        return False

print andShtsGetMarry(27,'love',1000000000)

练习题二：#双11要采购一些生活用品，但是money有限，只有200元，
#牛奶 20元 面包 2元 苹果5块 衣服 50 鞋子70 菜10元 零食22 饮料8 水7块 羽毛球 60

#1:随便输入几件自己喜欢的，输出购买商品和剩余的money

 

goodlist=[{'goodsname':'milk','goodsprice':20},
{'goodsname':'bread','goodsprice':2},
{'goodsname':'apple','goodsprice':5},
{'goodsname':'clothers','goodsprice':50},
{'goodsname':'apple','goodsprice':70},
{'goodsname':'vegetable','goodsprice':10},
{'goodsname':'drunkfood','goodsprice':22},
{'goodsname':'drink','goodsprice':8},
{'goodsname':'water','goodsprice':7},
{'goodsname':'ball','goodsprice':60}]
restmonye=200
#判断输入的商品名称是否存在商品列表里面
def isExitGoodslist(goodsname):
    for i in goodlist:
        if goodsname == i.values()[0]:
            return True
    return False

#判断剩余余额是否能购买此商品
def isenoughmoney(goodsname):
    global restmonye
    for i in goodlist:
        if goodsname == i.values()[0]:
            price = i['goodsprice']
    if restmonye>= price:
        restmonye-=price
        return True,price
    else:
        return False,0

def manygoods():
    goods=raw_input('请输入你要购买的商品：')
    if isExitGoodslist(goods):#判断商品存在
        if isenoughmoney(goods)[0]: #判断是否可以购买
            print goods,restmonye
            return manygoods()
        else:
            return '钱不够了'
    else:
        print '商品不存在'
        return manygoods()
# print manygoods()

#2：看看最多能买多少件，剩下多少钱
#3：最少能买多少件，剩下多少钱

学到了知识点：

1：如果要在函数里面修改全局变量，就需要在函数里面添加global修饰，即 global 全局变量名

2：return 后面加函数名，表示结束本次并且调用新的函数

3：字典是无序，所以使用要注意索引方式取值可能会混乱，要通过key来取值

4:  行参：函数后面跟的名字def(a,b) a b 就是行参，是参数的名称，实参：实实在在传递的值

函数总结：把具有独立功能的代码，拿出来，然后制作成一个整体，这个整理就叫做函数

定义了一个函数，仅仅表示有这个函数，这个函数是不会自动运行的

调用函数：即去执行这个函数中的代码

库函数：系统中给的，不需要自己编写，只需要调用即可 例如：print(),raw_input(), 等等 time.localtime()

自定义的函数，自己去定义的函数，