[Python知识库]python基础(学完过二级)

目录

数据类型

数字型

非数字型

查看变量类型

变量的输入

类型转换函数

变量的格式化输出

在python2中使用中文字符

time库的使用

时间获取

时间格式化：strftime() strptime()

程序计时：sleep() perf_counter()

程序的控制结构

单分支结构

二分支结构

多分支结构

条件判断

程序的异常处理

逻辑运算符

程序的循环结构

遍历循环

无限循环

循环控制保留字

循环的高级用法

eval() 函数（慎用）

random库

基本随机数函数

扩展随机数函数

自定义函数

format格式化函数

代码复用与函数递归

代码复用与模块化设计

函数递归

Pyinstaller库

实例：科赫雪花

集合类型及操作

集合操作

集合处理方法

集合类型应用场景

序列类型及操作

序列类型定义

序列处理函数及方法

元组类型定义

列表类型定义

序列类型应用场景

字典类型

字典处理函数及方法

字符串

全局变量与局部变量

全局变量

局部变量

缺省参数

多值参数

元组和字典元素的拆包

import

模块的搜索顺序

__name__

OS模块

jieba库

用法

包（Package）

__init__.py

文件的使用

文件的类型

strip()方法

文件的打开

文件的关闭

文件指针

文件内容的读取

数据的文件写入

小文件的复制

大文件的复制

一维数据格式化和处理

二维数据格式化和处理

CSV数据存储格式

wordcloud库

w = wordcloud.WordCloud((参数))

参数

实例：政府工作报告

程序设计方法学

实例：体育竞技分析

自顶向下（设计）

自底向上（执行）

体育竞技分析

python程序设计思维

计算思维

计算生态

用户体验

程序设计模式

模块化设计

配置化设计

应用开发四大步骤

python第三方库安装

PyPI · The Python Package Index

pip

集成安装

文件安装

os库

路径操作

进程管理

第三方库安装脚本

python计算生态

数据可视化

文本处理

机器学习

网络爬虫

数据爬取

信息提取

web网站开发

网络应用开发

图形用户界面

游戏开发

虚拟现实

图形艺术

封装 继承 多态

封装

继承

多态

面向对象程序设计

类和对象

大驼峰命名法

定义简单的方法类

__init__

__del__

__str__

__new__

创建私有属性

创建私有方法

新式类与旧式(经典)类

实例

类属性

类方法

静态方法

怎样确定方法的类别

单例

数据类型

数字型

• 整形（int）

• 浮点型（float）

• 布尔型（bool）

  • 真 True -- 非0数

  • 假 False -- 0

• 复数型（complex）

  • 主要用于科学计算，如：平面场问题、波动问题、电感电容等问题

非数字型

• 字符串

• 列表

• 元组

• 字典

查看变量类型

• type [name]

变量的输入

• input 函数

字符串变量名 = input("提示信息")

input 输入的内容都是字符串类型

类型转换函数

• int(x)

• float(x)

变量的格式化输出

• print("格式化字符串" % 变量1)

• print("格式化字符串" % ( 变量1, 变量2...))

在python2中使用中文字符

# 在代码第一行增加
# *-* coding:utf8 *-*
hello_str = u"hello世界"

• 代码第一行增加 # *-* coding:utf8 *-*

• 字符前面增加一个 u

time库的使用

时间获取

• time() 从1970.1.1.0:00开始到现在的秒数

• ctime() 获取当前时间并可读，字符串

• gmtime() 生成计算机可处理的时间格式

时间格式化：strftime() strptime()

程序计时：sleep() perf_counter()

程序的控制结构

单分支结构

if True: print(true)

二分支结构

if else

紧凑形式："对" if guess==99 else "错"

多分支结构

if elif

条件判断

程序的异常处理

try :

? <语句1>

except : ( except 异常类型 : ) # 此处的 except 可以有多个

? <语句2>

try:
 ? ?# 尝试执行的代码
 ? ?pass
