day 014总结

昨日回顾

迭代器

迭代器对象一定是可迭代对象，可迭代对象不一定是迭代器对象

可迭代对象

含有__iter__方法的数据类型

除了数字类型都是可迭代对象

迭代器对象

含有__iter__,__next__方法的数据类型

文件才是迭代器对象

可迭代对象加上__iter__会变成迭代器对象

迭代器对象加上__iter__方法依旧是迭代器对象

for循环原理

lt[1,2]
lt_iter=lt.__iter__()
while True:
    try:
        print(lt_iter.__next__())
    except StopIteration:
        break

三元表达式

条件成立 if 条件 else 条件不成立

列表推导式

[i for i in range(10)]

字典生成式

{i :i for i in range(10)}

zip

把多个可迭代对象一次性读取每一个可迭代对象的中的元素，拼成元组

生成器表达式

(i for i in range(10))

生成器

本质是迭代器，是自定迭代器，含有yield关键字的 函数

def ge():
    yield

yield

1. 暂停函数
2. 通过next取出一个yield的值

def range(start, stop, step):
    while start < stop:
        yield start
    	start += step
       
for i in range(1,10,2):
    print(i)

递归

函数调用函数本身，有退出条件

count = 0
def a():
    global count
    print(count)
    
    if count == 100:
        return
    count += 1
    a()
    
a()

今日内容

匿名函数

匿名函数没有名字

匿名需要关键字lambda

lambda 参数:返回值

匿名函数一般不单独使用，和filter()/map()/sorted()/列表的sort()内置方法连用

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

sort

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

sorted

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

max min filter

salary_list=list(salary_dict.items())
print(max(salary_list,key=lambda i:i[1]))#('jason', 100000)
print(min(salary_list,key=lambda i:i[1]))#('sean', 2000)
print(list(filter(lambda i: i[1] < 5000, salary_list)))  #[('nick', 3000), ('sean', 2000)]

不转换为列表

salary_dict = {    
    'nick': 3000,    
    'jason': 100000,    
    'tank': 5000,    
    'sean': 2000
}
#sorted
s=sorted(salary_dict,key=lambda i:salary_dict[i])
print(s)#['sean', 'nick', 'tank', 'jason']
#max
res = max(salary_dict, key=lambda name: salary_dict[name])
#min
res = min(salary_dict, key=lambda name: salary_dict[name])
#filter
res = filter(lambda item: salary_dict[item] > 3000, salary_dict)
#map
def function1(item):
    return item + 2
res = map(function1, [1, 2, 3, ])
print(res)
print(list(res))

内置函数

bytes 解码字符

res = bytes('中国', encoding='utf8')
print(res)#b'xe4xb8xadxe5x9bxbd'

chr/ord chr()参考ASCII码表将数字转换成对应字符；ord()将字符转换成对应数字

print(chr(97))#a
print(ord('a'))#97

divmod 取整/取余

print(divmod(10,4))#(2,2)

enumerate 带有索引的迭代(******)

lt=[1,2,3]
for i in enumerate(lt):
    print(i)
#(0, 1)
(1, 2)
(2, 3)

eval(***)把字符串的引号去掉，留下来的是什么就是什么

s='[1,2,3]'
print(eval(s))#[1,2,3]

hash 判断是否哈希

print(hash(1))#1

abs 绝对值

print(abs(-1))#1

all 可迭代对象内的元素全部为True则为True

print(all([1,2,3]))#true

any 只要一个元素为True则为True

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

bin/oct/hex 2进制 8进制 16进制

print(bin(123))
print(oct(123))
print(hex(123))

dir 列出模块的所有方法

frozenset:不可变的集合，类似于元组

s=frozenset({1,2,3})
print(s)

gloabls/locals# 列出所有全局变量/局部变量

print(globals())
print(locals())

pow

print(pow(2,2))#4

slice

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

sum

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

__import__通过字符串导入模块

time=__import__('time')
print(time.time())

异常处理

num=input('请输入数字')
dic={'a':1}
try:
    print(dic['b'])#KeyError
    1/int(num)
except Exception as e:#万能异常，只要有错误就捕捉
    print(e)#错误的描述信息
finally:#无论你报不报错，都会执行这一行
    print('finally')

try里报错之后，不运行下面的代码

异常捕捉只能捕捉逻辑错误

面向过程编程

对着过程编程

面向过程编程：一步一步（一个函数一个函数），上一个函数的输出是下一个函数的输入

优点：代码的独立性提高了，流程清晰

缺点：一个错误，让程序直接崩掉了