01_python_(python语言_数据类型详解)

python数据类型详解

内容大纲

1、字符串

2、布尔类型

3、整数

4、浮点数

5、数字

6、列表

7、元组

8、字典

9、日期

1、字符串

1.1、如何在Python中使用字符串

a、使用单引号(‘)

用单引号括起来表示字符串，例如：

str=‘this is string‘;

print str;

b、使用双引号(")

双引号中的字符串与单引号中的字符串用法完全相同，例如：

str="this is string";

print str;

c、使用三引号(‘‘‘)

利用三引号，表示多行的字符串，可以在三引号中自由的使用单引号和双引号，例如：

str=‘‘‘this is string

this is pythod string

this is string‘‘‘

print str;

2、布尔类型

bool=False;

print bool;

bool=True;

print bool;

3、数字类型

3.1、基本使用

整数

int=20;

print int;

浮点数

float=2.3;

print float;

3.2、删除数字对象引用，例如：

a=1;

b=2;

c=3;

del a;

del b, c;

#print a; #删除a变量后，再调用a变量会报错

3.3、数字类型转换

3.4、数学函数

4、列表

4.1、初始化列表，例如：
list=[‘physics‘, ‘chemistry‘, 1997, 2000];
nums=[1, 3, 5, 7, 8, 13, 20];

4.2、访问列表中的值，例如：

4.3、更新列表，例如：

nums[0]="ljq";

print nums[0];

4.4、删除列表元素

del nums[0];‘‘‘nums[:]: [3, 5, 7, 8, 13, 20]‘‘‘

print "nums[:]:", nums[:];

4.5、列表脚本操作符
列表对+和*的操作符与字符串相似。+号用于组合列表，*号用于重复列表，例如：

print len([1, 2, 3]); #3

print [1, 2, 3] + [4, 5, 6]; #[1, 2, 3, 4, 5, 6]

print [‘Hi!‘] * 4; #[‘Hi!‘, ‘Hi!‘, ‘Hi!‘, ‘Hi!‘]

print 3 in [1, 2, 3] #Truefor x in [1, 2, 3]: print x, #1 2 3

4.6、列表截取

L=[‘spam‘, ‘Spam‘, ‘SPAM!‘];

print L[2]; #‘SPAM!‘

print L[-2]; #‘Spam‘

print L[1:]; #[‘Spam‘, ‘SPAM!‘]

4.7、列表函数&方法

list.append(obj) 在列表末尾添加新的对象

list.count(obj) 统计某个元素在列表中出现的次数

list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)

list.index(obj) 从列表中找出某个值第一个匹配项的索引位置，索引从0开始

list.insert(index, obj) 将对象插入列表

list.pop() 移除列表中的一个元素(默认最后一个元素)，并且返回该元素的值

list.remove(obj) 移除列表中某个值的第一个匹配项

list.reverse() 反向列表中元素，倒转

list.sort([func]) 对原列表进行排序

5、元组(tuple)

Python的元组与列表类似，不同之处在于元组的元素不能修改；元组使用小括号()，列表使用方括号[]；元组创建很简单，只需要在括号中添加元素，并使用逗号(,)隔开即可，例如：

tup1 = (‘physics‘, ‘chemistry‘, 1997, 2000);

tup2 = (1, 2, 3, 4, 5 );

tup3 = ("a", "b", "c", "d");

创建空元组，例如：tup = ();

元组中只有一个元素时，需要在元素后面添加逗号，例如：tup1 = (50,);

元组与字符串类似，下标索引从0开始，可以进行截取，组合等。

5.1、访问元组

tup1 = (‘physics‘, ‘chemistry‘, 1997, 2000);

#tup1[0]: physics

print "tup1[0]: ", tup1[0]

#tup1[1:5]: (‘chemistry‘, 1997)

print "tup1[1:5]: ", tup1[1:3]

5.2、修改元组
元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，例如:
tup1 = (12, 34.56);
tup2 = (‘abc‘, ‘xyz‘);

# 以下修改元组元素操作是非法的。
# tup1[0] = 100;

# 创建一个新的元组

tup3 = tup1 + tup2;

print tup3; #(12, 34.56, ‘abc‘, ‘xyz‘)

