机器学习之python基础

本系列机器学习教程不仅仅记录算法算理，还会记录算法具体实现，本篇主要是总结python的基础语法，以及python在数据分析、机器学习中常用的库，例如numpy、pandas、matplotlib。那么，接下来我就总结一下编程基础知识点吧。

python内置数据类型

list

list实际上指一种有序的集合，list数据的数据类型可以不同，并且可以嵌套list。对于list数据类型的数据，我们可以进行的操作如下：
以下操作均是对list_1=[‘michelle’,’alex’,’anthony’,’linda’,’tom’]进行操作

增
在列表末尾追加‘jack’元素：
1
list_1.append('jack')
在列表指定位置插入元素：在索引号为0的位置增加一个‘lucy’元素
1
list_1.insert(0,'lucy')
删
删除list末尾的元素：
1
list_1.pop()
删除list指定位置(例如索引为0)的元素：
1
list_1.pop(0)
改
修改list某个位置的元素(例如将索引号为2的元素改为‘lili’)：
1
list_1[2]='lili'
查
可以通过下角标的方式(例如查找索引号为2的数据)：
1
2
list_1[2]
len(list_1)%查询list的长度

tuple

tuple和list类似，tuple不可更改，没有增加删除操作，只有查询操作。tuple用()包裹自己的元素，list用[]包裹自己的元素

dictionary

dictionary是以key-value形式存储的,键是唯一、不可变的。下面以dict_1={‘michelle’:18,’tom’:’16’,’lily’:20}为例，总结一下关于dict的常用操作：

增
向字典添加新内容的方法就是增加新的键值对：
1
dict_1['susan']=18 #增加了新的键值对

删
删除某一个键及其所对应的值

1	del dict_1['tom'] #删除'tom'这一条目

清空字典所有条目

1	dict_1.clear() #删除'tom'这一条目

改
通过索引键来修改相应的值

1	dict_1['lily']=11 #修改'lily'这一条目

查
因为dict是以键值对形式存储，键又是唯一的，可以通过键来访问数据.
1
print("%s"%(dict_1['tom']))
若访问dict里面没有的键的值会报错。在这里介绍一下容错处理：判断键是否存在
1
2
'tom' in dict_1 #若不存在，返回的是false,存在返回true
dict_1.get('tom') #若不存在，返回的是none，存在返回键所对应的值。

set

set和dict类似，也是一组key的集合，是无序存放的，但不存储value。由于key不能重复，所以在set中没有重复的key，即我们通常所说的集合。

创建:通过list创建,重复元素被自动过滤
1
s=set([1,3,1,3,5,7])
增
增加元素的方式：add(key)
1
s.add(9)
删
删除key的方式：remove(key)
1
s.remove(9)

python三大分支结构

顺序结构

顺序结构的执行顺序是从上向下，依次执行。在这里我们举一个小例子，输入用户的姓名，并输出。

1 2	name=input("请输入您的姓名:") print("%s,欢迎您！！！"%(name))

选择结构

if….elif…..else…..
注意在python中选择结构没有switch…..case。
举个例子，判断一个人输入的年龄:

age=int(input("请输入您的年龄"))#注意在python3这里，input返回的是str类型，需要强制类型转换
if age<=18:
    print("你好，青少年")
elif age<=40:
    print("你好，青年人")
else:
    print("你好，中年人")

循环结构

for
举个例子：循环输出1到10

1 2	for i in range(10):#range(10)，生成0.....9的列表 print(i+1)

while
举个例子：循环输出1到10

i=1
while i<10:
    print("i is %d"%(i))
    i=i+1

pythonIO编程

读写文件

读文件
读写文件都有可能产生IOError，所以说，我们在打开文件读取文件内容，常用的是：

1 2	with open('hello.txt','r') as f: #以只读的方式打开 print(f.read()) #一次性读取文件的全部内容，对文件操作完之后不必再使用close。

若文件内容很大，就会占用很多资源，为保险起见，我们可以采用readlines()函数一行一行的度：

1
2
3

with open('hello.txt','r') as f:	#以只读的方式打开
    for line in f.readlines():	#循环读取文件的每一行
        print(line.strip())	#打印每一行

关于读取二进制文件，比如说图像、视频，我们可以以’rb’模式打开文件即可。

写文件

1
2

with open('hello.txt','w') as f:	#以只写的方式打开，
    f.write('hello,world')	#若文件存在，直接覆盖(若不想覆盖可以考虑以追加'a'的方式在文件末尾添加)，若不存在，创建并写入

