Day 14 匿名函数/内置函数/面向过程编程
匿名函数
有名函数
有名函数顾名思义就是带函数名,并且基于函数名使用
匿名函数
匿名函数没有名字,使用一次即被收回,加括号即可运行
# lambda 参数:返回值
f = lambda x, y: x + y
print(f(1, 2))
3
与内置函数的联用
匿名函数常与内置函数max(), map(), filter(), sorted()方法联用
score_dict = {
'二白': 100
'小白': 60
'大白': 88
}
# max()
m = max(score_dict)
print(m)
print(max(score_dict, key=lambda item: score_dict[item]))
# 1.先把score_dict的键遍历出来到item中
# 2.item放入score_dict[item]中
# 3.通过max返回最大的值
# filter()
# python2与python3的区别:python2
res = filter(lambda name: score_dict[name] > 60, score_dict)
print(list(res))
def func(name):
return score_dict[name] > 60
res = filter(func, score_dict)
print(list(res))
# map()
res = map(lambda name: score_dict[name] + 10, score_dict)
print(list(res))
# sorted
res = sorted(score_dict, key=lambda name: score_dict[name])
print(res)
小白
二白
['二白', '大白']
['二白', '大白']
[110, 70, 98]
['小白', '大白', '二白']
内置函数
| Built-in Functions | ||||
|---|---|---|---|---|
| abs() | delattr() | hash() | memoryview() | set() |
| all() | dict() | help() | min() | setattr() |
| any() | dir() | hex() | next() | slice() |
| ascii() | divmod() | id() | object() | sorted() |
| bin() | enumerate() | input() | oct() | staticmethod() |
| bool() | eval() | int() | open() | str() |
| breakpoint() | exec() | isinstance() | ord() | sum() |
| bytearray() | filter() | issubclass() | pow() | super() |
| bytes() | float() | iter() | print() | tuple() |
| callable() | format() | len() | property() | type() |
| chr() | frozenset() | list() | range() | vars() |
| classmethod() | getattr() | locals() | repr() | zip() |
| compile() | globals() | map() | reversed() | __import__() |
| complex() | hasattr() | max() | round() |
# bytes
res = bytes('中国', encoding='utf8')
print(res)
# chr/ord
print(chr(97))
print(ord('a'))
# divmod
print(divmod(10, 4)) # 取整/取余
# 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))
# hash,可变不可哈希
print(hash(123123))
# 了解
# abs
print(abs(-1))
# all# 可迭代对象内的元素全部为True则为True
print(all([1, 2, 3, 3]))
# any
print(any([0, 0, ]))
# bin/oct/hex
print(bin(123))
print(oct(123))
print(hex(123))
# dir: 列出模块的所有方法
# import time
#
# print(dir(time))
# frozenset: 不可变化的集合,类似于元组
s = frozenset({1, 2, 3})
print(s)
# gloabals/locals
# print(globals()) # 列出所有全局变量
# print('locals():', 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])
# # sum
print(sum([1, 2, 3, 4, 5]))
# __import__ # 通过字符串导入模块
# import 'time'
time = __import__('time')
print(time.time())
面向过程编程
在早期的程序设计中，程序员们大量的使用全局变量和 goto 语句一类的东西。，这使得程序异常的繁杂，并且很难得维护，有时候作者本人都可能看不懂自己的代码，所以当年的程序又称为”意大利面条式“。
随后有人证明所有有意义的程序流程都可以使用三种基本流程（顺序、选择、重复）来实现，由此人们进行编程的方式发生重大变化，每种语言都提供这些基本控制结构的实现方式，并提供把数据访问局部化的能力（局部变量），以及某种形式的模块化来分别编译机制。在这些基础上，人们所进行的编程活动基本是通过写用于不同目的的功能函数来实现，故称为面向过程。
并且面向过程这个词是在面向对象出现之后为与之相对而提出的。其实它在以前基本被叫做结构化编程。
由此我们便能很清晰的看出，面向对象编程，其实就是将问题模块化，把问题的每一个步骤以函数或者结构体的形式写出来，然后在主函数中间调用，最后输出结果。
