40天入门python全栈(day - 4)

今日待办

• python 内部迭代器
• 装饰器，修饰器
• 前几日留下的问题
• 如何阅读python官方文档
• python内置函数
• python的类型函数和类函数
• python字符串
• python正则介绍
• leetcode十道题
• 八种排序算法
• 常用模块
• map函数

迭代器与生成器

在看文章的时候发现了一个很好的blog，今天的这篇内容大部分都是来源于这篇文章
大家可以去这篇文章学习
学习一个东西一般要问what, why, how

• what

  • 迭代器和生成器分别是什么
  • 什么是可迭代对象，什么是生成表达式
  • 以上互相之间有什么区别和联系
  • 常有的python数据类型与类（list,dict,str,tuple）是什么

• why

  • 为什么会有迭代器和生成器
  • 为什么要使用他们

• how

  • 如何创建一个生成器
  • 如何判断区分迭代器与迭代对象
  • examples

  以下依次给出问题的回答并附上相关例子

what？

• 何为迭代器，生成器？
  • iteration（迭代）访问集合元素的一种方式
    • 迭代器是一个对象，其特点是可以记住遍历的位置
    • 特点：
      • 从第一个元素开始访问
      • 只能依据指定的顺序向前访问不可以向后倒退
    • 迭代器均含有俩个基本方法
      • iter_():
      • next_()：

list = [1,2,2,3] # 创建一个列表
lst_iter = iter(list) # 列表，元组，字符串均可通过iter（）创建为迭代器
print(type(lst_iter)) # lst_iter 变成了list_iterator
print("通过next()输出迭代器下一个元素:")
print(next(lst_iter))
print(next(lst_iter)) # 此语句是相同的
print("也可以通过for循环逐次输出:")
lst_iter = iter(list)
for i in lst_iter: # for循环常与迭代结合使用
    print(i)

• 生成器是迭代器的一种，是一种程序，一串算法
• 生成器是一个返回迭代器的函数，其表现得像是迭代器
• 可以通过send()和next()函数恢复生成器
• 生成表达式会产生一个生成器
  • 生成器是一个返回迭代器的函数
  • 生成器表达式来源于迭代和解析得组合—其是一个表达式但是是可以迭代的生成器
• 生成器仅支持一个active迭代，生成器的迭代器就是生成器本身

lst = [x*x for x in range(10)]
lst_generator =(x*x for x in range(10)) # 直接通过（）创建生成器
print(f'列表生成表达式:{lst}, 类型为：{type(lst)}')
print(f'列表生成器:{lst_generator}, 类型为：{type(lst_generator)}')
# 使用生成器
print(next(lst_generator))
print(next(lst_generator))
print(next(lst_generator))
print(next(lst_generator))
print(next(lst_generator))
print(next(lst_generator))
print(next(lst_generator))
print(next(lst_generator))
print(next(lst_generator))
# print(next(lst_generator))
try:
    print(next(lst_generator))
except StopIteration:
    print('超出')
# 此时迭代数据已经超出，重新赋值 不然不会输出
finally:
    print('-'*25)
    lst_generator =(x*x for x in range(10)) # 直接通过（）创建生成器
    # 超出迭代范围时候会抛出StopIteration错误
    # 既然生成器是迭代器的一种那么生成器就必然是可迭代得
    for x in lst_generator:
        print(x) # for循环并不需要担心StopIteration错误
del(dict)

Iterable与Iterator

• 所有的生成器Iterator都是可迭代对象但Iterable并不一定是Iterator
• 主要原因在于迭代器可以被理解成为执行一段特定功能的算法程序即其理论空间是无限的可以无穷的迭代下去
  • 其表示的是一个无穷的数据流，通过我们人为的指定而终止
  • 而可迭代对象例如(list, dict, str)在我们赋予以后其值在此时空内就是固定的
    • 因此其可迭代是迭代对象但并不是迭代器
    • 通过type类型我们就可以判断出来
  • 方法中实现了iter的是可迭代的对象，只有迭代器可以用next方法进行访问
  • 两者是包含的关系
  • 所有的生成器均为迭代器
• 可以通过iter()将其变为迭代器
• 可以通过isinstance()判断一个对象是否为可迭代对象

