Python基础 4.函数

4.1 函数的定义

• 函数的定义：

  def 函数名(参数)： pass return 表达式

  函数名命名规则： 字母、数字和下划线组成，和变量命名规则一致 pass在这里表示什么都没有，不执行任何操作 return 后面可以返回任意表达式，但不能是赋值语句

• 函数调用：

  函数名(参数)

• return 和 print 的区别：

  return没有写返回值的话，默认None

  return是函数的返回值，返回值可以赋值给变量，而print只是打印出来

4.2 函数参数

• 必备参数：

def func(x):
    print(x)

func(1)

 

• 默认参数：

def func(x, y=None):
    print(x)
    print(y)

func(1) 
func(1, 2)

 

　　注意：默认参数要位于必备参数列表的后面

 

• 形参与实参

　　　　形参即变量名，实参即变量值，函数调用时，将值绑定到变量名上，函数调用结束，解除绑定

　　1 def sq(data):  #形参
　　2     print(data)
　　3 ret=123
　　4 sq(ret) #实参

 

• 不定长参数：

def  func(*args, **kwargs):
    print(args)
    print(kwargs)

　　　args: 参数包装成一个元组 kwargs： 参数包装成字典

　　　调用1：func(1, 2, 3, a=4, b=5, c=6)

　　    调用2：func(*(1, 2, 3), **{'a': 4, 'b': 5, 'c': 6})

 

def func(a,b,c):
    print(a)
    print(b)
    print(c)
my_list=[1,5,2]
func(*my_list)
#一个  * 解包列表等     两个解字典



def foo(*args,**kwargs):
    print( 'args=', args)
    print('kwargs=', kwargs)
foo(1,2,3)
foo(a=1,b=2,c=3)
foo(1,'b','c',a=1,b='b',c='c')
foo(*["a","b","c"],**{"a":"a","b":"b"})  #列表、字典
ps：参数顺序（位置参数，*args，默认参数，**kwargs）

 

执行结果：

• print (func()): 函数返回值
• print (func) : 函数本身

 

4.3 Python中简单内置函数

• 内置对象查看：

  dir(builtins)

• 常见函数：

　　　　len 求长度

　　　　min 求最小值

　　　　max 求最大值

　　　　sorted 排序

　　　　reversed 反向

　　　　sum 求和

• 进制转换函数：

  bin 转换为二进制 oct 转换为八进制 hex 转换为十六进制 ord 字符转ASCII码 chr ASCII码转字符

