python数据挖掘的书 python数据挖掘基础

一、概述 (ppt-1)

1、数据挖掘的特点

• 数据量大
• 多样性
• 价值密度低
• 处理速度快
• 可靠性低

2、传统数据分析和大数据挖掘的区别

传统数据分析（统计分析）：是指根据分析目的，用适当的统计分析方法（采样、假设检验、参数估计、回归分析等）及工具（SPSS, Eviews, SAS），对收集来的数据（结构化）进行处理与分析，提取有价值的信息，发挥数据的作用。—展示

数据挖掘（Data Mining，DM）：又称数据库中的知识发现（Knowledge Discover in Database，KDD），是指通过统计学、人工智能、机器学习等方法，从大量的、不完全的、有噪声的、模糊的、随机的数据（非结构化）中提取隐含在其中的、人们事先不知道的、但又是潜在有用的信息和知识的过程。—挖掘

二、 python开发环境与编程规范 (ppt-2)

1、python编码规范

（1）缩进：

Python对代码缩进是硬性要求，严格使用缩进来体现代码的逻辑从属关系。一般以4个空格为一个缩进单位，并且相同级别的代码块应具有相同的缩进量。在函数定义、类定义、选择结构、循环结构、异常处理结构和with语句等结构中，对应的函数体或语句块都必须有相应的缩进。当某一行代码与上一行代码不在同样的缩进层次上，并且与之前某行代码的缩进层次相同，表示上一个代码块结束。

def toTxtFile(fn):                     # 函数定义
    with open(fn, 'w') as fp:          # 函数体开始，相对def缩进4个空格
        for i in range(10):            # with块开始，相对with缩进4个空格
            if i%3==0 or i%7==0:       # 选择结构开始，再缩进4个空格
                fp.write(str(i)+'\n')  # 语句块，再缩进4个空格
            else:                      # 选择结构的第else分支，与if对齐
                fp.write('ignored\n')
        fp.write('finished\n')         # for循环结构结束
    print('all jobs done')             # with块结束
toTxtFile('text.txt')                  # 函数定义结束，调用函数

（2）空格与空行

• 在每个类、函数定义或一段完整的功能代码之后增加一个空行，在运算符两侧各增加一个空格，逗号后面增加一个空格，让代码适当松散一点，不要过于密集。
• 在实际编写代码时，这个规范需要灵活运用。有些地方增加空行和空格会提高可读性，代码更加利于阅读。但是如果生硬地在所有运算符两侧和逗号后面都增加空格，却会适得其反。

（3）标注符命名

在程序设计中，变量名、函数名和类名往往统称为标识符。在为标识符起名字时，应做到“见名知义”，并遵守下面的规范。

• 必须以英文字母、汉字或下划线开头。虽然Python 3.x支持使用汉字作为标识符，但一般并不建议这样做。
• 名字中可以包含汉字、英文字母、数字和下画线，不能有空格或任何标点符号。
• 不能使用关键字，例如yield、lambda、def、else、for、break、if、while、try、return这样的变量名都是非法的。
• 对英文字母的大小写敏感，例如student和Student是不同的变量。
• 不建议使用系统内置的模块名、类型名或函数名以及已导入的模块名及其成员名作变量名或者自定义函数名，例如type、max、min、len、list这样的变量名都是不建议作为变量名的，也不建议使用math、random、datetime、re或其他内置模块和标准库的名字作为变量名或者自定义函数名。

（4）续行

尽量不要写过长的语句，应尽量保证一行代码不超过屏幕宽度。如果语句确实太长而超过屏幕宽度，最好在行尾使用续行符“\”表示下一行代码仍属于本条语句，或者使用圆括号把多行代码括起来表示是一条语句。

expression1 = 1 + 2 + 3\          # 使用\作为续行符
              + 4 + 5
expression2 = (1 + 2 + 3          # 把多行表达式放在圆括号中表示是一条语句
               + 4 + 5)

（5）注释

对关键代码和重要的业务逻辑代码进行必要的注释，方便代码的阅读和维护。在Python中有两种常用的注释形式：#和三引号。井号#用于单行注释，表示本行中#符号之后的内容不作为代码运行；三引号常用于大段说明性文本的注释，也可以用于界定包含换行符的长字符串。

（6）多行

圆括号除了用来表示多行代码为一条语句，还常用来修改表达式计算顺序或者增加代码可读性避免歧义。

（7）内置对象，标准库，扩展库

