三元运算
三元运算，又称三目运算，主要作用是减少代码量，是对简单的条件语句的缩写。
书写格式：
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
深浅拷贝
1、对于数字和字符串而言，赋值、浅拷贝和深拷贝无意义，因为其永远指向同一个内存地址
只要是拷贝，不管是深拷贝还是浅拷贝以及赋值，其地址id都是一样的。
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
###由此可以看出字符串和数字类型的深拷贝，其内存指向的是同一块内存###
画图说明：
2、对于列表、元组、字典而言，浅拷贝只拷贝最外层，深拷贝是全部拷贝，除了最底层的值（数字、字符串）不变。
值是拷贝的索引
#赋值
n1 = {"k1":"","k2":"tina",'k3':['beauty',123]}
n2 = n1
print(id(n1),id(n2))
执行结果如下：
1003839407944 1003839407944 # ###结合上面数字字符串的内容可以看出任何类型的赋值，其内存指向的是同一块内存###
#浅拷贝（在内存中开创一块空间，创建第一层数据，相当于只拷贝了索引）
import copy
n1 = {"k1":"","k2":"tina",'k3':['beau',123]}
n2 = copy.copy(n1)
print(id(n1),id(n2))
执行结果如下：
715111778248 712964936072
#内存地址是不一样的
#深拷贝（在内存中将与所有的数据重新创建一份，但由于python内部对数字和字符串的优化：永远指向同一块内存，所以最后一层不改变）
import copy
n1 = {"k1":"","k2":"tina",'k3':['beau',123]}
n2 = copy.deepcopy(n1)
print(id(n1),id(n2))
执行代码如下：
205036701640 205037113416
函数
1、概念：
- 面向过程编程：
根据业务逻辑从上到下实现功能，其往往用一长段代码来实现指定功能，开发过程中最常见的操作就是粘贴复制，也就是将之前实现的代码块复制到现需功能处
- 函数式编程：
将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可，函数式编程最重要的是增强代码的重用性和可读性
- 面向对象编程：
对函数进行分类和封装，让开发“更快更好更强...”
2、函数的定义及使用：
def 函数名（参数）：
......
函数体
......
返回值 函数定义的关键点：
- def：表示函数的关键字
- 函数名：函数的名称，日后根据函数名调用函数
- 函数体：函数中进行一系列的逻辑计算，如：发送邮件、计算出 [11,22,38,888]中的最大数等
- 参数：为函数体提供数据
- 返回值：当函数执行完毕后，可以给调用者返回数据
返回值不是必须的，如果没有return语句，则Python默认返回值None。
函数名的命名规则（跟变量一样）：
函数名必须以下划线或字母开头，可以包含任意字母、数字或下划线的组合。不能使用任何的标点符号；
函数名是区分大小写的。
函数名不能是保留字。
3、函数的返回值：
返回值的作用是：判断函数是否执行成功，如果没有写return返回值时，默认返回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
4、函数参数：
（1）实现形式：
- 无参数时：
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%:
发送邮件("内存报警了。")
有参数实现
（2）参数的种类：
- 普通参数
形参，实参，传参
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 注：默认参数需要放在参数列表最后
- 动态参数
（a）一个星号的动态参数（*args）：
一个*号传递的参数默认定义为元祖类型
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'>
（b）两个星号的动态参数（**kwargs）：
两个*号传递的参数默认定义为字典类型
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'>
（c）*args和**kwargs的结合：
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默认认为传到了第一个*号的形参那里，第二个*号不会接收参数。通过第二种方式来传递参数，才能将匹配的参数传给对应的形参。
（d）动态参数的应用
动态参数的应用：
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
5、全局变量和局部变量：
全局变量也称为外部变量，它是在函数外部定义的变量。 它不属于哪一个函数，它属于一个源程序文件。其作用域是整个源程序。在函数中使用全局变量，一般应作全局变量说明。 只有在函数内经过说明的全局变量才能使用。全局变量的说明符为global。 但在一个函数之前定义的全局变量，在该函数内使用可不再加以说明。
局部变量也称为内部变量。局部变量是在函数内作定义说明的。其作用域仅限于函数内， 离开该函数后再使用这种变量是非法的。
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
*注：全局变量要大写，局部变量要小写