day20 匿名函数,内置函数,面向过程编程

有名函数

def f1():
print('my name is f1')
f1()


my name is f1


匿名函数

• 没有函数名的函数
• lambda关键字定义
• 语法:
  • lambda x,y(参数): x+y(逻辑代码)

# 这样做就成了一个有名函数了
f = lambda x,y:x+y
print(f(1, 2))# 这样调用没有什么实际意义
print((lambda x,y:x+y)(1, 2))


3
3


• 匿名函数也能调用,但是调用需要注意只能使用一次,匿名函数一般不单独使用,而是与max(),min(),map(),sorted(),filter()这些内置函数一起使用

max()

• 最大值

# 找到工资最高的人
salary_dict = {'leijun':17000, 'lalala': 19000}
max_salary = max(salary_dict) # 默认是按照键取
print(max_salary)


leijun


def key(res): # res = 'leijun','lalala'
return salary_dict[res]
max_salary = max(salary_dict, key=key)
print(max_salary)


lalala


• max中封装的过程

1. salary_dict变成迭代器对象salary_dict_iter
2. res = salary_dict_iter.next
3. 把res丢入函数func中，17000，19000
4. 得到函数的返回值，把这个返回值作为判断依据

# 自己写一个max函数
def max(iterable, key=None):
salary_dict_iter = iterable.__iter__()
init_num = 0
for salary in salary_dict_iter:
func_res = key(salary)
if func_res > init_num:
init_num, func_res = func_res, init_num
return init_num


# 上面的key函数，可以写成匿名函数
salary_max = max(salary_dict, key=lambda name:salary_dict[name])
print(salary_max)


lalala


min()

• 最小值

salary_min = min(salary_dict, key= lambda name:salary_dict[name])
print(salary_min)


leijun


sorted

• 排序

# 排序
salary_dict_sorted1 = sorted(salary_dict)
print(salary_dict_sorted1)
salary_dict_sorted2= sorted(salary_dict, key = lambda name:salary_dict[name])
print(salary_dict_sorted)


['lalala', 'leijun']
['leijun', 'lalala']


map

• 映射

name_list = ['nick', 'tank', 'sean']
res = map(lambda name:f'{name} dsb', name_list)
print(list(res))


['nick dsb', 'tank dsb', 'sean dsb']


filter

• 过滤

lis = ['jason dsb', 'tank dsb', 'sean dsb','nick']
res = filter(lambda x:not x.endswith('dsb'),lis)
print(list(res))


['nick']


内置函数

1.enumerate

• 获取索引和值

lis = ['a', 'b', 'c']
for i,a in enumerate(lis):
print(i, a)


0 a
1 b
2 c


2.eval()

• 去掉字符串的引号，还原原本的数据类型
• python3的input+eval就等于python2的input

num = '[1, 2, 3]'
print(list(eval(num)))


[1, 2, 3]


3.abs()

• 绝对值

print(abs(-100))


100


4.bin()/oct()/hex()

• 进制转换

print(bin(777))
print(oct(777))
print(hex(777))


0b1100001001
0o1411
0x309


5.globals()/locals

• 获取当前的全局/局部变量

print(globals())


6.sum()

• 求和

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


10


7._import_()

• 通过字符串格式导入模块

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


1560153794.2662559


8.bytes()

• unicode转utf-8

print('中文'.encode('utf-8'))
print(bytes('中文', 'utf-8'))


b'\xe4\xb8\xad\xe6\x96\x87'
b'\xe4\xb8\xad\xe6\x96\x87'


9.chr()/ord()

• ascill码中的对应关系

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


a
97


10.divmod()

• 求商取余

print(divmod(10, 3))


(3, 1)


11.hash()

• 可哈希不可变，不可哈希可变
• 可哈希就返回，不可哈希就报错

print(hash(10))
# print(hash([1, 22]))


10


12.all()/any()

• all全为真返回True
• any有真就返回True

print(all([0, 1, 2, 3]))
print(any([0, 1, 2, 3]))


False
True


13.dir()

• 把模块所有的方法读取出来

import time
print(dir(time))


['_STRUCT_TM_ITEMS', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'altzone', 'asctime', 'clock', 'ctime', 'daylight', 'get_clock_info', 'gmtime', 'localtime', 'mktime', 'monotonic', 'perf_counter', 'process_time', 'sleep', 'strftime', 'strptime', 'struct_time', 'time', 'timezone', 'tzname']


14.pow()

• 求幂后求余
• 可以单独求幂
• 历史遗留，可以直接用算数运算替代

print(pow(3, 2, 4))


1


15.round()

• 四舍五入

print(round(3.4))


3


16.slice

• 用切片就可以了
• 历史遗留问题

lis = ['a', 'b', 'c']
a = slice(1, 3, 1)
print(lis[a]) # lis[1:3:1]


['b', 'c']


面向过程编程

• 按照一定的顺序，其中每一步都可以看做是函数，当前函数的输入是上一个函数的输出，这就叫面向过程编程

• 优点：

  1. 逻辑清晰，简单明了
  2. 每个函数都可以独立的写出来

• 缺点：

  1. 相互之间会有一定的联系，其中一个断了，后面的也断了
  2. 可扩展性差

• 例如：ATM