except 错误类型1:
 ? ?pass
except Exception as result:
 ? ?pass
else:
 ? ?# 没有异常才会执行的代码
 ? ?pass
finally:
 ? ?# 无论是否有异常都会执行的代码
 ? ?pass

利用异常的传递性，只需要在主程序捕获异常

捕获未知错误

except Exception as result:
 ? ?print("未知错误 %s" % result)

主动抛出异常

• 创建一个 Exception 的对象

• 使用 raise 关键字抛出 异常对象

ex = Exception("异常类型")
raise ex

逻辑运算符

and

or

not

程序的循环结构

遍历循环

for <循环变量> in <遍历结构 > :

<语句块>

• for i in range(N) 循环N次

  • for i in range(M, N ,K) 从M开始，N结束，K为间隔

• for c in s 遍历字符串

• for item in ls 遍历列表

• for line in fi 遍历文件的每一行

完整的 for 循环

for 条件:
 ? ?执行语句
else:
 ?  (如果for没有break，则执行else   )

无限循环

while <条件> : <语句块>

循环控制保留字

break

跳出并结束整个循环(仅跳出当层循环)

continue

跳出本次循环，继续下次循环

循环的高级用法

else的使用

eval() 函数（慎用）

• eval() 函数 将字符串 当成 有效的表达式 来求值并 返回计算结果

# 基本的数学计算
eval("1 + 1")
?
# 字符串重复
eval("'*'' * 10")
?
# 将字符串转换type
eval("[1, 2, 3, 4, 5]")

• 若直接输入os则会调用终端命令，很危险

__import__('os').system('终端命令')
?
# 等价代码
import os
os.system("终端命令")

random库

基本随机数函数

• random.seed(a=None) #初始化给定的随机数种子，默认为当前系统时间

• random.random() 生成一个[0.0,1.0)之间的随机小数

扩展随机数函数

• randint(a, b) 生成一个[a, b]之间的整数

  • random.randint(10, 100)

• randrange(m, n[, k]) 生成一个[m ,n)之间以k为步长的随机整数

• getrandbits(k) 生成一个k比特长的随机整数

• uniform(a, b) 生成一个[a, b]之间的随机小数

• choice(seq) 从序列seq中随机选择一个元素

• shuffle(seq) 将序列seq中元素随机排列，返回打乱后的序列

自定义函数

def <函数名>(<参数(0个或多个)>):

<函数体>

return <返回值>

def <函数名>(<非可选参数>, <可选参数>):

<函数体>

return <返回值>

在程序中使用外部的全局变量：global

lambda函数

eval(x) : 去掉x两边的一对引号

format格式化函数

详细教程参考菜鸟教程，下面给出链接

Python format 格式化函数 | 菜鸟教程

代码复用与函数递归

代码复用与模块化设计

• 代码资源化

• 代码抽象化

• 代码复用

• 紧耦合

• 松耦合

  模块内部紧耦合，模块之间松耦合

函数递归

函数中调用函数自身的方式

• 链条：计算过程存在递归链条

• 基例：存在一个或多个不需要再次递归的基例

Pyinstaller库

-h 查看帮助

--clean 清理打包过程的临时文件

-D ，--onedir 默认值，生成dist文件夹

-F，--onefile 在dist文件夹中只生成独立的打包文件

-i<图标文件名.ico> 指定打包程序使用的图标(icon)文件

实例：科赫雪花

用turtle库绘制出科赫雪花

import turtle


def kehe(size, n):  # size线段长度，n阶数
    if n == 0:
        turtle.fd(size)
    else:
        for angle in [0, 60, -120, 60]:
            turtle.left(angle)
            kehe(size / 3, n - 1)


def main():
    turtle.setup(800, 400)
    turtle.penup()
    turtle.goto(-300, -50)
    turtle.pendown()
    turtle.pensize(2)
    turtle.speed(100)
    kehe(400, 3)
    turtle.hideturtle()


