Python#Day 3

高级数据类型

1.字符串及常用方法
2.列表及常用方法
3.元组
4.字典及常用方法
5.共有操作

序列：在python中，序列就是一组按照顺序排列的值。
python中存在三种内置的序列类型：字符串，列表和元组。
特点：第一个正索引为0，指向左端，第一个索引为负数指向右端。

字符串及常用方法

1.字符串有下标，每个字符对应一个下标，下标从0开始，从左往右依次增大。

切片：截取字符串的其中一段内容，使用语法[起始下标：结束下标：步长] 步长默认为1
下标会越界，切片不会，下标越界了会报错，切片不越界所以没有数据返回，但不会报错
示例：切片 左闭右开

#用下标截取内容
Test='python'
print('获取第一个字符%s'%Test[0])
print('获取第二个字符%s'%Test[1])
print('获取前三个字符%s'%Test[0:3])
print(Test[2:]) #第三个字符到最后
print(Test[0:3]) #1-3 Test[0:3]=Test[:3]
print(Test[::-1])#倒叙输出，符号表示方向

切片用-1倒叙输出时，时从右往左，数据项的下标由-1开始，从右往左依次递减
尽管是倒叙输出，依然遵循左闭右开的集合原则

示例① 首字母大写

name='peter'
print('姓名首字母大写%s'%name.capitalize())

示例②——复制字符串

#复制字符串
a='hello'
print('a的内存地址%d'%id(a)) #id 函数，可以查看一个对象的内存地址
b=a #在此只是把a对象的内存地址负值给了b
print('b的内存地址%d'%id(b))
print(b)

示例③删除空格

a='       hello     '
b=a.strip()  #去除字符串中的空格
print(a)
print(b)
print(a.lstrip()) #删除左边的空格

示例④查找内容

#查找内容
dataStr='I love PyhPton'
print(dataStr.find('Py')) #find函数可以查找对象所在位置(从左往右)，返回第一个找到对象的下标值，如果目标不存在则返回-1
print(dataStr.index('Py'))#检测字符串是否包含子字符串,返回的是下标值
#index如果没有找到对象数据，便会报错，而find函数不会，找不到返回-1

示例⑤join 是什么加入什么

seq=('a','b','c','d')
str='.'
print(str.join(seq))

注意 int数据没有join属性，只有字符串才有。

示⑥分割
语法

str.split(str="", num=string.count(str))

str – 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。
num – 分割次数。默认为 -1, 即分隔所有。

str='I love python'
print(str.split(' ')) 

注意 用作分割的对像必须是字符串拥有的才行

列表及常用方法

①创建一个列表，只要把逗号分隔的不同的数据项，而后使用方括号括起来即可。
②列表的下标取值/切片/是否越界与字符串一致，区别就是列表是获取元素。
③用for循环可以遍历列表。
特点
①支持增删改查
②列表中的数据是可以变化的【数据项可以变化，内存地址不会改变】
③用[ ]来表示列表类型，数据项之间用逗号分割。数据项可以是任何类型的数据
④支持索引和切片来进行操作

示例①增加

#增加
listA=['abcd',785,12.23,'ksdfs',True]
print('追加之前',listA)
listA.append('999')
print('追加之后',listA)
listA.insert(1,'这是我刚刚插入的数据') #插入操作 需要指定一个位置
print(listA)
rsData=list(range(10)) #强制转换为list对象
listA.extend(rsData) #拓展，等于批量增加。
listA.extend([11,23,415,6])

output

追加之前 ['abcd', 785, 12.23, 'ksdfs', True]
追加之后 ['abcd', 785, 12.23, 'ksdfs', True, '999']
['abcd', '这是我刚刚插入的数据', 785, 12.23, 'ksdfs', True, '999']

注意append和extend的区别

#extend and append
listA=['a','b','c']
listB=['a','b','c']
listA.append([1,2,3])
listB.extend([1,2,3])
print('listA=',listA)
print('listB=',listB)

输出结果

listA= ['a', 'b', 'c', [1, 2, 3]]
listB= ['a', 'b', 'c', 1, 2, 3]

append只是在列表末尾增加一个数据项，而extend是将多个数据项和原始列表合二为一

示例②修改

#修改
listA=['abcd',785,12.23,'ksdfs',True]
print('修改之前',listA)
listA[0]='peter'
print('修改之后',listA)

Output

修改之前 ['abcd', 785, 12.23, 'ksdfs', True]
修改之后 ['peter', 785, 12.23, 'ksdfs', True]

如果用切片进行修改

listA=['abcd',785,12.23,'ksdfs',True]
print('修改之前',listA)
listA[0:2]='peter'
print('修改之后',listA)

结果

修改之前 ['abcd', 785, 12.23, 'ksdfs', True]
修改之后 ['p', 'e', 't', 'e', 'r', 12.23, 'ksdfs', True]

