目录

• zip和enumerate
• try  except异常处理语句
• Python 对文件的读写
• 连接mysql数据库
• numpy
• pandas
• python画图

0、zip和enumerate

 zip的作用：可以在处理循环时用到，返回一个将多个可迭代对象组合成一个元组序列的迭代器。每个元组都包含所有可迭代对象中该位置的元素：

letters = ['a', 'b', 'c']
nums = [1, 2, 3]

for letter, num in zip(letters, nums):
    print("{}: {}".format(letter, num))

结果：
  a: 1
  b: 2
  c: 3

enumerate 是一个会返回元组迭代器的内置函数，这些元组包含列表的索引和值。当你需要在循环中获取可迭代对象的每个元素及其索引时，将经常用到该函数：

letters = ['a', 'b', 'c', 'd', 'e']
for i, letter in enumerate(letters):
    print(i, letter)


结果：
  0 a
  1 b
  2 c
  3 d
  4 e

1、try  except的使用

有时在写程序的时候，会出现一些错误或异常，导致程序终止。例如，做除法时，除数为0，会引起一个ZeroDivisionError

a=10
b=0
c=a/b
print ("done")

结果：
ZeroDivisionError: division by zero

程序因为ZeroDivisionError而中断了，语句print “done” 没有运行。为了处理异常，我们使用try…except,更改代码：

a=10
b=0
try:
    c=a/b
    print(c)
except ZeroDivisionError as e:
    print(e)
finally:
    print('finally...')
print("done")

结果：
division by zero finally...
done

这样程序就不会因为异常而中断，从而print “done”语句正常执行。

总结：当我们认为某些代码可能会出错时，就可以用try来运行这段代码，如果执行出错，则后续代码不会继续执行，而是直接跳转至错误处理代码，即except语句块，执行完except后，如果有finally语句块，则执行finally语句块，至此，执行完毕。

注：当你有多个异常，可添加多个except，如：

try:
    print('try...')
    r = 10 / int('2')
    print('result:', r)
except ValueError as e:
    print('ValueError:', e)
except ZeroDivisionError as e:
    print('ZeroDivisionError:', e)
else:
    print('no error!')
finally:
    print('finally...')
print('END')

异常类型：

2、python对文件的读写

读文件

打开一个文件用open()方法(open()返回一个文件对象，它是可迭代的)：

f = open('/Users/gama/test.txt', 'r')

标示符’r’表示读，这样，就成功地打开了一个文件。如果文件不存在，open()函数就会抛出一个IOError的错误

如果文件打开成功，接下来，调用read()方法可以一次读取文件的全部内容，Python把内容读到内存，用一个str对象表示：

f.read()

最后一步是调用close()方法关闭文件。文件使用完毕后必须关闭，因为文件对象会占用操作系统的资源，并且操作系统同一时间能打开的文件数量也是有限的：

f.close()

由于文件读写时都有可能产生IOError，一旦出错，后面的f.close()就不会调用。所以，为了保证无论是否出错都能正确地关闭文件，我们可以使用try ... finally来实现：

try:
    f = open('/path/to/file', 'r')
    print(f.read())
finally:
    if f:
        f.close()

但是每次都这么写实在太繁琐，所以，引入了with语句来自动帮我们调用close()方法：

with open('/path/to/file', 'r') as f:
    print(f.read())

这和前面的try ... finally是一样的，但是代码更简洁，并且不必调用f.close()方法。

调用read()会一次性读取文件的全部内容，如果文件有10G，内存就爆了，所以，要保险起见，可以反复调用read(size)方法，每次最多读取size个字节的内容。另外，调用readline()可以每次读取一行内容，调用readlines()一次读取所有内容并按行返回list。因此，要根据需要决定怎么调用。

如果文件很小，read()一次性读取最方便；如果不能确定文件大小，反复调用read(size)比较保险；如果是配置文件，调用readlines()最方便：

for line in f.readlines():
    print(line.strip()) # 把首末尾的'\n'或者空格删掉

之前说的默认都是读取文本文件，并且是UTF-8编码的文本文件。要读取二进制文件，比如图片、视频等等，用'rb'模式打开文件即可：

f = open('/Users/gama/test.jpg', 'rb')

