课程笔记--005（函数调用）

Python中，函数的应用非常广泛，前面章节中我们已经接触过多个函数，比如 input() 、print()、range()、len() 函数等等，这些都是 Python 的内置函数，可以直接使用。

一个程序可以按不同的功能实现拆分成不同的模块，而函数就是能实现某一部分功能的代码块。函数分为自定义函数和内置函数。

自定义函数需要先定义再调用，内置函数直接调用，有的内置函数是在特定的模块下，这时需要用import命令导入模块后再调用。

内建 Built-in 函数

Python内置了很多有用的函数，我们可以直接调用, 要调用一个函数，需要知道函数的名称和参数。
可以直接从Python的官方网站查看文档：http://docs.python.org/3/library/functions.html

Built-in Functions
The Python interpreter has a number of functions and types built into it that are always
available. They are listed here in alphabetical order.

要调用一个函数，需要知道函数的名称和参数。
调用函数的时候，如果传入的参数数量不对，会报TypeError 的错误，同时Python会明确地告诉你参数的个数。

如果传入的参数数量是对的，但参数类型不能被函数所接受，也会报TypeError 的错误，并且给出错误信息

要获取内置函数清单可以调用dir()，查询__builtins__模块

一、数学运算类

abs(x)	                    求绝对值,参数可以是整型，也可以是复数,若参数是复数，则返回复数的模
complex([real[, imag]])	    创建一个复数
divmod(a, b)	            分别取商和余数,注意：整型、浮点型都可以
float([x])	                将一个字符串或数转换为浮点数。如果无参数将返回0.0
int([x[, base]]) 	        将一个字符转换为int类型，base表示进制
long([x[, base]])        	将一个字符转换为long类型
pow(x, y[, z]) 	            返回x的y次幂
range([start], stop[, step])   产生一个序列，默认从0开始
round(x[, n]) 	               四舍五入
sum(iterable[, start]) 	       对集合求和
oct(x)	                       将一个数字转化为8进制
hex(x)	                       将整数x转换为16进制字符串
chr(i)	                       返回整数i对应的ASCII字符
bin(x)	                       将整数x转换为二进制字符串
bool([x])	                   将x转换为Boolean类型

二、集合类操作

basestring()	                str和unicode的超类，不能直接调用，可以用作isinstance判断
format(value [, format_spec])	格式化输出字符串，格式化的参数顺序从0开始，如“I am {0},I like {1}”
unichr(i)	                    返回给定int类型的unicode
enumerate(sequence [, start = 0])	返回一个可枚举的对象,该对象的next()方法将返回一个tuple
iter(o[, sentinel])	                生成一个对象的迭代器，第二个参数表示分隔符
max(iterable[, args...][key]) 	返回集合中的最大值
min(iterable[, args...][key])	返回集合中的最小值
dict([arg])	               创建数据字典
list([iterable]) 	       将一个集合类转换为另外一个集合类
set()	                   set对象实例化
frozenset([iterable])	   产生一个不可变的set
str([object]) 	           转换为string类型
sorted(iterable[, cmp[, key[, reverse]]]) 	队集合排序
tuple([iterable]) 	       生成一个tuple类型
xrange([start], stop[, step]) 	xrange()函数与range()类似，但xrnage()并不创建列表，而是返回一个xrange对象，它的行为与列表相似，但是只在需要时才计算列表值，当列表很大时，这个特性能为我们节省内存

三、逻辑判断

all(iterable)	    集合中的元素都为真的时候为真,特别的，若为空串返回为True
any(iterable)	    集合中的元素有一个为真的时候为真,特别的，若为空串返回为False
cmp(x, y)	        如果x < y ,返回负数；x == y, 返回0；x > y,返回正数

四、反射

callable(object)	    检查对象object是否可调用，1、类是可以被调用的，2、实例是不可以被调用的，除非类中声明了__call__方法
classmethod()	        1、注解，用来说明这个方式是个类方法，2、类方法即可被类调用，也可以被实例调用，3、类方法类似于Java中的static方法，4、类方法中不需要有self参数
compile(source, filename,mode[, flags[, dont_inherit]])   将source编译为代码或者AST对象。代码对象能够通过exec语句来执行或者eval()进行求值。1、参数source：字符串或者AST（Abstract Syntax Trees）对象。2、参数 filename：代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。3、参数model：指定编译代码的种类。可以指定为 ‘exec’,’eval’,’single’。4、参数flag和dont_inherit：这两个参数暂不介绍

