目录
PyPI · The Python Package Index
数据类型
数字型
-
整形（int）
-
浮点型（float）
-
布尔型（bool）
-
真 True -- 非0数
-
假 False -- 0
-
-
复数型（complex）
-
主要用于科学计算，如：平面场问题、波动问题、电感电容等问题
-
非数字型
-
字符串
-
列表
-
元组
-
字典
查看变量类型
-
type [name]
变量的输入
-
input 函数
字符串变量名 = input("提示信息")
input 输入的内容都是字符串类型
类型转换函数
-
int(x)
-
float(x)
变量的格式化输出
| 格式化字符 | 含义 |
|---|---|
| %s | 字符串 |
| %d | 有符号十进制整数，%06d表示输出的整数显示位数，不足的地方用0补全,超过的是多少就是多少 |
| %f | 浮点数，%.02f表示小数点后只显示两位 |
| %% | 输出 % |
-
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格式化函数
详细教程参考菜鸟教程，下面给出链接
代码复用与函数递归
代码复用与模块化设计
-
代码资源化
-
代码抽象化
-
代码复用
-
紧耦合
-
松耦合
模块内部紧耦合，模块之间松耦合
函数递归
函数中调用函数自身的方式
-
链条：计算过程存在递归链条
-
基例：存在一个或多个不需要再次递归的基例
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()集合类型及操作
-
多个元素的无序组合
-
集合元素为不可变数据类型
-
所有元素不可重复
-
建立空集合： 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.add(x) | 如果x不在集合S中，将x增加到S |
| S.discard(x) | 移除S中元素x，如果x不在集合S中，不报错 |
| S.remove(x) | 移除S中元素x，如果x不在集合S中，产生KeyError异常 |
| S.clear() | 移除S中所有元素 |
| S.pop() | 随机返回S的一个元素，更新S，若S为空产生KeyError异常 |
| S.copy() | 返回集合S的一个副本 |
| len(S) | 返回S的元素个数 |
| x in S | 判断x在S中则返回True，反之 |
| x not in S | 判断x不在S中则返回True，反之 |
| set(S) | 将其他类型变量x转变为集合类型 |
S.remove(x) 常与 try except 搭配使用
集合类型应用场景
-
包含关系比较
-
数据去重
序列类型及操作
序列类型定义
有先后关系的一组元素，是一个基类类型
序列处理函数及方法
| 操作符及应用 | 描述 |
|---|---|
| x in S | 若x是S的元素则返回True |
| x not in S | 若x不是S的元素则返回True |
| s + t | 连接两个序列s和t |
| s * n 或 n * s | 将序列s复制n次 |
| s[i] | 索引，返回s中的第i个元素，i是序列号 |
| s[i : j] 或 s[i : j : k] | 切片，返回序列s中第i到j以k为步长的元素子序列 |
| 函数和方法 | 描述 |
|---|---|
| len(s) | 返回序列s的长度 |
| min(s) | 返回序列s中最小元素 |
| max(s) | 返回s中最大元素 |
| s.index(x) 或 s.index(x, i, j) | 返回序列s从i开始到j位置中第一次出现x的位置 |
| s.count(x) | 返回序列s中x出现的总次数 |
元组类型定义
-
是一种序列类型，一旦创建不可修改
-
使用 () 或 tuple() 创建，元素间用逗号 , 分隔
current = "abc","cd","ab","ad"-
可以使用或不使用小括号
-
有序排列
def func():
return 1,2 # 返回了一个元组-
定义只包含一个元素的元组
info_tuple = (5, )| 函数或方法 | 描述 |
|---|---|
| info.count(x) | x 在 info 中出现的次数 |
| info.index(x) | x 在 info 中第一次出现的索引 |
如果函数返回的类型是元组，同时希望单独的处理元组中的元素，可以使用多个变量，一次接受函数的返回结果
tuple_info = (1, 2, 3)
a, b, c = tuple_info注意：使用多个变量接受结果时，变量的个数应该与元组中元素的个数相同
利用元组可实现两个变量的值互换
a, b = b, a列表类型定义
-
创建后可随意修改
-
使用方括号 [] 或 list() 创建，元素间用 , 分隔
ls = ["car" , "dog" , "tiger" , 1024] -
各元素类型可以不同，无长度限制
| 函数或方法 | 描述 |
|---|---|
| ls[i] = x | 替换ls第i元素为x |
| ls[i : j : k] = lt | 用lt替换ls切片后对应的元素子列表 |
| del ls[i] | 删除列表ls中第i元素 |
| del ls[i: j: k] | 删除le中第i到第j以k为步长的元素 |
| ls += lt | 更新列表ls，将列表lt增加到ls中 |
| ls *= n | 更新列表ls，其元素重复n次 |
-
del 为删除内存中保存的东西
| 函数或方法 | 描述 |
|---|---|
| ls.append(x) | 列表最后增加元素x |
| ls.clear() | 删除ls所有元素 |
| ls.copy() | 生成一个新列表，赋值ls中所有元素 |
| ls.insert(i, x) | ls的第i位置增加元素x |
| ls.pop(i) | 将ls中第i位置元素取出并删除该元素；无参数则默认删除最后一个元素 |
| ls.remove(x) | 将ls中出现的第一个x删除 |
| ls.reverse() | 将ls的元素反转 |
| ls.sort() | 升序排序 |
| ls.sort(reverse=True) | 降序排序 |
序列类型应用场景
用于数据展示
-
元组用于元素不改变的应用场景
-
列表是最常用的数据类型
元素遍历
for item in ls :
<语句块>数据保护
-
如果不希望数据被程序所改变，转化为元组类型
info_tuple = tuple(info_list)字典类型
-
映射：是一种键（索引）和值（数据）的对应
-
键值对：键是数据索引的扩展
-
字典是键值对的集合，键值对之间无序，使用print输出时通常输出顺序跟定义顺序不一致
-
采用大括号{} 和 dict() 创建，键值对用冒号 : 表示
<字典变量> = {<键1>:<值1>, <键2>:<值2>, ... , <键n>:<值n>} <值> = <字典变量>[<键>] <字典变量>[<键>] = <值>生成空字典：de = {}; type(de)
字典处理函数及方法
| 函数或方法 | 描述 |
|---|---|
| del d[k] | 删除字典d中键k对应的数据值 |
| k in d | 判断键k是否在字典d中 |
| d.keys() | 返回字典d中所有的键信息 |
| d.values() | 返回字典d中所有的值信息 |
| d.items() | 返回字典d中所有的键值对信息 |
| d.get(k, <deault>) | 键k存在，则返回相应值，不存在则返回<default>值 |
| d.pop(k, <default>) | 键k存在，则取出（删除）相应值，不存在则返回<default>值 |
| d.popitem() | 随机从字典d中取出一个键值对，以元组形式返回 |
| d.clear() | 删除所有的键值对 |
| len(d) | 返回字典d中元素的个数 |
| 函数 | 描述 |
|---|---|
| d["k"] | 若 k 键存在，返回 k 键对应的信息 |
| d["k"] = value | 若 k 键存在，则修改 k 键对应值为 value；若 k 键不存在，则增加 k 键，对应值为 value |
| d.update(d1) | 把 d1 字典合并到 d 字典中；如果被合并的字典中包含已经定义的键值对，则会覆盖原有的键值对 |
遍历字典
for k in d:
print("%s - %s" % (k, d[k]))-
其中，k 表示字典 d 中获取到键值对的 key
字符串
| 方法 | 说明 |
|---|---|
| string.isspace() | 如果 string 中只包含空格，则返回 True |
| string.isalnum() | 如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True |
| string.isalpha() | 如果 string 至少有一个字符并且所有字符都是字母则返回 True |
| string.isdecimal() | 如果 string 只包含数字则返回 True，全角数字 |
| string.isdigit() | 如果 string 只包含数字则返回 True，全角数字、(1)、\u00b2 |
| string.isnumeric() | 如果 string 只包含数字则返回 True，全角数字、汉字数字 |
| string.istitle() | 如果 string 是标题化的（每个单词的首字母大写）则返回 True |
| string.islower() | 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True |
| string.isupper() | 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True |
-
查找和替换
| 方法 | 说明 |
|---|---|
| string.startwith(str) | 检查字符串是否以str开头，是则返回True |
| string.endwith(str) | 检查字符串是否以str结尾，是则返回True |
| string.find(str, start=0, end=len(string)) | 检查str是否包含在string中，如果start和end指定范围，则检查是否包含在指定范围内，如果是 返回开始的索引值，否则返回-1 |
| string.rfind(str, start=0, end=len(string)) | 类似于find()函数，从右边开始查找 |
| string.index(str, start=0, end=len(string)) | 跟find()方法类似，如果str不在string中会报错 |
| string.rindex(str, start=0, end=len(string)) | 类似index()方法，从右边开始 |
| string.replace(old_str, new_str, num=string.count(old)) | 把string中的old_str替换成new_str，如果num指定，则替换不超过num次；不修改原有字符串的内容 |
全局变量与局部变量
在方法中不允许直接修改全局变量，如果使用赋值语句，会在函数内部定义一个局部变量；若要修改则在前面加上 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模块
| 方法名 | 说明 |
|---|---|
| os.rename(源文件名, 目标文件名) | 重命名文件 |
| os.remove(文件名) | 删除文件 |
| os.listdir(目录名) | 查看目录列表 |
| os.mkdir(目录名) | 创建目录 |
| os.rmdir(目录名) | 删除目录 |
| os.getcwd() | 获取当前目录 |
| os.chdir(目标目录) | 修改工作目录 |
| os.path.isdir(文件路径) | 判断是否是文件 |
jieba库
优秀的中文分词第三方库
pip install jieba
-
精确模式：把文本精确的分开，不存在冗余单词
-
全模式：把文本中所有可能的词语都扫描出来，有冗余
-
搜索引擎模式：在精确模式基础上，对长词再次切分
用法
| 函数 | 描述 | 用法 |
|---|---|---|
| jieba.lcut(s) | 精确模式，返回一个列表类型的分词结果 | jieba.lcut("中国是一个伟大的国家") ['中国', '是', '一个', '伟大', '的', '国家'] |
| jieba.lcut(s, cut_all=True) | 全模式，返回一个列表类型的分词结果，存在冗余 | jieba.lcut("中国是一个伟大的国家", cut_all=True) ['中国', '国是', '一个', '伟大', '的', '国家'] |
| jieba.lcut_for_search(s) | 搜索引擎模式，返回一个列表类型的分词结果，存在冗余 | jieba.lcut_for_search("中华人民共和国是伟大的") [ '中华', '华人', '人民', '共和', '共和国', '中华人民共和国', '是', '伟大', '的' ] |
| jieba.add_word(w) | 向分词词典增加新词w | jieba.add_word("蟒蛇语言") |
包（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(< 文件名 >, < 打开模式 >)| 文件的打开模式 | 描述 |
|---|---|
| ' r ' | 只读模式，默认值，如果文件不存在，返回FileNotFoundError |
| ' w ' | 覆盖写模式，文件不存在则创建，存在则完全覆盖 |
| ' x ' | 创建写模式，文件不存在则创建，存在则返回FileExistsError |
| ' a ' | 追加写模式，文件不存在则创建，存在则在文件最后追加内容 |
| ' b ' | 二进制文件模式 |
| ' t ' | 文本文件模式，默认值 |
| ' + ' | 与r/w/x/a一同使用，在原功能基础上增加同时读写能力 |
文件的关闭
<变量名>.close()文件指针
执行了read方法过后文件指针会移动到文件末尾，再次调用read方法将不会读取到任何内容
文件内容的读取
| 操作方法 | 描述 | |
|---|---|---|
| <f>.read(size=-1) | 读入全部内容，如果给出参数，读入前size长度 | s = f.read(2) 中国 |
| <f>.readline(size=-1) | 读入一行内容，如果给出参数，读入该行前size长度 | s = f.readline() 中国是一个伟大的国家 |
| <f>.readlines(hint=-1) | 读入文件所有行，以每行为元素形成列表，如果给出参数，读入前hint行 | s = f.readlines() ['中国是一个伟大的国家'] |
数据的文件写入
| 操作方法 | 描述 | |
|---|---|---|
| <f>.write(s) | 向文件写入一个字符串或字节流 | f.write("中国是一个伟大的国家") |
| <f>.writelines(lines) | 将一个元素全为字符串的列表写入文件 | ls = ["中国", "法国", "英国"] f.writelines(ls) 中国法国英国 |
| <f>.seek(offset) | 改变当前文件操作指针的位置，offset含义如下：0 - 文件开头；1 - 当前位置；2 - 文件结尾 | f.seek(0) # 回到文件开头 |
小文件的复制
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((参数))
| 方法 | 描述 | |
|---|---|---|
| w.generate(txt) | 向WordCloud对象w中加载文本txt | w.generate("python and WordCloud") |
| w.to_file(filename) | 将词云输出为图像文件，.png 或 .jpg 格式 | w.to_file("outfile.png") |
-
配置对象参数
-
加载词云文本
-
输出词云文件
-
分隔：以空格分隔单词
-
统计：单词出现次数并过滤较短的单词
-
字体：根据统计配置字号
-
布局：颜色环境尺寸
参数
-
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")程序设计方法学
实例：体育竞技分析
自顶向下（设计）
解决复杂问题的有效方法
-
将一个总问题表达为若干个小问题组成的形式
-
使用同样方法进一步分解小问题
-
直到每个小问题可用计算机简单明了的解决
自底向上（执行）
逐步组建复杂系统的有效测试方法
-
分单元测试，逐步组装
-
按照自顶向下相反的路径操作
-
直至系统各部分以组装的思路都经过测试和验证
体育竞技分析
| 总体框架 | 自定义函数 |
|---|---|
| 1. 打印程序的介绍性信息 | printInfo() |
| 2. 获得程序运行参数：proA, proB, n | getInputs() |
| 3. 利用球员A和球员B的能力值，模拟n场比赛 | simNGames() |
| 4. 输出球员A和B获胜比赛的场次及概率 | printSummary() |
python程序设计思维
计算思维
抽象和自动化
-
逻辑思维：推理和演绎
-
实证思维：实验和验证
-
计算思维：设计和构造
计算生态
用户体验
-
进度展示
-
异常处理
-
打印输出
-
日志文件
-
帮助信息
程序设计模式
-
从 IPO 开始
-
input
-
process
-
output
-
-
编写程序
-
调试程序
模块化设计
-
紧耦合
-
松耦合
配置化设计
-
引擎 + 配置 的设计思维
应用开发四大步骤
-
产品定义：对应用需求充分理解和明确定义。功能定义和商业模式
-
系统构架：关注数据流、模块化、体系架构
-
设计与实现：结合架构完成关键设计及系统实现。结合可扩展性、灵活性等进行设计优化
-
用户体验：从用户角度思考
python第三方库安装
pip官网：
PyPI · The Python Package Index
-
搜索相关主题
-
挑选适合开发目标的第三方库
-
完成需求
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
祝各位都高分过级
1669
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
