匿名函数

什么叫匿名函数？

我们之前学过的叫有名函数，就是有名字的函数

匿名函数 就是没有名字的函数，

语法

lambda 参数:返回值

# 演示匿名函数的使用

f = lambda x:x
print(f)
# <function <lambda> at 0x00000000005D1E18>
s = f(1)        # 注意 ，匿名函数调用拿到的是返回值。
print(s)
# 1

匿名函数一般与python内置方法连用。

max/min()

'''
用法：
max(可迭代对象，匿名函数)
返回最大值
'''
比如说我们想要求出以下字典的最高/最低薪资的人的名字

salary_dict = {
    'nick': 3000,
    'jason': 100000,
    'tank': 5000,
    'sean': 2000
}
print(max(salary_dict))     # 如果直接用max函数的话会按照字符串首字母顺序来排序
# tank

# 我们可以定义一个函数
def func(k):
    return salary_dict[k]
print(min(salary_dict,key=func))     
# sean
print(max(salary_dict,key=func))
# jason
'''
key=func  做的事情：
1. 循环salary_dict 取出所有的key值
2. 将每个key值放入func函数中，返回values，返回薪资
3. max函数进行排序
'''

# 用匿名函数实现
print(max(salary_dict,key=lambda name:salary_dict[name]))
# jason
print(min(salary_dict,key=lambda name:salary_dict[name]))
# sean

sorted()

'''
sorted(可迭代对象，reverse)
sorted，排序，返回值找一个变量接收
'''
lis = [1, 3, 2, 5, 8, 6]
lis = sorted(lis,reverse=True)		# reverse=True 反转
print(lis)
# [8, 6, 5, 3, 2, 1]

salary_dict = {
    'nick': 3000,
    'jason': 100000,
    'tank': 5000,
    'sean': 2000
}
def f2(item):
    return salary_dict[item]
res = sorted(salary_dict,key=f2,reverse=True)
print(res)
# ['jason', 'tank', 'nick', 'sean']

# 用匿名函数实现
res = sorted(salary_dict,key=lambda item:salary_dict[item],reverse=True)
print(res)
# ['jason', 'tank', 'nick', 'sean']

map()

'''
map(匿名函数，可迭代对象)
映射
'''

name_list = ['jason', 'tank', 'sean']

def f1(item):
    return item + "hahahhahahhahahhaha"
res = map(f1,name_list)
print(list(res))
# ['jasonhahahhahahhahahhaha', 'tankhahahhahahhahahhaha', 'seanhahahhahahhahahhaha']

# 匿名函数实现
res = map(lambda name:f"{name} sb",name_list)
print(list(res))
# ['jason sb', 'tank sb', 'sean sb']

filter()

'''
filter(匿名函数，可迭代对象)
筛选,按照某种条件对可迭代对象操作。
'''
name_list = ['nick', 'jason sb', 'tank sb', 'sean sb']

# 匿名函数实现
res = filter(lambda name:name.endswith("sb"),name_list)
print(list(res))
# ['jason sb', 'tank sb', 'sean sb']

lis = [2,3,4,5,6,7]
def function(item):
    if item > 5:
        return True
    else:
        return False
res = filter(function,lis)
print(list(res))
# [6, 7]

# 匿名函数实现
res = filter(lambda item:item > 5,lis)
print(list(res))
# [6, 7]

reduce函数

from functools import reduce
lst=[1,2,3,4]
print(reduce(lambda x,y: x+y, lst))

#计算过程如下:
# 这个式子只有两个参数,没有初始化值,那么就取列表前2项,通过lambda函数计算结果
#1+2=3,
#上面计算的结果在与列表第三个元素通过lambda函数计算
# 3+3=6
#上面计算的结果在与列表第四个元素通过lambda函数计算
# 6+4=10

# 它还可以传入一个参数
print(reduce(lambda x,y: x+y, lst,100))
# 表示初始值是100，第一次计算从100加列表的第一个元素，得到的结果再与后面的值依次相加

内置函数

## 需要掌握

1.bytes() # 解码字符
res = bytes("你好" ,encoding="utf8")	# 解码成二进制
print(res)

'''
2.chr()/ord()
按照ascil码 将数字转换为对应字符
ord 将字符转换为数字
'''
print(chr(65))
print(ord("A"))

'''
3.divmod()
将商 余数以元组形式返回
'''
print(divmod(10,3))

'''
4.ennumerate()  ********************重要
带有索引的值
'''
l = ["a","b","c"]
for i in enumerate(l):
    print(i)
# (0, 'a')
# (1, 'b')
# (2, 'c')

'''
5.eval()	********************重要
将字符串两边的引号去掉，变成剩下的数据类型
'''
lis = "[1,2,3]"
print(type(list))
# <class 'type'>
print(type(eval(lis)))
# <class 'list'>

'''
6.hash()
是否可哈希
'''
print(hash(10))
# 10

##############################################################################################

## 了解
'''
1. abs()	***
求绝对值
'''
print(abs(-1))
# 1