要读取非UTF-8编码的文本文件，需要给open()函数传入encoding参数，例如，读取GBK编码的文件：

f = open('/Users/gama/gbk.txt', 'r', encoding='gbk')

写文件

写文件和读文件是一样的，唯一区别是调用open()函数时，传入标识符'w'或者'wb'表示写文本文件或写二进制文件：

f = open('/Users/gama/test.txt', 'w')
f.write('Hello, python,this is a test !')
f.close()

python读写模式

 3、连接mysql数据库

 创建一个函数来实现连接数据库，并且执行对应sql，并返回sql查询结果：

import pymysql as pms

def get_datas(sql):
    # 一个传入sql导出数据的函数
    # 跟数据库建立连接
    conn = pms.connect(host='实例地址', user='用户',
                       passwd='密码', database='库名', port=3306, charset="utf8")
    # 使用 cursor() 方法创建一个游标对象 cursor
    cur = conn.cursor()
    # 使用 execute() 方法执行 SQL
    cur.execute(sql)
    # 获取所需要的数据
    datas = cur.fetchall()
    #关闭连接
    cur.close()
    #返回所需的数据
    return datas

4、numpy

NumPy 是一个 Python 包。 它代表 “Numeric Python”。 它是一个由多维数组对象和用于处理数组的例程集合组成的库。

使用NumPy，可以执行以下操作：

• 数组的算数和逻辑运算。

• 傅立叶变换和用于图形操作的例程。

• 与线性代数有关的操作。 NumPy 拥有线性代数和随机数生成的内置函数。

numpy 中定义的最重要的对象是称为 ndarray 的 N 维数组类型。 它描述相同类型的元素集合。 可以使用基于零的索引访问集合中的项目。

创建一个2维数组：

import numpy as np 
a = np.array([[1,  2],  [3,  4]])  
print(a)

numpy的数组属性：

ndarray.shape 返回一个包含数组维度的元组，它也可以用于调整数组大小。

import numpy as np 
a = np.array([[1,2,3],[4,5,6]])  
print(a.shape)

结果：
(2, 3)

# 调整数组大小  
import numpy as np 
a = np.array([[1,2,3],[4,5,6]]) a.shape =  (3,2)  
print (a)

或者
import numpy as np 
a = np.array([[1,2,3],[4,5,6]]) 
b = a.reshape(3,2)  
print(b)

ndarray.ndim返回数组的最小维数

import numpy as np
a = np.array([[1,2,3],[4,5,6]])
print(a.ndim)

numpy.itemsize返回数组中每个元素的字节单位长度

# 数组的 dtype 为 int8(一个字节)  
import numpy as np 
x = np.array([1,2,3,4,5], dtype = np.int8)  
print(x.itemsize)

numpy数组创建例程

numpy.empty创建指定形状和dtype的未初始化数组:

numpy.empty(shape, dtype = float, order = 'C')
#Shape 空数组的形状，整数或整数元组
#Dtype 所需的输出数组类型，可选
#Order 'C'为按行的 C 风格数组，'F'为按列的 Fortran 风格数组

import numpy as np 
x = np.empty([3,2], dtype = int)  
print(x)

numpy.zeros返回特定大小，以 0 填充的新数组：

numpy.zeros(shape, dtype = float, order = 'C')

同理 numpy.ones

现有数据转数组

numpy.array将 Python 序列转换为ndarray：

numpy.asarray(a, dtype = None, order = None)

#a 任意形式的输入参数，比如列表、列表的元组、元组、元组的元组、元组的列表
#dtype 通常，输入数据的类型会应用到返回的ndarray
#order 'C'为按行的 C 风格数组，'F'为按列的 Fortran 风格数组

# 将列表转换为 ndarray 
import numpy as np 

x =  [1,2,3] 
a = np.asarray(x)  
print(a)

从数值范围创建数组

numpy.arange 返回ndarray对象，包含给定范围内的等间隔值。

numpy.arange(start, stop, step, dtype)

#start 范围的起始值，默认为0
#stop 范围的终止值(不包含)
#step 两个值的间隔，默认为1
#dtype 返回ndarray的数据类型，如果没有提供，则会使用输入数据的类型。

# 设置了起始值和终止值参数  
import numpy as np
x = np.arange(10,20,2)  
print x

