Python高级数据类型

列表

在Python中，用方括号（ []）来表示列表，并用逗号来分隔其中的元素。下面是一个简单的列表示例，这个列表包含几种自行车

bicycles = ['trek', 'cannondale', 'redline', 'specialized']
print(bicycles)

打印如下：

['trek', 'cannondale', 'redline', 'specialized']

列表特点

• 列表是⼀个有序的集合，集合中的个体称为元素
• 列表中有若⼲个元素组成，元素可以是任意数据类型
• 列表是有顺序的，可以通过索引访问

列表创建方式
创建⼀个空列表，等价于mylst = list()
mylist = []
创建⼀个纯整数类型的列表
mylst = [1,2,3,4]
创建⼀个包含不同数据类型的列表
mylst = [1,None,3.5,True]

列表元素访问
通过索引访问列表语法：列表名[索引号]
列表索引是从0开始的
somenum = [1,2,3,4,5,6]
somenum[0] 结果表示列表中第⼀个元素1
somenum[2] 结果表示列表中第三个元素 3
somenum[-2] 负索引表示从右向左查（从-1索引开始） 结果显示 5

修改列表元素
somenum = [1,2,3,4,5,6]
somenum[2] = 55 -> 将列表索引2对应的元素修改为55 print(somenum) 结果输出：[1,2,55,4,5,6]

列表切片
如果要连续取得列表中前N个元素，我们不建议遍历索引取得元素，Python提供了切⽚操作符。 Python中符合序列的有序序列都⽀持切⽚(slice) ，例如列表，字符串，元组。
例如：

a2=[2,“jack”,19,2,“ces”,156] #定义⼀个列表
a2[0:2]>>>[2, ‘jack’] #注意不包含索引2对应的元素（即前包后不包） a2[0:]>>>[2,"jack",19,2,"ces",156]#不写结束索引则默认到最后 a2[:3]>>>[2,“jack”,19]#不写起始索引则默认起始索引从0开始
 a2[:]>>> [2,“jack”,19,2,“ces”,156]
 a2[0:-2] >>> [2,“jack”,19,2]#索引为负数则从右往左查，-2对应元素“ces”

列表基本运算

表达式	结果	描述
[1, 2, 3] + [4, 5, 6]	[1, 2, 3, 4, 5, 6]	组合
[‘Hi!’] * 4	[‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’]	重复
3 in [1, 2, 3]	True	元素是否存在于列表中,存在返回 True,不存在返回False
for x in [1, 2, 3]: print (x)	1 2 3	迭代

列表函数

表达式	结果	描述
len([1, 2, 3])	3	查看列表⻓度
min([1,2,3])	1	返回列表所有元素中的最⼩值
max([1,2,3])	3	返回列表所有元素中的最⼤值

操作列表方法

⽅法	说 明
L.append（value）	在列表末尾添加新的元素，括号内的参数为元素名
L.insert(index,value)	在指定位置插⼊指定的元素
L.extend(iterable)	在列表末尾⼀次性追加另⼀个序列中的多个值
L.pop(index)	根据索引移除列表中的⼀个元素（不加参数默认移除最后⼀个元素），并 且返回移除元素的值
L.index(value)	从左到右查找指定元素在列表中的索引并返回
L.count(value)	统计某个元素在列表中出现的次数
L.reverse()	反向列表中的元素
L.sort([reverse=False])	对列表L进⾏排序，默认从⼩到⼤排序
L.clear()	清除列表L中的所有元素
L.copy()	复制L列表并返回⼀个新的列表

元组

元组特点
元组是⼀个有序的集合
元组中右若⼲个元素组成，元素可以是任意数据类型
元组是不可变的数据类型，元组中的元素不可修改
元组⽤⼩括号表示

元组定义以及访问

#定义⼀个空元组 tp=() #或者tp=tuple()
 #定义包含有多个元素的元组 
 company = ('google','lenevo','华为') 
 print(company)
  #定义⼀个只有⼀个元素的元组 
  tp = (1,) 
  print(tp) 
  #访问元组中的元素 
  print(company[1]) 
  print(company[-1])#⽀持正负索引 
  #元组和列表⼀样 也⽀持切⽚ 
  print(company[0:3]) 结果('google', 'lenevo', '华为')

元组运算

