python快速学习笔记

1.基本数据类型
变量不需要声明
基本数据类型
a=10         # int 整数
a=1.3        # float 浮点数
a=True       # 真值 (True/False)
a='Hello!'   # 字符串
以上是最常用的数据类型，对于字符串来说，也可以用双引号。
变量不需要声明，不需要删除，可以直接回收使用。
type(): 查询数据类型
2.序列
序列有两种：tuple（定值表； 也有翻译为元组） 和 list (表)
>>>s1 = (2, 1.3, 'love', 5.6, 9, 12, False)         # s1是一个tuple
>>>s2 = [True, 5, 'smile']                          # s2是一个list
tuple和list的主要区别在于，一旦建立，tuple的各个元素不可再变更，而list的各个元素可以再变更。
序列引用
序列元素的下标从0开始：
>>>print s1[0]
范围引用： 基本样式[下限:上限:步长]
>>>print s1[:5]             # 从开始到下标4 （下标5的元素 不包括在内）
>>>print s1[2:]             # 从下标2到最后
>>>print s1[0:5:2]          # 从下标0到下标4 (下标5不包括在内)，每隔2取一个元素 （下标为0，2，4的元素）
>>>print s1[2:0:-1]         # 从下标2到下标1
从上面可以看到，在范围引用的时候，如果写明上限，那么这个上限本身不包括在内。
尾部元素引用
>>>print s1[-1]             # 序列最后一个元素
>>>print s1[-3]             # 序列倒数第三个元素
同样，如果s1[0:-1], 那么最后一个元素不会被引用 （再一次，不包括上限元素本身）
字符串是元组
3.运算
数学 +, -, *, /, **, %
判断 ==, !=, >, >=, <, <=, in
逻辑 and, or, not
4.选择语句IF
if语句之后的冒号
以四个空格的缩进来表示隶属关系, Python中不能随意缩进
if  <条件1>:
    statement
elif <条件2>:
    statement
elif <条件3>：
    statement
else:
    statement
5.循环语句
range()这个函数的功能是新建一个表。这个表的元素都是整数，从0开始，下一个元素比前一个大1， 直到函数中所写的上限 （不包括该上限本身）
for 元素 in 序列:
while 条件:
continue
break
6.函数
def function_name(a,b,c):
    statement
    return something  # return不是必须的return可以返回多个值，以逗号分隔。相当于返回一个tuple(定值表)。
return并不是必须的，当没有return, 或者return后面没有返回值时，函数将自动返回None。
函数调用和参数传递
基本数据类型的参数：值传递 （原值不变）
表作为参数：指针传递  （原表中元素发生改变）
7.面向对象
定义类
class Bird(object):
    have_feather = True
    way_of_reproduction = 'egg'
    def move(self, dx, dy):
        position = [0,0]
        position[0] = position[0] + dx
        position[1] = position[1] + dy
        return position
没有父类的类引用object
类中方法的参数中有一个self，它是为了方便我们引用对象自身。方法的第一个参数必须是self，无论是否用到。
创建对象
summer = Bird()
print 'after move:',summer.move(5,8)
继承
class Chicken(Bird):
    way_of_move = 'walk'
    possible_in_KFC = True
Chicken将享有Bird的所有属性。
__init__()方法
特殊方法的特点是名字前后有两个下划线。如果你在类中定义了__init__()这个方法，创建对象时，Python会自动调用这个方法。这个过程也叫初始化。
类和对象属性之间的区别，类属性是所有对象具有的属性，对象属性是特定于某个对象所具有的。
dir()用来查询一个类或者对象所有属性，help()用来查询的说明文档。
8.list类的一些方法
实验一些list的方法：
>>>print nl.count(5)       # 计数，看总共有多少个5
>>>print nl.index(3)       # 查询 nl 的第一个3的下标
>>>nl.append(6)            # 在 nl 的最后增添一个新元素6
>>>nl.sort()               # 对nl的元素排序
>>>print nl.pop()          # 从nl中去除最后一个元素，并将该元素返回。
>>>nl.remove(2)            # 从nl中去除第一个2
>>>nl.insert(0,9)          # 在下标为0的位置插入9
9.字典
dic = {'tom':11, 'sam':57,'lily':100}
与表不同的是，词典的元素没有顺序。你不能通过下标引用元素。词典是通过键来引用dic['tom'] = 11。
词典元素的循环调用
dic = {'lilei': 90, 'lily': 100, 'sam': 57, 'tom': 90}
for key in dic:
    print dic[key]
