python基础第三天(1)

时间:2020-12-17 20:51:43

函数

    函数分为:内置函数,自定义函数,导入函数。

内置函数

    python为咱们提供的快捷方式

python基础第三天(1)

vars()---针对脚本的,找到这个脚本中的所有变量。

python基础第三天(1)python基础第三天(1)
#!/usr/bin/env python
#
-*- coding:utf-8 -*-
name = 'sun'
print vars()


E:\python
>python test.py
{
'name': 'sun',
'__builtins__': <module '__builtin__' (built-in)>,
'__file__': ' ####表示这个文件的路径,
test.py',
'
__package__': None,
'__name__': '__main__',
'__doc__': None} ###注释 ,文件的注释。
默认在顶部 “”“ ”“” 这样注释,那么doc就会取到这个值。

###被执行的脚本,他的__name__的值就等于__main__,(主程序,也就是总的入口,我先执行谁)其他的都不等于

一般我们都在自己写的脚本最下面,都写
if __name__=="__main__"
vars

reload(temp)---import导入了一次,python就永久能用这个模块了,但是要是想在导入一次,必须要主动的在导入一次这个模块,才可以。

is  ---比对的是地址

divmod(10,1),---分页(取两个数的商和余数)

pow(2,11)---2的11次方

len()--某个序列的长度

all()---接收一个序列,判断,所有的值时真的,就为真,否则为假。

>>> li = ['sun','',18]
>>> all(li)
False
>>> li2 = ['sun',18]
>>> all(li2)
True

any()--都是假的,才是false.

>>> li3 = ['sun','',18]
>>> any(li3)
True
>>> li3 = ['','']
>>> any(li3)
False

chr(65)--asii码和数字转换

ord(‘a’)--也是转换用的,返回一个数字

hex()---16进制

oct()---8进制

bin()--2进制

range()

xrange()

enumerate() 枚举

>>> li = [11,22,33,44,55]
>>> for k,v in enumerate(li):
... print k,v
0 11

1 22

2 33

3 44

4 55

>>> for k,v in enumerate(li,1):##序号从1开始

1 11

2 22

3 33 

4 44

5 55

自定义函数

一、背景

在学习函数之前,一直遵循:面向过程编程,即:根据业务逻辑从上到下实现功能,其往往用一长段代码来实现指定功能,开发过程中最常见的操作就是粘贴复制,也就是将之前实现的代码块复制到现需功能处,如下

while True:
if cpu利用率 > 90%:
#发送邮件提醒
连接邮箱服务器
发送邮件
关闭连接

if 硬盘使用空间 > 90%:
#发送邮件提醒
连接邮箱服务器
发送邮件
关闭连接

if 内存占用 > 80%:
#发送邮件提醒
连接邮箱服务器
发送邮件
关闭连接

腚眼一看上述代码,if条件语句下的内容可以被提取出来公用,如下:这也就是函数式编程

 def email(arg):####定义了一个发邮件的函数,arg是参数