dir([object])	        1、不带参数时，返回当前范围内的变量、方法和定义的类型列表；2、带参数时，返回参数的属性、方法列表。3、如果参数包含方法__dir__()，该方法将被调用。当参数为实例时。4、如果参数不包含__dir__()，该方法将最大限度地收集参数信息
delattr(object, name)    删除object对象名为name的属性
eval(expression [, globals [, locals]])	      计算表达式expression的值
execfile(filename [, globals [, locals]])	  用法类似exec()，不同的是execfile的参数filename为文件名，而exec的参数为字符串。

filter(function, iterable)	        构造一个序列，等价于[ item for item in iterable if function(item)]1、参数function：返回值为True或False的函数，可以为None，2、参数iterable：序列或可迭代对象
getattr(object, name [, defalut])	获取一个类的属性
globals()	            返回一个描述当前全局符号表的字典
hasattr(object, name)	判断对象object是否包含名为name的特性
hash(object)	        如果对象object为哈希表类型，返回对象object的哈希值
id(object)	            返回对象的唯一标识

---

isinstance(object, classinfo)	判断object是否是class的实例
issubclass(class, classinfo)	判断是否是子类
len(s) 	                返回集合长度
locals() 	            返回当前的变量列表
map(function, iterable, ...) 	遍历每个元素，执行function操作
memoryview(obj) 	            返回一个内存镜像类型的对象
next(iterator[, default]) 	    类似于iterator.next()

object() 	        基类
property([fget[, fset[, fdel[, doc]]]]) 	属性访问的包装类，设置后可以通过c.x=value等来访问setter和getter
reduce(function, iterable[, initializer]) 	合并操作，从第一个开始是前两个参数，然后是前两个的结果与第三个合并进行处理，以此类推
reload(module) 	                     重新加载模块
setattr(object, name, value)	     设置属性值
repr(object) 	        将一个对象变幻为可打印的格式
slice（）	　
staticmethod	        声明静态方法，是个注解
super(type[, object-or-type]) 	引用父类
type(object)	        返回该object的类型
vars([object]) 	        返回对象的变量，若无参数与dict()方法类似，
bytearray([source [, encoding [, errors]]])	返回一个byte数组，1、如果source为整数，则返回一个长度为source的初始化数组；2、如果source为字符串，则按照指定的encoding将字符串转换为字节序列；3、如果source为可迭代类型，则元素必须为[0 ,255]中的整数；4、如果source为与buffer接口一致的对象，则此对象也可以被用于初始化bytearray.
zip([iterable, ...]) 	从参数中的多个迭代器取元素组合成一个新的迭代器；返回：返回一个zip对象，其内部元素为元组；可以转化为列表或元组；传入参数：元组、列表、字典等迭代器。

五、IO操作

file(filename [, mode [, bufsize]])	file类型的构造函数，作用为打开一个文件，如果文件不存在且mode为写或追加时，文件将被创建。添加‘b’到mode参数中，将对文件以二进制形式操作。添加‘+’到mode参数中，将允许对文件同时进行读写操作。1、参数filename：文件名称。2、参数mode：'r'（读）、'w'（写）、'a'（追加）。3、参数bufsize：如果为0表示不进行缓冲，如果为1表示进行行缓冲，如果是一个大于1的数表示缓冲区的大小 。
input([prompt]) 	                获取用户输入，推荐使用raw_input，因为该函数将不会捕获用户的错误输入
open(name[, mode[, buffering]]) 	打开文件
print	                            打印函数
raw_input([prompt]) 	            设置输入，输入都是作为字符串处理

六、其他

help()--帮助信息

x=abs(-20)              #20
x=max(2, 3, 1, -5)      #3
x=int('123')            #123
x=int(12.34)            #12
x=float('12.34')        #12.34
x=bool(2)               #True
x=bool(0)               #False
x=bool('')              #False
x=bin(8)                #'0b1000'
type((2, 3, 1, -5))     #
x=str(100)              #'100'