• Python所有内置对象不需要做任何的导入操作就可以直接使用，但标准库对象必须先导入才能使用，扩展库则需要正确安装之后才能导入和使用其中的对象。
• 作为建议，在编写代码时，一般先导入标准库对象再导入扩展库对象。
• 在程序中只导入确实需要使用的标准库和扩展库对象，确定用不到的没有必要进行导入，这样可以适当提高代码加载和运行速度，并能减小打包后的可执行文件体积

2、标准库和扩展库的导入（3 种）与使用方式

（1）import 模块名[ as 别名]

import math
import random
import posixpath as path     #Portable Operating System Interface of UNIX

print(math.sqrt(16))                 		# 计算并输出16的平方根
print(math.cos(math.pi/4))            		# 计算余弦值
print(random.choices('abcd', k=8))    		# 从字符串'abcd'随机选择8个字符
                                      		# 允许重复
print(path.isfile(r'C:\Windows\notepad.exe’)) 	# 测试指定路径是否为文件

（2）from 模块名 import 对象名[ as 别名]

from math import pi as PI
from os.path import getsize
from random import choice

r = 3
print(round(PI*r*r, 2))                      # 计算半径为3的圆面积
print(getsize(r'C:\Windows\notepad.exe'))    # 计算文件大小，单位为字节
print(choice('Python'))                      # 从字符串中随机选择一个字符

（3）from 模块名 import *

from itertools import *

characters = '1234'
for item in combinations(characters, 3):  # 从4个字符中任选3个的组合
    print(item, end=' ')                  # end=' '表示输出后不换行
print('\n'+'='*20)                        # 行号后输出20个等于号
for item in permutations(characters, 3):  # 从4个字符中任选3个的排列
    print(item, end=' ')

三、python数据类型与内置函数（ppt-3）

1.python 五种主要的数据容器

（1）列表

创建列表：

x_list = [1,2,3]

（2）元组

创建元组

x_tuple = (1,2,3)

（3）字典

创建字典

x_dict = {'a':97,'b':98,'c':99}

（4）集合

创建集合

x_set = {1,2,3}

（5）字符串

创建字符串

str = "hello world"

2、数据类型的特点

• 在Python中变量不直接存储值，而是存储值的内存地址或者引用，这样的内存管理方式与很多编程语言不同，也是变量类型随时可以改变的原因。
• 虽然Python变量的类型是随时可以发生变化的**，但每个变量在任意时刻的类型都是确定的。从这个角度来讲，Python属于**强类型编程语言。(类型固定，显示/强制转换)
• 在Python中，不需要事先声明变量名及其类型，使用赋值语句可以直接创建任意类型的变量，变量的类型取决于等号右侧表达式值的类型。
• 赋值语句的执行过程是：首先把等号右侧表达式的值计算出来，然后在内存中寻找一个位置把值存放进去，最后创建变量并指向这个内存地址。对于不再使用的变量，可以使用del语句将其删除。

3、内置函数：max,min,len,sum,sort,reversed,range

(1)最大值、最小值函数：max， min

data = [3, 22, 111]
print(data)
# 对列表中的元素直接比较大小，输出最大元素
print(max(data)) # 111
print(min(data))  # 3

(2)元素数量、求和函数：len, sum

data = [1, 2, 3, 4]
# 列表中元素的个数
print(len(data)) # 4
# 所有元素之和
print(sum(data)) # 10
data = (1, 2, 3)
print(len(data)) # 3
print(sum(data)) # 6

(3)排序、逆序: sort,reversed

list2 = [1,2,4,5,4,7,8]
list2.sort()
print(list2) # [1, 2, 4, 4, 5, 7, 8]

# reverse 逆序
list2.reverse()
print(list2) # [8, 7, 5, 4, 4, 2, 1]

(4)基本输入输出: input, print

num = int(input('请输入一个大于2的自然数：'))

(5)范围：range()

range1 = range(4)           # 只指定stop为4，start默认为0，step默认为1
range2 = range(5, 8)        # 指定start=5和stop=8，step默认为1
range3 = range(3, 20, 4)    # 指定start=3、stop=20和step=4
range4 = range(20, 0, -3)   # step也可以是负数
print(range1, range2, range3, range4)  #range(0, 4) range(5, 8) range(3, 20, 4) range(20, 0, -3)
print(range4[2])           #14
print(list(range1), list(range2), list(range3), list(range4))
#[0, 1, 2, 3] [5, 6, 7] [3, 7, 11, 15, 19] [20, 17, 14, 11, 8, 5, 2]
for i in range(10):
    print(i, end=' ')
# 0 1 2 3 4 5 6 7 8 9

(6)两组对象匹配打包：zip()

data = zip('1234', [1, 2, 3, 4, 5, 6])
print(data)
# 在转换为列表时，使用了zip对象中的全部元素，zip对象中不再包含任何内容
print(list(data))  #[('1', 1), ('2', 2), ('3', 3), ('4', 4)]
# 如果需要再次访问其中的元素，必须重新创建zip对象
data = zip('1234', [1, 2, 3, 4, 5, 6])
print(tuple(data))  #(('1', 1), ('2', 2), ('3', 3), ('4', 4))
data = zip('1234', [1, 2, 3, 4, 5, 6])
# zip对象是可迭代的，可以使用for循环逐个遍历和访问其中的元素
for item in data:
    print(item)
    <zip object at 0x000001E4DBA83B80>
# ('1', 1)
# ('2', 2)
# ('3', 3)
# ('4', 4)

(7)映射map()、累计映射reduce()、筛选filter()

• map()

from operator import add

print(map(str, range(5)))
print(list(map(str, range(5))))
print(list(map(len, ['abc', '1234', 'test']))) 
#['0', '1', '2', '3', '4']
#[3, 4, 4]

# 使用operator标准库中的add运算add运算相当于运算符+
# 如果map()函数的第一个参数func能够接收两个参数，则可以映射到两个序列上
for num in map(add, range(5), range(5,10)):
    print(num)

# 5
# 7
# 9
# 11
# 13

• reduce()

from functools import reduce
from operator import add, mul, or_

seq = range(1, 10)
print(reduce(add, seq))       # 累加seq中的数字
print(reduce(mul, seq))       # 累乘seq中的数字
seq = [{1}, {2}, {3}, {4}]
print(reduce(or_, seq))       # 对seq中的集合连续进行并集运算

# 45 362880 {1, 2, 3, 4}

• filter()

seq = ['abcd', '1234', '.,?!', '']
print(list(filter(str.isdigit, seq)))   # 只保留数字字符串
print(list(filter(str.isalpha, seq)))   # 只保留英文字母字符串
print(list(filter(str.isalnum, seq)))   # 只保留数字字符串和英文字符串
print(list(filter(None, seq)))          # 只保留等价于True的元素

# ['1234']
# ['abcd']
# ['abcd', '1234']
# ['abcd', '1234', '.,?!']

四、python数据容器（ppt-4）

1.列表和字典的创建与访问的最基本的操作

列表创建

>>> list((3, 5, 7, 9, 11))       # 将元组转换为列表
[3, 5, 7, 9, 11]
>>> list(range(1, 10, 2))        # 将range对象转换为列表
[1, 3, 5, 7, 9]
>>> list(map(str, range(10)))    # 将map对象转换为列表, 函数映射
['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
>>> list(zip('abcd', [1,2,3,4])) # 将zip对象转换为列表，压缩(匹配)
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
>>> list(enumerate('Python'))    # 将enumerate对象转换为列表，遍历
[(0, 'P'), (1, 'y'), (2, 't'), (3, 'h'), (4, 'o'), (5, 'n')]
>>> list(filter(str.isdigit, 'a1b2c3d456')) # 将filter对象转换为列表
['1', '2', '3', '4', '5', '6']
>>> list('hello world')          # 将字符串转换为列表，每个字符转换为列中的一个元素
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']
>>> list({3, 7, 5})              # 将集合转换为列表，集合中的元素是无序的
[3, 5, 7]
>>> x = list()                   # 创建空列表
>>> x = [1, 2, 3]
>>> del x                        # 删除列表对象
>>> x                            # 对象删除后无法再访问，抛出异常
NameError: name 'x' is not defined

列表访问

data = list(range(10))
print(data) #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(data[0])              # 第一个元素的下标为0， 0
print(data[1])              # 第二个元素的下标为1，1
print(data[-1])             # -1表示最后一个元素的下标，9
print(data[15])             # 15不是有效下标，代码抛出异常
                          IndexError: list index out of range

字典的创建

data = dict(name='张三', age=18, sex='M')
print(data)
data = dict.fromkeys([1, 2, 3, 4])    # 以指定的数据为“键”，“值”为空
print(data)
data = dict(zip('abcd', [97,98,99,100])) #zip {'a': 97, 'b': 98, 'c': 99, 'd': 100}
print(data)
data = {ch:ord(ch) for ch in 'abcd'}  # 字典推导式,ord返回字符ch的编码
print(data)

字典的访问

data = dict(name='张三', age=18, sex='M')
print(data['name'])                         # 使用“键”作为下标，访问“值”，张三
print(data.get('age'))                      # 18
print(data.get('address', '不存在这个键'))   # “键”不存在，返回默认值 '不存在这个键'
print(list(data))                           # 把所有的“键”转换为列表
print(list(data.values()))                  # 把所有的“值”转换为列表
print(list(data.items()))                   # 把所有的元素转换为列表, 元素=键值对儿
for key, value in data.items():             # 遍历字典的“键：值”元素
    print(key, value, sep='\t')

2.列表和字典的修改、增加和删除操作

列表常用方法：

append()（添加元素）、insert()（插入元素）、extend()（末尾插入多个元素）、pop()、remove()、count()、index()、sort()、reverse()

lst = [1, 2, 3, 4]
lst.append(5) 
lst.insert(0, 0) # insert(位置，值)
lst.insert(2, 1.5)
lst.extend([6, 7])
print(lst) # [0, 1, 1.5, 2, 3, 4, 5, 6, 7]

lst = [1, 2, 3, 4, 5, 6]
print(lst.pop())            # 删除并返回最后一个元素, 6
print(lst.pop(0))           # 删除并返回下标为0的元素，后面的元素向前移动,1
print(lst.pop(2))           # 删除并返回下标为2的元素，后面的元素向前移动,4
print(lst) # [2, 3, 5]
lst = [1, 2, 3, 2, 4, 2] 
lst.remove(2)               # 删除第一个2，该方法没有返回值
print(lst) # [1, 3, 2, 4, 2]

字典常用方法：

（1）当以指定“键”为下标为字典元素赋值时，有两种含义：

1）若该“键”存在，表示修改该“键”对应的值；

2）若不存在，表示添加一个新元素。

sock = {'IP': '127.0.0.1', 'port': 80}
sock['port'] = 8080                  # 修改已有元素的“值”
sock['protocol'] = 'TCP'             # 增加新元素
print(sock)   #{'IP': '127.0.0.1', 'port': 8080, 'protocol': 'TCP'}

（2）使用字典对象的update()方法可以将另一个字典的元素一次性全部添加到当前字典对象，如果两个字典中存在相同的“键”，则以另一个字典中的“值”为准对当前字典进行更新

sock = {'IP': '127.0.0.1', 'port': 80}
# 更新了一个元素的“值”，增加了一个新元素
sock.update({'IP':'192.168.9.62', 'protocol':'TCP'})
print(sock) #{'IP': '192.168.9.62', 'port': 80, 'protocol': 'TCP'}

（3）可以使用字典对象的pop()删除指定“键”对应的元素，同时返回对应的“值”。字典方法popitem()方法用于删除并返回一个包含两个元素的元组，其中的两个元素分别是字典元素的“键”和“值”。另外，也可以使用del删除指定的“键”对应的元素。

sock = {'IP': '192.168.9.62', 'port': 80, 'protocol': 'TCP'}
print(sock.pop('IP'))           # 删除并返回指定“键”的元素 192.168.9.62
print(sock.popitem())           # 删除并返回一个元素 ('protocol', 'TCP')
del sock['port']                # 删除指定“键”的元素
print(sock)                     # {}

五、python结构、函数与文件操作 (ppt-5)

1、选择（if）和循环（for）的基本结构

例4.2 首先生成[1,100]区间上的一个随机数，然后根据随机数的范围生成变量sex的值，当随机 数大于51时把sex设置为男，否则设置为女。

from random import randint
if randint(1, 100)>51:
sex = '男'
else:
sex = '女'
print(sex)

例4.3 编写程序，输出各位数字都不相同的所有三位数。

for n in range(200, 1, -1): # 从大到小遍历[200,2]
for i in range(2, n): # 遍历[2, n-1]区间的自然数
if n%i == 0: # 如果n有因数，就不是素数
break # 提前结束内循环，不执行else语句
else: # 如果内循环自然结束，继续执行这里的代码
print(n) # 输出素数
break # 结束外循

2、文件打开与关闭方法

Python内置函数open()使用指定的模式打开指定文件并创建文件对象， 该函数完整的用法如下：

open(file, mode='r', buffering=-1, encoding=None,
errors=None, newline=None, closefd=True, opener=None)