字典常用方法
>>>print dic.keys()           # 返回dic所有的键
>>>print dic.values()         # 返回dic所有的值
>>>print dic.items()          # 返回dic所有的元素（键值对）
>>>dic.clear()                # 清空dic，dict变为{}
>>>del dic['tom']             # 删除 dic 的‘tom’元素
>>>print(len(dic))            #字典中元素个数
10.文件操作
创建文件对象
f = open(文件名，模式)
最常用的模式有：
"r"     # 只读
"w"     # 写入
读取：
content = f.read(N)          # 读取N bytes的数据
content = f.readline()       # 读取一行
content = f.readlines()      # 读取所有行，储存在列表中，每个元素是一行。\
写入：
f.write('I like apple')      # 将'I like apple'写入文件
关闭文件：
f.close()
11.模块
模块(module)也是为了同样的目的。在Python中，一个.py文件就构成一个模块。通过模块，你可以调用其它文件中的程序。
模块引入
import first              #引入first模块调用模块中对象时first.laugh()
import a as b             # 引入模块a，并将模块a重命名为b
from a import function1   # 从模块a中引入function1对象。调用a中对象时，我们不用再说明模块，即直接使用function1，而不是a.function1。
from a import *           # 从模块a中引入所有对象。调用a中对象时，我们不用再说明模块，即直接使用对象，而不是a.对象。
搜索路径
Python会在以下路径中搜索它想要寻找的模块：
程序所在的文件夹
标准库的安装路径
操作系统环境变量PYTHONPATH所包含的路径
模块包：
可以将功能相似的模块放在同一个文件夹（比如说this_dir）中，构成一个模块包。通过import this_dir.module引入this_dir文件夹中的module模块。
该文件夹中必须包含一个__init__.py的文件，提醒Python，该文件夹为一个模块包。__init__.py可以是一个空文件。
12.函数的参数
函数的参数传递方式有：根据位置传递，根据关键字传递，包裹传递，包裹关键字传递，解包裹传递。
def f(a,b,c):
    return a+b+c
print(f(1,2,3))
print(f(c=3,b=2,a=1))
参数默认值
def f(a,b,c=10):
    return a+b+c


print(f(3,2))
print(f(3,2,1))
包裹传递：
在定义函数时，我们有时候并不知道调用的时候会传递多少个参数。这时候，包裹(packing)位置参数，或者包裹关键字参数，来进行参数传递，会非常有用。
def func(*name):
    print type(name)
    print name


func(1,4,6)
func(5,6,7,1,2,3)
包裹关键字传递：dict是一个字典，收集所有的关键字，传递给函数func
def func(**dict):
    print type(dict)
    print dict


func(a=1,b=9)
func(m=2,n=1,c=11)
解包裹：*和**，也可以在调用的时候使用，即解包裹(unpacking)
def func(a,b,c):
    print a,b,c


args = (1,3,4)
func(*args)
dict = {'a':1,'b':2,'c':3}
func(**dict)
13.循环设计
for循环后的in跟随一个序列的话，循环每次使用的序列元素，而不是序列的下标。


S = 'abcdefghijk'
for i in range(0,len(S),2):
    print S[i]
range():我们利用len()函数和range()函数，用i作为S序列的下标来控制循环。在range函数中，分别定义上限，下限和每次循环的步长。
S = 'abcdefghijk'
for (index,char) in enumerate(S):
    print index
    print char
