使用python做基本的数据处理

1.常用的基本数据结构

元组、列表、字典、集合、常用的序列函数

1.1基本操作

1.1.1 元组：逗号分开的序列值。

tup = tuple (4,5,6)

tup = (4,5,6) #推荐

tup = 4,5,6

(4,5,6)

虽然对象元组中存储的对象自身是可以改变的，但是元组一旦创建，各个位置上的对象是无法被修改的。

tup = (4,5,[2,4],6)

(4,5,[2,4],6)

tup[2][1] = 3 # 这样的操作是可以的

tup[2] = [2,3] # 直接修改是不可行的

1.1.2 列表：长度可变，内容可变的list

基本操作:

a_list = [1,2,3,None] # 初始化

a_list = list((4,5,6)) # 使用list关键字

a_list.append(7) #添加单个item

a_list.extend([8,9,10]) #添加一串list

a_list + b_list # 也可以用+，copy但是不建议使用，效率低

a_list.remove(10) #移除某一个字符

a_list.insert(1,2) #在具体位置插入item

a_list.pop(2) #弹出某一个位置的item

a_list.sort() #做排序

切片操作: a_list[start:stop:step]

起始位置start索引是包含的，结束位置stop索引并不包含。
切出来的元素数量是stop - start
start 和 stop 可以省略，默认是起始位置和结束位置
负索引就是从尾部开始数
当step为负数时，步长就是反方向移动，如a_list[::-1]

内建序列函数:

enumrate 增加当前元素的索引

for index,value in enumrate(a_list)

print(index)
zip 将列表或者元组的元素配对，成为新的列表

print(list(zip([1,2],[3,4])))

[(1,3),(2,4)]
reversed 逆序操作

同[::-1]
sorted 排序操作

sorted([7,2,1,3])

[1,2,3,7]

1.1.3 字典又叫哈希表，关联数组

初始化：a_dict = {'a':'some value','b':1}

基本操作:

a_dict['a'] # some value

a_dict.get('a') # some value

a_dict.get('c','default value') # 取不到值时，可以取默认值

del a_dict['a'] # 删除某个键值对

ret = a_dict.pop('a') # 弹出某个键值对

a_dict.update(b_dict) # 将两个dict合二为一

list(a_dict.keys()) # ['a','b']

list(a_dict.values()) # ['some value',1]

tup = (('a','some value'),('b',1))

b_dict = dict(tup)# {'a': 'some value', 'b': 1}

1.1.4 set 一种无序且元素唯一的容器

初始化：a_set = set([1,2,2,3,4,6]) # {1,2,3,4,6}

基本操作:

a_set = {1,2,3,4}

b_set = {4,5,6,7}

a.union(b) # 1,2,3,4,5,6,7 并集

a|b # 1,2,3,4,5,6,7 并集

a.intersection(b) # 4 交集

a & b # 4 交集

2.列表、集合、字典推导式

他允许你过滤一个容器的元素，用一种简明的表达式转换传递给过滤器的元素，从而生成一个新的列表。

表达式：[expr for val in collection if condition]

strings = ['a','b','as','bat','car','dove','python']

b_list = [x.upper() for x in strings if len(x) > 2]

['BAT', 'CAR', 'DOVE', 'PYTHON']

eg1：strings = ['a','b','as','bat','car','dove','python']，生成一个字典，key为strings的元素，value是元素的长度。

c_dict = {x:len(x) for x in strings }

eg2：strings = ['a','bat','as','bat','car','dove','python']，生成一个集合，value是元素的长度。

d_set = {len(x) for x in strings }

eg3：strings = ['a','bat','as','bat','car','dove','python']，生成一个字典，key为strings的元素，value是元素的字符列表。

e_dict = {x:[y for y in x] for x in strings }

3.pandas常用方法

pandas两种常用的数据结构：

Series：包含键值对的一维数据结构。它类似于 python 字典。
Dataframe：是一种二维数据结构，它基本上是两个或多个Series的组合。可以理解成value是[] 它们也可以被认为是数据的电子表格，是我们最常用的数据结构。

data1 = {'state': ['Ohio'], 'year': ['1988'], 'pop': ['1.7']}

data1_sr = pd.Series(data1)

  state    [Ohio]

  year     [1988]

  pop       [1.7]

  dtype: object

data2 = {'state': ['Ohio', 'Ohio', 'Nevada'], 'year':['1988', '1964', '1955'], 'pop': ['1.7', '2.5', '3.3']}

data_df = pd.DataFrame(data)

      state  year  pop

  0    Ohio  1988  1.7

  1    Ohio  1964  2.5

  2  Nevada  1955  3.3

3.1 DataFrame 取值的方法

df3 = pd.DataFrame(data, columns=['year', 'state', 'pop'], index=['a', 'b', 'c'])

print(df3.year)

print(df3['year']['a']) # 只支持[列][行]

print(df3.loc['a']['year']) # 支持[行][列]

print(df3.columns) # 索引类型都是不可变数组

  Index(['year', 'state', 'pop'], dtype='object')

