python中实例方法

顾名思义，python中的自定义模块，就不是python自带的模块，而是通过自己来创建出来的。

自己创建的模块，估计自己也感觉到非常有趣了，因为自己能创，也能调用其它人创建的模块使用，在工作量上面是轻松多了，这边所谓的自建模块的后缀名是(.py),还是通过示例来解说一下。特别注意一下，自己创建的模块得放到同一文件夹里面，虽然python有指令可以跨文件夹调用，但结果是不理想的。因为调用一下，下次估计这个指令就失效了，别怪我没提醒大家。下面我创建了两个.py的文件。

zhichuan1.py

zhichuan2.py

我第二个文件可以调用我自己创建的第一个模块的内容。见示例图：

通过上面两张图片可以看出，我第二个模块可以导入第一个模块。省略了写现在时间的程序了，只用了导入语句import zhichuan1和zhichuan1.now_time()。这种自建的模块，在写程序时，只要程序员能够合理利用自己建的模块。再复杂的程序，也不再是难写的事了。请看这个程序运行的结果，见下图：

为了让有兴趣的朋友也可以试一下，我把程序代码分享如下：

zhichuan1.py内的程序如下：import time

def now_time():nt = time.localtime() s = ("%02d:%02d:%02d" % nt[3:6]) print(s) time.sleep(1)

zhichuan2.py内的程序如下：

import zhichuan1import time#两位朋友的问时间对话a=str(input("请输入第一位朋友的英文名字tila："))b=str(input("请输入第二位朋友的英文名字lisa："))if a=="tila":print("tila:lisa 我们坐了这么久的车，现在是几点了") time.sleep(5)else: print("你输错第一个朋友名字了")if b=="lisa": print("lisa:tila 等等，我看一下，现在是北京时间")else: print("你输错第二个朋友名字了")zhichuan1.now_time()time.sleep(10)

以上是一些简单的程序，主要讲明自建模块的优点。运行时，是运行第二个自建模块。赶快行动起来，程序高手都是练出来的，如果你有自己新创的模块也可以分享出来给我们。因为互相学习才能成长更快，才能让我们的技术有新的突破。

Python爬虫学习了一些时间，今天看到某网的文章，平时只是一部分一部分复制粘贴，有时甚至不让复制。于是想利用Python爬虫下载文章保存到本地。哈哈。为了便于学习理解，直接上代码加注释。重点学习稳中有降模块的用法。

from urllib.request import urlopen

from bs4 import BeautifulSoup #Beautiful Soup 是一个可以从HTML或XML文件中提取数据的Python库

import html5lib #html5lib 是一个 Ruby和 Python用来解析 HTML文档的类库,支持HTML5

import time # Python time时间模块

import os

import requests #requests是python的一个HTTP客户端库

from time import sleep #,使用sleep函数可以让程序休眠延时。

def Download_Novel(html): #定义一个下载文章函数。

bsObj=BeautifulSoup(html,'html5lib') #利用BeautifulSoup析html页面

chapter=bsObj.find("p",{"class","read-content j_readContent"}) #获取文章内容

title=bsObj.find("",{"class","j_chapterName"}) #获取文章标题。

print (chapter.get_text()) #打印出文章内容。

print (title) #打印出文章标题。

fo=open("d:/001.txt","a") #打开文件

fo.write(chapter.get_text())#写入文件

fo.close #close()方法用于关闭一个已打开的文件

bsoup=bsObj.find("a",{"id":"j_chapterNext"}) #获取下一章节文章内容

html2="http:"+bsoup.get('href')+""#获取下一章节文章URL

return (urlopen(html2))

html=urlopen("https://xxxxxxxxxx/chapter/5889870403237101/15810501355231395")

i=1

while(i<10): #下载章节数目

html=Download_Novel(html)

i=i+1

start = time.time() #程序运行开始时间

Download_Novel(html)

sleep(1) #让程序延时

c = time.time() - start #程序运行结束时间

print('保存文章结束，运行共耗时:%0.2f'%(c))

运行结果如下图：

文件内容保存到D盘的001.txt文件中。

文中不妥之处请朋友们指正！谢谢

题目：有四个数字：1、2、3、4，能组成多少个互不相同且无重复数字的三位数？各是多少？

程序分析：

可填在百位、十位、个位的数字都是1、2、3、4。组成所有的排列后再去掉不满足条件的排列。

程序源代码：

以上实例输出结果为：

