函数晋级

函数：

有名函数：

基于函数名使用

匿名函数 ：

没有绑定名字，使用一次就被收回，加括号即可以运行

--关键字：lambda
lambda  参数：返回值
lambda x,y: x+y
res = (lambda x,y: x+y)
print(x+y)

匿名函数与内置方法联用:

--通常与max(),sorted() , filter() , sorted() ,map()方法联用

1.max()方法，默认比较字典的key--依赖首字母顺序,取最大值

2.min()方法，默认比较字典的key--依赖首字母顺序,取最小值

salary_dict = {
    'nick':3000,
    'jason':10000,
    'tank': 5000,
    'sean':2000,
}
print(f"max(salary_dict, key=func()): {max(salary_dict, key=func)}")
def func(k):
    return salary_dict[k]
print(f"max(salary_dict, key=func()): {max(salary_dict, key=func)}")

max(salary_dict): tank
max(salary_dict, key=func()): jason
    
res = max(salary_dict,key=lambda name:salary_dict[name])
print(res)

3.sorted()--排序

1.首先将可迭代对象变成迭代器对象

2.res=next(迭代器对象)，将res当做参数传给第一个参数指定的函数，然后将该函数的返回值当做判断依据

4.map()--映射

1.首先将可迭代对象变成迭代器对象

2.res=next(迭代器对象)，将res当做参数传给第一个参数指定的函数，然后将该函数的返回值作为map()方法的结果之一。

5.filter()---筛选

1.首先将可迭代对象变成迭代器对象

2.res=next(迭代器对象)，将res当做参数传给第一个参数指定的函数，然后filter会判断函数的返回值的真假，如果为真则留下。

res1 = sorted(salary_dict,key=lambda name: salary_dict[name])
res2 = map(lambda name: f"{name} sb",res1)

res3 = filter(lambda name: name.endswith('sb'),res2)
print(res1,res2,res3)

自定义sorted方法:

def sorted(iter, key=None, reverse=None):
    iter.sort()

    if key:
        # key 是一个函数对象
        lt = []
        lt2 = []
        for i in iter:
            res = key(i)
            lt.append(res)
            lt2.append(i)
        lt.sort()

        lt3 = []
        for i in lt:
            for j in lt2:
                if j[1] == i:
                    lt3.append(j)

        if reverse:
            lt3.reverse()
        return lt3

    if reverse:
        iter.reverse()
    return iter


salary_list = list(salary_dict.items())
print(salary_list) # [('nick', 3000), ('jason', 100000), ('tank', 5000), ('sean', 2000), ('z', 1000)]
print(sorted(salary_list, key=lambda i: i[1],
             reverse=None))  # [('sean', 2000), ('nick', 3000), ('tank', 5000), ('jason', 100000)]

内置函数：

1.掌握：

bytes() --解码字符
chr / ord() 数字 / 字母 --》对应字符/数字

divmod（） --》分栏
enumerate() -->带有索引的迭代 ！！！
eval() --->去除字符串的引号，翻译成数据类型
hash() --->判断是否可哈希（可变不可哈希）

res = bytes('你好'，encoding = 'utf-8')
print(res)
--b'xe4xbdxa0xe5xa5xbd'

print(chr(65))
print(ord('A'))
A  65

print(divmod(10,3)) # 10 % 3
(3,1) #取整 / 取余
l = ['a','b','c']
for i in enumerate(l):
    print(i)
(0, 'a')
(1, 'b')
(2, 'c')

lis = '[1,2,4]'
lis_eval = eval(lis)
print(lis_eval)
[1,2,4]

print(hash(1))

2.了解

abs()  --绝对值
all() ---可迭代对象内元素全为真，返回True
any() ---可迭代对象内元素有一个为真，返回True
bin()/oct/hex 二进/八进/十六进制
dir ----列举该模块的所有功能
frozenset() ---不可变集合
gloabals/locals--查看全局变量 / 当前变量
pow  -- 幂
round--四舍五入
slice --切片
sum --- 求和
__import__ 通过字符串导入模块

print(abs(-13))
13

print(all[1,2,4,5,0])
print(all([])
False  True
      
print(any[1,2,4,5,0])
print(any([])   
True  False

      
 m = __import__('time')
 print(m.tiem())
- 1556607502.334777     

面向对象编程:

--解决问题的一种思想

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

生产汽水瓶的流水线，没办法生产特斯拉。流水线下一个阶段的输入与上一个阶段的输出是有关联的。因此他的扩展性极差。

缺点：扩展性差

I -- P --O编程：input --process --output

异常处理:

1.语法错误：程序执行前检测

2.逻辑错误：除了语法错误

try:
    int(si)
except Exception as e:
    print(e) 
else:
    print('try内代码块没有异常则执行我')
finally:
     print('无论异常与否，都会执行该模块')

--抛出异常raise
try:
    raise TypeError('抛出异常，类型错误')
except Exception as e:
    print(e)
    
断言assert   (错误会报错) 
assert 1 == 1
try:
    assert 1 == 2
except Exception as e:
    print(e)

总结:

1. 把错误处理和真正的工作分开来

2. 代码更易组织，更清晰，复杂的工作任务更容易实现；

3. 毫无疑问，更安全了，不至于由于一些小的疏忽而使程序意外崩溃了；