《利用python进行数据分析》一书的第五章源码与读书笔记

直接上代码

  1. # -*- coding:utf-8 -*-
    # 《python for data analysis》第五章, pandas基础
    # 高级数据结构与操作工具
  2.  
  3. import pandas as pd
    import numpy as np
    import time
  4.  
  5. start = time.time()
    # pandas的数据结构, series and dataframe
    # 1、series,类似一维数据, 一个字典,建立了从索引值(index)到数据值(values)的映射
    # 组成:一组数据(numpy的各种数据类型,称为values)+数据标签(索引,称为index)+名称(称为name,values和index均有name属性,该属性可空缺)
    # index缺省值为0~N-1的整数型索引,N为数据个数
    # 创建一个series
    np.random.seed(10)
    series1 = pd.Series(np.arange(1, 6) + np.random.random(5))
    print(series1) # 打印series
    print('')
    print(series1.values) # 打印series的values属性
    print(series1.index) # 打印series的index属性
    # 修改该series的index属性,也可在一开始创建series的时候就指定index,
    # 即series1 = pd.Series(np.random.random(5), index=['a','aa','b','bb','z'])
    # 也可通过字典创建series实现相同效果
    # dict = {'a':1, 'aa':2, 'b':3, 'bb':4, 'z':5}
    # series1 = pd.Series(dict)
    series1.index = ['a', 'aa', 'b', 'bb', 'z'] # 三种方式效果一致
    print('')
    print(series1)
    print('')
    print(series1['aa']) # 可通过index索引的方式选择series中的值
    print(series1[['a', 'aa']]) # 可一次性选取一组值,注意双括号
    print('')
    dict = {'a': 1, 'aa': 2, 'b': 3, 'bb': 4, 'z': 5}
    series2 = pd.Series(dict, index=['a', 'aa', 'aaa'])
    print(series2) # 'a'与'aa'在dict中均有对应值,直接写入到series中,'aaa'无对应值,故用NaN表示(NaN——缺失值或NA值)
    # 对于多个series的运算,series在运算过程中会自动对齐,即同一个index的数据进行运算,不是所有series都有的index的结果用NaN表示
    print('')
    print(series1 + series2)
    # series对象的values属性和index属性均有一个name属性,上面的series1和series2的name均缺省,可对该属性进行赋值
    series1.name = 'distance' # values的name属性
    series1.index.name = 'city' # index的name属性
    print('')
    print(series1)
    # 2、dataframe,表格型数据结构,是一组有序的列
    # dataframe的每个列可视为一个series,所有列共用一个行索引(index),每个series的name就是列索引(columns)
    # index和columns可通过转置进行交换
    # 创建一个dataframe
    data = {
    'state': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada'],
    'year': [2000, 2001, 2002, 2001, 2002],
    'pop': [1.5, 1.7, 3.6, 2.4, 2.9],
    }
    dataframe = pd.DataFrame(data, columns=['year', 'state', 'pop', 'debt'], index=['one', 'two', 'three', 'four', 'five'])
    # 对于找不到的列(如'debt'),dataframe中以NaN表示该列元素,行不可以多
    print('')
    print(dataframe)
    # 赋值(广义的广播)
    dataframe['debt'] = 10.2
    # 通过标记方式(dataframe[])或属性方式(dataframe.)可将dataframe的某个列转换为一个series, 返回的series和dataframe有相同的行索引(index)
    print('')
    series3 = dataframe.year # 等价于 series3 = dataframe['year']
    print(series3)
    # dataframe通过索引返回的series是原dataframe的引用,而非复制,使用.copy()方法返回的就是原数据的复制
    # series3[0]=20
    # print(dataframe)
    del dataframe['debt'] # 删除dataframe的某一列,只能按照列索引删除某列
    print(dataframe)
    dataframe = dataframe.T # dataframe可以进行转置,即行索引与列索引进行互换,dataframe.T不改变原dataframe,需要赋值操作
    print(dataframe)
    # 上述的dataframe是从字典(非嵌套),配以指定行索引,得到的
    # 通过对嵌套字典进行dataframe()操作可以得到带有列索引与行索引的dataframe(无需指定行索引index)
    # 2.1、二重嵌套字典,默认以外层字典的键为列索引columns,内层字典的键为行索引index
    dict = {
    'cityA': {2001: 2.1, 2002: 2.5},
    'cityB': {2000: 1.5, 2001: 2.9, 2002: 3.0}
    }
    dataframe2 = pd.DataFrame(dict)
    print(dataframe2)
    # 2.2、三重及以上的嵌套字典,第一层字典的键为列索引columns,第二层字典的键为index,更内层的字典保留字典形式作为dataframe的value
    dict = {
    'cityA': {2001: {'pop': 1.2, 'debt': 2.1}, 2002: {'pop': 1.5, 'debt': 2.5}},
    'cityB': {2001: {'pop': 1.8, 'debt': 2.9}, 2002: {'pop': 1.9, 'debt': 3.0}}
    }
    dataframe3 = pd.DataFrame(dict)
    print(dataframe3)
    print('')
    # 3、索引对象
    print(series1) # 选一个之前用过的Series
    print(series1.index) # 打印该Series的索引对象,包括轴标签(a\aa\b\bb\z)、轴名称、dtype等
    print('')
    print(dataframe)
    print(dataframe.index)
    print(dataframe.columns)
    print('')
    print(series1.index)
    print(series2.index)
    print(series1.index.append(series2.index))
    # index有很多方法,如.append可以把两个index接到一起。append还可以拼接Series、dataframe等
    print('↑----------class1----------')
  6.  
  7. # pandas的基本功能
    # 1、重新索引, reindex
    # 1.1、series的reindex
    series1 = pd.Series(range(5), index=['d', 'a', 'c', 'b', 'e'])
    print(series1)
    series11 = series1.reindex(['a', 'b', 'c', 'd', 'e', 'blank'])
    print(series11) # 行索引按照a、b、c、d、e、blank的顺序重新排列,其中blank在原series中无value,故以NaN计入,
    series11 = series1.reindex(['a', 'b', 'c', 'd', 'e', 'blank'], fill_value=0) # 用0填充NaN值
    print(series11)
    # 对于单调(monotonic)变化的index(对原index而言),还可使用插值方法来对NaN值进行填充
    series1 = pd.Series(np.random.randn(3), index=[1, 3, 5])
    series11 = series1.reindex(range(1, 7), method='bfill') # 取后一个值填充NaN
    series111 = series1.reindex(range(1, 7), method='ffill') # 取前一个值填充NaN
    print(series11)
    print(series111)
    # 1.2、dataframe的reindex
    # 创建一个dataframe
    dataframe1 = pd.DataFrame(np.arange(1, 10).reshape(3, 3), index=['one', 'three', 'two'], columns=['b', 'a', 'c'])
    print(dataframe1)
    # 只传入一个index则默认是行index的修改,对于原dataframe中没有的值以NaN写入
    dataframe11 = dataframe1.reindex(['one', 'two', 'three', 'four'])
    # 上一行等价于dataframe11 = dataframe1.reindex(index = ['one','two','three','four'])
    print(dataframe11)
    # 修改列columns需要显式指定
    dataframe11 = dataframe1.reindex(columns=['a', 'b', 'c'])
    print(dataframe11)
    # 也可同时修改行index和列columns
    dataframe11 = dataframe1.reindex(index=['one', 'two', 'three'], columns=['a', 'b', 'c'])
    print(dataframe11)
    print('\n')
    # dataframe的reindex也可以指定缺失值的填充值、插值方式等
    # 2、丢弃指定轴(或该轴上的一些项)
    # 2.1、series的drop,直接向drop()函数中送入要删的元素的index
    series1 = pd.Series(range(3), index=['a', 'b', 'c'])
    print(series1)
    series2 = series1.drop('c')
    print(series2)
    # 2.2、dataframe的drop,送入的索引值需要指定轴号,0表示行索引,index;1表示列索引,columns;缺省值为0
    dataframe1 = dataframe1.reindex(index=['one', 'two', 'three'], columns=['a', 'b', 'c'])
    print(dataframe1)
    dataframe2 = dataframe1.drop('three') # 等价于dataframe1.drop('three', axis = 0)
    print(dataframe2)
    dataframe2 = dataframe1.drop('c', axis=1) # 删除columns中某项需要显示指定第二条轴
    print(dataframe2)
    print('\n')
    # 3、series/dataframe中values的索引、选取与过滤
    # 3.1、series的索引、选取与过滤
    print(series1)
    print(series1[1]) # 类似numpy的array的索引,0表示第一个元素,类推得
    print(series1[['a', 'b']]) # 用索引的标签值进行索引
    print(series1['a':'b']) # 用索引的标签值进行切片是闭区间,而类似numpy的array索引方式是左闭右开区间
    print(series1[0:1])
    print(series1[series1 < 1]) # 布尔型索引
    # 3.2、dataframe的索引、选取与过滤
    # 3.2.1 输入dataframe的列名进行选列
    print(dataframe1)
    print(dataframe1['a']) # 该方式(输入列名columns)只能选列,等价于print(dataframe1.a)
    # 3.2.2 dataframe切片选行
    print(dataframe1[1:2]) # 选出第2行,即左闭右开,注意!!该方式只能切片索引,不能直接输入行号或者行的位置进行索引
    # 3.2.3 dataframe布尔型数组选行!行
    print(dataframe1[dataframe1['a'] > 2]) # 选出‘a'这一列中元素大于2的行
    # 3.2.4 布尔型dataframe选元素
    print(dataframe1[dataframe1 > 3]) # 打印dataframe1中大于3的元素,打印时整张表格会输出,小于等于3的元素以NaN表示
    # dataframe直接索引的方式就这几种,可以看到无法通过行标签(one、two、three)进行索引
    # 为解决该问题,引入.ix字段,可以直接根据行标签进行选行,注意!直接输入列标签选列是不行的,毕竟已经有3.2.1了
    print(dataframe1.ix['one'])
    # .ix[]同时输入行标签、列标签进行子表的选取
    print(dataframe1.ix[['one', 'two'], ['a', 'b']]) # 注意顺序!!!先给出行标签再给出列标签
    print(dataframe1.ix[2]) # 还可以给出行的位置序号选行
    print('\n')
    # 特别对于整数索引的情况,上面这句话就会有歧义,目前规则是.ix面向标签,.irow和.icol面向位置,本章最后进行介绍
    # 4、算术运算与数据对齐
    # 两个不同索引的对象(Series or Dataframe)进行算术运算(直接的+-*/号),结果的索引为两者的并集,但仅交集有数据,其余为NaN
    dataframe1 = pd.DataFrame(np.arange(1, 10).reshape(3, 3), index=['one', 'two', 'three'], columns=['a', 'b', 'c'])
    dataframe2 = pd.DataFrame(np.arange(-10, -1).reshape(3, 3), index=['one', 'next', 'near'], columns=['a', 'd', 'e'])
    print(dataframe1)
    print(dataframe2)
    print(dataframe1 + dataframe2)
    # 用add、sub、div、mul来替代+、-、*、/,这样可以指定一个填充值来替代缺失值
    print(dataframe1.add(dataframe2, fill_value=0)) # 某对标签若在两个对象中均无数值则仍未NaN
    # Dataframe与Series之间的运算采用广播机制
    # 行上广播直接采用+-*/即可
    series1 = dataframe1.ix['one']
    print(dataframe1)
    print(series1)
    print(dataframe1 - series1)
    # 若在列上广播则需要用add、sub、mul、div,并指定轴为0!注意,是显示指定,不能缺省。
    series1 = dataframe1['a']
    print(dataframe1)
    print(series1)
    print(dataframe1 - series1) # 全为NaN,原因同上,无交集
    print(dataframe1.sub(series1, axis=0))
    print('\n')
    # 5、函数应用与映射
    # numpy有一些元素级数组方法,比如abs,可直接用于pandas对象
    print(dataframe2)
    print(dataframe2.abs())
    # 也可以自定义一些函数,通过.apply方法应用于pandas对象的行或者列(通过axis=0 or 1进行指定)
    function = lambda x: x.min() - x.max()
    print(dataframe1)
    print(dataframe1.apply(function, axis=0))
    print(dataframe1.apply(function, axis=1))
    # 也可以自定义一些元素级函数,通过.applymap()方法应用于dataframe对象,通过.map()方法应用于series对象
    function = lambda x: x / 2
    print(dataframe1.applymap(function))
    # 6、排序与排名
    # 6.1、list和array的排序,对前一章的回顾
    np.random.seed(10)
    list = list(np.random.random(5)) # array方法相同
    print(list)
    list.sort() # 也可以用list = np.sort(list)
    print(list)
    print('\n')
    # 6.2 pandas对象的排序,通过.sort_index()方法进行实现,按索引进行排序
    # 默认均为升序,降序需要显式指定ascending=False
    series = pd.Series(np.random.random(5), index=['d', 'b', 'c', 'e', 'a'])
    print(series)
    print(series.sort_index()) # series不需要指定轴号
    dataframe = pd.DataFrame(np.arange(9).reshape(3, 3), columns=['b', 'c', 'a'], index=[3, 1, 2])
    print(dataframe)
    print(dataframe.sort_index()) # 缺省axis=0
    print(dataframe.sort_index(axis=1, ascending=False))
    print('\n')
    # 若要按照value进行排序,则series用np.sort进行,索引会被抹去,dataframe还是用sort_index,并加入参数by指定排序的列
    print(series)
    print(np.sort(series))
    print(dataframe)
    print(dataframe.sort_index(by='a', ascending=0)) # 该方法只能进行列上的排序
    # by传入一个list时进行多列上的排序,list中越靠前的列排序优先级越高
    print('\n')
    # 6.3、排名,即在排序的基础上增设一个从0到数据量的排名值
    # 该排名值可按照一定关系改变平级关系
    series = pd.Series([2, 1, 2, -1, -2])
    print(series.rank()) # 默认给出平均排名,如2,3并列则都给出2.5
    print(series.rank(method='first')) # 先出现者排名高
    print(series.rank(method='min')) # 统一给出小排名,如2,3并列都给2
    print(series.rank(method='max')) # 统一给出大排名,如2,3并列都给3
    print('\n\n')
  8.  
  9. # 7、重复值的轴索引
    # pandas对象允许轴索引重复,不过实际使用中最好还是避免重复,很多pandas函数是要求index不重复的
    # Series为例,dataframe就是行索引
    series = pd.Series(range(5), index=['a', 'a', 'b', 'b', 'c'])
    print(series)
    print(series.index.is_unique) # pandas对象的index对象有一个is_unique属性,用于判断索引唯一与否
    print(series['a']) # 会打印出所有该轴标签的value
    print('↑----------class2----------\n\n')
  10.  
  11. # 汇总与计算描述统计
    # pandas有很多数学统计方法,如.sum()、.cumsum()、.mean()等,默认对每一列进行运算
    # 相较numpy中的同功能函数,numpy不允许存在数据缺失而pandas允许,并可以对缺失值进行一些基本的处理
    dataframe = pd.DataFrame([[1, 2, np.nan], [4, 5, 6], [7, 8, 9]], columns=['a', 'b', 'c'], index=['one', 'two', 'three'])
    print(dataframe)
    print(dataframe.sum(axis=1, skipna=True)) # 每行求和,并跳过缺失值,axis缺省0,skipna缺省True
    print(dataframe.sum(axis=1, skipna=0)) # 不调过NaN,则所有涉及到NaN的运算结果均为NaN,同numpy的原则
    ar1 = np.array([1, np.nan, np.nan, np.nan, 5])
    print(ar1)
    print(ar1.sum())
    # dataframe的describe方法可返回一个表的汇总统计结果
    print(dataframe1)
    print(dataframe1.describe())
    print('')
  12.  
  13. # 相关系数与协方差的计算
    # 补充数据拼接
    series1 = pd.Series(range(5), index=['day1', 'day2', 'day3', 'day4', 'day5'], name='companyA')
    series2 = pd.Series(sorted(range(5), reverse=True), index=['day1', 'day2', 'day3', 'day4', 'day5'], name='companyB')
    print(series1)
    print(series2)
    dataframe = pd.concat([series1, series2], axis=1)
    print(dataframe)
    # 用.cov()方法计算协方差,用.corr()方法计算相关系数。要求:重叠、非NA、按索引对齐
    # series之间的计算cov和corr
    print(dataframe.companyA.cov(dataframe.companyB))
    print(dataframe.companyA.corr(dataframe.companyB))
    print('')
    # 单个dataframe中计算cov和corr
    print(dataframe.cov())
    print(dataframe.corr())
    print('')
    # dataframe与series之间,dataframe与dataframe之间,用.corrwith()方法计算相关系数
    print(dataframe.corrwith(dataframe.companyA)) # 传入的series与dataframe的各列计算相关系数
    print(dataframe.corrwith(dataframe)) # 两个dataframe的列按列名进行相关系数的计算
    print('')
    # 唯一值、值计数及成员资格
    # 从series中抽取信息
    # 1、.unique()方法,得到唯一值数组,功能类似set()
    series = pd.Series([9, 10, 1, 1, 1, 2, 3, 2, 3, 4, 5, 6, 7, 8])
    print(series.unique()) # 结果是未排序的
    # 2、.value_counts()方法,计算series中各值出现的次数
    print(series.value_counts())
    # 补充,list相应有.count()方法计算元素出现次数
    list1 = [1, 2, 2, 3, 3, 3]
    print(list1.count(1))
    print(list1.count(2))
    # 3、.isin()方法可用于判断series中各值是否位于另一个矢量化集合中
    print(series.isin([1, 2, 3]))
    print('↑----------class3----------\n\n')
  14.  
  15. # 处理缺失数据
    # pandas中,python内置的None和numpy的np.nan都识别为NaN
    # 1、滤除缺失数据
    # 1.1、对于series,直接通过.dropna()方法丢弃缺失值及其索引
    series = pd.Series([1, 2, None, None, 3, 4, 5])
    print(series)
    print(series.dropna())
    # 1.2、对于dataframe,dropna()缺失为丢弃所有含有NaN的行
    dataframe = pd.DataFrame(np.arange(1, 10).reshape(3, 3), columns=['a', 'b', 'c'], index=['one', 'two', 'three'])
    dataframe.ix[1:, 1] = None
    dataframe.ix[1, :] = None
    print(dataframe)
    print(dataframe.dropna()) # 有NaN就丢
    print(dataframe.dropna(how="all")) # 全为NaN就丢
    print(dataframe.dropna(axis=1)) # 指定列上操作
    print(dataframe.dropna(thresh=2)) # 给定丢弃阈值,每行有2个及以上的非NaN值时保留该行
    # 2、填充缺失数据
    print(dataframe)
    print(dataframe.fillna(0)) # 直接用常数填充,可传入一个函数值,如dataframe.fillna(dataframe.mean()),每列平均值
    print(dataframe.fillna({'a': -1, 'b': -2})) # 传入字典,按照列名进行填充,没有的则保持为NaN
    print(dataframe.fillna(method='ffill')) # 插值方法仍然有效,ffill和bfill
    print('↑----------calss4-----------')
  16.  
  17. # 层次化索引,用低维数据形式表示高维数据
    # 1、层次化索引的series,相当于一张dataframe
    series = pd.Series(np.arange(9), index=[['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'c'], [1, 2, 3, 1, 2, 3, 1, 2, 3]])
    print(series) # 该series的索引是层次化的(两层)
    print(series['a']) # 外层索引选取的数据还是series
    print(series['a', 2]) # 双层索引
    # 通过.stack()和.unstack()可以实现层次化索引的series和dataframe之间的转换
    dataframe = series.unstack()
    print(dataframe)
    print(dataframe.stack()) # 又变回层次化索引的series
    # 2、层次化索引的dataframe,表示更高维数据,其行索引与列索引均可以层次化
    dataframe = pd.DataFrame(np.arange(12).reshape(-1, 3),
    columns=[['countrya', 'countrya', 'countryb'], ['citya', 'cityb', 'cityc']],
    index=[['a', 'a', 'b', 'b'], [1, 2, 1, 2]])
    print(dataframe)
    print(dataframe['countrya']['citya'].ix['a'][1]) # 先选列再选行
    print(dataframe.stack().stack()) # 一次.stack()把一层列索引打包到行索引上
    # 3、通过.swaplevel()可以交换层次化轴索引的顺序,传入轴索引name
    dataframe.columns.names = ['country', 'city']
    dataframe.index.names = ['one', 'two']
    print(dataframe)
    print(dataframe.swaplevel('city', 'country', axis=1))
    print('')
    # 4、通过.sortlevel()可以对某一个级别索引进行排序
    print(dataframe)
    print(dataframe.swaplevel().sortlevel(level=0, axis=1, ascending=False)) # 对列索引的第一级索引进行排序
    print('\n')
    # 5、对于层次化索引的pandas对象,之前提到的统计函数如sum、mean等均可指定level进行计算
    print(dataframe)
    print(dataframe.mean(axis=1, level=0)) # 对每一行在第一层索引上进行取平均
    # 6、用dataframe的列来当作行索引
    # 之前用.stack()和.unstack()方法进行了行索引与列索引之间的转换
    # 还可以用.set_index()和.reset_index()进行列的value与行索引标签之间的转换,相应地,列索引标签与行索引name进行转换
    dataframe = pd.DataFrame(np.arange(25).reshape(5, 5), columns=['a', 'b', 'c', 'd', 'e'])
    print(dataframe)
    print(dataframe.set_index(['a', 'b']))
    print(dataframe.set_index(['a', 'b']).reset_index(['a', 'b']))
    print('↑----------class5---------\n\n')
  18.  
  19. # pandas的其他话题 —— 整数索引 与 panel(面板)数据
    # 1、整数索引,有时候会有意外情况出现
    dataframe = pd.DataFrame(np.arange(9).reshape(3, 3), index=[-1, 0, 1], columns=['a', 'b', 'c'])
    print(dataframe)
    print(dataframe.ix[-1]) # 或许会有疑问,这里的-1是指索引为-1呢还是位置为-1呢?
    # 在pandas中,直接索引([])和.ix()方法索引,给出的值都是按照标签去进行索引
    # 用.irow()和.icol()方法则是按照位置去进行索引(dataframe),发现高版本pandas中已经没有.irow().icol()方法了
    # 这一个曾经有过教训
    # 事情是这样的,有一个很多行(比如1000行)的csv,我用read_csv(‘’,chunksize=100)分块读取
    # 想用抽样的方法对其减小体积,取100个中的前5个保存到新的csv文件中
    # 写为
    # slices = pd.read_csv('filename.csv',chunksize=100),此时索引为缺省的整数索引
    # for slice in slices:
    # slice.ix[:5,:].to_csv('newfilename.csv',method='a') , 追加写入方式
    # 本来应该要看到50行,但是打开csv只看到了5行数据
    # 这是因为.ix[]进行索引是按照标签进行的,:5是选择了索引为0、1、2、3、4这5行,之后的切片中都没有索引为0~4的了,所以
    # 追加写入的都是空集
    # 应该修改为
    # for slice in slices:
    # slice[:5].to_csv('newfilename.csv',method='a')
    # 切片选行是基于位置进行索引的
  20.  
  21. # 2、panel,面板数据类型,三维版的dataframe
    # 一个panel由很多张dataframe组成,panel和层次化索引的dataframe之间可以通过.to_dataframe()和.to_panel()方法进行转换
    # 前提——dataframe的层次化索引是行索引
    dataframe = pd.DataFrame(np.arange(12).reshape(-1, 3),
    columns=['countrya', 'countryb', 'countryc'],
    index=[['a', 'a', 'b', 'b'], [1, 2, 1, 2]])
    panel = dataframe.to_panel()
    print(dataframe)
    print(panel)
    print(panel.ix['countrya', 'a', :]) # 索引轴依次是item、major、minor。可切片。
  22.  
  23. print('\n')
    print("-------------that's all------------------")
    print('Total time is %.5f s' % (time.time() - start))

《python for data analysis》第五章,pandas的基本使用的更多相关文章

  1. 《python for data analysis》第九章,数据聚合与分组运算

    # -*- coding:utf-8 -*-# <python for data analysis>第九章# 数据聚合与分组运算import pandas as pdimport nump ...

  2. 《python for data analysis》第二章,美国1880-2010年出生人口姓名的数据分析

    <利用python进行数据分析>第二章的姓名例子,代码.整个例子的所有代码集成到了一个文件中,导致有些对象名如year同时作为了列名与行名,会打印warning,可分不同的part依次运行 ...

  3. 《python for data analysis》第七章,数据规整化

    <利用Python进行数据分析>第七章的代码. # -*- coding:utf-8 -*-# <python for data analysis>第七章, 数据规整化 imp ...

  4. < 利用Python进行数据分析 - 第2版 > 第五章 pandas入门 读书笔记

    <利用Python进行数据分析·第2版>第五章 pandas入门--基础对象.操作.规则 python引用.浅拷贝.深拷贝 / 视图.副本 视图=引用 副本=浅拷贝/深拷贝 浅拷贝/深拷贝 ...

  5. 《python for data analysis》第四章,numpy的基本使用

    <利用python进行数据分析>第四章的程序,介绍了numpy的基本使用方法.(第三章为Ipython的基本使用) 科学计算.常用函数.数组处理.线性代数运算.随机模块…… # -*- c ...

  6. 数据分析---《Python for Data Analysis》学习笔记【04】

    <Python for Data Analysis>一书由Wes Mckinney所著,中文译名是<利用Python进行数据分析>.这里记录一下学习过程,其中有些方法和书中不同 ...

  7. 数据分析---《Python for Data Analysis》学习笔记【03】

    <Python for Data Analysis>一书由Wes Mckinney所著,中文译名是<利用Python进行数据分析>.这里记录一下学习过程,其中有些方法和书中不同 ...

  8. 数据分析---《Python for Data Analysis》学习笔记【02】

    <Python for Data Analysis>一书由Wes Mckinney所著,中文译名是<利用Python进行数据分析>.这里记录一下学习过程,其中有些方法和书中不同 ...

  9. 数据分析---《Python for Data Analysis》学习笔记【01】

    <Python for Data Analysis>一书由Wes Mckinney所著,中文译名是<利用Python进行数据分析>.这里记录一下学习过程,其中有些方法和书中不同 ...

随机推荐

  1. 表单传参,在action中的参数得不到

    写上面这个的时候,发现传过去的url路径是这样的 在action后面的pro=login得不到. 只需要将method中的get改成post就可以了

  2. java基础 易忘易混点复习1

    原码 反码 补码 原码 正数的原码最高位是0 负数的原码最高位是1 例如:+7 0 0000111 -7 1 0000111 反码 正数的反码与原码相同 负数的反码相比原码 符号位不变,数值位取反 例 ...

  3. 关于redis实现分布式锁

    前言 分布式锁一般有三种实现方式:1. 数据库乐观锁:2. 基于Redis的分布式锁:3. 基于ZooKeeper的分布式锁.本篇博客将介绍第二种方式,基于Redis实现分布式锁.虽然网上已经有各种介 ...

  4. Mysql基础教程之mysql 设置参数常用方法

    1)设置mysql的全局方法,设置完立刻重启mysqlvim /etc/my.cnf[mysqld]interactive_timeout=1800wait_timeout=1800 全局永久生效现在 ...

  5. Jmeter安装web socket协议插件

    jmeter本身不支持websocket协议,需要安装第三方插件才能支持 1. 首先需要第三方插件: JMeterWebSocketSampler-1.0.2-SNAPSHOT.jar 2. 该插件依 ...

  6. python判断两个变量是否为同一数据类型

    >>> a = 1000>>> b = 1>>> isinstance(a,type(b))True>>>

  7. Linux中挂载详解以及mount命令用法

    转自:https://blog.csdn.net/daydayup654/article/details/78788310 挂载概念 Linux中的根目录以外的文件要想被访问,需要将其“关联”到根目录 ...

  8. 1077 Eight

    Eight Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 37738   Accepted: 15932   Special ...

  9. ubuntu16.04微信安装

    1.下载: git clone https://github.com/geeeeeeeeek/electronic-wechat/releases 2.移动微信客户端(下载解压重命名为wechat)到 ...

  10. Netty 服务端:新连接接入

    本文主要分析服务端新连接的接入过程,主要分为以下 3 各步骤: select 操作: processSelectedKeys 操作. 1. select 操作 在分析 select 操作前,先要回顾一 ...