使用列表形式，并计算总结：

将for循环和if语句综合成一句，直接打印出结果

参考方法(设置最大，最小值)：

python3 下参考方案：

参考方法：

python自带这个函数的

补充一下:

没事找事之位运算

考虑减少冗余判断和循环，做如下优化；

Python3 测试实例

加入了format函数

数量统计用个做自加就够了

参考：

说一下，对python面向对象的理解，并说明面向对象的三个特点。

1.面向对象是一种编程思想，符合人们的思考习惯，把执行者变为指挥者

把复杂的事情简单化，如果想完成意见事情，找到具有这样功能的对象

如果能找到，调用这个对象的功能，完成这件事情，如果找不到，创建

具有这样功能的对象，再调用完成这件事情。

2.面向对象是一种编程思想，是将数据封装到对象内部，通过对象的方法

来操作数据，通过对象和对象之间的相互的调用配合来完成整个功能的

过程。

面向对象的特点：封装：将有一定功能的代码封装起来，使用时调用即可、继承：将公共的属性和方法放在父类中，自己自考虑特有的属性和方法。多态：程序运行过程中，根据执行条件的不同，动态执行不同的操作代码的过程称为运行时多态。

1. 简答

1) 类对象和实例对象的区别

类对象就是类本身，当遇见类的时候，就会创建新的命名空间，命名空间

包含所有类变量和方法定义的名称。

实例对象就是通过类对象创建出来的实例（类对象实例化之后返回的

就是实例对象），用来存储实例属性和存储实例对象的引用。

2) 类属性和实例属性的区别

类属性：定义在类内部，方法外边，属于所有类对象和所有实例对象

调用：类对象.属性 = 值

实例属性：通过init初始化的变量和实例对象创建出来的属性

调用：实例对象.属性

3) 类方法和实例方法和静态方法的区别

类方法：必须有一个参数，这个参数表示为当前类对象，一般为cls,在

方法的头部加上@classmethod

实例方法：必须有一个参数，表示当前实例对象，一般是self

静态方法：普通函数的格式，不需要强制要求传递参数，在方法的头部

加上注释@staticmethod一般用于实例对象、类对象无关的

内容。

前面

一篇

文章我介绍了python面向对象的基本知识，链接在最下面。初步解释了面向对象和面向对象的优点，今天就开始正式用代码来展现面向对象。

1、利用class创建类

Python中，创建类的语句是如下所示

先解释一下，class后面跟的是类名，括号里面是基类（也成为父类）python3中默认继承object。里面的函数称为方法（注意，严格来说，python中，位于类里面的def语句才能被称为方法，而在类外面定义的def只能被称为函数）。示例如下

2、定义类的属性，

我们讲了类是有属性的，那么如何定义类的属性，有以下两种种：

1、 直接在类里面定义，这里属性是位于类的变量空间里面，整个类中可以直接访问。

2、 在构造函数里面定义，这是对象的属性，访问时要通过self访问。

3、构造函数__init__

类是由属性构成的，当我们在定义一个类的时候，我们需要对类的属性进行设置，这时候就用到了构造函数：__init__(self,[……])，我们在构造函数中的参数是赋值给self，因为在oop中，self就是实例对象，name、age、weight变成了状态信息。

我们接上面说为什么它继承object，通过dir()我们可以打印出他的属性，发现他继承了很多方法，在后面的使用中会比较方便。（这里涉及到了新式类和老式类的问题，在python3中全都是新式类，新式类更加强大）。

4、访问控制

Python不像Java中有明确的访问控制方法，说白了就是没有访问控制。不过有一套约定俗成的方法：全靠自觉

变量名前面无下划线，可以公开访问。

变量名前面带有一个下划线：类的私有属性。

变量名前面带有两个下划线：部分私有属性，类里面可以访问，实例化之后不能直接访问。

再说一遍：全靠自觉！其实它们无论怎样都是可以访问的。这样只是代码规范，方便以后的代码维护。

5、定义类的方法

函数和方法的区别：前面我讲过，python在类中的def才能被称为方法，因为函数和方法的区别就是它们是否依附于一个类。函数直接通过函数名调用，方法通过类实例化调用，方法是类的一个属性。

方法的访问控制和类的属性一样，也是没有，定义方法也就差不多，如下：

绑定方法：

你们可能注意到了，每个方法中 都有self，这个self是绑定类的，表示函数是类的属性。