# 判断常用数据类型
from collections import Iterator
from collections import Iterable
# 判断常用数据类型的可迭代对象
lst = [1,2,3]
st = set(lst)
t = tuple(lst)
dct = dict([('a',1),('b',1)])
s = "Hello"
a = 10
## 对文件的判断
print('list是可迭代对象么：{},list是迭代器么：{}'.format(isinstance(lst,Iterable), isinstance(lst,Iterator)))
print('set是可迭代对象么：{},list是迭代器么：{}'.format(isinstance(st,Iterable), isinstance(st,Iterator)))
print('tuple是可迭代对象么：{},list是迭代器么：{}'.format(isinstance(t,Iterable), isinstance(t,Iterator)))
print('dict是可迭代对象么：{},list是迭代器么：{}'.format(isinstance(dct,Iterable), isinstance(dct,Iterator)))
print('string是可迭代对象么：{},list是迭代器么：{}'.format(isinstance(s,Iterable), isinstance(s,Iterator)))
print('数据类型是可迭代对象么：{},list是迭代器么：{}'.format(isinstance(a,Iterable), isinstance(a,Iterator)))

• 迭代器的应用-斐波那契数列

def fibonacci(n):
    count, a, b = 0, 0, 1
    while count < n:
        yield b
        a,b = b,a+b
        count += 1
    return None
h = fibonacci(10)

print(h)
print(next(h))
for x in h:
    print(x)
# 当不采用for循环时候会报错
h_1 = fibonacci(6)
print(next(h_1))
print(next(h_1))
print(next(h_1))
print(next(h_1))
print(next(h_1))
print(next(h_1))
# 再执行这一句时候超出报错
try:
    print(next(h_1))
except StopIteration as e:
    print("返回值:",e.value)
    

装饰器/修饰器

• what
  • 装饰器是什么
  • 装饰器要装饰什么东西
  • 装饰器的几种装饰方法
  • 装饰器的几种类型
• why
  • 为什么要引入装饰器
• how
  • 装饰器是怎样工作的

对象/函数

何为函数？

• 函数是一个对象，在python中万物皆对象，函数也不例外，函数也是一种对象
• 函数是一种包含变量这种对象的对象
• 对象则是类得一种实例化（类是一些对象抽象而定义得）
• python中得对象除了函数还有列表，字符串 and so on
• 既然是对象那么就具有两种基本性质
  • 可以被赋值于其他对象
  • 可以被定义在另一个函数体内即作为变量被定义在函数这个对象内

# 函数可以被赋值于其他变量
def func_():
    print("this's a function")
func_copy = func_
func_copy()
func()
print(func_copy is func_)
print(id(func_),id(func_copy))

# 函数可以作为变量被定义和传递
def func_o (fc):
    print('out')
    fc() # 这里的fc为函数变量被传递进来
def func_fc():
    print('我就是被传递的')
func_o(func_fc)
print('*'*25)
def fc_1():
    print('this is fc_1')
    return fc_2
def fc_2():
    print('this is fc_2')
fc_ = fc_1()
fc_()
# 该函数其实与上面的实现是一样的
# fc_() = fc_1(fc_2())

函数的执行顺序为func_o(接受传递的参数func_fc(实参),fc为形参) -> 调用func_fc()执行

函数的嵌套以及闭包

• 嵌套
  • 在func_outer内部又定义了一个func_inner函数
  • func_outer的作用域应该包含func_inner的作用域
  • 在已经声明的一个函数内部又声明一个函数
• 闭包
  • 返回的函数对象，不仅仅是一个函数对象，在该函数外还包裹了一层作用域，这使得，该函数无论在何处调用，优先使用自己外层包裹的作用域
  • 用途*******?
    • 保存函数返回断点
    • 根据外部作用域的局部变量得到不同结果

def func_outer():
    a = "Here is in the func_outer but out of func_inner"
    print(a)
    def func_inner():
        b = "Here is in the func_inner"
        print(b)
        c = 'but i can use out variation\n' + a
        print(c)
    return func_inner()
f = func_outer
print(f())
# 最后其返回了内部的func_inner()
# 其所返回的不只是该函数对象还包括其外层的作用域

def add_out(o_num):
    def add_inner(i_num):
        return o_num + i_num
    return add_inner
res_fc1 = add_out(12)
res_fc2 = add_out(18)
print(res_fc1(100))
print(res_fc2(100))
# 传入的是同一个输入100的参数但输出却不一样
# 可以封闭内部的细节
# 可以对传入的参数施加外部装饰

python内置函数

• 数学运算
  • len(object,/) ：返回容器变量内的元素个数（包括字符串中单个字符的长度）
  • max(iterable, *[,default = obj, key = func]) ->value
  • pow
  • round
  • sum
  • abs
  • divmod
  • complex
  • hash
  • id
• 逻辑运算
  • all
  • any
• 进制转化
  • ascii
  • bin
  • oct
  • hex

类型函数

• bool()
• bytes()
• str()
• chr()
• ord()
• dict()
• set()
• list()
• tuple
• object()
• int()
• float()
• frozenset()
• range()
• slice()
• type()
• zip()

类对象及属性

• classmethod
• delattr()
• dir()
• getattr()
• hasattr()
• isinstance()
• issubclass()
• property()
• super()
• callable()