结果:
[10  12  14  16  18]

numpy切片和索引

基本切片是 Python 中基本切片概念到 n 维的扩展。 通过将
start，
stop和
step参数提供给内置的
slice函数来构造一个 Python
slice对象。 再把
slice对象被传递给数组来提取数组的一部分。

import numpy as np
a = np.arange(10)
s = slice(2,7,2)  
print(a[s])

结果：
[2  4  6]

通过将由冒号分隔的切片参数(start:stop:step)直接提供给ndarray对象，也可以获得相同的结果。

切片还可以包括省略号(...)：

# 最开始的数组
import numpy as np
a = np.array([[1,2,3],[3,4,5],[4,5,6]])
print('数组是：')
print(a)
print('\n')
# 这会返回第二列元素的数组：
print('第二列的元素是：')
print(a[...,1])
print('\n')
# 现在我们从第二行切片所有元素：
print('第二行的元素是：')
print(a[1,...])
print('\n')
# 现在我们从第二列向后切片所有元素：
print('第二列及其剩余元素是：')
print(a[...,1:])

整数索引是整数数组表示该维度的下标值：

import numpy as np 

x = np.array([[1,  2],  [3,  4],  [5,  6]]) 
y = x[[0,1,2],  [0,1,0]]  
print(y)

结果：
[1  4  5]

该结果包括数组中(0,0)，(1,1)和(2,0)位置处的元素。

布尔索引:当结果对象是布尔运算(例如比较运算符)的结果时，将使用此类型的高级索引。

import numpy as np 
x = np.array([[  0,  1,  2],[  3,  4,  5],[  6,  7,  8],[  9,  10,  11]])  
print  '我们的数组是：'  
print x 
print  '\n'  
# 现在我们会打印出大于 5 的元素  
print  '大于 5 的元素是：'  
print x[x >  5]

结果：
我们的数组是：
[[ 0  1  2] 
 [ 3  4  5] 
 [ 6  7  8] 
 [ 9 10 11]] 

大于 5 的元素是：
[ 6  7  8  9 10 11]

5、pandas

Pandas 是基于 NumPy 的一个开源 Python 库，它被广泛用于快速分析数据，以及数据清洗和准备等工作。它的名字来源是由“ Panel data”（面板数据，一个计量经济学名词）两个单词拼成的。可以把 Pandas 看作是 Python 版的 Excel。

安装pandas：

conda install pandas #若已安装anaconda
pip install pandas #未安装anaconda

Pandas的主要数据结构：

• Series 系列
• DataFrame 数据帧
• Panel 面板

Series创建：

系列(Series)是能够保存任何类型的数据(整数，字符串，浮点数，Python对象等)的一维标记数组。轴标签统称为索引。

import pandas as pd
import numpy as np
 
# 创建Series
a1 = pd.Series([1, 2, 3])  # 数组生成Series
a2 = pd.Series(np.array([1, 2, 3]))  # numpy数组生成Series
a3 = pd.Series([1, 2, 3], index=["index1", "index2", "index3"])  # 指定标签index生成
a4 = pd.Series({"index1": 1, "index2": 2, "index3": 3})  # 字典生成Series
a5 = pd.Series({"index": 1, "index2": 2, "index3": 3}, index=["index1", "index2", "index3"])  # 字典生成Series,指定index，不匹配部分为NaN
a6 = pd.Series(10, index=["index1", "index2", "index3"])

Series属性：

a1 = pd.Series([1, 2, 3])
index = a1.index  # Series索引
values = a1.values  # Series数值
a1.name = "population"  # 指定Series名字
a1.index.name = "state"  # 指定Series索引名字

Series查找元素：

a3 = pd.Series([1, 2, 3], index=["index1", "index2", "index3"])
# 查找元素
value1 = a3["index1"]  # 索引查找元素
value2 = a3.index1  # 键值索引查找元素
value3 = a3[0]  # 绝对位置查找元素
value4 = a3[["index1", "index2"]]  # 花式索引
value5 = a3[[0, 1]]  # 花式索引
value6 = a3[a3 > np.mean(a3)]  # 布尔值查找元素
value7 = a3[0:2]  # 绝对位置切片
value8 = a3["index1":"index3"]  # 索引切片

