函数

函数：

    可以简单理解为，是为原来一个实现独立的功能代码块，起个名字。
优点：
    节省空间
    保持一致性
    必须要有“唯一”的返回值，使用return返回结果，如果没有return语句，则返回 None
                        不管函数里面是什么代码，只要遇到return立即返回并结束

形式：
def function_name([参数]):
‘’’ doc文档可选 ‘’’
代码块
函数根据有参数分类：

无参函数
即没有参数，这样函数功能相对单一
示例： 求1-100之间的各
def myadd():
ret = 0
for i in range(1,101):
ret += i
return ret

        ret = myadd()
        print(ret)

有参函数 ： 定义函数时使用的参数称为形参数，调用函数时使用的参数称为实参
位置参数（必选参数）
def myadd(arg1):
ret = 0
for i in range(1,arg1 + 1):
ret += i
return ret

        ret = myadd(100)
        print(ret)

    默认参数
        def power(n,m=2):
            tmp = n ** m
            return tmp

        ret = power(3,3)
        print(ret)
    可变长参数
    关键字参数

100道练习题

第一题
num = ‘1234’
for bai in num:
for shi in num:
for ge in num:
if bai != shi and bai!=ge and shi!=ge:
print(’{}{}{}’.format(bai,shi,ge))

第三题
def is_sqrt(num):
tmp = num ** 0.5
if tmp == int(tmp):
return True
return False

    for num in range(1,100001):
        if is_sqrt(num + 100) and is_sqrt(num + 268):
            print(num)

第十二题
def is_prime(num):
for i in range(2,num):
if num % i == 0:
return False
return True

    for num in range(101,201):
        if is_prime(num): print(num)

第十四题
num = 90
ret = []
while True:
for i in range(2,num+1):
if num % i == 0:
ret.append(i)
num = num // i
break
if num == 1:
break

    print(ret)

第十八题
a = 5
n = 8
ret = [ int(str(a) * i) for i in range(1,n+1)]
print(sum(ret))

第二十题
init_h = 100
rate = 0.5
count = 10
every_height = []

    for i in range(count):
        tmp = rate ** (i+1) *init_h
        every_height.append(tmp)

    last_heigth = every_height[-1]
    s = sum(every_height[:-1]) * 2 +init_h

    print('第{}弹起的高度为{}'.format(count,last_heigth))
    print('经过{}次落地后，经过的总路程为{}米'.format(count,s))

第二二题
for a in ‘xyz’:
for b in ‘xyz’:
for c in ‘xyz’:
if a != b and a != c and b != c:
if a != ‘x’ and c not in ‘xz’:
print(a,b,c)

内部/内嵌函数

如果一个函数内部定义了另外一个函数，则称里面的函数为内部函数
形式：
    def   function1():
        def function2():
            function_suite

典型用途  ： 闭包   装饰器

闭包：

当内部函数使用了外部函数的参数时，称为闭包
    # y = ax + 1    a=2

    def f1(a):
        def f2(x):
            y = a * x + 1
            return y
        return f2

    ret = f1(2)
    y = ret(5)
    print(y)

装饰器：

它是一个特殊的闭包，因为内部函数使用了外部函数的参数，这个参数是个函数
示例1：

 def deco(fun):
        def wapper():
            print('http://www.taobao.com/k6335435s;fl')
            return fun()
        return wapper

    def f1():
        return 'f1'

    def f2():
        print('http://www.taobao.com/k6335435s;fl')
        return 'f2'


    ret1 = deco(f1)()
    # deco(f1)()  ==>  wapper()  ==>   return f1()
    print(ret1)

    ret2 =f2()
    print(ret2)

示例2：

  def deco(fun):
        def wapper():
            print('http://www.taobao.com/k6335435s;fl')
            return fun()
        return wapper

    @deco
    def f1():
        return 'f1'

    def f2():
        print('http://www.taobao.com/k6335435s;fl')
        return 'f2'

    ret1 = f1()
    #f1()  ==> deco(f1)()  ==>wapper()  ==>　return f1()  ==>  return  'f1'  ==>   ret1 = 'f1'
    print(ret1)

    ret2 =f2()
    print(ret2)

例3： 可以处理有参数函数和无参函数的通用装饰器

 def deco(fun):
        def wapper(*args,**kwargs):
            print('http://www.taobao.com/k6335435s;fl')
            return fun(*args,**kwargs)
        return wapper

    @deco
    def f1(a,b):
        return a + b
    @deco
    def f2():
        return 'f2'

    ret1 = f1(10,20)
    # deco(f1)(10,20)  ==> wapper(10,20) ==>  f1(10,20)
    print(ret1)

    ret2 =f2()
    # deco(f2)() ==> wapper()
    print(ret2)

python 内置函数

sum max min len map filter reduce del abs sorted
map(参数1，参数2)
参数1是接收一个参数的有参函数
参数2是一个迭代对象
它会将参数2中的每一个元素依次作用于参数1，并返回一个新的迭代对象

    L = [1,2,3,4,5]

    ret = [ i * 2 for i in L]
    print(ret)

    def f1(arg):
        return arg * 2

    ret = map(f1,L)
    print(list(ret))

    使用匿名函数
    ret = map(lambda x:x * 2,L)
    print(ret)