5.3、删除元组
元组中的元素值是不允许删除的，可以使用del语句来删除整个元组，例如:

tup = (‘physics‘, ‘chemistry‘, 1997, 2000);

print tup;

del tup;

5.4、元组运算符
与字符串一样，元组之间可以使用+号和*号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。

5.5、元组索引&截取

L = (‘spam‘, ‘Spam‘, ‘SPAM!‘);

print L[2]; #‘SPAM!‘

print L[-2]; #‘Spam‘

print L[1:]; #[‘Spam‘, ‘SPAM!‘]

5.6、元组内置函数

cmp(tuple1, tuple2) 比较两个元组元素。

len(tuple) 计算元组元素个数。

max(tuple) 返回元组中元素最大值。

min(tuple) 返回元组中元素最小值。

(seq) 将列表转换为元组。

6、字典

6.1、字典简介
字典(dictionary)是除列表之外python中最灵活的内置数据结构类型。列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

字典由键和对应的值组成。字典也被称作关联数组或哈希表。基本语法如下：

dict = {‘Alice‘: ‘2341‘, ‘Beth‘: ‘9102‘, ‘Cecil‘: ‘3258‘};

也可如此创建字典：

dict1 = { ‘abc‘: 456 };

dict2 = { ‘abc‘: 123, 98.6: 37 };

每个键与值必须用冒号隔开(:)，每对用逗号分割，整体放在花括号中({})。键必须独一无二，但值则不必；值可以取任何数据类型。

6.2、访问字典里的值

#!/usr/bin/python

dict = {‘name‘: ‘Zara‘, ‘age‘: 7, ‘class‘: ‘First‘};

print "dict[‘name‘]: ", dict[‘name‘];

print "dict[‘age‘]: ", dict[‘age‘];

6.3、修改字典
向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对如下实例:

#!/usr/bin/python

dict = {‘name‘: ‘Zara‘, ‘age‘: 7, ‘class‘: ‘First‘};

dict["age"]=27; #修改已有键的值

dict["school"]="wutong"; #增加新的键/值对

print "dict[‘age‘]: ", dict[‘age‘];

print "dict[‘school‘]: ", dict[‘school‘];

6.4、删除字典
del dict[‘name‘]; # 删除键是‘name‘的条目
dict.clear(); # 清空词典所有条目
del dict ; # 删除词典
例如：

#!/usr/bin/python

dict = {‘name‘: ‘Zara‘, ‘age‘: 7, ‘class‘: ‘First‘};

del dict[‘name‘];

#dict {‘age‘: 7, ‘class‘: ‘First‘}

print "dict", dict;

注意：字典不存在，del会引发一个异常

6.5、字典内置函数&方法

cmp(dict1, dict2) 比较两个字典元素。

len(dict) 计算字典元素个数，即键的总数。

str(dict) 输出字典可打印的字符串表示。

type(variable) 返回输入的变量类型，如果变量是字典就返回字典类型。
clear() 删除字典内所有元素

copy() 返回一个字典的深拷贝(在python中，函数的参数传递是：引用传递)

fromkeys(seq) 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值

get(key, None) 返回指定键的值，如果值不在字典中返回default值

has_key(key) 如果键在字典dict里返回true，否则返回false

items() 以列表返回可遍历的(键, 值) 元组数组

keys() 以列表返回一个字典所有的键

setdefault(key, default=None) 和get()类似, 但如果键不已经存在于字典中，将会添加键并将值设为default

dict1.update(dict2) 把字典dict2的键/值对更新到dict1里

values() 以列表返回字典中的所有值

7、日期和时间

7.1、获取当前时间，例如：
import  time, datetime;

#当前时间:

localtime = time.localtime(time.time())

print "Local current time :", localtime

## 结构化时间
time.struct_time(tm_year=2014, tm_mon=3, tm_mday=21, tm_hour=15, tm_min=13, tm_sec=56, tm_wday=4, tm_yday=80, tm_isdst=0)
说明：time.struct_time(tm_year=2014, tm_mon=3, tm_mday=21, tm_hour=15, tm_min=13, tm_sec=56, tm_wday=4, tm_yday=80, tm_isdst=0)属于struct_time元组，struct_time元组具有如下属性：

