自我总结13

匿名函数

匿名--> 没有名字 --> 没办法调用 --> 只能和某些方法联用

# 匿名函数的语法

# lambda 参数:返回值 # 如果你真的要用,也可以用,但是会变成有名函数

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

max/min/filter/map/sorted联用

max

# max 返回最大值

res = max([1, 2, 3, 4, 5])
print(res)

res = max(1, 2, 3, 4, 5, 6, )
print(res)
# 案例  
# 输入薪资最大
salary_dict = {
    'nick': 3000,
    'jason': 100000,
    'tank': 5000,
    'sean': 2000,
    'z': 1000
}
res= max(salary_dict) # 默认key的首字母
# 输出名字首字母最大,不是薪资最大
print(res) 
# z
#为了返回薪资,定义一个函数func

def func(name):  # nick/jason/tank/sean/z
    return salary_dict[name]  # 3000/100000/5000/2000/1000

res = max(salary_dict, key=func)  # 有名函数
print(res)
# jason

# key=func默认做的事情
# 1. 循环遍历salary_dict,会取到所有的key值
# 2. 然后把所有的key值依次丢入func中,返回薪资
# 3. 通过返回的薪资排序,得到最大值
# 匿名函数
def func(name): 
    return salary_dict[name] 

res = max(salary_dict, key=lambda name: salary_dict[name])
								# 参数 :返回值  
print(res)
# jason



#举一反三
res = min(salary_dict, key=lambda name: salary_dict[name])
print(res)
# z

fileter

# fileter ---> 筛选
def function(item):  # 1/2/3/4
    if item < 5:
        return True
    else:
        return False


# res = filter(function, [1, 2, 3, 4])
res = filter(lambda item: item > 2, [1, 2, 3, 4])
print(res)  # 迭代器
print(list(res))

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

res = filter(lambda item: salary_dict[item] > 3000, salary_dict)
print(list(res))

map

# map  --> 映射 --> y = x+1
def function1(item):
    return item + 2


res = map(function1, [1, 2, 3, ])
print(res)
print(list(res))

sorted

# sorted --> 排序
def function2(item):
    return salary_dict[item]


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

# res = sorted([2,3,4,1,0,5],key=function2,reverse=True)
res = sorted(salary_dict, key=function2, reverse=True)
print(list(res))

sorted内置方法

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

# 有兴趣的可以看一看
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)]

内置函数

# 用得上的

# enumerate(********) 取出索引和值
lt = [1, 2, 3]
for i in range(len(lt)):
    print(i, lt[i])

for ind, val in enumerate(lt):
    print(ind, val)

    
# eval(***) --> 把字符串的引号去掉,留下来的是什么就是什么
s = '"abc"'
print(type(eval(s)), eval(s))
# <class 'str'> abc

# hash,可变不可哈希,不可变可哈希
print(hash(123123))# 正确返回输入的值,错误报错
# 123123


# bytes
res = bytes('中国', encoding='utf8')
print(res)
# chr/ord
print(chr(97))
print(ord('a'))
# divmod
print(divmod(10, 4))  # 取整/取余


# 了解

# abs 绝对值
print(abs(-1))

# all# 可迭代对象内的元素全部为True则为True
print(all([1, 2, 3, 3]))

# any
print(any([0, 0, ]))

# bin/oct/hex
print(bin(123)) # 0b1111011  二进制
print(oct(123)) # 0c173		 八进制
print(hex(123)) # 0x7b		十六进制


# dir: 列出模块的所有方法
import time

print(dir(time))


# frozenset: 不可变化的集合,类似于元组
s = frozenset({1, 2, 3})
print(s)


# gloabals/locals
def func():
    s = 's1'
    print(globals())  # 列出所有全局变量
    print('locals():', locals())  # 列出当前位置所有变量
func()

# pow
print(pow(2, 2))

# round
print(round(10.333))

# slice
s = slice(1, 5, 2)  # 1start,5stop,2step
lt = [1, 2, 3, 4, 5, 6, 7]
print(lt[s])

print(lt[1:5:2]) #索引取值 python3

# sum
print(sum([1, 2, 3, 4, 5]))

# __import__  # 通过字符串导入模块
# import 'time'
time = __import__('time')
print(time.time())

异常处理

报了错,进行处理

print(1)
num = input('请输入数字:')

dic = {'a': 1}

try:

    print(dic['b'])  # KeyError
    1 / int(num)  # 报错之后,不运行下面的代码

except Exception as e:  # 万能异常,只要有错误,就捕捉
    print(e)  # 错误的描述信息
    print('傻逼,不知道什么错误')

print(2)
# 异常捕捉只能捕捉逻辑错误



fr = open('test.py')
try:
    # 文件中途报错
    1 / 0
    fr.close()
except Exception as e:
    print(e)
finally:  # 无论你包不报错,都执行这一行
    print('finally')
    

# raise 主动抛错误
# 写主动报出人的错误用到

面向过程编程

面条版 --》 面向过程编程 --》 思想 --》面向对象编程

面向(代词--》使用) 过程(流程--》步骤) 编程(写代码,写文件)

I input 输入(定义的变量) P Process 过程(控制变量的改变) O output(新的变量) 输出编程 == 面向过程编程

面向过程编程:类似于流水线,一步一步往下走,一个步骤就是一个函数

优点:逻辑非常清晰

缺点:上一步错了,下一步就跟着一起错

为什么会报错

逻辑 --》 控制变量改变的方向出错了

检查错误 --》打印变量的变化状态 --》

x = 10

y = 20

z = x + y
print(1, z) # 30

z = z + 10
print(2, z) # 40

z = z - 20

print(z)

debug

posted @ 2019-09-25 21:36  jzm1201  阅读(93)  评论(0编辑  收藏  举报