enumerate()：enumerate()在每次循环中，返回的是一个包含两个元素的定值表(tuple)，两个元素分别赋予index和char
如果你多个等长的序列，然后想要每次循环时从各个序列分别取出一个元素，可以利用zip()方便地实现：
ta = [1,2,3]
tb = [9,8,7]
tc = ['a','b','c']
for (a,b,c) in zip(ta,tb,tc):
    print(a,b,c)
zip()函数的功能，就是从多个列表中，依次各取出一个元素。每次取出的(来自不同列表的)元素合成一个元组，合并成的元组放入zip()返回的列表中。zip()函数起到了聚合列表的功能。
ta = [1,2,3]
tb = [9,8,7]
# cluster
zipped = zip(ta,tb)  #聚合两个列表
print(zipped)
# decompose
na, nb = zip(*zipped) #分解聚合
print(na, nb)
14.循环对象
循环对象：它包含有一个next()方法(__next__()方法，在python 3x中)， 这个方法的目的是进行到下一个结果，而在结束一系列结果之后，举出StopIteration错误。
当一个循环结构（比如for）调用循环对象时，它就会每次循环的时候调用next()方法，直到StopIteration出现，for循环接收到，就知道循环已经结束，停止调用next()。
迭代器：从技术上来说，循环对象和for循环调用之间还有一个中间层，就是要将循环对象转换成迭代器(iterator)。这一转换是通过使用iter()函数实现的。但从逻辑层面上，常常可以忽略这一层，所以循环对象和迭代器常常相互指代对方。
生成器：生成器(generator)的主要目的是构成一个用户自定义的循环对象。
生成器的编写方法和函数定义类似，只是在return的地方改为yield。生成器中可以有多个yield。当生成器遇到一个yield时，会暂停运行生成器，返回yield后面的值。当再次调用生成器的时候，会从刚才暂停的地方继续运行，直到下一个yield。生成器自身又构成一个循环器，每次循环使用一个yield返回的值
def gen():
    a = 100
    yield a
    a = a*8
    yield a
    yield 1000
该生成器共有三个yield， 如果用作循环器时，会进行三次循环。
for i in gen():
    print i
生成器表达式：G = (x for x in range(4))
表推导：表推导(list comprehension)是快速生成表的方法。L = [x**2 for x in range(10)]
15.函数对象
lambda函数：生成一个函数对象该函数参数为x,y，返回值为x+y。函数对象赋给func。func的调用与正常函数无异。
func = lambda x,y: x + y
print func(3,4)
函数可以作为参数传递;函数可以作为一个对象，进行参数传递
def test(f, a, b):
    print 'test'
    print f(a, b)


test(func, 3, 5)
map()函数：map()是Python的内置函数。它的第一个参数是一个函数对象。
map()的功能是将函数对象依次作用于表的每一个元素，每次作用的结果储存于返回的表中。
re = map((lambda x: x+3),[1,3,5,6])
re = map((lambda x,y: x+y),[1,2,3],[6,7,9])
reduce()函数：reduce函数的第一个参数也是函数，但有一个要求，就是这个函数自身能接收两个参数。reduce可以累进地将函数作用于各个参数。
print reduce((lambda x,y: x+y),[1,2,5,7,9])
相当于(((1+2)+5)+7)+9，相当于函数的计算结果作为参数与后面的元素再作用函数。
filter()函数：filter函数的第一个参数也是一个函数对象。它也是将作为参数的函数对象作用于多个元素。如果函数对象返回的是True，则该次的元素被储存于返回的表中。filter通过读入的函数来筛选数据。
def func(a):
    if a > 100:
        return True
    else:
        return False


print filter(func,[10,56,101,500])




16.异常处理
try:
    ...
except exception1:
    ...
except exception2:
    ...
except:
    ...
else:
    ...
