函数是组织好的，可重复使用的，用来实现单一和相关联功能的代码段。函数能提高应用的模块性和代码的重复利用率。在这之前我们已多次使用内置函数，如print()。当然，咱们也可以自定义函数。

5.1 函数语法

函数代码以def关键词开关，后接函数标识符名称和圆括号()，通过return[表达式]结束，选择性地返回一个值给调用方，不带表达式的return相当于返回None。其语法结构为：

def 函数名(参数列表):
执行语句1
执行语句…
return [表达式]

# 自定义函数
def add(a, b):
    return a + b


def nop():
    pass


# 调用函数
print(add(1, 2))
print(nop())

输出结果

3
None

1.参数传递
对于函数的调用者来说，需要知道如何传递正确的参数,才能正常调用函数。参数传递有无参数、必需参数、关键字参数、默认参数、不定长参数几种情况。无参数的函数，主要在内部执行逻辑内容，执行完成后，返回结果。

# 无参数函数
def opt():
    print("逻辑1")
    print("逻辑...")
    return True


# 调用时不传参数
result = opt()
print(result)

输出结果

逻辑1
逻辑...
True

带有固定参数的函数，可通过位置顺序和关键字进行调用，用关键字调用时，位置可调整。如果函数参数中有默认值，不传递时，会使用默认值。

# 有参数函数
def add(name, age=10):
    print("姓名", name)
    print("年龄", age)
    return 1


# 按位置顺序调用
print(add("东阳", 20))
# 用关键字调用
print(add(age=25, name="雷公"))
# 只传递姓名,年龄用默认值
print(add(name="厉害"))

输出结果

姓名 东阳
年龄 20
1
姓名 雷公
年龄 25
1
姓名 厉害
年龄 10
1

不定长参数，是说传递参数的数量是可变的，可以是1个、2个到任意个，还可以是0个。像计算不确定整数的和，用这个就和合适，不定长参数用标识。实际上，这些可变参数在函数调用时自动组装为一个元组。传递列表、元组、集合这些内容在变量前面加。

# 不定长参数
def calc(*numbers):
    data_sum = 0
    for n in numbers:
        data_sum += n
    return data_sum


# 传递逐个内容
print(calc(10, 20))
# 传递元组
print(calc(*(1, 2, 3, 4)))
# 传递列表
print(calc(*[6, 8]))
# 传递集合
print(calc(*{8, 12}))

输出结果

30
10
14
20

不定长参数既然可以表示元组(可传递字符串、元组、列表、集合内容)，那字典呢？–也是可以，用标识。虽然*和等可以一起组合使用，但建议不要把程序搞得很复杂。

# 不定长参数
def dict_util(key, **kw):
    if key in kw:
        print(key, "存在")
        return True
    else:
        for k, v in kw.items():
            print(k, v)
        print(key, "不存在")
        return False


extra = {"name": "gao", "age": 18}
# 调用函数
dict_util("phone", **extra)

输出结果

name gao
age 18
phone 不存在

2.匿名函数
使用lambda和冒号定义匿名函数，冒号前面表示函数的参数，后面是表达式。表达式只能有一个，其结果返回值，不用写return。匿名函数也是一个对象，可以把它赋值给一个变量，再利用变量来调用该函数。语法结构为：
lambda 参数列表:表达式

# 用lambda定义匿名函数
f = lambda a, b, c: a + b + c
print("和为:", f(1, 2, 3))

输出结果

和为: 6

3.值的改变
在函数传递参数过程中，外部的变量可能会被改变，也可能不会改变，就看传递的是不可变对象还是可变对象。一般整型、浮点型、字符串等基本数据类型，为不可变对象，数据结构中列表、集合、字典为可变对象，元组为不可变对象。
传递整型(不可变对象)给函数时，在函数内部的改变不会影响外部。

# 传递整型值,不改变内容
def change(a):
    a = 99
    print(a)


# 要传递参数值
a = 10
change(a)
print(a)

输出结果

99
10

那如果真的需要在函数内部，就可以改变外部值时，该怎么办?–用global关键字了就可以解决。如果函数内嵌套函数时，出现内部函数改变外部函数的变量时，使用nonlocal关键字。但建议不要把程序搞得那么复杂。

