A、函数的定义和调用

1、函数的定义

def 函数名(参数列表):
    "可选函数文档字符串"
    函数体
return 表达式
基于上述格式，下面对函数定义的规则进行说明：

函数代码块以 def 开头，后面紧跟的是函数名和圆括号
函数名的命名规则跟变量的名字一样，即只能使用字母、数字和下划线的热门和组合。但是不能以数字开头，并且不能和关键字重名
函数的参数必须放在括号里卖弄
函数的第一行可以选择性的使用文档字符串来存放函数说明
函数内容以冒号开始，并且缩进
return 表达式结束函数，选择性的返回一个 值给调用者。不带表达式的 return 相当于返回None
2、函数调用

def smcs():
    return "三木成森"


print(smcs())
运行结果：

三木成森
Python语言的函数支持嵌套

B、函数的参数

1、参数的传递

def smcs(date):
    return date


print(smcs("三木成森"))
运行结果：

三木成森
2、默认参数

Python函数的参数，可以设置默认值，这个参数叫默认参数。由于默认参数已经有了默认值，所以可以忽略，但是其他参数必须要传值。

如果默认参数没有传值，就使用默认值。如果默认参数传值了，就使用传入的值

def smcs(data='三木成森'):
    return data


print(smcs())
print(smcs('你好，三木成森'))
运行结果：

三木成森
你好，三木成森
需要注意的是，带有默认值的参数，一定要位于参数最后面，否则会报错

3、不定长参数

通常在定义一个函数时，若希望函数能够处理的参数个数比当初定义的参数个数多的时候，可以使用函数的不定长参数，其基本语法如下：

def smcs(a, b, *data):
    print(a)
    print(b)
    print(data)
    return
a和b为形参，*data为不定长参数。当调用函数的时候，传入的参数会优先匹配形参的个数，如果从传入的参数数量和形参数量相同，不定长参数会返回空元组或字典，如果传入参数数量超过形参个数，会分为两种情况：

传入的参数没有指定名称，那么会以元组的形式存放多余的参数

传入的参数指定了名称，会以字典的形式存放多余的参数

只有形参
def smcs(a, b, *data):
    print(a)
    print(b)
    print(data)
    return


smcs(1, 2)

运行结果：

1
2
()


多于形参个数——元组

def smcs(a, b, *data):
    print(a)
    print(b)
    print(data)
    return


smcs(1, 2, 3, 4, 5)
运行结果：

1
2
(3, 4, 5)


多于形参个数——字典

def smcs(a, b, **data):
    print(a)
    print(b)

    print(data)

smcs(1, 2, n='n', m='m')
运行结果：

1
2
{'n': 'n', 'm': 'm'}


C、变量作用域

1、LEGB原则

Python作用域一共有四种：

L（Local）函数内的区域，包括局部变量和参数
E（Enclosing）外面嵌套函数区域，常见的是闭包函数的外层函数
G（Global）全局作用域
B（Built-in）内建作用域
Python中变量是采用L→E→G→B的规则查找的，即Python检索变量会优先在局部作用域中查找，如果没有找到，便会去局部外的局部找（例如闭包），再找不到就会去全局作用域中找，再者去内建作用域中找

2、局部变量和全局变量

局部变量即定义在 def 函数里面的变量，只能在 def 函数里面使用，反之定义在函数外的变量叫做全局变量

def smcs():
    name = '三木成森'       # 局部变量
    return name


name = smcs()       # 局部变量
print(name)
局部变量只能在函数内访问，全局变量，全局都可以访问

Ps：函数的参数也是局部变量

3、global和nonlocal关键字

当内部作用域想修改外部作用域的时候就需要用到global或nonlocal关键字了

1、global关键字

global关键字用来在函数或其他作用域里面使用全局变量，不用global也可以，就是会有问题

不使用global关键字
代码：
name = '三木成森'
def smcs():
    name = '你好，三木成森'


