面向对象

"""面向对象的基本概念:
类(class):用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
实例化:创建一个类的实例，类的具体对象。
对象:通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量)和方法。
方法:类中定义的函数。
类变量:类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
"""


"""属性(指变量)
方法(指函数)
对象是类的实例()

类:在python当中是用来描述具有相同属性和方法的对象集合--类用class表达,就是用来存储函数和变量,用来归置这数据属性的.
一般类的命名要么是首字母大写,要么是驼峰式命名
实例化对象:
"""

# class TestCase():
#     def test01(self):                # self 表示这个函数是属于当前这个类的实例方法
#         print("第一个函数功能")
#     def test02(self):
#         print("第二个函数功能")
#     def test03(self):
#         print("第三个函数功能")
"""第一种方法:通过类之间调用类当中的方法"""
# TestCase().test01()
# TestCase().test02()
# """"第二种方法:实例化类的对象进行调用类当中的方法"""
# xiaoxiao = TestCase()      #xiaoxiao就是这个TestCase这个类的实例化对象
# xiaoxiao.test01()
# xiaoxiao.test02()

# xiaoxiao =aa=cc=vv= TestCase()

"""　　讲解：类相当于一个多个函数组成的家族，如果在这个dog大家族里有一个teddy，假如这个这个狗类当中具招手的功能，那么如果有一天
我需要这个来用这个一下招手的动作，那么我必须叫实例化一个teddy对象才可以让他给我招手"""
# class Dog(): #定义一个狗类
#     def wave(self): #定义一个实例方法
#         print("招手")
# Teddy = Dog() #实例化一个狗类的具体对象泰迪
# Teddy.wave()#通过泰迪调用招手这个动作

"""
实例属性:它是指类当中变量,用self表示它是类的实例
实例方法:它是指类当中的方法(函数),也是用self表示
"""
# class TestCase():
#     def __init__(self,name,age):     #它是用来初始化得功能-->一般用来定义实例属性
#         self.name = name
#         self.age = age
#         self.phone =12345678123
#
#     def test01(self,):
#         print(self.name)
#     def test02(self,):
#         print(self.age)
#     def test03(self,):
#         print(self.phone)
# TestCase("xiaoxiao",18).test01()
# TestCase("xiaoxn",20).test03()
# TestCase("xiaoxiao",21).test02()

"""名词解释:
1、定义类的时候_init_是一个构造函数，该函数是两个下划线开头和两个下划线结束，其作用就是当创建类的对象和
实例时系统会自动调用构造函数，通过构造函数对类进行初始化操作
2、定义类的时候_init_方法中有一个参数self，这也是类中的方法与普通函数的区别，类的中的方法必须有一个
参数self，而且位于参数列表的开头，在类中self就是代表类的当前类的实例（对象）自身，在python调用时无需传值
，python会将对象自动传给self接受"""



# class TestCase():
#     head = 1000    #可以被所有的实例方法所引用
#     """所有实例方法属性  共享的值,就是说它不是单独进行分配的"""
#     def __init__(self):
#         self.name = "admin"
#         self.age = "1994"
#         """每个实例方法单独拥有的变量--具体的某个属性值,它可以被所有的实例方法进行调用,但是它不可以被其
#         他类方法,静态等方法进行引用"""
#         """self 用来标识它是这个类的实例,熟悉或者方法,self不是固定的它可以用其他的来表示"""
#     @staticmethod    #用来修饰当前的方法
#     def case():        #静态方法,self不能引用其他类和静态
#         print(self.head)
#         print(self.name)
#     def test01(self):
#         print(self.name)
#     def test02(self):
#         print(self.age)
#         """实例方法可以引用实例数据,也可以使用类变量"""
#     def test03(self):
#         print(self.head)
# xiaoxiao = TestCase()
# xiaoxiao.test01()
# xiaoxiao.test03()

"""
类当中的方法:类方法,静态方法,实例方法
实例方法:用self表示,是一个实例方法
"""
"""类方法也需要用class装饰器进行修饰的,表示它是一个类方法,括号当中默认参数是cls表示类"""
"""静态方法需要通过static 装饰器进行修饰,它里面没有任何的默认参数"""
"""实例方法不需要装饰器,它当中第一个默认参数位self"""
# class TestCase():
#     head = "hello"
#     def __init__(self):
#         self.name = "admin"
#     @classmethod
#     def test01(cls):  #类方法只能使用类变量不能使用实例变量
#         print(cls.head)
#     @staticmethod
#     def test02():
#         print()
#     def test03(self):
#         print(self.name,self.head)
#
# a = TestCase()
# a.test01()
# a.test02()
# a.test03()

"""
实例方法，静态方法，类方法的区别
实例方法：
     1.实例方法形式参数当中默认带有slef
     2.实例方法不用装饰器进行修饰
     3.实例方法可以调用构造方法当中实例属性
     4.它可以调用类中的类变量
类方法:
     1.类方法默认的形式参数cls
     2.类方法需要用到@classmethod进行修饰
     3.类方法不能够调用构造方法当中的实例属性
     4.类方法可以调用类当中的类变量
     5.类方法可以直接通过类调用，实例对象调用
静态方法：
     1.静态方法当中没有默认的形式参数
     2.静态方法需要用到@staticmethod进行修饰
     3.静态方法可以直接通过类调用，实例对象调用
     4.不能够调用构造函数当中实例属性
     5.不能调用类当中的类变量

"""