main()

集合类型及操作

1. 多个元素的无序组合

2. 集合元素为不可变数据类型

3. 所有元素不可重复

• 建立空集合： set()

集合操作

• S | T：返回一个新的集合，包括在集合S和T中的所有元素

• S - T：返回一个新的集合，包括在集合S但不在T中的元素

• S & T：返回一个新的集合，包括同时在集合S和T中的元素

• S ^ T：返回一个新的集合，包括集合S和T中的非相同元素

• S <= T 或 S < T：返回True / False

• S >= T 或 S > T：返回True / False

集合处理方法

S.remove(x) 常与 try except 搭配使用

集合类型应用场景

• 包含关系比较

• 数据去重

序列类型及操作

序列类型定义

有先后关系的一组元素，是一个基类类型

序列处理函数及方法

元组类型定义

• 是一种序列类型，一旦创建不可修改

• 使用 () 或 tuple() 创建，元素间用逗号 , 分隔

current = "abc","cd","ab","ad"

• 可以使用或不使用小括号

• 有序排列

def func():
	return 1,2  # 返回了一个元组

• 定义只包含一个元素的元组

info_tuple = (5, )

如果函数返回的类型是元组，同时希望单独的处理元组中的元素，可以使用多个变量，一次接受函数的返回结果

tuple_info = (1, 2, 3)
a, b, c = tuple_info

注意：使用多个变量接受结果时，变量的个数应该与元组中元素的个数相同

利用元组可实现两个变量的值互换

a, b = b, a

列表类型定义

• 创建后可随意修改

• 使用方括号 [] 或 list() 创建，元素间用 , 分隔

  ls = ["car" , "dog" , "tiger" , 1024]

• 各元素类型可以不同，无长度限制

• del 为删除内存中保存的东西

序列类型应用场景

用于数据展示

• 元组用于元素不改变的应用场景

• 列表是最常用的数据类型

元素遍历

for item in ls :
	<语句块>

数据保护

• 如果不希望数据被程序所改变，转化为元组类型

info_tuple = tuple(info_list)

字典类型

• 映射：是一种键（索引）和值（数据）的对应

• 键值对：键是数据索引的扩展

• 字典是键值对的集合，键值对之间无序，使用print输出时通常输出顺序跟定义顺序不一致

• 采用大括号{} 和 dict() 创建，键值对用冒号 : 表示

  <字典变量> = {<键1>:<值1>, 
            	 <键2>:<值2>,
               ... ,
             <键n>:<值n>}
  <值> = <字典变量>[<键>]  <字典变量>[<键>] = <值>

  生成空字典：de = {}; type(de)

字典处理函数及方法

遍历字典

for k in d:
    print("%s - %s" % (k, d[k]))

• 其中，k 表示字典 d 中获取到键值对的 key

字符串

• 查找和替换

全局变量与局部变量

在方法中不允许直接修改全局变量，如果使用赋值语句，会在函数内部定义一个局部变量；若要修改则在前面加上 global

若方法传入的是可变类型参数，在使用方法修改了数据内容，会影响到外部的数据

全局变量

• 全局变量的使用周期为整个程序结束

• 全局变量应全部定义于所有函数的上方

• 命名建议：避免局部变量与全局变量出现混淆，在定义全局变量时在前面加上 g_ 或 gl_ 的前缀

局部变量

• 局部变量的使用周期为该方法结束

缺省参数

• 定义函数时，可以给某个参数指定一个默认值，具有默认值的参数就叫缺省参数

• 调用函数时，如果没有传入缺省参数的值，则在函数内部使用定义函数时指定的默认参数值

• 函数的缺省参数，将常见的值设置为参数的缺省值，从而简化函数的调用

定义缺省参数

def print_info(name, gender=True)

• 指定默认值时，应使用最常见的值作为默认值，且定义在非缺省参数后

多值参数