表达式	结果	描述
len((1, 2, 3))	3	计算元素个数
(1, 2, 3) + (4, 5, 6)	(1, 2, 3, 4, 5, 6)	组合
(‘Hi!’)* 4	(‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’)	重复
3 in (1, 2, 3)	True	元素是否存在
for x in (1, 2, 3): print (x)	1 2 3	迭代
len((1, 2, 3))	3	查看列表⻓度
min((1,2,3))	1	返回列表所有元素中的最⼩值
max((1,2,3))	3	返回列表所有元素中的最⼤值
tuple(iterable)	元组	将指定的可迭代类型转换为元组
list(元组)	列表	将指定的元组转换为列表

元组方法

⽅法	说 明
T.index(value)	从左到右查找指定元素在元组中的索引并返回
T.count(value)	统计某个元素在元组中出现的次数

字符串

字符串特点
字符串是⼀个有序的集合，⽀持索引访问
字符串是不可变数据类型，字符串中的元素不可修改
字符串是⽤单引号或双引号括起来的任意⽂本
字符串创建与访问
Python中的字符串可以包含普通字符，换⾏字符，制表符以及其他特殊字符

#定义字符串常量 
"mky"#这个就是字符串常量 
#定义字符串变量 mystr="manongayong" 
ch=mystr[0] print(ch) #>>> "m" 
ch=mystr[-2] print(ch) #>>> "n" 
#字符串⽀持切⽚ 
print(mystr[2:5]) #>>>"non" 
'''
Python不⽀持单字符类型（char类型），单字符在python中作为⼀个字符串使⽤，当⼀个字符串太⻓，⼀ ⾏写不下可以使⽤续⾏符来连接。
'''

转义字符
转义字符串的意义在于将⼀些有特殊含义的字符表示为普通字符，所谓转义，就是不采⽤符号本身的含 义，⽽采⽤l另外⼀种含义

转义字符	说 明
| 在⾏尾时表示续航⾏符
\	反斜杠符号
\’	单引号
\”	双引号
\a	响铃
\n	换⾏
\t	横向制表符

|\r| 回⻋
| \xyy |⼗六进制数，yy代表的字符，例如 ：\ x0a代表换⾏
  |\oyy |⼋进制数，yy代表的字符，例如：\o12 代表换⾏
  | \f| 换⻚ 
   |\000 |空
   | \other| 其他的字符以普通格式输出

字符串格式化
Python⽀持格式化字符串的输出，最基本的⽤法是将⼀个值插⼊另⼀个字符串格式符%s的字符串中
print("今天购物：%s,花费：%.2f "%(“⽪鞋，356.7”))
输出：今天购物：⽪鞋，花费：356.70
%占位符就是⽤来格式化字符串的，在字符串内部，%s表示⽤字符串替换，%d表示⽤整数替换。有⼏ 个%?占位符，后⾯就跟⼏个变量或者值，顺序要对应好。如果只有⼀个%?，括号可以省略。 有些时候，字符串⾥⾯的%是⼀个普通字符怎么办？这个时候就需要转义，⽤%%来表示⼀个%
例如： print(‘growth rate: %d%%’%7)
输出 ‘growth rate: 7%’

常用的格式占位符主要有

符号名称	描述
%s	格式化字符串
%d	格式化⼗进制整数
%f	格式化浮点数字，可指定⼩数点后的精度
%c	格式化字符及其ASCII码
%x	格式化⽆符号⼗六进制数

字符串运算

表达式	结果	描述
“china” + “ok”	“chinaok”	组合
‘Hi!’* 4	“Hi Hi Hi Hi”	重复
‘a’ in “china”	True	元素是否存在
for x in ”china”: print (x)	c h i n a	迭代

字符串函数

函数名	描述
len(str)	查看字符串⻓度
min(str)	返回列表所有元素中的最⼩值
max(str)	返回列表所有元素中的最⼤值

字符串方法

