python变量——黑板客老师课程学习

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)

　　　　　　

　　　　　　其中：

　　　　　　　　　

　　　　　　是一个元组。