您的位置：首页 > 编程语言 > Python开发

Python快速入门——函数

2018-12-13 10:51 537 查看

A、函数的定义和调用

1、函数的定义

[code]def 函数名(参数列表):
"可选函数文档字符串"
函数体
return 表达式

基于上述格式，下面对函数定义的规则进行说明：

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

2、函数调用

[code]def smcs():
return "三木成森"

print(smcs())

运行结果：

[code]三木成森

Python语言的函数支持嵌套

B、函数的参数

1、参数的传递

[code]def smcs(date):
return date

print(smcs("三木成森"))

运行结果：

[code]三木成森

2、默认参数

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

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

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

print(smcs())
print(smcs('你好，三木成森'))

运行结果：

[code]三木成森
你好，三木成森

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

3、不定长参数

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

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

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

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

只有形参

[code]def smcs(a, b, *data):
print(a)
print(b)
print(data)
return
smcs(1, 2)

运行结果：

[code]1
2
()

多于形参个数——元组

[code]def smcs(a, b, *data):
print(a)
print(b)
print(data)
return
smcs(1, 2, 3, 4, 5)

运行结果：

[code]1
2
(3, 4, 5)

多于形参个数——字典

[code]def smcs(a, b, **data):
print(a)
print(b)

print(data)

smcs(1, 2, n='n', m='m')

运行结果：

[code]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 函数里面使用，反之定义在函数外的变量叫做全局变量

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

name = smcs()       # 局部变量
print(name)

局部变量只能在函数内访问，全局变量，全局都可以访问

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

3、global和nonlocal关键字

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

1、global关键字

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

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

smcs()
print(name)
```
这是一个没有使用global关键字的代码，运行结果为：
```
[code]三木成森
```
可以看到运行结果为 三木成森 ，而不是 你好，三木成森 ，原因是因为，在函数里面虽然对name变量进行了修改，但是系统会把函数里面的name变量当做是一个局部变量，又因为函数里面的nama变量是一个局部变量，和外面的全局变量name没有任何关系，所以在函数里修改name变量的值没有用，可以试一下，在函数里面把name变量打印出来
```
[code]name = '三木成森'
def smcs():
name = '你好，三木成森'
print(name)

smcs()
print(name)
```
运行结果：
```
[code]你好，三木成森
三木成森
```
可以看到，函数里面的name输出为 你好，三木成森，外面的全局变量name输入结果仍然是 三木成森
使用global关键字
加上global关键字的代码：
```
[code]name = '三木成森'
def smcs():
global name
name = '你好，三木成森'

smcs()
print(name)
```
运行结果为：
```
[code]你好，三木成森
```
可以看到，函数外部的全局变量name的值确实变成了 你好，三木成森

2、nonlocal关键字

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

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

不使用nonlocal关键字

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

smcs()

运行结果：

[code]三木成森

使用nonlocal关键字

[code]def smcs():
name = '三木成森'
def sm():
nonlocal name
name = '你好，三木成森'
sm()
print(name)

smcs()

运行结果：

[code]你好，三木成森

D、匿名函数

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

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

lambda调用

[code]name = lambda a, b: a+b
print(name('三木', '成森'))

运行结果：

[code]三木成森

需要注意的是，使用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()等

[code]import time;    # 引入time模块

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

运行结果：

[code]现在的时间戳为： 1544612747.7893069

2、格式化时间戳

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

[code]timer.strftime(format[, t])

format：格式字符串
t：可选参数，是一个struct_time对象

[code]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]) 1fa48 接受时间元组并返回一个可读的形式为"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模块的有很广泛的方法用来处理年历和月历，比如打印某月的月历

[code]import calendar;    # 引入calendar模块

rl = calendar.month(2019,12)
print(rl)

运行结果：

[code]   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月）。

[code]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模块

[code]import random

random.random()
返回0与1之间的浮点数，范围是0<=N<1.0
```
[code]print(random.random())
```
运行结果：
```
[code]0.2829958140690443
```
random.uniform(a, b)
返回a与b之间的浮点数N，如果a<b则取值范围是：a<=N<=b，反之则是：b<=N<=a
```
[code]print(random.uniform(3, 4))
```
运行结果：
```
[code]3.7977128084339826
```
random.randint(a, b)
返回随机数N，取值范围是：a<=N<=b
```
[code]print(random.randint(1, 10))
```
运行结果：
```
[code]5
```
注意：a和b必须为整数，并且a的值一定要小于b
random.randrange(start, stop, step)
返回指定递增基数集合中的一个随机数，基数默认为1，start表示开始，包含在范围中，stop表示结束，不包含在范围中，step表示基数
```
[code]print(random.randrange(10, 100, 2))
```
运行结果：
```
[code]82
```
相等于从[10, 12, 14,...,96, 98]中取一个
上述这些参数必须为整数
random.choice(sequence)
从sequence中返回一个随机的元素，sequence可以是列表、元组或字符串
```
[code]data = [1, 2, 3, 4, 5]
print(random.choice(data))
```
运行结果：
```
[code]2
```

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

[code]data = [1, 2, 3, 4, 5]
random.shuffle(data)
print(data)

运行结果：

[code][1, 4, 3, 2, 5]

random.sample(sequence, k)
从指定列表中随机获取k个元素作为一个片段返回，sample函数不会修改原有的序列
```
[code]data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(random.sample(data, 5))
```
运行结果：
```
[code][1, 2, 5, 9, 6]
```

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航