day-14

目录

• 1. 匿名函数
  • 1.1 语法
  • 1.2 与内置函数连用
    • 1.2.1 与 max() 连用
    • 1.2.2 与 fileter() 连用
    • 1.2.3 与 map() 连用
    • 1.2.4 与 sorted() 连用
    • 1.2.5 自定义 sorted() 方法（了解）
• 2. 内置函数
  • 2.1 掌握
  • 2.2 了解
• 3. 异常处理
  • 3.1 模板
• 4. 面向过程编程

1. 匿名函数

一种没有函数名的函数，由于没有函数名，因此没法直接调用，只能和某些方法结合在一块儿使用。

1.1 语法

lambda 参数:返回值

1.2 与内置函数连用

匿名函数一般与 max()、sorted()、filter()、sorted() 方法联用。

1.2.1 与 max() 连用

# 取出字典中薪资最高的人的名字
salary_dict = {
    'nick': 3000,
    'jason': 100000,
    'tank': 5000,
    'sean': 2000
}
# 直接使用 max() 方法---不能实现

print(max(salary_dict))  # 只能比较字典的 key


# 使用函数---能够实现
def func(k):
    return salary_dict[k]


print(max(salary_dict, key=func))

# 使用匿名函数---能够实现

print(max(salary_dict, key=lambda name: salary_dict[name]))
# key=lambda name: salary_dict[name] 的做用
# 1. 首先明确 salary_dict 是可迭代对象，后面的语句会将 salary_dict 内的对象（键值对）逐个取出
# name: salary_dict[name]
# 2. 第一步获得了字典内全部的键值对，salary_dict[name] 将全部的值放在一块儿，进行 max() 函数的运算，获得这些值中的最大值，name 表示咱们须要拿到的值

运行结果：

tank
jason
jason

Process finished with exit code 0

1.2.2 与 fileter() 连用

# 筛选出大于 5 的元素 
lt = [1, 2, 3, 4, 5, 6, 7, 8, 9]

res = filter(lambda i: i > 5, lt)
res = list(res)
print(res)

运行结果：

[6, 7, 8, 9]

Process finished with exit code 0

1.2.3 与 map() 连用

# 经过某种关系产生映射，如数学中的han'shu
lt = [1, 2, 3, 4]
res = map(lambda item: item ** 2, lt)
res = list(res)
print(res)

运行结果：

[1, 4, 9, 16]

Process finished with exit code 0

1.2.4 与 sorted() 连用

# 将列表里的人按照薪资大小排序
salary_dict = {
    'nick': 3000,
    'jason': 100000,
    'tank': 5000,
    'sean': 2000,
}

print(sorted(salary_dict, key=lambda name: salary_dict[name],reverse=True))

运行结果：

['jason', 'tank', 'nick', 'sean']

1.2.5 自定义 sorted() 方法（了解）

# 了解
def sorted(iter, key=None, reverse=None):
    iter.sort()

    if key:
        # key 是一个函数对象
        lt = []
        lt2 = []
        for i in iter:
            res = key(i)
            lt.append(res)
            lt2.append(i)
        lt.sort()

        lt3 = []
        for i in lt:
            for j in lt2:
                if j[1] == i:
                    lt3.append(j)

        if reverse:
            lt3.reverse()
        return lt3

    if reverse:
        iter.reverse()
    return iter


salary_dict = {
    'nick': 3000,
    'jason': 100000,
    'tank': 5000,
    'sean': 2000,
}
salary_list = list(salary_dict.items())
print(salary_list) # [('nick', 3000), ('jason', 100000), ('tank', 5000), ('sean', 2000), ('z', 1000)]
print(sorted(salary_list, key=lambda i: i[1],
             reverse=None))  # [('sean', 2000), ('nick', 3000), ('tank', 5000), ('jason', 100000)]

2. 内置函数

2.1 掌握

• bytes()

  # 将字符解码成二进制
  res = bytes('中国', encoding='utf8')
  print(res)

  运行结果：

  b'\xe4\xb8\xad\xe5\x9b\xbd'

• chr() 、 ord()

  # chr()参考ASCII码表将数字转成对应字符；ord()将字符转换成对应的数字。
  print(chr(97))
  print(ord('a'))

  运行结果：

  a
  97

• divmod()

  # 返回两个数的商和余数
  print(divmod(10, 4))  # 取整/取余

  运行结果：

  (2, 2)

• enumerate()

  # 迭代得到列表的索引和值
  lt = ['a', 'b', 'c']
  for i in enumerate(lt):
      print(it)

  运行结果：

  (0, 'a')
  (1, 'b')
  (2, 'c')

• eval()

  # 把字符串翻译成数据类型，字符串去掉引号知足什么数据类型的条件，就是什么数据类型
  lis = '[1,2,3]'
  lis_eval = eval(lis)
  print(type(lis_eval),lis_eval)

  运行结果：

  <class 'list'> [1, 2, 3]

• hash()

  # 获取一个对象的哈希值
  print(hash(0))
  print(hash('0'))

  运行结果：

  0
  3174128774324462608

2.2 了解

• abs()

  # 求绝对值
  print(abs(-13))

  运行结果：

  13

• all()

  # 可迭代对象内元素所有为真，则返回真
  print(all([1, 2, 3, 0]))
  print(all([]))

  运行结果：

  False
  True

• any()

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

  运行结果：

  True
  False

• bin()

  # 二进制转换
  print(bin(17))

  运行结果：

  0b10001

• oct()

  # 八进制转换
  print(oct(17))

  运行结果：

  0o21

• hex()

  # 十六进制转换
  print(hex(17))

  运行结果：

  0x11

• 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', 'tzset']

• frozenset()

  # 不可变集合
  s = frozenset({1, 2, 3})
  print(s)

  运行结果：

  frozenset({1, 2, 3})

• globals() 、 locals()

  # 查看全局变量名；查看局部变量名

  运行结果：

• pow()

  # 幂运算
  print(pow(3, 2))

  运行结果：

  9

• round()

  # 四舍五入
  print(round(10.333))

  运行结果：

  10

• slice()

  # 索引取值
  s = slice(1, 5, 2)  # 1start,5stop,2step
  lt = [1, 2, 3, 4, 5, 6, 7]
  print(lt[s])
  print(lt[1:5:2])

  运行结果：

  [2, 4]
  [2, 4]

• sum()

  # 求和
  print(sum([1, 2, 3, 4, 5]))

  运行结果：

  15

• \_\_import\_\_()

  # 经过字符串导入模块
  time = __import__('time')
  print(time.time())

  运行结果：

  1569482755.649973 # 真实时间

3. 异常处理

异常处理只能捕捉到程序中的逻辑错误。

3.1 模板

代码
  try:
      认为可能会出错的代码
  except Exception as e:
      print(e)  # 若是出现错误，打印错误信息
  finally:
      须要继续执行的代码

4. 面向过程编程

面向过程编程：

核心是 过程 ，指的是解决问题的步骤，先作什么，再作什么，最后作什么。

优势：将复杂的问题流程化，简单化。

缺点：扩展性差。