深入浅出pandas——第二部分：数据结构

#  第二章 数据结构
# 2.1数据结构的概述
# 2.1.1 什么是数据

# 什么是数据？
# 数据是我们对客观世界的记录，而记录的形式就是我们发明的记录符号和记录载体。
# 数据类型有同构数据和异构数据
# 对于异构数据，我们需要将其进行转换使其一致
'''
什么是数据结构？
数据结构是组织数据、存储数据的方式。
常见的数据结构有栈、队列、数组、链表、树、图等。我们最常见的数据结构是数组

2.2 python的数据结构
# 不可变的数据 ：数字、字符串、元组。
# 可变的数据：列表、字典、集合。
可以使用内置的type()函数查看数据类型
也可以使用isinstance来判断数据是不是指定的类型

'''
type(123)  # 可以使用内置的type()函数查看数据类型
print(type(123))
isinstance(123,int) # 也可以使用isinstance来判断数据是不是指定的类型
print(isinstance(123,int))
print(isinstance(123,str))
print(isinstance(123,bool))

# 数字
'''
python中的数字类型可以存储数学中的各种数字，包括自然数、复数中的虚数、无穷大数、正负数、带小数点的数、不同进制的数
'''
a1 = 111
a2 = 1.213123
a3 = 1j
print(type(a1))
print(type(a2))
print(type(a3))

