python2.7笔记

python

……好好学习了下python2.7.放笔记放笔记

输入输出及NULL

输入 raw_input("输入提示")
输出 print
python的NULL None

函数导入

4种导入方式

1
2
3
4
import pandas
import pandas as pd #重命名为pd
from pandas import *
from pandas import funtion1

运算符

  • 没有++ –
  • 算数运算符 + - * / % ** //(表示整数除法，/在3.0只能表示浮点数除法)
  • 关系运算符 == != < > <= >= <>(在3.0已经被淘汰 )
  • 逻辑运算符 and or not (没有|| &&)
  • 位运算符 & | ^ ~ << >>
  • 成员运算符 in not in (判断是否包含)
  • 身份运算符 is not is (判断地址是否相同)

运算符优先级

符号 意思
** 指数 (最高优先级)
~ + - 按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)
* / % // 乘，除，取模和取整除
+ - 加法减法
>> << 右移，左移运算符
& 位 ‘AND’
^ ｜ 位运算符
<= < > >= 比较运算符
<> == != 等于运算符
= %= /= //= -= += *= **= 赋值运算符
is is not 身份运算符
in not in 成员运算符
not or and 逻辑运算符

变量

数字变量

类型：int long bool float complex(复数)
long 不固定长度，受限于虚拟内存

字符串变量

表现形式：‘str’ ‘’str’’ ‘’’str’’’
三引号可以保留字符串中的所有格式信息
字符串加 r或R 前缀表示不使用转义字符而是原生字符

字符串运算、索引、切片

字符串运算

str1+str2 拼接字符串
str*3 重复字符串
str in string 判断包含

字符串索引

从0开始，从前向后; str[0] 第一个字符
从-1开始，从后向前; str[-1] 倒数第一个字符

字符串切片

str[start:finish:countby] ———— 左闭右开
start: 切片开始位置，包括start索引对应字符（不设置，默认第一个字符）
finish: 切片结束位置，不包括end索引对应字符（不设置，默认最大索引+1）
countby：计数参数，若为2，隔一个字符取一个字符；若为-1，获得逆序输出（不设置，默认为1）ps.对于前两者参数有要求，start索引位置要位于end后，且符号相同

字符串方法

  • dir(变量类型)
    查看该变量类型所有方法
  • str.replace(old,new)
    生成一个新的字符串，用new替换所有old;可设定替换次数：max
  • str.find(str)
    返回第一次出现子串的下标，找不到则返回-1;可设定查找范围：beg，end
  • str.isdigit()
    字符串是否包含数字，ture，false
  • str.count(sub,start=0,end=len(string))
    统计字符串内子串出现的次数；可以设定范围;左闭右开，len(string) != -1;
  • str.strip()
    去掉字符串开始和结尾的空格回车;可设定自定义字符串sub,移除字符串中字符
  • str.split()
    str.split(分隔符，分割次数)
    返回分割后的字符串列表，分隔符默认是所有空格（空格、换行、制表符等）
  • str.title()
    生成一个新的字符串,所有单词首字母大写其他字母小写
  • str.capitalize()
    生成一个新的字符串,首字母大写其余小写（只有第一个字母）
  • str.upper()
    生成一个新的字符串,全部大写
  • str.lower()
    生成一个新的字符串,全部小写

字符串格式化

字符串格式化输出 有两种方法：str.format()函数和类似C语言的%形式

str.format()

利用 {} : 两个符号格式化字符串：{}设定参数位置, :设定参数格式
{}:

1
2
3
4
5
6
7
8
9
10
11
12
1.通过位置设定参数，可多次使用位置
    '{1}{0}{1}'.format(1,2)  ==> '212'
    使用列表
    >>> li = ['hoho',18]
        'my name is {} ,age {}'.format(*li)
        'my name is hoho ,age 18'
2.通过关键词设定参数（关键词不能为数字）
    '{name}{id}'.format(id='1',name='2') ===> '21'
    使用字典
    >>> hash = {'name':'hoho','age':18}
        'my name is {name},age is {age}'.format(**hash)
        'my name is hoho,age is 18'