• 一、内置函数

  1.1、作用域相关

  locals()  #以字典的类型返回当前位置的全部局部变量。
  globals() #以字典的类型返回全部全局变量。

   

  1.2、迭代器生成器相关

  range()  #可创建一个整数对象，一般用在 for 循环中
  next() #内部实际使用了__next__方法，返回迭代器的下一个项目。
  iter()  #用来生成迭代器（将一个可迭代对象，生成迭代器）同于：__iter__()

   

  1.3、基础数据类型相关

  bool()   #用于将给定参数转换为布尔类型，如果没有参数，返回 False
  int()   #用于将一个字符串或数字转换为整型。
  float()  #用于将整数和字符串转换成浮点数。
  list()   #将一个可迭代对象转化成列表
  tuple()  #将一个可迭代对象转化成元祖
  dict()  #创建一个字典
  set()  #创建一个集合
  str()  #转化成字符串

   

  1.4、转换及运算相关

  bin() #将十进制转换成二进制并返回。
  oct()#将十进制转化成八进制字符串并返回
  hex()#将十进制转化成十六进制字符串并返回。
  print(bin(10),type(bin(10)))  # 0b1010 <class 'str'>
  print(oct(10),type(oct(10)))  # 0o12 <class 'str'>
  print(hex(10),type(hex(10)))  # 0xa <class 'str'>
  abs()#返回数字的绝对值。
  divmod()#计算除数与被除数的结果，返回一个包含商和余数的元组(a // b, a % b)。
  round()#保留浮点数的小数位数，默认保留整数。
  pow()#求x**y次幂。（三个参数为x**y的结果对z取余）
  print(abs(-5))  # 5
  print(divmod(7,2))  # (3, 1)
  print(round(7/3,2))  # 2.33
  print(round(7/3))  # 2
  print(round(3.32567,3))  # 3.326
  print(pow(2,3))  # 两个参数为2**3次幂  结果8
  print(pow(2,3,3))  # 三个参数为2**3次幂，对3取余。 余数2
  sum()#对可迭代对象进行求和计算（可设置初始值）。
  min()#返回可迭代对象的最小值（可加key，key为函数名，通过函数的规则，返回最小值）
  max()#返回可迭代对象的最大值（可加key，key为函数名，通过函数的规则，返回最大值）
  print(sum([1,2,3]))  #6
  print(sum((1,2,3),100))  #106
  print(min([1,2,3]))  # 返回此序列最小值1
  ret =min([1,2,-5,],key=abs)  # 按照绝对值的大小，返回此序列最小值
  print(ret) #1
  dic ={'a':3,'b':2,'c':1}
  print(min(dic,key=lambdax:dic[x]))# x为dic的key，lambda的返回值（即dic的值进行比较）返回最小的值对应的键
  print(max([1,2,3]))  # 返回此序列最大值3
  ret =max([1,2,-5,],key=abs)  # 按照绝对值的大小，返回此序列最大值-5
  print(ret)
  dic ={'a':3,'b':2,'c':1}
  print(max(dic,key=lambdax:dic[x]))# x为dic的key，lambda的返回值（即dic的值进行比较）返回最大的值对应的键
  reversed() #将一个序列翻转，并返回此翻转序列的迭代器。
  slice() #构造一个切片对象，用于列表的切片
  ite =reversed(['a',2,3,'c',4,2])
  fori inite:
      print(i)  #2 4 c 3 2 a
  li =['a','b','c','d','e','f','g']
  sli_obj =slice(3)
  print(li[sli_obj]) #['a', 'b', 'c']
  sli_obj =slice(0,7,2)
  print(li[sli_obj])  #['a', 'c', 'e', 'g'],开始、结束、步长
  format() #与具体数据相关，用于计算各种小数，精算等
  bytes()#用于不同编码之间的转化。
  s ='你好'
  bs =s.encode('utf-8')
  print(bs)  #b'\xe4\xbd\xa0\xe5\xa5\xbd'
  bs =bytes(s,encoding='utf-8')
  print(bs)  #b'\xe4\xbd\xa0\xe5\xa5\xbd'
  s1 =bs.decode('utf-8')
  print(s1) #你好
  bytearry()#返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256
  ret =bytearray('jump',encoding='utf-8')
  print(id(ret))
  print(ret)
  print(ret[0])
  ret[0] =65
  print(ret)
  print(id(ret))
  memoryview()
  ret =memoryview(bytes('你好',encoding='utf-8'))
  print(len(ret))  #6
  print(ret)   #<memory at 0x008A0BF8>
  print(bytes(ret[:3]).decode('utf-8'))  #你
  print(bytes(ret[3:]).decode('utf-8'))   #好
  ord()#输入字符找该字符编码的位置
  chr()#输入位置数字找出其对应的字符
  ascii()#是ascii码中的返回该值，不是就返回/u...
  print(ord('a'))  #97
  print(ord('中'))  #20013
  #chr 输入位置数字找出其对应的字符
  print(chr(97))  #a 
  print(chr(20013))  #中
  #是ascii码中的返回该值，不是就返回/u...
  print(ascii('a')) #"a"
  print(ascii('中')) #'\u4e2d'
  repr()#返回一个对象的string形式

   

  1.5、常用相关

  id() #用于获取对象的内存地址
  hash#获取一个对象（可哈希对象：int，str，Bool，tuple）的哈希值
  print() #输出
  input() #输入
  open() #打开文件
  type()  #对象类型
  len#返回一个对象中元素的个数（长度）
  dir() #查看一个对象的方法
  help()  #帮助方法
  isinstance() #来判断一个对象是否是一个已知的类型，类似 type()
  a=123
  isinstance(a,int) #True
  __import__#用于动态加载类和函数
  __import__('a')        # 导入 a.py 模块

   

  1.6、其他相关

  eval()#执行字符串类型的代码，并返回最终结果
  exec()#执行字符串类型的代码。
  compile()#将字符串类型的代码编译。代码对象能够通过exec语句来执行或者eval()进行求值。
  eval('2 + 2')  # 4
  s ='''
  for i in [1,2,3]:
      print(i)
  '''
  exec(s)  #1 2 3
  complex()#函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。
  filter()#过滤
  deffunc(x):returnx%2==0
  ret =filter(func,[1,2,3,4,5,6,7])
  print(ret)  #<filter object at 0x006327B0>
  fori inret:
      print(i)  #2,4,6
  zip() #拉链方法
  #用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同
  l1 =[1,2,3,]
  l2 =['a','b','c',5]
  l3 =('*','**',(1,2,3))
  fori inzip(l1,l2,l3):
      print(i)   #(1, 'a', '*')  (2, 'b', '**')  (3, 'c', (1, 2, 3))
  map()#会根据提供的函数对指定序列做映射。
  defsquare(x) :            # 计算平方数    
      returnx **2
  map(square, [1,2,3,4,5])   # 计算列表各个元素的平方 [1, 4, 9, 16, 25]
  sorted()#对所有可迭代的对象进行排序操作
  L =[('a', 1), ('c', 3), ('d', 4),('b', 2), ]
  sorted(L, key=lambdax:x[1])               # 利用key[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
  students =[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
  sorted(students, key=lambdas: s[2])            # 按年龄排序[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
   sorted(students, key=lambdas: s[2], reverse=True)    # 按降序[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
  frozenset()#返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。
  enumerate()#枚举，返回一个枚举对象 (可迭代对象加序号)
  li =['a','b','c','d','e']
  fori inenumerate(li):
      print(i)
  forindex,name inenumerate(li,1): #索引默认从0开始，可改成1开始
      print(index,name)
  all()#可迭代对象中，全都是True才是True
  any()#可迭代对象中，有一个True 就是True
  callable() 检查是否是函数  返回True、False
  defadd(x,y):returnx+y
  callable(add)             # 返回 True
  a=123
  callable(a)  #返回False

   

  1.7、类相关

  object() #是Python中所有类的基类，如果定义一个类时没有指定继承哪个类，则默认继承object类。
  staticmethod()#静态方法
  classmethod()#是一个装饰器函数，用来标示一个方法为类方法
  property()#静态属性
  super() #用于调用父类(超类)的一个方法
  issubclass() #方法用于判断参数 class 是否是类型参数 classinfo 的子类。如果 class 是 classinfo 的子类返回 True，否则返回 False。
  vars() #返回对象object的属性和属性值的字典对象，如果没有参数，就打印当前调用位置的属性和属性值 类似 locals()
  hasattr(object,name) #判断name是否在object,判断object中是否有一个叫name的方法或者属性
  getattr(object,name,"xxx")#取object中name 的值，xxx为找不到报错信息，否则找不到报错
  setattr(x,y,v) #给x对象中的y属性设置值v
  delattr(x,y)#删除对象x中y

   

   1.8、几个重要的内置函数

  zip()
  filter()
  map()
  max()
  min()
  sorted()
  enumerate()

4.4 Python中高级内置函数

• 返回一个可以枚举的对象

  enumerate

• 取出字符串中的内容

• 将字符串str当成有效的表达式来求指并返回计算结果

  eval

• 执行字符串编译过的字符串 不返回结果

  exec

• 过滤器

  filter

• 对于参数中的每个元素都应用函数中，并将结果作为列表返回

  map()

• 将对象逐一与()中的方法配对

  zip

 　　

    my_list=[1,2,5,6,9,8,7,4,5,66,55,54,444,]
    def sorted_func(data,my_order):
        if my_order is True:
            result=sorted(data,reverse=False)
            return result
        elif my_order is False:
            result = sorted(data, reverse=True)
            return result
        else:
            print('youwenti')
    
    print(sorted_func(my_list,True))
​
#########                         zip
​
    my_dict={'a':100,'b':200,'c':300}
    my_tuple=(400,500,'haha')
    
    def exchange_list (my_dict,my_tuple):
        new_dict= dict(zip(my_dict.keys(),my_tuple))
        new_tuple= tuple(my_dict.values())
        return new_dict,new_tuple
    
    new_dict,new_tuple = exchange_list (my_dict,my_tuple)
    print(new_tuple)
    print(new_dict)
​
#############                     map 
​
    a=[1,2,3,4]
    def func (args):
        return args*100
    result=list(map(func,a))
    print(result)
​
############                     enumerate
​
    a=[22,66,77,99,656]
    for i in enumerate(a):
        print(i)
​
################                 filter
    
    a=[1,2,3,4]
    def func(args):
        if args>2:
            return  True
        else:
            return False
    result=list(filter(func,a))
    print(result)
​

 

4.5 匿名函数

lambdaa,b:a**b
#关键字 参数：返回值
#参数可以有多个，用逗号隔开
#匿名函数不管逻辑多复杂，只能写一行，且逻辑执行结束后的内容就是返回值
#返回值和正常的函数一样可以是任意数据类型

 

4.6 函数作用域

外部不能访问函数内部变量：
数内部能够访问函数外部变量
函数里面不能修改函数外部变量

global(全局变量)：      最外层

x = 123
def   fun1():
    global x
    x += 1
    return x

nonlocal(局部变量):    上一层变量

def  fun2():
    x = 123
    def fun3():
        nonlocal x
        x += 1
        return  x
    return fun3()

 

4.7嵌套函数 闭包

 

• 嵌套函数

def func_out():
    def func_int():
        print('nei ')
    return func_int
result=func_out()
result()

 

• 闭包：

  闭包是函数里面嵌套函数，外层函数返回里层函数，这种情况称之为闭包。

  闭包是概念，不是某种函数类型，和递归的概念类似，就是种特殊的函数调用，闭包可以得到外层函数的局部变量，是函数内部和函数外部沟通的桥梁

def fx(x):    
     x += 1    
     def fy(y):        
          return x*y    
     return fy
​
    def func_out(times):
        def func_int(num):
            return times*num
        return func_int
    
    time_5=func_out(5)
    print(time_5(100))
    
    time_8=func_out(8)
    print(time_8(100))
​

 

4.8递归和回调函数 （要有递归的终止条件）

1.递归：

函数自身调用自身，但是使用时类似于条件循环一样，要有递归的终止条件
​

def factorial(num):
    if num ==1:
        return num
    return factorial(num-1)*num
​
print(factorial(6))

2.回调函数：

自身是一个函数，只是被传入到另一个函数当中，供其调用
​
回调函数不一定会被调用，是否调用由被传入函数的内部逻辑决定

​

    def add (x,y):
        return x+y
    def multipy(x,y):
        return x*y
    def use(func,num1,num2):
        return func(num1,num2)
    
    a=10
    b=20
    print(use(add,a,b))
​

4.9 肥波数列

def feib(num):
    a=0
    b=1
    while b <num:
        print(b)
        a,b=b,a+b
​
feib(10)
def feib(num):
    if num==1 or num==2:
        return 1
    return feib(num-1)+feib(num-2)
​
print(feib(5))