• 参数名前增加一个 * 可以接收元组

  • *arge -- 存放 元组 参数

  • args 是arguments的缩写，有变量的含义

• 参数名前增加两个 * 可以接收字典

  • **kwargs -- 存放 字典 参数

  • kw 是keyword的缩写，可以记忆键值对参数

元组和字典元素的拆包

def num_print(*args, **kwargs):
    print(args)
    print(kwargs)
gl_nums = (1, 2, 3)
gl_dict = {"name": "xiaoming", "age": 18}
num_print(*gl_nums, **gl_dict)

import

import 模块名 as 模块别名

• 模块别名应符合大驼峰命名法

from 模块名 import 工具名

• 从一个模块中导入部分工具

• 导入过后不需要通过模块名

• 可以直接使用模块提供的工具

• 注意：如果两个模块存在同名的函数，那么后导入模块的函数，会覆盖先导入的函数

  • 可以使用别名的方法来避免覆盖

from 模块名 import *

• 导入所有工具（不推荐使用）

模块的搜索顺序

• 搜索当前目录指定模块名的文件，如果有就直接导入

• 如果没有，再搜索系统目录

在开发时，给文件起名，不要和 系统的模块文件重名

• 内置属性 __file__ 可以查看模块的完整路径

  __name__

• 在导入文件时，文件中 所有没有任何缩进的代码 都会被执行一遍

• 通常会在 模块 下方增加一些测试代码

  • 仅在模块内使用，而被导入到其他文件中不需要执行

• __name__ 是一个内置属性，记录一个字符串

  • 如果是被其他文件导入的，__name__ 就是模块名

  • 如果是当前执行的文件，__name__ 是 __main__

# 导入模块
# 定义全局变量
# 定义类
# 定义函数

#在代码的最下方
def main():
    # ...
    pass

# 根据 __name__ 判断是否执行下方代码
if __name__ == "__main__":
    main()

OS模块

jieba库

优秀的中文分词第三方库

pip install jieba

• 精确模式：把文本精确的分开，不存在冗余单词

• 全模式：把文本中所有可能的词语都扫描出来，有冗余

• 搜索引擎模式：在精确模式基础上，对长词再次切分

用法

包（Package）

• 包 是一个包含 多个模块 的特殊目录

• 目录下有一个 特殊的文件 __init__.py

• 包名的 命名方式 和变量名一致

__init__.py

• 在此文件中需要指定 对外界提供的模块列表

from . import 模块名1
from . import 模块名2
...

文件的使用

文件的类型

是存储在辅助存储器上的数据序列

• 文本方式打开看，楼

  • 如果文件存在，返回文件操作对象

  • 如果文件不存在，会抛出异常

  • readline方法可以一次读取一行内容

tf = open("f.txt", "rt")
print(tf.readline())
tf.close()

• 二进制方式打开

tf = open("f.txt", "rb")
print(tf.readline())
tf.close()

打开 - 操作 - 关闭

strip()方法

• Python strip() 方法用于移除字符串头尾指定的字符（默认为空格或换行符）或字符序列。

• 注意：该方法只能删除开头或是结尾的字符，不能删除中间部分的字符。

str.strip([chars])

• chars ：移除字符串头尾指定的字符序列

• 返回值 ：返回移除字符串头尾指定的字符生成的新字符串。

文件的打开

< 变量名 > = open(< 文件名 >, < 打开模式 >)

文件的关闭

<变量名>.close()

文件指针

执行了read方法过后文件指针会移动到文件末尾，再次调用read方法将不会读取到任何内容

文件内容的读取

数据的文件写入

小文件的复制

file_read = open("文件名")
file_write = open("文件名[复件]", "w")  # 以只写方式打开

text = file_read.read()
file_write.write(text)

file_read.close()
file_write.close()

大文件的复制

file_read = open("文件名")
file_write = open("文件名[复件]", "w")  # 以只写方式打开

while True:
    text = file_read.readline()
    
    if not text:
        break
    
    file_write.write(text)