smcs()
print(name)
这是一个没有使用global关键字的代码，运行结果为：

三木成森
可以看到运行结果为 三木成森 ，而不是 你好，三木成森 ，原因是因为，在函数里面虽然对name变量进行了修改，但是系统会把函数里面的name变量当做是一个局部变量，又因为函数里面的nama变量是一个局部变量，和外面的全局变量name没有任何关系，所以在函数里修改name变量的值没有用，可以试一下，在函数里面把name变量打印出来

name = '三木成森'
def smcs():
    name = '你好，三木成森'
    print(name)

smcs()
print(name)
运行结果：

你好，三木成森
三木成森
可以看到，函数里面的name输出为 你好，三木成森，外面的全局变量name输入结果仍然是 三木成森

使用global关键字
加上global关键字的代码：

name = '三木成森'
def smcs():
    global name
    name = '你好，三木成森'


smcs()
print(name)
运行结果为：

你好，三木成森
可以看到，函数外部的全局变量name的值确实变成了 你好，三木成森

2、nonlocal关键字

nonlocal关键字是在Python3.x版本中新增的，Python2.x版本里面不提供支持，使用nonlocal关键字可以对嵌套函数的外部函数里的局部变量进行修改

和global关键字一样，不使用的话，可以访问，但是不能修改

不使用nonlocal关键字
def smcs():
    name = '三木成森'
    def sm():
        name = '你好，三木成森'
    sm()
    print(name)


smcs()
运行结果：
三木成森
使用nonlocal关键字
def smcs():
    name = '三木成森'
    def sm():
        nonlocal name
        name = '你好，三木成森'
    sm()
    print(name)


smcs()
运行结果：
你好，三木成森


D、匿名函数

匿名函数就是没有函数名的函数，也就是不在使用def定义的函数，声明匿名函数需要使用lambda表达式

lambda格式：
lambda [arg...]:表达式


lambda调用

name = lambda a, b: a+b
print(name('三木', '成森'))
运行结果：

三木成森


需要注意的是，使用lambda声明的匿名函数能接受任意数量的参数，但只能返回一个表达式的值。匿名函数不能直接调用print()函数，这是因为lambda需要一个表达式。
注意：

与def函数相比，lambda定义的函数有很多不同的地方

def定义的函数是有名称的，而lambda定义的没有名称，这是最明显的区别
lambda定义的函数通常会返回一个对象或者一个表达式，它不会将返回结果赋值给一个变量，而def风衣的函数则可以
lambda定义的函数中只有一个表达式，函数体也比def定义的函数简单得多，而def定义的函数的函数体是一个语句
lambda表达式的冒号后面只能有一个表达式，def定义的函数则可以有多个
像if或for等语句不能用于lambda定义的函数中，而def定义的函数则可以使用
lambda一般用来定义简单的函数，而def可以定义复杂的函数
lambda定义的函数不能共享给别的程序调用，而 def定义的函数则可以被调用
E、日期时间函数

1、时间函数

在Python中，通常有一下几种方法表示时间：

时间戳
格式化时间字符串
时间元组(struct_time)
1、时间戳

通常来说，时间戳就是从1970年1月1日00:00:00开始按秒计算的偏移量。返回时间戳的函数主要有time()、clock()等

import time;    # 引入time模块

date = time.time()
print("现在的时间戳为：", date)
运行结果：

现在的时间戳为： 1544612747.7893069
2、格式化时间戳

可以使用time模块的 strftime 函数来格式化日期，定义格式为：

