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

7.1 函数语法

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

def 函数名(参数列表):

执行语句1

执行语句…

return [表达式]

# 自定义函数def add(a, b):    return a + bdef nop():    pass# 调用函数print(add(1, 2))print(nop())

输出结果

3None

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="厉害"))

输出结果

姓名 东阳年龄 201姓名 雷公年龄 251姓名 厉害年龄 101

不定长参数，是说传递参数的数量是可变的，可以是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}))

输出结果

30101420

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

# 不定长参数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 Falseextra = {"name": "gao", "age": 18}# 调用函数dict_util("phone", **extra)

输出结果

name gaoage 18phone 不存在

2. 匿名函数

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

lambda 参数列表:表达式

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

输出结果

和为: 6

3. 值的改变

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

传递整型(不可变对象)给函数时，在函数内部的改变不会影响外部。

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

输出结果

9910

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

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

输出结果

9910

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

# 传递列表(可变对象)def change(ls):    ls.append(5)    print("函数内的值: ", ls)lst = [1, 2, 3]change(lst)print("函数外的值: ", lst)

输出结果

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

有关函数定义的内容，老陈讲完了，如果觉得对你有所帮助，希望老铁来个三连击，让更多人看到这篇文章。不善表达的人真的很吃亏，付出多，却没一个人说你好，否则，我就可用言语让好多人转发给更多想学编程的人，可惜我不善表达。

7.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)

输出结果

61524

(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.9351print(round(i, 2))

输出结果

43.51-125.94

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

# 取最接近但大于原值的整数import mathi = 6.2451print(math.ceil(i))i = -6.2451print(math.ceil(i))

输出结果

7-6

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

# 取最接近但小于原值的整数import mathi = 3.51264print(math.floor(i))i = -3.51264print(math.floor(i))

输出结果

3-4

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

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

输出结果

8-8

2. 随机数

随机数应用挺多的，如随机生成6位数密码，随时生成短信验证码，登录验证码；还有抽奖时，通过随机数产生的值去对应奖品等。

(1) random.random()生成一个0到1.0之间的随机浮点数。

# 获取0~1.0中的随时浮点数import randomf = random.random()print(f)

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

0.9392144902656036

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

# 获取范围内的随时浮点数import randomf = 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 randomi = random.randint(100000, 999999)print(i)

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

40

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

# 随机获取一个偶数值import randomi = random.randrange(0, 101, 2)print(i)

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

40

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

# 随机抽取元素import randomlst = random.sample("Welcome to Python.", 3)s = "".join(lst)print(s)

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

 mo

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

# 随机获取一个元素import randoms = random.choice(["124dds", "ew6210", "98rac1"])print(s)

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

124dds

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

# 洗牌import randomitem = [1, 2, 6, 8, 3, 5]random.shuffle(item)print(item)

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

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

有关常用函数的内容，老陈讲完了，如果觉得对你有所帮助，希望老铁能转发点赞，让更多的人看到这篇文章。

7.3 日期函数

时光不可追，往事不可回。以往创建的数据，如若没有日期做标识，不堪回首。几乎任何一个产品都会用到日期，如登录日期、创建日期、修改日期等。正因如此，编程语言中，几乎都有内置日期函数。

1. 当前日期

获取日期和时间的有datetime和time模块。其中datetime模块对time模块进行了封装。用datetime.now()获取到当前日期和时间，并可在返回结果当中，可只取其中的一部分内容如年份、月份。

# 获取当前日期和日期from datetime import datetimenow = 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.4460102020 10 15 19 37 25

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

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

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

16026683441602668344275

2. 日期计算

两个日期相差多少天， 今天的n天后的日期，明天的日期等这种情况，就需要进行日期计算，它可通过datetime.timedelta()方法实现。

(1) 获取昨天日期，利用当前日期减去一天

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

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

2020-10-16

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

# 算出20天后的日期from datetime import datetime, timedeltanow = 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 datetimenow = 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.9183052020-10-162020101619:51:45

4. 日期库

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

用过arrow之后，轻轻舒了一口气，感觉就是爽，爽，爽。

# 引入arrow模块import arrowt = arrow.now()# 获取年份和月份y = t.datetime.yearm = t.datetime.monthprint(y, m)# 时间戳ts = t.timestampprint(ts)# 日期格式化f = t.format("YYYY-MM-DD HH:mm:ss")print(f)

输出结果

2020 1016028479832020-10-16 19:33:03

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

# 计算出昨天日期import arrowt = 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-132020-10-152020-07-1420201014

有关函数的内容，老陈讲完了，如果觉得对你有所帮助，希望老铁能转发点赞，让更多的人看到这篇文章。你的转发和点赞，就是对老陈继续创作和分享最大的鼓励。

一个当了10年技术总监的老家伙，分享多年的编程经验。想学编程的朋友，可关注今日头条：老陈说编程。我将分享Python，前端(小程序)和App方面的编程知识。关注我，没错的。

7.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.01602720769.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 datetimenow = datetime.now()print(now)

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

2020-10-15 20:19:46.169928

(2) 简化导入

# ---用import导入---import datetimenow = datetime.datetime.now()print(now)

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

2020-10-15 20:21:32.981823

3. as用法

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

# ---用as取别名---import xml.etree.cElementTree as Etc = 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 sqlutils = sqlutil.join("customers")print(s)

输出结果

select * from customers

好了，有关模块导入的内容，老陈讲完了，如果觉得对你有所帮助，希望老铁能转发点赞，让更多的人看到这篇文章。你的转发和点赞，就是对老陈继续创作和分享最大的鼓励。

一个当了10年技术总监的老家伙，分享多年的编程经验。想学编程的朋友，可关注今日头条：老陈说编程。我将分享Python，前端(小程序)和App方面的编程知识。关注我，没错的。

#程序员##Python##Python编程从入门到实践#