函数

print 函数

  • 默认输出并换行: print("string")

  • 指定输出结束符: print("string", end="__")

自定义函数

def func_name():
  ...
  return None
`

  • 形式参数(形参)

  • 传递参数/实际参数(传参/实参)

  • 返回值(注意：返回值得内存地址)

  • 函数嵌套调用，必须顺序正确

  • 位置参数：必须传值，且有几个参数就传几个传值

  • 默认参数：没有传值，使用默认参数

  • 形参：

    • *args: 元祖

    • **kargs: 字典

func(1,2,3, a='a',b='b',c='c')
args = (1,2,3)
kargs = {a:'a',b:'b',c:'c'}

li = [1,2,3]
func(*li) # 实参角度，序列按照顺序打散

def func(*args): # 形参角度，给变量加上*，就是组合所有传来的值
'''
#     这个函数实现了什么功能
#     参数1：
#     参数2：
#     :return: 是字符串或者列表的长度
#     '''

  • 形参：

    • 位置参数 ： 必须传

    • *args ：可以接收任意多个位置参数

    • 默认参数 ： 可以不传

    • **kwargs ： 可以接收多个关键字参数

  • 实参：按照位置传参，按照关键字传参

  • 默认函数参数的值是一个可变数据类型，那么每一次调用函数的时候，如果不传值就公用这个数据类型的资源

def fun(k, l={}):
  l[k] = 'v'
  print(l)

fun(1) # {1:'v'}
fun(2) # {1:'v',2:'v'}
fun(3) # {1:'v',2:'v',3:'v'}

命名空间和作用域

  • 内置命名空间

    • Python解释器启动就可以使用的名字存储在内置命名空间中

    • 内置的名字在启动解释器的时候被加载进内存里

      • print()

      • input()

  • 全局命名空间

    • 在程序从上到下被执行的过程中一次加载进内存的

    • 放置了我们设置的所有变量名和函数名

  • 局部命名空间

    • 函数体内定义的名字

    • 调用函数的时候，才会产生这个名称空间，随着函数执行的结束，这个命名空间就消失

  • 在局部:可以使用全局、内置命名空间中的名字

  • 在全局:可以使用内置命名空间中的名字，但是不能用局部中使用

  • 在内置:不能使用局部和全局的名字的

  • globals()

  • locals()

  • global 关键字

局部调用：局部命名空间 < 全局命名空间 < 内置命名空间

全局调用：全局命名空间 < 内置命名空间

nonlocal

只能用于局部变量，找上层中离当前函数最近一层的局部变量

声明了 nonlocal 的内部函数的变量修改会影响到里当前函数最近一层的局部变量

对全局无效

对局部也是对最近一层有影响

return

函数里没有 return, 会默认返回一个 None

如果return多个对象，那么 Python 会把多个对象封装成一个元组作为一个一个整体结果输出

作用域

LEGB: Local < Enclosing < Global < Builtin

内置函数 Buil-in functions

不需要导入模块就可以使用的函数

  • abs()

  • all([1,2,3,4]) 所有元素都是真的时候返回 True

    • None => False

    • "" => False

    • [] => False

    • () => False

    • {} => False

  • any(['',1,{}]) 只有有一个真的则返回 True

  • ascii() 返回字符串格式

    • ascii(8) == int.__repr__()

  • bin(10) # '0b1010'

  • bool()

  • bytearray("微明", encoding="utf-8") # 返回字节数组 b'\xe5\xbe\xae\xe6\x98\x8e'

  • bytes("微明", encoding="utf-8") # 返回字节 b'\xe5\xbe\xae\xe6\x98\x8e'

  • callable(变量名) 变量是否可执行函数True

  • chr(99) # 'c'

    • import random

    • random.randint(1,99) # 验证码例子

  • ord('c') # 99

  • classmethod()

  • compile(filename) 编译

    • filename文件的内容字符串编译成python语言

  • complex()

  • delattr() 反射时使用

  • dict()

  • dir() 返回列表的key

  • divmod()

  • enumerate()

    • li = ['alex','eric','lily']

    • for i,item in enumerate(li, 1):print(i,item)

  • eval('6*8')

  • exec()

  • filter(func, list) 过滤元素

  • float()

  • format() == int.format()`

  • frozenset() 不能增加修改set

  • getattr()

  • globals() 当前所有的全局变量

  • hasattr()

  • hash()

  • help()

  • hex()

  • id()

  • input()

  • int()

  • isinstance()

  • issubclass()

  • iter()

  • len()

  • list()

  • locals() 所有的局部变量

  • map()

    • li = map(lambda x:x+100, [11,22,33])

    • print(list(li))

  • max(1,23,33)

  • memoryview()

  • min()

  • next()

  • object()

  • oct()

  • open()

  • pow()

  • print()

  • property()

  • range(0,10) 迭代器，不到10，循环时创建数字

  • repr()

  • reversed()

  • round()

  • set()

  • setattr()

  • slice()

  • sorted()

  • staticmethod()

  • str()

  • sum()

  • super()

  • tuple()

  • type()

  • vars() 返回key:value

  • zip()

  • __import__()

匿名函数-lamda

lambda 参数,参数2 : 返回值表达式 和五个特殊的内置函数可以结合使用

递归函数

在函数中调用自身函数

  • 最大递归深度默认是997/998 —— 是python从内存角度出发做得限制

  • 如果递归次数太多，就不适合使用递归来解决问题

  • 递归的缺点 ： 占内存

  • 递归的优点： 会让代码变简单

RecursionError: maximum recursion depth exceeded while calling a Python object 递归的错误，超过了递归的最大深度

Previous数据类型Next文件

Last updated

Was this helpful?