python数据分析系列教程（1） —— 基础数据类型和内置容器

目录一.数据类型
    1.1 数字型(Numbers)
    1.2 布尔型(Boolean)
    1.3 字符型(Strings)
二.内置容器
    2.1 列表(List)
    2.2 元组(tuple)
    2.3 字典(Dict)
    2.4 集合(Set)

一.数据类型

python和其他编程一样，包括几种数据类型：整形、浮点型、布尔型、字符型。这类数据类型的使用方法与其他编程语言很相似

1.1 数字型(Numbers)

（1）numbers是python中的数字类型，其包括：整数(长整数)、浮点数、复数。
（2）对数字类型的操作符有：加减乘除、幂运算(**)、与或非运算。
内置数学函数:pow、abs、round、int、hex、bin。
公用模块:random、math等。

#python中数据类型不用预先声明，直接传递数据即可
x = 3         #创建整形3
print type(x) # Prints "<type 'int'>"
print x       # Prints "3"
print x + 1   # 加法运算; prints "4"
print x - 1   # 减法运算; prints "2"
print x * 2   # 乘法运算; prints "6"
print x ** 2  # 幂运算; prints "9"
x += 1        # 增一操作
print x       # Prints "4"
x *= 2        # 倍增操作
print x       # Prints "8"
y = 2.5       # 创建浮点型2.5
print type(y) # Prints "<type 'float'>"
print y, y + 1, y * 2, y ** 2     # Prints "2.5 3.5 5.0 6.25"

1.2 布尔型(Boolean)

（1）Python的布尔类型与别人的编程语言一致，不过在逻辑符号的表示上有了一些改变。
逻辑符号：and、or、not、！=
布尔值：True、Falset = True
f = False
print type(t) # Prints "<type 'bool'>"
print t and f # Logical AND; prints "False"
print t or f # Logical OR; prints "True"
print not t # Logical NOT; prints "False"
print t != f # Logical XOR; prints "True"
（2）Python会把0、空字符串”和None看成 False，其他数值和非空字符串都看成 True。因此我们可以使用逻辑符号来连接表达式，另外需要注意的是，python进行逻辑计算时，可能会遇到短路问题，如下面的程序：a = True
print a and ‘a=T’ or ‘a=F’ #输出为a=F输出结果为什么是a=F，而不是True。
原因是这里存在短路计算的原则：
* 在计算 a and b 时，如果 a 是 False，则根据与运算法则，整个结果必定为 False，因此返回 a；如果 a 是 True，则整个计算结果必定取决与 b，因此返回 b。
* 在计算 a or b 时，如果 a 是 True，则根据或运算法则，整个计算结果必定为 True，因此返回 a；如果 a 是 False，则整个计算结果必定取决于 b，因此返回 b。
首先计算a and 'a=T',计算结果是 ‘a=T’ 。 之后计算‘a=T’ or ‘a=F’ 计算结果还是 ‘a=T’

1.3 字符型(String)

（1）python中字符串可以看做是一个有序的字符的集合，用于存储和表现基于文本的信息。（2）因为字符串可以看做一个集合，因此针对序列数据的操作对字符串同样适用，比如索引、分片、乘法、判断成员资格、求长度、取最大最小值、合并、分片等操作。hello = 'hello'         # 使用单引号创建
world = "world"          # 也可用双引号创建
print hello         # Prints "hello"
print len(hello)          # String length; prints "5"
hw = hello + ' ' + world # 直接用加号,可以进行字符合并
print hw # prints "hello world"
hw12 = '%s %s %d' % (hello, world, 12) # 可以预先拼写字符格式 %s(字符型) %d(整数型)
print hw12 # prints "hello world 12"
（3）要注意python中字符串是不可变的，因此对字符串的项或者分片进行赋值操作是不合法的。website='www.baidu.com'
website[-2:]='con' #报错 'str' object does not support item assignment （4）针对字符串的方法有：find()、join()、lower()、replace()、split()、strip()、translate()等方法。s='hellO'
print s.find('e')     # 输出搜索词所在的索引位置;print 1
print s.capitalize()  # 首字母大些; prints "Hello"
print s.lower()       # print "hello"
print s.strip()       # 除去两侧空格
print s.upper()       # 全转为大些; prints "HELLO"
print s.rjust(7)      # Right-justify a string, padding with spaces; prints "  hellO"
print s.center(7)     # 让字符居中来扩充空间; prints " hellO "
print s.replace('l', '(ell)')  # Replace all instances of one substring with another;prints "he(ell)(ell)O"
print 'world '.strip()  # 将所有字符小写; prints "world"

二.内置容器

