Python数据类型

序列类型 — list, tuple, range

本文所讲序列类型包括list, tuple, range

序列类型通用操作

表中的s和t同一类序列类型，n,i,j和k都是整数, x可以是任何对象 ，

操作	结果	例子
x in s	若x在s中存在就返回True，否则返回False
x not in s	若在s中不存在就返回True，否则返回False
s + t	s和t的并联	a=[1,2]+[3,4]; a=[1,2,3,4]
s*n 或 n*s	相当于s自身相加n次	a=(1,2)*n; a=(1,2,1,2)
s[i]	s中的第i个元素，位置从0开始算起	s=(1,2,3,4); s[2] = 3
s[i:j]	新序列：数据为s从第i个元素到第j个元素	s=(1,2,3,4); s[1:3]=(2,3,4)
s[i:j:k]	新序列：数据为s从第i个元素到第j个元素,步长为k	s=(1,2,3,4); s[0:3:2]=(1,3)
len(s)	s的长度	s=(1,2,3,4); len(s)=4
min(s)	s中的最小元素	s=(1,2,3,4); min(s)=1
max(s)	s中的最大元素	s=(1,2,3,4); max(s)=4
s.index(x)	s中x元素第一次出现的索引（位置）	s=(1,2,3,4); s.index(2) =1
s.count(x)	s中x元素的个数	s=[1,2,2,2,3]; s.count(2)=2

注意：若i和j是负数，索引便是相对于s序列的末尾来计算：此时i和j用len(s)+i,len(s)+j 替代

可变序列

列表中的s是一个可变序列对象，t是一个可迭代的对象，x可以是任何对象

操作	结果	例子
s[i]=x	用x替换s中的第i个元素
s[i:j] = t	用t中的内容替换s中第i至第j个元素	s=[1,2,3],t=[‘c’,’d’];s[0:2] = t, s=[‘c’,’d’,3]
del s[i:j]	相当于s[i:j]=[]	s=[1,2,3]; del s[0:1], s=[2,3]
s[i:j:k]=t	s中的s[i:j:k]元素被t中的元素代替	s=[1,2,3,4],t=[‘a’,’b’]; s[0:3:2]=t, s=[‘a’,2,’b’,4]
del s[i:j:k]	删除s中的s[i:j:k]元素	s=[1,2,3,4]; del s[0:3:2], s=[2,4]
s.append(x)	将x追加到s的结尾	s=[1,2,3,4]; s.append(‘a’),s=[1,2,3,4,’a’]
s.clear()	清空s	s=[1,2,3,4]；s.clear(), s=[]
t=s.copy	将s复制一份赋值给t	s=[1,2,3,4]；t = s.copy(), t = [1,2,3,4]
s.extend(t)或s+=t	将t的元素加在s的结尾	s=[1,2],t=[‘a’,’b’]; s.extend(t),s=[1,2,’a’,’b’]
s*=n	更新s，将元素重复n次	s=[1,2];s*=3, s=[1,2,1,2,1,2]
s.insert(i,x)	将x插入到s的i位置	s=[1,2];s.insert(0,‘a’),s=[‘a’,1,2]
s.pop（i）	取出s中的第i个元素，并将其从s中删除	s=[1,2]; s.pop(i)–>2, s = [1]
s.reverse()	反转s中元素	s=[1,3,4,2];s.reverse(),s=[2,4,3,1]

list

list属于可变序列，list有几种构建方式：

• 用一对方括号表示空列表：[]
• 使用方括号，用逗号（英文）隔开元素：[a], [a,b,c]
• 列表生产式：[x for x in iterable]
• 使用构造函数：list() 或 list(iterable)

注意：使用构造函数生成列表时，列表中的元素内容和位置与iterable中的元素一样。iterable可能是列表、可迭代对象，如果是列表，将会复制一份列表，如list([1,2])返回[1,2].如果是字符，如list(‘breeze’)返回[‘b’,’r’,’e’,’e’,’z’,’e’],如果是元组，如list((1,2,3))返回[1,2,3].

list除了具有序列类型通用操作和可变序列操作之外，list还支持sort(key=none,reverse=False),该方法没有返回值，但是会对列表的对象进行排序
参数解析：

