python半小时快速上手

机器学习算法day01_python快速上手

课程大纲

Python快速上手	Python简介
	Python集成开发环境
	Python基本语法
	Python的变量和集合
	Python流程控制语法
	Python函数
	Python模块
Numpy矩阵运算包	Numpy简介
	Numpy中的多维数组ndarray
	Ndarray常用方法
	数组的基本运算
	数组的形状操作

 

 

 

 

课程目标：

1. 在已有JAVA语言的基础上迅速实现python上手开发
2. 掌握Numpy矩阵算法包的核心功能
3. 了解数据挖掘与机器学习算法的概念及其关系
4.  

1 Python快速上手

1.1.Python简介

Python 是一个高层次的结合了解释性、互动性和面向对象的脚本语言。

Python 的设计具有很强的可读性，相比其他语言经常使用英文关键字，其他语言的一些标点符号，它具有比其他语言更有特色语法结构。

1. Python是一种解释型语言： 这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。
2. Python是交互式语言： 这意味着，您可以在一个Python提示符，直接互动执行写你的程序。
3. Python是面向对象语言: 这意味着Python支持面向对象的风格或代码封装在对象的编程技术。
4. Python是初学者的语言：Python 对初级程序员而言，是一种伟大的语言，它支持广泛的应用程序开发，从简单的文字处理到WWW浏览器再到游戏

 

12.Python集成开发环境

1.2.1 Python安装

Python已经被移植在许多平台上（经过改动使它能够工作在不同平台上）。

可以直接下载相应平台的二进制代码，然后安装Python，或者使用C编译器手动编译源代码。编译的源代码，功能上有更多的选择性，为python安装提供了更多的灵活性。

 

Python版本的选择：

有两大系列  python 2.x

            Python 3.x

 

以下为不同平台上安装Python的方法：

1、Unix & Linux 平台安装 Python:

打开WEB浏览器访问http://www.python.org/download/

选择适用于Unix/Linux的源码压缩包。

下载及解压压缩包。

如果你需要自定义一些选项修改Modules/Setup

执行 ./configure 脚本

make

make install

执行以上操作后，Python会安装在 /usr/local/bin目录中，Python库安装在/usr/local/lib/pythonXX，XX为你使用的Python的版本号。

 

2、Window 平台安装 Python:

打开WEB浏览器访问http://www.python.org/download/

在下载列表中选择Window平台安装包，包格式为：python-XYZ.msi 文件 ， XYZ 为你要安装的版本号。

下载后，双击下载包，进入Python安装向导，安装非常简单，你只需要使用默认的设置一直点击"下一步"直到安装完成即可。

 

3、环境变量配置

程序和可执行文件可以在许多目录，而这些路径很可能不在操作系统提供可执行文件的搜索路径中。

path(路径)存储在环境变量中，这是由操作系统维护的一个命名的字符串。这些变量包含可用的命令行解释器和其他程序的信息。

Unix或Windows中路径变量为PATH（UNIX区分大小写，Windows不区分大小写）。

vi /etc/profile

export PATH="$PATH:/usr/local/bin/python"

 

在 Windows 设置环境变量

在环境变量中添加Python目录：

在命令提示框中(cmd) : 输入

path %path%;C:\Python , 按下"Enter"。

注意: C:\Python 是Python的安装目录。

 

4、运行Python

有三种方式可以运行Python：

• 交互式解释器：

你可以通过命令行窗口进入python并开在交互式解释器中开始编写Python代码。

你可以在Unix，DOS或任何其他提供了命令行或者shell的系统进行python编码工作。

$python    # Unix/Linux

或者

C:>python   # Windows/DOS

以下为Python命令行参数：

选项 描述

-d 在解析时显示调试信息

-O 生成优化代码 ( .pyo 文件 )

-S 启动时不引入查找Python路径的位置

-v 输出Python版本号

-X 从 1.6版本之后基于内建的异常（仅仅用于字符串）已过时。

-c cmd 执行 Python 脚本，并将运行结果作为 cmd 字符串。

file 在给定的python文件执行python脚本。

 

• 命令行脚本

在你的应用程序中通过引入解释器可以在命令行中执行Python脚本，如下所示：

#在 Unix/Linux下

$python script.py

 

# 在Windows下

C:>python script.py

注意：在执行脚本时，请检查脚本是否有可执行权限。

 

• 集成开发环境（IDE：Integrated Development Environment）

您可以使用图形用户界面（GUI）环境来编写及运行Python代码。以下推荐各个平台上使用的IDE：

IDLE 是 Linux上最早的 Python IDE。

Pycharm 是jetbrain出品的Python 集成开发环境

 

 

 

1.2.2 python依赖库管理工具pip

pip 是一个安装和管理 Python 包的工具，python安装包的工具有easy_install, setuptools, pip，distribute。使用这些工具都能下载并安装python依赖包

 

1、安装pip

安装和升级之前，先下载get-pip.py

然后使用下面的命令：

python get-pip.py

不过注意一下，linux或osX下，需要权限，使用下面的命令，输入密码后即可。

sudo python get-pip.py

windows下需要管理员权限启动终端。

 

2、安装setuptools

如果你还没有安装了setuptools，get-pip.py 会帮你安装。

如果你已经安装了setuptools，可以运行下面的命令进行升级。

pip install -U setuptools

windows下，注意将pip路劲加到系统的path中。

 

3、升级pip

Linux or OS X系统，运行下面的命令:

pip install -U pip

windows系统运行下面的命令：

python -m pip install -U pip

 

4、安装依赖包

使用下面的命令来安装包

pip install SomePackage    # 默认下载安装最新版本

pip install SomePackage==1.0.4    # 指定安装版本

pip install 'SomePackage>=1.0.4'   # 指定最低版本

要看更多地例子，可以看这里pip install

例如要安装web开发框架库 Django，用下面的一条命令即可，方便快捷：

pip install Django==1.7

 

1.2.3 python环境一键安装  

在用python做科学计算的场景中，需要安装的依赖库非常多且非常麻烦，建议用python科学计算集成环境 anaconda

 

一句话点评：省事！！！给力！！！

请see官方介绍：

Anaconda is a completely free Python distribution (including for commercial use and redistribution). It includes more than 400 of the most popular Python packages for science, math, engineering, and data analysis.

官网下载地址

https://www.continuum.io/downloads

 

WINDOW版本：

 

LINUX版本：

 

MAC OS版本：

 

1.3.Python基本语法

1.3.1 行和缩进

Python中，不使用括号来表示代码的类和函数定义块或流程控制。

代码块是由行缩进，缩进位的数目是可变的，但是在块中的所有语句必须缩进相同的量。

如下所示：

if True:     print "True" else:   print "False"

然而，在本实施例中的第二块将产生一个错误：

if True:     print "Answer"     print "True" else:     print "Answer"   print "False"

1.3.2 Python引号

Python接受单引号（'），双引号（“）和三（''或”“”）引用，以表示字符串常量，只要是同一类型的引号开始和结束的字符串。

 

三重引号可以用于跨越多个行的字符串。例如，所有下列是合法的：

word = 'word' sentence = "This is a sentence." paragraph = """This is a paragraph. It is made up of multiple lines and sentences."""

1.3.3 Python注释

“＃”号之后字符和到物理行是注释的一部分，Python解释器会忽略它们。

