Python学习之基础数据部分

0）引论
Python是一门面向对象的编程语言，语法简洁清晰，容易上手，而且应用相当广泛，尤其在科学计算领域与网络领域。python与matlab很相似，都是解释型的语言，能够通过解释器实时得到每一步的结果。相对比于matlab，python是免费的，这才是其最大优势，而且python有很强大的库（当然这个比matlab差点，毕竟商业软件有很强大的资金支持），但是在很多方面也是够用的了，而且python的发展前景一定是由于matlab的。
首先写python的第一个程序，‘Hello World!’

>>> # 'Hello World!'>>> print("Hello World!")Hello World!

这个就不用多说了，自打C语言后，每个语言的第一件事就是输出‘Hello World!’。
注意的是：Python是不需要用分号做结束的，这跟C是不同的。Python的一行算是一个语句，这个是编程规范。
在Python中注释是用的‘#’，话说好像不同的编程语言，注释貌似也很不同啊，这也是比较奇怪的事情。

1） 数据结构
本小结，我们主要关注数据的组织结构。Python中主要有3中数据结构，列表，元组，字典。这3中结构有相同的数据操作也有各自独特的特点，下面我们来逐个分析。
1.1） 列表
各个元素以逗号相隔，写在方括号里，这样的数据组织方式成为列表。列表中的元素可以是字符，字符串，数字等等。如下面的例子

>>> num=[1,2,3]>>> name=['Arsharm','Bob','Cristina']>>> numstr=['1','2','3']>>> chara = ['A','a']>>> mix = ['Arsharm','1','A','a',1]

列表可以存储的元素可以是各种类型，不像C语言，数组只能有一种类型。

1.1.1） 序列基本操作
首先先来看一下序列的基本操作（列表，元组，字符串都是序列）
下面来介绍一下序列的基本操作：
序列主要有5中基本操作：索引，分片，加法，乘法，成员资格。

索引：索引就是给序列中的每个元素编号，以方便访问。

>>> num=[1,2,3,4,5,6,7,8,9,10]>>> num[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]>>> num[0]1>>> num[9]10>>> num[10]Traceback (most recent call last):File "<pyshell#13>", line 1, in <module>num[10]IndexError: list index out of range

上面的例子说明，索引是从0开始的，直到n-1。索引n是不存在的，如果访问，则会出错。

分片：个人认为，分片就是批量的对索引进行操作。分片是利用冒号实现的。

>>> num=[1,2,3,4,5,6,7,8,9,10]>>> num[1:5][2, 3, 4, 5]>>> num[1:10][2, 3, 4, 5, 6, 7, 8, 9, 10]>>> num[-3:-1][8, 9]>>> num[-1]10>>> num[-3:][8, 9, 10]>>> num[:][1, 2, 3, 4, 5, 6, 7, 8, 9, 10]>>> num[1:7:2][2, 4, 6]

上面是分片的应用，我们一步一步的来解释。
首先第一行建立了一个列表；
第二行通过分片索引访问列表中的部分元素，注意的是num[1:5]包含了索引为1的元素，不包含索引为5的元素，因为分片的原则是：第一个元素的索引以及分片后剩下的元素的第一个元素的索引；
我们再看第三行，不是没有索引10么，问什么没有报错？因为索引10是分片后剩下的元素的第一个元素的索引，虽然这个元素不存在，但是我们也没有去访问它，所以这样子是没有问题的。
第四行说明索引是可以从负数开始的，-1是最后一个元素的索引，同理利用num[-3:-1]是访问不到最后一个元素的。如果想要访问最后一个元素，则可以用第五行的方式
第五行说明把分片的后一个元素空着，就可以访问到最后一个元素。
第六行显示了怎样访问整个序列
第七行说明了怎样以一个较大的步长访问数据。格式是【起始索引：结束端索引：步长】，这个跟matlab是不同的。

加法： 序列的加法就是起到连接的作用。

>>> [1,2,3]+[4,5,6][1, 2, 3, 4, 5, 6]>>> [1,2,3]+['1','2','3'][1, 2, 3, '1', '2', '3']>>> [1,2,3]+['W','Hello'][1, 2, 3, 'W', 'Hello']>>> [1,2,3]+'World'Traceback (most recent call last):File "<pyshell#28>", line 1, in <module>[1,2,3]+'World'TypeError: can only concatenate list (not "str") to list

可以看到加法就是连接两个序列，但是这种连接只能连接两个相同类型的序列（列表，字符串，元祖都是序列），不能连接两个不同类型的序列，就像列表和字符串，所以程序报错了。