会把字符串拆成单个字符，替换对应的切片数量，比如[0:2]就是前两个被替换，但是被拆分字符串无论替换几个都会显示所有
示例③删除

# #删除
listB=list(range(1,5))
print('修改之前',listB)
#删除列表的第一个元素
del listB[0] 

#批量删除多项数据
del listB[1:3] 

#移除指定的元素，参数是具体的数据值
listB.remove(2) 
#print(listB.remove(2)) 错的

#删除指定的项 参数是索引值
listB.pop() #不加参数默认删除最后一个数
listB.pop(1) 
#print(listB.pop(1)) #这么写是错的

元组

是一种不可变的序列，在创建之后不能做任何的修改

1.特点
①不可变
②用( )创建元组类型，数据项用逗号类分割
③可以是任何的类型
④元组中只有一个元素时，要加上逗号，不然解释器会当作int或str来处理
e.g.错误操作

tupleB=(1)
print(type(tupleB))
<class 'int'>

⑤同样可以支持切片操作

2.补充：可以对元组中的列表进行修改
示例

tupleA=('abcd',89,9.12,'peter',[11,22,33])
tupleB=tuple(range(1,10)) #如果使用range，前面一定要加tuple，否则不是元组
tupleA[4][0]=212321 #可以对元组中的列表类型的数据进行修改
print(tupleA)

Output

('abcd', 89, 9.12, 'peter', [212321, 22, 33])

3.元组的内置方法
count 统计元素在元组中出现的次数
index 查找指定元素在元组中的位置

字典

可包含任何数据类型，有键值对组成的基和，通常使用键来访问数据，效率非常高，和list一样，支持对数据的添加、修改、删除，
特点
①不是序列类型，没有下标的概念，是一个无序的 键值集合
②用{ } 来表示字典对象，每个键值对用逗号分割
③键 必须是不可变的类型【元组、字符串】 值 是可以任意的类型
④每个 键 必定是唯一的，如果存在重复的 键，后者会覆盖前者

示例：创建字典

dictA={} #空字典
#统一设定键值对
dictA={'pro':'艺术','school':'北京电影学院'}
#分开设定键值对
dictA['name']='李易峰'
dictA['age']=30
dictA['pos']='歌手'
print(dictA)

Output

{'pro': '艺术', 'school': '北京电影学院', 'name': '李易峰', 'age': 30, 'pos': '歌手'}

示例：修改

#修改
dictA['name']='谢霆锋'
dictA.update({'age':32}) #可以添加也可以更新
print(dictA)

示例：提取键和值

# 统一设定键值对
dictA = {'pro': '艺术', 'school': '北京电影学院'}
# 分开设定键值对
dictA['name'] = '李易峰'
dictA['age'] = 30
dictA['pos'] = '歌手'
print(dictA)  # 输出完整的字典
print(dictA['name'])  # 通过键获取对应的值

# 获取所有的键
print(dictA.keys())
# 获取所有的值
print(dictA.values())
# 获取所有的键和值
print(dictA.items())
for key,value in dictA.items():
    print('%s==%s' % (key, value))

Output

{'pro': '艺术', 'school': '北京电影学院', 'name': '李易峰', 'age': 30, 'pos': '歌手'}
李易峰
dict_keys(['pro', 'school', 'name', 'age', 'pos'])
dict_values(['艺术', '北京电影学院', '李易峰', 30, '歌手'])
dict_items([('pro', '艺术'), ('school', '北京电影学院'), ('name', '李易峰'), ('age', 30), ('pos', '歌手')])
pro==艺术
school==北京电影学院
name==李易峰
age==30
pos==歌手

示例：删除

#删除操作
del dictA['name']
dictA.pop('age')

示例：排序

dictB={'A':1,'B':2,'C':3,'D':4,'E':1.2,'F':3.11}
#如何排序 按照key排序 根据ACSII码排序
print(sorted(dictB.items(),key=lambda d:d[0]))
#按照value排序 str和int 没法一起排序
print(sorted(dictB.items(),key=lambda d:d[1]))

Output

[('A', 1), ('B', 2), ('C', 3), ('D', 4), ('E', 1.2), ('F', 3.11)]
[('A', 1), ('E', 1.2), ('B', 2), ('C', 3), ('F', 3.11), ('D', 4)]

公有操作

1.合并操作 +
将两个对象拼在一起
2.复制 *
对象自身按指定次数复制
3.in 判断对象是否存在指定数据集中

示例

#合并 适用于字符串，列表和元组
#字符串合并
strA='人生苦短'
strB='Python'
print(strA+strB)

#列表合并
listA=list(range(10))
listB=list(range(11,20))
print(listA+listB)

#复制 适用于字符串，列表和元组
print(strA*3)

#in 判断对象是否存在 结果是一个bool值 适用于字符串，列表，元组和字典
print('生' in strA)