setInterval函数使用方法及小例

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了setInterval函数使用方法及小例相关的知识,希望对你有一定的参考价值。

参考技术A 1、setInterval() 方法可按照指定的周期(以毫秒计)来调用函数或计算表达式。

2、setInterval() 方法会不停地调用函数,直到 clearInterval(params) 被调用或窗口被关闭。由 setInterval() 返回的 ID 值可用作 clearInterval() 方法的参数。

    let id = setInterval(

        function()

            console.log('执行定时任务,id =',id)

        

    ,1000)

1、params必选参数

2、clearInterval 将清除返回为params参数的定时任务

    let id = setInterval(

            function()

    console.log('执行定时任务,id =',id)

            

        ,1000)

setTimeout(

    () =>

        clearInterval(id)

        console.log('5秒后将清除定时任务,id=',id)

    ,5000

)

1、web端,列表需要定时更新时

let id = setInterval(

            function()

                ...

                获取列表的请求

                ...

            

        ,1000)

2、web端,列表需要定时更新,在某一特定情况下需清除定时任务

let id = setInterval(

            function()

                ...

                   if(特定情况)

                        clearInterval(id)

                    else

                        ...

                            发送请求

                        ...

                    

                ...

            

        ,1000)

3、如果需要反复触发,可设置一个全局变量接收返回id值,触发时先清除id,再跑任务

let copyID = 0; // 全局变量

function reload()

    clearInterval(copyID)

    let id = setInterval(

            function()

                ...

                   if(特定情况)

                        clearInterval(id)

                    else

                        ...

                            发送请求

                        ...

                    

                ...

            

        ,1000)

copyID = id

python3 类的属性方法封装继承及小实例

 

Python 类

Python中的类提供了面向对象编程的所有基本功能:类的继承机制允许多个基类,派生类可以覆盖基类中的任何方法,方法中可以调用基类中的同名方法。

对象可以包含任意数量和类型的数据。

python类与c++类相似,提供了类的封装,继承、多继承,构造函数、析构函数。

在python3中,所有类最顶层父类都是object类,与java类似,如果定义类的时候没有写出父类,则object类就是其直接父类。

 
类定义

类定义语法格式如下:

class ClassName:
    <statement-1>
    .
    .
    .
    <statement-N>

类对象:创建一个类之后,可以通过类名访问、改变其属性、方法

实例对象:类实例化后,可以使用其属性,可以动态的为实例对象添加属性(类似javascript)而不影响类对象。

 
类的属性

可以使用点(.)来访问对象的属性

也可以使用以下函数的方式来访问属性:

    getattr(obj, name[, default]) : 访问对象的属性

    hasattr(obj,name) : 检查是否存在一个属性
    setattr(obj,name,value) : 设置一个属性。如果属性不存在,会创建一个新属性

    delattr(obj, name) : 删除属性

 

Python内置类属性

    __dict__ : 类的属性(包含一个字典,由类的数据属性组成)

    __doc__ :类的文档字符串

    __name__: 类名

    __module__: 类定义所在的模块(类的全名是‘__main__.className‘,如果类位于一个导入模块mymod中,那么className.__module__ 等于 mymod)

    __bases__ : 类的所有父类构成元素(包含了以个由所有父类组成的元组)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
class Person:
    "Person类"
    def __init__(self, name, age, gender):
        print(‘进入Person的初始化‘)
        self.name = name
        self.age = age
        self.gender = gender
        print(‘离开Person的初始化‘)
    def getName(self):
        print(self.name)
= Person(‘ice‘18‘男‘)
print(p.name)  # ice
print(p.age)  # 18
print(p.gender)  # 男
print(hasattr(p, ‘weight‘))  # False
# 为p添加weight属性
p.weight = ‘70kg‘
print(hasattr(p, ‘weight‘))  # True
print(getattr(p, ‘name‘))  # ice
print(p.__dict__)  # {‘age‘: 18, ‘gender‘: ‘男‘, ‘name‘: ‘ice‘}
print(Person.__name__)  # Person
print(Person.__doc__)  # Person类
print(Person.__dict__)  # {‘__doc__‘: ‘Person类‘, ‘__weakref__‘: <attribute ‘__weakref__‘ of ‘Person‘ objects>, ‘__init__‘: <function Person.__init__ at 0x000000000284E950>, ‘getName‘: <function Person.getName at 0x000000000284EA60>, ‘__dict__‘: <attribute ‘__dict__‘ of ‘Person‘ objects>, ‘__module__‘: ‘__main__‘}
print(Person.__mro__)  # (<class ‘__main__.Person‘>, <class ‘object‘>)
print(Person.__bases__)  # (<class ‘object‘>,)
print(Person.__module__)  # __main__


