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

目录

• 有名函数
• 匿名函数
  • max()
    • min()
    • sorted
    • map
    • filter
• 内置函数
• 面向过程编程

有名函数

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'xe4xb8xadxe6x96x87'
b'xe4xb8xadxe6x96x87'

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. 可扩展性差