::

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
1.填充与对齐
    **{:(填充字符)(对齐方式)(宽度)}**
    填充字符： 只能指定一个字符，不指定的话默认使用空格
    对齐方式： ^ < > 分别是 居中，左对齐，右对齐
    宽度： 总宽度;（宽度奇数，居中偏左；宽度过小，不填充）
    `'{:*>8}'.format('2015')`
2.精度与类型
    **{:(.精度长度)f}**
    .(精度长度): 长度为X的精度(4舍5入) 只能与f一起用
    类型：f(float) 
    `'{:.2f}'.format(3.12342)`
    **{:(类型)}**
    b(二进制) o(八进制) d(十进制) x(十六进制) float类型无法用b 0 d x 表示
    ,(金额的千位分隔符) float类型留一位小数
    `'{:d}.format(2015)'`
结合：`'{:0>8.2f}'.format(0.33)`

“” % ( )

另一种格式化字符串方法
例子
"abc %s" % ('abc')
格式符——控制位置和格式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
%%    字符"%"
%s    字符串 (采用str()的显示)
%r    字符串 (采用repr()的显示)
%c    单个字符
%b    二进制整数
%d    十进制整数
%i    十进制整数
%o    八进制整数
%x    十六进制整数
%e    指数 (基底写为e)
%E    指数 (基底写为E)
%f    浮点数
%F    浮点数，与上相同
%g    指数(e)或浮点数 (根据显示长度)
%G    指数(E)或浮点数 (根据显示长度)

添加格式控制

1
2
3
4
5
6
7
8
9
%[(name)][flags][width].[precision]类型
(name)为命名
flags：可以有**-,' '或0**。
    不填写flags表示右对齐。
    **-**：表示左对齐。
    **' '**：为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。
    **0**：表示使用0填充。
width：表示显示宽度，可以用*代替，在%后面作为参数填充
precision：表示小数点后精度，可以用*代替，在%后面作为参数填充

类型转换函数

字符与整数的转换（一个字符与ascii码）
字符转整数：ord()
整数转字符：chr()

python2.x关键词

1
2
3
4
5
6
and del from not while as
elif global or with assert
else if pass yield break 
except import print class exec
in raise continue finally is
return def for lambda try

函数

函数调用

函数的参数可以设置默认值

1
2
3
def test(a=1,b=2,c=3):
    print a,b,c
test()        # 123

4种静态函数调用

1
2
3
4
5
6
7
8
9
10
11
12
#coding:utf8
def test(a,b,c):
    print a,b,c
#元组x
x = (1, 2, 3)
#字典xx
xx={'a':1,'b':2,'c':3}

test(1,2,3)       #123
test(a=1,b=2,c=3) #123 abc为函数变量，填错报错
test(*x)          #123 元组转变，相当于式子1 ； list列表也可
test(**xx)        #123 字典转变，相当于式子2

2种动态参数调用
*arg

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#coding:utf8
def test2(*args):
    print type(args)
    for i in args:
        print i

test2(1)
test2(1,'a',None)
a=(1,'a',None)
test2(*a)
# <type 'tuple'>
# 1
# <type 'tuple'>
# 1
# a
# None
# <type 'tuple'>
# 1
# a
# None

**arg

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#coding:utf8
def test3(**args):
    print type(args)
    for k,v in args.items():
        print k,v
dic={'k1':1,'k2':'a'}
test3(k1=1)
test3(k1=1,k2='a')
test3(**dic)
# <type 'dict'>
# k1 1
# <type 'dict'>
# k2 a
# k1 1
# <type 'dict'>
# k2 a
# k1 1

两种动态参数混用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
def test4(*arg1,**arg2):
    for i in arg1:
        print i
    for k,v in arg2.items():
        print k,v
test4(1)
test4(k1=1)
test4(100,200,k3=True)
a=(100,200)
b={'k3':True}
test4(a,b)
test4(*a,**b)
# 1

# k1 1

