python基础 Day11

python Day11

• 函数中默认参数的陷阱

  • 只针对默认参数是可变的数据类型（如果你的默认参数指向的是可变的数据类型，那么你无论调用多少次默认参数，都是同一个）

    def test(name,list=[]):
        list.append(name)
        return list
    res=test("Zhxuiayu")
    print(res)
    res1=test("zhu")
    print(res1)
    ##正确的结果：['Zhxuiayu']
           ##   ['zhu']
    ##运行的结果：['Zhxuiayu']
           ##   ['Zhxuiayu', 'zhu']
    #解析：因为这里的lsit=[]变量即不再全局空间中也不在局部名称空间中
    

  • 在函数中，如果你定义了一个变量，但是在定义这个变量之前对其进行引用了，那么解释器认为：语法问题，应该在使用前经常定义

    count=1
    def func():
        print(count)
        count=3
    func()
    ##结果 UnboundLocalError: local variable 'count' referenced before assignment
    

  • 全局变量global ,在局部变量前添加global，全局名称空间变量可以引用局部名称变量

    def func():
        global  name
        name="zhuxiayu"
    func()
    print(name)
    

  • nonlocal(不能操作全局变量，是内层函数对外层函数的局部变量进行修改）

    def wapper():
        count=1
        def inner():
            nonlocal  count
            count+=1
            print(count)
        inner()
    wapper()
    ##结果：2
    

• 函数名的应用

  • 函数名指向的是函数的内存地址

• 函数名+（）就可以执行次函数

• 函数名就是变量

  def fun():
      print("1")
  def fun1():
      print("2")
  fun1=fun
  fun1()
  ##结果1
  

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

  def fun():
      print("1")
  def fun1():
      print("2")
  def fun2():
      print("3")
  l1=[fun,fun1,fun2]
  for i in l1:
      i()
  

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

  def fun():
      print("1")
  def fun1(x):
      x()
  fun1(fun)
  ##结果 1
  

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

  def fun():
      print("1")
  def fun1(x):
      return x
  rest=fun1(fun)
  rest()
  ##结果 1
  

• 格式化输出

  • 任意表达式

    #结合字典格式
    dict={"name":"zhxuaiyu","age":12}
    print(f'我的名字是{dict["name"]},我的年龄是{dict["age"]}')
    ###结果：我的名字是zhxuaiyu,我的年龄是12
    

    ###结合函数的形式
    def sum(a,b):
        return a+b
    print(f"最终的结果为：{sum(10,20)}")
    

  • 优缺点

    • 缺点是！，：{}这些标点符号不能出现在表达式的{}中
    • 优点:
      • 结构更加简单
      • 可以结合表达式，函数进行使用

• 迭代

  • 可迭代对象
    • python中一切皆对象。一个实实在在存在的值，对象。
    • 可迭代：更新迭代。重复的，循环的一个过程，每次都有新的内容，可以进行循环更新的一个实实在在的值。
    • str list tuple dict set range 文件句柄
    • 内部含有‘——iter——’方法的对象，可迭代对象。
  • 可迭代对象的优点
    • 存储的数据直接能显示，比较直观
    • 拥有的方法比较多，操作方便。
  • 可迭代对象的优点
    • 占用内存

• 迭代器（可更新迭代的工具）

  • 迭代器的定义

    • 内部含有‘——iter——‘方法并且含有’——next——‘方法的对象就是迭代器。

    • 可以判断是否是迭代器：‘——iter——‘and’——next——‘在不在dir(对象中)

      ss1="Fdsfsdffddfs"
      obj=iter(ss1)
      for i in range(len(ss1)):
          print(obj.__next__())
      

    • 优点

      • 节省内存。
      • 惰性机制，next一次，取一个值，绝不过多取值。因为是按需一次获取一次数据项，这样占的内存就很少。next一次，取一个值

    • 缺点

      • 时间慢
      • 不走回头路

  • 可迭代对象与迭代器的对比

    • 可迭代对象是一个操作方法比较多，比较直观，存储数据相对少的一个数据集。

    • 当你数据量过大，大到足以撑爆你的内存或者你以节省为首选因数时，将数据集设置为迭代器是一个不错的选择。

    • 利用while去模拟for循环对可迭代对象进行取值的机制。

      ss1="Fdsfsdffddfs"
      obj=iter(ss1)
      while 1:
          try:
              print(obj.__next__())
          except StopIteration:
              break
      

• 作业

  • 看代码写结果

    def func1():
        print("in the func1")
    def func2(x):
        print("in func2")
        return x
    def func3(y):
        print("in the func3")
        return y
    ret=func2(func1)
    ret()
    ###结果：in func2
         ## in the func1
    

    def func1():
        print("in the func1")
    def func2(x):
        print("in func2")
        return x
    def func3(y):
        print("in the func3")
        return y
    ret=func3(func2)
    ret1=ret(func1)
    ret1()
    ###结果：in the func3
       ###  in func2
       ###  in the func1
    
    

    def func():
        for item in range(10):
            pass
        print(item)
    func()
    ###结果：9
    

  • 传入一个参数n，返回一个n的阶乘

    #传入一个参数n返回一个n的阶乘
    def func(number):
        count=1
        for i in range(number,0,-1):
            count=count*i
        return count
    print(func(4))
    

  • 写一个函数，返回一个扑克牌列表，里面有52项，每一项是一个元组，eg:[("草花"，2)，（“红心”：3）]

  def pukepai(*args):
      list=[]
      for i in range(0,len(args),2):
          tuple1=args[i:i+2]
          list.append(tuple1)
      return list
  list=["红桃",2,"草花",3]
  print(pukepai(*list))
  

  • 写代码完成99乘法表

    for m in range(1,10):
        for n in range(1,10):
            if m<=n:
                print("%s*%s=%s"%(m,n,m*n),end=" ")