a4 = 10
a5 = 313
a4 + a5
a4 - a5
a4 * a5
a4 / a5
a4 ** a5 # 10的21次幂
a5 % a4 # 取余
print(a4 + a5)
print(a4 - a5)
print(a4 * a5)
print(a4 / a5)
print(a4 ** a5)
print(a5 % a4)
# 地板除，相除之后只保留整数部分，即向下取整
# 但是如果其中一个操作数为负数，则取负无穷大方向的距离结果最近的整数
9//2
9.0//2.0
-11//3
-11.0//3
print(9//2)
print(9.0//2.0)
print(-11//3)
print(-11.0//3)

# 2.2.1字符串
# 字符串可以是一条或多条文本信息 可以对字符串进行切片访问（同时适用于字符、列表、元组等）。字符串可以从左往右，索引从0开始；从右往左，索引从-1开始。可以取字符串中的片段，切片索引按左闭右开原则
var = 'Hellow World!'
var[-1]
var[-3:-1]
var[1:7] # 有个空格
var[6:] # 指定开头 这个相当于
var[:] # 相当于复制功能
var[0:5:2] # 2为步长按2的倍数选取
var[::-1]  #  实现了反转字符功能
print(var[-1], var[-3:-1], var[1:7], var[6:], var[:], var[0:5:2], var[::-1])
# 下面是常用的字符操作
len('good') # 查看字符串的长度
'good'.replace('g', 'G') # 替换字符
'山-水-风-光'.split('-')
'好山好水好风光'.split('好')
'-'.join(['山','水','风','光']) # 山-水-风-光
'good'.upper() # 全部转成大写
'GOOD'.lower() # 全部转换成小写
'Good Bye'.swapcase() # 大小写互换
'good'.capitalize() # 首字母转换成大写
'good'.islower() # 是否全是小写
'good'.isupper() # 是否全是大写
'3月'.zfill(3) # 指定宽度，如果长度不够则前面补0
# 2.2.3 布尔型
'''
在计算机中0和1是基本元素，在python中Ture和False分别代表真假
'''
# 下面是一些金典的布尔运算(and 、or、 not、的优先级）优先级：and > or

b1 = 0
b2 = 1
b3 = 2
b1 and b2
b2 and b1
b1 or b2
b1 and b2 or b3
b1 and (b2 or b3) # 用类似于数学中的符号提高运算的优先级

# not的注意事项
not b1
not b1 == b2
not(b1 == b2)
# b1 == not b2 这条语法有误
b1 == (not b2)
# 2.2.4 列表
# 列表是用方括号组织起来的，每个元素用逗号隔开，每个元素可以使任意类型的内容。通常元素的类型是相同的也可以是不同的。
x1 = []
x2 = [1, 2, 3, 4, 5]
x3 = ['a', 'b', 'c']
x4 = ['a', 'b', '1.416123', 'ture', [1, 2, 3, 4, 5]] # 各种类型混杂
type(x1) # type函数查看数据类型
type(x2)
type(x3)
type(x4)
print(type(x1), type(x2), type(x3), type(x4))

# 列表和字符串一样支持切片访问，可以将字符串中的一个字符当成列表中的一个元素。
a111 = [1, 2, 3]
len(a111)
max(a111)
min(a111)
sum(a111)
a111.index(2) # 指定元素位置
a111.count(1) # 求元素的个数
for i in a111: print(i) # 迭代元素
sorted(a111) #  返回一个排序的列表但是不改变原列表
any(a111) # 是否至少有一个元素为真
all(a111) # 是否所有的元素为真
a111.append(4) # [1, 2, 3, 4] (增加一个元素)
a111.pop() # 每执行一次，删除最后一个元素。
a111.extend([9, 8]) # 与其他列表合并
a111.insert(1, 'a') # 在指定的索引位置插入元素，索引从0开始
a111.remove('a') # 删除一个指定的元素
a111.clear() # 清空

# 将一个可迭代的对象展开，形成一个列表
[i for i in range(5)]
print([i for i in range(5)]) # [0, 1, 2, 3, 4]
# 可以将结果进行处理
['第'+str(i) for i in range(5)]
print(['第'+str(i) for i in range(5)])

# 可以进行条件筛选实现取偶数
[i for i in range(5) if i%2==0]
print([i for i in range(5) if i%2==0])
[i.upper() for i in 'Hellow World' if i != ' ']
print([i.upper() for i in 'Hellow World' if i != ' '])

# 元组
# 元组列表非常相似，二者之间的差距是元组不可以修改，而列表是可以修改的。元组使用（），列表使用[]
x = [1,2,3,4,5]
a,*b = x # a占第一个神域的组成列表全给了b
a,*b,c = x # a占第一个 c占最后一个，剩余中间的都留给b

#  字典
# 键值对组成
d = {} # 定义空字典
d1 = dict() # 定义空字典
d2 = {'a':1, 'b':2, 'c':3} #
d3 = {'a':1, 'a':1, 'a':1,} # key值不能重复，重复时取最后一个
d4 = {'a':1, 'b':{'x':3}} # 嵌套字典
d5 = {'a':[1,2,3],'b':[4,5,6]}
print(d1, d2, d3, d4, d5)

# 以下定义如下结果。
# {'name': 'tom', 'age': '18', 'height': '180'}
d11 = {} # 定义一个空字典
d11 = dict(name = 'tom', age = 18 , height = 180)
d11 = dict([('name','tom'),('age','18'), ('height','180')])
print(d11)
# 访问字典的操作方法
d11['name'] # 'tom' 获取键的值
print(d11['name'])
d11['age'] = 20 # 跟age的值跟新为20
print(d11['age'])
d11['female'] = "man" # 增加属性
d11.get('height',180)
print(d11.get('height',180))
# 嵌套取值
d11 = {'a': {'name':'tom','age':'18'},'b':[4,5,6]}
print(d11)
d11['b'][1] # 5
print(d11['b'][1]) # 取字典中的第1个数 在字典中数字排序从0开始。
# d['a']['age'] # 18 因为a赋值
# print(d['a']['age'])
'''
# 常用的1字典操作方法如下
d11.pop('name') # 'tom'(删除指定的key）
d11.popitem() # 随机删除某一项
del d11['name'] # 删除键值对
# d11.clear() # 清空字典
# 按访问访问可以迭代
d11.keys() # 列出所有的键值对
d11.values()
d11.iteams() # 列出所有键值对元组（k，v）
# 操作
d11.setdefault('a',3) # 插入一个键并给定默认值为3，如不指定则为none
d11.uodate(d1) # 将字典d1的键值对添加到字典d11
# 如果值存在，则返回其对应值；如果不在字典中，则返回默认值。
d11.get('math', 100)
d12 = d11.copy() # 拷贝d11变化不影响d12

d21 = {'a':1,'b':2,'c':3}
max(d21)
min(d21)
len(d21) # length
str(d21) # 字符串类型
any(d21) # ture 只要一个键值为ture
all(d21) # 所有的键值都为ture
sorted(d21) # 所有键的列表排序
'''
################
# 2.2.7 集合

# 集合是存放无顺序、无索引内容的容器。在python中集合用｛｝表示。集合可以消除重复的元素，也可以用它作交、差、补等数学运算。
s1 = {} # 空集合
s1 = {'5元','10元','15元'} # 定义集合
s2 = set() # 空集合
s2 = set([1,2,3,4,5]) # 用列表定义｛1，2,3,4,5｝
s3 = {1,True,'a' }
s3 = {1,1,1,1} # {1}集合会主动去重
#type(s1,s2,s3)
#print(type(s1)) # 类型检测
# 集合没有顺序，没有索引，所以无法指定位置去访问，但可以用for遍历的方式进行读取。
s4 = {'a','b','c'}
# 判断是否有每个元素
'a' in s4
# 添加元素，
s4.add(2)
print(s4.add(2))
s4.update([1,3,4])
print(s4.update([1,3,4]))

# 删除和清空元素
s4.remove('a') # 若元素不存在则会报错
s4.discard('3') # 删除一个元素，无则忽略，不报错。
s4.clear() # set()集合清空
# 集合的数学运算

s11 = {1,2,3}
s12 = {2,3,4}
s11 & s12 # 交集
print(s11 & s12)
s11.intersection(s12) # 交集
s11.intersection_update(s12) # 交集 会覆s11
s11 | s12 # 并集
s11.union(s12) # 并集

s11.difference(s12) # 差集
s11.intersection_update(s12) # 差集，会覆盖s11
s11.symmetric_difference(s12) # 交集之外（余集）
s11.isdisjoint(s12)# 是否没有交集
s11.issubset(s12) # s11是否是s12的子集
s11.issuperset(s12) # s11是否是s12的超集

########################################
#  2.3 Numpy # Numpy是python中的一个高性能矩阵运算的科学计算库。

# 创建数据

import numpy as np
# np.qrray([1, 2, 3])
# np.qrray((1, 2, 3))
# print(np.qrray([1,2,3]),np.qrray((1,2,3))) # 矩阵可以使用[]()来表示


#   数据类型
# Numpy的常见类型
#
'''
np.int64 # 有符号64位整形
np.float32 # 标准双精度浮点类型。
np.complex # 由128位的浮点数组成的复数类型
np.bool # bool类型
np.object # python中的object类型
np.string # 固定长度的string类型
np.unicode # 固定长度的unicode类型
np.NaN # np.float的子类型
np.nan

# 数组信息
np.shape() # 数组形状，返回值是一个元组
np.shape = (4,1) # 改变形状
n111 = np.reshape((2,2)) # 改变原数组的形状，创建一个新的数组
np.dtype # 数据类型
np.ndim # 维度数
np.size # 元素数
np.typedict # np的所有数据类型


#统计计算
np.array([10,20,30,40])[:3] # 支持类似于切片
n1 = np.array([10,20,30,40])
n11 = np.array([1,2,3,4])
n1+n11
print(n1+n11)
n1 - 1
print(n1 - 1)
4*np.sin(n1)
print(4*np.sin(n1))
# 以下是一些数学函数的例子，还支持非常多的数学函数
n1.max()
n1.min()
n1.sum()
n1.std()
n1.all()
n1.cumsum()
n11.sum(axis=1)
'''
# 2.4 pandas的数据结构
# series 是一个带有标签的一堆数组，这一系列连续的数据代表了一定的业务意义。
'''
横向的称作行，纵向的称作列
第一行是表头
第一列是索引，表头和索引页称为列索引和行索引。

'''
# 2.5 pandas生成数据
import pandas as pd
import numpy as np
# 创建数据
df = pd.DataFrame({'国家': ['中国', '美国', '日本'],
                   '地区': ['亚洲', '北美', '亚洲'],
                   '人口': [13.97, 3.28, 1.26],
                   'GDP': [14.34, 21.43, 5.08],
                   })
print(df)

'''
   国家  地区     人口    GDP
0  中国  亚洲  13.97  14.34
1  美国  北美   3.28  21.43
2  日本  亚洲   1.26   5.08
'''
# DataFrame可以容纳Series，所以在dataframe中可以使用Series，
df2 = pd.DataFrame({'A': '1',
                    'B': pd.Timestamp('20130102'),
                    'C': pd.Series(1, index = list(range(4)), dtype='float32'),
                    'D': np.array([3] * 4, dtype = 'int32'),
                    'E': pd.Categorical(["test", "train", "test", "train"]),
                    'F': 'foo',
                    })
print(df2)

'''
   A          B    C  D      E    F
0  1 2013-01-02  1.0  3   test  foo
1  1 2013-01-02  1.0  3  train  foo
2  1 2013-01-02  1.0  3   test  foo
3  1 2013-01-02  1.0  3  train  foo

'''
df['人口']
print(df['人口'])
'''
0    13.97
1     3.28
2     1.26
Name: 人口, dtype: float64
'''
# 如下单独创建一个Series
s = pd.Series([14.34, 21.43, 5.08],name='gdp')
print(s)
'''
0    14.34
1    21.43
2     5.08
Name: gdp, dtype: float64
'''

type(s)
print(type(s))
print(type(df))

'''
<class 'pandas.core.series.Series'>
<class 'pandas.core.frame.DataFrame'>
'''
# 生成Series
# 使用列表和元组

s111 = pd.Series(['a','b','c','d','e']) # 这个里面的[]可以用{}代替，效果是一样的

# 使用ndarry
# 如下使用numpy的ndarry结构
s1111 = pd.Series(np.random.randn(5), index = ['a', 'b', 'c', 'd', 'e'])
s1111.index #查看索引
s1111 = pd.Series(np.random.randn(5)) # 未指定索引
# 使用字典
d111 = {'b':1, 'a':0, 'c':2}
s11111 = pd.Series(d111)
print(s11111)
'''
b    1
a    0
c    2
dtype: int64
'''
# 如果指定索引，则会按索引顺序，如有无法与索引对应的值会产生缺失值。
pd.Series(d,index = ['a', 'b', 'c', 'd', 'e'])
# 使用标量
pd.Series(5.)

pd.Series(5.,index = ['a', 'b', 'c', 'd', 'e']) # 指定索引

# 生成DataFrame
# DataFrame最基本的定义格式
# df = pd.DataFrame(data = None, index = None, columns = None)
d = {'国家': ['中国', '美国', '日本'],
     '人口': [13.97, 3.28, 1.26],
     }
df = pd.DataFrame(d)
print(df)
#df11111111 = pd.DataFrame(d, dindex = ['a', 'b', 'c'])
#print(df11111111)

# Series组成的字典
# 这是一种非常典型的构造数据的方法，字典里的一个键值对为一列数据，键值列名就是一个Series
d = {'x':pd.Series([1., 2., 3.], index=['a','b','c']),
     'y':pd.Series([1., 2., 3.,4.], index=['a','b','c','d'])}
df3 = pd.DataFrame(d)
print(df3)
# 字典组成的列表。

# 定义一个字典列表，、
data1 = [{'x':1,'y':2},{'x':3,'y':4,'z':5}]
# 生成DataFrame对象。

pd.DataFrame(data1)
print(pd.DataFrame(data1))
# 指定索引
pd.DataFrame(data1, index=['a','b'])
print(pd.DataFrame(data1, index=['a','b']))
# Series生成 一个Series只会生成一列DataFrame，
s = pd.Series(['a','b','c','d','e'])
pd.DataFrame(s)
print(pd.DataFrame(s))
# 其他方法
# 从字典里生成
pd.DataFrame.from_dict({'国家':['中国','美国','日本'],'人口':[13.97,3.28,1.26]})
# 从列表、元组、ndarray中生成
pd.DataFrame.from_records([('中国','美国','日本'),(13.97,3.28,1.2)])
# 列表内容为一个字典 因为没有创建该字典
# pd.json_normalize(df.col)
# df.col.apply(pd.Series)