高级数据类型
在python中，序列就是一组按照顺序排列的值，序列也可以称作为数据集合
在python中有三种内置的序列类型：字符串，列表和元组
序列的特点：可以支持索引和切片的操作，第一个正索引为0，指向的是左端；第一个正索引为负数时，指向的
是右端；切片是指截取字符串中的一段内容，切片的基本语法：[起始下标：结束下标：步长]
字符串String
字符串：字符串是以引号括起来的任意文本，引号可以是单引号('') 双引号("") 三引号(''' ''')，三引号可以表示多行文本，如果字符串本身包含了单引号，我们可以用双引号将其括起来，反之如果本身包含了双引号我们可以用单引号将其括起来，如果既有单引号又有双引号，我们就用三引号括起来
字符串与列表都可以看成容器，有顺序的容器称为序列，列表和字符串都称为为序列，序列可以做加法，也可以和一个整数相乘。相加和相乘不会改变容器的本身，会创造一个新的容器存放。字符串本身不能被修改，只能将改动的字符放入另外一个字符串中。
常见的转义字符
\'(单引号)\b(退格)\r(回车)\n(换行)
字符串运算符
+连接字符串'hello'+'world'='helloworld'- ``*
复制字符串'ab'*3='ababab'` in成员运算符，如果字符串中包含字符，返回True
字符串索引与切片
字符串是一个有序序列，可以正向递增也可以反向递减
索引：在[]中给出序号
切片：在[]中给出切片序号范围：
string_name[start_index : end_index : step]start_index去掉表示从头开始，不需要写0；end_index去掉表示取到字符串的最后一个字符从左到右索引默认从0开始，最大范围是字符串长度少1；从右到左索引默认从-1开始，最大范围是字符串开头
如 字符串
s="abcdefgh"
s[0]='a's[-1]='h's[1:5]='bcde'5是取不到的，左闭右开
s1='123' s1[1]=2 方括号里面是数是元素的编号，列表也一样
第一个元素是第零号 最后一个是-1号
修改元素：t1[0]=4 但是字符串是不可以修改的类型，仅对于列表适用
序列函数
对于：s1='123'
len(s1)=3表示字符串长度len()对于字符串和列表都适用min()得到序列里面最小的元素。对于字符串和列表都适用max()得到序列里面最大的元素。对于字符串和列表都适用id(s1)表示字符串s1的内存地址
字符串的相关函数
字符串相关函数的调用一般是通过，字符串.函数 进行使用的，字符串常用的函数如下所示：
| 函数 | 描述 | 相关案例 |
|---|---|---|
count() | 统计某字符出现的次数 | s.count('aaa') 返回s字符串里面aaa元素的个数 |
capitalize() | 将字符串的首字母变成大写 | s = "What is Your Name?" s.capitalize() 结果为： 'What is your name?' |
title() | 将每个单词的首字母大写 | s.title() 结果为： 'What Is Your Name?' |
swapcase() | 将字母的大小写互换 | s.swapcase() 结果为： 'wHAT IS yOUR nAME?' |
lower() | 将字符串全部变成小写 | s=s1.lower() 将s1里面字符串所以的字符变成小写写到s里面。但是s1不会修改，因为所有的字符串都不能被修改。 |
upper() | 将字符串全部变成大写 | s.upper() 返回大写字符串，将小写变成大写 |
strip() | 将字符串两边的空格(空白字符包括空格、制表符(\t)、换行(\n)、回车(\r）等)去除，中间的不管 | s=' Hello World ' 调用s.strip() 结果为：'Hello World' |
rstrip() | 将右边的空格和空白字符去掉，中间的不去掉 | s.rstrip() 结果为：' Hello World' |
lstrip() | 将左边的空格和空白字符去掉，中间的不去掉 | s.rstrip() 结果为：'Hello World ' |
find() | 查找某字符是否在字符串中 | s.find('aaa') 返回aaa在s字符串第一次出现的位置，找不到返回-1,若有多个a，就给出从左边给出的第一个位置。s1.find('a',3) 3表示从字符串a中的第4个字符开始找 |
rfind() | 查找某字符在字符串中最后出现的位置 | s.rfind('aaa') 返回aaa在s字符串最后一次出现的位置，如果不存在则返回-1 |
index()和rindex() | 查找某字符的出现位置 | 两种方法用来返回一个字符串在另一个字符串中首次和最后一次出现的位置，如果不存在则抛出异常(报错)； |
startswith()和endswith() | 是否以某个字符/字符串开头/结尾 | 输出是一个bool类型的数据；s = 'Beautiful is better than ugly.' s.startswith('Be') 检测整个字符串，返回True |
strip() | 删除指定字符串 | "aaaassddf".strip("a") 删除指定字符'a' 结果'ssddf' |
replace() | 取代字符串中的某个部分 | s.replace(' ','-') 将s里面的空格替换成减号。前面的是被替换的，后面的是替换物。字符串修改都不会对原先的字符串进行改变，都会产生新的字符串 |
split() | 切割字符串 | split() 方法分别用来以指定字符为分隔符，把当前字符串从左往右分隔成多个字符串，并返回包含分隔结果的列表 |
字符串的常用判断方法：
isalnum()、isalpha()、isdigit()、isnumeric()、isspace()、isupper()、islower()，用来测试字
符串是否为数字或字母、是否为字母、是否为数字字符、是否为空白字符、是否为大写字母以及是否为小写字母
字符串与数字之间的转化
数字转化为字符串：使用全局函数str()，str(123) 得到一个字符串'123'
%字符串的格式化运算符：'I am %d years old and weight %.2f kg.' %(18,60.334)
得到'I am 18 years old and weight 60.33 kg.'
%10d 表示数字前面有10个空格
列表 List
列表用[]标识，数据项之间用逗号来分隔，数据项支持字符、数字、字符串甚至可以包含列表
List是一种有序的集合，可以随时添加和删除其中的元素，支持增删改查，列表中的数据项是可以变换的，但其内存中的地址不会改变
列表支持索引和切片来进行对数据的操作
每个列表对象里的元素的数据类型可以相同，也可以不同。用[]括起来，用逗号进行分割
list()函数，将字符串展开成列表，包括中间的空格t1=[1,2,3]创造了一个列表[1,2,3]t2=t1t2也指向了这个列表t2[0]=0t2变成了[0,2,3], t1也变成了[0,2,3]，列表变量是列表的管理者，不是所有者，t2=t1表示让
t2去管理t1管理的列表要想产生一个新的列表，用切片：
t2=t1[:]t2就指向新的列表，这样就将t2和t1分开了，在t2上任何修改与t1都没有关系del t[2]将列表t的2号元素删除。列表遍历：
for i in t1i变量依次取列表t1中的每个元素
列表的相关函数
cmp(list1,list2)比较两个列表的元素len(list)列表元素的个数list(seq)将元组转换为列表
元素的增加
| 函数 | 描述 | 相关案例 |
|---|---|---|
append() | 在列表后面追加元素 | t1.append(5) 往列表最后面加入元素5，t1.append([4,5]) 得到[1,2,3,[4,5]] |
extend() | 拓展，批量添加元素 | t1.extend([7,8,9]) 将列表[7,8,9]加到t1列表后面，t1.extend([4,5]) 得到[1,2,3,4,5] |
insert() | 指定索引值前面加上元素 | t1.insert(1,9) 在t1列表原来索引值为1号前面加上元素9，当insert的下标超过数字标号，就会将9添加到列表最后 |
元素的修改
去列表中要修改的元素的下标，直接进行新值的赋值修改
list[n] = N n表示要修改的元素的下标，N表示修改的内容，N可以是不同的数据类型
元素的删除
| 函数 | 描述 | 案例 |
|---|---|---|
del | 删除元素 | del t[2] 将列表t的索引值为2的元素删除；del t[0:2] 删除索引值为0和1的元素；del t 删除整个列表，如此后仍使用t时，则出现“NameError”的异常 |
remove() | 删除列表中首次出现的） 元素 | t1.remove(2) 删除值为2的元素：list1 = ["北京市", "上海市", "天津市","重庆市", "天津市"] list1.remove('天津市') 删除第一次出现的元素'天津市'，删除后list1的元素值为：['北京市', '上海市', '重庆市', '天津市'] |
pop() | 根据索引值删除并返回对应位置的元素 | t1.pop() 弹出某个元素 ()里面是序列号，弹出之后这个元素不在列表里面了，这和t1[3]不同 |
元素的分隔
partition() 用来以指定字符串为分隔符将原字符串分隔为3部分，即分隔符前的字符串、分隔符字符串、分隔符后的字符串，如果指定的分隔符不在原字符串中，则返回原字符串和两个空字符串。
s = "apple,peach,banana,pear"
s.partition(',')
('apple', ',', 'peach,banana,pear')元素的查找和排序
列表元素的查找：
t1.index(9) 查找元素9在哪个位置上 查找单个元素第一次出现的位置。与字符串find相似 random.choice(t1) 随机在列表t1中选择一个元素
S = [1,2,3,4,5,6,7,8]
for index,i in enumerate(S):
print(index,i) # index和i变量依次取列表S中的索引和对应的元素。列表元素的排序：
| 函数 | 描述 | 案例 |
|---|---|---|
reverse() | 颠倒列表中元素的顺序 | t1.reverse() |
成员函数sort()和内置sorted()对列表元素进行排序：
其语法格式为：
list_name.sort/sorted(key=None, reverse=False)sort()会改变原列表的元素的排列顺序sorted()会建立一个原列表的副本，该副本为排序后的列表，而原列表保持不变list2=sorted(list1)建立一个原列表的副本list2，该副本为排序后的列表，而原列表不变
key表示指定从每个元素中提取一个用于比较的键，默认值为Nonereverse表示排序方式，默认为升序排列：list1.sort()表示升序list1.sort(reverse=True)表示降序
字符串与列表之间的转换
字符串转为列表
split() 函数
用于将字符串中按照特定的元素分隔成列表
s = "this is a test"
s.split()
# 得到['this', 'is', 'a', 'test']split()没有参数，就用空格作为分隔符，则字符串中的任何空白符号（空格、换行符\n、制表符等）都将被认为是分隔符，把连续多个空白字符看作一个分隔符。
a = "12::35"
a.split('::') # 得到['12', '35']
a.split(':') # 得到['12', '', '35'] ::之间默认有空格list()函数
将字符串完全展开成列表，包括中间的空格。 list(s) 得到：['t', 'h', 'i', 's', ' ', 'i', 's', ' ', 'a', ' ', 't', 'e', 's', 't']
将列表转化为字符串
join()函数
将列表转换为字符串，字符串连接
t = ['this', 'is', 'a', 'test']
' '.join(t) # 用空格连接
# 得到: "this is a test"小技巧：使用split()和join()方法可以删除字符串中多余的空白字符，如果有连续多个空白字符，只保留一个，例如：
x = 'aaa bb c d e fff '
' '.join(x.split())元组Tuple
()将多个元素存放在一起，多个元素之间用英文逗号界开。与列表几乎差不多，元组用()，元组是一种不可修改的数据，元组可以通过下标进行访问
用途：不想要拿到方可以修改列表，就使用元组
元组中的元素可以是任何的类型，当元组中只有一个元素时，要加上逗号，不然解释器会当做整形来处理，如果相邻的值用逗号隔开，但是没有圆括号，python也会认为他们是元组。
返回元组中某项（第三项）的数据类型：type(tupleA[3])
可以对于元组中的列表数据类型的数据进行修改：tupleA[3][0] = 12，如元组中的第四项是一个列表数据类型，我们可以对其列表的第一项进行修改
元组的创建
t1 = tuple() # 创建名为t1的空元组
t1 = () # 创建名为t1的空元组，与t1=tuple()等价元组的操作和列表相似，但是元组不能进行修改，因此元组不能进行增删改操作，只能对元组进行查找，对于元组中元素的查找，还是主要通过切片操作进行
如果元组中的数据项只有一个，我们在创建的时候必须在第一项后面加上一个逗号，如 t1 = (123,)这样才能视为一个元组类型
对元组进行重新赋值/创建，前后两次的内存空间是不一样的
元组的函数
- 统计元组中某个元素出现了多少次：
count() - 查找指定元素的下标索引：
index()
列表转化为元组
tuple()函数
p=tuple(t) p为元组，t为列表
元组的基本操作同列表类似，唯一不同之处在于元组是不可变数据类型，即不能对元组进行增加、删除、修改和排序等操作，否则会发生“TypeError: ‘tuple’ object does not support item assignment”的异常
当一个元组中包含多个元素时，可采用解包操作将每个元素赋给不同的变量，例：
tuplea=('zhangsan',18,'nan')元组中包含三个元素name,age,sex=tuplea通过解包操作将不同的元素赋给不同的变量
此时，name,age,sex分别被赋值为'zhangsan',18,'nan'。这种操作经常用作函数参数传递时，多参数返回值的情况
字典Dictionary
字典{}是将多个形如“键:值”的元素放在一对英文大括号中，多个元素之间用英文逗号界开{ 键1 : 值1, 键2 : 值2, …… }的高级数据类型。其中：
- 键名不可修改，只有不可变的数据可以充当；而键值是允许修改的，任何类型的数据可以充当键
- 键名具有唯一性，字典中不允许出现相同的键名，但是不同的键名允许对应相同的键值
- 字典中的键名必须是不可变的类型，一般是字符串、数字或者元组；而键值却可以是任何数据类型
- 如果在字典的定义中确实需要使用多个子元素联合充当键，则需要使用元组
- 如果出现重复的键，后者会覆盖前者
当我们在字典中去查找元素时，我们通过键去进行查找，键的方法进行查找的效率非常高
字典和列表一样，是可以进行改变的，可以进行增删改查操作
字典不能进行索引，一般通过键去访问，所以键不能重复，键只能是不可变类型，如数字，字符串和元组
字典是一个无序的键值组合，是python中内置的高级数据类型
len() 返回字典中键值对的对数
获取字典中所有的键：dictA.keys() 获取字典中所有的值：dictA.values()
获取字典中所有的数据项(键值对)：dictA.items() 输出结果是元组
字典的产生方法
# 两种方式创建空字典
dict1 = {}
dict1 = dict()
keys = ['name','age','xingbie']
values = ['zhou ming',18,'nan']
dict2 = dict(zip(keys,values)) # 利用zip()函数来生成（键，值）数据对
dict2['name'] = 'zhou ming'
dict2['age'] = 18
dict2['xingbie'] = 'nan'
dict2 = dict('name':'zhou ming','age':18,'xingbie':'nan')
dict2 = dict(name='zhou ming',age=18,xingbie='nan')
dict2 = dict([('name','zhou ming'),('age',18),('xingbie','nan')])字典的增删改查操作
增加元素
dictb = {'name':'zhou ming','age':18,'xingbie':'nan'}
dictb['chengji'] = 88 # 增加了一个’chengji’键，其对应的值为88
print(dictb)
# 输出结果为：{'name': 'zhou ming', 'age': 18, 'xingbie': 'nan', 'chengji': 88}
# 方法二：
dictA.update({'age':32}) # 值不存在就是一个添加的操作修改元素
dictb['chengji'] = 91 # 将’chengji’修改为新的值91
dict1['1'] = 111
# 如果1条目存在，就修改里面的值，如果1条目不存在就加一个条目。
#方法二：
dictA.update({'age':32}) #值存在就在一个修改的操作删除元素
利用del dictA[键] 的方法删除对应的键及其值
del dict1['1'] # 将键为1的条目删除利用pop()删除某键对应的元素：
dictb.pop('chengji') # 删除键为’chengji’的元素，同时返回91
print(dictb)
# 输出结果为：{'name': 'zhou ming', 'age': 18, 'xingbie': 'nan'} #可看到键为’chengji’的元素已被删除利用clear()方法将字典中的所有元素都删除：
dictb.clear() # 将所有元素删除掉
print(dictb) # 输出结果为：{}查找元素
打印字典对象可以输出完整的字典，通过键，可以去获取相对应的值
键值对被称为字典的条目item、字典中的元素是无序的，不能通过索引来访问，只能通过键名来访问。
dict1 = {"jiangsu":"nanjing","zhejiang":"hangzhou"}
print(dict1["jiangsu"]) # 输出结果为：nanjing
dict1 = {1:"fer",2:"eddcv",3:56} # 冒号前面为键，后面为值。逗号隔开为字典不同的条目。
print(dict1[1]) # 得到fer通过get()方法来访问键值，语法格式：字典名.get(键) ，get方法按照指定的“键名” 访问字典中对应条目，并返回其对应的“值”； 如果指定的“键名”在字典中不存在，则返回None
dict1 = {"jiangsu":"nanjing","zhejiang":"hangzhou"}
print(dict1.get("jiangsu")) # 输出结果为：nanjing
print(dict1.get("hubei")) # 输出结果为：None字典的遍历
dictb.keys()获取字典中的所有键名dictb.values()获取字典中的所有键值dictb.iterms()获取字典中的所有条目
对于字典来说，做for循环，我们实际上在遍历它的键。通过得到的键，我们可以访问他的值。
dict1 = {1:"fer",2:"eddcv",3:56}
for i in dict1.keys(): # 得到键名
print(i)
# 得到：1
# 2
# 3
for i in dict1.values(): # 得到键值
print(i)
# 得到："fer"
# "eddcv"
# 56
for i in dictk.items(): # 得到条目
print(i)
# 得到：(1, 'fer')
# (2, 'eddcv')
# (3, 56)min(dictb)得到字典dictb最小那个键名，max(dictb)得到字典dictb最大那个键。
字典的排序
通过python中内置的函数sorted()进行排序，对字典中的值进行排序，排序会按照ASCILL码进行排序
排序选择：对于键和值，哪个排序有意义就选择哪个进行排序
字典排序，对于选择作为排序的指标的数据类型需要保持一致，不然会报错
按照键进行排序
sorted(dictA.items(), key=lambda d:d[0])
d[0]表示按照键的ASCILL码进行排序，键的第一个字母的ASCILL码小的在前
按照值进行排序
sorted(dictA.items(), key=lambda d:d[1])
d[1]表示按照值的ASCILL码进行排序，值的第一个字母的ASCILL码小的在前
集合Set
集合里面的值不能重复，如果输入重复的只会保留一个。输入没有顺序的数，会输出从小到大有序的数。集合的顺序不能由程序员来指定。集合是无序的容器
产生集合的方法：
seta = set() # 定义一个空集合
print(seta) # 输出结果为：set()集合的常用方法
去掉列表里面重复的数，集合是不能存在重复的数：
list1 = [1,2,3,4,1,2]
print(set(list1))
setc = set('abcdcba') # 利用字符串生成集合
print(setc) # 输出结果为：{'a', 'd', 'c', 'b'}添加元素
s = {1,2,3,4,5}
s.add(0)
# 得到：{0,1,2,3,4,5}删除元素
删除元素的方法有：
remove()pop()discard()
seta = {1,2,3}
seta.remove(1)
# 得到: {2,3} 直接将集合里面的1值删掉。
m = seta.pop() # 弹出集合seta里面任意一个元素，若无元素，显示异常。
seta.discard(1)
# 得到: {2,3} 直接将集合里面的1值删掉。和remove()相似。
seta.clear() # 移除集合seta所有元素- 集合的对象是不能取下标的，如
s[0]是错误的 - 可以用
for循环来遍历集合 <在集合里面表示真子集<=在集合里面表示子集- |表示并集，将两个集合取并集
- &表示交集，将两个集合取交集
s1-s2表示从s1里面去掉在s2里面存在的东西。
统计长度
len(seta) 统计元素个数
高级数据类型的公有方法
- 连接字符串，列表和元组，可以使用+来进行连接
- 复制字符串，列表和元组，可以使用*来进行复制
- 判断某元素是否存在在字符串，列表，元组和字典（判断某个键是否存在）中，可以用in来进行查找，返回
bool类型的数据