python中的容器是通过某种方式将不同类型的数据组织在一起，是一种数据结构，常见的内置有：List、Dictionary、Set、Tuple。

2.1 列表(List)

（1）列表是python中最常用、最具灵活性的有序集合对象，使用[]进行表示，其内部可以包含任何种类的对象包括：数字、字符、列表等。xs = [3, 1, 2] # Create a list
print xs, xs[2] # Prints "[3, 1, 2] 2"（2）列表不同于字符串、元组的是，列表是一个可变类型，其内部数据可以进行修改，其可以对容器原处进行修改、还能实地的增加、缩短长度。list1=[1,2,3,4]
list1[2]=5 #对第二个索引位置进行修改
print(list1) #print [1, 2, 5, 4]（3）对列表的基本操作包括：索引、分片、序列相加（拼接）、乘法（倍增）、成员资格判断、求长度、最大最小值等操作。xs = [3, 1, 2,5,8,9]   # 创建一个列表
print(xs, xs[2])  # Prints "[3, 1, 2,5,8,9]  2"
print(xs[-1])     # 反向寻找列表中倒数第一个数; prints "9"

xs[2] = 'foo'     # Lists can contain elements of different types
print(xs)         # Prints "[3, 1, 'foo',5,8,9]"

xs.append('bar')  # Add a new element to the end of the list
print(xs)         # Prints "[3, 1, 'foo',5,8,9 'bar']"

x = xs.pop()      # Remove and return the last element of the list
print(x, xs)      # Prints "bar [3, 1, 'foo',5,8,9 ']"

xss=xs[2:4]       # 对[3, 1, 'foo',5,8,9 ']做分片操作
print(xss)        # print['foo', 5]

xss=xs+['n1','n2']#对[3, 1, 'foo',5,8,9 ']做序列相加
print(xss)        #print [3, 1, 'foo', 5, 8, 9, 'n1', 'n2']

xss=xs*3          #对序列做乘法操作
print(xss)        #print [3, 1, 'foo', 5, 8, 9, 3, 1, 'foo', 5, 8, 9, 3, 1, 'foo', 5, 8, 9]

'foo'in xss       #进行成员判断，输出逻辑值 print True
print(len(xss))   #获取长度注意：
*做分片操作时，如xs[2:4]是取第2个到第3个索引的数，尾部索引值不取。
*当内部有字符串类型时，不能进行sorted(排序)、min(获取最小值)、max等数值操作。

2.2 元组(Tuple)

（1）元组和列表一样是一种序列，使用()定义，内部可以包含各种数据类型，两者唯一的不同是元组不可修改，属于不可变序列类型，但是元组元素的元素是可以修改的。t = (17, 'Jesse', ('LinuxKernel', 'Python'), [17, 'Jesse'])
t[0] = 18  #报错不可修改  不可改变内部元素 TypeError: 'tuple' object does not support item assignment

t = (11,22,["alex",{"k1":"v1"}])
t[2][1]['k1']='k2'   #对元组内部元素的元素进行修改
print(t)            #输出 (11, 22, ['alex', {'k1': 'k2'}])（2）我们可以使用两者方式来定义元组，一种是使用[]直接定义元组，另一种是使用tuple来定义存放可迭代的数据类型。ages = (11, 22, 33, 44, 55) #第一种定义方式
ages = tuple((11, 22, 33, 44, 55)) #第二种定义方式（3）对元组的操作没有序列那么多，主要有：索引、合并、重复、迭代等操作。tup = (55,77,85,55,96,99,22,55,)
tup.count(55) #返回结果：3 元素‘55’在元组tup中出现了3次

tup = (55,77,85,55,96,99,22,55,)
tup.index(55) #返回结果：0
tup.index(85) #返回结果：2
tup.index(55,2,7)

name_tuple = (1,2,3) #进行切片操作
print(name_tuple[0:2]) #输出（1,2）

name_tuple = (1,2,3) #获取元组长度
print(name_tuple[len(name_tuple)-1]) #输出 3（4）既然有了列表，而有时必须要使用元组的原因是*元组的不可变性提供了某种完整性，这样可以确保元组在程序中不能被另一个引用修改，而列表并没有这种保证，这样元组就类似于常数声明，提供了一种不可修改的保护性，用于应对于有固定关系的情况。
*有些地方必须要用元组，比如字典中键的声明，键从本意上是不允许修改的，这样就比较适合对元组的使用。

2.3 字典(Dictionary)

