面向对象初级

一、如何创建类

　　class 类名：

　　　　pass

二、创建方法

　　1、普通方法

　　　　obj=类()

　　　　obj.方法名()

　　　　实例：

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# author by lh

class bar:
   def main(self, a):
        print(a)

obj = bar()
obj.main(2)      #self指调用方法的对象

　　

　　2、构造方法

　　　　obj=类(参数)

　　　　实例：

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# author by lh

class bar:
    def __init__(self, name, age):     #类名（）调用时，自动执行__init__（封装）
        self.n = name
        self.a = age

    def main(self):
        print(self.n, self.a)

z = bar('lh', 18)        #参数为__init__中的参数
z.main()

　　

三、适用场景

　　如果多个函数中有一些相同参数时，转换成面向对象

　　

class DataBaseHelper:
    
        def __init__(self, ip, port, username, pwd):
            self.ip = ip
            self.port = port
            self.username = username
            self.pwd = pwd
        
        def add(self,content):
            # 利用self中封装的用户名、密码等   链接数据
            print('content')
            # 关闭数据链接
        
        def delete(self,content):
            # 利用self中封装的用户名、密码等   链接数据
            print('content')
            # 关闭数据链接
        
        def update(self,content):
            # 利用self中封装的用户名、密码等   链接数据
            print('content')
            # 关闭数据链接
            
        def get(self,content):
            # 利用self中封装的用户名、密码等   链接数据
            print('content')
            # 关闭数据链接

s1 = DataBaseHelper('1.1.1.1',3306, 'lh', '123')

　　

四、面向对象三大特性

　　1、封装

　　　　

　　2、继承

　　　　（1）继承　

class F:
    def f1(self):
        print('f1')

    def f2(self):
        print('f2')


class S(F):
    def f3(self):
        print('f3')

obj = S()
obj.f3()
obj.f1()

　　

　　　　（2）重写（两种方式）

　　　　　　a、super(派生类名，self).基类中的方法名(参数)

　　　　　　b、基类方法名.基类中的方法名(self，参数)

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# author by lh

class F:
   def f1(self):
        print('F.f1')

    def f2(self):
        print('F.f2')


class S(F):
    def f3(self):
        print('S.f3')

    def f2(self):
        super(S, self).f2()
       #重写是为了既想调用基类中的方法，又想调用派生类中的方法（两个方法相同）
        # F.f2(self)
        print('S.f2')

obj = S()
obj.f2()

　　

　　　　（3）self永远是执行该方法的调用者

　　　　（4）Python中支持多继承

　　　　　　　a、从左侧基类开始

　　　　　　　b、左侧基类找完之后再找右边基类

　　　　　　　c、如果有左侧的基类和右侧的基类有相同的基类时，相同的基类最后执行

　　3、多态

　　　　　　Python中原生就是多态的

五、静态字段与静态方法

　　1、字段

　　　　（1）普通字段：保存在对象中，执行只能通过对象访问

　　　　（2）静态字段：保存在类中，执行可以通过对象访问也可以通过类访问　　

　　　　（3）实例：

class province:
     country = '中国'          #静态字段

     def __init__(self, name):     
         self.name = name           #普通字段
 
 
print(province.country)
obj = province('河北')
print(obj.name)

　　

　　2、方法

　　　　（1）普通方法：保存在类中，由对象来调用，self=》对象

　　　　（2）静态方法：保存在类中，由类直接调用

　　　　（3）类方法：保存在类中，由类直接调用，cls=》当前类

　　　　（4）实例：

class foo:
    def bar(self):          #普通方法
        print('abc')

    @staticmethod           #静态方法
    def sta():
        print('123')

    @staticmethod           #带参数的静态方法
    def stat(a1, a2):
        print(a1, a2)

    @classmethod            #类方法
    def classmd(cls):
        print('classmd')

    @classmethod                  #带参数的类方法
    def classmth(cls,a1,a2):
        print(a1,a2)

obj = foo()
obj.bar()               #直接通过对象调用
foo.sta()               #通过类调用
foo.stat(1, 2)          #通过类调用
foo.classmd()           #通过类调用
foo.classmth(1,2)       #通过类调用

　　

　　3、property：不用括号，直接调用

　　　　实例：

class bar:
    @property
    def foo(self):
        print('666')
        return 1
obj=bar()
ret=obj.foo    # 不用括号，直接调用
print(ret)

　　

　　实例：

class pagenum:
    def __init__(self, current_page):
        try:                                  #当输入除了数字之外的字符时，自动跳到第一页
           p = int(current_page)
        except Exception as e:
            p = 1
        self.page = p                      #将输入的页码赋值

    @property
    def start(self):
        val = (self.page - 1) * 10                 #每页的开始值
        return val

    @property
    def end(self):
        val = self.page * 10                #每页的结束值
        return val


li = []
for i in range(1000):
    li.append(i)

while True:
    p = input('请输入页码：')
    obj = pagenum(p)                        # 执行__init__方法，将输入的页码传入
    print(li[obj.start:obj.end])            # 打印