Python 函数 III

1. 今日内容

   1. 默认参数的坑
   2. 函数名的应用
   3. python新特性：f-string
   4. 可迭代对象
   5. 迭代器
   6. 可迭代对象与迭代器的对比

2. 昨日回顾

   1. 万能参数，动态参数

   def func(*args,**kwargs):
     pass
   #函数的定义：*将实参角度的所有位置参数聚合成一个元组，赋值给args
   #**将实参角度的所有的关键字参数聚合成一个字典赋值kwargs
   func(*[1,2,3],**{'name':'alex','age':18})#函数的执行：* ** 打散

   1. 第四种传参：

      仅限关键字参数：* ,c

   2. 形参角度的最终顺序：

      位置参数，*args，默认参数，仅限关键字参数，**kwargs

   3. 名称空间：

      内置，全局，局部

   4. 取值，加载顺序

      加载：内置，全局，局部

      取值：就近原则

   5. 作用域

      全局，局部

   6. glocals():返回字典，全局作用域的所有内容

      locals()：返回字典，当前作用域的所有内容

   7. 嵌套函数

3. 具体内容

   1. 默认参数的坑

   #当默认参数是可变的数据类型，坑坑坑
   def func(a,l=[]):
     l.append(a)
     return l
   print(func(1))#[1,]
   print(func(2))#[1,2]
   print(func(3))#[1,2,3]
   
   def func(val,li=[]):
     li.append(val)
     return li
   list1 = func(1)#[1,]
   list2 = func(123,[])#[123,]
   list3 = func(2)#[1,2]
   print(f'list1={list1}')#[1,2]
   print(f'list2={list2}')#[123]
   print('list3=%s'%list3)#[1,2]
   
   def func(val,lis=[]):
     lis.append(val)
     return lis
   print(f'lis1={func(1)}')#[1,]
   print(f'lis2={func(123,[])}')#[123,]
   print(f'lis3={func(2)}')#[1,2]

   1. 函数名的应用

      • 函数名是一个特殊的函数

      def func():
        print(666)
      print(func)#func = <function func at 0x00000000003F1EA0>
      #函数名指向的是函数的内存地址，
      fucn()#执行函数

      • 函数名是一个变量

      def func():
        print(666)
      ret = func
      ret1 =ret
      ret1()
      ret()

      • 函数名可以作为容器类类型的元素

      def func1():
        print('func1')
      def func2():
        print('func2')
      def func3():
        print('func3')
      li = [func1,func2,fucn3]
      for i in li:
        i()

      • 函数名可以作为函数的实参

      def func1():
        print('func1')
      def func2(argv):
        print('func2')
        argv()
      print(func2(func1))

      • 函数名可以作为函数的返回值

      def func1():
        print('func1')
      def func2(argv):
        print('func2')
        return argv
      ret = func2(func1)
      ret()

   2. python 新特性 f-string

      #f不区分大小写
      num = input('>>>')
      s = F'{num}'
      print(s)
      
      #加入表达式
      s = 'alex'
      s1 = f'我的名字是{s.upper()}'
      print(s1)
      
      #结合函数
      li = [1,2,3,4]
      s1 = f'{li[0],{li[1]}}'
      print(s1)
      
      #不能放一些特殊的函数 ! , : { } ;
      print(f'{{{66}}}')#{66}

   3. 可迭代对象

      • 字面意思：一个可以重复取值的实实在在的东西。

      ​ 专业角度：内部函数 'iter' 方法的对象，就是可迭代对象

      • 内置函数：dir()

      • 判断一个对象是否是可迭代对象：

        print('iter'in dir(str))
        

      • 优点：

        1. 直观
        2. 操作方法较多

      • 缺点：

        1. 占内存
        2. 不能迭代取值（索引，字典的key）

   4. 迭代器

      • 字面意思：可以重复的工具

        专业角度：内部含有 'iter' 和 'next' 方法的对象

      • 可迭代对象转化成迭代器

        li = [1,2,3,4]
        obj = iter(li)
        #迭代器利用next()取值
        print(next(obj))
        print(next(obj))
        
        #迭代器一条路走到底，不会头
        li = [1,2,3,4,5,6]
        obj = iter(li)
        for i in range(3):
          next(i)
        for i in range(2):
          next(i)
        
        #迭代器：
        #利用while循环，模拟for循环内部循环可迭代对象的机制
        #1.先要将可迭代对象转化成迭代器
        #2.利用next对迭代器进行取值
        #3.利用异常处理try一下防止报错
        li = [1,2,3,4,5]
        obj = iter(li)
        while 1 :
          try:
            print(next(obj))
          except StopIteration:
            break
        

      • 优点

        1. 非常节省内存
        2. 惰性机制

      • 缺点：

        1. 效率低
        2. 不直观
        3. 操作不灵活

   5. 可迭代对象与迭代器的对比

      可迭代对象：可迭代对象是一个操作比较灵活，直观，效率相对高，但是比 较占内存的数据集

      迭代器：迭代器是一个非常节省内存，满足惰性机制，但是效率相对低，操 作不灵活的数据集