# 100
# 200
# k3 True
####下一个输出结果：a,b 被*arg1编成元组 ((100, 200), {'k3': True})
####都在第一个for中输出
# (100, 200)
# {'k3': True}

# 100
# 200
# k3 True

静态动态混用
*arg1 **arg2 可以不填参数，arg必须填

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
def test5(arg,*arg1,**arg2):
    print arg
    for i in arg1:
        print i
    for k,v in arg2.items():
        print k,v
a=(100,200)
b={'k3':True}
test5(1)
test5(1,*a,**b)
# 1
# 1
# 100
# 200
# k3 True

Lambda函数

Lambda函数——快速定义单行函数
lambda (输入参数)：表达式
输入参数：可以有多个，’,’隔开
表达式：表达式的处理结果为返回值

1
2
f=lambda x,y:x+y
print f(4,5) #9

map函数

map函数——序列映射函数
Map(函数，序列)
函数：一个函数
序列：可以多个
返回：处理后的对应序列
多个序列输入到一个函数返回一个序列

1
2
3
4
m=[1,2,3,4,5]
n=[1,2,3,4,5]
print map(lambda x,y:x+y,m,n)
#[2, 4, 6, 8, 10]

Reduce函数

Reduce函数——序列叠加函数
Reduce(函数,序列)
函数：一个函数
序列：一个序列
返回：值
从序列中从左到右依次取数，进入函数，返回值作为第一个参数继续进入，如此叠加

1
2
3
m=[1,2,3,4,5]
print map(lambda x,y:x+y,m)
#15

Filter函数

Filter函数——过滤函数
filter(函数，序列)
函数：一个函数
序列：一个序列
返回 函数返回结果为真的值 组成的序列

1
2
3
m=[1,2,3,4,5]
print filter(lambda x:x%2,m)
#[1, 3, 5] 此处是奇数返回1

Eval()函数

eval(str)
str：字符串
将字符串str当成有效的表达式来求值并返回计算结果。

1
2
3
m="1+2"
print eval(m)
#3

列表（序列、List）

动态数组，有序
数组的值可以是任意类型
字符串运算、索引、切片同样适用

基础操作

生成列表,创建列表副本

1
2
3
4
5
6
7
8
a=[1,'a',['abc',1],3] # 可嵌套
##列表解析 [表达式 for 变量 in 列表 if 条件]
a=[x for x in range(10)] # 0-9
a=[x**2 for x in range(1,6)] # 1,4,9,16,25
a=[x for x in range(1,5) if x%2==0] # [2,4]
##列表副本
b=a    # b和a指向同一地址，牵一发而动全身
b=a[:] # b为一个新的列表不是跟a指向同一地址，就是切片[0:len(a)]，切片是生成新的列表

添加、删除、插入（不返回新列表，在原列表操作）

1
2
3
4
5
list=[1,2]
list.append(3) # [1,2,3]
list.append([3,4]) # [1,2,[3,4]]
list.remove(1) # [2,[3,4]]  删除对应的值，不是索引，多相同值，移除接近头的
list.insert(1,-1) # [2,-1,[3,4]] 在索引为1的位置插入-1

取尾元素、反转、排序

1
2
3
4
5
6
7
8
9
list=[2,-1,3]
list.pop() # [2,-1] 返回尾元素 list删除尾元素
list.reverse() # [-1,2]  在原列表操作
re = list[::-1] # [-1,2]
a=[-3,1,2]
a.sort() # [-3，1,2] 默认从小到大
sorted(a) # [-3，1,2]
a.sort(key=abs) # [1,2,-3]
a.sort(key=lambda x : 1/x) # [-3,2,1]

enumerate()函数

为可遍历对象提供索引
返回[(索引0，值0),(索引1，值1)……]

1
2
3
4
5
6
7
m=[1,2,3,4]
for index,value in enumerate(m):
    print index,value
# 0 1
# 1 2
# 2 3
# 3 4

嵌套列表

1
2
3
4
x=[[5,4,7,3],[4,8,9,7],[5,1,2,3]]
print x[2][1]  # 1 第三行第二个
print len(x)   # 3 行数
print len(x[0]) # 4 列数

