有名函数
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中封装的过程
- salary_dict变成迭代器对象salary_dict_iter
- res = salary_dict_iter.next
- 把res丢入函数func中，17000，19000
- 得到函数的返回值，把这个返回值作为判断依据
# 自己写一个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']
面向过程编程
-
按照一定的顺序，其中每一步都可以看做是函数，当前函数的输入是上一个函数的输出，这就叫面向过程编程
-
优点：
- 逻辑清晰，简单明了
- 每个函数都可以独立的写出来
-
缺点：
- 相互之间会有一定的联系，其中一个断了，后面的也断了
- 可扩展性差