函数
程序而言，函数就是对程序逻辑进行结构化，或者过程化的一种编程方法
Built-in function 内置函数—>BIF
函数的定义
- 函数代码块以 def 关键词开头，后接函数标识符名称和小括号 ()
- 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数
- 函数的第一行语句可以选择性地使用文档字符串(用于存放函数说明)
- 函数内容以冒号起始，并且缩进
- return [表达式] 结束函数，选择性的返回一个值。不带表达式的return相当于返回 None。
其中参数列表和返回值不是必须的,return后也可以不跟返回值,甚至连 return也没有。
对于return后没有返回值的和没有return语句的函数都会返回None值
有些函数可能既不需要传递参数,也没有返回值。
没有参数时,包含参数的圆括号也必须写上,圆括号后也必须有“:”。
声明函数的一般形式：
def function_name(arg1,arg2,...,argn):
'''statements'''
func_statements
return value
函数调用
定义一个函数只给了函数一个名称，指定了函数里包含的参数，和代码块结构。
这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从Python提示符执行。
def printme(str):
print(str)
return
# 调用函数
printme("ABC")
printme("DEF")
函数参数
- 不传参函数
- 参数函数
- 顺序
函数参数种类
def test(x,y):
print(x)
print(y)
print('1'.center(10,'*'))
test(1,2)
print('2'.center(10,'*'))
test(x=1,y=2)
print('3'.center(10,'*'))
test(y=2,x=1)
print('4'.center(10,'*'))
test(1,y=2)
print('5'.center(10,'*'))
形参和实参
-
形参
- 只有在调用时才分配内存单元，调用结束后，即释放所分配的内存单元，因此，形参只在内部有效，函数调用结束返回主调用函数后则不能再使用该形参变量
-
实参
- 实参是一个确定的值，能够传递给形参
只传递实参，默认参数
如果传递覆盖，不传递默认值
关键字参数
关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。
使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值
def usr_manage(name, age, job, hobby='Trip'):
print('用户管理系统'.center(16, '-'))
print('\tName:\t', name)
print('\tAge:\t', age)
print('\tJob:\t', job)
print('\tHobby\t', hobby)
usr_manage('tom', 23, 'sutdent')
usr_manage('lcuy', 22, 'IT', 'read')
默认值参数
调用函数时，默认参数的值如果没有传入，则被认为是默认值。
def usr_manage(name, age, job='IT', hobby='Trip'):
print('用户管理系统'.center(16, '-'))
print('\tName:\t', name)
print('\tAge:\t', age)
print('\tJob:\t', job)
print('\tHobby\t', hobby)
usr_manage('tom', 23, 'sutdent')
usr_manage('lcuy', 22, 'IT', 'eat')
usr_manage('jack', 22,hobby='coding',job='student')
默认值参数，关键字参数，必须放置于位置参数之后
不定参数
一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述2种参数不同，声明时不会命名。
在python中不定参数主要是指*args和**kwargs两个变量
它们两个主要是用于函数定义，我们可以将不定数量的参数传递给一个参数
- *args用来接收任意非键值对的参数并返回元组
- **kwargs将参数以字典的形式导入
def uncertain_para(para, para2,*args):
print('普通位置参数：', para,para2)
print('不定参数：', args)
print(type(args))
uncertain_para(1, 2, 3, 4, 'a', 'b')
uncertain_para([1, 2, 3], 'ab', 'cd', 'ef')
def un_para_key(**kwargs):
print(kwargs)
print(type(kwargs))
un_para_key(a=1,b=2,c=3,d=5)
函数引用
def bar():
print('bar()')
def foo():
print('foo()')
bar()
函数属性
函数属性是python中另外一个使用句点属性标示并拥有名字空间的领域
内嵌函数
作用域
bar()整个函数都处于外部foo()函数的作用域里（foo()是我们可以从外部访问的一个对象区域），除了在foo()内部，其他地方无法对bar()进行调用
def foo():
def bar():
print('bar() called.')
print('foo() called.')
bar()
foo()
bar()
foo() called.
bar() called.
NameError: name 'bar' is not defined
变量作用域
作用域的产生
- 就作用域而言，python和c有很大的差别，只有当变量在module,class,函数中定义的时候，才会有作用域的概念
- 在作用域中定义变量，一般只在作用域内有效，需要注意的是，在if-elif-else,for-else,while-else,try-except(else-finally)等关键字的语句块中不会产生作用域
作用域的类型
python 中，使用一个变量时并不要求需要预先声明它，但在真正使用的时候，他必须绑定到某个内存对象（被定义，赋值）。这种变量名的绑定将在当前作用域引入新的变量，同时，屏蔽外层作用域中的同名变量
-
局部作用域（locale—L)
- 局部变量：包含在def关键字定义的语句块中，即在函数中定义的变量。每当函数被调用时都会创建一个新的局部作用域。Python中也有递归，即自己调用自己，每次调用都会创建一个新的局部命名空间。在函数内部的变量声明，除非特别的声明为全局变量，否则均默认为局部变量。有些情况需要在函数内部定义全局变量，这时可以使用global关键字来声明变量的作用域为全局。局部变量域就像一个 栈，仅仅是暂时的存在，依赖创建该局部作用域的函数是否处于活动的状态。所以，一般建议尽量少定义全局变量，因为全局变量在模块文件运行的过程中会一直存在，占用内存空间。注意：如果需要在函数内部对全局变量赋值，需要在函数内部通过global语句声明该变量为全局变量。
-
嵌套作用域（enclosing—E)
-
E也包含在def关键字中，E和L是相对的，E相对于亘上层的函数而言也是L,与L的区别在于，对于一个函数而言，L是定义在定义在此函数内部的局部作用域
-
主要为了实现python的闭包，而增加的实现
-
全局作用域（Global—G)
- 即在模块层次中定义的变量，模块顶层申明的变量具有全局作用域，从外部来看，模块的全局变量就是一个模块对象的属性。
-
内置作用域（bulit-in—B)
- 系统固定模块中定义的变量
搜索变量名的优先级：局部作用域>嵌套作用域>全局作用域>内置作用域
全局变量和局部变量
定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。
局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。
a=6688
def foo():
a=666
print('foo(),修改前a:\t',a)
b= 888
print('foo(),修改后a:\t',b)
def bar():
# a=6888
print('bar(),a:\t',a)
foo()
bar()
#foo(),修改前a: 666
#foo(),修改后a: 888
#bar(),a: 6688
递归函数
在一个函数体的内部，调用函数本身，就被称为递归函数
def f(n):
if n ==1:
return 1
if n==2:
return 1
else:
return f(n-1)+f(n-2)
print(f(10))
# 55
匿名函数
格式
- lambda para1,para2,…,paraN:expression using paras
f = lambda x, y, z: x + y + z
print(type(f))
print(f(1, 2, 3))
<class 'function'>
6
高阶函数
把一个函数名，以实参的形式，传递给这个函数的形参，这个函数就是高阶函数
def pow(x):
return x ** 2
def add(a, b, c):
return c(a) + c(b)
a_value = add(-9, 1, pow)
print(a_value)
过滤函数
f1 = filter(lambda sr:not sr.endswith('ty'),li)
print(list(f1))
功能：
-
过滤掉序列中不符合函数条件的元素，当序列中需要保留的元素可以用某些函数描述时，就应该想到filter函数
-
filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 **list()**来转换。
-
接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。
调用格式：
filter(function,sequence)
- function :可以是自定义的函数，也可以匿名函数
- sequence: 列表，元组，字符串
li = ['economy', 'industry', 'city', 'chemistry']
def start_sr(sr):
return sr.startswith('c')
def end_sr(sr):
return sr.endswith('ty')
def filter_test(func, para):
ret = []
for i in li:
if not func(i):
ret.append(i)
return ret
print(filter_test(start_sr, li))
print(filter_test(end_sr, li))
['economy', 'industry']
['economy', 'industry', 'chemistry']
map映射
功能：
- 求一个序列或者多个序列进行函数映射后的值（用list()强转）
格式：
map(function,iterable1,iterable2)- function的参数可以不止一个
- Iterable1,iterable2就是传入function的参数
x = [1, 2, 3, 4, 5]
ret = []
for i in x:
ret.append(i + 1)
print(ret)
def pow(x):
return x**2
def map_test(func, para):
ret = []
for i in para:
ret.append(func(i))
return ret
print(map_test(pow, x))
[2, 3, 4, 5, 6]
[1, 4, 9, 16, 25]
apply
功能
- pandas中，应用对象是pandas中的DataFrame或者Series
- 直接对DataFrame或者Series应用函数
- 对pandas中groupie 之后的聚合对象应用apply
import numpy as np
import pandas as pd
a = np.random.randint(low=0, high=4, size=(2, 4))
print(a)
reduce函数
功能：
-
对一个序列进行压缩运算，得到一个value
-
python2中，reduce()是内置函数，而python3中，他被移植到functools模块中
-
from functools import reduce
格式：
- reduce(function,iterable,[initial])
- function必须要传入两个参数
- Iterable—>列表/元组
from functools import reduce
b = [2, 3, 4, 5, 6]
z = reduce(lambda a, b: a + b, b)
print(z)
# 20
zip函数
功能：
- 将可迭代对象作为参数，将对象中对应的元素打包成一个个元组，返回由这些元组构成的对象
- 长度不一样的时候，以长度短的为准
格式：
- zip(iterable1,iterable2,….)
- itterable—>两个或者多个可迭代序列（字符串，列表，元组，字典）
a = {1: 11, 2: 22}
b = {3: 33, 4: 44}
c = {5: 55, 6: 66}
tp = tuple(c)
print(tp)
print(list(zip(a, b, c)))
扫一扫
357
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
