python自动化测试学习笔记-7面向对象编程，类，继承，实例变量，邮件

时间：2023-03-09 21:35:45
python自动化测试学习笔记-7面向对象编程，类，继承，实例变量，邮件

面向对象编程（OOP）术语：

class TestClass(object):

  val1 = 100
   
  def __init__(self):
    self.val2 = 200
   
  def fcn(self,val = 400):
    val3 = 300
    self.val4 = val
    self.val5 = 500
 if __name__ == '__main__':
  inst = TestClass()
    
  print TestClass.val1
  print inst.val1
  print inst.val2
  print inst.val3
  print inst.val4 
  print inst.val5

类：TestClass是一个类，用户定义的一个对象，定义一类对象的属性特点，是一个模型，模具，通用的；定义类的时候类名首字母都大写。

类变量：类变量紧接在类名后面定义，可以直接由类名直接调用，也可以由对象调用，val1是一个类变量，也叫做类属性，类属性应该是为其实例所共享的

构造函数：构造函数，是类在初始化的时候会自动执行它，如果你要在实例化的时候传入一些参数，那么你就可以在init这个函数中写参数

析构函数：实例被销毁的时候会执行析构函数 def  __del__(self): print('over')

del bus#销毁一个实例的时候会调用析构函数，如果没有销毁的代码，则在程序运行完以后自动执行析构函数

成员变量：val2是成员变量，可以由类的对象来调用，这里可以看出成员变量一定是以self.的形式给出的，因为self的含义就是代表实例对象；
                 val3不是成员变量，只是fcn方法里边的一个局部变量
                 val4和val5 也不是成员变量，它没有在构造函数中初始化
方法：方法是类里边的方法
实例化：创建一个类的实例.就比方把一个汽车模型造成一个实际的汽车，这个过程就叫做实例化，造出来的汽车就叫做实例。
             一个类可以有多个实例
             对象就是类的一个实例
实例变量：一个方法内定义的变量只属于一类的当前实例.
为了区分类变量和实例变量，我们来看一个例子，从一个帖子看到的，讲的比较详细 http://python.jobbole.com/85100/
class AAA():
    aaa = 10

# 情形1
obj1 = AAA()
obj2 = AAA()
print(obj1.aaa,obj2.aaa,AAA.aaa)

# 情形2
obj1.aaa += 2
print(obj1.aaa,obj2.aaa,AAA.aaa)

# 情形3
AAA.aaa += 3
print(obj1.aaa, obj2.aaa,AAA.aaa)
Python中属性的获取
对于属性，我们通常采用类.属性或实例.属性的形式调用。
例如上例中的AAA.aaa属于类.属性形式，obj1.aaa属于实例.属性的形式

Python中属性的设置
对于属性的设置我们通常采用类.属性 = 值或实例.属性 = 值的形式
例如obj1.aaa = 3

上例中obj1.aaa += 2等价于obj1.aaa = obj1.aaa + 2，这句话包含了属性获取及属性设置两个操作

上面我们指出obj.aaa += 2包含了属性获取及属性设置两个操作。即obj1.aaa += 2等价于obj1.aaa = obj1.aaa + 2。
其中等式右侧的obj.aaa属于属性获取，其规则是按照上面提到的查找规则进行，即，这时候，获取到的是AAA的属性aaa，所以等式左侧的值为12。
第二个操作是属性设置，即obj.aaa = 12。当发生属性设置的时候，obj1这个实例对象没有属性aaa，因此会为自身动态添加一个属性aaa。
由于从对象的角度，类对象和实例对象属于两个独立的对象，所以，这个aaa属性只属于obj1，也就是说，这时候类对象AAA和实例对象aaa各自有一个属性aaa。
那么，在情形3中，再次调用obj1.aaa时，按照属性调用查找规则，这个时候获取到的是实例对象obj1的属性aaa，而不是类对象AAA的属性aaa。

我们查看执行结果：

10 10 10
12 10 10
12 13 13