file_read.close()
file_write.close()

一维数据格式化和处理

列表类型（有序）和集合类型（无序）

空格分隔、逗号分隔、特殊符号分隔

.split() 和 .join()

二维数据格式化和处理

列表类型

CSV数据存储格式

Comma-Separated Values

• 国际通用的一二维数据存储格式，一般 .csv 扩展名

• 每行一个一维数据，采用逗号分隔，无空行

• Excel和一般编辑软件都可以读入或另存为csv文件

wordcloud库

将文本转化为词云

w = wordcloud.WordCloud((参数))

1. 配置对象参数

2. 加载词云文本

3. 输出词云文件

• 分隔：以空格分隔单词

• 统计：单词出现次数并过滤较短的单词

• 字体：根据统计配置字号

• 布局：颜色环境尺寸

参数

• width

• height

• min_font_size

• max_font_size

• font_step ：指定词云中字体字号的步进间隔，默认1

• font_path ：指定字体文件的路径

• max_words ：指定词云显示的最大单词数量，默认200

• stop_words ：指定词云的排除词列表，即不显示的单词列表

• mask ：指定词云形状，默认为长方形，需要引用imread()函数

  form scipy.misc import imread
  mk=imread("pic.png")
  w=wordcloud.WordCloud(mask=mk)

• background_color

实例：政府工作报告

import jieba
import wordcloud
f = open("新时代中国特色社会主义.txt", "r", encoding="utf-8")
t = f.read()
f.close()
ls = jieba.lcut(t)
txt = " ".join(ls)
w = wordcloud.WordCloud(font_path = "msyh.ttc", width = 1000, height = 700, background_color = "white")
w.generate(txt)
w.to_file("grwordcloud.png")

程序设计方法学

实例：体育竞技分析

自顶向下（设计）

解决复杂问题的有效方法

• 将一个总问题表达为若干个小问题组成的形式

• 使用同样方法进一步分解小问题

• 直到每个小问题可用计算机简单明了的解决

自底向上（执行）

逐步组建复杂系统的有效测试方法

• 分单元测试，逐步组装

• 按照自顶向下相反的路径操作

• 直至系统各部分以组装的思路都经过测试和验证

体育竞技分析

python程序设计思维

计算思维

抽象和自动化

• 逻辑思维：推理和演绎

• 实证思维：实验和验证

• 计算思维：设计和构造

计算生态

用户体验

• 进度展示

• 异常处理

• 打印输出

• 日志文件

• 帮助信息

程序设计模式

• 从 IPO 开始

  • input

  • process

  • output

• 编写程序

• 调试程序

模块化设计

• 紧耦合

• 松耦合

配置化设计

• 引擎 + 配置 的设计思维

应用开发四大步骤

1. 产品定义：对应用需求充分理解和明确定义。功能定义和商业模式

2. 系统构架：关注数据流、模块化、体系架构

3. 设计与实现：结合架构完成关键设计及系统实现。结合可扩展性、灵活性等进行设计优化

4. 用户体验：从用户角度思考

python第三方库安装

pip官网：

PyPI · The Python Package Index

1. 搜索相关主题

2. 挑选适合开发目标的第三方库

3. 完成需求

pip

• 安装：pip3 install <第三方库>

• 更新：pip3 install -U <第三方库名>

• 卸载：pip3 uninstall <第三方库名>

• 下载不安装：pip3 download <第三方库名>

• 列出详细信息：pip3 show <第三方库名>

• 根据关键词搜索库：pip3 search <关键词>

• 列出已安装的第三方库：pip3 list

集成安装

Anaconda工具

文件安装

UCI页面

os库

是python的标准库

路径操作

import os.path

• .abspath(path)：返回path在当前系统中的绝对路径

• .normpath(path)：归一化path的表示形式，统一用 \\ 分隔路径

• .relpath(path)：返回当前程序与文件之间饿相对路径

