Python学习笔记 - day6 - 函数

函数

　　函数在编程语言中就是完成特定功能的一个词句组(代码块)，这组语句可以作为一个单位使用，并且给它取一个名字。可以通过函数名在程序的不同地方多次执行（这叫函数的调用）。函数在编程语言中有基本分为：预定义函数，自定义函数。预定义函数可以直接使用，而自定义函数顾名思义需要我们自己定义函数。

为什么要使用函数

　　在编程中使用函数主要有两个优点：

　　1、降低编程难度：通常将一个复杂的大问题分解成一系列的小问题，然后将小问题划分成更小的问题，当问题细化为足够简单时，我们就可以分而治之，各个小问题解决了，大问题就迎刃而解了。

　　2、代码重用：避免重复劳作，提供效率

函数的基本使用

　　在Python中，定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用return语句返回。

　　我们以自定义一个求绝对值的函数为例：

def jueduizhi(x):
    if x >= 0:
        return x
    else:
        return -x

　　函数体内部的语句在执行时，一旦执行到return时，函数就执行完毕，并将结果返回。因此，函数内部通过条件判断和循环可以实现非常复杂的逻辑。

　　如果没有return语句，函数执行完毕后也会返回结果，只是结果为None。return None可以简写为return。

　　调用函数，那么只需要使用函数名加括号，就能执行，但如果函数定义了参数，那么必须在执行的时候传递参数给函授，否则会报异常！

jueduizhi(-10)

函数的参数

函数的参数按照定义和传递的情况时分为形式参数和实际参数。

　　1、形式参数：在定义函数时，函数名后面括号中的变量名称叫做形式参数，或者成为形参。

　　2、实际参数：在调用函数时，函数名后面括号中的变量名称叫做实际参数，或者成为实参。

　　PS：命名规则：两个单词的话，第二个单词大写，看起来比较清楚。

而形参又分为：位置参数，关键字参数，可变位置参数，可变关键字参数，命名关键字参数

默认参数

　　def func(arg = 'value'),表示如果arg没有传值，那么它默认等于values，如果对某个参数设定了默须放在参数列表中的最后。

　　特点:调用参数的时候非默认传递，可以根据默认值来预先编写函数逻辑

　　注意：默认参数最好指向不变的对象

　　对默认参数进行赋值的时候，可以用位置参数进行赋值，也可以用关键则参数进行赋值

可变参数（参数组）

　　*args：表示参数可能是多个的，函数内部使用元祖tuple来存储这些参数

可变关键字参数

　　**kargs：也表示参数是多个的，只是函数内部使用dict来存储这些参数，适用于var = value（关键字）的方式传值！

 

　　主要区别：

　　　　1、*args接受的是N个位置参数，用元祖存储

　　　　2、**kwargs接受的是N个关键字参数，用字典存储

　　　　注意：

　　　　　　1、当函数接受可变参数的时候，如果我们刚好有一个list 或者tuple，可以直接在前面加上*，把元素变成可变参数进行传递

　　　　　　2、如果已有字典要传递给函数的话，可以在传递的时候加上**，把字典的key，value变成关键字参数进行传递

　　　　　　3、三个参数的位置不能调换，若同时存在arg,*argv,**kargv,必须先给arg赋值（除非它有默认值）,然后才能给*argv和**kargv赋值。

命名关键字参数

　　我们可以指定命名关键字参数进行传递，如果传如的关键字参数没有包含命名关键字参数，那么将会报错。

　　如果函数有可变参数，那么可以在后面直接定义命名关键字参数，如果函数只有位置参数，那么命名关键字参数之前就需要添加*，来隔开，表示后面的为命名关键字参数

def func(name,age,*,city,job):
print(name,age,city,job)
>>> func('daxin',22,city='beijing',job='linux')
daxin 22 beijing linux

　　这里可以指定命名关键字的默认值

 函数的返回值

　　return var，在函数的内部把某个结果进行返回,return之后直接跳出函数。

　　返回值数量=0，即return(或者不写return语句)，返回的数据为None。

　　返回值数量=1，返回object(一个对象)。

　　返回值数量>1，返回tuple(一个元组)。

用return的方式取得proc下的进程号

#!/usr/bin/env python

import os

PidFile = os.listdir('/proc')

def isPid(pid):
    if pid.isdigit():
        return True
    return  False

for i in PidFile:
    if isPid(i):
        print i,

　　注意：在函数中我们一般不会对结果进行打印，而是使用return把结果返回给调用它的地方。

函数的变量

函数的变量分为局部变量和全局变量，Python中的任何变量都有自己特定的作用域：

　　1、在函数中定义的变量一般只能在该函数内部使用，这些只在程序的特定部分使用的变量叫做局部变量

