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 num
True
>>> 'H' in Str
True

对于序列，有三个内建函数可以应用，它们是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
>>> pi
3.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 dic
True
>>> 'Bob' in dic
False

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();
>>> aa
dict_values(['Bob', ['Toyota', 'Honda', 'infiniti']])
>>> aaa
dict_keys(['name', 'car'])
>>> list(aa)
['Bob', ['Toyota', 'Honda', 'infiniti']]
>>> list(aaa)
['name', 'car']

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

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

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