• .dirname(path)：返回path中的目录名称

• .basename(path)：返回path中最后的文件名称

• .join(path, *paths)：组合path和paths，返回一个路径字符串

• .exists(path)：判断存在则返回True，反之

• .isfile(path)：判断是否为文件

• .isdir(path)：判断是否为目录

• .getatime(path)：返回path对应文件或目录上一次的访问时间

• .getmtime(path)：返回path对应文件或目录最近一次的修改时间

• .getctime(path)：返回path对应文件或目录的创建时间

• .getsize(path)：返回path对应文件的大小，以字节为单位

进程管理

os.system(command)

第三方库安装脚本

用脚本安装libs中列出的第三方库

import os
libs = {"numpy", "matplotlib", "pillow", "sklearn", "requests", "jieba", "beautifulsoup4", "wheel", "networkx", "sympy", "pyinstaller", "django", "flask", "werobot", "pyqt5", "pandas", "pyopengl", "pypdf2", "docopt", "pygame"}
try:
    for lib in libs:
        os.system("pip install " + lib)
   	print("Sucessful")
except:
    print("Failed Somehow")

python计算生态

数据可视化

• 二维

  • matplotlib库

  • seaborn库

• 三维

  • mayavi库

文本处理

pypdf2库

nltk库：自然语言处理库

python-docx库：创建或更新Microsoft Word文件的第三方库

机器学习

sklearn库

tensorflow库：AlphaGo背后的机器学习计算框架

MXNet库：基于神经网络的深度学习计算框架

网络爬虫

数据爬取

requests库最友好的网络爬虫功能库

scrapy ：优秀的网络爬虫框架

pyspider库：强大的web页面爬取系统。支持数据库后端、消息队列、优先级、分布式架构等

信息提取

beautifulsoup库：HTML和XML的解析库

re库：正则表达式解析和处理功能库

python-goose库：提取文章类型web页面的功能库

web网站开发

Django库：大型

pyramid库：中型

flask库：小型

网络应用开发

werobot库：微信公众号开发框架

aip库：百度AI开放平台接口

myqr库：二维码生成第三方库

图形用户界面

pyqt5：qt开发框架的python接口

wxpython：跨平台GUI开发框架

pygobject：使用GTK+开发GUI的功能库

游戏开发

pygame库：简单的游戏开发功能库

panda3d库：开源、跨平台的3d渲染和游戏开发库

cocos2d库：构建2d游戏和图形界面交互式应用的框架

虚拟现实

vrzero库：在树莓派上开发vr应用的python库

pyovr库

vizard库

图形艺术

quads库：迭代的艺术

ascii_art库：ASCII艺术库

turtle库

封装 继承 多态

封装

• 封装是面向对象编程的一大特点

• 面向对象编程的第一步 -- 将属性和方法 封装 到一个抽象的类中

• 外界使用 类 创建对象，然后 让对象调用方法

• 对象方法的细节都被封装在类的内部

继承

• 子类 拥有 父类 的所有 方法 和 属性

class 类名(父类名):
    pass

• 子类 继承自 父类 ，可以直接 享受 父类中已经封装好的方法，不需要再次开发

• 子类 中应该根据 职责，封装 子类特有的 属性和方法

• 子类 是 父类 的派生类，父类 是 子类 的基类，子类 从 父类 派生

• 子类 拥有 父类 的所有 方法 和 属性

• 当 父类 的方法实现不能满足子类需求时，可以对方法进行 重写(override)

  • 扩展 父类 的方法：super().父类方法

  • 在 python 2.x 版本中，需要 父类名.方法(self)

多继承

• 子类 拥有 多个父类，并且具有 所有父类 的 属性 和 方法

class 类名(父类名1， 父类名2， ...):

• 在开发时，如果 父类之间 存在 同名 的 属性或方法，应该 尽量避免 使用多继承

多态

