一、函数

 1、函数的使用场景及定义

    在使用函数编程之前，我们一直是面向过程式编程，语句的堆积造成大量的代码重复，由此，函数应运而生，函数式编程是将反复使用的代码封装到函数中，使用时只需调用即可。函数的学习会让我们更快理解面向对象这一抽象的概念，面向对象即是对函数进行分类和封装。

#函数的定义def first_func():    print("This is my first function!")first_func()

def：定义函数的关键字

first_func：函数名（自定义），通过函数名来调用函数

() : 可向函数传递的参数

print... : 函数体，包含函数所有的功能语句

first_func() :  调用函数

函数的调用结果如下

C:\python36\python36.exe D:/cto3jym/day3/def_1.pyThis is my first function!

返回值：函数执行完毕后，返回给调用者的数据

 2、函数的返回值

   函数的返回值默认为None，在函数体中有return等有返回值的语句时，才有返回值；return多个对象时，解释器会把多个对象组装成一个元组作为一个整体结果输出

   我们要知道函数具体的执行结果时可以如以下发送邮件的示例

import smtplibfrom email.mime.text import MIMETextfrom email.utils import formataddrdef mail():    ret = True    try:        msg = MIMEText('邮件内容','plain','utf-8')        msg['From'] = formataddr(["jym",'jym520125@126.com'])        msg['To'] = formataddr(["gg",'614949750@qq.com'])        msg['Subject'] = "主题"        server = smtplib.SMTP("smtp.126.com",25)        server.login("jym520125@126.com","*********")        server.sendmail('jym520125@126.com',['614949750@qq.com',],msg.as_string())        server.quit()    except Exception:        ret = False    return retret = mail()print(ret)

    如示例中所示，返回值为True说明函数执行成功，邮件发送

3、参数

    1、无参数：形如上文发送邮件的例子，mail(): 无参数，那么在调用时()中也不填入参数

    2、有参数

    1.普通参数：定义函数时指定几个参数，调用时就要传入几个参数

#一个参数def show(arg):    print(arg)show("one parameter")#两个参数def show(a1,a2):    print(a1,a2)show("two parameter")

   2.默认参数：在定义函数时指定参数的默认值，调用时不传参数即返回默认值，传入参数返回传入的参数

def show(a1,a2=1):    print(a1,a2)show("default",)返回值：C:\Users\JYM\untitled\Scripts\python.exe D:/cto3jym/day3/func_parameter.pydefault 1def show(a1,a2=1):    print(a1,a2)show("default",2)返回值：C:\Users\JYM\untitled\Scripts\python.exe D:/cto3jym/day3/func_parameter.pydefault 2

 Ps：默认参数必须在位置参数的后面

         

   3.指定参数：调用时根据变量名指定参数

def show(a1,a2):    print(a1,a2)show(a2=2,a1=1)返回值：C:\Users\JYM\untitled\Scripts\python.exe D:/cto3jym/day3/func_parameter.py1 2

   4.动态参数：可灵活的传入任意参数

1、*args ：将传入的参数转为元组存入内存def f1(*args):    print(args,type(args))f1(1)函数调用结果如下(1,) 
     
      或者可以直接传入序列def f1(*args):    print(args,type(args))l1 = [11,22,33]f1(*l1)2、**kwargs：将传入的参数转为字典存入内存def f1(**kwargs):    print(kwargs,type(kwargs))f1(k1='v1',k2='v2')函数调用结果如下{'k2': 'v2', 'k1': 'v1'} 
      
       或者直接传入字典def f1(**kwargs):    print(kwargs,type(kwargs))d1 = {'k1':'v1','k2':'v2'}f1(**d1)3、*args,**kwargs：可传入任意参数def f2(*args,**kwargs):    print(args,type(args))    print(kwargs,type(kwargs))f2(11,22,33,44,k1='v1')函数调用结果如下(11, 22, 33, 44) 
       
        {'k1': 'v1'} 
        
         Ps：*args,**kwargs同时使用时，*args在前如上，如果直接传入引用名的话，会是什么样的呢def f2(*args,**kwargs):    print(args,type(args))    print(kwargs,type(kwargs))l1 = [11,22,33,44]d1 = {'k1':'v1'}f2(l1,d1)结果如下：([11, 22, 33, 44], {'k1': 'v1'}) 
         
          {} 
          
           那么，引用时指明传入的类型呢f2(*l1,**d1)结果如下：(11, 22, 33, 44) 
           
            {'k1': 'v1'} 

 4、函数的作用域

   python中的作用域分四种情况

        local：函数中定义的变量

        enclosing：父函数定义的变量，作用域包含父函数极其所有子函数

        globa：全局变量

        built-in：系统变量

   作用域查找顺序：

        1、local < enclosing < globa < built-in，在查找变量过程中，模块内定义的变量在函数内先声明就会覆盖外部变量，不声明直接使用，就会使用外部作用域的变量。

        2、函数内要修改外部作用域变量时，全局变量使用global关键字，嵌套作用域变量使用nonlocal关键字，nonlocal是python3新增的关键字。