乘法：乘法的作用就是重复n次，这个没什么可说的。

>>> 'Hello World! '*5'Hello World! Hello World! Hello World! Hello World! Hello World! '

成员资格：检查一个值是否在序列中。主要用到的操作符是in。

>>> num=[1,2,3,4,5,6,7,8,9,10]>>> Str='Hello World!'>>> 1 in numTrue>>> 'H' in StrTrue

对于序列，有三个内建函数可以应用，它们是len，max，min，也就是长度，最大，最小。

>>> num=[1,2,3,4,5,6,7,8,9,10]>>> Str='Hello World!'>>> len(num)10>>> len(Str)12>>> max(num)10>>> min(num)1>>> max(Str)'r'>>> min(Str)' '

字符的大小事按照ASCII排序的。

1.1.2）列表的 基本操作
list函数：根据字符串创建列表

>>> list("Hello World!")['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd', '!']

利用分片进行赋值

>>> word=list('pearl')>>> word['p', 'e', 'a', 'r', 'l']>>> word[1:]=list('ython')>>> word['p', 'y', 't', 'h', 'o', 'n']>>> word[2:2]=list('**')>>> word['p', 'y', '*', '*', 't', 'h', 'o', 'n']>>> word[2:4]=[]>>> word['p', 'y', 't', 'h', 'o', 'n']

删除元素：del

>>> name=['Arsharm','Bob','Cristina']>>> del name[1]>>> name['Arsharm', 'Cristina']

1.1.3）列表的方法
面向对象的语言貌似基本上都会有个叫做方法的东西，或许习惯于C语言的函数式的编程会觉得方法很陌生，起始方法还是很好用的，至少感觉比函数要好用。方法起始是对列表的一些基本操作，格式为：对象.方法()。下面介绍列表的几个方法：
append：列表末尾追加新的对象

>>> num=[1,2,3,4,5]>>> num[1, 2, 3, 4, 5]>>> num.append(6)>>> num[1, 2, 3, 4, 5, 6]

count：统计某一元素在列表中出现的次数

>>> num=[1,2,3,2,4]>>> num.count(2)2

extend：列表末尾一次性追加另一个列表的若干个值。

>>> num_a=[1,2,3,4,5]>>> num_b=[6,7,8,9]>>> num_a.extend(num_b[0:2])>>> num_a[1, 2, 3, 4, 5, 6, 7]>>> num_a.extend(num_b)>>> num_a[1, 2, 3, 4, 5, 6, 7, 6, 7, 8, 9]

index：列表中查找某个值的第一个匹配项的索引

>>> num=[1,2,3,4,5]>>> num.index(2)1

insert：列表中插入一项

>>> num=[1,2,3,4,5]>>> num.insert(2,'people')>>> num[1, 2, 'people', 3, 4, 5]

pop：弹出一个元素，主要用于堆栈

>>> num[1, 2, 'people', 3, 4, 5]>>> num=[1,2,3,4,5,6]>>> num.pop()6>>> num[1, 2, 3, 4, 5]>>> num.pop(2)3>>> num[1, 2, 4, 5]

pop可以弹出最后一个元素，也可以弹出任意一个元素。

remove：移除列表中的第一个匹配项

>>> num=[1,2,3,4,5,6,2]>>> num.remove(2)>>> num[1, 3, 4, 5, 6, 2]

reverse：反向存放列表

>>> num=[1,2,3,4,5,6,2]>>> num.reverse()>>> num[2, 6, 5, 4, 3, 2, 1]

sort：排序（不是产生副本的排序，而是直接在原始列表中排序）

>>> num=[3,1,4,1,5,9,2,6]>>> num.sort()>>> num[1, 1, 2, 3, 4, 5, 6, 9]

下面的例子能更好的说明一个问题：y=x与y=x[:]是不一样的

>>> x=[3,4,1,8,2]>>> y=x>>> y.sort()>>> y[1, 2, 3, 4, 8]>>> x[1, 2, 3, 4, 8]

>>> x=[3,4,1,8,2]>>> y=x[:]>>> y.sort()>>> y[1, 2, 3, 4, 8]>>> x[3, 4, 1, 8, 2]

上面的例子中，y=x仅仅是y，x都指向了一个序列，因此，第一个对y排序就相当于对原始的x进行了排序；而y=x[:]是进行了复制，所以对y排序不影响x中的排序。

1.2） 元组
把元素用圆括号括起来，就是元组，元组是不可修改的。利用逗号可以形成一个值得元组

>>> a = (1,2,3)>>> a(1, 2, 3)>>> b = 4,>>> b(4,)