Series修改元素：

# 修改元素
a3["index3"] = 100  # 按照索引修改元素
a3[2] = 1000  # 按照绝对位置修改元素

Series添加元素：

# 添加元素
a3["index4"] = 10  # 按照索引添加元素

Series删除元素：

a3.drop(["index4", "index3"], inplace=True)  # inplace=True表示作用在当前Series
print(a3)  # index1 1 index2 2

Series方法：

a3 = pd.Series([1, 2, 3], index=["index1", "index2", "index3"])
a3["index3"] = np.NaN  # 添加元素
a3.isnull()  # 判断Series是否有缺失值
a3.notnull()  # 判断Series是否没有缺失值
print("index1" in a3)  # 判断Series中某个索引是否存在
a3.isin([1])  # 判断Series中某个值是否存在
a3.unique()  # 统计Series中去重元素
a3.value_counts()  # 统计Series中去重元素和个数

数据帧(DataFrame)是二维数据结构，即数据以行和列的表格方式排列。

数据帧(DataFrame)的功能特点：

• 潜在的列是不同的类型
• 大小可变
• 标记轴(行和列)
• 可以对行和列执行算术运算

pandas中的
DataFrame可以使用以下构造函数创建：

pandas.DataFrame( data, index, columns, dtype, copy)

#data：数据采取各种形式，如:ndarray，series，map，lists，dict，constant和另一个DataFrame
#index:对于行标签，要用于结果帧的索引是可选缺省值np.arrange(n)，如果没有传递索引值。
#columns:对于列标签，可选的默认语法是 - np.arange(n)。 这只有在没有索引传递的情况下才是这样。
#dtype:每列的数据类型。
#copy:如果默认值为False，则此命令(或任何它)用于复制数据。

import pandas as pd
web_stats = {'Day':[1,2,3,4,5,6],
             'Visitors':[43,34,65,56,29,76],
             'Bounce Rate':[65,67,78,65,45,52]}
df = pd.DataFrame(web_stats)
print(df.head(5))

结果：
   Bounce Rate  Day  Visitors
0           65    1        43
1           67    2        34
2           78    3        65
3           65    4        56
4           45    5        29

看到左边有这些数字，0,1,2,3,4等等，就像行号一样。 这些数字实际上是你的“索引”。 数据帧的索引是数据相关，或者数据按它排序的东西。 一般来说，这将是连接所有数据的变量。如果要设置一个新的索引：

df.set_index('Day', inplace=True)

输出结果：
     Bounce Rate  Visitors
Day                       
1             65        43
2             67        34
3             78        65
4             65        56
5             45        29

从列表来创建DataFrame:

import pandas as pd
data = [['Alex',10],['Bob',12],['Clarke',13]]
df = pd.DataFrame(data,columns=['Name','Age'],dtype=float)
print(df)

从系列的字典来创建DataFrame:

import pandas as pd

d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
      'two' : pd.Series([1, 2, 3, 4], index=['a', 'e', 'c', 'd'])}

df = pd.DataFrame(d)
print(df)

结果：
   one  two
a  1.0  1.0
b  2.0  NaN
c  3.0  3.0
d  NaN  4.0
e  NaN  2.0

DataFrame选择和切片：

import pandas as pd

d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
      'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}

df = pd.DataFrame(d)
print(df ['one']) #列选择
df['three']=pd.Series([10,20,30],index=['a','b','c'])#列添加
del df['one'] #列删除
df.pop('two') #列删除
print(df.loc['b']) #行选择
print(df[2:4]) #行切片

df2 = pd.DataFrame([[5, 6], [7, 8]], columns = ['one','two'])
df = df.append(df2) #行添加
df = df.drop('a') #删除行
print(df.loc[:,['one','two']])  #表示选取所有的行以及columns为'one','two'的列

DataFrame转置

import pandas as pd
import numpy as np

# Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Minsu','Jack']),
   'Age':pd.Series([25,26,25,23,30,29,23]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}

# Create a DataFrame
df = pd.DataFrame(d)
print("before:")
print(df)
print ("after:")
print(df.T)

print(df.axes) #返回轴标签和列轴标签列表

DataFrame统计性描述

import pandas as pd
import numpy as np