读写内存

操作str

from io import StringIO    #导入StringIO模块
f=StringIO()	#创建一个StringIO内存
f.write('hello')	#在内存中写内容
f.getvalue()	#读取文件中的内容
f.readlines()	#一行行地读

操作二进制数据

from io import BytesIO    #导入BytesIO模块
f=BytesIO()	#创建一个StringIO内存,也可以用一个byte初始化
f.write('中文'.encode('utf-8'))	#在内存中写内容
f.getvalue()	#读取文件中的内容
f.readlines()	#一行行地读

系统函数调用

查看系统类型
1
2
import os
print(os.name) #如果是'posix'，说明系统是linux、unix、mac，如果是'nt',则是windows OS.
os是和操作系统相关的，在不同的OS上面，os模块所支持的函数是不同的。

查看系统变量

1 2	import os print(os.environ) #环境变量是以键值对也就是字典形式存储，可以通过键找到相应的value

操作目录

import os
os.path.abspath('.')	#查看当前路径的绝对路径
os.mkdir('hello')	#在当前路径下创建一个目录
os.rm('hello')	#删除当前路径的一个目录

操作文件

1
2
3

import os
os.rename('python.py','python.txt')	#重命名一个文件
os.remove('python.txt')	#删除一个文件

python线程和进程

概念解析：
多任务：操作系统可以同时运行多个任务，比如说你一边在上网，一边在写文档，一边听歌，这就是多任务。操作系统是如何实现多任务的呢？操作系统是轮流让各个任务交替执行，表面上看这些任务是同时执行的，但实际上是操作系统执行速度太快了，我们感觉像是在同时执行一样。
进程：一个任务就是一个进程。比如说打开浏览器就是启动一个进程。
线程：进程内的子任务。比如说，word它可以同时进行打字、拼写检查，在一个任务内，要同时干很多事情，这些就会被称之为子任务。
多任务的实现方式总结来说：
多进程模式；多线程模式；多进程+多线程模式

多进程

在python中，在linux下用os模块中的fork函数即可创建一个进程，系统会自动将当前进程的资源复制了一份给子进程。windows下面没有fork调用。
创建一个子进程代码实现如下:

import os
print("%s start..."%(os.getpid()))	#获取当前进程ID号
pid=os.fork()	#当前进程创建子进程，返回值为0，则是子进程，返回值为非0（子进程ID号），则是父进程。
if pid==0:
    print("I am child process %s and my father process is %s"%(os.getpid(),os.getppid()))
else:
    print("I am father process %s, my child process is %s"%(os.getpid(),pid))

创建多个子进程代码实现如下，在windows平台可以使用（跨平台）:

from multiprocessing import Process 	#multiprocessing模块是跨平台版本的多进程模块。
import os

def run_proc(name):
    print('Run child process %s (%s)...' % (name, os.getpid()))

if __name__=='__main__':	#函数入口处
    print('Parent process %s.' % os.getpid())	#获得父进程的ID号
    p = Process(target=run_proc, args=('test',))	#创建一个子进程，子进程运行run_proc函数，args是给函数传递的参数
    print('Child process will start.')
    p.start()	#启动子进程
    p.join()	#等待子进程结束
    print('Child process end.')

如果有大量的子进程需要启动，则采用进程池的方式创建。

多线程

import time, threading

#新线程执行的代码:
def loop():
    print('thread %s is running...' % threading.current_thread().name)
    n = 0
    while n < 5:
        n = n + 1
        print('thread %s >>> %s' % (threading.current_thread().name, n))
        time.sleep(1)
    print('thread %s ended.' % threading.current_thread().name)

print('thread %s is running...' % threading.current_thread().name) #主线程
t = threading.Thread(target=loop, name='LoopThread')#创建一个线程，名称为LoopThread
t.start()	#线程启动
t.join()	#等待线程结束
print('thread %s ended.' % threading.current_thread().name)

numpy

numpy比python原生派数据结构速度快、灵活，支持更多的数据类型。

创建numpy array

一般是通过list或者是tuple来创建。

import numpy as np
list_1=[1,2,3,4]
numpy_list=np.array(list_1,dtype='int')  #dtype指定了数据元素的类型
tuple_1=('123','456')
numpy_tuple=np.array(tuple_1,dtype='str') 
print(numpy_list)
print(numpy_tuple)

创建特殊的array