filter(参数1，参数2)
    参数1是接收一个参数的有参函数
    参数2是一个迭代对象
    它会将参数2中的每一个元素依次作用于参数1，如果返回真则保留元素，否则不保留元素

    L = [1,2,3,4,5,11,12,14,15]

    ret = [ i for i in L if i % 2 == 0]
    print(ret)

    def f1(arg):
        if arg % 2 == 0:
            return True
        return False

    ret = filter(f1,L)
    print(list(ret))

    使用匿名函数
    ret = filter(lambda x: (x+1) % 2,L)
    print(ret)

reduce(参数1，参数2)
    参数1是接收二个参数的有参函数
    参数2是一个迭代对象
    from functools import reduce

    L = [1,2,3,4,5,11,12,14,15]

    print(sum(L))

    def f1(arg1,arg2):
        return arg1 + arg2

    ret = reduce(f1,L)
    print(ret)

    使用匿名函数
    ret = reduce(lambda x,y:x+y,L)
    print(ret)

sorted 排序函数
    sorted(iterable, key=None, reverse=False)
        sorted对可迭代对象进行排序，
        key 是接收一个参数的函数，根据返回值排序。
        reverse 指否将排序的结果进行逆序显示
        L = [('tom', 22, 90), ('bob', 18, 100), ('lily', 20, 90)]

        例1：
            L = [('tom', 22, 90), ('bob', 18, 100), ('lily', 20, 90)]

            def f1(x):
                #先按成绩排序再按年龄排序
                return x[2],x[1]

            ret = sorted(L,key=f1)
            print(ret)

            使用匿名函数
            ret = sorted(L,key=lambda x: (x[2],x[1]))
            print(ret)

        例2：
            有一列表 [11, -9, 2, 20, 33, 5, 26, -4, -16]，根据条件进行排序：
            要求1.正数在前负数在后 2.正数从小到大 3.负数从大到小
                L = [11, -9, 2, 20, 33, 5, 26, -4, -16]

                def f1(x):
                    return x <= 0,abs(x)

                ret = sorted(L,key=f1)
                print(ret)

匿名函数

lambda [参数]：表达式
有时需要实现一个功能相对简单的函数，这时可以使用匿名函数
def f():
return ‘haha’
f()
f1 = lambda : ‘haha’
f1()

ret = (lambda x,y: x + y)(10,20)
print(ret)

命名空间与作用域

我们将函数内部称为局部作用域
函数外部称为全局作用域
函数里面如果使用一个变量，没有找到，会到全局作用域中查找
全局作用域无法看到局部作用域中的值

如果局部作用域使用了全局作用域中的不可变类型的变量则不会影响全局作用域
（如果希望将局部作用域的变量和全局作用域的变量统一可以使用global关键字））
如果局部作用域使用了全局作用域中的可变类型的变量则会影响全局作用域（前提是局部作用域不能有相同的变量

var = 100

def f1():
    global  var
    var = 200
    print(var)

print(var)
f1()
print(var)

查看全局作用域和局部作用域 globals() locals()
var = 100

def f1():
    a = 10
    b = 20
    print(locals())


print(globals())
f1()

思考：
tmplist1 = [lambda :x for x in range(10) ]
tmplist2 = [ i() for i in tmplist1 ]
tmplist3 = [ (lambda :x)() for x in range(10) ]
请问tmplist1,tmplist2及tmplist3里面的元素类型或值 ，及里面元素的结果及原因？

练习题

练习8：
    def find_user(username,file):
        with open(file,'r') as f:
            for line in f:
                tmp = line.split(':')[0].strip()
                if tmp == username:
                    return line
            return None

    def main(username):
        ret = [username]
        passwd = find_user(username,'passwd')
        shadow = find_user(username,'shadow')
        if passwd and shadow:
            ret.append(shadow.split(':')[1])
            ret.append(passwd.split(':')[2])
            ret.append(passwd.split(':')[5])
            return ','.join(ret)
        else:
            return '{} is not exists'.format(username)

    for user in ['root','bin','nobody']:
        ret = main(user)
        print(ret)

练习9：
        def save_file(data,file='stu.csv'):
            with open(file,'a',encoding='utf-8') as f:
                f.write(data)

        f = open('stu.txt','r',encoding='utf-8')
        first_line = f.readline()
        first_line = ','.join(first_line.split())
        save_file('{}\n'.format(first_line))

        for line in f:
            tmp = line.strip().split()
            score = [int(i) for i in  tmp[1:]]
            avg = sum(score) / len(score)
            avg = '{0:.1f}'.format(avg)
            tmp.append(avg)
            tmp = ','.join(tmp)
            save_file('{}\n'.format(tmp))

        f.close()


练习十：
    jiu = 10 // 2
    pingzi = 0
    pinggai = 0
    pingzi_rate = 3
    pinggai_rate = 6
    all = 0

    while jiu:
        all += jiu
        pingzi += jiu
        pinggai += jiu

        jiu = pingzi // pingzi_rate
        pingzi = pingzi % pingzi_rate

        jiu += pinggai // pinggai_rate
        pinggai %= pinggai_rate

    print(all)