print(df3.index) # 索引类型都是不可变数组

  RangeIndex(start=0, stop=3, step=1)

3.2 关于index 的一些方法

obj = pd.Series([4.5, 2.3, 4.6, 2.3], index=['b', 'a', 'd', 'c'])

obj = obj.drop('a') # 删除a行

obj = obj.reindex(['b', 'a', 'd', 'c', 'e'])

  b    4.5

  a    NaN

  d    4.6

  c    2.3

  e    NaN

data = {'state': ['Ohio', 'Ohio', 'Nevada'], 'year': ['1988', '1964', '1955'], 'pop': ['1.7', '2.5', '3.3']}

df = pd.DataFrame(data)

      state  year  pop

  0    Ohio  1988  1.7

  1    Ohio  1964  2.5

  2  Nevada  1955  3.3

df = df.drop(columns='year', axis=1) # drop 删除索引

      state  pop

  0    Ohio  1.7

  1    Ohio  2.5

  2  Nevada  3.3

3.2 常用的方法

3.2.1 deepcopy & copy

data = {'state': ['Ohio', 'Ohio', 'Nevada'], 'year': ['1988', '1964', '1955'], 'pop': ['1.7', '2.5', '3.3']}

df = pd.DataFrame(data)

df2 = df.copy(False)

df3 = df.copy(True)

df2['state'][0] = 'Nevada'

print(df)

   state  year  pop

  0    Ohio  1988  1.7

  1    Ohio  1964  2.5

  2  Nevada  1955  3.3

print(df2) # 浅copy会变化

     state  year  pop

  0  Nevada  1988  1.7

  1    Ohio  1964  2.5

  2  Nevada  1955  3.3

print(df3) # 深copy则不会变化

      state  year  pop

  0    Ohio  1988  1.7

  1    Ohio  1964  2.5

  2  Nevada  1955  3.3

3.2.2 用set_index修剪索引 + to_dict 转成可用的dict

df = pd.DataFrame({"month": [2, 6, 12, 10], "year": [2008, 2012, 2012, 2019], "day": [29, 30, 31, 31]})

df2 = df.set_index("year") # 原来的索引被删除了，year变成索引

print(df2)

        month  day

  year

  2008      2   29

  2012      6   30

  2012     12   31

  2019     10   31

df2 = df.set_index("year", drop=False) # 原来的索引被删除了，year也可以不用删除

print(df2)

        month  year  day

  year

  2008      2  2008   29

  2012      6  2012   30

  2012     12  2012   31

  2019     10  2019   31

info_dict = df2.to_dict('index')# 会报错，有两个2012，ValueError: DataFrame index must be unique for orient='index'.

df2 = df.set_index(['year', 'month'], drop=False) # 用两个值做索引

print(df2)

              month  year  day

  year month

  2008 2          2  2008   29

  2012 6          6  2012   30

       12        12  2012   31

  2019 10        10  2019   31

info_dict = df2.to_dict('index')

print(info_dict)

  {(2008, 2): {'month': 2, 'year': 2008, 'day': 29}, (2012, 6): {'month': 6, 'year': 2012, 'day': 30}, (2012, 12): {'month': 12, 'year': 2012, 'day': 31}, (2019, 10): {'month': 10, 'year': 2019, 'day': 31}}

print(info_dict.get((2012, 6)))

  {'month': 6, 'year': 2012, 'day': 30}

3.2.3 使用apply 函数操作数据

df = pd.DataFrame([[4, 9]] * 3, columns=['A', 'B'])

print(df)

df2 = df.apply(lambda x: pd.Series([x[1], x[0]], index=['foo', 'bar']), axis=1)

print(df2)

     foo  bar

  0    9    4

  1    9    4

  2    9    4

3.2.4 isna 和 isin 通过分离 NaN 或定义数据所在的范围来过滤数据。

df3 = df2.isin([9, 4])

print(df3)

      foo   bar

  0  True  True

  1  True  True

  2  True  True

df = pd.DataFrame({'num_legs': [2, 4], 'num_wings': [2, 0]}, index=['falcon', 'dog'])

print(df)

        num_legs  num_wings

  falcon         2          2

  dog            4          0

df2 = df.apply(lambda x: pd.Series([x[1], pd.NA], index=['foo', 'bar']), axis=1)

print(df2)

          foo   bar

  falcon    2  <NA>

  dog       0  <NA>

print(df2.isna().sum())

  foo    0

  bar    2

  dtype: int64

3.2.5 merge方法

df1 = pd.DataFrame({'lkey': ['foo', 'bar', 'baz', 'foo'], 'value': [1, 2, 3, 5]})

df2 = pd.DataFrame({'rkey': ['foo', 'bar', 'baz', 'foo'], 'value': [5, 6, 7, 8]})

print(df1.merge(df2, left_on='lkey', right_on='rkey'))

    lkey  value_x rkey  value_y

  0  foo        1  foo        5

  1  foo        1  foo        8

  2  foo        5  foo        5

  3  foo        5  foo        8

  4  bar        2  bar        6

  5  baz        3  baz        7