#!/usr/bin/python   # First comment print "Hello, Python!";  # second comment 这将产生以下结果：   Hello, Python! 注释可能会在声明中表达或同一行之后： name = "Madisetti"  # This is again comment 你可以使用多行注释如下：   # This is a comment. # This is a comment, too. # This is a comment, too. # I said that already.

 

1.3.4 分号的使用

python中一个语句的结束不需要使用分号

如果想在一行中输入多个语句，可使用分号：

import sys; x = 'foo'; sys.stdout.write(x+""" """)

 

1.4.Python的变量和集合

Python有五个标准的数据类型：

1. 数字
2. 字符串
3. 列表
4. 元组
5. 字典

f)   set

 

python中定义变量时不需要显示指定变量类型，以下为python中变量使用的典型语法：

 

1.4.1变量定义和赋值

#基本使用 counter  = 100         # 整型 miles   = 1000.0       # 浮点 name    = "John"      # 字符串   print counter print miles print name   #多重赋值 a = b = c = 1 d, e, f = 1, 2, "john" 从控制台接收整数和浮点型 value = input('input a int:') print value 接收一个字符串 hello = raw_input('input a string:') print hello 做while循环

 

1.4.2字符串的使用

str = 'Hello World!'    #字符串在python中本质上是一个字符序列Seq print str         # 打印整个字符串 print str[0]       # 打印字符串第一个字母 print str[2:5]     # 打印第3到第5个字母 print str[2:]      # 打印从第3个字母到末尾 print str * 2      # 字符串重复2次 print str + "TEST"  # 字符串拼接 实现对字符串进行颠倒操作

 

1.4.3列表的使用

list = [ 'abcd', 786 , 2.23, 'john', 70.2 ] tinylist = [123, 'john']   print list          # 打印整个列表 print list[0]        # 打印第一个元素 print list[1:3]       # 打印第二和第三个元素 print list[2:]        # 打印第三个元素到末尾 print tinylist * 2     # 打印2次 print list + tinylist    # 拼接两个list   #修改list中的元素 list[0]=”python”   print(list) list.remove("xxx") 1）实现对列表增删改查操作

 

 

将输出以下结果：

['abcd', 786, 2.23, 'john', 70.200000000000003] abcd [786, 2.23] [2.23, 'john', 70.200000000000003] [123, 'john', 123, 'john'] ['abcd', 786, 2.23, 'john', 70.200000000000003, 123, 'john']

 

1.4.4元组使用

元组是类似于列表中的序列数据类型，一个元组由数个逗号分隔的值组成。

列表和元组之间的主要区别是：列表用方括号[]，列表的长度和元素值是可以改变的

而元组用圆括号()，不能被更新。

元组可以被认为是只读列表。

tuple = ( 'abcd', 786 , 2.23, 'john', 70.2) tinytuple = (123, 'john')   print tuple           # 打印整个元组 print tuple[0]         # 打印第一个元素 print tuple[1:3]       # 打印第2、3两个元素 print tuple[2:]        # print tinytuple * 2     # 重复2遍 print tuple + tinytuple  # 拼接 使用for两种方式取tuple值 for in   for in range() 取tuple其中两值

 

 

这将产生以下结果：

('abcd', 786, 2.23, 'john', 70.200000000000003) abcd (786, 2.23) (2.23, 'john', 70.200000000000003) (123, 'john', 123, 'john') ('abcd', 786, 2.23, 'john', 70.200000000000003, 123, 'john')

 

 

 

 

1.4.5字典

Python字典是一种哈希表型。由“键-值”对组成。Nosql使用键值对

键可以是任何Python类型，但通常是数字或字符串。

值可以是任意Python的对象。

字典是由花括号括号{}，可分配值，并用方括号[]访问。例如：

dict = {} dict['one'] = "This is one" dict[2]     = "This is two"   tinydict = {'name': 'john','code':6734, 'dept': 'sales'}     print dict['one']       # Prints value for 'one' key print dict[2]           # Prints value for 2 key print tinydict          # Prints complete dictionary print tinydict.keys()   # Prints all the keys print tinydict.values() # Prints all the values   dictMap={"name":"张三","sex":"男"} print dictMap.get("name") print dictMap["name"] dictMap["name"]="xxxxx" dictMap[0]="xxxddd" #遍历value for item in dictMap.values():     print item #遍历key for item in dictMap.keys():     print dictMap.get(item) #返回元组 for item in dictMap.items():     print item 统计lst集合中每个字符串出现次数

这将产生以下结果：

This is one This is two {'dept': 'sales', 'code': 6734, 'name': 'john'} ['dept', 'code', 'name'] ['sales', 6734, 'john']

 

1.4.6 set

定义一个set：

a={1,2,3,4,5}

print a

a.remove(3)

a.add(6)

a.union(b)

setx={"cc","ddd"}
setx.add("xxx")
setx.add("cc")
setx.remove("cc")
setx.add("xx2x")
print setx

for item in setx:
    print item

set=set()

过滤list集合中的重复元素

 

1.4.7数据类型转换

有时候，可能需要执行的内置类型之间的转换。

类型之间的转换，只需使用类名作为函数。

int(x [,base])	将x转换为整数。基数指定为base（进制）
long(x [,base] )	将x转换为一个长整数。基数指定为base，
float(x)	将x转换到一个浮点数。
str(x)	转换对象x为字符串表示形式。
eval(str)	计算一个表达式字符串，并返回一个对象。
tuple(s)	把s（序列）转换为一个元组。
list(s)	把s（序列）转换为一个列表。
set(s)	把s（序列）转换为一个set集合。
dict(d)	转成字典,d必须是（键，值）元组序列。

 

例如：

a=int("23")
print a

结果为: 23

 

s=set(["aa","dd","ff"])
print tuple(s)

 

a=tuple(range(1,10,2))

print(a)

 

b=tuple("hello")

print b

 

e=eval("['a','b']")
print e
for I in e:
   print I

 

f=dict([(1,2),(3,4),('a',100)])

print f

 

结果为：

(1, 3, 5, 7, 9)

('h', 'e', 'l', 'l', 'o')

(1+2j)

2

{'a': 100, 1: 2, 3: 4}

 

x=3
e=eval('x+1*45')
print e#48

y=int(x)
print float(x)
print long(x)
print tuple(x)#('3', '3', '3')
print set(x) #set(['3'])
print list(x)#['3', '3', '3']
z=[("name","张碱"),("sex","女")]
print dict(z)#必须是元组序列

x=90

 

1.5.Python流程控制语法

1.5.1 if语句

var1 = 100 if var1:    print "1 - Got a true expression value"    print var1   var2 = 0 if var2:    print "2 - Got a true expression value"    print var2 print "Good bye!" #if的条件可以是数字或字符串或者布尔值True和False（布尔表达式） #如果是数字，则只要不等于0，就为true #如果是字符串，则只要不是空串，就为true random.random random.random()用于生成一个0到1的随机符点数: 0 <= n < 1.0 random.randint 　　random.randint()的函数原型为：random.randint(a, b)，用于生成一个指定范围内的整数。其中参数a是下限，参数b是上限，生成的随机数n: a <= n <= b   import csv import random; train_set=[] test_set=[] with open("D:\pythonworkspace\data.txt","rb") as file:     xx=csv.reader(file)     dataset=list(xx)     for x in range(len(dataset)):         rr=random.random();         if rr<0.5:             train_set.append(dataset[x])         else:             test_set.append(dataset[x]) print "train_set:"+str(len(train_set))

 

