函数:
有名函数:
基于函数名使用
匿名函数 :
没有绑定名字,使用一次就被收回,加括号即可以运行
--关键字: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)
总结:
-
把错误处理和真正的工作分开来
-
代码更易组织,更清晰,复杂的工作任务更容易实现;
-
毫无疑问,更安全了,不至于由于一些小的疏忽而使程序意外崩溃了;