例：

count = 1 # 全局变量def outer():    global count  # 在函数中要修改全局变量需先global声明    count+=5    print(count)def outer():    count = 1    def inner():        nonlocal count  # 在函数中要修改父级变量需先nonlocal声明,(python3新增)        count+=5        print(count)    inner()    print(count)outer()

二、内置函数

     

常用的内置函数：

abs()：取绝对值

>>> abs(-1)1

all()：传入的序列中元素都为真返回True，有假则返回False

>>> all([11,22,])True>>> all([0,None,False,[],"",11])False

any()： 传入的序列中的元素有一个为真就返回True  

>>> any([1,0,[],None,False,(),"",{},])True

bin()：将传入的参数转换为二进制

>>> bin(1)'0b1'>>> bin(16)'0b10000'

bool()：传入的参数为真时返回True，为假时返回False

>>> bool(1)True>>> bool([])False

callable()：判断传入的参数是否可被调用

>>> f = lambda x:x+1>>> callable(f)True

chr()：ord()：ASCII编码表转换

>>> chr(65)'A'>>> ord("A")65

enumerate()

>>> for i,item in enumerate([11,22,33],1):print(i,item)1 112 223 33

map()：遍历序列，对序列中每个元素进行操作，最终获取新的序列

>>> l1 = [11,22,33]>>> newlist = map(lambda a:a+100, l1)>>> for i in newlist: print(i)111122133>>> l2 = [1,2,3]>>> nl = map(lambda a,b:a+b,l1,l2)>>> for i in nl:print(i)122436

filter()：对于序列中的元素进行筛选，获取符合条件的序列

>>> l1 = [11,22,33]>>> newlist = filter(lambda x: x>20, l1)>>> for i in newlist:print(i)2233

globals()：返回当前所有的全局变量

>>> globals(){'l2': [1, 2, 3], 'f': 
     
      
        at 0x02B58978>, '__spec__': None, 'i': 33, 'nl': 
       
        , '__name__': '__main__', 'l1': [11, 22, 33], 'random': 
        
         , '__builtins__': 
         
          , 'newlist': 
          
           , '__package__': None, '__doc__': None, '__loader__': 
           
            , 'item': 33}

locals()：返回本地变量

>>> locals(){'l2': [1, 2, 3], 'f': 
     
      
        at 0x02B58978>, '__spec__': None, 'i': 33, 'nl': 
       
        , '__name__': '__main__', 'l1': [11, 22, 33], 'random': 
        
         , '__builtins__': 
         
          , 'newlist': 
          
           , '__package__': None, '__doc__': None, '__loader__': 
           
            , 'item': 33}

hex()：十六进制转换

>>> hex(16)'0x10'

oct()：八进制转换

>>> oct(8)'0o10'

id()：获取元素在内存中的位置

>>> id(1)1786045296

help()：帮助信息

input()：接受用户输入

>>> input("please input number:")please input number:11'11'

len()：长度

>>> len("123fda")6

max()：获取最大值

>>> max(11,22,33,44)44

min()：获取最小值

>>> min(11,22,33,44)11

round()：四舍五入

>>> round(0.9)1>>> round(1.1)1

reversed()：给定序列反转

>>> l1 = reversed([11,22,33])>>> list(l1)[33, 22, 11]

sorted()：给定序列排序

>>> sorted([11,33,55,22,44])[11, 22, 33, 44, 55]

sum()：给定序列求和

>>> sum([11,22])33

type()：返回对象的类

>>> type([])

zip()：

>>> x = [1,2,3]>>> y = [4,5,6]>>> z = [7,8,9]>>> z1 = zip(x,y,z)>>> list(z1)[(1, 4, 7), (2, 5, 8), (3, 6, 9)]