finally:
    ...
   如果try中有异常发生时，将执行异常的归属，执行except。异常层层比较，看是否是exception1, exception2...，直到找到其归属，执行相应的except中的语句。如果except后面没有任何参数，那么表示所有的exception都交给这段程序处理。
   如果try中没有异常，那么except部分将跳过，执行else中的语句。
finally是无论是否有异常，最后都要做的一些事情。
抛出异常：raise StopIteration()
17.参数传递
不可变数据对象  参数传递时不改变
可变数据对象（列表、字典） 参数传递时有可能改变。


18.内建函数
s为一个序列
len(s)         返回： 序列中包含元素的个数
min(s)         返回： 序列中最小的元素
max(s)         返回： 序列中最大的元素
all(s)         返回： True, 如果所有元素都为True的话
any(s)         返回： True, 如果任一元素为True的话
下面的方法主要起查询功能，不改变序列本身, 可用于表和定值表:
sum(s)         返回：序列中所有元素的和
# x为元素值，i为下标(元素在序列中的位置)
s.count(x)     返回： x在s中出现的次数
s.index(x)     返回： x在s中第一次出现的下标


由于定值表的元素不可变更，下面方法只适用于表:
# l为一个表, l2为另一个表
l.extend(l2)        在表l的末尾添加表l2的所有元素
l.append(x)         在l的末尾附加x元素
l.sort()            对l中的元素排序
l.reverse()         将l中的元素逆序
l.pop()             返回：表l的最后一个元素，并在表l中删除该元素
del l[i]            删除该元素
(以上这些方法都是在原来的表的上进行操作，会对原来的表产生影响，而不是返回一个新表。)


下面是一些用于字符串的方法。尽管字符串是定值表的特殊的一种，但字符串(string)类有一些方法是改变字符串的。这些方法的本质不是对原有字符串进行操作，而是删除原有字符串，再建立一个新的字符串，所以并不与定值表的特点相矛盾。
#str为一个字符串，sub为str的一个子字符串。s为一个序列，它的元素都是字符串。width为一个整数，用于说明新生成字符串的宽度。
str.count(sub)       返回：sub在str中出现的次数
str.find(sub)        返回：从左开始，查找sub在str中第一次出现的位置。如果str中不包含sub，返回 -1
str.index(sub)       返回：从左开始，查找sub在str中第一次出现的位置。如果str中不包含sub，举出错误
str.rfind(sub)       返回：从右开始，查找sub在str中第一次出现的位置。如果str中不包含sub，返回 -1
str.rindex(sub)      返回：从右开始，查找sub在str中第一次出现的位置。如果str中不包含sub，举出错误
str.isalnum()        返回：True， 如果所有的字符都是字母或数字
str.isalpha()        返回：True，如果所有的字符都是字母
str.isdigit()        返回：True，如果所有的字符都是数字
str.istitle()        返回：True，如果所有的词的首字母都是大写
str.isspace()        返回：True，如果所有的字符都是空格
str.islower()        返回：True，如果所有的字符都是小写字母
str.isupper()        返回：True，如果所有的字符都是大写字母
str.split([sep, [max]])    返回：从左开始，以空格为分割符(separator)，将str分割为多个子字符串，总共分割max次。将所得的子字符串放在一个表中返回。可以str.split(',')的方式使用逗号或者其它分割符
str.rsplit([sep, [max]])   返回：从右开始，以空格为分割符(separator)，将str分割为多个子字符串，总共分割max次。将所得的子字符串放在一个表中返回。可以str.rsplit(',')的方式使用逗号或者其它分割符
str.join(s)                返回：将s中的元素，以str为分割符，合并成为一个字符串。
str.strip([sub])           返回：去掉字符串开头和结尾的空格。也可以提供参数sub，去掉位于字符串开头和结尾的sub  
str.replace(sub, new_sub)  返回：用一个新的字符串new_sub替换str中的sub
str.capitalize()           返回：将str第一个字母大写
str.lower()                返回：将str全部字母改为小写
str.upper()                返回：将str全部字母改为大写
str.swapcase()             返回：将str大写字母改为小写，小写改为大写
str.title()                返回：将str的每个词(以空格分隔)的首字母大写
str.center(width)          返回：长度为width的字符串，将原字符串放入该字符串中心，其它空余位置为空格。
str.ljust(width)           返回：长度为width的字符串，将原字符串左对齐放入该字符串，其它空余位置为空格。
str.rjust(width)           返回：长度为width的字符串，将原字符串右对齐放入该字符串，其它空余位置为空格。

