• 函数晋级


    函数:

    有名函数:

    基于函数名使用

    匿名函数 :

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

    --关键字: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. 毫无疑问,更安全了,不至于由于一些小的疏忽而使程序意外崩溃了;

  • 相关阅读:
    tomcat 启动超时
    读书笔记-String
    读书笔记-集合
    读书笔记-算法
    多变量梯度下降
    多变量线性回归
    梯度下降算法在线性回归中的运用
    梯度下降
    线性回归——代价函数
    线性回归
  • 原文地址:https://www.cnblogs.com/shaozheng/p/11585022.html
Copyright © 2020-2023  润新知