书写格式：

 result = 值1 if 条件 else 值2

 即如果条件成立，则将值1赋给result变量，如果不成立，将值2赋给result变量

 eg：name = "tina" if 1==1 else "fei"

name = "tina" if 1!=1 else "fei"

print(name)

执行结果如下：

fei 

小练习：

a = 1 if True else 0

print(a)

b=1 if False else 0

print(b)

c = "Fire" if True else "Water"

print(c)

d = "Fire" if False else "Water"

print(d)

执行结果如下：

1

0

Fire

Water 

import copy

#数字类型

n1 = 222

print(id(n1))

#赋值

n2 = n1

print(id(n2))

#字符串类型

n1 = "tina is a beauty"

n2 = n1

print(id(n1),id(n2))

###执行结果如下：

1638075088

1638075088

948823211080 948823211080

###由此可以看出字符串和数字类型的赋值，其内存指向的是同一块内存###

#浅拷贝

n1 = 22

n2 = "asdf"

n3 = copy.copy(n1)

n4 = copy.copy(n2)

print(id(n1),id(n3))

print(id(n2),id(n4))

执行结果如下：

1638068688 1638068688

168374752680 168374752680

###由此可以看出字符串和数字类型的浅拷贝，其内存指向的是同一块内存###

#深拷贝

n3 = copy.deepcopy(n1)

n4 = copy.deepcopy(n2)

print(id(n1),id(n3))

print(id(n2),id(n4))

执行结果如下：

1638068688 1638068688

778961474984 778961474984 

###由此可以看出字符串和数字类型的深拷贝，其内存指向的是同一块内存###

画图说明：

#深拷贝（在内存中将与所有的数据重新创建一份，但由于python内部对数字和字符串的优化：永远指向同一块内存，所以最后一层不改变）

import copy

n1 = {"k1":"","k2":"tina",'k3':['beau',123]}

n2 = copy.deepcopy(n1)

print(id(n1),id(n2))

执行代码如下：

205036701640 205037113416

 def  函数名（参数）：

       ......

       函数体

       ......

       返回值

函数定义的关键点：

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

返回值不是必须的，如果没有return语句，则Python默认返回值None。

函数名的命名规则（跟变量一样）：

函数名必须以下划线或字母开头，可以包含任意字母、数字或下划线的组合。不能使用任何的标点符号；

函数名是区分大小写的。

函数名不能是保留字。

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

例如：

def 发送短信():

      发送短信的代码

     。。。。。。

      if 发送成功：

          return True

      else:

          return False

while True:

    result = 发送短信()

    if result == False:

        记录日志，短信发送失败...

 # 每次执行发送短信函数，都会将返回值自动赋值给result

 # 之后，可以根据result来写日志，或重发等操作   

###函数的返回值###

#返回一个值：

def onevalue(a,b):

    c = a + b

    return c

print(onevalue(1,2))

#返回多个值：

def secondvalue(a,b,c):

    d = a + b + c

    return(a,b,c,d)

print(secondvalue(11,22,33))

#返回多个值：

def somevalue(a,b):

 c = a + b

 return (a,b,c)

x,y,z = somevalue(1,2)

print('x:',x,'y:',y,'z:',z)

执行结果如下：

3

(11, 22, 33, 66)

x: 1 y: 2 z: 3

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%:

        发送邮件("内存报警了。")

有参数实现

形参，实参，传参

def email(p,text,subject):

    import smtplib

    from email.mime.text import MIMEText

    from email.utils import formataddr

    msg = MIMEText(text,'plain','utf-8')

    msg['From'] = formataddr(["菲菲",'wptawy@126.com'])

    msg['To'] = formataddr(['hhhh','424662508@qq.com'])

    msg['Subject'] = subject

    server = smtplib.SMTP('smtp.126.com',25)

    server.login('wptawy@126.com','WW.3945.59')

    server.sendmail('wptawy@126.com',[p,],msg.as_string())

    server.quit()