• 不同的 子类对象 调用相同的 父类方法，产生不同的执行效果

  • 多态 可以 增加代码的灵活性

  • 以 继承 和 重写父类方法 为前提

  • 是以调用方法的技巧，不会影响到类的内部设计

面向对象程序设计

类和对象

• 类是模板，对象是根据 类 创建出来的，先有类，再有对象

• 类只有一个，而对象可以有很多个

  • 不同对象之间属性可能会各不相同

• 类中定义了什么属性和方法，对象中就有什么属性和方法，不能多也不能少

大驼峰命名法

• 类名 满足大驼峰命名法 CapWords

• 属性 这类事物具有什么样的特征

• 方法 这类事物具有什么样的行为

定义简单的方法类

class 类名:
    def 方法1(self, 参数列表):
        pass
    def 方法2(self, 参数列表):
        pass

• 方法第一个参数必须是 self（哪一个对象调用的方法，self就是那个对象的引用）

• 类名的命名规则需要符合大驼峰命名法

创建对象

对象变量 = 类名()

__init__

class Cat:
    def __init__(self):
        print("这是一个初始化方法")

• 使用 类名() 创建对象的时候，会自动调用初始化方法 __init__

__del__

def __del__(self):
    print("")

• __del__ 函数在对象被消灭之前自动执行

__str__

class Cat:
    def __str__(self):
        return "tom"

tom = Cat()
print(tom)

__str__ 函数可使print函数打印我们自定义的内容

__new__

使用 类名() 创建对象时，解释器会首先调用 __new__ 方法为对象分配空间

• 在内存中为对象 分配空间

• 返回 对象的引用

解释器获得对象的 引用 后，将引用作为第一个参数，传递给 __init__ 方法

• 重写 __new__ 的方法：

  return super().__new__(cls)

创建私有属性

self.__age = 18

• 私有属性在外界不能被直接访问，在对象的饿方法内部可以访问对象的私有属性

• 子类对象 不能在自己的方法内部，直接 访问父类的 私有属性 或 私有方法

• 子类对象 可以通过 父类 的 公有方法 间接访问 私有属性 或 私有方法

创建私有方法

def __secret(self):
    pass

• 同私有属性

新式类与旧式(经典)类

• 新式类：以 object 为基类的类

• 经典类：不以 object 为基类的类

实例

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

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

• 对象的属性 叫做 实例属性

• 对象调用的方法 叫做 实例方法

类属性

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

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

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

class Tool(object):

    count = 0

    def __init__(self, name):
        self.name = name
        print("添加的工具是 %s" % self.name)
        Tool.count += 1


tool1 = Tool("斧头")
print(Tool.count)

类属性的调用

• 类名.类属性

类方法

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

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

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

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

  • 使用其他名称也可以瞒不过习惯使用 cls

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

• 在方法内部

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

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

class Tool(object):
    
    count = 0
    
    @classmethod
    def show_tool_count(cls):
        print("数量 %d" % cls.count)

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

静态方法

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

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

class Dog(object):

    @staticmethod
    def run():
        print("run")


Dog.run()

• 类名.静态方法

调用静态方法不需要创建对象

怎样确定方法的类别

• 实例方法 ---- 方法内部需要访问 实例属性

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

• 类方法 ---- 方法内部 只 需要访问 类属性

• 静态方法 ---- 方法内部不需要访问 实例属性 和 类属性

单例

• 让 类 创建的对象在系统中只有 唯一的一个实例

  • 定义一个 类属性，初始值是 None，用于记录 单例对象的引用

  • 重写 __new__ 方法

  • 如果 类属性 is None，调用父类方法分配空间，并在类属性中记录结果

  • 返回 类属性 中记录的 对象引用

class MusicPlayer(object):
    
    instance = None
    
    def __new__(cls, *args, **kwargs):
        
        # 判断 instance 是否为 None
        if cls.instance is None:
            cls.instance = super().__new__(cls)
        return cls.instance

手打不易，给个赞吧qwq

祝各位都高分过级