　　2、在一个文件顶部定义的变量可以供文件中任何函数调用，这些为整个程序所使用的变量叫做全局变量

调用规则

　　1、全局变量可以在函数内部调用，但是不能修改，如果修改需要在函数内部使用 global x 来声明

　　2、局部变量不能再函数外部生效，函数执行完毕自动销毁，但在函数内部可以使用global x 来声明局部变量达到全局使用的目的

三元运算符和匿名函数

正常情况下如果想要判断两个数字的大小，需要如下代码：

if 1 > 3:
    print 'lt'
else:
    print 'gt'

运用三元运算符：（三目运算符）

print 'lt' if 1>3 else 'gt'

 解读：

　　如果 1大于3，那么返回lt，否则返回gt。这样写起来既简单，逼格又高。

匿名函数

　　Python中的匿名函数一般指lambad，lambda 函数是一种快速定义单行的最小函数，可以用在任何需要函数的地方

# 常规版本：
def fun(x,y)
    return x*y

# lambda版本：
r = lambda x,y:x*y
print(r(1,2))

基本格式：

lambda 参数列表：[表达式]

由于lambda返回的是函数对象（构建的是一个函数对象），所以可以定义一个变量去接收　　

匿名函数优点：

　　1、使用Python写一些脚本时，使用lambda可以省去定义函数的过程，让代码更加精简。

　　2、对于一些抽象的，不会被别的地方再重复使用的函数，有时候函数起个名字也是个难题，使用lambda不需要考虑命名的问题

　　3、使用lambda在某些时候然后代码更容易理解

# 搭配reduce的应用
# reduce(fun,list)
# reduce依次把list中的数字赋值给fun进行计算
# 注意fun必须是连个数字间的运算，list必须是整型数字
 