self 变量用于在类实例方法中引用方法所绑定的实例。因为方法的实例在任何方法调用中总是作为第一个参数传递的，self 被选中用来代表实例。你必须在方法声明中放上 self(你可能已经注意到了这点),但可以在方法中不使用实例(self)。如果你的方法中没有用到 self , 那么请考虑创建一个常规函数，除非你有特别的原因。毕竟，你的方法代码没有使用实例，没有与类关联其功能，这使得它看起来更像一个常规函数。在其它面向对象语言中，self 可能被称为 this。

方法装饰器：

@classmenthod类方法，调用的时候用类名，不是先生成对象，由对象调用

@property像访问属性一样调用方法，就是指不用加括号了。

如下：我在上面的那个类里面加了两个方法，用了这两个修饰器。

使用方法如下：

上一篇：Python 入门基础之面向对象过程-面向过程概述

下一篇介绍类的继承、运算符重载（钩子）等。欢迎关注。

Python里面经常会用到多线程，即所有的方法在同一时间开始运行，而不是按顺序一个一

个运行。所用到的模块为threading，下面详解threading用法。

一、我们写三个方法，one、two、three并正常运行。

这里只截图了one（）方法，two、three与one内容一样。

按下面图中的运行方式，三个函数是分别在不同时间运行的。

这种方式三个函数时在不同时间运行的

二、我们用threading使三个方法在同一时间运行

定义一个线程池并把要运行的线程one()/two()/three()都写到这个线程池列表里：

threads = []#定义一个线程池

t1 = threading.Thread(target=one,args=(,))#建立一个线程并且赋给t1，这个线程指定调用方法one，并且不带参数

threads.append(t1)#把t1线程装到threads线程池里

t2 = threading.Thread(target=two)

threads.append(t2)

t3 = threading.Thread(target=three)

threads.append(t3)

这时threads这个列表中就有三个线程装在里面了。

下面就是运行这个线程池里面的线程

for t in threads:

用一个for语句遍历threads里的线程，然后调用start()方法运行

注意t.join()必须放在for语句外面。

三、运行结果为在同一时间启动的

结果每个循环都是在同一个时间运行

是不是很快就明白threading的用法了呢？

类属性和类方法

目标

类的结构 类属性和实例属性 类方法和静态方法

01. 类的结构

1.1 术语 —— 实例

1. 使用面相对象开发，第 1 步 是设计 类

2. 使用 类名() 创建对象，创建对象 的动作有两步：

1) 在内存中为对象 分配空间

2) 调用初始化方法 `__init__` 为 对象初始化

3. 对象创建后，内存 中就有了一个对象的 实实在在 的存在 —— 实例

因此，通常也会把：

1. 创建出来的 对象 叫做 类 的 实例

2. 创建对象的 动作 叫做 实例化

3. 对象的属性 叫做 实例属性

4. 对象调用的方法 叫做 实例方法

在程序执行时：

1. 对象各自拥有自己的 实例属性

2. 调用对象方法，可以通过 `self.`

访问自己的属性

调用自己的方法

结论

每一个对象 都有自己 独立的内存空间，保存各自不同的属性

多个对象的方法，在内存中只有一份，在调用方法时，需要把对象的引用 传递到方法内部

1.2 类是一个特殊的对象

> `Python` 中 一切皆对象：

> `class AAA:` 定义的类属于 类对象

> `obj1 = AAA()` 属于 实例对象

在程序运行时，类 同样 会被加载到内存

在 `Python` 中，类 是一个特殊的对象 —— 类对象

在程序运行时，类对象 在内存中 只有一份，使用 一个类 可以创建出 很多个对象实例

除了封装 实例 的 属性 和 方法外，类对象 还可以拥有自己的 属性 和 方法

1. 类属性

2. 类方法

通过 类名. 的方式可以 访问类的属性 或者 调用类的方法

02. 类属性和实例属性

2.1 概念和使用

类属性 就是给 类对象 中定义的 属性

通常用来记录 与这个类相关 的特征

类属性 不会用于记录 具体对象的特征

示例需求

定义一个 工具类

每件工具都有自己的 `name`

需求 —— 知道使用这个类，创建了多少个工具对象？