（1）字典是python中比较灵活的内置数据结构类型，字典就像JAVA里面的map，以及JavaScript中的Object，是一种无序的集合，不同于之前的列表(有序集合)，Dictionary通过定义键值对，使得内部的元素通过键进行存取，而不是使用序号偏移。d = {'cat': 'cute', 'dog': 'furry'} # 使用键值对创建字典
print(d['cat']) # 通过字典的键，获取对应的值; prints "cute"（2）字典有很大的灵活性，我们可以使用数字、字符串、元组等不可变数据类型来定义键，而且保存在字典中的项没有特定顺序，因此不能使用分片、合并等序列操作,并且内部的键值是不可重复的。

d = {'cat': 'cute', 'dog': 'furry'} # 使用键值对创建字典
#print(d[0])                        # 按位置获取会报错 Error:KeyError: 0

print(d.keys())                     #获取所有键      输出dict_keys(['dog', 'cat'])
print(d.values())                   #获取所有对应值  输出dict_values(['furry', 'cute'])

print(d['dog'])                     #获取键dog对应值 输出furry

（3）对字典的基本操作包括修改字典（修改已有key的value）、增加新键值对、修改已有键值对、成员判断、迭代等操作。

person={'name':'zyb','addr':'hainan'}       #定义字典
person=dict({'name':'zyb','addr':'hainan'})

print(person['name'])  #查询内部元素  输出 zyb
person.get('name')

person['sex']='男'     #修改键对应值
print(person)          #打印输出 {'sex': '男', 'name': 'zyb', 'addr': 'hainan'}

person.pop('sex')      #删除字典中一个键值对
#del person['sex']
print(person)          #删除后输出:{'name': 'zyb', 'addr': 'hainan'}

for key in person:    #遍历输出所有的键值：name    addr
print(key)

person.clear()         #清空所有字典,
print(person)          #输出空字典{}

person1={'name':'zyb','addr':'hainan'}
personcp=person1.copy()
print(personcp)        #进行内容拷贝，输出为{'name': 'zyb', 'addr': 'hainan'}

personmk={}.fromkeys(['name','age'])
print(personmk)        #使用fromkey方式常见字典，输出{'age': None, 'name': None}

2.4 集合(Set)

（1）集合是python中一种无序且不重复的元素集合，其内元素是不可变对象，使用{}进行定义。*集合与字典有很大的相似性，只不过Set中没有value，其内成员可以作为字典的键，而且其内元素是无序不重复的，因此不能使用数字进行索引。
*进行集合定义时有两种方式，一种是使用set()，另一种是使用{}直接创建。

a=set('boy')               
print(a,type(a))            #最简单的创建方式，输出{'y', 'o', 'b'} <class 'set'>

b=set(['y', 'b', 'o','o'])
print(b,type(b))            #列表不能作为集合的内部元素，所以列表不能保留下来，内部元素将作为集合元素，输出{'y', 'o', 'b'} <class 'set'>

c=set({"k1":'v1','k2':'v2'})
print(c,type(c))            #使用字典来创建，会直接提取其中的键，输出{'k1', 'k2'} <class 'set'>

d={'k1','k2','k2'}
print(d,type(d))            #集合内元素是不重复的，所以只保留了两个元素，输出{'k1', 'k2'} <class 'set'>

e={('k1', 'k2','k2')}
print(e,type(e))            #元组可以作为集合的内部元素，输出出来，输出{('k1', 'k2', 'k2')} <class 'set'>

（2）对集合的操作包括集合比较、删除、交集、成员判断、合并、更新等操作。

#比较操作
se = {11, 22, 33}
be = {22, 55}
temp1 = se.difference(be)        #找到se中存在，be中不存在的集合，返回不同的值
print(temp1)                     #{33, 11}

#删除操作
se = {11, 22, 33}
se.discard(11)  # 移除元素11
se.discard(44)  # 移除不存的元素44，未报错
print(se)       # 打印输出{33, 22}

#取交集操作
se = {11, 22, 33}
be = {22, 55}
temp1 = se.intersection(be)  # 取se和be之间的交集(共同存在的元素)，赋给新值
print(temp1)                 # 输出22

#集合的更新
se = {11, 22, 33}
be = {22,44,55}
se.update(be)   # 使用be对se进行更新，会将be的值对se进行覆盖
print(se)       # 输出结果：{33, 22, 55, 11, 44}

#集合的转换
se = set(range(4))   #生成四个数0,1,2,3 组成一个集合
li = list(se)        #将集合转换成列表
tu = tuple(se)       #将集合转成元组
st = str(se)         #将集合转成字符串
print(li,type(li))   #输出[0, 1, 2, 3] <class 'list'>
print(tu,type(tu))   #输出(0, 1, 2, 3) <class 'tuple'>
print(st,type(st))   #输出{0, 1, 2, 3} <class 'str'>