• key: 排序关键字,值为一个函数，此函数只有一个参数且返回一个值，排序时就按返回的值进行排序.Key默认值为none
• reverse: 默认为False，为True的话就是反序排序
• 例子

 >>>student_tuples = [('john','A',15),('jane','B',12)('dave','B',10)]
 >>>student_tuples.sort(key=lambda student: student[2])
 >>>student_tuples
 [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]`

tuple

tuple（元组）是不可变序列，序列类型的通用操作tuple都具有。tuple有以下几种构建方式：

• 用一对括号表示空元组：（）
• 只有一个元素时末尾需加上逗号：a,或（a,）
• 多个元素的话需用逗号隔开：a.b.c或（a,b,c）
• 用构造函数：tuple 或tuple(iterable)

注意：使用构造函数生成元组时，元组中的元素内容和位置与iterable中的元素一样。对于一个元组来说，逗号不可少，（）是可选的，除了空元组和为了避免语法歧义，如f(a,b,c)表示调用一个函数传入了三个参数，而f((a,b,c))表示调用函数传入一个参数。

String

string是不可变序列的一种，序列类型的通用操作string都具有。string有以下几种构建方式：

• 单引号; ‘allows embedded “double” quotes’
• 双引号: “allows embedded ‘single’ quotes”

• 三引号： ”’Three single quotes”’, “”“Three double quotes”“”
  注意：三引号表示的字符串可能跨越多行，所有相关的空格都包含在字符串中

  字符串操作

name = 'breeze'
print(name.capitalize())#首字母大写，输出:Breeze
print(name.center(11, "*"))#以字符为中心，返回一个长度为11的字符，两边用指定符号填充，输出:***breeze**
print(name.count('e', 2, 3))#e在字符'breeze'中从索引2到索引3出现的次数,输出：1
print(name.startswith('b'))#判断字符串是否以'b'开头，输出：True
print(name.endswith('e'))#判断字符串是否以'e'结尾，输出：True
print("Breeze\tLi".expandtabs())#将字符中的Tab用空格替代，输出:Breeze Li
print('123'.isdigit())#判断字符串中的字符是否都是数字，输出：True
print(name.islower())#判断字符串中的字符是否都是小写，输出：True
print('date type'.title())#将字符串变为标题形式，输出：Date Type
print(name.upper())#将字符串中的字符都变为大写,输出：BREEZE
print('BREEze'.swapcase())#将字符中的大写字符变小写，小写变大写，输出：breeZE
print(' Breeze '.strip())#去除字符串首位的空格，输出:Breeze
print('1;2;3;4'.split(';'))#以‘;’分割字符串，返回一个list,输出：[1,2,3,4]
print(name.replace('e', 'a'))#将字符串中的字符'e'用'a'替换掉，输出：braaza

集合– set

set特点：一是元素无序，二是元素不重复。主要用途包括：元素测试，去除序列中的重复元素，进行数学运算如求交集、并集等。
set的构建方式有两种：用大括号和set()都可以。注意：创建空的集合只能用set(),{}表示的是空字典，后面会讲到。

>>> basket = {'apple', 'orange', 'apple','orange', 'banana'}
>>> print(basket)                      #重复元素已被移除 
{'orange', 'banana', 'apple'}
>>> 'orange' in basket                 #测试成员元素
True
>>> 'crabgrass' in basket
False

# 数学运算
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  # 去除重复元素
{'a', 'r', 'b', 'c', 'd'}
>>> a - b                              # a集合中存在且b集合中不存在的元素
{'r', 'd', 'b'}
>>> a | b                              # a与b的并集即存在于a中或存在于b中
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b                              # a与b的交集即存在于a中且存在于b中
{'a', 'c'}
>>> a ^ b                              # 存在于a中或者b中，但不同时存在
{'r', 'd', 'b', 'm', 'z', 'l'}

其他常见操作：
>>>basket ={‘orange', 'banana', 'apple'}
>>>basket.add('grape')                 #add只能添加一个元素
>>>basket
{‘orange', 'banana', 'apple','grape'}
>>>basket.update(['peach,pear'])

映射类型 – dict

dict的元素由key:value组成，特点：key不能重复，元素无序。

>>> tel = {'jack': 4098, 'sape': 4139}
>>> tel['guido'] = 4127                   #添加一个元素
>>> tel
{'sape': 4139, 'guido': 4127, 'jack': 4098}
>>> tel['jack']                           #通过键取值
4098
>>> del tel['sape']                       #移除一元素
>>> tel['irv'] = 4127                               
>>> tel
{'guido': 4127, 'irv': 4127, 'jack': 4098}
>>> list(tel.keys())                     #将dict的key值组合成一个list
['irv', 'guido', 'jack']
>>> sorted(tel.keys())                   #将dirc的key值排序后组成一个list
['guido', 'irv', 'jack']
>>> 'guido' in tel                       #判断key值'guido'是否存在
True
>>> 'jack' not in tel                    #判断key值'jack'是否存在
False

循环遍历一个dict

>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}
>>> for k, v in knights.items():
...     print(k, v)
...
gallahad the pure
robin the brave

Data Structures
Built-in Types