'''
2. all()
可迭代对象内元素全为真则返回真
'''
print(all([1,2,3]))
# True

'''
3. any()
可迭代对象内有一元素为真，则为真
'''
print(any([1,2,3,0]))
# True

'''
4. bin()
    oct()
    hex()
    二进制、八进制、十六进制转换
'''
print(bin(17))
print(oct(17))
print(hex(17))
# 0b10001
# 0o21
# 0x11

'''
5. dir()
列出所有time的功能
'''
print(dir())
# ['__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__',
#  '__name__', '__package__', '__spec__', 'i', 'l', 'lis', 'res']

'''
6. frozenset()
不可变的集合
'''
set8 = frozenset({1,2,3,4,5})
print(set8)
# frozenset({1, 2, 3, 4, 5})
# set8.add(10)
# AttributeError: 'frozenset' object has no attribute 'add'

'''
7. globals()
loacals()
查看全局、局部名字
'''
def func():
    a = 1
    # print(locals())   # 以字典形式返回
    # print(globals())    # 打印全局名字
func()
# {'a': 1}
# {'__name__': '__main__', '__doc__': '\n1.bytes()\n解码字符\n', '__package__': None, '
# __loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000000001DCB208>,
#  '__spec__': None, '__annotations__': {},
# '__builtins__': <module 'builtins' (built-in)>,
# '__file__': 'C:/Users/Administrator/Desktop/老男孩python文档/老男孩Python程序编写/练习/第三章Python基础--文件操作&函数/内置函数.py', '__cached__': None, 'res': b'\xe4\xbd\xa0\xe5\xa5\xbd', 'l': ['a', 'b', 'c'], 'i': (2, 'c'), 'lis': '[1,2,3]', 'set8': frozenset({1, 2, 3, 4, 5}), 'func': <function func at 0x00000000004F1E18>}

'''
8. pow()
返回 xy（x的y次方） 的值。
'''
print(pow(5,2))
# 25

'''
9. round()	***
返回浮点数x的四舍五入值。
'''
print(round(5.1))
# 5

'''
10. slice()
切片对象，主要用在切片操作函数里的参数传递。
slice 语法：
class slice(stop)
class slice(start, stop[, step])
'''
myslice = slice(5)
print(myslice)

'''
11. sum()	***
进行求和计算
'''
print(sum(range(100)))
# 4950

'''
12. __import__()
通过字符串导入模块
'''
m = __import__("time")
print(m.time())
# 1569325150.957757

'''
面向对象函数，-----^_^-----
classmethod
staticmethod
property
delattr
hasattr
getattr
setattr
isinstance()
issubclass()
object()
super()
'''

面向过程编程

什么叫面向过程，面向 流程 编程

面向过程编程是解决问题的一种思想，过程是解决问题的步骤

将复杂的问题拆解成一个个流程，从而做完整个事情

优点：复杂的问题流程化，简单化

缺点：扩展性差

'''
注册功能
接受用户输入用户名，进行合法性校验，拿到合法的用户名
'''
def check_user():
    username = input(">>>").strip()
    if username.isalpha():
        return username
    else:
        print("用户名必须为字母，傻逼")

'''
分层实现功能
用户功能层：实现用户具体的功能
接口层：连接数据处理层和用户功能层
数据处理层：处理数据后把结果交给接口层
'''

异常处理

什么是异常

异常就是程序运行时候的报错

异常的种类

在python中不同的异常是不同的类型，一个异常标识一种错误

异常处理

try:
    代码
except 错误类型:
    代码

print(1)
num = input('请输入数字:')
dic = {'a': 1}

try:
    print(dic['b'])  	# KeyError
    1 / int(num)  		# 报错之后,不运行下面的代码
except ZeroDivisionError:
    print('傻逼,不能输入0')
except KeyError:
    print('傻逼,不知道什么错误')

print(2)

# 万能捕捉异常

print(1)
num = input('请输入数字:')
dic = {'a': 1}
try:
    print(dic['b'])  	# KeyError
    1 / int(num)  	# 报错之后,不运行下面的代码
except Exception as e:  	# 万能异常,只要有错误,就捕捉
    print(e)  	# 打印错误的描述信息
    print('傻逼,不知道什么错误')
print(2)

try...except总结

1. 把错误处理和真正的工作分开
2. 代码更加清晰，复杂的工作任务更容易实现
3. 代码更加有健壮性

finally语句

finally 表示无论报不报错都执行下面的代码

# 异常捕捉只能捕捉逻辑错误
fr = open('test.py')
try:
    # 文件中途报错
    1 / 0
except Exception as e:
    print(e)
finally:  	# 无论你报不报错,都执行这一行
    print('finally')
    fr.close()

主动抛出异常raise

try:
    raise TypeError('抛出异常，类型错误')
except Exception as e:
    print(e)

断言assert

assert 1 == 1

try:
    assert 1 == 2
except Exception as e:
    print(e)