列表实例

1
2
3
4
#一行输入多个数，保存在列表中
#raw_input() 默认是字符串 .split() 返回的是列表，列表的数据是字符
a=[int(i) for i in raw_input("输入多个数,空格分割").split()]
print a  #[1, 2, 3, 4]

元组(tuple)

静态数组，不能修改，长度固定
索引，切片，len适用
元组与列表可以嵌套

基础操作

生成元组,赋值，交换

1
2
3
4
5
6
7
8
9
10
#生成
a=1,2,3,4   #(1, 2, 3, 4)
b=(5,'a',7.0,8) #(5, 'a', 7.0, 8)
#赋值
b=a # (1, 2, 3, 4)  因为不能修改 无所谓地址不地址吧？
#交换
a,c = c,a  #相当于（a,c）=(c,a) 所以a,c 可以是任意类型
a,c='1 3'.split() #，的其他用法，但是此时得到a,c就不是元组
print a # 1
print c # 3

元组实例

1
2
3
4
def add(x,y)
    return x,y,x+y
x,y,z=add(6,7)
print x,y,z # 6 7 13

字典

键值对
不支持切片，索引

基础操作

生成,访问,添加，删除

1
2
3
4
5
6
7
8
9
10
11
12
13
 #键不可重复不可变，数字，字符串，元组，不能是列表（可变）
 #值是任意类型
#生成
dic={'name':'lala','id':1} #键名是字符串需要''
a=dict(name='liming',age=20) #键名是字符串不需要''
#访问
print dic['name'] # lala
#添加更新
dic['num']=1
dic.update({'ok':'1'}) #从b字典中更新a字典，如果键相同则更新，a中不存在则追加
#删除
del dic['ok']
dic.pop('num')

字典应用

1
2
3
4
5
6
7
8
9
len(dic) #字典中键值对的数量
if key in dic :#判断
    print 'ok'
for key in dic : #枚举字典中的键，键是无序的
    print dic[key]
dic.items() # 全部的键值对 用两个变量接受
dic.keys() # 全部的键
dic.valus() # 全部的值
dic.clear() # 清空字典

迭代

1
2
3
4
for t in h.iteritems()
    print t  # (1, 'lala')
for t,v in h.items()
    print t,v # 1 lala

集合

元素不重复，无序，不能枚举
不支持索引和切片操作
分为可变集合（set）和不变集合(frozen set)

基础操作

生成、添加、删除

1
2
3
4
5
6
7
8
9
10
11
12
13
#生成
x={'key1','key2'} 
print x # set(['key2', 'key1'])
y=frozenset(['key1','key2'])
print y # frozenset(['key2', 'key1'])
k=[1,2,3,1,2,3]
l=set(k)
print l # set([1, 2, 3])
#添加
l.add('body') # set(['body', 1, 2, 3])
#删除
l.remove('body') # set([1, 2, 3])
l.discard('body') # set([1, 2, 3]) 删除不存在的元素。discard不抛出异常，remove抛出异常

集合运算

1
2
3
4
5
6
7
8
# - 差集
# & 交集
# | 并集
# != 不等于
# == 等于
# < 是否为子集
# > 是否为超集
# set.isdisjoint(t) 是否有交集

文件读写

1
2
3
4
5
6
7
8
f=open('test.txt','r')
f.read() # 一次读取文件的全部的内容 存入str
f.readline() # 每次读取一行
f.readlines()  # 一次读取所有内容并按行返回list列表

f=open('test.txt','w') # 
f.write('Hello') # 
f.close()

Zip函数

zip(list1,list2)
输入：任意多个（包括0个和1个）序列 元组也可
返回：各个序列相应索引组成的元组的列表
序列长度不一，最后有多少个元组，取最短的序列作为元组长度
0个序列时 返回空序列
1个序列时 返回一个值的元组组成的序列 如：[(1,),(2,)]
zip(*list)
把zip的结果作为list输入，相当于unzip()
把序列拆分，其中的元组作为序列重新zip，变为原来的序列对应的元组