7.2、获取格式化的时间
可以根据需求选取各种格式，但是最简单的获取可读的时间模式的函数是asctime():
1、日期转换为字符串

首选：print time.strftime(‘%Y-%m-%d %H:%M:%S‘);

其次：print datetime.datetime.strftime(datetime.datetime.now(), ‘%Y-%m-%d %H:%M:%S‘)

最后：print str(datetime.datetime.now())[:19]

2、字符串转换为日期

expire_time = "2013-05-21 09:50:35"

d = datetime.datetime.strptime(expire_time,"%Y-%m-%d %H:%M:%S")

print d;

7.3、获取日期差

## 定义时差步长

oneday = datetime.timedelta(days=1)

#今天，2014-03-21

today = datetime.date.today()

#昨天，2014-03-20

yesterday = datetime.date.today() - oneday

#明天，2014-03-22

tomorrow = datetime.date.today() + oneday

#获取今天零点的时间，2014-03-21 00:00:00

today_zero_time = datetime.datetime.strftime(today, ‘%Y-%m-%d %H:%M:%S‘)

#0:00:00.001000

print datetime.timedelta(milliseconds=1), #1毫秒

#0:00:01

print datetime.timedelta(seconds=1), #1秒

#0:01:00

print datetime.timedelta(minutes=1), #1分钟

#1:00:00

print datetime.timedelta(hours=1), #1小时

#1 day, 0:00:00

print datetime.timedelta(days=1), #1天

#7 days, 0:00:00

print datetime.timedelta(weeks=1)

7.4、获取时间差

#1 day, 0:00:00

oneday = datetime.timedelta(days=1)

#今天，2014-03-21 16:07:23.943000

today_time = datetime.datetime.now()

#昨天，2014-03-20 16:07:23.943000

yesterday_time = datetime.datetime.now() - oneday

#明天，2014-03-22 16:07:23.943000

tomorrow_time = datetime.datetime.now() + oneday

注意时间是浮点数，带毫秒。

那么要获取当前时间，需要格式化一下：

print datetime.datetime.strftime(today_time, ‘%Y-%m-%d %H:%M:%S‘)

print datetime.datetime.strftime(yesterday_time, ‘%Y-%m-%d %H:%M:%S‘)

print datetime.datetime.strftime(tomorrow_time, ‘%Y-%m-%d %H:%M:%S‘)

7.5、获取上个月最后一天

last_month_last_day = datetime.date(datetime.date.today().year,datetime.date.today().month,1)-datetime.timedelta(1)

7.6、字符串日期格式化为秒数，返回浮点类型：

expire_time = "2013-05-21 09:50:35"

d = datetime.datetime.strptime(expire_time,"%Y-%m-%d %H:%M:%S")

time_sec_float = time.mktime(d.timetuple())

print time_sec_float

7.7、日期格式化为秒数，返回浮点类型：

d = datetime.date.today()

time_sec_float = time.mktime(d.timetuple())

print time_sec_float

7.8、秒数转字符串

time_sec = time.time()

print time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(time_sec))

 01_python_(python语言与numpy库)

机器学习算法day01_python快速上手

课程大纲

课程目标：

1、在已有JAVA语言的基础上迅速实现python上手开发

2、掌握Numpy矩阵算法包的核心功能

3、了解数据挖掘与机器学习算法的概念及其关系

4、 

1 Python快速上手

1.1.Python简介

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

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

l  Python是一种解释型语言： 这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。

l  Python是交互式语言： 这意味着，您可以在一个Python提示符，直接互动执行写你的程序。

l  Python是面向对象语言: 这意味着Python支持面向对象的风格或代码封装在对象的编程技术。

l  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中，不使用括号来表示代码的类和函数定义块或流程控制。

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

如下所示：

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

1.3.2 Python引号

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

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

1.3.3 Python注释

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

1.3.4 分号的使用

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

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

1.4.Python的变量和集合

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

a)       数字

b)       字符串

c)        列表

d)       元组

e)       字典

f)   set

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

1.4.1变量定义和赋值

1.4.2字符串的使用

1.4.3列表的使用

将输出以下结果：

1.4.4元组使用

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

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

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

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

这将产生以下结果：