# 传递整型值,可以用global改变内容
def change():
    global a
    a = 99
    print(a)


# 要传递参数值
a = 10
change()
print(a)

输出结果

99
10

传递列表(可变对象)给函数时，在函数内部的改变会同时影响外部。

# 传递列表(可变对象)
def change(ls):
    ls.append(5)
    print("函数内的值: ", ls)


lst = [1, 2, 3]
change(lst)
print("函数外的值: ", lst)

输出结果

函数内的值:  [1, 2, 3, 5]
函数外的值:  [1, 2, 3, 5]

有关函数定义的内容到此结束。

5.2 常用函数

Python内置了很多函数，除了之前说过的生成数列的range()、求最大值的max()、求最小值的min()、求长度的len()、排序用的sorted()等函数外，还有一些常用函数，如绝对值、四舍五入、随机数等。
1.计算相关
(1) abs(a)：求取绝对值。正负数的绝对为正数，0的绝对值还是0.

# 求数值绝对值
i = abs(-66.6)
print(i)

输出结果

66.6

(2) divmod(a,b): 获取商和余数。结果是元组，第1位为商，第2位是余数。

# 求商和余数
t = divmod(7, 2)
print("商是：", t[0])
print("余数是：", t[1])

输出结果

商是： 3
余数是： 1

(3) sum(list) : 计算元组、列表或集合元素的和。

# 计算元组的和
t = sum((1, 2, 3))
print(t)
# 计算列表的和
lst = sum([4, 5, 6])
print(lst)
# 计算集合的和
set1 = sum([7, 8, 9])
print(set1)

输出结果

6
15
24

(4) pow(a,b) : 获取乘方数。

# 求乘方的结果
p = pow(2, 3)
print(p)

输出结果

8

(5) round(a,b) : 获取指定位数的小数。a代表浮点数，b代表要保留的位数。返回浮点数x的四舍五入值。

# 求四舍五入
i = 3.51264
# 取整数
print(round(i))
# 保留两位小数
print(round(i, 2))
# 负数的四舍五入
i = -125.9351
print(round(i, 2))

输出结果

4
3.51
-125.94

(6) ceil()得到的是最接近原数但大于原数的整型 ，既向上取整。

# 取最接近但大于原值的整数
import math

i = 6.2451
print(math.ceil(i))
i = -6.2451
print(math.ceil(i))

输出结果

7
-6

(7) floor()得到的是最接近原数但小于原数的整型 ，既向下取整。

# 取最接近但小于原值的整数
import math

i = 3.51264
print(math.floor(i))
i = -3.51264
print(math.floor(i))

输出结果

3
-4

(8) int() 直接截去小数部分,返回整型。

# 截取整数
i = 8.36412
print(int(i))
i = -8.36412
print(int(i))

输出结果

8
-8

2.随机数
随机数应用挺多的，如随机生成6位数密码，随时生成短信验证码，登录验证码；还有抽奖时，通过随机数产生的值去对应奖品等。
(1) random.random()生成一个0到1.0之间的随机浮点数。

# 获取0~1.0中的随时浮点数
import random

f = random.random()
print(f)

输出结果(随机生成，结果会不一样)

0.9392144902656036

(2) random.uniform(a，b)生成一个a到b之间的随机浮点数。

# 获取范围内的随时浮点数
import random

f = random.uniform(286.20, 951.15)
print(f)

输出结果(随机生成，结果会不一样)

581.1038876738178

(3) random.randint(a，b)生成一个a到b之间的随机整数。函数返回数字 N ，N 为 a到b 之间的数字（a <= N <= b），包含 a 和 b。

# 获取范围内的随时整数
import random

i = random.randint(100000, 999999)
print(i)

输出结果(随机生成，结果会不一样)

40

(4) random.randrange(start,stop,step) 按步长随机在上下限范围内取一个随机数。

# 随机获取一个偶数值
import random

i = random.randrange(0, 101, 2)
print(i)

输出结果(随机生成，结果会不一样)

40

(5) random.sample(str,n)随机的选取n个字符,结果为列表。

# 随机抽取元素
import random

lst = random.sample("Welcome to Python.", 3)
s = "".join(lst)
print(s)

输出结果(随机生成，结果会不一样)

mo