Numpy

列表list元素可以是任何对象，保存指针，浪费内存cpu
python自带array——一维数组，没有运算函数
Numpy的两种基本对象：
ndarray：数组，存储单一数据类型的多维数组
ufuc：对数组进行处理的函数

ndarray对象

索引，切片适用
导入、生成

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
import numpy as np
#from numpy import *
##### 通过创建python序列，再通过array函数转化为数组
a=np.array([1,2,3,4],dtype=np.float) #dtype 设定元素类型，默认整数
print a  # [ 1.  2.  3.  4.]
print a.dtype # float64
b=np.array([[1,2,3,4],[5,6,7,8]])
print b  
#[[1 2 3 4]
# [5 6 7 8]]
##### numpy自带创建创建数组函数
#np.arange(start=0,end,step=1) 左包右开
g=np.arange(0,1,0.2) # [ 0.   0.2  0.4  0.6  0.8]
#np.linspace(start,end,num,endpoint=True(包括终值)) 等差数列
h=np.linspace(0,1,5,endpoint=False) # [ 0.   0.2  0.4  0.6  0.8]
#np.logspace(start,end,num,endpoint=True(包括终值)),base=10（底数）) 等比数列
#base^start~base^end 取num
j=np.logspace(0,1,2,base=2) # [ 1.  2.]
#全0
np.zeros((3,3))
#全1
np.ones((3,3))
#对角线为1，4*4
np.eye(4)
#随机数 元素值0-1的2*2的随机数组
np.random.rand(2,2)
#fromfuction（函数，尺寸） 生成乘法表
def func(i,j):
    return (i+1)*(j+1)
table = np.fromfunction(func,(4,4))
# [[  1.   2.   3.   4.]
#  [  2.   4.   6.   8.]
#  [  3.   6.   9.  12.]
#  [  4.   8.  12.  16.]]

ndarray函数

以下类似1,2 其实都是元组 （1,2）

1
2
3
4
5
6
7
8
9
10
11
12
13
#获取数组维数
print a.shape,b.shape # (4L,) (2L, 4L) 一维数组 4列 二维数组 2行4列
#元素不变情况下,定义数组尺寸
b.shape=4,2
print b
# [[1 2]
#  [3 4]
#  [5 6]
#  [7 8]]
#创建改变数组尺寸的新数组
c=b.reshape(8,)  # [1 2 3 4 5 6 7 8]
d=b.reshape(1,8) # [[1 2 3 4 5 6 7 8]]
## reshape生成的新数组其实共享数据存储区域，牵一发而动全身

存取数组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#### 二维数组的切片取数  二维列表没有二维切片
data=np.arange(16).reshape(4,4)
data2=data[1:3,2:4] #左闭右开
[[ 6  7]
 [10 11]]
#########data展开成一行
print data[:]
#### 通过列表list取数 
##整数序列 作为索引 取行
data3=data[[0,1]]
[[0 1 2 3]
 [4 5 6 7]]
##元组序列 作为点索引 取点
data4=data[[(0,0),(0,1)]]
[0 1]
##布尔序列 元素个数要一致
data5=data4[np.array([True,False])]
data5=data4[[True,False]]  #两者一样
[0]
#### 条件筛选
data2>10 
[[False False]
 [False  True]]
#选出data中大于10的元素变成一维数组 原理是布尔序列取数
data[data>10] #[11 12 13 14 15]
#选出data中偶数元素变为一维数组  原理是布尔序列取数
data[data%2==0] #[ 0  2  4  6  8 10 12 14]

where函数

元素依次进入，生成返回值数组
np.where(条件,真返回值,假返回值)

1
2
3
4
5
6
#coding:utf8
import numpy as np
arr=np.random.rand(2,2)
print np.where(arr>0.5,1,0)
[[1 0]
 [0 0]]

cunsum函数、cumprod函数
对行（0）或列（1）累计求和、求列

ufunc运算