元组是不可以修改的，因此元组就没有上面那么多的操作和方法了，因此比较简单，只有创建元组，访问元组这两种方式。那么一个问题是：元组有什么用呢？
元组的优势就在于不可修改。元组可以作为字典的键，以及内建函数方法的返回值。

tuple函数：利用序列创建元组

>>> tuple([1,2,3,4])(1, 2, 3, 4)

1.3） 字符串

1.3.1） 首先字符串是不可变的，因此给字符串赋值是不合法的。

>>> Str='Hello World!'>>> Str[1:3]='ey'Traceback (most recent call last):File "<pyshell#66>", line 1, in <module>Str[1:3]='ey'TypeError: 'str' object does not support item assignment

1.3.2） 百分号‘%’可以用作字符串的转换符

>>> 'hello %d' % 42'hello 42'>>> 'Hello %s!' % 'World''Hello World!'

1.3.3） print函数

>>> print('hello %d' % 42)

1.3.4） 字段的宽度与精度问题：

>>> from math import pi>>> pi3.141592653589793>>> '%10.2f' %pi' 3.14'>>> '%010.2f' %pi'0000003.14'>>> '%-10.2f' %pi'3.14 '>>> '%+10.2f' %pi' +3.14'

10.2f中10表示宽度，2表示精度。010.2f前面的0不是八进制，而是以0填充的意思。‘-’是左对齐。‘+’就是正常的加号。

1.3.5） 字符串的方法

find：查找子字符串，返回最左端索引

>>> Str = 'I love Python, Python is an amazing language!'>>> Str.find('Python')7>>> Str.find('a')25

lower：返回字符串的小写字母表示

>>> Str = 'Python'>>> Str.lower()'python'

replace：返回匹配项被替换后的字符串

>>> Str='I like Python'>>> Str.replace('ython','earl')'I like Pearl'>>> Str'I like Python'

split：字符串分割成序列

>>> Str='I like Python'>>> Str.split()['I', 'like', 'Python']

strip：返回去除两侧空格的字符串

>>> ' such a fun gay! '.strip()'such a fun gay!'

1.4） 字典
1.4.1） 字典是一种通过名字引用值得数据结构。名字就是所谓的键。
字典由冒号，逗号，大括号组成。
{}表示空字典
创建字典：

>>> PhoneNum = {'Arsharm':'1234','Bob':'0123','Cristina':'0019'}

dict函数可以通过映射来创建字典

>>> item = [('Arsharm','1234'),('Bob','0123')]>>> dict(item){'Arsharm': '1234', 'Bob': '0123'}

1.4.2） 字典的基本操作：
len（d）：字典中键-值对的个数
d[k]：访问键k的值
d[k]=v： 将v关联到键k上
del d[k]：删除d中含有键k的项
k in d： 检查d中是否含有键为k的项

>>> item = [('Arsharm','1234'),('Bob','0123'),('Cristina','0019')]>>> dic = dict(item)>>> dic{'Arsharm': '1234', 'Bob': '0123', 'Cristina': '0019'}>>> len(dic)3>>> dic['Bob']'0123'>>> dic['Bob']='0012'>>> dic{'Arsharm': '1234', 'Bob': '0012', 'Cristina': '0019'}>>> del dic['Bob']>>> dic{'Arsharm': '1234', 'Cristina': '0019'}>>> 'Arsharm' in dicTrue>>> 'Bob' in dicFalse

1.4.3） 字典的方法：
clear： 清除字典中的所有项。

>>> tem = [('Arsharm','1234'),('Bob','0123'),('Cristina','0019')]>>> dic = dict(item)>>> dic{'Arsharm': '1234', 'Bob': '0123', 'Cristina': '0019'}>>> dic.clear()>>> dic

利用clear才能完成真正的清空，我们来看下面的例子：

>>> x={}>>> x['key']='value'>>> x{'key': 'value'}>>> y=x>>> y{'key': 'value'}>>> x={}>>> y{'key': 'value'}>>> x={}>>> x['key']='value'>>> x{'key': 'value'}>>> y=x>>> y{'key': 'value'}>>> x.clear()>>> x{}>>> y{}

上面提到y=x仅仅是说明x，y指向了同一个字典，在第一个例子中把x={}并不能真正清空这个字典，只是x不再表示这个字典罢了。而用clear方法则是直接把这个字典清空了，因此才会有第二个的例子。
copy：返回一个具有相同键-值对的新字典

>>> item[('Arsharm', '1234'), ('Bob', '0123'), ('Cristina', '0019')]>>> dic = dict(item)>>> dic{'Arsharm': '1234', 'Bob': '0123', 'Cristina': '0019'}>>> dic1 = dic.copy()>>> dic1{'Arsharm': '1234', 'Bob': '0123', 'Cristina': '0019'}