1.4.5字典

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

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

值可以是任意Python的对象。

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

这将产生以下结果：

1.4.6 set

定义一个set：

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

print a

a.remove(3)

a.add(6)

a.union(b)

1.4.7数据类型转换

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

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

例如：

a=int(‘A’,16)

print(a)

结果为: 10

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

print(a)

b=tuple("hello")

print b

c=complex(1,2)

print c

x=1

e=eval(‘x+1‘)

print e

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}

1.5.Python流程控制语法

1.5.1 if语句

if else

嵌套if else

1.5.2 while循环

1.5.3 for循环

当执行上面的代码，产生以下结果：

1.6.Python函数

1.6.1 基本形式[M2] 

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

默认参数和可变参数

1.6.2 匿名函数

²  可以使用lambda关键字来创建小的匿名函数。这些函数被称为匿名，因为它们不是以标准方式通过使用def关键字声明。

²  Lambda形式可以采取任何数量的参数，但在表现形式上只返回一个值。它们不能包含命令或多个表达式。

²  匿名函数不能直接调用打印，因为需要lambda表达式。

²  lambda函数都有自己的命名空间，并且不能访问变量高于在其参数列表和那些在全局命名空间的变量。

示例：

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中的高阶函数效果：

1.7.Python模块

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

1.7.1 模块的定义和导入

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

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

1.7.2 模块和包

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

1.7.1 模块搜索路径

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

1.7.2 导入模块

1.7.2.1 使用import语句导入模块

有下面两种方式

import module1

import module2

import module3

import module1,module2,module3

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

v  python标准库

v  第三方模块

v  应用程序自定义模块

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

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

单行导入

from module import name1,name2,name3

多行导入

from module import name1,name2,\

                   name3

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

from module import *

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

1.7.2.3 扩展的import语句

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

import simplejson as json

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

1.7.2.4 重新导入模块

reload(module)

内建函数reload可以重新导入一个已经存在的模块

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编码，可以指定编码方式，如

4. 解决导入循环问题

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

b.py

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

b.py

1.8.Python文件IO

1.8.1 文件读写

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

file_handler = open(filename,,mode）

open mode

操作文件对象方法

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

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

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

例4:文件的写操作

1.8.2 文件夹相关操作

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

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

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

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

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

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

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

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

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

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

Eg：

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

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

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

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

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

运行shell命令: os.system()

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

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

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

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

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

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

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

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

终止当前进程：os.exit（）

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

1.9  Python多线程

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

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

示例代码如下：

1.10面向对象

1.10.1 创建类

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

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

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

1.10.2 实例

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

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

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

类的方法

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

1.10.3 创建实例对象

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

访问属性

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

完整实例：

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

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

1.10.4 Python内置类属性

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

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

Employee.__doc__: 所有员工的基类

Employee.__name__: Employee

Employee.__module__: __main__

Employee.__bases__: ()

Employee.__dict__: {‘__module__‘: ‘__main__‘, ‘displayCount‘: <function displayCount at 0x10a939c80>, ‘empCount‘: 0, ‘displayEmployee‘: <function displayEmployee at 0x10a93caa0>, ‘__doc__‘: ‘\xe6\x89\x80\xe6\x9c\x89\xe5\x91\x98\xe5\xb7\xa5\xe7\x9a\x84\xe5\x9f\xba\xe7\xb1\xbb‘, ‘__init__‘: <function __init__ at 0x10a939578>}

1.10.5 私有属性

1、类的私有属性

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

2、类的私有方法

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

3、实例

运行结果会报错：

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

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

print counter._JustCounter__secretCount

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

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__方法运行：

以上实例运行结果如下：

3083401324  3083401324  3083401324

Point 销毁

1.10.7 类的继承

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

1、语法：

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

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

   ‘Optional class documentation string‘

   class_suite

2、实例：

以上代码执行结果如下：

调用子类构造方法

调用子类方法 child method

调用父类方法

父类属性 : 200

你可以继承多个类

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、方法重写

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

实例：

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

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)

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

Vector(7,8)

2 Numpy快速上手

2.1. 什么是Numpy

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

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

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

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

2.1.2 安装导入了Numpy

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

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：每个元素占用的字节数。