1
2
3
4
5
6
7
8
9
10
np.sin(ndarray) #对于ndarray中的每个元素求正弦值 返回新数组
np.add(ndarray1,ndarray2[,ndarray3]) #对于其中的元素一一相加 返回新数组[写入ndarray3]
np.subtract(x1,x2[,y]) # y=x1 - x2
np.multiply(x1,x2[,y]) # y=x1 * x2
np.divide(x1,x2[,y]) # y=x1 / x2
np.true divide(x1,x2[,y]) # y=x1 / x2 返回精确商
np.floor divide(x1,x2[,y]) # y=x1 // x2 返回对返回值取整
np.negative(x[,y]) # y= -x
np.power(x1,x2[,y]) # y = x1**x2
np.remainder(x1,x2[,y]) # y = x1 % x2

Pandas

Series 和 DataFrame 支持切片、筛选

Series

Series 类似于一维数组的对象，由一组数据以及相关的索引组成
生成、读取属性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
from pandas import *
############从序列中生成
se=Series([1,2,3,4])
print se
#索引 数据
# 0    1
# 1    2
# 2    3
# 3    4
# dtype: int64
se=Series([1,2,3,4],index=['a','b','c','d'])
print se
# a    1
# b    2
# c    3
# d    4
# dtype: int64
#################从字典中生成
sdata={'num1':1,'num2':2,'num3':3}
obj2=Series(sdata)
print obj2
# num1    1
# num2    2
# num3    3
# dtype: int64
#################从字典中生成，按照index排序，重构
sdata={'num1':1,'num2':2,'num3':3}
states=['num2','num1','name']
obj2=Series(sdata,index=states)
print obj2
#  索引  数据
# num2    2.0
# num1    1.0
# name    NaN
# dtype: float64
###########属性
print se.values,se.index 
#[1 2 3 4] Index([u'a', u'b', u'c', u'd'], dtype='object')

读取数据

不支持切片取数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
obj=Series([1,2,3,4],index=['a','b','c','d'])
###########按照索引读取值
print obj['a'] 
# 1
###########按照索引序列读取行
print obj[['a','b']] 
# a    1
# b    2
# dtype: int64
###########按照布尔Series取行
a=Series({'a':True,'b':True,'c':True,'d':False})
print obj[a]
# a    1
# b    2
# c    3

删除

del
只能删除一个 obj[‘’]

1
2
3
4
5
6
7
obj=Series([1,2,3,4],index=['a','b','c','d'])
del obj['a']
print obj
# b    2
# c    3
# d    4
# dtype: int64

drop
删除一个(‘’) 删除多个([‘’,’’])

1
2
3
4
5
6
from pandas import *
obj=Series([1,2,3,4],index=['a','b','c','d'])
print obj.drop(['a','b'])
# c    3
# d    4
# dtype: int64

筛选

numpy DataFrame 同理

1
2
3
4
5
6
7
8
9
print obj>pbj.median()
# a    False
# b    False
# c     True
# d     True
print obj[obj>obj.median()]  #原理 按照布尔Series取数
# c    3
# d    4
# dtype: int64

isnull notnull函数

1
2
3
4
5
6
7
8
9
import pandas as pd 
a={'ok':1,'go':2,'od':3}
obj=pd.Series(a,index=['ok','go','od','fi'])
print pd.isnull(obj)
ok    False
go    False
od    False
fi     True
dtype: bool

Series运算，索引取并集，索引相同之间运算，索引不同显示NaN

DataFrame

表格型数据结构
有行索引，有列索引
列的地位比行的高