a = "[[1,2], [3,4], [5,6], [7,8], [9,0]]"
print(type(a))          #

b = eval(a)
print(type(b))          #
eval('3*8-3')           #21

str2='12378461231238904'
str2.count('123',2)     #2
str2.find('123',2)      #7
str2.split('123')       #['', '7846', '', '8904']

a=10
isinstance(a,int)       #True
isinstance(a,(int,str,float)) #True

b = {'a':5,'b':6} #判断是否为字典
isinstance(b,(list))    #False

非内建模块函数

与内建函数不同的非内建模块的函数，需要先借助于import来导入模块才可以调用。
比如 math 模块中的sin()函数，直接调用会出现未定义函数的错误。

sin(1)
'''
#输出
Traceback (most recent call last):
  File "", line 1, in 
    sin(1)
NameError: name 'sin' is not defined
'''

要调用此类函数都需要先导入模块，还以上面的sin()为例。

导入模块方法

法一：将整个文件引入

import 文件名
文件名.函数名( ) / 文件名.类名

通过这个方法可以运行另外一个文件里的函数，例如：

import math
math.sin(1)   

法二：只引入某个文件中一个类/函数/变量

需要从某个文件中引入多个函数或变量时，用逗号隔开即可

from 文件名 import 函数名,类名，变量名

from math import sin
sin(1)         #结果：  0.8414709848078965

Python数学函数

import math

函数	返回值 ( 描述 )
abs(x)	返回数字的绝对值，如abs(-10) 返回 10
ceil(x)	返回数字的上入整数，如math.ceil(4.1) 返回 5
cmp(x, y)	如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1
exp(x)	返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
fabs(x)	返回数字的绝对值，如math.fabs(-10) 返回10.0
floor(x)	返回数字的下舍整数，如math.floor(4.9)返回 4
log(x)	如math.log(math.e)返回1.0,math.log(100,10)返回2.0
log10(x)	返回以10为基数的x的对数，如math.log10(100)返回 2.0
max(x1, x2,…)	返回给定参数的最大值，参数可以为序列。
min(x1, x2,…)	返回给定参数的最小值，参数可以为序列。
modf(x)	返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
pow(x, y)	x**y 运算后的值
round(x [,n])	返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数

函数	返回值 ( 描述 )
sqrt(x)	返回数字x的平方根
acos(x)	返回x的反余弦弧度值。
asin(x)	返回x的反正弦弧度值。
atan(x)	返回x的反正切弧度值
atan2(y, x)	返回给定的 X 及 Y 坐标值的反正切值
cos(x)	返回x的弧度的余弦值
hypot(x, y)	返回欧几里德范数 sqrt(xx + yy)
sin(x)	返回的x弧度的正弦值
tan(x)	返回x弧度的正切值
degrees(x)	将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0
radians(x)	将角度转换为弧度

内联函数

函数不必在单独的文件中创建。如果你只是针对一个任务编写一个简短的脚本，那么在同一个文件中编写函数可能更有意义。唯一的区别是你不必导入自己的模块，但函数的工作方式是一样的。

1.lambda函数

语法只包含一个语句，如下：

lambda arg1,arg2,.....argn:expression

# lambda匿名函数
f = lambda a,b,c:a+b+c
print(f(1,2,3))

L=[x * x for x in range(1, 11)]

List1=[1,2,-2,3,-4,6,-5]
NEGindex=[i for i in range(len(List1)) if List1[i]>0]

2.zip

Python内置的zip函数接受任意多个list作为参数，并把相同索引的元素组合成tuple，最后形成一个新的list，新的list长度以传入参数的最小值为准。
另外(*)操作符与zip函数配合可以实现与zip相反的功能，即将合并的序列拆成多个tuple

zip(list1,list2,...)

x = [ 1, 2, 3];y = [ 'a', 'b', 'aa', 'bb'];z = [ 'A', 'B', 'C'];
print(zip(x,y,z))
print(list(zip(x,y,z)))
print(list(zip(*zip(x,y,z))))