self 的用法self代表类的实例，而非类。定义时需要而调用时又不需要。

Self

是类方法特有的一个参数，普通函数是没有的。定义类方法时，必须有一个额外的参数，并且他必须是第一个参数，它就是self。要注意的是，调用类方法时，并不需要给这个参数赋值，Python会提供这个值。这个特别的参数指对象本身，代表当前对象的地址。按照惯例它的名称是self，你也可以定义成其它名字,但是最好还是使用约定俗成的self。

class My():
    def __init__(self,name):
        self.name=name
        self.cry()

    def cry(self):
        print('cry')

    def learn(self):
        self.skill=['开车']

    def my_self(self):
        print('我的名字【%s】,我会【%s】'%(self.name,self.skill))

我们先实例化一个对象：

pyf=My('pei')

直接执行查看结果打印：cry

在调用cry的时候self可以不用写，指的就是他自己

我们再调用learn和my_self

p1=My('pei')
p1.learn()
p1.my_self()

执行查看结果：

cry
我的名字【pei】,我会【['开车']】

p1=My('pei')
p1.learn()
p1.skill.append('抽烟')
p1.my_self()
执行查看结果：cry
我的名字【pei】,我会【['开车', '抽烟']】，可以看到打印出来的skill，p1.skill.append('抽烟')对类的属性进行的设置
实例变量：必须在实例化以后才能使用
class Person(object):
    country='China'#类变量，直接在类里边定义的,公共的属性
    def __init__(self,name,age,sex):
        self.name=name#实例变量，必须实例化之后才能用
        self.age=age
        self.sex=sex
    def say_my_country(self):
        print(self.country)
# sss=Person('sss',33,'男')
print(Person.name)#不实例化的话是不会执行的
print(Person.country)#类变量不实例化也能调用
实例变量必须在实例化以后才能使用，上述代码中，如果不对person进行实例化，直接调用其中的变量，执行会报错
aaarticlea/png;base64,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" alt="" />
类变量不用实例化也能执行:
class Person(object):
    country='China'#类变量，直接在类里边定义的,公共的属性
    def __init__(self,name,age,sex):
        self.name=name#实例变量，必须实例化之后才能用
        self.age=age
        self.sex=sex
    def say_my_country(self):
        print(self.country)
print(Person.country)#类变量不实例化也能调用
执行，可以打印出country
类方法，不需要实例化就能直接用，它可以使用类变量和类方法；
静态方法，不需要实例化就能直接使用，就是一个普通的函数，写在类里边而已，但是它不能调用类里边其他的函数，不能使用类变量和类方法，也不能用self
看下面的例子：
import redis

class MyRedis():
    xiaolei='hahaha'
    def __init__(self,host,password='',port=6379):
        self.__host=host
        self.passwd=password
        self.port=port
        self.__coon_redis()
    def __coon_redis(self):
        self.coon=redis.Redis(host=self.__host,password=self.passwd,port=self.port)
    def get(self,k):
        print('__host...',self.__host)
        return self.coon.get(k).decode()

    @staticmethod #静态方法 ，不需要实例化，但不能使用类方法
    def othor():
        print('woshi qita')
    @classmethod #类方法，也不需要实例化，直接就能用，它比静态方法高级一些，可以使用类变量和类方法
    def class_fun(cls):
        print(cls.xiaolei)
    @classmethod
    def class_fun2(cls):
        print('我是方法2')

MyRedis.class_fun2()
MyRedis.class_fun()
#都可以直接调用运行
 #继承
继承：如果定义的类有很多重复的功能，那就可以把这些重复的功能定义成父类，父类有的一些属性，变量子类都有，
面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过继承机制。
基类：父类，也叫基类，假如我需要定义几个类，而类与类之间有一些公共的属性和方法，这时我就可以把相同的属性和方法作为基类的成员，而特殊的方法及属性则在本类中定义，这样只需要继承基类这个动作，就可以访问到基类的属性和方法了，它提高了代码的可扩展性。
继承特点：

