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

有名函数

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 = ['test1', 'test2', 'test3']
res = map(lambda name:f'{name} dsb', name_list)
print(list(res))
['test1 dsb', 'test2 dsb', 'test3 dsb']

filter

  • 过滤
lis = ['test1 dsb', 'test2 dsb', 'test3 dsb','test4']
res = filter(lambda x:not x.endswith('dsb'),lis)
print(list(res))
['test4']

内置函数

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. 可扩展性差
posted @ 2019-06-04 20:39  abcde_12345  阅读(142)  评论(0编辑  收藏  举报