email("1156997553@qq.com","youjianneirong","zhuti")

##其中，p,text,subject就是形参，"1156997553@qq.com","youjianneirong","zhuti"是实参，即实参是执行函数时实际传入的值。

######### 定义函数 ######### 

# name 即为函数aa的形式参数，简称：形参

def aa(name):

    print name

######### 执行函数 #########

#  'tina' 就是函数func的实际参数，简称：实参

func('tina')

def fun(name, age = 18):

    print("%s:%d" %(name,age))

# 指定参数

fun('tina', 19)

# 使用默认参数

fun('tony')

执行结果如下：

tina:19

tony:18

注：默认参数需要放在参数列表最后

def f1(*a):

    print(a,type(a))

f1(123,456,[222,33])

执行结果如下：

(123, 456, [222, 33]) <class 'tuple'>

def func(*args):

    print（args）

# 执行方式一

func(11,33,4,4454,5)

执行结果如下：

(11, 33, 4, 4454, 5) <class 'tuple'>

# 执行方式二

li = [11,2,2,3,3,4,54]

func(*li)

执行结果如下：

(11, 2, 2, 3, 3, 4, 54) <class 'tuple'>

def f1(**a):

    print(a,type(a))

f1(k1=123,k2=456)

执行结果如下：

{'k1': 123, 'k2': 456} <class 'dict'>

def func(**kwargs):

    print(kwargs,type(kwargs))

# 执行方式一

func(name='tina',age=18)

执行结果如下：

{'name': 'tina', 'age': 18} <class 'dict'>

# 执行方式二

li = {'name':'tina', 'age':18, 'gender':'female'}

func(**li)

执行结果如下：

{'gender': 'female', 'name': 'tina', 'age': 18} <class 'dict'>

def f2(p,*a,**aa):

    print(p,type(p))

    print(a,type(a))

    print(aa,type(aa))

f2(11,22,33,k1=123,k2=456)

执行结果如下：

11 <class 'int'>

(22, 33) <class 'tuple'>

{'k2': 456, 'k1': 123} <class 'dict'>

def show (*arg,**kwargs):

    print (arg,type(arg))

    print (kwargs,type(kwargs))

show([11,22,33],[44],['a','b'],k1='v1',k2='v2')

执行结果：

　　([11, 22, 33], [44], ['a', 'b']) <class 'tuple'>

　　{'k2': 'v2', 'k1': 'v1'} <class 'dict'>

##结论：同时传递两个带*号的参数，在形参定义里，第一个形参只能是带一个*号，第二个形参只能是带两个*号，同时在参数传递的时候，第一个参数只能是普通的定义，第二个参数是字典的定义

def show (*arg,**kwargs):

    print (arg,type(arg))

    print (kwargs,type(kwargs))

li = [[11,22,33],[44],['a','b']]

di = {'k1':'v1','k2':'v2'}

show (li,di)

show(*li,**di)

执行结果：

　　([[11, 22, 33], [44], ['a', 'b']], {'k1': 'v1', 'k2': 'v2'}) <class 'tuple'>

　　{} <class 'dict'>

　　([11, 22, 33], [44], ['a', 'b']) <class 'tuple'>

　　{'k1': 'v1', 'k2': 'v2'} <class 'dict'>

##结论：通过第一种方式来传参数，python默认认为传到了第一个*号的形参那里，第二个*号不会接收参数。通过第二种方式来传递参数，才能将匹配的参数传给对应的形参。

动态参数的应用：

s = '{0} is {1}'

li = ['tina','charming']

re = s.format(*li)

print(re)

s = '{a} is {b}'

di = {'a':'tina','b':'charming'}

re = s.format(**di)

print(re)

执行结果为：

tina is charming

tina is charming

PERSON = "tina"

def fun1():

    a = 123

    global PERSON

    PERSON = "fei"

    print(a)

def fun2():

    a = 456

    print(PERSON)

    print(a)

fun1()

fun2()

执行结果如下：

123

fei

456