类的方法

在类地内部,使用def关键字可以为类定义一个方法,与一般函数定义不同,类方法必须包含参数self,且为第一个参数。

 

类的专有方法:

    __init__ 构造函数,在生成对象时调用

    __del__ 析构函数,释放对象时使用

    __repr__ 打印,转换

    __setitem__按照索引赋值

    __getitem__按照索引获取值

    __len__获得长度

    __cmp__比较运算

    __call__函数调用

    __add__加运算

    __sub__减运算

    __mul__乘运算

    __div__除运算

    __mod__求余运算

    __pow__称方

 

__init__()方法是一种特殊的方法,被称为类的构造函数或初始化方法,当创建了这个类的实例时就会调用该方法,与c++中构造函数类似。只需在自定义的类中重写__init__()方法即可。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class Person:
    def __init__(self, name, age, gender):
        print(‘进入Person的初始化‘)
        self.name = name
        self.age = age
        self.gender = gender
        print(‘离开Person的初始化‘)
    def getName(self):
        print(self.name)
# Person实例对象
= Person(‘ice‘18‘男‘)
print(p.name)
print(p.age)
print(p.gender)
p.getName()
# 进入Person的初始化
# 离开Person的初始化
# ice
# 18
# 男
# ice


析构函数 __del__ ,__del__在对象消逝的时候被调用,当对象不再被使用时,__del__方法运行:

方法

  实例方法:只能通过实例调用,实例方法第一个定义的参数只能是实例本身引用

class Myclass:
    def foo(self):
        print(id(self),foo)

a=Myclass()#既然是实例对象,那就要创建实例
a.foo()#输出类里的函数地址
print(id(a))#输出类对象的地址

#结果地址一样

 

        类方法:定义类方法,要使用装饰器@classmethod,定义的第一个参数是能是类对象的引用,可以通过类或者实例直用

 
class Myclass:
@classmethod#类装饰器
    def foo2(cls):
        print(id(cls),foo2)
   #类对象,直接可以调用,不需要实例化
print(id(Myclass),yy)
Myclass.foo2()#直接可以调用

 

   静态方法:定义静态方法使用装饰器@staticmethod,没有默认的必须参数,通过类和实例直接调用

class Myclass:
@staticmethod#静态方法
    def foo3():
        print(foo3)

Myclass.foo3()#没有参数
a.foo3()
#结果foo3

 

 
类的封装

 python通过变量名命名来区分属性和方法的访问权限,默认权限相当于c++和java中的public

 
类的私有属性: __private_attrs:两个下划线开头,声明该属性为私有,不能在类地外部被使用或直接访问。在类内部的方法中使用时self.__private_attrs。

类的私有方法:__private_method:两个下划线开头,声明该方法为私有方法,不能在类地外部调用。在类的内部调用 self.__private_methods

 
虽然python不允许实例化的类访问私有数据,但可以使用 object._className__attrName 访问属性。其实python内部私有化的实现只是将attrName属性变为了_className__attrName而已

1
2
3
4
5
6
7
8
class Demo:
    __id = 123456
    def getId(self):
        return self.__id
temp = Demo()
# print(temp.__id)  # 报错 AttributeError: ‘Demo‘ object has no attribute ‘__id‘
print(temp.getId())  # 123456
print(temp._Demo__id)  # 123456


类的继承

面向对象的编程带来的主要好处之一是代码的重用,实现这种重用的方法之一是通过继承机制。继承完全可以理解成类之间的类型和子类型关系。

需要注意的地方:继承语法 class 派生类名(基类名)://... 基类名写作括号里,基本类是在类定义的时候,在元组之中指明的。

