做数据挖掘、机器学习需要用到Python，写下一些基本备忘，特别是相对C++不同的地方
信息源
RUNOOB.COM 上的Python教程
http://www.runoob.com/python/python-intro.html
Python定义和特性
Python 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。
- Python 是一种解释型语言： 这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。
- Python 是交互式语言： 这意味着，您可以在一个Python提示符，直接互动执行写你的程序。
- Python 是面向对象语言: 这意味着Python支持面向对象的风格或代码封装在对象的编程技术。
Python代码缩进结构
没有{}作为代码块功能，利用缩进结构和代码块前一行加个冒号（:）区分代码块
普通语句除非同行 无需 分号（;）
Python变量无需声明类型 直接赋值
| 标准数据类型 | 描述 |
|---|---|
| Numbers（数字） | int float complex复数 |
| String（字符串） |
特殊的索引负数索引
使用 [头下标:尾下标] 来截取相应的字符串 |
| List（列表） | 中括号 [ ] Python 中使用最频繁的数据类型 |
| Tuple（元组） | 小括号 ( ) 元组不能二次赋值，相当于只读列表 |
| Dictionary（字典） | 大括号 { } 键值对 dict={}; dict[180]="林烁"tinydict = {'name': 'john','code':6734, 'dept': 'sales'}
|
有数据类型转换内置函数
| 函数 | 描述 |
|---|---|
| str(x) | 将对象 x 转换为字符串 |
| dict(d) | 创建一个字典。d 必须是一个序列 (key,value)元组。 |
Python运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| ** | 幂 - 返回x的y次幂 | a**b 为10的20次方， 输出结果 100000000000000000000 |
| // | 取整除 - 返回商的整数部分（向下取整） | 9//2 输出结果 4 , 9.0//2.0 输出结果 4.0 |
| **= | 幂赋值运算符 | c **= a 等效于 c = c ** a |
| //= | 取整除赋值运算符 | c //= a 等效于 c = c // a |
| ^ << >> | 按位异或 左移 右移 |
a = 60 # 60 = 0011 1100 c = a >> 2; # 15 = 0000 1111
|
| **not ** | 布尔“非”，不是 ！ |
if not( a and b ): print "5 - 变量 a 和 b 都为 false，或其中一个变量为 false"else: print "5 - 变量 a 和 b 都为 true"
|
|
in not in |
成员运算符 | a=10; list=[1,2,3]; if ( a in list ): print:"yes" |
| is |
身份运算符 is 是判断两个标识符是不是引用自一个对象 每一个变量都有name、id、value三个属性 |
x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False |
| is not | is not 是判断两个标识符是不是引用自不同对象 | x is not y ， 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。 |
Python语句
- Python没有switch语句
用elif num==2:来实现其功能 - Python 的 while...else语句
#!/usr/bin/python
count = 0
while count < 5:
print count, " is less than 5"
count = count + 1
else:
print count, " is not less than 5"
- Pthon的 for .. in .. : 可以遍历任何序列的项目，如一个列表或者一个字符串
fruits = ['banana', 'apple', 'mango']
for fruit in fruits: # 第二个实例
print '当前水果 :', fruit
for index in range(len(fruits)): #通过序列索引迭代
print '当前水果 :', fruits[index]
print "Good bye!"
- Python 的 pass 语句
占位符，凑格式
Python 模块导入
- cmath
import math
cmath 模块的函数跟 math 模块函数基本一致，区别是 cmath 模块运算的是复数，math 模块运算的是数学运算。
>>> import cmath
>>> dir(cmath)
['__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atanh', 'cos', 'cosh', 'e', 'exp', 'inf', 'infj', 'isclose', 'isfinite', 'isinf', 'isnan', 'log', 'log10', 'nan', 'nanj', 'phase', 'pi', 'polar', 'rect', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau']
>>> cmath.sqrt(-1)
1j
>>> cmath.sqrt(9)
(3+0j)
>>> cmath.sin(1)
(0.8414709848078965+0j)
>>> cmath.log10(100)
(2+0j)
>>>
- Python随机数函数
- 三角函数
- 数学常量 pi e
Python字符串
- "hello world" 'hello world' 单引号双引号都行
- 字符串运算符 + * 索引[] 截取 [ : ] in
not inr"haha\n" % -
字符串格式化
print "My name is %s and weight is %d kg!" % ('Zara', 21) -
Python 三引号
实现WYSIWYG，所见即所得
Python 变量没有类型
a=[1,2,3]
a="Runoob"
[1,2,3] 是 List 类型，"Runoob" 是 String 类型，而变量 a 是没有类型，她仅仅是一个对象的引用（一个指针），可以是 List 类型对象，也可以指向 String 类型对象。
Python文件操作
- 打开文件
语法：file object = open(file_name [, access_mode = "r" ][, buffering])
完整语法：open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
例子：fo=open("foo.txt","a+")
access_mode参数
六种模式
默认为文本模式，如果要以二进制模式打开，加上 b,如 ab+,rb+,wb
- 关闭文件方法
fo.close()是一个好习惯
避免遗漏以及繁琐操作，Python引入了with语句来自动调用close()
with open("foo.txt","a") as fo:
fo.write("Don't scoff at others\n")
print (fo.read())
pass
- File对象的属性
| 属性 | 描述 |
|---|---|
| file.closed | 文件是否已关闭 |
| file.mode | 文件的打开方式 |
| file.name | 文件的名称 |
- 文件读写方法
| 方法(函数) | 描述 |
|---|---|
| fo.read([count]) | 读字节数，不带参数读整个文件，可读二进制文件 |
| fo.readline() | 读一行 |
| fo.readlines() | 读所有行，存入一个列表中 可用for line in fo.readlines遍历 ['Hello, world!\n','I love you \n'] 利用 len(fo.readlines())可以获取文本文件的行数
|
| file.write(str) | - 在文件关闭前或缓冲区刷新前，字符串内容存储在缓冲区中，这时你在文件中是看不到写入的内容的。 - 如果文件打开模式带 b，那写入文件内容时，str (参数)要用 encode 方法转为 bytes 形式，否则报错：TypeError: a bytes-like object is required, not 'str'。 |
| file.writelines(sequence) | 向文件写入字符串列表序列 |
- 文件定位
| 方法(函数) | 描述 |
|---|---|
| file.tell() | 返回文件当前读写指针位置 |
| file.seek(offset[, whence]) | 设置文件当前位置 whence 何处默认值为0，从文件开头开始算起，whence=1 从当前位置算起（即tell()返回值），2表示从文件末尾算起。 |
-
file.next() 方法
方法在文件使用迭代器时会使用到，在循环中，next()方法会在每次循环中调用，该方法返回文件的下一行，如果到达结尾(EOF),则触发 StopIteration
fo=open("foo.txt","r")
print ("文件名为：",fo.name)
for index in range(5):
line = fo.__next__()
print ("第 %d 行 - %s" % (index,line))
fo.close()
-
file.flush()
把输出缓存区的内容flush到文件系统的文件中，输出缓冲区因此被清空（flushed，冲掉了） -
file.truncate( [ size = 0 ] )
从文件当前位置保留size个字节后面的全部truncate（剪）掉 -
Python os 模块
os 文件/目录 方法一览表
import os
os.rename(current_file_name, new_file_name)
os.remove(file_name)
- 目录操作
os.getcwd()
os.mkdir("newdir")
os.chdir("newdir")
os.rmdir("newdir")
Python 内置函数（常用）
- 数学相关
| Input | Output |
|---|---|
| abs(-1) | 1 |
| max([1,2,3]) min([1,2,3]) |
3 1 |
| 序列长度 len('abc')、len([1,2,3])、len((1,2,3)) | 3 |
| 返回(商,余数)的tupple的除法 divmod(10,3) |
(3,1) |
| pow(9,1/2) | 3.0 |
| 四舍五入round(1.6) | 2 |
- range()
输出0~9
for index in range(10):
print (index)
pass
打印单字符不换行
x='linshuo'
for i in range(len(x)):
print(x[i],end=" ")
____
l i n s h u o
range常用法
>>>range(10) # 从 0 开始到 10
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(1, 11) # 从 1 开始到 11
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> range(0, 30, 5) # 步长为 5
[0, 5, 10, 15, 20, 25]
>>> range(0, 10, 3) # 步长为 3
[0, 3, 6, 9]
>>> range(0, -10, -1) # 负数
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
>>> range(0)
[]
>>> range(1, 0)
[]
Python 面向对象-类
对象包括两个数据成员，类变量和实例变量
-
类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
书写方式类名.类变量名 Teacher.teacherCount - 实例变量：定义在方法中的变量，只作用于当前实例的类。
- 类的定义
class Employee:
'所有员工的基类'
empCount=0 #类变量
def __init__(self,name,salary):
self.name=name
self.salary=salary
Employee.empCount += 1
def __del__(self):
class_name = self.__class__.__name__
print (class_name,"销毁")
def displayCount(self):
print ("Total Employee: %d" % Employee.empCount)
def displayEmployee(self):
print ("Name: %s ,Salary: %d " % (self.name,self.salary))
self 代表类的实例，而非类
类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self。
(self 不是 python 关键字，我们把他换成 runoob 也是可以正常执行的)
-
类的私有属性与私有方法
__secretAttr = 0
两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs
__private_method
两个下划线开头，声明该方法为私有方法，不能在类的外部调用。在类的内部调用 self.__private_methods
实例化的类访问私有属性的方式
foo._Foo__.__privateAttr
Python不允许实例化的类访问私有数据，但你可以使用object._className__attrName（ 对象名._类名__私有属性名 ）访问属性 -
类方法
实例方法、类方法与静态方法的区别
@classmethod
def displayCount(cls):
print ("Total Employee: %d" % Employee.empCount)
print ("Total Teachers: %d" % Teacher.teacherCount)
___
调用时用 Teacher.displayCount()
-
对象的属性操作
getattr(obj, name[, default]) : 访问对象的属性。
hasattr(obj,name) : 检查是否存在一个属性。
setattr(obj,name,value) : 设置一个属性。如果属性不存在，会创建一个新属性。
delattr(obj, name) : 删除属性。
hasattr(emp1,'age') ; setattr(emp1,'age',11) ; getattr(emp1,'age') ; delattr(emp1,'age')
或者
emp1.age = 7 # 添加一个 'age' 属性
emp1.age = 8 # 修改 'age' 属性
del emp1.age # 删除 'age' 属性 -
类的内置属性
Employee.__doc__ # '所有员工的基类'
Employee.__name__ # 'Employee'
Employee.__module__ # __main__
Employee.__bases__ # ()
Employee.__dict__
- 类的继承
class SubClassName (ParentClass1[, ParentClass2, ...]):
pass
class Teacher(Employee):
'这个是老师类，职员的派生类'
teacherCount = 0 #类变量
def __init__(self,name,salary):
Employee.__init__(self,name,salary)
Teacher.teacherCount += 1
@classmethod #类方法
def displayCount(cls):
print ("Total Employee: %d" % Employee.empCount)
print ("Total Teachers: %d" % Teacher.teacherCount)
def displayEmployee(self):#方法override
print("Teacher- Name: %s ,Salary: %d " % (self.name,self.salary))
def __del__(self):
Teacher.teacherCount -= 1
print ("Teacher类的析构方法")
Employee.__del__(self)
-
子类构造方法和父类构造方法的重写
如果在子类中需要父类的构造方法就需要显示的调用父类的构造方法，或者不重写父类的构造方法。
子类不重写__init__，实例化子类时，会自动调用父类定义的__init__。
如果重写了__init__，实例化子类时，就不会调用父类定义的__init__。
重写__init__,如果要用到父类的构造方法，可以用父类名称.__init__(self,arg1,arg2,...)的方式调用 - 运算符重载
class Vector:
def __init__(self,a,b):
self.a=a
self.b=b
#obj->str方法重载
def __str__(self):
return '我重载了__str__函数\n Vector (%d,%d)' % (self.a,self.b)
# 运算符重载
def __add__(self,other):
return Vector(self.a+other.a,self.b+other.b)
v1 = Vector(1,1)
v2=Vector(2,3)
print (v1+v2)
-----------------------------
输出：
我重载了__str__函数
Vector (3,4)
- 单下划线、双下划线、头尾双下划线说明
| 格式 | 说明 |
|---|---|
__foo__ |
特殊方法、系统定义的名字，如 __init__() __del__() __str__() __add__()
|
_foo |
protected variables 保护类型 只允许本身与子类进行访问，不能用于from module import *
|
__foo |
private variables 私有类型 只允许这个类本身进行访问 |
网友评论