Python5

lambda表达式和匿名函数

• lambda表达式用来声明匿名函数，lambda函数实际生成一个函数对象
• lambda表达式只允许包含一个表达式，不能包含复杂语句。

基本语法：
lambda arg1,arg2,arg3…:<表达式>
arg1,arg2,agr3为函数的参数。<表达式>为函数体
运算结果：表达式的运算结果

f=lambda a,b,c:a+b+c
def test01(a,b,c):
    return a+b+c
print(f)
print(f(1,2,3))

g=[lambda a:a*2,lambda b:b*3,lambda c:c*4]
print(g[0](6),g[1](7),g[2](8))

h=[test01,tset01]  #函数也是对象
print(h[0](2,3,4))

eval()函数用法

功能：将字符串str当成有效的表达式来求值并返回计算结果
语法：eval(source，[globals,locals])->value
参数：source:一个Python表达式或函数compile()返回的代码对象
globals:可选，必须是字典
locals:可选，任意映射对象

s="print('dd')"
eval(s) #dd

a=10
b=20
c=eval("a+b")
print(c) #30

dict1=dict(a=100,b=100)
d=eval("a+b",dict1)
print(d)  #300

递归函数

• 自己调自己，直到栈满

def test01():
    print("test01")
    test01()  #开辟栈帧
    print("##3333")  #不会执行

递归函数：

1. 终止条件
   2.递归条件

def test01(n):
    print("test01:",n)
    if n==0:
        print("over")
    else:
        test01(n-1)
    print("teat01****",n)

test01(4)

• 递归函数：阶乘案例

def f(n):
    if n==1:
        return 1
    else:
       return n*f(n-1)

for i in range(1,5):
    print(i,"!=",f(i))

• 嵌套函数：在函数内部定义的函数

一般什么情况下使用嵌套函数：

• 1.封装：数据隐藏
  外部无法访问"嵌套函数"

• 2.贯彻DRY(Don’t Repeat Yourself)原则
  降低重复代码

• 3. 闭包

def outer():
    print("outer running...")

    def inner01():
        print("inner01 running...")
    inner01()

outer()


def printChinese(name,familyName):
    print("{0} {1}".format(familyName,name))

def printEnglish(name,familyName):
    print("{0} {1}".format(name,familyName))

def printName(isChinese,name,familyName):
    def inner_print(a,b):
        print("{0} {1}".format(a,b))
    if isChinese:
        inner_print(familyName,name)
    else:
        inner_print(name,familyName)

printName("true","小气","高")

nonlocal_global

nonlocal:声明外层的局部变量
globa：声明全局变量

a=199
def outer():
    b=10
    def inner():
        nonlocal b
        print("inner b:",b) #声明外部函数的局部变量
        b=20

        global a  #声明全局变量
        a=100

    inner()
    print("outer b:" ,b)

outer()
print("a:",a)

LEGB规则

#str="global str"
def outer():
   # str="outer"
    def inner():
        #str="inner"
        print(str)
    inner()

outer()

类的定义

class Student:  #类名一般首字母大写，多个采用驼峰原则

    def __init__(self,name,score):  #self必须位于第一个参数
        self.name=name
        self.score=score
    def say_score(self):  #self必须位于第一个参数
        print("{0}的分数是： {1}".format(self.name,self.score))

s1=Student("gaoqi",18)  #通过类名()调用构造函数
s1.say_score()

• 构造函数_init_

• 实例属性
  

异常的本质

• 异常类的继承层次
  
  1.抛出异常
  2.捕获异常

#TraceBack追溯。most recent call last最后一次调用
a=1/0

try_except基本结构

try:
被监控的可能引发异常的语句块
except BaseException [as e]:
异常处理语句块

try:
    print("step1")
    a=3/0
    print("step2")  #跳高try块中异常以后的代码
except BaseException as e:
    print("step3")
    print(e)
print("step4")

try_多个except结构

try:
被监控的、可能引发异常的语句块
excep Exception1:
处理Exception1的语句块
except Exception2:
处理Exception2的语句块
…
excep BaseException:
处理可能遗漏的异常

try:
    a = input("请输入一个被除数:")
    b = input("请输入一个除数:")
    c=float(a)/float(b)

except ZeroDivisionError:
    print("异常，不能除以0")
except ValueError:
    print("异常，不能讲字符串转为数字")
except NameError:
    print("异常，变量不存在")
except BaseException as e:
    print(e)

else结构

try…except…else结构增加了"else块"。如果try块中没有抛出异常，则执行else块。如果try块中抛出异常，则执行except块，不执行else块

try:
    a = input("请输入一个被除数:")
    b = input("请输入一个除数:")
    c=float(a)/float(b)

except BaseException as e:
    print(e)
else:
    print("除的结果为",c)

finally结构

try…except…finally结构中，finally块无论是否发生异常都会被执行：通常用来释放try块中申请的资源

try:
    a = input("请输入一个被除数:")
    b = input("请输入一个除数:")
    c=float(a)/float(b)

except BaseException as e:
    print(e)
else:
    print("除的结果为",c)
finally:
    print("我是finally中语句，无论是否发生异常与否，都执行")

自定义异常

• 通常继承Exception或者其子类即可。命名一般以Error、Exception为后缀
• 自定义异常由raise语句主动抛出

class AgeError(Exception):  #继承Exception
    def __init__(self,errorInfo):
        Exception.__init__(self)
        self.errorInfo=errorInfo
    def __str__(self):
        return "年龄错误"

if __name__=="__main__":
    age=int(input("输入一个年龄"))
    if age<1 or age>100:
        raise AgeError()
    else:
        print(age)