在python中继承中的一些特点:

    1:在继承中基类的构造(__init__()方法)不会被自动调用,它需要在其派生类的构造中亲自专门调用。使用super().__init__()或parentClassName.__init__()
    2:在调用基类的方法时,需要加上基类的类名前缀,且需要带上self参数变量。区别于在类中调用普通函数时并不需要带上self参数
    3:Python总是首先查找对应类型的方法,如果它不能在派生类中找到对应的方法,它才开始到基类中逐个查找。(先在本类中查找调用的方法,找不到才去基类中找)。

如果在继承元组中列了一个以上的类,那么它就被称作"多重继承" 。

语法:

派生类的声明,与他们的父类类似,继承的基类列表跟在类名之后。

多态

如果父类方法的功能不能满足需求,可以在子类重写父类的方法。实例对象调用方法时会调用其对应子类的重写后的方法

 

python3.3 类与继承 小例 
hon中的类提供了面向对象编程的所有基本功能:类的继承机制允许多个基类,派生类可以覆盖基类中的任何方法,方法中可以调用基类中的同名方法。

class Base:
    def __init__(self):
        self.data=[]
    def add(self,x):
        self.data.append(x)
    def addtwice(self,x):
        self.add(x)
        self.add(x)

# child extends base
class Child(Base):
    def plus(self,a,b):
        return a+b

oChild=Child()
oChild.add("str1")
oChild.add(999)
oChild.addtwice(4)
print(oChild.data)
print(oChild.plus(2,3))

 


对象可以包含任意数量和类型的数据。

python类与c++类相似,提供了类的封装,继承、多继承,构造函数、析构函数。

在python3中,所有类最顶层父类都是object类,与java类似,如果定义类的时候没有写出父类,则object类就是其直接父类。

 
类定义

类定义语法格式如下:

class ClassName:
    <statement-1>
    .
    .
    .
    <statement-N>

类对象:创建一个类之后,可以通过类名访问、改变其属性、方法

实例对象:类实例化后,可以使用其属性,可以动态的为实例对象添加属性(类似javascript)而不影响类对象。

 
类的属性

可以使用点(.)来访问对象的属性

也可以使用以下函数的方式来访问属性:

    getattr(obj, name[, default]) : 访问对象的属性

    hasattr(obj,name) : 检查是否存在一个属性
    setattr(obj,name,value) : 设置一个属性。如果属性不存在,会创建一个新属性

    delattr(obj, name) : 删除属性

 

Python内置类属性

    __dict__ : 类的属性(包含一个字典,由类的数据属性组成)

    __doc__ :类的文档字符串

    __name__: 类名

    __module__: 类定义所在的模块(类的全名是‘__main__.className‘,如果类位于一个导入模块mymod中,那么className.__module__ 等于 mymod)

    __bases__ : 类的所有父类构成元素(包含了以个由所有父类组成的元组)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
class Person:
    "Person类"
    def __init__(self, name, age, gender):
        print(‘进入Person的初始化‘)
        self.name = name
        self.age = age
        self.gender = gender
        print(‘离开Person的初始化‘)
    def getName(self):
        print(self.name)
= Person(‘ice‘18‘男‘)
print(p.name)  # ice
print(p.age)  # 18
print(p.gender)  # 男
print(hasattr(p, ‘weight‘))  # False
# 为p添加weight属性
p.weight = ‘70kg‘
print(hasattr(p, ‘weight‘))  # True
print(getattr(p, ‘name‘))  # ice
print(p.__dict__)  # {‘age‘: 18, ‘gender‘: ‘男‘, ‘name‘: ‘ice‘}
print(Person.__name__)  # Person
print(Person.__doc__)  # Person类
print(Person.__dict__)  # {‘__doc__‘: ‘Person类‘, ‘__weakref__‘: <attribute ‘__weakref__‘ of ‘Person‘ objects>, ‘__init__‘: <function Person.__init__ at 0x000000000284E950>, ‘getName‘: <function Person.getName at 0x000000000284EA60>, ‘__dict__‘: <attribute ‘__dict__‘ of ‘Person‘ objects>, ‘__module__‘: ‘__main__‘}
print(Person.__mro__)  # (<class ‘__main__.Person‘>, <class ‘object‘>)
print(Person.__bases__)  # (<class ‘object‘>,)
print(Person.__module__)  # __main__


类的方法

在类地内部,使用def关键字可以为类定义一个方法,与一般函数定义不同,类方法必须包含参数self,且为第一个参数。

 