#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Minsu','Jack',
   'Lee','David','Gasper','Betina','Andres']),
   'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])}

#Create a DataFrame
df = pd.DataFrame(d)
print(df.describe())

结果：
               Age         Rating
count    12.000000      12.000000
mean     31.833333       3.743333
std       9.232682       0.661628
min      23.000000       2.560000
25%      25.000000       3.230000
50%      29.500000       3.790000
75%      35.500000       4.132500
max      51.000000       4.800000

 统计函数：

面板(Panel)是3D容器的数据

pandas.Panel(data, items, major_axis, minor_axis, dtype, copy)

3轴(axis)这个名称旨在给出描述涉及面板数据的操作的一些语义。它们是 :

• items – axis 0，每个项目对应于内部包含的数据帧(DataFrame)。
• major_axis – axis 1，它是每个数据帧(DataFrame)的索引(行)。
• minor_axis – axis 2，它是每个数据帧(DataFrame)的列。

从DataFrame对象的dict创建面板:

#creating an empty panel
import pandas as pd
import numpy as np

data = {'Item1' : pd.DataFrame(np.random.randn(4, 3)), 
        'Item2' : pd.DataFrame(np.random.randn(4, 2))}
p = pd.Panel(data)
print(p)

要从面板中访问数据，可以使用以下方式：

• Items
• Major_axis
• Minor_axis

# creating an  panel
import pandas as pd
import numpy as np
data = {'Item1' : pd.DataFrame(np.random.randn(4, 3)), 
        'Item2' : pd.DataFrame(np.random.randn(4, 2))}
p = pd.Panel(data)
print(p['Item1'])
print(p.major_xs(1))
print(p.minor_xs(1))

pandas读写文件

data = pd.read_csv("data.txt")#从文件、URL、文件新对象中加载带有分隔符的数据，默认分隔符是逗号。
data = pd.read_table("data.txt",sep=",")#从文件、URL、文件型对象中加载带分隔符的数据，默认分隔符为制表符("\t")
文件没有标题:
data1 = pd.read_csv("data.txt",header=None)#设置header参数，读取文件的时候没有标题
data2 = pd.read_csv("data.txt",names=["a","b","c","d","name"])#设置names参数，来设置文件的标题

使用pandas在读取文件的时候，pandas会默认将NA、-1.#IND、NULL等当作是缺失值，pandas默认使用NaN进行代替。
data1 = pd.read_csv("data.txt",na_values=["a","b"]) #读取含有缺失值文件时，将指定的值替换缺失值

读取函数 　　　　写入函数
read_csv    　　   to_csv
read_excel 　　    to_excel
read_hdf 　　       to_hdf
read_sql 　　        to_sql
read_json 　　      to_json
read_html 　　      to_html
read_stata 　　     to_stata
read_clipboard 　 to_clipboard
read_pickle 　　   to_pickle
read_msgback 　 to_msgback
read_bbq 　　     to_gbq

6、python 画图 

为了能够显示图表，首先需要安装matplotlib库。 

 折线图：

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
# 产生1000个4列正态分布的随机数
data = pd.DataFrame(np.random.randn(1000, 4))
# 对其中的数据进行累加，目的是为了能够使例子中显示的曲线有上升波动效果
data = data.cumsum()
# 打印出前几行的数据，方便我们调试其中的数据值
print(data.head())
# 画图表
data.plot()
# 显示图表
plt.show()

散点图：

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
# 产生1000个4列正态分布的随机数
data = pd.DataFrame(np.random.randn(1000, 4), columns=list("ABCD"))
# 打印出前几行的数据，方便我们调试其中的数据值
print(data.head())
# 显示散点图
data.plot.scatter(x='A', y='B')
# 显示图
plt.show()

 直方图：

# -*- coding: utf-8 -*-
import matplotlib.pyplot as plt

salary = [2500, 3300, 2700, 5600, 6700, 5400, 3100, 3500, 7600, 7800,
          8700, 9800, 10400]

group = [1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000, 9000, 10000, 11000]

plt.hist(salary, group, histtype='bar', rwidth=0.8)

plt.legend()

plt.xlabel('salary-group')
plt.ylabel('salary')

plt.title(u'测试例子——直方图')

plt.show()