if else

var = 100 if var == 200:    print "1 - Got a true expression value"    print var elif var == 150:    print "2 - Got a true expression value"    print var elif var == 100:    print "3 - Got a true expression value"    print var else:    print "4 - Got a false expression value"    print var   print "Good bye!"   def tanh():     print "tanh函数被调用" def logistic():     print "逻辑函数" def fun(fname='tanh'):     if fname=="tanh":         tanh()     elif fname=="logistic":         logistic(); fun()

 

嵌套if else

var = 100 if var < 200:    print "Expression value is less than 200"    if var == 150:       print "Which is 150"    elif var == 100:       print "Which is 100"    elif var == 50:       print "Which is 50" elif var < 50:    print "Expression value is less than 50" else:    print "Could not find true expression"   print "Good bye!"

 

 

1.5.2 while循环

count = 0 while count < 5:    print count, " is  less than 5"    count = count + 1 else:    print count, " is not less than 5"   x=2 i=0 while x<34:     i+=1     if i==12:         print "break....................................."         break;     print x x=35 i=0 while x<34:     i+=1     if i==12:         print "break....................................."         break;     print x else:     print "没有执行循环......."   import numpy as np from numpy import * matrix=np.array([[1,2],[4,5],[6,7]]) len=len(matrix)-1 min=np.mean(matrix[0]) while len>0:     avg=np.mean(matrix[len]);     if avg         min=avg;     len=len-1; print min

 

 

 

 

 

1.5.3 for循环

for i in range(0,5):     print i; for i in range(0,5,1):     print i; for i in range(5,0,-1):     print i;   import numpy as np from numpy import * list=["3","3","4"] for i in range(len(list)):     list[i]=int(list[i]) avg=np.mean(list); print avg   #遍历集合 r=range(10,20) r={1,2,3,4,5}    #set类型 r=["aaa",3,"c"] print(r) for num in r:     print(num)     r={"a":9,"b":10} print(r) for num in r.values():     print(num)

 

 

1.6.Python函数

1.6.1 基本形式

#定义函数 def changeme( mylist ):    "This changes a passed list into this function"    mylist.append([1,2,3,4]);    print "Values inside the function: ", mylist    return (mylist,"haha")   # 调用函数 mylist = [10,20,30]; changeme( mylist ); print "Values outside the function: ", mylist   def fun(lst):     for i in range(1,4):         print i;     for item in lst:         print item     return "遍历成功!!" lst=["xx","yy","cc"] result=fun(lst); print result   def euclideanDistance(instance1,instance2,length):     distance=0     for x in range(length):         #返回2次方值        distance = pow(instance1[x] - instance2[x],2)+distance     return math.sqrt(distance) val=euclideanDistance([12,34,56],[23,23,45],3) print val

python的函数调用是引用传递，这将产生以下结果：

Values inside the function:  [10, 20, 30, [1, 2, 3, 4]] Values outside the function:  [10, 20, 30, [1, 2, 3, 4]]

 

默认参数和可变参数

# 默认参数 #有默认值的参数后面不能再跟无默认值的参数 def fun(lst,name="lisi"):     for i in range(1,4):         print i;     for item in lst:         print item     print  name;     return "遍历成功!!" lst=["xx","yy","cc"] result=fun(lst,"wangwu"); print result   def printinfo( name, age = 35 ):    "This prints a passed info into this function"    print "Name: ", name;    print "Age ", age;    return; #调用 #如果调换了参数的顺序，则必须把参数名都带上 printinfo( age=50, name="miki" ); printinfo( name="miki" );   #可变参数 #可变参数转换成是元组 def fun(x,*y):     print "参数:"+str(x)     for item in y:         print item     print  y fun(45,45,4,3,2,33)   def printinfo( arg1, *vartuple ):    "This prints a variable passed arguments"    print "Output is: "    print arg1    for var in vartuple:       print var    return; # 调用 printinfo( 10 ); printinfo( 70, 60, 50 );

 

 

1.6.2 匿名函数

• 可以使用lambda关键字来创建小的匿名函数。这些函数被称为匿名，因为它们不是以标准方式通过使用def关键字声明。
• Lambda形式可以采取任何数量的参数，但在表现形式上只返回一个值。它们不能包含命令或多个表达式。
• 匿名函数不能直接调用打印，因为需要lambda表达式。

示例：

sum2=lambda arg1,arg2:arg1+arg2; print(sum2(33,33))   # 定义 sum = lambda arg1, arg2: arg1 + arg2    #lambda表达式 # 调用 print "Value of total : ", sum( 10, 20 ) print "Value of total : ", sum( 20, 20 )   ##返回多个值 tup=lambda x,y:(x+1,y+1) c=tup(2,3) print c[0],c[1] (a,b)=tup(2,3) print a,b print c[0],c[1]

 

利用lambda可以实现类似于scala中的高阶函数效果：

#!/usr/bin/python # -*- coding: UTF-8 -*- #传递匿名函数 def fun(fun1,x,y):     print fun1(4,5); fun(lambda x,y:x+y,1,2) def outfunc(func,x,y):     c=func(x,y)     print(c)   outfunc(lambda x,y:x+y,1,2)

 

 

 

1.7.Python模块

简单地说，一个模块是由Python代码的文件。一个模块可以定义函数，类和变量。模块还可以包括可运行的代码。

1.7.1 模块的定义和导入

例：以下代码定义在support.py文件中

def print_func( par ):    print "Hello : ", par    return

 

在别的模块比如(hello.py)中可以导入已定义好的模块

#!/usr/bin/python   #导入模块 import cn.oracle.test.support # 使用导入的模块中的函数 cn.oracle.test.support.print_func("Zara")   #------------------------------------------------ #或者 from cn.oracle.test.support import print_func   print_func("Zara")

 

 

 

 

1.7.2 模块和包

在python中一个文件可以被看成一个独立模块，而包对应着文件夹，模块把python代码分成一些有组织的代码段，通过导入的方式实现代码重用。

 

1.7.1 模块搜索路径

导入模块时，是按照sys.path变量的值搜索模块，sys.path的值是包含每一个独立路径的列表，包含当前目录、python安装目录、PYTHONPATH环境变量，搜索顺序按照路径在列表中的顺序（一般当前目录优先级最高）。

[‘/home/zhoujh/study_workspace/studynotes/python/python_base’, ‘/usr/local/lib/python2.6/site-packages/setuptools-0.6c11-py2.6.egg’, ‘/usr/local/lib/python2.6/site-packages/redis-2.2.1-py2.6.egg’, ‘/usr/local/lib/python2.6/site-packages/Flask-0.8-py2.6.egg’, ‘/usr/local/lib/python2.6/site-packages/Jinja2-2.6-py2.6.egg’, ‘/usr/local/lib/python2.6/site-packages/Werkzeug-0.8.3-py2.6.egg’, ‘/usr/local/lib/python2.6/site-packages/tornado-2.2.1-py2.6.egg’, ‘/usr/local/lib/python2.6/site-packages/MySQL_python-1.2.3-py2.6-linux-x86_64.egg’, ‘/usr/local/lib/python2.6/site-packages/PIL-1.1.7-py2.6-linux-x86_64.egg’, ‘/usr/local/lib/python2.6/site-packages/SQLAlchemy-0.7.8-py2.6-linux-x86_64.egg’, ‘/home/zhoujh/python_workspace/python_app’, ‘/usr/local/lib/python26.zip’, ‘/usr/local/lib/python2.6’, ‘/usr/local/lib/python2.6/plat-linux2’, ‘/usr/local/lib/python2.6/lib-tk’, ‘/usr/local/lib/python2.6/lib-old’, ‘/usr/local/lib/python2.6/lib-dynload’, ‘/usr/local/lib/python2.6/site-packages’]

 

 

