1、和C++、Java的区别：
动态类型：不需要声明a的类型。
a=34
type(a)
<type ‘int’>
一切皆对象：
4
2、数字:
自动转换类型：a=34
A=3.14
A=2**1000（2的1000次方）
//——整除的意思
Decimal:
问题1:0.3*3=0.8999999999999
解决办法1：print(0.3*3)
输出0.9
解决办法2：用decimal
From decimal import Decimal as D
D(‘0.3’)*D(3)
输出：Decimal(‘0.9’)
问题2:1/2**10000=0L
原因：上边这么写会自动转换成整数，所以为0。
错误改正：1.0/2**10000
此时又超了范围，无法表示
正确改正：D(1)/D(2**10000)
输出：Decimal(‘5.0123727……E-3011’)
decimal这么好的优点，可以计算许多。缺点是执行时间可能比较长。
我们可以用python -s “python语句”的形式在控制页面中执行Python的单条语句。再加上-mtimeit可以统计1000或10000次里边计算最快的那次。
例如：
python -mtimeit -s “from decimal import Decimal as D”
“D(‘1.2’)+D(‘3.4’)”与
python -mtimeit -s “from decimal import Decimal as D”
“1.2+3.4”的运行时间，发现Decimal 的运行时间比直接运行要慢很多。
常用库：
Import math
math.pi
math.sqrt(80)
math.log10(2**1000)
math.pow((x,y) 求x的y次方
math.factorial(x) x的阶乘
import random
random.random()
random.choice(1,2,3,4) 等概率的从中选一个
random.randint(a,b) a 到b的整数中的一个随机整数
random.uniform(a,b) a到b之间均匀分布的一个随机数
Random.gaus(mu,lamda) 返回一个高斯分布的随机数
使用help(math)可以返回所有的函数的用法。因为Python中一切皆对象，所以，写函数的时候要用点的形式调用(猜的)。
random有什么用：
random.random()>0.8则中奖
numpy 科学运算的库:产生数组或矩阵，正态分布的随机数矩阵运算，矩阵求逆
scipy 科学计算的库，拟合，线性插值，样条插值 积分，微分，解非线性方程
3、字符串
切片，索引
s=”use python do something”
s[1] s中第二个字符
s[-1] s中最后一个字符
s[1:3] s中1-3的字符串
s[1:6:2] s中从1开始，到6结束，2是步长
s[1:] 从1开始的到最终的所有字符
s[:-1] 从开始到最后一个字符
S[:] 表示所有
split 把单词按照某种要求分隔开如split(‘ ’)会按照空格把单词分隔开
join 和split区别，是把单词合并
常用的方法集合
“let us ”+s 把s加到let us后边
s*2 两个s
s.upper() 全部大写
s.find(‘pa’) 找含有pa的字符
s.replace(‘python’,’java’) 用java替换python
print”%s like %s %”(‘we’,’python’) 用we和Python填到%s里边
strip 是去掉两头的空格
转义字符
s=”C:\newpython”,print s,len(s)
解决方法:
r’ \n’前缀字符串，不考虑转义
三个双引号”””,用在字符串中既有单引号又有双引号的情况。
Unicode u’ ‘
可以显示各国语言，是一种编码方式，是一个字符集。如utf8是一种国际化的编码方式。如果只想支持国语：gb2312,建议大家都用utf8，会比较方便。
写法 u’ ’
字符串-re模块
import re
Regular expression
re.match(p,text) 从头开始找，其他地方不找，只返回一个
re.search(p,text) 从开始找，其他地方也找，只返回一个
re.findall(p,text) 返回多个，然后作为列表返回
re.split(p,text) 分离
re.sub(p,s,text) 替换
实际步骤(提高性能):pattern=re.compile(p)
result=pattern.match(text)
正则表达式(太多了，需要好好记)：
举例
^是非，|是或，[^0-9]意思是不是数字，因为空格也不是数字，所以后边会跟了一串……
贪婪模式* + 尽可能匹配多
非贪婪模式*? +? 尽可能匹配的少
4、日期和时间
datetime
日期：datetime.date.today()
日期和时间：datetime.datetime.now()
1000天以后是哪一天 datetime.timedelta(day=1)
打印格式：Isoformat(),strftime()
time
datetime.time(12,11,30) 十二点十一分三十秒
time.time() 实际时间，运行两次，然后求差
time.clock() cpu时间，运行两次，然后求差
time.sleep()
5、列表
类似于数组。
>>> a=[1,2,3]
>>> a_ref=a a_ref是a的引用
>>> a[2]=100
>>> a
[1, 2, 100]
>>> a_ref
[1, 2, 100]
常用操作
a_copy a的拷贝
a.append(300) a的末尾加一个元素
a.insert(1,50) 把50插到1这个位置上
a.pop() 弹出来
a.sort() 排序
a.reverse() 反序
del a[1] 删除1这个位置的元素
嵌套，多个类型并存
+与*
a.count(1)对a中的1进行计数。
列表属于变量，可以多次赋值；字符串是常量，不可以多次赋值
6、不可变列表——元组，用小括号()
(a,b,c),不能修改
常用操作：
index
count 对某个元素计数
+ *
嵌套 可嵌套可变的list
转换 tuple() 将一个list转换成元组
转换完成元组的时候，引用某个元素还是要用[]完成，而不是()。
7、字典
Key-Value
dict={‘xiaoming’:90,’xiaohong’:80,’xiaomao’:60,’xiaoli’:54} 直接定义字典
dict 每个字典都是一个对象，用它的构造函数生成一个字典
zip 两个相同长度的列表生成一个字典，一个是key，一个是values
常用操作
keys,values
get
update 想里边加入
del 删除
clear 清空
嵌套 关键字只能用不可变的类型，如数字，字母，元组等
字典是散列表，没有顺序，适合插入查询操作，key不一定是字符串，但一定是个不可变的对象。字典是通过关键字访问元素，list使用index来访问元素。
排序：
方法1：[(k,dict[k])for k in sorted(eict.keys())]
方法2：sorted(dict.iteritems(),key=lambda d:d[1],reverse=true)
再谈引用和拷贝
引用：字典直接用=，则是引用，拷贝需要专门的拷贝函数，这个与list不同。list的引用c=a，而赋值如d=a[:]
浅拷贝：
字典d.copy(),copy.copy(d)
列表L[:]
深拷贝：
copy.deepcopy(d)
如果只有一层的话，深拷贝和浅拷贝一样的，如果有多层，浅拷贝只拷贝一层。
8、文件
f=open(path,’r’)返回对象为file-like object 还可以是内存、网络等，r是只读，w是只写，a是既可以读也可以写。
f.read() 读出来一个字节或一个单位
f.readline() 读出一行来，读到换行为止
r.write() 写
r.close() 关闭文件
中文支持
import codecs
f=codecs.open(filename,mode,encoding) encoding我们一般用的uft-8的模式
文件操作
import os
os.path.exists(filename) 判断文件是否存在
实际操作在IDLE中照样是乱码，如果在cmd中或者在IDLE中生成文件后再运行时不会乱码。
shelve 库 （把书放到书架上）
import shelve
d=shelve.open(file)
d[‘name’]=’heibanke’
d.close()
它只有一个函数open，是一个简单的数据存储方案，你可以用它来存储东西，可以当做一个字典。
程序中‘d’并没有写进去，因为是d没有写回，你把[‘a’,’b’,’c’]存到x，当你再次读取s[‘x’]的时候，它又从源中读取了一个拷贝，解决办法是利用一个中间变量。
注意的是，f如果没有关闭的话，将会赋值成空，关闭之后再赋值，结果与第一次的一样。
pickle/cpickle 库 保存数据
import cpickle
f=open(file,mode)
cpickle.dump(obj,f)
obj=cpickle.load(f)
其中：
是一个元组。