生成

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
####################通过等长列表生成
from pandas import *
data1=[[1,2,3,4,],[5,6,7,8],[9,10,11,12]]
frame=DataFrame(data1)
print frame
#    0   1   2   3
# 0  1   2   3   4
# 1  5   6   7   8
# 2  9  10  11  12
#######通过序列或Numpy数组组成的字典生成，字典的键名作为列名
data2={'num1':[1,2,3,4],'num2':[5,6,7,8],'num3':[9,10,11,12]}
frame=DataFrame(data2)
print frame
#    num1  num2  num3
# 0     1     5     9
# 1     2     6    10
# 2     3     7    11
# 3     4     8    12
#######已经有列名，添加columns作为列序列，按照指定顺序排序
frame=DataFrame(data2,columns=['num3','num2','num1'])
print frame
#    num3  num2  num1
# 0     9     5     1
# 1    10     6     2
# 2    11     7     3
# 3    12     8     4
##############添加index作为行索引
frame=DataFrame(data2,index=['one','two','three','four'])
print frame
#        num1  num2  num3
# one       1     5     9
# two       2     6    10
# three     3     7    11
# four      4     8    12
###############嵌套字典生成DataFrame  外层字典的键作为列索引，内层键作为行索引
data2={'num1':{'one':1,'two':2},
'num2':{'one':5,'two':6},
'num3':{'one':9,'two':10}}
frame=DataFrame(data2)
print frame
#      num1  num2  num3
# one     1     5     9
# two     2     6    10

DataFrame取值赋值 —— 变为Series

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
#        num1  num2  num3
# one       1     5     9
# two       2     6    10
# three     3     7    11
# four      4     8    12
###############通过列名选取列数据,更改列数据（也可添加）
print frame['num1']
# one      1
# two      2
# three    3
# four     4
frame['num1']=np.arange(4)
#        num1  num2  num3
# one       0     5     9
# two       1     6    10
# three     2     7    11
# four      3     8    12
#################通过index选择行，通过index位置选择行
print frame.loc['one']
print frame.iloc[0]
# num1    1
# num2    5
# num3    9
###################删除 del drop
###################axis=1按列 axis=0按行 默认0
del frame['num1']  #只能用于列
#        num2  num3
# one       5     9
# two       6    10
# three     7    11
# four      8    12
print frame.drop(['num1','num2'],axis=1)   #删列，返回一个删除了的新对象
#        num3
# one       9
# two      10
# three    11
# four     12
print frame.drop(['one','two'])         #删行，返回一个删除了的新对象
#        num1  num2  num3
# three     3     7    11
# four      4     8    12

选取

  1. 行切片 data[1:2] 选取行
  2. 布尔型序列 data[[True,False,True,False]] 选取行
  3. 布尔型DataFrame过滤 data[data<9] 返回原格式 不满足变为NaN
  4. frame.ix[行索引] （行索引为一个时，结果为Series，多个用序列表示,返回DataFrame）
  5. frame.ix[:,列索引] （行索引为一个时，结果为Series，多个用序列表示,返回DataFrame）
  6. frame.ix[[行索引],[列索引]]
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    #        num1  num2  num3
    # one       1     5     9
    # two       2     6    10
    # three     3     7    11
    # four      4     8    12
    print frame.ix['one']
    # num1    1
    # num2    5
    # num3    9
    # Name: one, dtype: int64
    print data.ix[['one','two'],['num1','num2']]
    #      num1  num2
    # one     1     5
    # two     2     6

重新索引

DataFrame 同理

1
2
3
4
5
6
7
8
9
10
se=Series([1,2,3],index=['one','two','three'])
print se
# one      1
# two      2
# three    3
se2=se.reindex(['one','b','c'],fill_value=0) #fill_value默认缺失值，默认为NaN
print se2
# one    1
# b      0
# c      0

排序

按照行列索引进行字典排序
axis=0 按照行索引 axis=1 按照列索引
ascending=True 按照升序 False 按照降序
frame.sort_index(axis=0,ascending=True)

文件加载、写入

将表格性数据读取为DataFrame对象
read_csv()
从文件、URL、文件型对象中加载带分隔符的数据，默认分隔符为逗号
read_table()
从文件、URL、文件型对象中加载带分隔符的数据，默认分隔符为制表符

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import pandas as pd
#####文件内容没有自带列索引，分配默认列名
df=pd.read_csv('文件路径',header=None)
#####文件内容没有自带列索引，自己定义列名
df=pd.read_csv('文件路径',names=['a','b','c','d'])
#####文件内容没有自带列索引，自己定义列名，指定一列内容作为行索引
df=pd.read_csv('文件路径',names=['a','b','c','d']，index_col='d')
##参数sep 指定拆分字符序列 或 正则表达式
##参数na_values=['NULL'] 指定缺失值 也可用字典指定每列不同值填充为缺失
##参数encoding=utf8 指定解码形式
#########文件写入到一个以逗号分隔的文件中
df.to_csv('文件路径')
##参数na_rep='NULL' 指定输出缺失值
##参数index=False 指定不写行索引
##参数header=None 指定不写列索引
##参数columns=[]  指定要写入的列索引名
##参数seq='|'     指定分隔符

