函数是具有特定功能可重复利用的代码块，有名字、参数（可选）、返回值（可选），又叫做方法。本篇介绍函数的定义、函数的参数、函数的返回值、函数的调用及Python内置函数。
函数的定义
1、函数通过def关键字定义，def是define的缩写;
2、函数名称是一个有效的标识符;
3、函数名后面是一个括号，内部可传入0到多个参数，逗号隔开；
4、函数内容以冒号开始并缩进；
5、return 关键字结束函数并返回。没有return 默认返回None;
形如：
#a,b两个参数必须是相同类型且可加的
def getAdd(a,b):
"返回两个数的最大值"
return a+b
这里的getAdd为函数名，括号内a,b为两个参数。
函数的参数
函数括号内的参数可有可无，参数不用申明具体数据类型（Python中的变量都不用申明特定的类型，Python自动识别），多个参数用逗号隔开。函数名称括号内的参数为形参，传入的实际值为实参。
函数的返回值
函数的返回值为前面提到的七大基本类型：数字（Number 包括：int-整型，long-长整型，float-浮点型，complex-复数）、字符串（str）、列表（list）、集合（set）、元组（tuple）、字典（dict）、None。
函数的调用
函数的调用在可用的情况下直接使用其函数名，传入对应的参数，有返回值的用变量接受返回值即可。注意：这里的可用的情况是条件的，同一个脚本文件中的函数在本脚本中可直接使用，其他的脚本中申明的函数需要引入模块后才能直接使用。
#调用函数
c = getAdd(1,2)
print(c)#输出3
c = getAdd('darker','wang')
print(c)#darkerwang
Python内置函数
Python中封装了常用的基本内置函数，整理如下：
0、输入输出函数
x = inpupt("请录入:")#等待录入数据，赋值给x
print(x)#打印录入的数据
1、数据类型函数
原始七大数据类型对应的构造函数
x = int(1)# 构造一个整型对象
print(type(x)) #输出为 <class 'int'>
print("x="+str(x))#输出为 x=1
'''
long() python2函数，python3已弃用，python3只有int
如果int内参数溢出python3自动构造成一个长整型
'''
x = float()#构造一个浮点型对象
print(type(x)) #输出为 <class 'int'>
print("x="+str(x))#输出为 x=1
x = complex()#构造一个复数对象
print(type(x)) #输出为 <class 'float'>
print("x="+str(x))#输出为 x=0.0
x = bool()#构造一个布尔对象
print(type(x)) #输出为 <class 'complex'>
print("x="+str(x))#输出为 x=0j
x = list()#构造一个列表对象
print(type(x)) #输出为 <class 'bool'>
print("x="+str(x))#输出为 x=False
x = set()#构造一个集合对象
print(type(x)) #输出为<class 'set'>
print("x="+str(x))#输出为 x=set()
x = dict()#构造一个字典对象
print(type(x)) #输出为 <class 'dict'>
print("x="+str(x))#输出为 x={}
x = str()#构造一个字符串对象
print(type(x)) #输出为 <class 'str'>
print("x="+str(x))#输出为 x=
x = tuple()#构造一个元组对象
print(type(x)) #输出为 <class 'tuple'>
print("x="+str(x))#输出为 x=()
2、非数据类型函数
- abs()
绝对值，用于获取某个数的绝对值。
x = abs(-1)
print(x)#输出1
- all()
判断可迭代参数是否全为真（非0或False），是则返回True，否则返回False。
可理解为：所有元素都为真则真。
注意：可迭代参数为空时不含0或False，也返回True。
x = list()
print(x.__len__())#输出长度0
print(all(x))#无元素，返回True
x.append(0)#添加一个0元素，
print(all(x))#有一个0元素，返回False
x.append(False)#添加一个False元素
print(all(x))#有False元素，返回False
x[0]=1#第一个元素重新赋值为1，非0
print(x)#打印目前x [1,False]
print(all(x))#还有一个False元素，返回False
x[1]=True#将第二个False元素赋值为True
print(all(x))#没有0或者False元素，返回True
print(x)#打印最终x [1,True]
- any()
判断可迭代参数是否含有真值（非0），是则返回True，否则返回False。
可理解为：任何一个元素是真则真。
注意：可迭代参数为空时没有一个是真，返回False。
x = list()
print(any(x))#x元素为空，没有任何一个为真(非0或False)，返回False
x.append(0)#添加一个0（False）
print(any(x))#没有一个为真，返回False
x.append(True)#添加一个True
print(x)#打印此时x [0,True]
print(any(x))#x 有一个为真，返回真（True）
x[0] = 1#第一个元素为非0（真）
x[1] = False#第二个元素为否
print(x)#打印此时x[1,False]
print(any(x))#x有一个为真，返回真（True）
x[0] = 1#第一个元素为真（非0）
x[1] = 2#第二个元素为真（非0）
print(x)#打印此时的x[1,2]
print(any(x))#两个元素都为真（非0），返回真（True）
x[0] = 0#第一个元素为0
x[1] = -1#第二个元素为非0
print(x)#打印此时x[0,-1]
print(any(x))#有一个元素为真（非0），则返回True
- isinstance()
判断两个类型是否一致，是则返回True，否则返回False，与type()类似
isinstance() 与 type() 区别：
type() 不会认为子类是一种父类类型，不考虑继承关系。
isinstance() 会认为子类是一种父类类型，考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()。
- basestring()
str 和 unicode 的超类，不能直接使用，可用于类型判断类型
from pip._vendor.pyparsing import basestring
x = "2232"
print(isinstance(x,basestring))
print(isinstance(x,str))
- bin()
二进制函数，将对应的数值参数转为二进制
注意：参数必须是整型，否则会报TypeError
print(bin(0))#输出 0b0
print(bin(1))#输出 0b1
print(bin(-122))#输出 -0b1111010
bool()
将参数转为布尔值，参数非0即True
print(bool(0))#输出False
print(bool(-1))#输出True
print(bool(1))#输出True
print(bool(1.2))#输出True
print(bool('abc'))#输出True
- bytearray()
返回一个元素可变的新的字节数组类。
可理解为：将目标转为字节数组类
注意：如果没有输入任何参数，默认就是初始化数组为0个元素。
形如：class bytearray([source[, encoding[, errors]]])
如果 source 为整数，则返回一个长度为 source 的初始化数组；
如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；
如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数；
如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。
x = bytearray(4)
print(x.__len__())#单个数字时生成一个指定长度为4的元素都为0的新数组
print(x)#输出 bytearray(b'\x00\x00\x00\x00')
x = bytearray([1,2,4])#数组时长度为新数组长度3
print(x.__len__())#长度为原数组长度
print(x)#输出 bytearray(b'\x01\x02\x04')
x = bytearray('abc','utf-8') #输出 bytearray(b'abc')
print(x.__len__())#数组新数组长度3
print(x)#输出 bytearray(b'abc')
- cmp()
phthon2中比较两个对象的大小， x<y返回-1，x=y 返回0，x>y 返回1
python3.4.3 以上的版本中已经没有cmp函数，被operator模块代替，使用时需要导入模块。operator模块中还有很多与比较相关的函数
import operator
print(operator.eq(1,3))#equal 判断两个参数是否相等
print(operator.ne(1, 3))#not equal 判断两个参数是否不相等
print(operator.gt(1, 3))#great than 判断大于
print(operator.ge(1, 3))#great equal 大于等于
print(operator.le(1, 3))#little equal 小于等于
print(operator.lt(1,3))#little than 小于
- compile()
将一个字符串的可执行代码编译为字节代码
compile(source, filename, mode[, flags[, dont_inherit]])
参数
source 字符串或者AST（Abstract Syntax Trees）对象。。
filename 代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。
mode 指定编译代码的种类。可以指定为 exec, eval, single。
flags 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。
flags和dont_inherit是用来控制编译源码时的标志
str = "print('hello world')"
c = compile(str,'','exec') # 编译为字节代码对象
print(c)
exec(c)#执行字节代码
'''
打印内容
<code object <module> at 0x0000000002162810, file "", line 1>
hello world
'''
exec("print('hello world')")#直接exec(字符串的代码)也能正常执行
- callable()
检查一个对象是否是可调用，是则返回True否则返回False
可理解为：函数、方法、lambda 函式、 类以及实现了 call 方法的类实例, 它都返回 True
注意：具体字符串与数值不是对象
#自定义一个函数
def testFun():
print('test')
print(callable(0))#不是对象，函数，返回False
print(callable('abc'))#不是对象，函数，返回False
print(callable(str))#可用函数，返回True
print(callable(exec))#可用函数，返回True
print(callable(testFun))#可用函数，返回True
s = str("abc")#申明一个对象，
print(callable(s))#可用对象，返回True
#自定义一个没有实现__call__()方法的类
class A(object):
def aFun(self):
print("A.aFun")
print(callable(A))#是一个类，返回True
a = A()#申明一个类实例
print(callable(a))#类对象没有实现__call__返回False
#自定义一个实现纳__call__()方法的类
class A(object):
def __call__(self):
print("A.__call_")
print(callable(A))#是一个类，返回True
a = A()#申明一个类实例
print(callable(a))#类对象实现__call__返回True
- chr() / ord()
chr 返回数字对应的字符，参数0-256内的某个16进制，10进制的数值
ord 返回对应的 ASCII 数值
print(chr(48))#输出48对应的字符 0
print(chr(49))#输出49对应的字符1
print(chr(97))#输出97对应的字符a
print(chr(98))#输出98对应的字符b
print(ord("a"))#输出97
print(ord("1"))#输出49
- classmethod / staticmethod
classmethod 声明为类方法，修饰符对应的函数不需要实例化
可理解为：静态方法，类名直接调用 与java 的 public static 声明类似
注意：使用形式为@classmethod
staticmethod 声明为静态方法，该方法不强制要求传递参数
注意：使用形式为@staticmethod
#自定义一个类
class A(object):
#自定义方法
def add(self,a,b):
return a+b
#自定义方法，声明为类方法
@classmethod
def getClassName(self):
return 'A'
a = A()#实例化类
print(a.add(1, 2))#实例化调用，输出3
print(a.getClassName())#实例化调用，输出A
print(A.getClassName())#类直接调用，输出A
print(A.add(1, 2))#类直接调用，该方法未声明为类方法执行出错
class A(object):
@staticmethod
def method1():
print('method1')
@classmethod
def method2(self):
print("method2")
A.method1()
A.method2()
- delattr()
用于删除类中的属性
注意：必须是类且属性存在
#创建一个测试类
class ClassA(object):
a = 'A'#属性a
b = 'B'#属性b
#实例化对象
ca = ClassA()
print(ca.a)#打印ca对象的属性a，值为A
delattr(ClassA,'a')#删除类的属性a
print(ca.a)#属性已被删除，报错AttributeError: 'ClassA' object has no attribute 'a'
- dir()
不带参数返回当前范围内的变量，变量包括，属性，方法等构造元素
指定参数返回指定参数对应范围内的变量
可理解为：显示一个文件或者类的所有构造元素
class ClassA(object):
a = 'A'
b = 'B'
c = "123"
ca = ClassA()
print(dir())#当前变量
print(dir(ca))#制定ca对象的变量
- divmod()
把除数和余数运算结果结合起来，返回一个包含商和余数的元组
注意：返回的元组第一个是商，第二个是余数
x = divmod(7, 2)
print(x)# 输出(3,1)
-enumerate()
将一个可遍历的数据对象（列表，元组，字符串等）组合成一个索引-值序列
注意：一般用于for循环 【常用】
语法：enumerate(sequence, [start=0])
参数：sequence 可遍历对象，可选参数start 下标起始位置，默认0
lists = ['Spring', 'Summer', 'Fall', 'Winter']
for i,v in enumerate(lists):
print('index='+str(i)+" value="+v)#这里k是下标
idict = {'a':"darker","b":"wang","c":"godbirds"}
#1、直接编列字典
for i,v in enumerate(idict):
print('index='+str(i)+" value="+str(v))#这里k是下标 ，v是key的值
#2、遍历其建
for i,v in enumerate(idict.keys()):
print('index='+str(i)+" value="+str(v))#与1、同
#2、遍历其元素
for i,v in enumerate(idict.items()):
print('index='+str(i)+" value="+str(v))#这里k是下标,v是内部元素（元组展示）
#3、一般遍历字典我们用如下方法
for i,v in idict.items():
print('index='+str(i)+" value="+str(v))#这里k是元素的键，v是元素的值
- eval()
执行一个字符串表达式，并返回其值
注意：与exec的区别，exec是执行一个python语句，eval是表达式【常用】
print(eval('1+2')) #输出3
exec('print(eval("1+2"))')#执行一个语句输出3
- execfile()
执行一个python脚本文件【常用】
execfile('hello.py')#hello.py是编写好的一个文件
- filter()
用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换过滤后的对象。
注意：该方法接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。过滤函数根据需求灵活编写运用。
语法：filter(function, iterable)
#自定义一个函数：判断是否是素数
def is_prime(n):
if n == 1:
return False
for i in range(2,n//2+1):
if n % i == 0:
return False
return True
tmplist = filter(is_prime, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10,11,12,13,14,15,16,17])
newlist = list(tmplist)
print(newlist)
- format()
格式化字符串的函数，str.format(value)。
语法：通过"{}"或者":"来格式化目标
注意：参数个数大于等于待格式化目标数
#1、通过参数索引地址格式化赋值
x = "{} {}".format("hello", "world") # 不设置指定位置，按默认顺序
print(x)#输出 hello,world
x = "{0},{0}".format("hello","world")#制定索引位置
print(x)#输出hello,hello
x = "{0},{1}".format("hello","world")#制定索引位置
print(x)#输出hello,world
#2、通过默认从参数格式化赋值
x = "姓名:{name},年龄:{age},性别:{sex}".format(name="Darker", age="18",sex="男");
print(x)#输出 姓名:Darker,年龄:18,性别:男
#3、按字典的键进行格式化赋值
idict = dict({"name":"Darker","age":"18","sex":"男"})
x = "姓名:{name},年龄:{age},性别:{sex}".format(**idict);
print(x)#输出 姓名:Darker,年龄:18,性别:男
#4、数字格式化 『:.2f』 冒号后面制定精度格式
x = "{:.2f}".format(0.33333333)#待小鼠点
print(x)#输出0.33
x = "{:.0f}".format(0.33333333)#不带小数点
print(x)#输出0，不带小数点会四舍五入
- frozenset()
返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。
可理解为：返回一个冻结不让修改的集合，原集合不变
list1 = [1,2,3]
list2 = frozenset(list1)
list1.append(4)#原始集合未冻结，可操作
print(list1)#输出：[1,2,3,4]
#报错：AttributeError: 'frozenset' object has no attribute 'append'
list2.append(5)#list2为冻结集合，不能修改
- getattr()/setattr()
getattr用于获取一个对象属性值。等价于getXXX方法，getattr(object,name)。
setattr用于设置一个对象属性值。等价于setXXX方法，setattr(object,name,value)。
class Person(object):
name = "Darker"
age = 18
sex = "男"
o = Person()
x = getattr(o,"name")
print(x)#输出Darker
print(getattr(o, "age"))#输出18
setattr(o,"age",28)#重新设置属性值
print(getattr(o,"age"))#输出28
- globals() / locals()
返回当前位置的全部全局变量，字典方式展示（接收）。
注意：与dir()的区别，dir是返回对象的属性，列表方式展示（接收）
注意：与locals()的区别，locals返回的是局部变量。
class Person(object):
name = "Darker"
print(globals())
print(dir())
print(locals())
- hasattr()
于判断对象是否包含对应的属性，即属性是否存在
注意：在获取属性或者设置属性之前判断一下属性是否存在可用此方法
class Person(object):
name = "Darker"
obj = Person()
print(hasattr(obj, "name"))#输出True
print(hasattr(obj, "sex"))#输出False
- hash()
获对象（字符串或者数值等）的哈希值。
class Person(object):
name = "Darker"
obj = Person()
print(hash(obj))
print(hash(1))
print(hash("abc"))
- help()
用于查看函数或模块用途的详细说明。
help(hash)#输出如下图
#自定义一个类
class Person(object):
'''
自定义的一个函数
'''
name = "Darker"
help(Person)#输出如下图
图片.png
- hex() / oct()
hex将数值参数转换为16进制
oct将数值参数转换为8尽职
注意：参数只能是数值否则会报：TypeError: 'str' object cannot be interpreted as an integer
print(hex(1))#输出：0x1
print(oct(1))#输出：0o1
print(hex(10))#输出 ：0xa
print(oct(10))#输出：0o12
- id()
用于获取对象的内存地址。从下可以看出，数值时数值的地址是一样的，修改后地址发生改变，方法内部修改形参，实参地址不变，值不变（除非生命全局变量）
a = "1"
b = 1
d = [1,2,3]
print(id(a))#打印a的地址：30510528
print(id(b))#打印b的地址：1797680144
print(id(d))#打印d的地址：39341128
print(id(d[0]))#打印d[0]的地址： 1797680144
def modify(x):
x = "10"
return x
modify(a)#修改a的值
print(id(a))#打印a的地址：30510528
modify(d[0])#修改d[0]的值
print(id(d))#打印d的地址：39341128
print(id(d[0]))#打印d[0]的值： 1797680144
a = "abc"
print(id(a))#30768744
- isinstance() / type()
判断一个对象是否是一个已知的类型，类似 type()
isinstance 会认为子类是一种父类类型，考虑继承关系。
type 不会认为子类是一种父类类型，不考虑继承关系
class A:
pass
#B继承A
class B(A):
pass
isinstance(A(), A) # returns True
type(A()) == A # returns True
isinstance(B(), A) # returns True
type(B()) == A # returns False
- issubclass()
判断是否是继承关系
class A(object):
pass
class B(A):
pass
class C(object):
pass
print(issubclass(B,A))#B是A的继承，输出True
print(issubclass(A,B))#A是B的集成，输出False
print(issubclass(C,A))#C是A的集成，输出False
print(issubclass(C,object))#C是object的继承，输出True
- iter()
用来生成对象的一个迭代器，一般用在for循环中
语法：iter(object[, sentinel])
参数：object-支持迭代的集合，sentinel- 如果传递了第二个参数，则参数 object 必须是一个可调用的对象（如，函数），此时，iter 创建了一个迭代器对象，每次调用这个迭代器对象的__next__()方法时，都会调用 object。
lst = [1, 2, 3]
for i in iter(lst):
print(i)
- len()
返回对象（字符、列表、元组等）长度或项目个数
lst = [1, 2, 3]
x = "abcd"
print(len(lst))#输出3
print(len(x))#输出4
- map()
根据提供的函数对指定序列做映射。与iter用法相同
语法：map(function, iterable, ...)
参数：function 映射到具体函数，返回对应的值,iterable迭代对象
def mapping(x):
if x == 1:return "男"
if x == 0:return "女"
else: return "未知"
lst = [1,2,3,1,3,2,2,1]
x = map(mapping,lst)#次数为一个类，因为mapping中换了返回值的类型
x = list(x)#转化为List
print(x)#输出：['男', '未知', '未知', '男', '未知', '未知', '未知', '男']
- max() / min() / sum() / pow()
max 返回给定参数的最大值，参数可以为序列
min 返回给定参数的最小值，参数可以为序列。
sum 对系列进行求和计算
pow 返回 x的y次方
print(max([1,2,3]))#输出3
print(min([1,2,3]))#输出1
print(sum([1,2,3]))#输出6
print(pow(2,3))#输出8
- memoryview()
返回给定参数的内存查看对象(Momory view)
v = memoryview(bytearray("abcefg", 'utf-8'))
print(v[0])#输出97
print(v[1])#输出98
- next()
返回迭代器的下一个项目
语法：next(iterator[, default])
参数：iterator-可迭代对象，default-可选，用于设置在没有下一个元素时返回该默认值，如果不设置，又没有下一个元素则会触发 StopIteration 异常。
注意：以StopIteration异常时结束迭代
# 首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
while True:
try:
# 获得下一个值:
x = next(it)
print(x)
except StopIteration:
# 遇到StopIteration就退出循环
break
- open()
用于打开一个文件，并返回文件对象。在对文件进行处理过程都需要使用到这个函数，如果该文件无法被打开，会抛出 OSError。
注意：使用 open() 函数一定要保证关闭文件对象，即调用 close() 函数。
语法：open(file, mode='r')
参数：
file: 必需，文件路径（相对或者绝对路径）。
mode: 可选，文件打开模式
buffering: 设置缓冲
encoding: 一般使用utf8
errors: 报错级别
newline: 区分换行符
closefd: 传入的file参数类型
opener:
| mode模式 | 相关描述 |
|---|---|
| t | 文本模式 (默认)。 |
| x | 写模式，新建一个文件，如果该文件已存在则会报错。 |
| b | 二进制模式。 |
| + | 打开一个文件进行更新(可读可写)。 |
| U | 通用换行模式（不推荐）。 |
| r | 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。 |
| rb | 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。 |
| r+ | 打开一个文件用于读写。文件指针将会放在文件的开头。 |
| rb+ | 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。 |
| w | 打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。 |
| wb | 以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。 |
| w+ | 打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。 |
| wb+ | 以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。 |
| a | 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 |
| ab | 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 |
| a+ | 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。 |
| ab+ | 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。 |
- property()
用以在新式类中返回属性值。
class Parrot(object):
def __init__(self):
self._voltage = 100000
@property
def voltage(self):
"""Get the current voltage."""
return self._voltage
- range()
返回的是一个可迭代对象（类型是对象），而不是列表类型， 所以打印的时候不会打印列表，可用list转型。
x = range(5)
print(x)#输出 range(0, 5)
print(list(x))#输出 [0, 1, 2, 3, 4]
网友评论