(6) random.choice()从列表中随机返回一个元素。

# 随机获取一个元素
import random

s = random.choice(["124dds", "ew6210", "98rac1"])
print(s)

输出结果(随机生成，结果会不一样)

124dds

(7) random.shuffle()对list列表随机打乱顺序，也就是洗牌。

# 洗牌
import random

item = [1, 2, 6, 8, 3, 5]
random.shuffle(item)
print(item)

输出结果(随机生成，结果会不一样)

[6, 8, 3, 1, 2, 5]

有关常用函数的内容到此结束。

5.3 日期函数

时光不可追，往事不可回。以往创建的数据，如若没有日期做标识，不堪回首。几乎任何一个产品都会用到日期，如登录日期、创建日期、修改日期等。正因如此，编程语言中，几乎都有内置日期函数。
1.当前日期
获取日期和时间的有datetime和time模块。其中datetime模块对time模块进行了封装。用datetime.now()获取到当前日期和时间，并可在返回结果当中，可只取其中的一部分内容如年份、月份。

#获取当前日期和日期
from datetime import datetime

now = datetime.now()
print(now)
# 获取年份、月份等
y = now.year  # 年份
M = now.month  # 月份
d = now.day  # 天
h = now.hour  # 时
m = now.minute  # 分
s = now.second  # 秒
print(y, M, d, h, m, s)

输出结果(以你电脑的时间为准)

2020-10-15 19:37:25.446010
2020 10 15 19 37 25

开发产品时，用时间戳表示唯一值或比较，是常有的事。时间戳可通过time模块获取。

# 获取当前日期和日期
import time
t = time.time()
# 10位时间戳
print(int(t))
# 13位时间戳
print(int(t*1000))

输出结果(以你电脑的时间为准)

1602668344
1602668344275

2.日期计算
两个日期相差多少天， 今天的n天后的日期，明天的日期等这种情况，就需要进行日期计算，它可通过datetime.timedelta()方法实现。
(1) 获取昨天日期，利用当前日期减去一天

# 计算出昨天日期
from datetime import datetime, timedelta
now = datetime.now().date()
date = now - timedelta(days=1)
print(date)

输出结果(以你电脑的时间为准)

2020-10-16

(2) 获取20后的日期，利用当前日期加上20天

# 算出20天后的日期
from datetime import datetime, timedelta
now = datetime.now().date()
date = now + timedelta(days=20)
print(date)

输出结果(以你电脑的时间为准)

2020-11-01

3.格式日期
格式化日期，在编程中，是常用的，如2019-01-01这种格式。格式使用strftime(format)方法,format内容由特殊的字符组成。%y两位数的年份表示(00-99)，%Y四位数的年份表示(000-9999)，%m月份(01-12)，%d 月内中的一天(0-31)，%H 24小时制，小时数(0-23)，%I 12小时制，小时数(01-12)，%M 分钟数(00=59)，%S秒(00-59)。

# 日期格式化
from datetime import datetime
now = datetime.now()
print(now)
# 日期转化为字符串
s = datetime.strftime(now, "%Y-%m-%d")
print(s)
# 日期转化为整型
s = datetime.strftime(now, "%Y%m%d")
print(int(s))
# 时分秒
h = datetime.strftime(now, "%H:%M:%S")
print(h)

输出结果(以你电脑的时间为准)

2020-10-16 19:51:45.918305
2020-10-16
20201016
19:51:45

4.日期库
Python针对日期时间的处理提供了大量的package，类和方法，但在使用上挺繁琐，挺别扭的。好在有一些好用的第三方日期库可供使用，特别是Arrow。它提供了一个合理的、人性化的方法来操作日期。要使用Arrow库，先通过：pip install arrow或pip3 install arrow下载和安装。
用过arrow之后，轻轻舒了一口气，感觉就是爽，爽，爽。

# 引入arrow模块
import arrow

t = arrow.now()
# 获取年份和月份
y = t.datetime.year
m = t.datetime.month
print(y, m)
# 时间戳
ts = t.timestamp
print(ts)
# 日期格式化
f = t.format("YYYY-MM-DD HH:mm:ss")
print(f)

输出结果

2020 10
1602847983
2020-10-16 19:33:03