1.7.2 导入模块

1.7.2.1 使用import语句导入模块

 

有下面两种方式

import module1

import module2

import module3

 

import module1,module2,module3

这两种方式的效果是一样的，但是第一种可读性比第二种好，推荐按照下面的顺序导入模块，并且一般在文件首部导入所有的模块：

1. python标准库
2. 第三方模块
3. 应用程序自定义模块

也可以在函数内部导入模块，这样被导入的模块作用域是局部的

 

1.7.2.2 使用from-import语句导入模块的属性

单行导入

from module import name1,name2,name3

from test import fun,fun1,fun2 as f

多行导入

from module import name1,name2,\

                   name3

导入全部属性（由于容易覆盖当前名称空间中现有的名字，所以一般不推荐使用，适合模块中变量名很长并且变量很多的情况）

from module import *

from test import *

如果你不想某个模块的属性被以上方法导入，可以给该属性名称前加一个下划线(_test)，如果需要取消隐藏，可以显示的导入该属性（from module import _test）

from test import _fun4

 

1.7.2.3 扩展的import语句

使用自定义的名称替换模块的原始名称

import simplejson as json

from test import _fun4 as xxx

模块被导入时，加载的时候模块顶层代码会被执行，如：设定全局变量、类和函数的声明等，所以应该把代码尽量封装到类和函数中。一个模块无论被导入多少次，只加载一次，可以防止多次导入时代码被多次执行。

1.7.3.包结构

1.包定义结构

包将有联系的模块组织在一起，有效避免模块名称冲突问题，让应用组织结构更加清晰。

一个普通的python应用程序目录结构：

 

app/

__init__.py

a/

__init__.py

a.py

b/

__init__.py

b.py

app是最顶层的包，a和b是它的子包，可以这样导入：

 

from app.a import a

from app.b.b import test

 

a.test()

test()

上面代码表示：导入app包的子包a和子包b的属性test，然后分别调用test方法。

 

2. __init__.py的作用

每个目录下都有__init__.py文件，这个是初始化模块，from-import语句导入子包时需要它，可以在里面做一些初始化工作，也可以是空文件。

ps：__init__.py定义的属性直接使用 顶层包.子包 的方式导入，如在目录a的__init__.py文件中定义init_db()方法，调用如下：

from app import a

a.init_db()

 

3. 指定python文件编码方式

python默认是使用ASCII编码，可以指定编码方式，如

#!/usr/bin/env python #coding=utf-8 或者 #!/usr/bin/env python # -*- coding:utf-8 -*-

 

4. 解决导入循环问题

有下面两个模块，a.py和b.py

a.py #!/usr/bin/env python #coding=utf-8   import b   if __name__ == '__main__':     print 'hello,I'm a'

 

 

 

b.py

#!/usr/bin/env python #coding=utf-8   import a   if __name__ == '__main__':     print 'hello,I'm b'

 

在这里a尝试导入b，而b也尝试导入a，导入一个先前没有完全导入的模块，会导致导入失败。解决办法：移除一个导入语句，把导入语句放到函数内部，在需要的时候导入。

b.py

#!/usr/bin/env python #coding=utf-8   if __name__ == '__main__':     import a     print 'hello,I'm b'

 

 

1.8.Python文件IO

1.8.1 文件读写

Python进行文件读写的函数为open或file:

file_handler = open(filename,,mode）

open mode

W	以写方式打开文件，可向文件写入信息。如文件存在，则清空该文件，再写入新内容
r+	以读写方式打开文件，可对文件进行读和写操作。
w+	消除文件内容，然后以读写方式打开文件。
a+	以读写方式打开文件，并把文件指针移到文件尾。

 

 

 

 

操作文件对象方法

f.close()	关闭文件，记住用open()打开文件后一定要记得关闭它，否则会占用系统的可打开文件句柄数。
f.fileno()	获得文件描述符，是一个数字
f.flush()	刷新输出缓存
f.isatty()	如果文件是一个交互终端，则返回True，否则返回False。
f.read([count])	读出文件，如果有count，则读出count个字节。
f.readline()	读出一行信息。
f.readlines()	读出所有行，也就是读出整个文件的信息。
f.seek(offset[,where])	把文件指针移动到相对于where的offset位置。where为0表示文件开始处，这是默认值 ；1表示当前位置；2表示文件结尾。
f.tell()	获得文件指针位置。
f.truncate([size])	截取文件，使文件的大小为size。
f.write(string)	把string字符串写入文件。
f.writelines(list)	把list中的字符串一行一行地写入文件，是连续写入文件，没有换行。

 

 

例1：从文本文件中每读取一行文本便输出

#!/usr/bin/env/ python #coding=utf-8   fileHandler = open('/root/a.txt', 'a+') #以读写方式处理文件IO fileHandler.seek(0) line = fileHandler.readline() while line: print line line = fileHandler.readline() fileHandler.close

 

 

例2:其他文件IO函数的使用

#!/usr/bin/env/ python #coding=utf-8   fileHandler = open('/root/a.txt', 'a+') #以读写方式处理文件IO fileHandler.seek(0) #读取整个文件 contents = fileHandler.read() print contents 运行结果： llo tom 2.hello ketty 3.helllo jerry #读取所有行,再逐行输出 fileHandler.seek(0) lines = fileHandler.readlines() for line  in lines: print line   #当前文件指针的位置 print fileHandler.tell()   fileHandler.close   #encoding=UTF-8 def fileWrite():     rw=open("D:/b.txt","r+")     rw.writelines(["xxx","dd","fff"])     rw.flush()     rw.close() #fileWrite(); def fileRead():       rw=open("D:/b.txt","r+")       line=rw.readline();       while line:           print line;           line=rw.readline()       rw.close()

 

例3:用file(...)替换open(...)

#!/usr/bin/env/ python #coding=utf-8 fileHandler = file('/root/a.txt', 'a+') #以读写方式处理文件IO fileHandler.seek(0) line = fileHandler.readline() while line: print line line = fileHandler.readline()

 

例4:文件的写操作

#!/usr/bin/env/ python #coding=utf-8 fileHandler = file('/root/a.txt','a+')   #或者调用open()函数 fileHandler.write("\r\n")    fileHandler.write("thank you") fileHandler.seek(0) contents = fileHandler.read() print contents fileHandler.close

 

1.8.2 文件夹相关操作

Python中对文件、文件夹（文件操作函数）的操作需要涉及到os模块和shutil模块。

得到当前工作目录，即当前Python脚本工作的目录路径: os.getcwd()

import os
fs=os.getcwd();
vv=fs.strip()
print vv

返回指定目录下的所有文件和目录名:os.listdir()

import os
xx=os.listdir("d:/before")
print xx

删除一个文件:os.remove()

import os
os.remove("d:/b.txt")

 

删除多个目录（只能删除空目录）：os.removedirs（r”c：\python”）

os.removedirs(r"D:/xxx")

检验给出的路径是否是一个文件：os.path.isfile()

import os
result=os.path.isfile("D:\python/oo.py")
print result

检验给出的路径是否是一个目录：os.path.isdir()

import os
result=os.path.isdir("d:/before")
print result

判断是否是绝对路径：os.path.isabs()

import os
result=os.path.isabs("before")
print result

检验给出的路径是否存在:os.path.exists()

import os
result=os.path.exists("d:/before")
print result

返回一个路径的目录名和文件名:os.path.split()   分离路径和文件名称

import os
result=os.path.split("D:\python/aa.py")
print result[0],result[1] 

Eg：

 os.path.split('/home/swaroop/byte/code/poem.txt')

结果：('/home/swaroop/byte/code', 'poem.txt') 

分离扩展名：os.path.splitext()

import os
result=os.path.splitext("D:\python/aa.py")
print result

('D:\\python/aa', '.py')

获取路径名：os.path.dirname()

result=os.path.dirname("D:\python/aa.py")
print result

D:\python

获取文件名：os.path.basename()

result=os.path.basename("D:\python/aa.py")
print result

aa.py

读取和设置环境变量:os.getenv() 与os.putenv()

import os
xx=os.getenv("PATH")
print xx

 

给出当前平台使用的行终止符:os.linesep    Windows使用'\r\n'，Linux使用'\n'而Mac使用'\r'

xx=  os.linesep
print xx

 

指示你正在使用的平台：os.name       对于Windows，它是'nt'，而对于Linux/Unix用户，它是'posix'

import os
xx=  os.name
print xx

nt

重命名：os.rename（old， new）

import os
os.renames("D:/111/aa.txt","C:/aaa.txt")

 

创建多级目录：os.makedirs（r“c：\python\test”）

import os
os.makedirs(r"c:\111\test")

创建单个目录：os.mkdir（“test”）

import os
os.mkdir("/test")

 

获取文件属性：os.stat（file）

import os
xx=os.stat("d:/111")
print xx

 

修改文件权限与时间戳：os.chmod（file）

os.chmod(path, mode)

参数

• path -- 文件名路径或目录路径。
• flags -- 可用以下选项按位或操作生成， 目录的读权限表示可以获取目录里文件名列表， ，执行权限表示可以把工作目录切换到此目录 ，删除添加目录里的文件必须同时有写和执行权限 ，文件权限以用户id->组id->其它顺序检验,最先匹配的允许或禁止权限被应用。
  • stat.S_IXOTH: 其他用户有执行权0o001
  • stat.S_IWOTH: 其他用户有写权限0o002
  • stat.S_IROTH: 其他用户有读权限0o004
  • stat.S_IRWXO: 其他用户有全部权限(权限掩码)0o007
  • stat.S_IXGRP: 组用户有执行权限0o010
  • stat.S_IWGRP: 组用户有写权限0o020
  • stat.S_IRGRP: 组用户有读权限0o040
  • stat.S_IRWXG: 组用户有全部权限(权限掩码)0o070
  • stat.S_IXUSR: 拥有者具有执行权限0o100
  • stat.S_IWUSR: 拥有者具有写权限0o200
  • stat.S_IRUSR: 拥有者具有读权限0o400
  • stat.S_IRWXU: 拥有者有全部权限(权限掩码)0o700
  • stat.S_ISVTX: 目录里文件目录只有拥有者才可删除更改0o1000
  • stat.S_ISGID: 执行此文件其进程有效组为文件所在组0o2000
  • stat.S_ISUID: 执行此文件其进程有效用户为文件所有者0o4000
  • stat.S_IREAD: windows下设为只读
  • stat.S_IWRITE: windows下取消只读

 

import os, sys, stat
os.chmod("d:/111/aa.bat",stat.S_ENFMT)

获取文件大小：os.path.getsize（filename）

import os
xx=os.path.getsize("d:/111")
print xx

 

 

1.9  Python多线程

Python中的多线程是伪线程；不能充分利用cpu中的多核，但是在io等待型的场景下多线程还是可以提高效率

Python中的多线程有多种实现方式，利用threading包实现是比较普遍的做法

示例代码如下：

#encoding=UTF-8 import threading from time import ctime,sleep def music(str):     for i in range(0,10):         print str,ctime()         sleep(2) def film(str):       for i in range(0,10):         print str,ctime()         sleep(2) threads=[] t1=threading.Thread(target=music("我想你了，你在哪里")) threads.append(t1) t2=threading.Thread(target=film("啊凡达")) threads.append(t2) for t in threads:     t.start();     t.join();     import time # 格式化成2016-03-20 11:45:39形式 print time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())

 

 

1.10面向对象

1.10.1 创建类

使用class语句来创建一个新类，class之后为类的名称并以冒号结尾，如下实例:

class ClassName:    '类的帮助信息'   #类文档字符串    class_suite  #类体

类的帮助信息可以通过ClassName.__doc__查看。

class_suite 由类成员，方法，数据属性组成。

 

1.10.2 实例

以下是一个简单的Python类实例:

#!/usr/bin/python # -*- coding: UTF-8 -*-   class Employee:    '所有员工的基类'    empCount = 0      #构造函数    def __init__(self, name, salary):       self.name = name       self.salary = salary       Employee.empCount += 1        def displayCount(self):      print "Total Employee %d" % Employee.empCount      def displayEmployee(self):       print "Name : ", self.name,  ", Salary: ", self.salary

empCount变量是一个类变量，它的值将在这个类的所有实例之间共享。你可以在内部类或外部类使用Employee.empCount访问。

第一个方法__init__()方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法

 

类的方法

使用def关键字可以为类定义一个方法，与一般函数定义不同，类方法必须包含参数self,且为第一个参数

 

 

1.10.3 创建实例对象

要创建一个类的实例，你可以使用类的名称，并通过__init__方法接受参数。

"创建 Employee 类的第一个对象" emp1 = Employee("Zara", 2000) "创建 Employee 类的第二个对象" emp2 = Employee("Manni", 5000)

 

访问属性

可以使用点(.)来访问对象的属性。使用如下类的名称访问类变量:

emp1.displayEmployee() emp2.displayEmployee() print "Total Employee %d" % Employee.empC ount

 

完整实例：

#!/usr/bin/python # -*- coding: UTF-8 -*-   class Employee:    '所有员工的基类'    empCount = 0      def __init__(self, name, salary):       self.name = name       self.salary = salary       Employee.empCount += 1        def displayCount(self):      print "Total Employee %d" % Employee.empCount      def displayEmployee(self):       print "Name : ", self.name,  ", Salary: ", self.salary   "创建 Employee 类的第一个对象" emp1 = Employee("Zara", 2000) "创建 Employee 类的第二个对象" emp2 = Employee("Manni", 5000) emp1.displayEmployee() emp2.displayEmployee() print "Total Employee %d" % Employee.empCount

 

执行以上代码输出结果如下：

Name :  Zara ,Salary:  2000 Name :  Manni ,Salary:  5000 Total Employee 2

 

你可以添加，删除，修改类的属性，如下所示：

emp1.age = 7  # 添加一个 'age' 属性 emp1.age = 8  # 修改 'age' 属性 del emp1.age  # 删除 'age' 属性 你也可以使用以下函数的方式来访问属性： getattr(obj, ‘name’[, default]) : 访问对象的属性。 hasattr(obj,’name’) : 检查是否存在一个属性。 setattr(obj,’name’,value) : 设置一个属性。如果属性不存在，会创建一个新属性。 delattr(obj, ‘name’) : 删除属性。 hasattr(emp1, 'age')    # 如果存在 'age' 属性返回 True。 getattr(emp1, 'age')    # 返回 'age' 属性的值 setattr(emp1, 'age', 8)   # 添加属性 'age' 值为 8 delattr(empl, 'age')    # 删除属性 'age'

 

1.10.4 Python内置类属性

__dict__ : 类的属性（包含一个字典，由类的数据属性组成） __doc__ :类的文档字符串 __name__: 类名 __module__: 类定义所在的模块（类的全名是'__main__.className'，如果类位于一个导入模块mymod中，那么className.__module__ 等于 mymod） __bases__ : 类的所有父类构成元素（包含了以个由所有父类组成的元组）

 

Python内置类属性调用实例如下：

#!/usr/bin/python # -*- coding: UTF-8 -*-   class Employee:    '所有员工的基类'    empCount = 0      def __init__(self, name, salary):       self.name = name       self.salary = salary       Employee.empCount += 1        def displayCount(self):      print "Total Employee %d" % Employee.empCount      def displayEmployee(self):       print "Name : ", self.name,  ", Salary: ", self.salary   print "Employee.__doc__:", Employee.__doc__ print "Employee.__name__:", Employee.__name__ print "Employee.__module__:", Employee.__module__ print "Employee.__bases__:", Employee.__bases__ print "Employee.__dict__:", Employee.__dict__

 

执行以上代码输出结果如下：

Employee.__doc__: 所有员工的基类

Employee.__name__: Employee

Employee.__module__: __main__

Employee.__bases__: ()

Employee.__dict__: {'__module__': '__main__', 'displayCount': , 'empCount': 0, 'displayEmployee': , '__doc__': '\xe6\x89\x80\xe6\x9c\x89\xe5\x91\x98\xe5\xb7\xa5\xe7\x9a\x84\xe5\x9f\xba\xe7\xb1\xbb', '__init__': }

 

 

1.10.5 私有属性

1、类的私有属性

__private_attrs：两个下划线开头，声明该属性为私有，不能在类地外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs

 

2、类的私有方法

__private_method：两个下划线开头，声明该方法为私有方法，不能在类地外部调用。在类的内部调用 self.__private_methods

 

3、实例

#!/usr/bin/python # -*- coding: UTF-8 -*-   class JustCounter: __secretCount = 0  # 私有变量 publicCount = 0    # 公开变量   def count(self): self.__secretCount += 1 self.publicCount += 1 print self.__secretCount   counter = JustCounter() counter.count() counter.count() print counter.publicCount print counter.__secretCount  # 报错，实例不能访问私有变量

运行结果会报错：

Traceback (most recent call last):   File "test.py", line 17, in     print counter.__secretCount  # 报错，实例不能访问私有变量 AttributeError: JustCounter instance has no attribute '__secretCount'

 

Python不允许实例化的类访问私有数据，但你可以使用 object._className__attrName 访问属性，将如下代码替换以上代码的最后一行代码：

.........................

print counter._JustCounter__secretCount

执行以上代码，执行结果如下：

1 2 2 2

 

 

 

 

1.10.6 python对象销毁(垃圾回收)

同Java语言一样，Python使用了引用计数这一简单技术来追踪内存中的对象。

在Python内部记录着所有使用中的对象各有多少引用。

一个内部跟踪变量，称为一个引用计数器。

当对象被创建时， 就创建了一个引用计数， 当这个对象不再需要时， 也就是说， 这个对象的引用计数变为0 时， 它被垃圾回收。但是回收不是"立即"的， 由解释器在适当的时机，将垃圾对象占用的内存空间回收。

a = 40      # 创建对象  <40>

b = a       # 增加引用， <40> 的计数

c = [b]     # 增加引用.  <40> 的计数

 

del a       # 减少引用 <40> 的计数

b = 100     # 减少引用 <40> 的计数

c[0] = -1   # 减少引用 <40> 的计数

垃圾回收机制不仅针对引用计数为0的对象，同样也可以处理循环引用的情况。循环引用指的是，两个对象相互引用，但是没有其他变量引用他们。这种情况下，仅使用引用计数是不够的。Python 的垃圾收集器实际上是一个引用计数器和一个循环垃圾收集器。作为引用计数的补充， 垃圾收集器也会留心被分配的总量很大（及未通过引用计数销毁的那些）的对象。 在这种情况下，解释器会暂停下来，试图清理所有未引用的循环。

 

实例

析构函数 __del__

__del__在对象销毁的时候被调用，当对象不再被使用时，__del__方法运行：

#!/usr/bin/python # -*- coding: UTF-8 -*-   class Point:    def __init__( self, x=0, y=0):       self.x = x       self.y = y    def __del__(self):       class_name = self.__class__.__name__       print class_name, "销毁"   pt1 = Point() pt2 = pt1 pt3 = pt1 print id(pt1), id(pt2), id(pt3) # 打印对象的id del pt1 del pt2 del pt3

 

以上实例运行结果如下：

3083401324  3083401324  3083401324

Point 销毁

 

 

1.10.7 类的继承

面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过继承机制。继承完全可以理解成类之间的类型和子类型关系。

 

1、语法：

派生类的声明，与他们的父类类似，继承的基类列表跟在类名之后，如下所示：

class SubClassName (ParentClass1[, ParentClass2, ...]):

   'Optional class documentation string'

   class_suite

 

2、实例：

#!/usr/bin/python # -*- coding: UTF-8 -*-   class Parent:        # 定义父类    parentAttr = 100    def __init__(self):       print "调用父类构造函数"      def parentMethod(self):       print '调用父类方法'      def setAttr(self, attr):       Parent.parentAttr = attr      def getAttr(self):       print "父类属性 :", Parent.parentAttr   class Child(Parent): # 定义子类    def __init__(self):       print "调用子类构造方法"      def childMethod(self):       print '调用子类方法 child method'   c = Child()          # 实例化子类 c.childMethod()      # 调用子类的方法 c.parentMethod()     # 调用父类方法 c.setAttr(200)       # 再次调用父类的方法 c.getAttr()          # 再次调用父类的方法

以上代码执行结果如下：

调用子类构造方法

调用子类方法 child method

调用父类方法

父类属性 : 200

Employee.__init__(self,"aa",333)调用父类构造方法

 

你可以继承多个类

class A:        # 定义类 A

.....

 

class B:         # 定义类 B

.....

 

class C(A, B):   # 继承类 A 和 B

.....

可以使用issubclass()或者isinstance()方法来检测。

issubclass() - 布尔函数判断一个类是另一个类的子类或者子孙类，语法：issubclass(sub,sup)

isinstance(obj, Class) 布尔函数如果obj是Class类的实例对象或者是一个Class子类的实例对象则返回true。

 

3、方法重写

如果你的父类方法的功能不能满足你的需求，你可以在子类重写你父类的方法：

实例：

#!/usr/bin/python # -*- coding: UTF-8 -*-   class Parent:        # 定义父类    def myMethod(self):       print '调用父类方法'   class Child(Parent): # 定义子类    def myMethod(self):       print '调用子类方法'   c = Child()          # 子类实例 c.myMethod()         # 子类调用重写方法

 

执行以上代码输出结果如下：

 

 

 

4、基础重载方法

下表列出了一些通用的功能，你可以在自己的类重写：

1/ __init__ ( self [,args...] )

构造函数

简单的调用方法: obj = className(args)

2/ __del__( self )

析构方法, 删除一个对象

简单的调用方法 : dell obj

3/ __str__( self )

用于将值转化为适于人阅读的形式

简单的调用方法 : str(obj)

4/ __cmp__ ( self, x )

对象比较

简单的调用方法 : cmp(obj, x)

 

#!/usr/bin/python   class Vector:    def __init__(self, a, b):       self.a = a       self.b = b      def __str__(self):       return 'Vector (%d, %d)' % (self.a, self.b)        def __add__(self,other):       return Vector(self.a + other.a, self.b + other.b)   v1 = Vector(2,10) v2 = Vector(5,-2) print v1 + v2

 

 

以上代码执行结果如下所示:

Vector(7,8)

 

 

 

 

 

2 Numpy快速上手

2.1. 什么是Numpy

Numpy是Python的一个科学计算的库

主要提供矩阵运算的功能，而矩阵运算在机器学习领域应用非常广泛

Numpy一般与Scipy、matplotlib一起使用。

虽然python中的list已经提供了类似于矩阵的表示形式，不过numpy为我们提供了更多的函数。

 

2.1.2 安装导入了Numpy

（通用做法import numpy as np 简单输入）

>>> import numpy as np >>> print np.version.version 1.6.2

 

2.1.3 Numpy组成

Numpy基础部分中，有两个主要内容，如下：

任意维数的数组对象（ndarray，n-dimensional array object）

通用函数对象（ufunc，universal function object）

2.2. 多维数组

2.2.1 Numpy中的数组<矩阵>

Numpy中，最重要的数据结构是：多维数组的类型（numpy.ndarray）

ndarray由两部分组成：

实际所持有的数据；

描述这些数据的元数据（metadata）

 

与Python原生支持的List类型不同，数组的所有元素必须同样的类型。

数组（即矩阵）的维度被称为axes，维数称为 rank 

ndarray 的重要属性包括:

• ndarray.ndim：数组的维数，也称为rank
• ndarray.shape：数组各维的大小，对一个n行m列的矩阵来说， shape 为 (n,m)
• ndarray.size：元素的总数。
• ndarray.dtype：每个元素的类型，可以是numpy.int32, numpy.int16, and numpy.float64等
• ndarray.itemsize：每个元素占用的字节数。

 

 

2.2.2 ndarray常用方法示例

2.2.2.2 使用numpy.array方法

以list或tuple变量为参数产生一维数组：

>>> print np.array([1,2,3,4]) [1 2 3 4] >>> print np.array((1.2,2,3,4)) [ 1.2  2.   3.   4. ] >>> print type(np.array((1.2,2,3,4)))

 

以list或tuple变量为元素产生二维数组或者多维数组：

>>> x = np.array(((1,2,3),(4,5,6))) >>> x array([[1, 2, 3],        [4, 5, 6]]) >>> y = np.array([[1,2,3],[4,5,6]]) >>> y array([[1, 2, 3],        [4, 5, 6]])   index 和slicing ：第一数值类似数组横坐标，第二个为纵坐标 >>> x[1,2] 6 >>> y=x[:,1]     #取第二列 >>> y array([2, 5]) 涉及改变相关问题，我们改变上面y是否会改变x？这是特别需要关注的！ >>> y[0] = 10 >>> y array([10,  5]) >>> x- array([[ 1, 10,  3],      [ 4,  5,  6]])

通过上面可以发现改变y会改变x ，因而我们可以推断，y和x指向是同一块内存空间值，系统没有为y 新开辟空间把x值赋值过去。

 

2.2.2.3 使用numpy.arange方法

>>> print np.arange(15)#生成范围15个数，一维数组 [ 0  1  2  3  4  5  6  7  8  9  10  11  12  13  14] >>> print type(np.arange(15)) >>> print np.arange(15).reshape(3,5) 设置多少行，多少列 [[ 0  1  2  3  4]  [ 5  6  7  8  9]  [10 11 12 13 14]] >>> print type(np.arange(15).reshape(3,5))

 

2.2.2.4 使用numpy.linspace方法

例如，在从1到10中产生20个数：

>>> print np.linspace(1,10,20) [  1.           1.47368421   1.94736842   2.42105263   2.89473684    3.36842105   3.84210526   4.31578947   4.78947368   5.26315789    5.73684211   6.21052632   6.68421053   7.15789474   7.63157895    8.10526316   8.57894737   9.05263158   9.52631579  10.        ]

 

使用numpy.zeros，numpy.ones，numpy.eye等方法可以构造特定的矩阵

构造“0”矩阵：

>>> print np.zeros((3,4)) [[ 0.  0.  0.  0.]  [ 0.  0.  0.  0.]  [ 0.  0.  0.  0.]]

 

构造“1”矩阵

>>> print np.ones((3,4)) [[ 1.  1.  1.  1.]  [ 1.  1.  1.  1.]  [ 1.  1.  1.  1.]]

 

构造单位矩阵(E矩阵)

>>> print np.eye(3) [[ 1.  0.  0.]  [ 0.  1.  0.]  [ 0.  0.  1.]]

 

 

 

2.2.2.5 获取数组的属性：

>>> a = np.zeros((2,2,2)) 表示一维有2个元素，二维有2个元素，3维有两个元素 >>> print a.ndim   #数组的维数 3 >>> print a.shape  #数组每一维的大小 (2, 2, 2) >>> print a.size   #数组的元素数 8 >>> print a.dtype  #元素类型 float64 >>> print a.itemsize  #每个元素所占的字节数 8

 

 

2.2.3 数组的基本运算

数组的算术运算是按元素逐个运算。数组运算后将创建包含运算结果的新数组。

与其他矩阵语言不同，NumPy中的乘法运算符*按元素逐个计算，矩阵乘法可以使用dot函数或创建矩阵对象实现（后续介绍）

 

2.2.3.1 数组的加减运算

>>> a= np.array([20,30,40,50]) >>> b= np.arange( 4) >>> b array([0, 1, 2, 3]) >>> c= a-b >>> c array([20, 29, 38, 47])

将运算结果更新原数组，不创建新数组

>>> a= np.ones((2,3), dtype=int) >>> b= np.random.random((2,3))   ##生成2*3矩阵，元素为[0,1)范围的随机数 >>> a*= 3 >>> a array([[3, 3, 3],     　　 [3, 3, 3]]) >>> b+= a   #a转换为浮点类型相加 >>> b array([[ 3.69092703, 3.8324276, 3.0114541],     　　　 [ 3.18679111, 3.3039349, 3.37600289]]) >>> a+= b   # b转换为整数类型报错 TypeError: Cannot cast ufunc add output from dtype('float64') to dtype('int32') with casting rule 'same_kind'

 

当数组中存储的是不同类型的元素时，数组将使用占用更多位（bit）的数据类型作为其本身的数据类型，也就是偏向更精确的数据类型(这种行为叫做upcast)。

>>> a= np.ones(3, dtype=np.int32) >>> b= np.linspace(0,np.pi,3) >>> b.dtype.name 'float64' >>> c= a+b >>> c array([ 1., 2.57079633, 4.14159265]) >>>  'float64'

 

2.2.3.2 数组乘法运算

>>> b**2 array([0, 1, 4, 9]) >>> 10*np.sin(a) array([ 9.12945251,-9.88031624, 7.4511316, -2.62374854]) >>> a<35 array([True, True, False, False], dtype=bool)

2.2.3.3 数组内部运算

许多非数组运算，如计算数组所有元素之和，都作为ndarray类的方法来实现，使用时需要用ndarray类的实例来调用这些方法。

二维数组：

>>> np.sum([[0, 1], [0, 5]]) 6 >>> np.sum([[0, 1], [0, 5]], axis=0) array([0, 6]) >>> np.sum([[0, 1], [0, 5]], axis=1) array([1, 5])

 

>>> b= np.arange(12).reshape(3,4) >>> b array([[ 0, 1, 2, 3],            [ 4, 5, 6, 7],            [ 8, 9, 10, 11]]) >>> b.sum(axis=0)    # 计算每一列的和 array([12, 15, 18, 21]) >>> b.min(axis=1)    # 获取每一行的最小值 array([0, 4, 8]) >>> b.cumsum(axis=1)   # 计算每一行的累积和 array([[ 0, 1, 3, 6],            [ 4, 9, 15, 22],            [ 8, 17, 27, 38]])

 

 

三维数组：

import  numpy as np c = np.array([[[0, 1, 2,3],                [4, 5, 6,7]],                [[1, 2, 3,4],                 [5,6,7,8]]]) print( c.sum(axis=0));#在各元素第一维度对应相加 print "----------------" print( c.sum(axis=1));#在各元素中，第二维度中内部相加 print "----------------" print( c.sum(axis=2))#在第三维度各个元素相加 print "----------------"   [[ 1  3  5  7]  [ 9 11 13 15]] ---------------- [[ 4  6  8 10]  [ 6  8 10 12]] ---------------- [[ 6 22]  [10 26]] ----------------

 

求元素最值

>>> a= np.random.random((2,3)) >>> a array([[ 0.65806048, 0.58216761, 0.59986935],[ 0.6004008, 0.41965453, 0.71487337]]) >>> a.sum() 　  3.5750261436902333 >>> a.min()      0.41965453489104032 >>> a.max()      0.71487337095581649

 

 

2.2.3.4 数组的索引、切片

和列表和其它Python序列一样，一维数组可以进行索引、切片和迭代操作。

>>> a= np.arange(10)** 3   #记住，操作符是对数组中逐元素处理的！ >>> a array([0, 1, 8, 27, 64, 125, 216, 343, 512, 729]) >>> a[2] 8 >>> a[2:5] array([ 8, 27, 64]) >>> a[:6:2]= -1000 # 等同于a[0:6:2]= -1000，从开始到第6个位置，每隔一个元素将其赋值为-1000（每两个元素，赋值-1000） >>> a array([-1000, 1,-1000, 27,-1000, 125, 216, 343, 512, 729]) >>> a[: :-1] # 反转a array([ 729, 512, 343, 216, 125,-1000, 27,-1000, 1,-1000]) >>>for i in a: ...    print i**2, ... 1000000 1 1000000 729 1000000 15625 46656 117649 262144 531441

 

多维数组可以每个轴有一个索引。这些索引由一个逗号分割的元组给出。

>>>def f(x,y): ...    return 10*x+y ... >>> b= np.fromfunction(f,(5,4),dtype=int)  #fromfunction是一个函数 定义一个5行4列矩阵，x,y指的是行号和列号 >>> b array([[ 0, 1, 2, 3],            [10, 11, 12, 13],            [20, 21, 22, 23],            [30, 31, 32, 33],            [40, 41, 42, 43]]) >>> b[2,3] 23   >>> b[0:5, 1] # 每行的第二个元素，不包括第4行 array([ 1, 11, 21, 31, 41])   >>> b[: ,1] # 与前面的效果相同 array([ 1, 11, 21, 31, 41])   >>> b[1:3,: ] # 每列的第二和第三个元素 array([[10, 11, 12, 13],            [20, 21, 22, 23]])

 

2.2.3.5 矩阵的遍历

>>>for row in b: ...    print row ... [0 1 2 3] [10 11 12 13] [20 21 22 23] [30 31 32 33] [40 41 42 43]

 

如果想对数组中每个元素都进行处理，可以使用flat属性，该属性是一个数组元素迭代器：

>>>for element in b.flat: ...    print element, ... 0 1 2 3 10 11 12 13 20 21 22 23 30 31 32 33 40 41 42 43

 

2.2.3.6 合并数组

使用numpy下的vstack（垂直方向）和hstack（水平方向）函数：

>>> a = np.ones((2,2)) >>> b = np.eye(2) >>> print np.vstack((a,b)) [[ 1.  1.]  [ 1.  1.]  [ 1.  0.]  [ 0.  1.]] >>> print np.hstack((a,b)) [[ 1.  1.  1.  0.]  [ 1.  1.  0.  1.]]

看一下这两个函数有没有涉及到浅拷贝这种问题：

>>> c = np.hstack((a,b)) >>> print c [[ 1.  1.  1.  0.]  [ 1.  1.  0.  1.]] >>> a[1,1] = 5 >>> b[1,1] = 5 >>> print c [[ 1.  1.  1.  0.]  [ 1.  1.  0.  1.]]

通过上面可以知道，这里进行是深拷贝，而不是引用指向同一位置的浅拷贝。

2.2.3.7 深度拷贝

数组对象自带了浅拷贝和深拷贝的方法，但是一般用深拷贝多一些：

>>> a = np.ones((2,2)) >>> b = a >>> b is a True >>> c = a.copy()  #深拷贝 >>> c is a False

 

 

 

2.2.3.8 矩阵转置运算

>>> a = np.array([[1,0],[2,3]]) >>> print a [[1 0]  [2 3]] >>> print a.T [[1 2]  [0 3]]

 

 

 

 

2.2.4 数组的形状操作

2.4.1 reshape更改数组的形状

数组的形状取决于其每个轴上的元素个数：

>>> a= np.floor(10*np.random.random((3,4))) >>> a array([[ 7., 5., 9., 3.],            [ 7., 2., 7., 8.],            [ 6., 8., 3., 2.]]) >>> a.shape (3, 4)

 

可以用多种方式修改数组的形状：

>>> print a.flatten() # 平坦化数组 array([ 7., 5., 9., 3., 7., 2., 7., 8., 6., 8., 3., 2.]) >>> a.shape= (6, 2) #把a变成6行2列数据 >>> a.T array([[ 7., 9., 7., 7., 6., 3.],            [ 5., 3., 2., 8., 8., 2.]])

 

由ravel()展平的数组元素的顺序通常是“C风格”的，就是以行为基准，最右边的索引变化得最快，所以元素a[0,0]之后是a[0,1]。如果数组改变成其它形状(reshape)，数组仍然是“C风格”的。NumPy通常创建一个以这个顺序保存数据的数组，所以ravel()通常不需要创建起调用数组的副本。但如果数组是通过切片其它数组或有不同寻常的选项时，就可能需要创建其副本。还可以同过一些可选参数函数让reshape()和ravel()构建FORTRAN风格的数组，即最左边的索引变化最快。

 

2.4.2 resize更改数组形状

reshape函数改变调用数组的形状并返回该数组，而resize函数改变调用数组自身。

import  numpy as np a=np.array([[1,2,3,4],[5,6,7,8],[9,8,4,3]]) a.resize((2,6)) #a.reshape((2,6)) print a