timer.strftime(format[, t])
format：格式字符串
t：可选参数，是一个struct_time对象
print(time.strftime("%Y-%m-%d", time.localtime()))    # 2018-12-12
print(time.strftime("%a %b %d %H:%M:%S", time.localtime()))   # Wed Dec 12 19:16:57
Python中时间r日期格式化字符串
格式化符号        含义
%y        两位数的年份表示（00——99）
%Y        四位数的年份表示（000——999）
%m        月份（01——02）
%d        月内中的一天
%H        24小时制小时数（0——23）
%l        12小时制小时数（0——12）
%M        分钟数（00——59）
%S        秒（00——59）
%a        本地简化的星期名称
%A        本地完整星期名称
%b        本地简化的月份名称
%B        本地完整的月份名称
%c        本地相应的日期表示和时间表示
%j        年内的一天（001——366）
%p        本地A.M或P.M.等价符
%U        一年中的星期数（00——53），星期一为星期的开始
%w        星期（0——6），星期天为星期的开始
%x        本地相应的日期表示
%X        本地相应的时间表示
%Z        当前时区的名称
%%        %本身
3、时间元组（struct_time）

struct_time元组的字段
序号        字段        含义及取值范围
0        tm_year        4位数的年份，例如：2018
1        tm_mon        表示月份，取值范围：1——12
2        tm_mday        表示天数，取值范围是1——31
3        tm_hour        表示小时数，取值范围0——23
4        tm_min        表示分钟数，取值范围0——59
5        tm_sec        表示秒数，取值范围0——61（60或61是闰秒）
6        tm_wday        表示星期数，取值范围0——6（0是周一）
7        tm_yday        表示一年中的第几天，取值范围是1——366（儒略历）
8        tm_isdst        决定是否为夏令时的标识符，允许的值时-1，0，1
time模块的函数
序号        代表含义
1        time.altzone
返回格林威治西部的夏令时地区的偏移秒数。如果该地区在格林威治东部会返回负值（如西欧，包括英国）。对夏令时启用地区才能使用。
2        time.asctime([tupletime])
接受时间元组并返回一个可读的形式为"Tue Dec 11 18:07:14 2008"（2008年12月11日 周二18时07分14秒）的24个字符的字符串。
3        time.clock( )
用以浮点数计算的秒数返回当前的CPU时间。用来衡量不同程序的耗时，比time.time()更有用。
4        time.ctime([secs])
作用相当于asctime(localtime(secs))，未给参数相当于asctime()
5        time.gmtime([secs])
接收时间戳（1970纪元后经过的浮点秒数）并返回格林威治天文时间下的时间元组t。注：t.tm_isdst始终为0
6        time.localtime([secs])
接收时间戳（1970纪元后经过的浮点秒数）并返回当地时间下的时间元组t（t.tm_isdst可取0或1，取决于当地当时是不是夏令时）。
7        time.mktime(tupletime)
接受时间元组并返回时间戳（1970纪元后经过的浮点秒数）。
8        time.sleep(secs)
推迟调用线程的运行，secs指秒数。
9        time.strftime(fmt[,tupletime])
接收以时间元组，并返回以可读字符串表示的当地时间，格式由fmt决定。
10        time.strptime(str,fmt='%a %b %d %H:%M:%S %Y')
根据fmt的格式把一个时间字符串解析为时间元组。
11        time.time( )
返回当前时间的时间戳（1970纪元后经过的浮点秒数）。
12        time.tzset()
根据环境变量TZ重新初始化时间相关设置。
time模块的属性
序号        属性说明
1        time.timezone
属性time.timezone是当地时区（未启动夏令时）距离格林威治的偏移秒数（>0，美洲;<=0大部分欧洲，亚洲，非洲）。
2       
time.tzname
属性time.tzname包含一对根据情况的不同而不同的字符串，分别是带夏令时的本地时区名称，和不带的。
2、日期函数（calendar模块）

calendar模块的有很广泛的方法用来处理年历和月历，比如打印某月的月历

import calendar;    # 引入calendar模块

rl = calendar.month(2019,12)
print(rl)
运行结果：

   December 2019
Mo Tu We Th Fr Sa Su
                   1
