python基础第三天(1)

函数

    函数分为：内置函数，自定义函数，导入函数。

内置函数

    python为咱们提供的快捷方式

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

#!/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__"

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

#! /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、参数

为什么要有参数？

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

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

def 内存报警邮件()
    #发送邮件提醒
    连接邮箱服务器
    发送邮件
    关闭连接
 
while True：
 
    if cpu利用率 > 90%:
        CPU报警邮件（）
 
    if 硬盘使用空间 > 90%:
        硬盘报警邮件（）
 
    if 内存占用 > 80%:
        内存报警邮件（）

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'