19.正则表达式
使用正则表达式需要引入包re
import re
m = re.search('[0-9]','abcd4ef')
print(m.group(0))
正则表达式的函数
m = re.search(pattern, string)  # 搜索整个字符串，直到发现符合的子字符串。
m = re.match(pattern, string)   # 从头开始检查字符串是否符合正则表达式。必须从字符串的第一个字符开始就相符。
对于返回的m, 我们使用m.group()来调用结果
str = re.sub(pattern, replacement, string) # 在string中利用正则变换pattern进行搜索，对于搜索到的字符串，用另一字符串replacement替换。返回替换后的字符串。
re.split()                                 # 根据正则表达式分割字符串， 将分割后的所有子字符串放在一个表(list)中返回
re.findall()                               # 根据正则表达式搜索字符串，将所有符合的子字符串放在一给表(list)中返回
写一个正则表达式
1）单个字符:
.          任意的一个字符
a|b        字符a或字符b
[afg]      a或者f或者g的一个字符        
[0-4]      0-4范围内的一个字符
[a-f]      a-f范围内的一个字符
[^m]       不是m的一个字符
\s         一个空格
\S         一个非空格
\d         [0-9]
\D         [^0-9]
\w         [0-9a-zA-Z]
\W         [^0-9a-zA-Z]
2）重复
紧跟在单个字符之后，表示多个这样类似的字符
*         重复 >=0 次
+         重复 >=1 次
?         重复 0或者1 次
{m}       重复m次。比如说 a{4}相当于aaaa，再比如说[1-3]{2}相当于[1-3][1-3]
{m, n}    重复m到n次。比如说a{2, 5}表示a重复2到5次。小于m次的重复，或者大于n次的重复都不符合条件。
正则表达          相符的字符串举例
[0-9]{3,5}       9678
a?b              b
a+b              aaaaab
3) 位置
^         字符串的起始位置
$         字符串的结尾位置
正则表达          相符的字符串举例        不相符字符串
^ab.*c$          abeec               cabeec (如果用re.search(), 将无法找到。)
返回控制
import re
m = re.search("output_(\d{4})", "output_1986.txt")
print(m.group(1))
该正则表达式用括号()包围了一个小的正则表达式，\d{4}。 这个小的正则表达式被用于从结果中筛选想要的信息（在这里是四位数字）。这样被括号圈起来的正则表达式的一部分，称为群(group)。
我们可以m.group(number)的方法来查询群。group(0)是整个正则表达的搜索结果，group(1)是第一个群。
我们还可以将群命名，以便更好地使用m.group查询:
import re
m = re.search("output_(?P<year>\d{4})", "output_1986.txt")   #(?P<name>...) 为group命名
print(m.group("year"))
20.时间与日期
time包
time包基于C语言的库函数(library functions)。Python的解释器通常是用C编写的，Python的一些函数也会直接调用C语言的库函数。
import time
print(time.time())   # wall clock time, unit: second
print(time.clock())  # processor clock time, unit: second
time.sleep()可以将程序置于休眠状态，直到某时间间隔之后再唤醒程序，让程序继续运行。
import time
print('start')
time.sleep(10)     # sleep for 10 seconds
print('wake up')
time包还定义了struct_time对象。该对象实际上是将挂钟时间转换为年、月、日、时、分、秒……等日期信息，存储在该对象的各个属性中(tm_year, tm_mon, tm_mday...)。
下面方法可以将挂钟时间转换为struct_time对象:
st = time.gmtime()      # 返回struct_time格式的UTC时间
st = time.localtime()   # 返回struct_time格式的当地时间, 当地时区根据系统环境决定。
s  = time.mktime(st)    # 将struct_time格式转换成wall clock time
datetime包
import datetime
t = datetime.datetime(2012,9,3,21,30)
print(t)
所返回的t有如下属性:hour, minute, second, microsecond,year, month, day, weekday   # weekday表示周几
datetime包还定义了时间间隔对象(timedelta)。一个时间点(datetime)加上一个时间间隔(timedelta)可以得到一个新的时间点(datetime)。
import datetime
t      = datetime.datetime(2012,9,3,21,30)
t_next = datetime.datetime(2012,9,5,23,30)
delta1 = datetime.timedelta(seconds = 600)
delta2 = datetime.timedelta(weeks = 3)
print(t + delta1)
print(t + delta2)
print(t_next - t)
时间格式化
字符串转换为时间
import datetime
formatstr = "%Y-%m-%d %H:%M:%S"
strs = "2014-5-6 12:32:30"
t = datetime.datetime.strptime(strs,formatstr)
print(t)
时间转换为字符串
t.strftime("%Y-%m-%d-%H:%M:%S")  #m月份，M分钟
21.路径与文件
os.path包
import os.path
path = '/home/vamei/doc/file.txt'
print(os.path.basename(path))    # 查询路径中包含的文件名
print(os.path.dirname(path))     # 查询路径中包含的目录
info = os.path.split(path)       # 将路径分割成文件名和目录两个部分，放在一个表中返回
path2 = os.path.join('/', 'home', 'vamei', 'doc', 'file1.txt')  # 使用目录名和文件名构成一个路径字符串
p_list = [path, path2]
print(os.path.commonprefix(p_list))    # 查询多个路径的共同部分
print(os.path.exists(path))    # 查询文件是否存在
print(os.path.getsize(path))   # 查询文件大小
print(os.path.getatime(path))  # 查询文件上一次读取的时间
print(os.path.getmtime(path))  # 查询文件上一次修改的时间
print(os.path.isfile(path))    # 路径是否指向常规文件
print(os.path.isdir(path))     # 路径是否指向目录文件
glob包
glob.glob()列出所有符合该表达式的文件（与正则表达式类似），将所有文件名放在一个表中返回。所以glob.glob()是一个查询目录下文件的好方法。
import glob
print(glob.glob('/home/vamei/*'))
22.文件管理
os包下方法
mkdir(path)                  #创建新目录，path为一个字符串，表示新目录的路径。相当于$mkdir命令
rmdir(path)                  #删除空的目录，path为一个字符串，表示想要删除的目录的路径。相当于$rmdir命令
listdir(path)                #返回目录中所有文件。相当于$ls命令。
remove(path)                 #删除path指向的文件。
rename(src, dst)             #重命名文件，src和dst为两个路径，分别表示重命名之前和之后的路径。 
chmod(path, mode)            #改变path指向的文件的权限。相当于$chmod命令。
chown(path, uid, gid)        #改变path所指向文件的拥有者和拥有组。相当于$chown命令。
stat(path)                   #查看path所指向文件的附加信息，相当于$ls -l命令。
symlink(src, dst)            #为文件dst创建软链接，src为软链接文件的路径。相当于$ln -s命令。
getcwd()                     #查询当前工作路径 (cwd, current working directory)，相当于$pwd命令。
创建目录
import os
os.mkdir('/home/vamei/new')
shutil包下方法
copy(src, dst)               #复制文件，从src到dst。相当于$cp命令。
move(src, dst)               #移动文件，从src到dst。相当于$mv命令。
复制文件
import shutil
shutil.copy('a.txt', 'b.txt')