python--基础知识点梳理（一）数据类型、迭代生成装饰器、函数

可变数据类型和不可变数据类型有哪些？

# 可变数据类型：列表、字典、集合
# 不可变数据类型：数字、元祖、字符串

常见数据结构

# 栈(stack)--先进后出、 队列(queue)-先进先出、链表(LinkedList)

可迭代对象

# 可迭代对象包括：列表、字典、集合、字符串等数据类型。
# 数字类型不可迭代

迭代：我们把python中被for循环取值的操作过程可以理解为迭代

可迭代对象：把可以被for循环遍历的对象也叫可迭代对象。一个具有__iter__()方法的对象是可迭代的，具有__next__()方法的对象是迭代器。(__iter__()方法返回自己，__next__()返回for循环的下一个对象，for循环的本质就是不断调用__next__()方法)

迭代器：访问集合内元素的一种方式。是一个可以记住遍历的位置的对象。迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不能后退，分步骤的完成某个事情

# 迭代器实现斐波那契：
class Fei(object):
    def __init__(self,n):
        self.n=n
        self.num1=0
        self.num2=1
        self.word_index=0
    def __iter__(self):
        return self
    def __next__(self):
        if self.word_index < self.n:
            num=self.num1
            self.num1,self.num2=self.num2,self.num1+self.num2
            self.word_index+=1
            return num
        else:
            raise StopIteration
a=Fei(10)
for i in a:
    print(i,end=" ")            # 0 1 1 2 3 5 8 13 21 34

 

判断是否是可迭代对象

#通过isinstance 判断是否是可迭代对象
from collections import Iterable
def test(name,obj):
#返回布尔值 true 或 false
    flag = isinstance(obj,Iterable)# isinstance 接收两个参数 第一个是你要判断的对象 第二个是固定的 Iterable
    print("%s 是否是可迭代对象%s"%(name,flag))
test("字符串","hello")            # True
test("列表",[2,3,5,7,9])           # True
test("数字",10)                  # False
test("range",range(10))          # True

自定义迭代器

# 自定义可迭代对象
class Userlist(object):
    def __init__(self):
        self.list_item = []
    def append_item(self,name):
        self.list_item.append(name)
    def func(self):
        #获取Userlist对象的迭代器
        user_iter = iter(user)
        print(next(user_iter))
        print(next(user_iter))
        print(next(user_iter))
        print(next(user_iter))
        print(next(user_iter))
    # 通过iter 方法返回一个迭代器
    def __iter__(self):
        stu = StuIterable(self.list_item)
        return stu # 返回迭代器
# 自定义迭代器
#一个实现了__iter__方法和__next__方法的对象，就是迭代器。
class StuIterable(object):
    def __init__(self,list_item):
        self.list_item = list_item
        self.current_index = 0    #定义变量，记录下标位置
    #重写next 方法返回数据
    def __next__(self):
        if self.current_index<len(self.list_item):
            self.current_index+=1
            return self.list_item[self.current_index-1]
     # 本身是一个迭代器 所以返回自己就好
    def __iter__(self):
        return self
#创建Userlist对象
user = Userlist()
user.append_item("小花")
user.append_item("小明")
user.append_item("小红")
user.append_item("小丽")
user.append_item("小强")
user.func()

生成器：生成器是一个特殊的迭代器，内部封装了__iter__()方法。在python中一边循环一边计算的机制称为生成器。比如：列表推导式、yield关键字

# 普通列表推导式
print([i*2 for i in range(10)])        # [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
# 将列表推导式中的方括号改成小括号就是一个生成器
print((i*2 for i in range(10)))        # <generator object <genexpr> at 0x02D65B30>

# yield生成器实现斐波那契：       没有yield 他就是个普通的函数，有了yield 就是一个生成器
def fi(n):
    current_index=0
    num1 = 0
    num2 = 1
    while current_index<n:
        num = num1
        num1,num2 = num2,num1+num2
        print("=======1")
        yield num
        print("=======2")
    return "done"
f = fi(10)
print(next(f))
print(next(f))
print(next(f))

"""
=======1
0
=======2
=======1
1
=======2
=======1
1
"""

yield和return的区别：

yield相当于 return 返回一个值，并且记住这个返回的位置，下次迭代时，代码从yield的下一条语句开始执行。

return会终止当前函数，且不会记住当前位置，下次执行依然重新开始

闭包：

首先必须是嵌套函数，外层函数返回内层函数，内层函数应用了外层函数的变量。闭包的应用一般可以用作装饰器。

def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    return sum        #将定义的函数sum()作为结果值返回
f = lazy_sum(1, 3, 5, 7, 9)
print(f())          #

装饰器：

在不改变被装饰函数源代码、被装饰函数的调用方式的情况下。为被装饰函数增加功能的函数，用@符调用。

搜索变量名的优先级：

# LEGB原则：
# 局部作用域local > 嵌套作用域enclosing > 全局作用域global > 内置作用域 built-in

函数：是指将一组语句的集合通过一个名字(函数名)封装起来，要想执行这个函数，只需调用其函数名即可

python函数的三种传参方式

# 位置参数（name）
def stu_register(name,age,course):
# 关键字参数（指定参数名可以不按顺序传参）
stu_register(age=22,name='alex',course="python",)
# 非固定参数（*args必须放在**kwargs前面，*args接收列表类型参数，**kwargs接收字典类型参数）
def stu_register(name,age,*args,**kwargs):

python函数的四种类型

# 1. 无参数，无返回值
# 2. 无参数，有返回值
# 3. 有参数，无返回值
# 4. 有参数，有返回值

递归：函数在内部调用自身本身，这个函数就是递归函数。递归的最大层数是998，根据电脑性能CPU决定。

递归函数的优点是定义简单，逻辑清晰。理论上，所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰。 缺点是过深的调用会导致栈溢出

# 递归实现斐波那契：
def gui(num):
    if num > 0:
        if num == 1:
            return 0
        elif num == 2:
            return 1
        else:
            return gui(num-1)+gui(num-2)
    else:
        return False
for i in range(1,11):
    print(gui(i),end=" ")           # 0 1 1 2 3 5 8 13 21 34

python四大高阶函数

lambda匿名函数

res = map(lambda x:x**2,[1,5,7,4,8])
for i in res:
    print(i)