函数1

PYTHON函数1

一、函数传参

1. 实参角度

   1. 位置参数

      def meet(sex,age,skill):
           print('打开tantan')
      meet('女',25,'python技术好的',)
      

      • 三元运算符

        c = a if a > b else b
        

   2. 关键字参数

      def meet(sex,age,skill,hight,weight,):
      	print('打开tantan')
      meet(age=25,weight=100,hight=174,skill='python技术好的',sex='女')
      

   3. 混合参数

      • 位置参数一定要在关键字参数的前面。

      • def meet(sex,age,skill,hight,weight,):
            print('打开tantan')
        print(meet('女',25,weight=100,hight=174,skill='python技术好的'))
        

2. 形参角度

   1. 位置参数

   2. 默认参数

      def meet(age,skill='python技术好的',sex='女',):
      	print('打开tantan')
      meet(25,'python技术好的',)
      meet(25,'运维技术好的','男')
      

   3. 万能参数： *args, 约定俗称：arguments

      *代表聚合。 他将所有的位置参数聚合成一个元组，赋值给了 args。记住，是位置参数哦

      def eat(*args):
          print(args)#打印的元祖
          print('我请你吃：%s,%s,%s,%s,%s,%s' % args)
      
      eat('蒸羊羔', '蒸熊掌', '蒸鹿邑','烧花鸭','烧雏鸡','烧子鹅')
      

   4. 万能参数：**kwargs

      ** 将所有的关键字参数聚合到一个字典中，将这个字典赋值给了kwargs

      def func(**kwargs):
          print(kwargs)
      func(name='alex',age=73,sex='laddyboy')
      

      # * **在函数的调用时，*代表打散。
      def func(*args,**kwargs):
          print(args) # (1,2,3,22,33)
          print(kwargs)
      
      # func(*[1,2,3],*[22,33])  # func(1,2,3,22,33)
      # func(*'fjskdfsa',*'fkjdsal')  # func(1,2,3,22,33)
      func(**{'name': '太白'},**{'age': 18})  #func(name='太白',age='18')
      func(**{'name': '太白','age': 18})  #func(name='太白',age='18')
      

      #重要：函数调用时**后面一定要字典，*后面可以是列表，字符串
      
      

   5. 形参角度最终的顺序：位置参数,*args,默认参数，仅限关键字参数，**kwargs。这样的顺序是有道理的。

      *args前都是位置参数，**kwargs前都是关键字参数
      
      

      def func(a,b,*args,sex= '男',c,**kwargs,):
          print(a,b)
          print(sex)
          print(args)
          print(c)
          print(kwargs)
      func(1,2,3,4,5,6,7,sex='女',name='Alex',age=80,c='666')
      
      

   6. 如果你的默认参数指向的是可变的数据类型，那么你无论调用多少次这个默认参数，都是同一个。

      def func(a, list=[]):
          list.append(a)
          return list
      print(func(10,))  # [10,]
      print(func(20,[]))  # [20,]
      print(func(100,))  # [10,100]
      l1 = []
      l1.append(10)
      print(l1)
      l2 = []
      l2.append(20)
      print(l2)
      l1.append(100)
      print(l1)
      
      def func(a, list= []):
          list.append(a)
          return list
      ret1 = func(10,)  # ret = [10,]
      ret2 = func(20,[])  # [20,]
      ret3 = func(100,)  # ret3 = [10,100]
      print(ret1)  # [10,]  [10,100]
      print(ret2)  # 20,]  [20,]
      print(ret3)  # [10,100]  [10,100]
      
      

二、命名空间

1. python分为三个空间：
   内置名称空间（builtins.py）
   全局名称空间（当前py文件）
   局部名称空间（函数，函数执行时才开辟）

2. 加载顺序：

   内置名称空间 ---> 全局名称空间 ----> 局部名称空间（函数执行时）

3. 局部作用域可以引用全局作用域的变量,使用可以，不能改变

4. globals and locals

   a = 1
   b = 2
   def func():
       name = 'alex'
       age = 73
       print(globals())  # 返回的是字典：字典里面的键值对：全局作用域的所有内容。
       print(locals())  # 返回的是字典：字典里面的键值对：当前作用域的所有的内容。
   func()
   
   

5. global and nonlocal

   1. 局部可以引用全局变量，但不能改变它。还有一点：在函数中，如果你定义了一个变量，但是在定义这个变量之前对其引用了，那么解释器认为：语法问题，也就是局部定义变量一定要在引用之前。不能因为局部可以引用全局，就把局部声明变量放在后面了。

      count = 1
      def func():
          print(count)
          count = 3
      func()
      print(name)#错误的
      
      

   2. nonlocal:不能够操作全局变量。内层函数对外层函数的局部变量进行修改;global :可以操作

三、可迭代对象和迭代器

1. 可迭代对象iterable

   1. 字面上可以迭代循环遍历的就是可迭代对象了。专业角度，可迭代对象是内部含有'__iter__'方法的对象。包括str/list/tuple/dict/set/range/文件句柄f。

   2. 判断是否为迭代对象

      print('__iter__' in dir(s1))
      
      

   3. 优缺点

      1. 优点：存储的数据直接能显示，比较直观；拥有的方法比较多，操作方便。
      2. 缺点：占用内存；不能直接通过for循环

2. 迭代器iterator

   1. 内部含有’iter'和‘next'的方法的对象就是iterator。现在仅有文件句柄，判断是否为迭代器

      with open('文件1',encoding='utf-8',mode='w') as f1:
          print(('__iter__' in dir(f1)) and ('__next__' in dir(f1)))
      
      

   2. 要遍历，用到

      print(next(obj)) # print(obj.__next__())
      
      

   3. 优缺点

      1. 优点：节省内存。惰性机制，next一次，取一个值。
      2. 缺点：速度慢。不走回头路。

3. 转化问题

   1. 可迭代对象转迭代器

      1. 我感觉iter方法的存在就是给可迭代对象转化成迭代器用的。

         ---

      s1 = 'fjdag'
      obj = iter(s1)  # s1.__iter__()
      
      

      2. 要遍历，直接用next方法好了

         l1 = [11,22,33,44,55,66,77,88,99,1111,1133,15652]
         # 将可迭代对象转化成迭代器。
         obj = iter(l1)
         while 1:
             try:
                 print(next(obj))
             except StopIteration:
             # except Exception:
                 break
         with open('文件1',encoding='utf-8',mode='r') as ff:
             while 1:
                 try:
                     print(next(ff))
                 except StopIteration:
                 # except Exception:
                     break