²  ndarray.data：指向数据内存。

2.2.2 ndarray常用方法示例

2.2.2.2 使用numpy.array方法

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

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

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

2.2.2.3 使用numpy.arange方法

2.2.2.4 使用numpy.linspace方法

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

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

构造“0”矩阵：

构造“1”矩阵

构造单位矩阵(E矩阵)

2.2.2.5 获取数组的属性：

2.2.3 数组的基本运算

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

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

2.2.3.1 数组的加减运算

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

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

2.2.3.2 数组乘法运算

2.2.3.3 数组内部运算

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

二维数组：

三维数组：

求元素最值

2.2.3.4 数组的索引、切片

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

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

当少于提供的索引数目少于轴数时，已给出的数值按秩的顺序复制，缺失的索引则默认为是整个切片：

b[i]中括号中的表达式被当作i和一系列"："，来代表剩下的轴。NumPy也允许你使用“点”像b[i,...]。

点(…)代表许多产生一个完整的索引元组必要的冒号。如果x是秩为5的数组(即它有5个轴)，那么:　　

l  x[1,2,…] 等同于 x[1,2,:,:,:],  

l  x[…,3] 等同于 x[:,:,:,:,3]

l  x[4,…,5,:] 等同 x[4,:,:,5,:]　

2.2.3.5 矩阵的遍历

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

2.2.3.6 合并数组

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

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

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

2.2.3.7 深度拷贝

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

2.2.3.8 矩阵转置运算

2.2.4 数组的形状操作

2.4.1 reshape更改数组的形状

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

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

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

2.4.2 resize更改数组形状

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

3 数据挖掘与机器学习导论

----机器学习算法最适用的场景就是：不便用规则处理的场合

3.1数据挖掘

简而言之，数据挖掘（Data Mining）是有组织有目的地收集数据，通过分析数据使之成为信息，从而在大量数据中寻找潜在规律以形成规则或知识的技术。

3.2 数据挖掘与机器学习的关系

机器学习可以用来作为数据挖掘的一种工具或手段；

数据挖掘的手段不限于机器学习，譬如还有诸如统计学等众多方法；

但机器学习的应用也远不止数据挖掘，其应用领域非常广泛，譬如人工智能；

3.2机器学习

3.2.1定义

机器学习(Machine Learning, ML)是一门多领域交叉学科，涉及概率论、统计学、逼近论、凸分析、算法复杂度理论等多门学科。专门研究计算机怎样模拟或实现人类的学习行为，以获取新的知识或技能，重新组织已有的知识结构使之不断改善自身的性能。

它是人工智能的核心，是使计算机具有智能的根本途径，其应用遍及人工智能的各个领域。目前，世界上共有几百种不同的机器学习算法。

3.2.2机器学习算法类别

分类与聚类

l  Classification (分类)[dht4] ：

给定一堆样本数据，以及这些数据所属的类别标签，通过算法来对预测新数据的类别

有先验知识

l  Clustering(聚类[dht5] )：

事先并不知道一堆数据可以被划分到哪些类，通过算法来发现数据之间的相似性，从而将相似的数据划入相应的类，简单地说就是把相似的东西分到一组

没有先验知识

常见的分类与聚类算法

• 常用的分类算法：k-最近邻法(k-nearest neighbor，kNN)，决策树分类法，朴素贝叶斯分类算法(native Bayesian classifier)、支持向量机(SVM)的分类器，神经网络法，模糊分类法等等。

• 常见聚类算法： K均值(K-means clustering)聚类算法、K-MEDOIDS算法、CLARANS算法；BIRCH算法、CURE算法、CHAMELEON算法等；基于密度的方法：DBSCAN算法、OPTICS算法、DENCLUE算法等；基于网格的方法：STING算法、CLIQUE算法、WAVE-CLUSTER算法；

监督学习与无监督学习

机器学习按照训练数据是否有“先验知识”，一般划分为三类：

1)       监督学习(supervised learning)

2)       无监督学习(unsupervised learning)

3)       半监督学习(semi-supervised learning)

ü  监督式学习技术需要关于结果的先验知识

例如，如果我们正在研究一个市场活动的历史数据，我们可以根据市场是否产生预期的反应来对数据进行分类，或决定下一步要花多少钱。监督式学习技术为预测和分类提供了强大的工具。