3.filter

filter(func, list)接受两个参数：一个函数func和一个列表list，返回一个列表。
函数func只能有一个参数。filter的功能：列表中所有元素作为参数传递给函数，返回可以另func返回真的元素的列表

list1=filter(lambda x:x*x-10>0,range(-3,10))
print(list1)
print(list(list1))

4.map

map(function, sequence) ：对sequence中的item依次执行function(item)

list1=map(lambda x:x*x-10,range(-3,10))
print(list(list1))

定义函数

函数是迈向模块化过程中重要的一步，因为它们是形式化的重复方法。如果在程序中，有一个任务需要反复执行，那么可以将代码放入一个函数中，根据需要随时调用该函数。这样，只需编写一次代码，就可以随意使用它。

在Python中，定义一个函数要使用def 语句，依次写出函数名、括号、括号中的参数和冒号: ，然后，在缩进块中编写函数体，函数的返回值用return 语句返回。

def 函数名(参数列表)：
    函数体

def my_dot(List1,List2):
    tempsum=0
    for i in range(len(List1)):
        tempsum=tempsum+float(List1[i])*float(List2[i])
    return tempsum
a=[1,2,3];b=[2,-1,3]
y=my_dot(a,b)
print(y)

#输入任意自然数，输出1到该数之间的完数
INNum=int(input('请输入一个自然数：'))
def PerNum(x):#x是形式参数
    PerN={}
    if x>0 and isinstance(x,int):
        for i in range(1,x):
            sum=0
            fac=[]
            for j in range(1,i):
                if i % j ==0:
                    sum=sum+j
                    fac.append(j)
            if i==sum:
                PerN[i]=fac
    else:
        print('请输入一个自然数')
    return PerN
PerN=PerNum(INNum)#INNum是实参
print(len(PerN))
print(PerN)

#冒泡排序
def bubbleSort(arr):
    n = len(arr)
    # 遍历所有数组元素
    for i in range(n):
        # Last i elements are already in place
        for j in range(0, n-i-1):
            if arr[j] > arr[j+1] :
                arr[j], arr[j+1] = arr[j+1], arr[j]
    return arr
 
arr = [64, 34, 25, 12, 22, 11, 90]
Newarr=bubbleSort(arr)
print(Newarr)

#计算距离矩阵
#计算距离矩阵
import math
def Caldis(P1,P2):
    temp=(P2[0]-P1[0])*(P2[0]-P1[0])+(P2[1]-P1[1])*(P2[1]-P1[1])
    dis=math.sqrt(temp)
    return dis

def CalDis(Points):
    m=len(Points)
    DisMat=[]
    for i in range(m):
        temp1=Points[i]
        Rowi=[]
        for j in range(m):
            temp2=Points[j]
            tempdis=Caldis(temp1,temp2)
            Rowi.append(tempdis)
        DisMat.append(Rowi)
        return DisMat
Points = [[64, -34], [-25, 12], [22, 11], [90,-12],[24, 34], [25, 32], [34, 43], [45,0]]
DisMat=CalDis(Points)
print(DisMat)
'''
# 输出 [[0.0, 100.18482919085105, 61.554853586049575, 34.058772731852805, 78.89233169326408, 76.66159403508382, 82.63776376451628, 38.948684188300895]]
'''

#最短路径问题
#Floyd算法
#coding:utf-8
import numpy as np

N = 4
M = 100
edge = np.mat([[0,2,6,4],[M,0,3,M],[7,M,0,1],[5,M,12,0]])
A = edge[:]
path = np.zeros((N,N))

def Floyd():
    for i in range(N):
        for j in range(N):
            if(edge[i,j] != M and edge[i,j] != 0):
                path[i][j] = i

    print('init:')
    print(A,'\n',path)
    for a in range(N):
        for b in range(N):
            for c in range(N):
                if(A[b,a]+A[a,c]<A[b,c]):
                    A[b,c] = A[b,a] + A[a,c]
                    path[b][c] = path[a][c]

    print('result:')
    print(A,'\n',path)

if __name__ == "__main__":
    Floyd()

输出结果：