还有一个deepcopy，这两个copy在处理含有符合对象的字典时会有不同的结果

>>> a = {'name':'Arsharm','car':['Toyota','Honda','infiniti']}>>> b=a.copy()>>> b{'name': 'Arsharm', 'car': ['Toyota', 'Honda', 'infiniti']}>>> b['name']='Bob'>>> b{'name': 'Bob', 'car': ['Toyota', 'Honda', 'infiniti']}>>> a{'name': 'Arsharm', 'car': ['Toyota', 'Honda', 'infiniti']}>>> b['car'].remove('Honda')>>> b{'name': 'Bob', 'car': ['Toyota', 'infiniti']}>>> a{'name': 'Arsharm', 'car': ['Toyota', 'infiniti']}

>>> a = {'name':'Arsharm','car':['Toyota','Honda','infiniti']}>>> b=a.copy()>>> b{'name': 'Arsharm', 'car': ['Toyota', 'Honda', 'infiniti']}>>> b['car'][0]='BMW'>>> b{'name': 'Arsharm', 'car': ['BMW', 'Honda', 'infiniti']}>>> a{'name': 'Arsharm', 'car': ['BMW', 'Honda', 'infiniti']}

可以看到当用copy时，对字典的项进行替换时，不会对原字典产生影响，而对复合结构进行移除处理时，则会改变原字典。这就是copy被称为浅层复制的原因。

>>> import copy>>> a = {'name':'Arsharm','car':['Toyota','Honda','infiniti']}>>> b = copy.deepcopy(a)>>> b{'name': 'Arsharm', 'car': ['Toyota', 'Honda', 'infiniti']}>>> b['car'].remove('Toyota')>>> b{'name': 'Bob', 'car': ['Honda', 'infiniti']}>>> a{'name': 'Arsharm', 'car': ['Toyota', 'Honda', 'infiniti']}

当用deepcopy时，对复合结构进行移除处理时，就不会改变原字典。这个称之为深层复制。

fromkeys： 使用给定键建立新字典

>>> {}.fromkeys(['name','age']){'age': None, 'name': None}

get：访问字典

>>> a = {'name':'Arsharm','car':['Toyota','Honda','infiniti']}>>> a.get('name')'Arsharm'>>> a.get('car')['Toyota', 'Honda', 'infiniti']

pop：返回给定键的值，然后将键-值对移除

>>> a.pop('name')'Arsharm'>>> a{'car': ['Toyota', 'Honda', 'infiniti']}

popitem：随机弹出一个项，因为字典没有顺序。

>>> a = {'name':'Arsharm','car':['Toyota','Honda','infiniti']}>>> a.popitem()('name', 'Arsharm')>>> a{'car': ['Toyota', 'Honda', 'infiniti']}

update：利用一个字典去更新另一个字典的值。

>>> a = {'name':'Arsharm','car':['Toyota','Honda','infiniti']}>>> b = {'name':'Bob'}>>> a.update(b)>>> a{'name': 'Bob', 'car': ['Toyota', 'Honda', 'infiniti']}

values/keys： 分别以列表的形式返回字典中的值/键

>>> list(aa)['Bob', ['Toyota', 'Honda', 'infiniti']]>>> a{'name': 'Bob', 'car': ['Toyota', 'Honda', 'infiniti']}>>> aa=a.values()>>> aaa=a.keys();>>> aadict_values(['Bob', ['Toyota', 'Honda', 'infiniti']])>>> aaadict_keys(['name', 'car'])>>> list(aa)['Bob', ['Toyota', 'Honda', 'infiniti']]>>> list(aaa)['name', 'car']

items：将字典项以列表的形式返回

>>> a{'name': 'Bob', 'car': ['Toyota', 'Honda', 'infiniti']}>>> b=a.items()>>> bdict_items([('name', 'Bob'), ('car', ['Toyota', 'Honda', 'infiniti'])])>>> list(b)[('name', 'Bob'), ('car', ['Toyota', 'Honda', 'infiniti'])]

2）总结
以上就是Python学习之基础数据部分的全部内容了。数据的组织是一门语言最基本的问题。我们可以看到，python中数据类型主要的就那么几种，但是各种操作以及方法还是蛮多的。这个其实用用就会了，没什么太大的意思。常见“7天学会XXX”。其实7天学会一门语言不难，基本的东西就那么些，而且各种语言还很相通，但是真正要运用好语言，恐怕得最少也要乘以100吧。