时间推移就是要获取某个时间之前的时间或者之后的时间，比如要获取相对于当前时间前一天的时间。Arrow在这方面的计算也挺方便的。

# 计算出昨天日期
import arrow
t = arrow.now()
t = t.shift(days=-1)
t = t.format("YYYY-MM-DD")
print(t)
# 算出明天日期
t = arrow.now()
t = t.shift(days=1)
t = t.format("YYYY-MM-DD")
print(t)
# 算出三个月前的今天
t = arrow.now()
t = t.shift(months=-3)
t = t.format("YYYY-MM-DD")
print(t)
# 日期转为整数
t = arrow.now()
t = t.format("YYYYMMDD")
print(int(t))

输出结果(以你电脑的时间为准)

2020-10-13
2020-10-15
2020-07-14
20201014

有关函数的内容到此结束。

5.4 模块导入

模块是一个包含所有你定义的函数和变量的文件，其后缀名是.py。模块可以被别的程序引入，以使用该模块中的函数等功能。
模块让你能够有逻辑地组织代码段，把相关的代码分配到一个模块里，能让你的代码更好用，更易懂。导入存在的模块，起到资源复用的作用。
1.import语句
用import导入模块(文件)跟其他编程语言是一样的，直接使用import 模块名1,模块2…,语句导即可。虽然一条import语句可以同时导入多个模块，但建议采用一条import语句只导入一个模块。这样做，除了可提高可读性外，删除也更方便。
import除了可以导入模块，也可以导入包下的所有模块，就是用import package1, package2…，但最好不要这样使用。

import math  # 导入math模块
import time  # 导入time时间模块

# 用math模块里pow函数
a = math.pow(2, 3)
print(a)
# 用time模块里time函数
b = time.time()
print(b)

输出结果(时间结果以你电脑的为准)

8.0
1602720769.0266612

2.from语句
除了可以导入整个模块外，Python还可以支持只导入其中的部分内容，如只导入某个函数。要实现这个，可用from 模块名 import name1,name2..语句。

from math import pow

# 导入math模块里pow函数
a = pow(2, 6)
print(a)

输出结果

64.0

当然，如果要导入模块的全部内容也是可以的，就是用from 模块名 import *的方式。只是这种方式，会存在一些纰漏(如函数重名),所以建议少用或不用。

from math import *

# 用math模块里的floor函数
m = floor(102.25)
print(m)

输出结果

102

除了导入部分内容外，实际上from语句，还可以简化前缀。
(1) 完整导入

# ---用from导入---
from datetime import datetime

now = datetime.now()
print(now)

输出结果(以你电脑时间为准）

2020-10-15 20:19:46.169928

(2) 简化导入

# ---用import导入---
import datetime

now = datetime.datetime.now()
print(now)

输出结果(以你电脑时间为准）

2020-10-15 20:21:32.981823

3.as用法
如果导入的模块名比较长，用起来比较”费劲”时，可以用as给它举个别名。import和from语句都可以。

# ---用as取别名---
import xml.etree.cElementTree as Et

c = Et.Comment("<book>12天搞定Python</book>")
print(c.text)

输出结果

<book>12天搞定Python</book>

4.重名区分
在开发过程中，文件(模块)名出现重名的几率挺高的。如果不加以区分，那就老鼠、老虎傻傻分不清了。区分模块名，可以包。包治百病，包(package)就是有一个__.init__.py特殊文件在里面的文件夹，包(文件夹)用来存放.py文件。其中__init__.py，可以为空文件。
包里面的文件名，不要与package同名，也不要使用关键字。
用一个工程(mk)来说明一下。在utils和model包下，都有一个名叫sqlutil.py的模块，用于处理sql语句。当在controller用到sqlutil.py时，指定包名，以便区分。

model下sqlutil.py(动手新建，不要偷懒)文件的内容

# 拼接sql语句
def join(table=""):
    sql = "select * from {0}"
    return sql.format(table)
utils下sqlutil.py(动手新建，不要偷懒)文件的内容

# 拼接sql语句
def join(table=""):
    sql = "select * from {0}"
    return sql.format(table)
controller下test.py文件的内容

# 导入utils下的模块
from utils import sqlutil

s = sqlutil.join("customers")
print(s)

输出结果

select * from customers

好了，有关模块导入的内容到此为止。