"""私有属性(变量):可以被类的内部所使用,但不能被外部使用
实例方法:只能在类的内部进行使用,不能通过外部进行调用,也是使用下划线__进行命令它是私有的
"""
# class TestCase():
#     def __init__(self):
#         self.__name = "sdmin"
#         self.age = "12"
#     def __test(self):          #双下划线表示私有属性或者私有方法
#         print(1000)
#     def case(self):
#         TestCase().__test()     #在类当中去应用私有方法
#         print(self.__name)
# # a = TestCase()
# # a.case()
# # print(a.age)
# # # print(a.name)
# print(TestCase().age)
# print(TestCase().case())


"""类的第一个特性:
用于封装:
"""

"""数据库方法的封装:针对pymys.ql进行封装--->二次封装想要去打开数据库连接的话:
1.确定参数host,user,password,database, port 设置成形式参数在用于连接其他数据的时候,我就不需要在
进行更该源代码放在构造函数里面
2.获取到数据库的连接对象--->封装了一个自动连接数据的方法--->把需要连接的参数---传入connect里面
--在调用的过程当中他会自己去进行连接返回一个连接好的对象
3.封装方法:定义了一个查询第一行数据的方法:find_onefind_all update delete都可以进行封装
目的:就为了方便管理我的常用的功能---->
封装的优点:
优点:复用率高
     代码容易维护代码
    更容易阅读"""


# import pymysql
# class DataBase():
#     def __init__(self,host,user,password,database,port):
#         self.host =host
#         self.user =user
#         self.password =password
#         self.database =database
#         self.port =port
#     def connect(self):
#         db = pymysql.connect(host=self.host,
#                              user=self.user,
#                              password=self.password,
#                              database=self.database,
#                              port=self.port)
#
#         return db
#     def find_one(self,sql):         #查询第一行的数据
#         db=self.connect()
#         get=db.cursor()
#         get.execute(sql)
#         one=get.fetchone()
#         print(one)
#     def update(self):
#         pass
#     def delete(self):
#         pass
#     def insert(self):
#         pass
#
# if __name__=="__main__":
#     a=DataBase("192.168.2.114",
#                "root","123456",
#                "wuhan10",3306)
#
# # a.find_one("select * from wuhan10;")
#


"""继承的特性:
一个类继承另一个类时，会自动获得另一个类的所有属性和方法，被继承的类称之为父类，继承的类称为子类。
子类拥有父类所有的属性和方法，并且可以定义自己的属性和方法
继承的方法是建立类的基础之上
"""
"""第一种:通过实例化对象调用"""
# class Father():
#     head = 100000
#     def money(self):
#         print("100w")
#     def vehicle(self):
#         print("跑车")
# class Boy(Father):
#     def belle(self):
#         print("美女")
#     def bloc(self):
#         print("公司")
# # a = Boy()
# # a.belle()
# # a.bloc()
# # a.money()
# # a.vehicle()
# """通过类本身进行调用"""
# Boy().vehicle()
# print(Boy().head)

"""
构造函数的继承:父类有构造方法,子类没有时会自动继承父类所有的属性及方法
当子类有构造方法时,子类不会去继承父类的构造方法
"""
# class Test01():
#     def __init__(self):
#         self.name = "admin"
#     def aa(self):
#         print("kkkk")
# class Test02(Test01):
#     def __init__(self):
#         self.age =19
#     def cc(self):
#         print("zzz")
# x = Test02()
# x.cc()
# x.aa()
# # print(x.name)
# print(x.age)

"""多继承:"""
# class T1():
#     def aa1(self):
#         print("aa")
# class T2():
#     def aa2(self):
#         print("ss")
# class T3(T1,T2):         #同时继承多个类
#     def aa3(self):
#         print("dd")
# a = T3()
# a.aa3()
# a.aa1()
# a.aa2()

"""多态:基于继承的关系重写父类"""

# class T1():
#     def aa1(self):
#         print("aa")
# class T3(T1):
#     def aa1(self):
#         print("dd")
# a = T3()
# a.aa1()

# class Test01():
#     def boy(self,values):
#         print("一号男嘉宾")
# class Test02():
#     def boy(self,values):
#         print("二号男嘉宾")
# class Test03():
#     def boy(self,values):
#         print("三号男嘉宾")
# a = Test01()
# a.boy("一号女嘉宾")
# a = Test02()
# a.boy("二号女嘉宾")
# a = Test03()
# a.boy("三号女嘉宾")
from selenium import webdriver           ##下载slenium你可以进行导入

driver = webdriver.Chrome()
driver.get("https://www.baidu.com")

#pip install selenium==3.8.0 -i https://pypi.douban.com/simple

#http://chromedriver.storage.googleapis.com/index.html