numpy_zero=np.zeros([2,2])  #创建2*2全为0的array
numpy_one=np.ones([2,2])	#创建2*2全为1的array
numpy_eye=np.eye(5)		#创建5*5主对角线全为1的array
np.arange(1,10,3)	#创建一个1-10，等差为3的等差数列，不包括10
np.linspace(0,11,4)  #创建一个0-11的四等分的array

对array的操作

有一般的矩阵加减乘除，在这里不在赘述。
生成0-1的随机数组成的array

1	num = np.random.random([3,3]) #3*3是array的shape

生成标准正太分布的数组成的array

1	num = np.random.randn([3,3]) #3*3是array的shape，数字服从标准正太分布

计算统计量

num_sum = num.sum()	#计算array各元素之和  
num_max	= num.max()	#计算array中最大的值  
num_min	= num.min()	#计算array中最小的值  
num_mean = num.mean() #计算array中的平均值
num_std = num.std()  #计算array中各元素的标准差 
num_var = num.var()  #计算array中各元素的方差
num_row_sum = num.sum(axis=1)	#计算每一行中各元素之和 
num_columns_min = num.sum(axis=0)	#计算array中每一列各元素之和

切片、去重、排序

1
2
3

num_slice=num[1,:]	#获取第二行中所有元素  
np.unique(num_slice)    #去重 
np.sort(num_slice)    #从小到大排序

对矩阵的基本操作

num_t = num.T #num的转置 
from numpy.linalg import inv  
num_inv = inv(num) #num的逆矩阵  
num_trace=np.trace(num)  #num对角线上的和

numpy的条件表达式

1	t=np.where(condition,A,B) #condition为真，t=A，反之，t=B

pandas

pandas主要提供了两种数据格式，一种为Series和DataFrame两种数据类型的格式。

Series

Series数据类型主要由索引号和值构成，在默认情况下，索引号为1,2,….

创建
可以由list创建

1
2
3

import pandas as pd
import numpy as np
s = pd.Series([1,2,3,4,5,'str',np.nan],index=['a','b','c','d','e','f','g'])

查看

 
print(s['a'])	#通过索引查看相应的value
print(s.loc['a'])  #通过定位索引来查看相应的value
print(s.iloc[0]) 	#通过下角标来查看相应的value 

s.index #查看s所有的索引  
s.values #查看s所有的value
s.size  #查看元素的个数
s.shape  #查看元素的维度
s.sort_value() #按照value大小进行排序 
s.describe() #输出值的一些描述信息


s.head(5)	#查看前5个元素
s.tail(3)	#从后向前数，后三个

删除
1
2

print(df.drop('e')) #删除'e'所对应值
DataFrame
DataFrame可以认为是传统意义上的表格,主要由索引(行名)、列名以及相应的值构成。

创建

1	df = pd.DataFrame({'day1':[90,100, 95], 'day2':[60, 80, 100]}, index=['math', 'english', 'python'])

查找

  
print(df.index) 	#输出索引，即行名
print(df.columns) 	#输出列名 
print(df.values) 	#输出value
print(df.shape) 	#输出维度
print(df.size)		#输出数据元素的个数
print(df.head(2)) 	#输出前两行
print(df.tail(2)) 	#输出最后面两行 
print(df.describe()) 	#输出描述信息 
print(df.loc['day1']) 	#输出'day1'对应列所有的元素
print(df.loc['day1'].loc['math']) #输出结果为90，等价于df.iloc[0][0]

删除

1 2	print(df.drop('english')) #删除'english'所对应的每一行

matplotlib

直方图

import matplotlib 
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from IPython.display import Image
from IPython.display import *

#设置随机种子
np.random.seed(8)

mu, sigma = 50, 3
x = mu + sigma * np.random.randn(10000)

n, bins, patches = plt.hist(x, 50, normed=1, facecolor='b', alpha=0.5)#画直方图，返回值中，bins是各个bin的区间起始点

plt.xlabel('Num')
plt.ylabel('Probability')
plt.title('Histogram')
plt.text(60, .025, g'$\mu=50,\ \sigma=3$')
plt.axis([50, 150, 0, 0.04])
plt.grid(True)
plt.show()

散点图

N = 20
x = np.random.rand(N)
y = np.random.rand(N)
c = np.random.rand(N)
area = np.pi * (10 * np.random.rand(N))**2  
plt.scatter(x, y, s=area, c=c, alpha=0.5)
plt.show()