1. 序列：一组按照顺序排序的值
2. 序列类型：字符串、元组、列表，字典不是序列
3. 优点：可以支持索引和切片的操作
4. 特征：第一个正索引为0，指向的是左端，第一个索引为负数的时候，指向的是右端
5. 切片：【高级特征】 可以根据下标来获取序列对象的任意{部分}数据
6. 语法结构：数据名[start:end:步长step]
一、字符串------不可变数据类型
# 字符串输出---可部分输出，也可以遍历（切片）
Test='python'
print(type(Test))
print('获取第一个字符%s'%(Test[0]))
print('获取第二个字符%s'%(Test[1]))
# for循环遍历
for item in Test: #i得到的是数据项，不是索引下标
print(item,end=' ')
name='peter'
print('首字母变成大写%s'%name.capitalize())
#去除空格
a=' Hello '
b=a.strip() # 删除两边的空格
print(b)
print(a)
print(a.strip())
print('删除左边的空格：%s'%a.lstrip())
print('删除右边的空格：%s'%a.rstrip())
#复制一个字符串（相当于赋值）
a='python'
b=a # 在此只是把a的内存地址赋给了b
print(b)
print('a的内存地址：%d'%id(a)) #id() 可以查看一个对象的内存地址
print('b的内存地址：%d'%id(b)) #b=a时，他们的内存地址一样
#查找某个字符存在不存在 .find() 或者 .index() 或者print(对象 in 字符串)----输出bool类型
datastr='I Love PythoPn'
print(datastr.find('o')) #.find() 查找目标对象在序列对象中 首次出现 的位置（从左到右）
print(datastr.find('m')) #如果没有找到的情况下，返回-1
print(datastr.index('L')) #.index() 查找目标对象在序列对象中 首次出现 的位置（从左到右）
print(datastr.index('m')) #index() 也可以用于检测字符串中是否包含字符
# .index() 没有找到时报错 .find() 返回-1
# 是否以X结束/开始 .startswith()/.endswith()
datastr='I Love PythoPn'
print(datastr.startswith('I')) #True
print(datastr.startswith('Io')) #False
print(datastr.endswith('n')) #True
# 大小写转换 .lower()/.upper()
datastr='I Love PythoPn'
print(datastr.lower())
print(datastr.upper())
strMsg='hello world'
# slice[start:end:step] 左闭右开 start<=value<end
print(strMsg) #输出完整数据
print(strMsg[0])
print(strMsg[2:5]) #输出2-5【下标】之间的数据，不包括5,234
print(strMsg[2:]) #输出2之后的内容，没有结束就不用写end
print(strMsg[0:3]) #输出【第一个（下标0）到第三（下标2）个字符】
print(strMsg[:3]) #strMsg[0:3]=strMsg[:3]
# 倒序输出
print(strMsg[::-1]) #负号 表示从右边开始输出，倒序
| .endswith()/.startswith() | 是否以X结束/开始 |
| .isalnum() | 判断是否是字母和数字 |
| .isalpha() | 判断是否是字母 |
| .isdigit() | 判断是否是数字 |
| .islower() | 判断是否是小写 |
| .join() | 循环取出所有值，用xx去连接 |
| .lower（）/.upper（） | 大小写转换 |
| .swapcase() | 大写变小写，小写变大写 |
| .lstrip()/.rstrip()/.strip() | 移除左右 两侧空白 |
| .split() | 切割字符串 |
| .title() | 把每个字母的首字母都变成大写 |
| .replace(old,new,count=None) | old被换字符串，new替换字符串，count换多少个，没有count全部换 |
| .count() | 统计出现次数 |
二、列表-----可变数据类型
list: python 当中非常重要的数据结构，是一种有序的数据集合 特点： 1.支持增删改查 2.列表中的数据是可以变化的【数据项可以变化，这个列表的内存地址不会改变-可变数据类型 3.用[ ]来表示列表类型，数据项之间用逗号分隔，注意：数据项可以是[任何类型的数据] 4.支持索引和切片来来操作 5. 可以通过for循环来遍历列表中的数据
# 定义一个列表
li=[1,2,3,'你好'] #这个列表 有四个数据项，整形和字符串
print(len(li)) #len()可以获取到列表对象中的数据个数
strA='我喜欢python'
print(len(strA))
print(type(li))
#---------for循环遍历 列表----------
listA=[1,2,3]
for item in listA:
print(item)
#----------增加-----------
#append() 追加列表--在列表结尾后继续加
listA=['abcd',785,12.23,'qiuzhi',True]
print('追加之前',listA)
listA.append(['fff','ddd'])
listA.append(6666)
print('追加之后',listA)
#.insert(下标位置,插入内容) 列表中插入数据
listA=['abcd',785,12.23,'qiuzhi',True]
listA.insert(1,'这是刚刚插入的数据') #插入操作 需要执行一个位置的插入
print(listA) #使新数据位于某个下标
#强制转换成list数据
listA=['abcd',785,12.23,'qiuzhi',True]
print(range(10))
rsData=list(range(10)) #强制转化为list数据
print(type(rsData))
# 让listA批量的 追加 列表对象rsData
# .extend() 拓展函数=批量添加
listA.extend(rsData)
print(listA)
listA.extend([1,2,3])
print(listA)
#--------查找：切片（在支持索引前提下）---------
listA=['abcd',785,12.23,'qiuzhi',True]
print(listA) #获取完整的列表
print(listA[0]) #输出第一个元素
print(listA[1:3]) #输出第二个元素到地三个元素
print(listA[1:5]) #从第二个元素开始输出到最后
print(listA[2:]) #从第二个元素开始输出到最后
print(listA[::-1]) #倒序输出
print(listA*2) #连续 多次 输出，相当于 [复制]
# -----------删除list数据项-----------
listB=list(range(10,50))
print('删除之前：',listB)
del listB[0] #删除列表中的第一个元素
print('删除之后：',listB)
del listB[1:3] #批量删除多项数据：删除列表中的第2、3个元素
print('删除之后：',listB)
listB.remove(20) #移除指定的元素20,不是下标20
print('移除之后：',listB)
listB.pop(1) #移除指定的项，指的是下标
print('移除之后：',listB)
# -----------修改-----------
listA=['abcd',785,12.23,'qiuzhi',True]
print('修改之前',listA)
listA[0]=333.6 #修改就是直接 重新赋值
print('修改之后',listA)
# -----------查找元素位置-----------
print(listB.index(19)) #查找元素位置,返回的是一个索引下标
print(listB.index(19,20,25)) #查19，从20开始查，查25个元素（查不到）
| .append() | 在列表后面追加【元素】，可多可少 |
| .insert() | 在指定位置插入，数字代表要替换的【下标】 |
| .extend() | 扩展，相当于批量添加【列表】 |
| .index(19) | 获取指定元素19的索引号【下标】 |
| .count() | 统计元素出现的次数 |
| del listB[0] | |
| del listB[1:3] | 批量删除多项数据 |
| .pop(1) | 移除指定索引下标的数据项 |
| .pop() | 删除最后一个元素 |
| .remove(20) | 移除指定的元素20,不是下标20 |
| .remove() | 移除左边找到的第一个元素 |
| .reserve() | 反转列表 |
| .sort() | 列表排序 |
| listA[0]=333.6 | 给列表中某一项重新赋值 |
三、元组------可变数据类型
1.是一种不可以修改、不可变的序列，不能做任何修改 2.用（） 创建元组类型，数据项用逗号来分割 3.可以是任何类型 4.当元组中只有一个元素时，要加上逗号，不然解释器会当作整形来处理 5.同样可以支持切片操作 6. 可以遍历(for)，读取，不能增删改 7.当元组中只有一个数据时，要在后边加 逗号，否则就是整形
# -------元组的创建---------
# 元组不能修改，不能对它进行 增删改，只能对他进行【查找，获取】
tupleA=() #空元组
print(type(tupleA))
#-------元组的查找-------
tupleA=('abc',89,9.12,'peter','[11,22,33]')
print(id(tupleA)) # 元组里的数据项不同，存储地址也不同
#-------for 遍历元组中的数据项-------
for item in tupleA:
print(item,end=' ')
print(tupleA[2]) #可以通过切片进行查找
print(tupleA[2:4])
print(tupleA[::-1]) # 倒序，隔一个取一个
print(tupleA[::-2]) # 倒序，隔两个取一个
print(tupleA[::-3]) # 倒序，隔三个取一个
print(tupleA[-2:-1:]) #从-2开始，到-1前结束
print(tupleA[-4:-2:])
#-------元组不支持修改-------
tupleA[0]='python' #重新赋值=修改:报错'tuple' object does not support item assignment
#-------可以对元组中的【列表】进行修改-------
tupleA=('abc',89,9.12,'peter',[11,22,33])
tupleA[4][0]=289384 #tupleA[4]是列表，可以修改
print(tupleA) #修改的是 元组 中的 列表里的数据项
print(type(tupleA[4]))
tupleB=(1,) # 当元组中只有一个数据时，要在后边加 逗号，否则就是整形
print(type(tupleB))
print(tupleB)
tupleC=tuple(range(10)) #强制转换为tuple类型
print(tupleC.count(8)) #统计元组中出现了几个 8
tupleC=(1,2,2,2,3,4,5,)
print(tupleC.count(2))四、字典--------可变数据类型
也是python中重要的数据类型，字典是有【键值对】组成的集合，通常使用键来访问数据，效率非常高，和list一样，支持对数据的增加、删除、修改。不是序列，被支持索引来切片
特点：
1.不是序列类型 没有下标的概念----不能用索引，是一个无序的 键值集合，是[内置的高级数据类型] 2.用{}来表示 字典对象，每个键值对用逗号分割
3.键 必须是不可变类型【元组、字符串、整形（一旦变化，存储地址变化，相当于另一个对象），但是不可以是列表，集合，字典。】 值 可以变化
4.每个键必须是唯一的，如果存在重复的键，后者会覆盖前者
# -----在字典里添加数据-------
dictA={'pro':'艺术','school':'北京电影学院'}
dictA['name']='李易峰' #键key：name value：李易峰,输出：{'name': '李易峰'}
dictA['age']=30
dictA['pos']='歌手'
print(len(dictA))
print(dictA) #输出完整的字典
#----- .update(键值对) 更新某个键的值/增加键值-------
#.update() 函数用于【更新】键的值 或者 【增加】新的键和值
dictA.update({'age':'32'}) #修改age的值
print(dictA)
dictA.update({'height':178}) #增加键值 {’heiht‘：178}
print(dictA)
#-----通过键获取完整的值-------
#数据项的查找（用键来获取对应的值）
print(dictA['name']) #通过键获取完整的值
#-----修改键对应的值-------
dictA['name']='谢霆锋' #修改字典键name对应的值
print(dictA)
dictA['school']='香港大学'
print(dictA)
#-----获取某个键、值或者所有键和值-------
获取所有的键
print(dictA.keys()) # .keys()
获取所有的值
print(dictA.values()) # .values()
获取所有的键和值
print(dictA.items())
for item in dictA.items():
print(item)
for key,value in dictA.items():
print('%s==%s'%(key,value))
#-------------删除----------------
del dictA['name']
print(dictA)
dictA.pop('age')
print(dictA)
#------对字典进行排序-----
print(dictA)
# 按照键key来排序
print(sorted(dictA.items(),key=lambda d:d[0]))
# dictA.items()指所有数据（键和值），按key排序，
# 按照键value来排序
print(sorted(dictA.items(),value=lambda d:d[0])) #报错，值的类型不一致五、字符串、列表、元组、字典 共有方法（ + * in）
#-------------字符串合并---------
strA='人生苦短'
strB='我爱python'
print(strA+strB)
#-------------列表合并------------
listA=list(range(10))
listB=list(range(10,20))
print(listA+listB)
#-------------元组合并-------------
tupleA=(1,2,3,4)
tupleB=tuple(range(10,16))
print(tupleA+tupleB)
#—-------------字典合并(不支持)-------------
dictA={'one':1,'two':2,'three':3}
dictB={'seven':7,'ten':'pyhton'}
print(dictA+dictB)
#-------------复制 *-------------
strA='人生苦短'
listA=list(range(10))
tupleA=(1,2,3,4)
dictA={'one':'1','two':'2','three':'3'}
print(strA*3)
print(listA*3)
print(tupleA*3)
print(dictA*3) #不支持
#---------- in 判断对象是否存在,结果是bool类型的值------
strA='人生苦短'
print('生'in strA) #true
print('我'in strA) #false
listA=list(range(10))
print(22 in listA) #false
dictA={'name':'peter'}
#判断键
print('age'in dictA) #判断键false
print('name'in dictA) #true
929
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