```python

class Tool(object):

使用赋值语句，定义类属性，记录创建工具对象的总数

count = 0

def __init__(self, name):

self.name = name

针对类属性做一个计数+1

Tool.count += 1

创建工具对象

tool1 = Tool("斧头")

tool2 = Tool("榔头")

tool3 = Tool("铁锹")

知道使用 Tool 类到底创建了多少个对象?

print("现在创建了 %d 个工具" % Tool.count)

2.2 属性的获取机制（科普）

在 `Python` 中 属性的获取 存在一个 向上查找机制

因此，要访问类属性有两种方式：

1. 类名.类属性

2. 对象.类属性 （不推荐）

注意

如果使用 `对象.类属性 = 值` 赋值语句，只会 给对象添加一个属性，而不会影响到 类属性的值

03. 类方法和静态方法

3.1 类方法

类属性 就是针对 类对象 定义的属性

使用 赋值语句 在 `class` 关键字下方可以定义 类属性

类属性 用于记录 与这个类相关 的特征

类方法 就是针对 类对象 定义的方法

在 类方法 内部可以直接访问 类属性 或者调用其他的 类方法

语法如下

```python

@classmethod

def 类方法名(cls):

pass

```

类方法需要用 修饰器 `@classmethod` 来标识，告诉解释器这是一个类方法

类方法的 第一个参数 应该是 `cls`

由 哪一个类 调用的方法，方法内的 `cls` 就是 哪一个类的引用

这个参数和 实例方法 的第一个参数是 `self` 类似

提示 使用其他名称也可以，不过习惯使用 `cls`

3. 通过 类名. 调用 类方法，调用方法时，不需要传递 `cls` 参数

4. 在方法内部

可以通过 `cls.` 访问类的属性

也可以通过 `cls.` 调用其他的类方法

示例需求

定义一个 工具类

每件工具都有自己的 `name`

需求 —— 在 类 封装一个 `show_tool_count` 的类方法，输出使用当前这个类，创建的对象个数

```python

@classmethod

def show_tool_count(cls):

"""显示工具对象的总数"""

print("工具对象的总数 %d" % cls.count)

```

> 在类方法内部，可以直接使用 `cls` 访问 类属性 或者 调用类方法

3.2 静态方法

在开发时，如果需要在 类 中封装一个方法，这个方法：

既 不需要 访问 实例属性 或者调用 实例方法

也 不需要 访问 类属性 或者调用 类方法

这个时候，可以把这个方法封装成一个 静态方法

语法如下

```python

@staticmethod

def 静态方法名():

pass

```

静态方法 需要用 修饰器 `@staticmethod` 来标识，告诉解释器这是一个静态方法

通过 类名. 调用 静态方法

```python

class Dog(object):

狗对象计数

dog_count = 0

@staticmethod

def run():

不需要访问实例属性也不需要访问类属性的方法

print("狗在跑...")

def __init__(self, name):

self.name = name

```

3.3 方法综合案例

需求

1. 设计一个 `Game` 类

2. 属性：

定义一个 类属性 `top_score` 记录游戏的 历史最高分

定义一个 实例属性 `player_name` 记录 当前游戏的玩家姓名

3. 方法：

静态方法 `show_help` 显示游戏帮助信息

类方法 `show_top_score` 显示历史最高分

实例方法 `start_game` 开始当前玩家的游戏

4. 主程序步骤

1) 查看帮助信息

2) 查看历史最高分

3) 创建游戏对象，开始游戏

案例小结

1. 实例方法 —— 方法内部需要访问 实例属性

实例方法 内部可以使用 类名. 访问类属性

2. 类方法 —— 方法内部 只 需要访问 类属性

3. 静态方法 —— 方法内部，不需要访问 实例属性 和 类属性

提问

如果方法内部 即需要访问 实例属性，又需要访问 类属性，应该定义成什么方法？

答案

应该定义 实例方法

因为，类只有一个，在 实例方法 内部可以使用 类名. 访问类属性

```python

class Game(object):

游戏最高分，类属性

top_score = 0

@staticmethod

def show_help():

print("帮助信息：让僵尸走进房间")

@classmethod

def show_top_score(cls):

print("游戏最高分是 %d" % cls.top_score)

def __init__(self, player_name):

self.player_name = player_name

def start_game(self):

print("[%s] 开始游戏..." % self.player_name)

使用类名.修改历史最高分

Game.top_score = 999

1. 查看游戏帮助

Game.show_help()

2. 查看游戏最高分

Game.show_top_score()

3. 创建游戏对象，开始游戏

game = Game("小明")

game.start_game()

4. 游戏结束，查看游戏最高分

Game.show_top_score()

``