⽅法名称	说明
s.count(str)	返回
s.index(s[,start,end]) s.find(s[,start,end])	返回⼦串在字符串中的索引，不存在则抛异 返回指定字符串str在string中的索引,不存在返回-1
s.replace(old, new [, max])	⽤new替换在s中发现old⼦串，默认全部替换
s.strip([substr])	去除str字符串两端的空格或指定字符
s.startswith(substr)	判断字符串s是否以substr开头,是则返回True
s.endswith(substr)	判断字符串s是否以substr结尾,是则返回True
s.split(str,count)	⽤指定的⼦串去分割s字符串，返回列表类型
s.join(iterable)	将字符串s去连接序列中的各个元素，返回str类型
s.rjust(width[, fillchar])	返回⼀个原字符串右对⻬,并使⽤ fillchar 填充
s.ljust(width[, fillchar])	返回⼀个原字符串左对⻬,并使⽤ fillchar 填充
s.zfill(width)	返回⻓度为 width 的字符串，原字符串右对⻬，前⾯填充0
s.center(width[, fillchar])	返回⼀个指定的宽度 width 居中的字符串
s.expandtabs(tabsize=8)	把字符串 str中的 tab 符号转为空格，tab 符号默认的空格数是 8
s.lower()	将字符串的所有英⽂字符转换为⼩写
s.upper()	将字符串的所有英⽂字符转换为⼤写
s.swapcase()	将字符串中的字符⼤写转⼩写，⼩写转⼤写
s.capitalize()	将字符串的英⽂字符⾸字⺟⼤写，其他字⺟全部⼩写
s.title()	将字符串中的所有单词⾸字⺟⼤写
s.isalpha()	检测字符串是否全是字⺟，是则返回真，否则返回假
s.isdigit()	检测字符串是否全是数字，是则返回真，否则返回假
s.isalnum()	检测字符串是否全是数字、字⺟或数字与字⺟混合
s.islower()	检测字符串是否全是⼩写
str.istitle()	检测字符串是否是⾸字⺟⼤写
s.isspace()	检测是否全是空⽩字符
s.isidentifier()	检测字符串是否是标识符

字典

字典特点
字典也是⼀个集合，但是字典是⼀个⽆序的集合
字典中的每个元素有两部分组成，分别是键和值
字典是⼀个可变类型，可以存储任意类型对象
字典使⽤发括号来表示字典类型
创建字典
字典中没有任何元素称为空字典，字典中的每个元素有两部分组成，分别是键和值，键与值之间⽤冒号隔 开。

##定义⼀个空字典
 dt={}#也可以通过dt=dict()定义空字典 
 #定义⼀个包含有3个元素的字典 
 dt={"黎明":56,"阿勇":78,"码农":90} 
 print(dt) 
 #>>>{"黎明":56,"阿勇":78,"码农":90}

访问字典
由于字典是⼀个⽆序的集合，就意味着不能⽤过索引访问⾃带你中的元素，但是可以通过键名去访问指定 键名对应的值。
dt = {“zs”:88,“lisi”,99,“ww”:67}
print(dt[“zs”]) 访问字典中指定键名对应的值。结果展示88 print(dt.get(“zs”)) 可以调⽤函数通过键访问值操作
字典元素修改与添加实例：
dt={“张⻜”:30,“关⽻”:67,“刘备”:78}
dt[“张⻜”]=100 #修改张⻜对应的值
print(dt)
#>>>dt={“张⻜”:100,“关⽻”:67,“刘备”:78}
dt[“曹操”]=88 #向字典dt添加⼀个元素(曹操:88)
字典中的键名不允许重现重复，如果重现重复，字典将被视为只有⼀个。
print(dt)
#>>>{“张⻜”:100,“关⽻”:67,“刘备”:78,“曹操”:88}

遍历字典
遍历字典中的键名：
for i in dt:
print(i)
遍历字典中的值
for i in dt:
print(dt[i])
由于字典是无序的，所以每次打印出的键名顺序不同，在Python中给我们提供了线程的 dt.keys(),dt.items()分别实现键，值和键值对的获取⽅法

字典方法

dict.clear()	删除字典内所有元素
dict.copy()	返回⼀个字典的浅复制
dict.keys()	以列表返回⼀个字典所有的键
dict.values()	以列表返回字典中的所有值
dict.items()	以列表返回可遍历的(键, 值) 元组数组
dict.update(dict2)	把字典dict2的键/值对更新到dict⾥
dict.pop(key[,default])	删除字典给定键 key 所对应的值，返回值为被删除 的值。key必须指定。 否则返回default值。
dict.popitem()	随机返回并删除字典中的⼀对键和值。返回的是元组 类型。
dict.get(key,default=None)	返回指定键的值，如果值不在字典中返回default值
dict.fromkeys(seq,val)	创建⼀个新字典，以序列seq中元素做字典的键， val为字典所有键对应的初始值
dict.setdefault(key, default=None)	和get()类似, 如果键不存字典中，将添加键并将值设default。