函数的进阶(三)

目录

• 匿名函数
  • 与内置函数联用
• 内置函数
• 异常处理
  • 提前预防
  • 之后预防
  • 万能异常Exception
• 面向过程编程

匿名函数

匿名函数他没有绑定的名字，使用一次即被回收，加括号可以运行

lambda x,y:x+y

res = (lambda x,y:x+y)(1,2)
print(res)

 # 3

与内置函数联用

匿名函数通常与max()、sorted()、filter()、map()

 # max()
salary_dict = {
    'nick': 3000,
    'jason': 100000,
    'tank': 5000,
    'sean': 2000,
    'z': 1000
}

s= max(salary_dict,key = lambda name: salary_dict[name])
print(list(s))

 # jason'

 # sorted()
def func(item):
	return item

s = sorted([1,4,3,2,6,5],key=item,reverse=True)
print(list(s))

 # filter()
salary_dict = {
    'nick': 3000,
    'jason': 100000,
    'tank': 5000,
    'sean': 2000,
    'z': 1000
}
s = filtet(lambda name:salary_dict[name]>3000,salary_dict)
print(list(s))

 # map
def func(item):
    return item+2
s = map(func,[1,2,3])
print(list(s))

内置函数

1. bytes

   res = bytes('你好',encoding='utf8')
   print(res)
   
    # b'\xe4\xbd\xa0\xe5\xa5\xbd' 解码字符。
   

2. chr/ord

   print(chr(65))
    # A
   print(ord('A'))
    # 65
    # chr()参考ASCII码表将数字转成对应字符；ord()将字符转换成对应的数字。
   

3. divmod

   print(divmod(10,3))
    # (3,1)
    # 分栏
   

4. enumerate

   lit = ['a','b','c']
   for i in enumerart(lit):
       print(i)
       
    # (0, 'a')
    # (1, 'b')
    # (2, 'c')
   

5. eval

   lis = '[1,2,3]'
   
   print(eval(lis))
   
    # 把字符串的引号去掉,留下来的是什么就是什么
   

6. hash

   print(hash(123123))  # 不可变类型返回本身
   lis = [1,2,3]
   print(hash(lis))	 # 可变类则报错，为不可西哈
   

异常处理

提前预防

AGE = 10
while True:
    age = input('>>: ').strip()
    if age.isdigit():  # 只有在age为字符串形式的整数时，下列代码才不会出错，该条件是可预知的
        age = int(age)
        if age == AGE:
            print('you got it')
            break
            
 # 如果错误发生的条件是可预知的，我们需要用if进行处理：在错误发生之前进行预防

之后预防

# 基本语法为
try:
    # 被检测的代码块
except 异常类型：
    try #中一旦检测到异常，就执行这个位置的逻辑

 # 如果错误发生的条件是不可预知的，则需要用到try...except：在错误发生之后进行处理

万能异常Exception

s1 = 'hello'
try:
    int(s1)
except Exception as e:
    print(e)

面向过程编程

面向过程编程是解决问题的一种思想，相当于武林门派，武林门派之间没有好坏之分，因此它与我们之后学习的面向对象编程其实没有好坏之分。

面向过程编程，核心是编程二字，过程指的是解决问题的步骤，即先干什么、后干什么、再干什么、然后干什么……

优点：复杂的问题流程化，进而简单化。

缺点：扩展性差