类的专有方法:

    __init__ 构造函数,在生成对象时调用

    __del__ 析构函数,释放对象时使用

    __repr__ 打印,转换

    __setitem__按照索引赋值

    __getitem__按照索引获取值

    __len__获得长度

    __cmp__比较运算

    __call__函数调用

    __add__加运算

    __sub__减运算

    __mul__乘运算

    __div__除运算

    __mod__求余运算

    __pow__称方

 

__init__()方法是一种特殊的方法,被称为类的构造函数或初始化方法,当创建了这个类的实例时就会调用该方法,与c++中构造函数类似。只需在自定义的类中重写__init__()方法即可。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class Person:
    def __init__(self, name, age, gender):
        print(‘进入Person的初始化‘)
        self.name = name
        self.age = age
        self.gender = gender
        print(‘离开Person的初始化‘)
    def getName(self):
        print(self.name)
# Person实例对象
= Person(‘ice‘18‘男‘)
print(p.name)
print(p.age)
print(p.gender)
p.getName()
# 进入Person的初始化
# 离开Person的初始化
# ice
# 18
# 男
# ice


析构函数 __del__ ,__del__在对象消逝的时候被调用,当对象不再被使用时,__del__方法运行:

 
类的封装

 python通过变量名命名来区分属性和方法的访问权限,默认权限相当于c++和java中的public

 
类的私有属性: __private_attrs:两个下划线开头,声明该属性为私有,不能在类地外部被使用或直接访问。在类内部的方法中使用时self.__private_attrs。

类的私有方法:__private_method:两个下划线开头,声明该方法为私有方法,不能在类地外部调用。在类的内部调用 self.__private_methods

 
虽然python不允许实例化的类访问私有数据,但可以使用 object._className__attrName 访问属性。其实python内部私有化的实现只是将attrName属性变为了_className__attrName而已

1
2
3
4
5
6
7
8
class Demo:
    __id = 123456
    def getId(self):
        return self.__id
temp = Demo()
# print(temp.__id)  # 报错 AttributeError: ‘Demo‘ object has no attribute ‘__id‘
print(temp.getId())  # 123456
print(temp._Demo__id)  # 123456


类的继承

面向对象的编程带来的主要好处之一是代码的重用,实现这种重用的方法之一是通过继承机制。继承完全可以理解成类之间的类型和子类型关系。

需要注意的地方:继承语法 class 派生类名(基类名)://... 基类名写作括号里,基本类是在类定义的时候,在元组之中指明的。

在python中继承中的一些特点:

    1:在继承中基类的构造(__init__()方法)不会被自动调用,它需要在其派生类的构造中亲自专门调用。使用super().__init__()或parentClassName.__init__()
    2:在调用基类的方法时,需要加上基类的类名前缀,且需要带上self参数变量。区别于在类中调用普通函数时并不需要带上self参数
    3:Python总是首先查找对应类型的方法,如果它不能在派生类中找到对应的方法,它才开始到基类中逐个查找。(先在本类中查找调用的方法,找不到才去基类中找)。

如果在继承元组中列了一个以上的类,那么它就被称作"多重继承" 。

语法:

派生类的声明,与他们的父类类似,继承的基类列表跟在类名之后。

多态

如果父类方法的功能不能满足需求,可以在子类重写父类的方法。实例对象调用方法时会调用其对应子类的重写后的方法

 

python3.3 类与继承 小例 

class Base:
    def __init__(self):
        self.data=[]
    def add(self,x):
        self.data.append(x)
    def addtwice(self,x):
        self.add(x)
        self.add(x)

# child extends base
class Child(Base):
    def plus(self,a,b):
        return a+b

oChild=Child()
oChild.add("str1")
oChild.add(999)
oChild.addtwice(4)
print(oChild.data)
print(oChild.plus(2,3))



























































































































































































































































































以上是关于setInterval函数使用方法及小例的主要内容,如果未能解决你的问题,请参考以下文章

base_convert()函数探秘及小bug记录

flask小例

pytthon3 ---类的属性方法封装继承及小实例

setInterval的问题。

如何使用 SetInterval 函数和 'if' 使 div 弹出?

javascript函数setInterval和setTimeout的使用区别详解