print arg
连接邮箱服务器
发送邮件
关闭连接
if __name__ == '__main__':  ###来个一个起始的函数,提供一个入口。
while True:
if cpu > 90%:
#发送邮件(
'CPU报警')
alert = "cpu问题"
email(alert)
if disk > 90%:
alert = "cpu问题"
#发送邮件('硬盘报警')
email(alert)
if mem > 80%:
email()
python基础第三天(1)python基础第三天(1)
#! /usr/bin/env python
#
-*- coding:utf-8 -*-
import smtplib
from email.mime.text import MIMEText
from email.utils import formataddr
def email(message):
msg
= MIMEText(message, 'plain', 'utf-8')
msg[
'From'] = formataddr(["",'发信用户'])
msg[
'To'] = formataddr(["qq",'收信用户'])
msg[
'Subject'] = "孙的报警"
server
= smtplib.SMTP("smtp.fang.com", 25)
server.login(
"发信用户", "密码")
server.sendmail(‘发信用户
', ['收心用户',], msg.as_string())
server.quit()
email(
'不好了,有报警了')
报警短信模块如下

 完整的监控脚本

#! /usr/bin/env python
#
-*- coding:utf-8 -*-
import smtplib
from email.mime.text import MIMEText
from email.utils import formataddr
def email(message):
msg
= MIMEText(message, 'plain', 'utf-8')
msg[
'From'] = formataddr(["",'发件邮箱'])
msg[
'To'] = formataddr(["qq",'收件@163.com'])
msg[
'Subject'] = "sun的报警"
server
= smtplib.SMTP("smtp.fang.com", 25)
server.login(
"发件", "密码")
server.sendmail(
'发件', ['收件',], msg.as_string())
server.quit()

if __name__ == '__main__':
cpu
= 100
disk
= 500
ram
= 50
for i in range(1):
if cpu > 90:
alert
= u"cpu出现问题"
email(alert)
if disk > 90:
alert
= u"disk出现问题"
email(alert)
if ram > 80:
alert
= u"ram出现问题"
email(alert)

 对于上述的两种实现方式,第二次必然比第一次的重用性和可读性要好,其实这就是函数式编程和面向过程编程的区别:

  • 函数式:将某功能代码封装到函数中,日后便无需重复编写,仅调用函数即可
  • 面向对象:对函数进行分类和封装,让开发“更快更好更强...”

函数式编程最重要的是增强代码的重用性和可读性

二、 函数的定义和使用

  def 函数名(参数):

          ...     函数体     ...

函数的定义主要有如下要点:

  • def:表示函数的关键字
  • 函数名:函数的名称,日后根据函数名调用函数
  • 函数体:函数中进行一系列的逻辑计算,如:发送邮件、计算出 [11,22,38,888,2]中的最大数等... 不自动执行,调用后才执行
  • 参数:为函数体提供数据
  • 返回值:当函数执行完毕后,可以给调用者返回数据。

以上要点中,比较重要有参数和返回值:

1、返回值

函数是一个功能块,该功能到底执行成功与否,需要通过返回值来告知调用者。

def 发送短信():

发送短信的代码...

if 发送成功:
return True #返回值
else:
return False

result = 函数() #这个意思是先去执行这个函数,如果函数有返回值,就付给result
while True:

# 每次执行发送短信函数,都会将返回值自动赋值给result
# 之后,可以根据result来写日志,或重发等操作
# 如果函数没有写返回值,那么他默认就返回none
# 如果有返回值可以赋值给某个变量

result
= 发送短信()
if result == False:
记录日志,短信发送失败...

2、参数

为什么要有参数?

python基础第三天(1)python基础第三天(1)
def CPU报警邮件()
#发送邮件提醒
连接邮箱服务器
发送邮件
关闭连接

def 硬盘报警邮件()
#发送邮件提醒
连接邮箱服务器
发送邮件
关闭连接

def 内存报警邮件()
#发送邮件提醒
连接邮箱服务器
发送邮件
关闭连接

while True:

if cpu利用率 > 90%:
CPU报警邮件()

if 硬盘使用空间 > 90%:
硬盘报警邮件()

if 内存占用 > 80%:
内存报警邮件()
上例中无参数
python基础第三天(1)python基础第三天(1)
def 发送邮件(邮件内容)

#发送邮件提醒
连接邮箱服务器
发送邮件
关闭连接


while True:

if cpu利用率 > 90%:
发送邮件(
"CPU报警了。")

if 硬盘使用空间 > 90%:
发送邮件(
"硬盘报警了。")

if 内存占用 > 80%:
发送邮件(
"内存报警了。")
上例中有参数

函数的有三中不同的参数:

  • 普通参数
  • 默认参数
  • 动态参数
                                           普通参数:
    #
    ######### 定义函数 #########
    # name 叫做函数func的形式参数,简称:形参
    def func(name):
    print name

    # ######### 执行函数 #########
    #
    'wupeiqi' 叫做函数func的实际参数,简称:实参
    func('wupeiqi')

     例如:

       def email(message):    ####形式参数,行参,他没有实际的值,他只是一个指针。他可以随便定义。可以定义多个参数,但是调用的时候就要带多个了。

          msg = mimetext(message)

         ###实际参数,实参,他是调用这个函数的时候来的。email("报警")

        形式参数传递给实际参数。

                                            默认参数
    def
    func(name, age = 18):
    print "%s:%s" %(name,age)

    # 指定参数,他会覆盖默认参数
    func('wupeiqi', 19)
    # 使用默认参数,不传,就使用默认参数
    func('alex')

    注:默认参数需要放在参数列表最后
                                 动态参数1
    def
    func(*args): #整合成一个元组,可以传递多个参数。
    print args


    # 执行方式一
    func(11,33,4,4454,5)
    (11,33,4,4454,5)
    # 执行方式二
    li = [11,2,2,3,3,4,54]
    func(
    *li) #这样传参数,就代表我真正要传的值,而不用在给我在外层构造一层元组了。
    (11,2,2,3,3,4,54)
    func(li)#还会在外层给你构造一个元组
    ([11,2,2,3,3,4,54],)

    可以通过获取下标的形式来获取元素
    def func(*args):
    print func[0]
    func(11,22,33,44)
                                   动态参数2
    def
    func(**kwargs): ###整合成一个字典。只认识key---values的方式
    print kwargs


    # 执行方式一
    func(name='wupeiqi',age=18)

    # 执行方式二
    li = {'name':'wupeiqi', age:18, 'gender':'male'}
    func(
    **li)
                        动态参数3
    def
    func(*args, **kwargs): #单值和双值都可以传进来了。
    print args
    print kwargs

    format函数内部也是这么做的。

    >>> name = "i am {ss},age {dd}"
    >>> dic = {'ss':123,'dd':456}
    >>> name.format(**dic)
    'i am 123,age 456'