这一节来学习Python的函数使用。首先看看函数的基本组成，然后学习不同种类的参数传递，以及Python的内置函数。
定义函数的时候，需要包括以下几个部分：
-
def：表示函数的关键字
-
函数名：函数的名称，日后根据函数名调用函数
-
函数体：函数中进行一系列的逻辑计算，如：发送邮件、计算出 [11,22,38,888,2]中的最大数等...
-
参数：为函数体提供数据
-
返回值：当函数执行完毕后，可以给调用者返回数据。可以返回任何数据，一旦返回数据，则函数自动结束，后面的代码不会再执行，如果不主动定义返回值，则默认返回值为None
例子
|
1
2
3
4
5
6
7
8
|
def sendmail():
try:
pass
except:
return "Failed"
else:
return "Succesful"
ret=sendmail()
|
执行函数的时候注意函数声明必须在前面，调用在后面，Python是按顺序操作的，而java，c#是直接把整个文件放内存，因此调用函数的位置无关紧要
小技巧：如果需要测试，可以在Pycharm里面执行断点和debug进行一步步跟踪
接下来看看具体参数是怎么传递的，Python里面有下面几种情况
-
普通参数
-
默认参数，可以在定义的时候给一个预分配的值，但是这个默认参数必须放在末尾
-
动态参数
-
动态参数 *args 和 **args
* 默认将传入的参数，全部放在元组中，元组的元素按顺序传入的值，比如 f1(*[1,2,3,4])
** 默认将传入的参数，全部放在字典中 f1(**{'k1':'v1','k2':'v2'})
例子（默认参数，指定参数）
定义函数send，里面有3个参数，最后一个参数预分配了一个值oo，那么传入参数的时候，最后一个有值的参数可以不用传递；传递参数的时候，如果不指定参数名，那么就默认安装位置传递；如果指定了名字，那么位置可以颠倒。
|
1
2
3
4
5
6
7
8
|
>>> def send(xx,bb,dd="oo"):
print(xx,bb,dd)
return True
send(23,233,22)
send(bb=22,xx=33)
--------------
23 233 22
33 22 oo
|
例子（动态参数）
定义了一个*args参数，注意调用的时候，f1(list)和f1(*list)的区别；前者把整个列表当做元组的一个元素，后者把列表转换成元组
|
1
2
3
4
5
6
7
8
9
10
11
12
|
>>> def f1(*args):
print(args,type(args))
f1(11,22,"ddd")
li=[1,2,3,4]
#把整个列表当做元组的一个元素f1(li,'2')
#把列表的每一个元素都转换成元组的元素f1(*li)
---------------
(11, 22, 'ddd') <class 'tuple'>
([1, 2, 3, 4], '2') <class 'tuple'>
(1, 2, 3, 4) <class 'tuple'>
|
类似的，定义了一个**args的参数，调用的时候，需要传入字典；同理对应比较f2(dic)和f2(**dic)
|
1
2
3
4
5
6
7
8
9
10
|
>>> def f2(**args):
print(args,type(args))
f2(n1="alex",n2=18)
dic={'k1':'v1','k2':'v2'}
f2(kk=dic)
f2(**dic)#直接赋值
---------------------
{'n1': 'alex', 'n2': 18} <class 'dict'>
{'kk': {'k1': 'v1', 'k2': 'v2'}} <class 'dict'>
{'k1': 'v1', 'k2': 'v2'} <class 'dict'>
|
例子（万能参数）
|
1
2
3
4
5
6
7
8
9
|
>>> #形式参数的名字可以变换，但是默认习惯使用以下
def f1(*args,**kwargs):
print(args)
print(kwargs)
#自动把列表顺序的（一个星）放第一个参数，字典格式的放第二个（两星的）---------------------
f1(11,22,33,44,k1='v1',k2='v2')
(11, 22, 33, 44)
{'k1': 'v1', 'k2': 'v2'}
|
看看万能参数的实际应用，比如字符串有个format的函数，它的解释是这样的
|
1
2
3
4
5
6
7
8
|
def format(self, *args, **kwargs): # known special case of str.format
"""
S.format(*args, **kwargs) -> str
Return a formatted version of S, using substitutions from args and kwargs.
The substitutions are identified by braces ('{' and '}').
"""
pass
|
使用的时候，传递列表的效果
|
1
2
3
4
5
6
7
|
>>> s1="i am {0},age {1}".format("alex",18) #自动封装到*args 里面
print(s1)
s2="i am {0},age {1}".format(*["alex",18]) #自动封装到*args 里面
print(s2)
-------------
i am alex,age 18
i am alex,age 18
|
传递字典的效果
|
1
2
3
4
5
6
|
>>> s="iam {name},age{age}".format(name='alex',age=19) #传到了**kwargs
dic={'name':'alex','age':189}
s2="iam {name},age{age}".format(**dic) #传到了**kwargs
print(s2)
--------------
iam alex,age189 |
几个注意事项注意事项：
1.当定义函数的时候，如果定义了2个重名的函数，因为是按照顺序放入内存的，那么后面的函数会覆盖前面的定义
2.很重要的一点，函数参数传递的是引用，而不是拷贝，因此内容会一起改变
3.在函数后面直接输入""",然后回车会自动生成注释的格式
4.如果使用全局变量，约定俗成的习惯是全部大写，如果要在函数中修改，需要使用global
例子（传递的参数在函数中发生了改变，在函数外也同时发生了改变）
|
1
2
3
4
5
6
7
8
9
10
11
|
>>> def f1(a):
'''
:param a:
:return:
'''
a.append(999)
li=[1,2,3]
f1(li)print(li)
----------------
[1, 2, 3, 999]
|
例子 全局变量如果需要在函数里面修改，需要使用global关键字
|
1
2
3
4
5
6
7
8
|
>>> a=10
def f1(num):
global a
a+=num
print(a)
f1(20)
--------------
30 |
三元运算和lambda 表达式
三元运算：有些简单的if..else语句可以直接用一行表示
例子
|
1
|
name ="alex" if 1==1 else "sb"
|
lambda表达式，一些简单的函数也可以用一行表示
例子
下面的函数等同于一行就实现的lambda表达式
|
1
2
3
4
5
6
|
>>> def f1(a1):
return a1+100
ret=f1(10)
print(ret)
----------
110 |
lambda表达式，对比上面的正式写法，冒号前面的是形式参数；冒号后面是函数的主体，函数的结果自动返回
|
1
2
3
4
5
|
>>> f2=lambda a1:a1+100 #冒号前面是参数，注意只能用一行
r2=f2(9)
print(r2)
--------------
109 |
最后看看种类繁多的内置函数
例子：
abs()求绝对值
|
1
2
3
|
>>> print(abs(-1))
----------------
1 |
bool()返回布尔值，注意0,None,"",[],{},() 返回的布尔值都是False
|
1
2
3
4
5
|
>>> print(bool(None))
print(bool(()))
--------
FalseFalse |
all()里面传入可以迭代的对象，比如列表，字典，如果每一个对象的布尔值都是真，那么结果为真，其中一个为假，结果为假
any()和all()相对应，如果有一个对象为真，那么他的结果就是真
|
1
2
3
4
|
>>> n=all([1,2,3,4,None])
print(n)
--------
False |
|
1
2
3
4
|
>>> m=any([1,0,""])
print(m)
----------
True |
ascii(),自动执行对象的_repr_方法,比如定义了一个class，该class里面有一个_repr_的方法，那么他会自动执行。
bin() 10进制转2进制
oct() 10进制转8进制
hex() 10进制转16进制
|
1
2
3
4
5
6
7
|
>>> print(bin(5))
print(oct(9))
print(hex(15))
----------
0b1010o110xf |
byte() 把字符串转换为字节，请注意编码不同，汉字的转换不同
utf-8 1个汉字是3个字节，gbk一个汉字 2个字节
utf-8,一个字节8位，一个汉字3个字节，所以一个汉字24位
如下所示，同样的“李杰”转换成utf-8是6个字节，而gbk只有4个字节
|
1
2
3
4
5
6
7
8
9
|
>>> s="李杰"
#把字符串转换成字节类型n=bytes(s,encoding="utf-8")
print(n)
n=bytes(s,encoding="gbk")
print(n)
-------------
b'\xe6\x9d\x8e\xe6\x9d\xb0'
b'\xc0\xee\xbd\xdc'
|
str()和bytes功能相反，把字节转换为字符串，同样需要指定编码
|
1
2
3
4
5
|
>>> #字节转换成字符串
m=str(bytes(s,encoding="utf-8"),encoding="utf-8")
print(m)
----------
李杰 |
callable()判断是否可以是调用的函数
|
1
2
3
4
5
6
7
8
|
>>> def f1():
pass
f1()f2=123
print(callable(f1))
print(callable(f2))
TrueFalse |
chr()和ord()都是用来进行ASCII码的转换，前者是把代码转换成对应的字符；后者是把字符转换成代码
|
1
2
3
4
5
6
7
|
>>> #ASCII 转换
r=chr(65)
print(r)
n=ord("B")
print(n)
A66 |
随机数
比如ASCII 65-90 代表 A-Z，我选择一个范围，随机生成一个数字，然后把这个数字转换成字符就是一个随机的英文字符
|
1
2
3
4
5
6
|
>>>import random
i=random.randrange(65,91)
c=chr(i)
print(c)
----------
H |
例子 生成一组随机的代码
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
import random
li=[]
for i in range(6):
r=random.randrange(0,5)
if r==2 or r==4:
num=random.randrange(0,10)
li.append(str(num))
else:
temp = random.randrange(65, 91)
c = chr(temp)
li.append(c)
res="".join(li)
print(li)
print(res)
-------------------
['T', 'Q', 'G', '2', 'Q', '6']
TQG2Q6 |
当执行一个Phython文件的时候，他一般会经过以下几个步骤
-
读取文件内容，把读取的字符串保存到内存
-
python把这些字符串编译为特殊代码
-
执行这些代码
比如saltstack，django的语法，其实最后都是转换成python的字符串，然后通过python编译执行。
下面是相关的一些函数
compile()把字符串转换成python代码
exec()执行任意的的Python代码，没有返回值
eval()执行运算表达式，有返回值
例子
compile可以把字符串转换成代码，然后exec来执行这个代码
|
1
2
3
4
5
6
7
|
s="print(123)"
r=compile(s,"<string>","exec")
print(r)
exec(r)
---------------
<code object <module> at 0x000001CB92285D20, file "<string>", line 1>
123 |
当然exec()也可以直接执行，他会自动转换之后再编译执行
|
1
2
3
|
>>>exec("print(123)")
-----
123 |
当使用eval()的时候，我们可以有返回值，比如
|
1
2
3
4
5
6
|
>>>s="6*8"
ret=eval(s)
print(ret)
exec("print(11)")
------------
48 |
dir()可以快速查看他有哪些函数
|
1
2
3
|
print(dir(dict))
-----------
['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__iter__', '__le__',
|
如果想查看细节，可以用help()
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
help(list)
-----------
Help on class list in module builtins:
class list(object)
| list() -> new empty list
| list(iterable) -> new list initialized from iterable's items
|
| Methods defined here:
|
| __add__(self, value, /)
| Return self+value.
|
| __contains__(self, key, /)
| Return key in self
... |
divmod()用来取商和余数
比如
|
1
2
3
4
5
6
7
|
>>> r=divmod(97,10)
print(r)
n1,n2=divmod(97,10)
print(n1,n2)
-----------------
(9, 7)
9 7
|
isinstance()判断一个对象是否为某个类的实例
比如字符串alex是str的一个实例，所以返回值为True
|
1
2
3
4
|
>>> s="alex"
r=isinstance(s,str)
print(r)
True |
filter(),第一个参数参数传入函数，第二个参数传入一个可以迭代的对象，比如列表；在filter 内部，循环第二个参数，让每个循环元素执行函数（第一个参数），如果返回为True，表示元素合法
例如下面一个函数的效果
|
1
2
3
4
5
6
7
8
9
10
11
|
def f1(args):
res=[]
for item in args:
if item > 22:
res.append(item)
return res
li=[11,22,33,44,55]
ret=f1(li)
print(ret)
--------------
[33, 44, 55]
|
他可以用filter来实现
|
1
2
3
4
5
6
7
|
>>> def f2(a):
if a > 22:
return True
ret=filter(f2,li)
print(list(ret))
-----------------
[33, 44, 55]
|
例：结合lambda表达式，可以很简便
|
1
2
3
4
5
6
7
8
9
|
>>> f1=lambda a: a>30
ret=f1(90)
print(ret)
li=[11,22,33,44,55]
res=filter(lambda a:a > 14,li)
print(list(res))
-------------------
True[22, 33, 44, 55]
|
map()的使用方式和filter类似，第一个参数是函数，第二个参数是可以迭代的对象
比如，下面一个例子
|
1
2
3
4
5
6
7
8
9
10
|
>>> li = [11,22,33,44,55]
def f1(args):
res=[]
for i in args:
res.append(100+i)
return res
r=f1(li)
print(list(r))
----------------
[111, 122, 133, 144, 155]
|
同样的功能如果用map实现的话
|
1
2
3
4
5
6
|
>>> def f2(a):
return a+100
result=map(f2,li)
print(list(result))
----------------
[111, 122, 133, 144, 155]
|
区别：
filter: 函数返回True; 将元素添加到结果中
map:把函数返回值添加到结果中
float()转换到浮点型
set()集合
fronzenset()不可变的集合
globals()所有全局变量
locals()所有局部变量
例
|
1
2
3
4
5
6
7
8
9
10
11
12
|
>>> NAME="ALEX"
def show():
a=123
c=123
print(locals())
print(globals())
show()------------
{'c': 123, 'a': 123}
{'NAME': 'ALEX', 'show': <function show at 0x0000025EFD3DB488>, 'sys': <module 'sys' (built-in)>, '__builtins__': {'PendingDeprecationWarning': <class 'PendingDeprecationWarning'>, 'IndexError': <class 'IndexError'>, 'SystemError': <class 'SystemError'>, 'abs': <built-in function abs>, 'getattr': <built-in function getattr>, 'iter': <built-in function iter>, 'BaseException': <class 'BaseException'>, 'UnicodeDecodeError': <class 'UnicodeDecodeError'>, 'sum': <built-in function sum>, 'id': <built-in function id>, 'setattr': <built-in function setattr>, '__doc__': "Built-in functions, exceptions, and other objects.\n\nNoteworthy: None is the `nil' object; Ellipsis represents `...' in slices.", 'ProcessLookupError': <class 'ProcessLookupError'>, 'NotImplemented': NotImplemented, 'memoryview': <class 'memoryview'>, 'str': <class 'str'>, 'RuntimeError': <class 'RuntimeError'>, 'print': <built-in function print>, 'enumerate': <class 'enumerate'>, 'BrokenPipeError': <class 'BrokenPipeError'>, 'open': <built-in function open>, 'eval': <built-in function eval>, 'KeyError': <class 'KeyError'>, 'locals': <built-in function locals>, 'UnicodeWarning': <class 'UnicodeWarning'>, '__import__': <bound method ImportHookManager.do_import of <module '_pydev_bundle.pydev_import_hook.import_hook'>>, '__spec__': ModuleSpec(name='builtins', loader=<class '_frozen_importlib.BuiltinImporter'>), 'ZeroDivisionError': <class 'ZeroDivisionError'>, 'int': <class 'int'>, 'license': Type license() to see the full license text, 'isinstance': <built-in function isinstance>, 'len': <built-in function len>, 'LookupError': <class 'LookupError'>, 'OverflowError': <class 'OverflowError'>, 'dict': <class 'dict'>, '__debug__': True, 'dir': <built-in function dir>, 'BlockingIOError': <class 'BlockingIOError'>, 'range': <class 'range'>, 'super': <class 'super'>, 'PermissionError': <class 'PermissionError'>, 'FutureWarning': <class 'FutureWarning'>, 'True': True, 'FileNotFoundError': <class 'FileNotFoundError'>, 'staticmethod': <class 'staticmethod'>, 'TabError': <class 'TabError'>, 'hex': <built-in function hex>, '__name__': 'builtins', 'copyright': Copyright (c) 2001-2016 Python Software Foundation.
All Rights Reserved.
Copyright (c) 2000 BeOpen.com.
|
hash() 生成哈希值，然后保存到内存；一般用于比如字典的key转换成哈希值的保存，做索引
|
1
2
3
4
|
s="hhh"
print(hash(s))
--------------
3961184104134240409 |
len()输出长度，Python3是显示字符，而2显示的是字节
|
1
2
3
4
5
6
7
|
>>> s="理解" #python 3 是2（字符）,2.7是6（字节）
print(len(s))
b=bytes(s,encoding="utf8")
print(len(b))
------------
26 |
max()最大
min()最小
sum()求和
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
>>> r=max([11,22,33])
print(r)
l=min([11,22,33])
s=sum([1,2,3])
print(l,s)
>>> r=max([11,22,33])
print(r)
l=min([11,22,33])
s=sum([1,2,3])
print(l,s)
3311 6
|
pow()求指数，效果和两个*一样
|
1
2
3
4
|
>>> print(2**10)
print(pow(2,10))
10241024 |
reverse翻转，下面例子两个表达效果一样
|
1
2
3
4
|
>>> 翻转li=[11,22,33]
li.reverse()reversed(li)
|
zip()可以把多个列表的列抽出来
|
1
2
3
4
5
6
|
>>> l1=["alex",11,22,33]
l2=["is",11,22,33]
l3=["sb",11,22,33]
r=zip(l1,l2,l3)
print(list(r)[0])
('alex', 'is', 'sb')
|