正则表达式

导入模块

1
2
3
import re
s='123abc456eabc789'
print re.findall(r'abc',s,re.I)

命令

re.I : 忽略大小写
re.M : 多行匹配，影响^和$
re.S : 使.匹配包括换行在内的所有字符

特殊字符

‘.’ : 匹配除了换行符外的任意一个字符
‘^’ : 行首
‘$’ : 行末
‘\A’: 整个字符串开头
‘\Z’: 整个字符串结尾
‘\b’: 匹配单词的分割，一个单词的前后都有
‘\B’: [^\b]
‘|’ : 或，匹配子表达式中的一个，用（）圈定范围,没用（）则表示整个字符串
‘?’ : 表示?前一个元素是有可有无的，用（）圈定元素
‘+’ : 表示+前一个元素出现一次或多次 >=1 ，用（）圈定元素
‘‘ : 表示\前一个元素出现任意多次 >=0 ，用（）圈定元素
‘+?’: 表示懒惰模式，满足之后的需求，+所匹配的次数尽可能少
‘?’: 表示懒惰模式，满足之后的需求，\所匹配的次数尽可能少
‘??’: 表示懒惰模式，满足之后的需求，?尽可能匹配0次
‘{min,max}?’： 表示懒惰模式，满足之后的需求，{}匹配的次数尽可能少

字符组 []

字符组：匹配字符组内的若干字符之一
如：[ae] 匹配 a或e
字符组中的两种特殊字符：
‘-‘ : 当’-‘不在字符组开头时，表示范围
如：[0-9][a-z][A-z] 等于 [0-9a-zA-Z]
‘^’ : 当’^’在字符组开头是，表示排除，匹配除了之后字符以外的字符
如：[^1-6] 除了1~6以外的字符
预定字符集（可以不写在[]中）：
\d : 数字[0-9]
\D ：非数字[^\d]
\s : 空白字符[ \t\r\n\f\v]
\S : 非空白字符[^\s]
\w : 单词字符[A-Za-z0-9_] #有下划线
\W : 非单词字符[^\w]
\number : 表示跟编号为number的括号（）匹配内容相同的一个字符串 （不是表达式相同）

出现次数范围

限定{}前面的元素重现次数
{num} 固定次数
{min,max} 次数范围
如 [a-zA-Z]{1,5} 匹配1~5个大小写字母
? 等于 {0,1}

（）

每个括号都有一个编号，从左往右，从1开始
1.记忆被匹配到的文本
多个（）一一对应多个变量
2.用于|的多选项范围
（）内加 ?: 不记忆这部分被匹配到的内容
3.用于? * +的量词作用范围
（）内加 ?: 不记忆这部分被匹配到的内容
4.指定别名
(?P…) 指定一个别名
(?P=name) 引用别名为name的分组匹配到的字符串

对于以上所有用到的特殊字符，用转义字符’\’来表示本身
如 ([a-z]+) ==> (very)

requests

//requests 包的使用
1.使用requests.get(url=urlforflag)
后者需要手动进行url加密 需要修改变量的地方断开使用字符串链接来构造payload
2.使用response=requests.get(url=url,params=data)
data = {“id”: sql_forflag % (i, x)}
data内的内容会被自动url加密；可以用response.url查看发送的真实url
3.使用response=requests.post(url=url,data=data,cookies=cookies)\
data = {“id”: sql_forflag % (i, x)}
cookies = {dict(PHPSESSID=’c3vg3kihmut0ne06ubhja3hgv6’,hello=’123’)}