# 1.子类继承父类，子类拥有父类的所有属性和函数

# 2.子类继承父类，子类可以用自己独有的属性和函数,但是父类不可以使用子类独有的属性和函数

# 3.子类继承父类，子类可以重写父类的函数
例子： 


class Person(object):#父类
    def __init__(self,name,height,weigth): #构造函数
        self.name=name
        self.height=height
        self.weight=weigth
    def learn(self): #定义一个函数
        print('woaixuexi')

class Women(Person):#子类
    def __init__(self,name,heigth,weigth,age):#继承父类时，如有新加的，自己添加额外的元素
        Person.__init__(self,name,heigth,weigth) # 子类不会自动调用父类的构造函数，需要手动调用一下，，要加入父类方法的引用
        self.age=age#绑定
    def aihao(self):
        print('用户姓名：{name},用户身高：{heigth},用户体重：{weigth}，用户年龄:{age},用户总资产：{moneys}'
              .format(name=self.name, heigth=self.height, weigth=self.weight, age=self.age, moneys=10000))
    def skill(self): #继承父类的方法
        Person.learn(self)#需要调用

pyf=Women('pei','180cm','80jin','23')
pyf.aihao()
pyf.skill()




查看执行结果：


用户姓名：pei,用户身高：180cm,用户体重：80jin，用户年龄:23,用户总资产：10000
woaixuexi




########################################################################################################3


#邮件


python中发送邮件，用到了smtplib模块，和email模块首先要先导入该模块


剩下的就是发送邮件的过程了，


1、链接服务器，


2、登录邮箱，


3、发送服务请求


4、退出



以下是不带附件的邮件发送：




import smtplib
from email.mime.text import MIMEText
email_host='smtp.163.com'#邮箱的服务器地址
email_user='test@jzjz.com'#邮箱地址
email_pwd='test!123'#邮箱密码，#口令,QQ邮箱是输入授权码，在qq邮箱设置 里用验证过的手机发送短信获得，不含空格
email_list='test@qq.com,test@126.com'#j接收邮件地址
msg=MIMEText('新的一年，大家加油啊')#邮件内容
msg['Subject']='欢迎新同学'#邮件主题
msg['From']=email_user#发件人
msg['To']=email_list#接收人
smtp=smtplib.SMTP(email_host,port=25)#链接邮箱，传入邮箱地址端口号，SMTP端口号是25
# #smtp=smtplib.SMTP_SSL(email_host,port=465)#,QQ邮箱添加了安全连接发件箱地址是qq邮箱的话用这个
smtp.login(email_user,email_pwd)#登录邮箱
smtp.sendmail(email_user,email_list,msg.as_string())#发送邮件
smtp.quit()#退出
print('邮件发送成功')




如果要发送带附件的邮件，需要导入MIMEMultipart





import smtplib
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText



email_host='smtp.163.com'#邮箱的服务器地址
email_user='test@jzjz.com'#邮箱地址
email_pwd='test!123'#邮箱密码，#口令,QQ邮箱是输入授权码，在qq邮箱设置 里用验证过的手机发送短信获得，不含空格
email_list='test@qq.com,test@126.com'#j接收邮件地址
msg=MIMEMultipart()
file='实例变量.py'
att=MIMEText(open(file,encoding='utf-8').read())#打开文件，读取文件内容
att["Content-type"]='application/octet-stream'
att["Content-Disposition"]='attachment;filename="%s"'%file
msg.attach(att)#把创建好的附件添加到正文里边
msg.attach(MIMEText('正文，其他请查看附件'))#添加邮件内容
msg['Subject']='测试邮件主题'#邮件主题
msg['From']=email_user
msg['To']=email_list
smtp=smtplib.SMTP(email_host,port=25)
smtp.login(email_user,email_pwd)
smtp.sendmail(email_user,email_list,msg.as_string())
smtp.quit()
print('chenggong')