# 例：求1到100的累加
reduce (lambda x,y:x + y,xrange(1,101)
 
 
# 应用：
ret = (lambda x,y:x+y)(2,3)
print(ret)
 

一般用在函数逻辑比较简单，在程序内基本不会重复调用的函数，节省代码量。

Python内置函数

　　内建函数，Python内置的函数（build in function），不需要引用其他包，一般成为BIF.

abs()  # 计算绝对值,abs(-10),接收number，返回一个number
 
max() # 求序列的的最大值（可迭代的），同时也可以比较一些数字
 
min() # 求序列的最小值（可迭代的），同时也可以比较一些数字
 
len() # 求序列的长度，（字典也可以，求index的个数）
 
divmod(x,y)    # 求x,y的商和余数，存放在元组中
 
pow(x,y,z) # 求x的y次方，如果有第三个参数，那么把前面的结果和第三个参数求余
 
round(number) # 用来四折五入，后面可以跟精度（先把number编程浮点数，然后看保留几位）把12.45转换成float，那么就不是12.45了，而可能是12.4999999了
 
callable() # 判断一个对象是否是可调用的，比如函数，类都是可以调用的，但是变量无法调用
 
type（） # 查看对象的类型
 
isinstance（对象，类型） # 判断一个对象是否是给定类型。类型可以是多个，只要是其中1个即可(类型1，类型2)
 
cmp（x,y） # 比较两个对象的大小，x大于y返回1，x等于y返回-1，x小于y返回-1，字符串也可以比较，是按单个字符的大小开始比对。
 
str() # 可以把任何数据转换成字符串（字典，元组，也会直接输出）
 
hex(10) # 把10进制转换为8进制
 
eval() # 把字符串当做一个有效的表达式来求值
# eval('1+2') 返回3
# eval("[1,2,3]") 返回[1,2,3]
 
oct() # 把10进制转换为8进制
 
chr(i) # i的范围是0~255，求i对应的acsii码值
 
ord(i） # i的范围是ascii的值，求对应的值
 
filter（函数或空，序列） # 用来过滤，把序列的每一个元素，交给函数来处理。如果为None，则什么也不做，直接输出（序列），如果有函数，那么只有函数的返回值为True才打印序列中的元素
例子：
def even(n):
    if n % 2 == 0:
        return True
    filter(even,xrange(10))
    [0, 2, 4, 6, 8]
高级写法：
    filter(lambda x: x%2 ==0,xrange(10)
 
zip(seq1，seq2,seqN...) # 把seq1和seq2组合成1个大的列表，每个序列取1个组成元组，存放在整合后的列表中，如果序列的长度不同，那么就以最小的序列的长度为基准。
 
map(func,seq1,seq2) # 返回也是一个列表，func可以是一个函数也可以是个None，如果为None，那么返回的列表长度以当前最长列表为基准，依旧是依次去每个列表中去取，只不过没有的，用none补充
例子：
l1 = [1, 2, 3]
l2 = ['a', 'b', 'c', 'd']
l3 = ['I', 'II', 'III', 'IV', 'V', 'VI']
map(None,l1,l2,l3)
[(1, 'a', 'I'),
(2, 'b', 'II'),
(3, 'c', 'III'),
(None, 'd', 'IV'),
(None, None, 'V'),
(None, None, 'VI')]
# 如果函数位上是一个函数，那么如果只有1列表，那么就需要这个函数定义1个参数，然后每次把列表中的1个元素交给函数进行处理，并打印，或者保存在迭代器中去
# 如果需要处理两个序列，那么函数就必须定义2个参数，去接受这两个序列的元素。
# 高级应用：
map(lambda x,y:x+y,l1,l4)
 
reduce(func,seq) # 只能定义1个序列，然后传递给func进行处理。（lambda函数求累加）

函数高级

主要说明一些函数的高级用法

函数对象 　　

函数是第一类对象，可以当作数据进行传递，具有如下特点
1、可以被引用

def func():
    print('from func')

f = func     #把函数地址当作变量一样进行传递
f() 

2、可以当作参数传递

def func():
    print('from func')

def wapper(func):
    print('from wapper',func)

wapper(func)  #把函数的地址作为变量传递给另一个函数

注意：把函数作为参数传入，这样的函数称为高阶函数.

3、返回值可以是函数

def func():
    print('from func')

def wapper(func):
    return func

f = wapper(func)     #把函数的内存地址传递，并返回，用f接收那么f就等于func的内存地址，那么加上括号就可以运行

f()

4、可以当作容器类型的元素

def func():
    print('from func')

func_dict = {'func':func}    #直接作为字典的值存储，那么调用函数就可以用  func_dict['func']() 直接进行调用了

函数嵌套

函数的嵌套主要分为嵌套调用，以及嵌套定义。

1、函数的嵌套调用

def max2(a,b):   #判断两个变量的最大值
    return a if  a > b else b

def max4(a,b,c,d):  #判断四个变量的最大值
    res1 = max2(a,b)  #函数的嵌套调用
    res2 = max2(res1,c)
    res3 = max(res2,d)
    print(res3)

max4(10,100,21,99)

2、函数的嵌套定义

def func1():
    print('from func1')
    def func2():
        print('from func2')
        def func3():
            print('from func3')
        func3()  # 只有在func2中才能调用内部定义的函数func3
    func2()

func1()

注意：在函数的内部定义函数，所以内部函数的作用于就在外部函数内，在其他地方就无法进行调用

列表生成式

通过简洁的语法可以生成一个列表，或者对一组元素进行过滤，还可以对元素进行转换处理的式子。

# 语法格式：  [ exp for val in collection if condition ]

[ i for i in range(1,11) if i % 2 == 0 ]

# 列表生成式打印 1-10 中的偶数

1 def func():
2     a = []
3     for i in range(1,11):
4         if i % 2 == 0 :
5             a.append(i)
6     return a 
7 
8 
9 print(func())

普通的方法获取1-10中的偶数

　　通过列表生成式，我们可以直接创建一个列表，但是收到内存限制，列表容量肯定是有限的，而且创建一个包含100万个元素的列表，不仅占用很大的存储空间，如果我们仅仅需要访问前几个元素，那后面绝大多数元素占用的空间都白白浪费了。

　　所以，如果列表元素是可以按照某周算法推算出来，那我们是否可以在循环过程中不断的推算处后续的元素呢？这样就不必创建完整的list，从而节省大量的空间，在Python中，这种一边循环一边计算的机制，成为生成器(generator)。

生成器

　　要创建一个generator，有很多种方法，第一种方法是把一个列表生成器的[]，换成(),就创建了一个生成器。

　　生成器是一次生成一个值的特殊类函数，简单来说如果在函数的执行过程中使用yield关键字，那么这个函数就变成了一个生成器，yield语句会把需要的值返回给调用生成器的地方，然后退出函数，下一次调用生成器的时候又从上一次中断的地方开始执行，而生成器内的所有变量参数都会被保存下来，供下一次使用。　

# 修改列表生成式，创建生成器
a = ( i for i in range(1,11) if i % 2 == 0 )


# 使用yield关键字创建 生成器
def func():

    for i in range(1,11):
        if i % 2 == 0 :
            yield i

　包含yield语句的函数会被Python解释器翻译为生成器。当函数被调用时，返回的是一个生成器对象，这个对象支持迭代器借口，每当遇到yield关键字的时候，你可以理解成函数的return语句，yield后面的值，就是返回的值，但不是想一般的函数在return后退出函数，生成器函数在生成值后会自动刮起并记录当前执行的状态，在函数恢复时会从上一次yield语句的后面继续执行后面的语句，直到遇到下一个yield语句。

区别：

• 一个直接返回了表达式的结果列表，而另一个是一个对象，该对象包含了对表达式结果的计算引用，通过循环可以直接输出。
• 生成器不会一次性列出所有的数据，当你用到的时候，在列出来，更加节约内存。
• 如果想要列出所有的数据，可以使用for循环，或者直接使用list()，来创建。

迭代器

重复的过程为迭代，每次重复既一次迭代，并且每次迭代的结果是下一次迭代的初始值,为什么要用迭代器？ 使没有索引的数据类型，依然能够通过循环，迭代去获取数据的方式.

可迭代对象

可迭代的对象，具有 __iter__ 方法的对象，而执行 __iter__ 方法，那么对象就变成了迭代器。迭代器没有索引，只能通过 __next__ 方法来获取元素，每执行一次，获取一个元素，当迭代器被获取完毕，__next__ 会抛出异常：StopIteration,表示没有值了
例子：
　　迭代一个字典，对于字典进行迭代，那么默认只能获取字典的key，但是可以通过其他方法来获取字典的value

dic = {'a':1,'b':2,'c':3}
d = dic.__iter__()
while True:
    try:
        key = d.__next__()    #获取字典的key
        print(dic[key])       #通过key获取value
    except StopIteration:
        break

扩展：
　　1）既然一个对象的长度可以用len,或者用对象的 __len__()方法，其实执行len(对象)，其实就是在执行对象的 __len__ 方法
　　2）那么把一个对象转换为迭代器，不仅仅可以用对象的 __iter__()，也可以使用iter(对象)，来进行转换
　　3）获取迭代器的元素，不仅仅可以用 __next__(),也可以用next(对象)

 迭代器的特点

1、如何判断对象是可迭代对象，还是迭代器对象　　

from collections import Iterable,iterator
print(isinstance('abc',Iterable))

# collections里面放着python内置的扩展的数据类型
# 通过导入特殊的数据类型来进行判断

2、可迭代的数据类型

只要对象含有__iter__方法，执行__iter__方法，可以得到迭代器对象，列表，元祖，字典，字符串，集合，文件描述符 (可以对可迭代对象执行__iter__方法来变成迭代器)

3、迭代器协议

　　1）对象有__next__,__iter__方法称为迭代器
　　2）对于迭代器对象来说，执行__iter__得到的结果，仍然是它本身。（for循环有关）

4、for循环原理

　　1）遵循迭代器协议，执行对象的__iter__方法，然后利用__next__（next）去获取元素
　　2）并且会帮我们捕捉异常，并且进行break
　　3）所以for循环的对象必须具有__iter__方法（可迭代对象变成了迭代器，而迭代器执行__iter__还是迭代器）
　　4）for循环又称为迭代循环

5、迭代器的优点和缺点

　　优点：
　　　　1）提供了一种不依赖下标的迭代方式（非序列对象可以被迭代）
　　　　2）就迭代器本身来说，更节省内存（只有对迭代器进行next方法，才会读取下一个值）
　　缺点：
　　　　1）迭代器只能被迭代一次，既一次性的，不如序列类型灵活
　　　　2）只能往后取值，不能往前倒退
　　　　3）无法获取迭代器对象的长度

装饰器

　　如果我们想在一个已经上了线的项目上的某个函数上添加一个功能，但是又不希望更改函数的源代码，这种在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）。

　　本质上，decorator就是一个返回函数的高阶函数。所以，我们要定义一个能打印函数运行时间的decorator。

import time

def timer(func):

    def wapper():
        start_time = time.time()    
        res = func()
        end_time = time.time()
        return res,(end_time - start_time)
    return wapper


@timer       # 在被装饰函数上添加 Python 特有的语法棒棒糖表示，装饰后面的函数
def index():

    time.sleep(3)
    return 'hello index'

print(index())

　@timer：表示 index = timer(index) , 其实就是把原来的index函数给偷偷替换了。　

这个时候会出现一个问题，我们都知道使用func.__name__会打印当前函数的名称，而虽然我们偷偷替换了index函数，但是在打印func.__name__的时候，还是会打印wapper，那是因为我们真正执行的是wapper函数，那么有些依赖函数签名的代码执行就会出错。

所以这里在wapper函数上添加Python内置装饰器，来继承该属性

import time
import functools   # 需要引入代码包

def timer(func):
    @functools.wraps(func)   # 继承函数的__name__等属性 
    def wapper():
        start_time = time.time()
        res = func()
        end_time = time.time()
        return res,( end_time - start_time )
    return wapper


@timer
def index():

    time.sleep(3)
    return 'hello index'

print(index.__name__)

转载于:https://www.cnblogs.com/dachenzi/p/7757654.html