ü  无监督学习技术不需要先验知识。

例如，在某些欺诈的案例中，只有当事情发生很久以后，我们才可能知道某次交易是不是欺诈。在这种情况下，与其试图预测哪些交易是欺诈，我们不如使用机器学习来识别那些可疑的交易，并做出标记，以备后续观察。我们对某种特定的结果缺乏先验知识、但仍希望从数据中汲取有用的洞察时，就要用到无监督式学习。

3.3 机器学习的应用步骤

1)       需求分析

2)       收集数据

3)       探索数据特性

4)       提取数据特征并建模[dht6] 

5)       开发代码（常用语言：R语言，Python语言，spark mllib库）

6)       训练模型[dht7] 

7)       应用系统集成（比如将训练好的算法模型集成到推荐系统中）

通用机器学习算法应用工程技术架构

3.4 机器学习必需数学知识

在数据挖掘所用的机器学习算法中，很大一部分问题都可以归结为以下三个方面的数学知识：概率、距离、线性方程

3.4.1 概率

基本概念：

概率描述的是随机事件发生的可能性

比如，抛一枚硬币，出现正反两面的概率各为50%

基本计算：

设一个黑箱中有8个黑球2个红球，现随机抽取一个球，则

取到黑球的概率为：8/(8+2) =0.8

取到红球的概率：2 /(8+2) =0.2

条件概率：

假如有两个黑箱A/B，A中有7黑球+1红球，B中有1黑球+1红球，假如随机抽取到一个球为红球，问，球来自A箱的概率——这就是条件概率问题

所求概率可表示为： p(A|红球)   即在已知结果是红球的条件下，是来自A的概率

条件概率的计算：

P(A|红球) = P(A,红球)/P(A)

<补充：具体运算过程>[dht8] 

3.4.2 距离（相似度）

在机器学习中，距离通常用来衡量两个样本之间的相似度，当然，在数学上，距离这个概念很丰满，有很多具体的距离度量，最直白的是“欧氏距离”，即几何上的直线距离

v  图示：

如图，在二维平面上有两个点(x1,y1) , (x2,y2)，求两点之间的距离

v  计算方法：

 D₁₂ =  

 而在机器学习中，通常涉及的是多维空间中点的距离计算，计算方式一样：

 Dn =

3.4.3 线性方程

机器学习中的线性拟合或回归分类问题都需要理解线性方程

v  图示

线性方程用来描述二维空间中的直线或多维空间中的平面，比如在二维空间中，如图

y=ax+b即是图中直线的线性方程：

u  x是自变量，y是因变量

u  a b 是参数，决定直线的斜率和截距

如果在多维空间中，线性方程则是表示平面，方程形式如：ax+by+cz+d=0

v  计算方法

初等数学经常已知a,  b求解x y，而在高等数学中，我们往往是知道大量的(y,x)样本比如(x1,y1)，(x2,y2),(x3,y3)要求反推参数列表(a,b,..)

在维度小，样本数据都“正确+精确”的情况下，可以通过线性方程求解的方式来解出a,b,....

但在机器学习中，我们拿到的大量样本数据本身都是“不精确且充满噪点”的，所以代入方程来求解a,b...显然不可行，此时，一般都是采用逼近的思想[dht9] 来求解：

<补充：一个运算实例>[dht10] 

3.4.5 向量和矩阵

在以上3大数学问题中，都涉及到大量样本数据大量特征值的“批量运算”，此时，可运用数学中的工具：“向量和矩阵”

N维向量：就是一个一维的数组(x1,x2,x3,x4,.....)，数组中的元素个数即为向量的“维度数”

矩阵：将多个(比如M个) N维向量写在一起，就是矩阵（M*N）：

x11,x12,x13,x14,.....

x21,x22,x23,x24,.....

x31,x32,x33,x34,.....

x41,x42,x43,x44,.....

矩阵和向量的意义主要在哪呢？就是为了方便快速地进行大量数据（尤其是线性方程问题）的批量运算

如：

矩阵相加

矩阵相乘

python

原文：https://www.cnblogs.com/skorzeny/p/6686881.html