字符串:

切片的语法：[起始:结束:步长] 字符串[start: end: step] 这三个参数都有默认值，默认截取方向是从左往右的 start:默认值为0； end : 默认值未字符串结尾元素； step : 默认值为1；

格式化输出：

• %，(类似C)：

  print('大家好！我叫%s，我的身高是%d cm, 数学成绩%.2f分,英语成绩%d分' % (name, hight, score_math, score_english))

• format:
  

  print('大家好！我叫{}，我的身高是{:d} cm, 数学成绩{:.2f}分,英语成绩{}分'.format(name, int(hight), score_math, score_english))​

• f-string(Python 3.6):

  print(f"大家好！我叫{name}，我的身高是{hight:.3f} cm, 数学成绩{score_math}分,英语成绩{score_english}分")​

生成器:

类似列表生成式: L = [x * x for x in range(10)]

基于函数: 将函数返回值关键字return 改为 yield

assert: 常用于检查传入函数的参数

def worker(s):
    assert type(s)== int
    assert s != 0​

logging:

import logging
logger = logging.getLogger()
formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')

# Configure stream handler for the cells
chandler = logging.StreamHandler()
chandler.setLevel(logging.INFO)
chandler.setFormatter(formatter)
logger.addHandler(chandler)
logger.setLevel(logging.INFO)

函数参数：
参数定义的顺序必须是：必选参数(name)、默认参数(age=18)、可变参数(*books:set())、命名关键字参数(city)和关键字参数(**kw:dict())

def student_info(name, age=18, *books, city, **kw):
# 如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了
def person(name, age, *, city, job):
# 命名关键字参数需要一个特殊分隔符*，*后面的参数被视为命名关键字参数(city, job)

变量作用域：

def change_my_name():
    print('我的名字曾经是', name) #UnboundLocalError: local variable 'name' referenced before assignment
    name = '李四'
    print('我的名字现在是', name)

name = '张三'
change_my_name()
name

定义的函数中有与全局变量同名的变量被赋值，则会定义为局部变量

global 关键字调用全局变量 在函数内部的修改也会改变其在函数外部的值

def change_my_name():
    global name
    print('我的名字曾经是', name)
    name = '李四'
    print('我的名字现在是', name)

lambda匿名函数：
lambda 若干个输入参数 : 返回值的表达式

lambda arg1, arg2: arg1 + arg2

lambda 的主体是一个表达式，而不是一个代码块。仅仅能在 lambda 表达式中封装有限的逻辑进去。
lambda 函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。

高阶函数：
map()函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回。

reduce(): 用传给 reduce 中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用 function 函数运算，依此类推，最后得到一个结果。

key 可以是一个lambda或函数 对每个位置上的元素进行特定操作(或指定比较的对象)后比较

sorted(iterable, key=None, reverse=False)
key = lambda x:x.value
key = lambda x: x[0]

sorted([36, 5, -12, 9, -21], key=abs) #按绝对值排序key指定的函数将作用于list的每一个元素上，并根据key函数返回的结果进行排序

装饰器：

• 闭包：如果在一个内部函数里，对在外部作用域（但不是在全局作用域）的变量进行引用，那么内部函数就被认为是闭包(closure).

# 一个需要注意的问题是，返回的函数并没有立刻执行，而是直到调用了f()才执行。
def count():
    fs = []
    for i in range(1, 4):
        def f():
            # print(id(i))
            return i*i
        fs.append(f)
    return fs
f1, f2, f3 = count()

在这个闭包中，f()并没有被执行，但在调用count()函数时，其中的for循环已经结束，包含的变量i为3，所有三个函数返回的i*i结果一致
返回闭包时牢记一点：返回函数不要引用任何循环变量，或者后续会发生变化的变量。

def count():
    def f(j):
        def g():
            # print(id(j))
            return j*j
        return g

    fs = []
    for i in range(1, 4):
        fs.append(f(i)) # f(i)立刻被执行，因此i的当前值被传入f()
    return

在这个函数中f()可以独立看作一个闭包，在这个闭包中的闭包g()返回的j*j就不属于循环变量，而是调用时传入的变量

装饰器是函数的函数，传入的参数就是一个函数，然后通过实现各种功能来对这个函数的功能进行增强。

# 装饰器输入一个函数，输出一个函数
def print_working(func):
    def wrapper(*args, **kw):
        print(f'{func.__name__} is working...')
    func(*args, **kw)
    return wrapper
# 使用
# Method 1
worker1 = print_working(worker1)
worker1()
# Method 2 Better
@print_working
def worker1():
    print('我是一个勤劳的工作者！')

装饰器最大的优势是用于解决重复性的操作，其主要使用的场景有如下几个：

• 计算函数运行时间
• 给函数打日志
• 类型检查

偏函数：
通过设定参数的默认值，降低函数调用的难度

from functools import partial

def student_info(name, age, city):
    print(f'我的名字叫{name}, 今年{age}岁，来自{city}')
student_info_beijing = partial(student_info, city='北京')
student_info_beijing('Molly',18)

原始函数没有默认值，后期重载一个包含默认值的