2  3  4  5  6  7  8
9 10 11 12 13 14 15
16 17 18 19 20 21 22
23 24 25 26 27 28 29
30 31
calendar模块常见函数
序号        函数和说明
1        calendar.calendar(year,w=2,l=1,c=6)
返回一个多行字符串格式的year年年历，3个月一行，间隔距离为c。 每日宽度间隔为w字符。每行长度为21* W+18+2* C。l是每星期行数。
2        calendar.firstweekday( )
返回当前每周起始日期的设置。默认情况下，首次载入caendar模块时返回0，即星期一。
3        calendar.isleap(year)
是闰年返回 True，否则为 False。
4        calendar.leapdays(y1,y2)
返回在Y1，Y2两年之间的闰年总数。
5        calendar.month(year,month,w=2,l=1)
返回一个多行字符串格式的year年month月日历，两行标题，一周一行。每日宽度间隔为w字符。每行的长度为7* w+6。l是每星期的行数。
6        calendar.monthcalendar(year,month)
返回一个整数的单层嵌套列表。每个子列表装载代表一个星期的整数。Year年month月外的日期都设为0;范围内的日子都由该月第几日表示，从1开始。
7        calendar.monthrange(year,month)
返回两个整数。第一个是该月的星期几的日期码，第二个是该月的日期码。日从0（星期一）到6（星期日）;月从1到12。
8        calendar.prcal(year,w=2,l=1,c=6)
相当于 print calendar.calendar(year,w,l,c).
9        calendar.prmonth(year,month,w=2,l=1)
相当于 print calendar.calendar（year，w，l，c）。
10        calendar.setfirstweekday(weekday)
设置每周的起始日期码。0（星期一）到6（星期日）。
11        calendar.timegm(tupletime)
和time.gmtime相反：接受一个时间元组形式，返回该时刻的时间戳（1970纪元后经过的浮点秒数）。
12        calendar.weekday(year,month,day)
返回给定日期的日期码。0（星期一）到6（星期日）。月份为 1（一月） 到 12（12月）。
import calendar

print(calendar.calendar(2018))
print(calendar.firstweekday())
print(calendar.isleap(2018))
print(calendar.leapdays(2008, 2018))
print(calendar.monthcalendar(2018, 12))
print(calendar.monthrange(2018, 12))
F、随机数函数

使用之前要引入random模块

import random
random.random()
返回0与1之间的浮点数，范围是0<=N<1.0
print(random.random())
运行结果：

0.2829958140690443


random.uniform(a, b)
返回a与b之间的浮点数N，如果a<b则取值范围是：a<=N<=b，反之则是：b<=N<=a

print(random.uniform(3, 4))
运行结果：

3.7977128084339826


random.randint(a, b)
返回随机数N，取值范围是：a<=N<=b

print(random.randint(1, 10))
运行结果：

5
注意：a和b必须为整数，并且a的值一定要小于b

random.randrange(start, stop, step)
返回指定递增基数集合中的一个随机数，基数默认为1，start表示开始，包含在范围中，stop表示结束，不包含在范围中，step表示基数

print(random.randrange(10, 100, 2))
运行结果：

82
相等于从[10, 12, 14,...,96, 98]中取一个
上述这些参数必须为整数

random.choice(sequence)
从sequence中返回一个随机的元素，sequence可以是列表、元组或字符串

data = [1, 2, 3, 4, 5]
print(random.choice(data))
运行结果：

2


random.shuffle(x)
将列表元素顺序打乱

data = [1, 2, 3, 4, 5]
random.shuffle(data)
print(data)
运行结果：

[1, 4, 3, 2, 5]


random.sample(sequence, k)
从指定列表中随机获取k个元素作为一个片段返回，sample函数不会修改原有的序列

data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(random.sample(data, 5))
运行结果：

[1, 2, 5, 9, 6]
---------------------
【转载】仅作分享，侵删
作者：三木成森.
原文：https://blog.csdn.net/Asdzxc968/article/details/84930727

奈斯