可变数据类型和不可变数据类型有哪些？
# 可变数据类型：列表、字典、集合 # 不可变数据类型：数字、元祖、字符串
常见数据结构
# 栈(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()) # 25
装饰器：
在不改变被装饰函数源代码、被装饰函数的调用方式的情况下。为被装饰函数增加功能的函数，用@符调用。
搜索变量名的优先级：
# 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)