Python【第三天】序列、字典与集合

总体描述

序列：在Python中，序列就是一组按照顺序排列的值【数据集合】
在Python中 存在三种内置的序列类型：
字符串、列表、元组

字符串操作

优点：支持索引和切片操作
特征：第一个正索引为0，索引指向的是左端，第一个索引为负数，指向的是右端
切片：【高级特征】可以根据下标获取序列对象的任意[部分]数据
语法结构：[start : end : step]step默认为1，若切片越界，切片不会报异常
截取的内容不包括结束下标对应的数据
len(x) #字符串x的字符个数
capitalize() #首字母变大写
endswith/startswith() #是否 x结束/开始
find() #检测x是否在字符串中
isalnum() #判断是否是数字或者字母
isalpha() #判断是否是字母
isdigit() #判断是否是数字 ‘abc123’.isdigit()
islower() #判断是否是小写
join() #循环取出所有值用x去连接
lower/upper() #大小写转换
swapcase() #大写变小写，小写变大写
lstrip/rstrip/strip #移除左/右/两侧空白
split() #切割字符串
title() #把每个单词的首字母变成大写
replace(old,new,count=None) #old：被换字符串，new：替换字符串，count：换多少个。无count表示全部替换
count() #统计出现的次数

# Test = 'Python'
# print(type(Test))
# print("获取第一个字符串%s"%Test[0])
# print("获取第二个字符串%s"%Test[1])
# for item in Test:
#     print(item,end='')
Test = 'helloworld'
print("Test：%s"%Test)
print("Test的内存地址:%d"%id(Test))
print("Test首字母变大写为:%s"%Test.capitalize())  #首字母变大写
print("Test是否以H开始:%s"%Test.startswith(' '))  #是否 x开始
print("Test是否以!结束:%s"%Test.endswith('!'))  #是否 x结束
print("'o'在Test中的下标为:%s"%Test.find('o'))  #检测o在字符串第几位，返回下标值，如果没找到，返回-1
print("'o'在Test中的下标为:%s"%Test.index('o'))  #检测o在字符串第几位，返回下标值，如果没找到，报错
print("Test是否为数字或者字母:%s"%Test.isalnum())  #判断是否是数字或者字母
print("Test是否为字母:%s"%Test.isalpha())  #判断是否是字母
print("Test是否为数字:%s"%Test.isdigit())  #判断是否是数字
print("Test是否为小写:%s"%Test.islower())  #判断是否是小写
# print("循环取出Test所有值，用+连接:%s"%Test.join('+'))  #循环取出所有值用+去连接
print("Test转换为大写:%s"%Test.lower())  #转换为大写
print("Test转换为小写:%s"%Test.upper())  #转换为小写
print("Test大小写相互转换:%s"%Test.swapcase())  #大写变小写，小写变大写
print("移除Test左侧空白:%s"%Test.lstrip())  #移除左侧空白
print("移除Test右侧空白:%s"%Test.rstrip())  #移除右侧空白
print("移除Test两侧空白:%s"%Test.strip())  #移除两侧空白
print("以'o'切割Test:%s"%Test.split('o'))  #切割字符串
print("Test每个单词首字母变大写:%s"%Test.title())  #把每个单词的首字母变成大写
# print("将Test中'!'替换为'~':%s"%Test.replace('w','W',count=None))  #old：被换字符串，new：替换字符串，count：换多少个。无count表示全部替换
print("Test中'o'出现的次数:%s"%Test.count('o'))  #统计出现的次数
print("输出Test中第三个到第五个字符串:%s"%Test[3:6:1])  #输出Test中第三个到第五个字符串
print("输出Test倒序的字符串:%s"%Test[::-1])

列表操作

Python中非常重要的数据结构，也是一种有序的数据集合
特点：
1.支持增、删、改、查
2.列表中的数据是可以变化的【数据项是可以变化的，内存地址不会改变】
3.用[]表示列表类型，数据项之间用’,'分割，注：数据项可以是任何类型的数据
4.支持索引和切片来进行操作
len(x) #列表x的数据项个数
append() #在列表后追加元素
count() #统计元素出现的次数
extend() #扩展，相当于批量添加
index() #获取指定元素索引号
insert() #在指定位置插入
pop() #删除最后一个元素
remove() #移除左边找到的第一个元素
reverse() #反转列表
sort() #列表排序 reverse = True

li = []
li = [1,2,3,3,'你好']
print("长度：%d"%len(li))  #获取列表中对象的数据个数
print("类型：%s"%type(li))
print("内容：%s"%li)  #输出完整列表
print("输出下标为1的列表元素：%s"%li[1])  #输出下标为1的列表元素
print("输出第二项到第三项的列表元素：%s"%li[1:3])  #输出第二项到第三项元素
print("倒序输出li列表的数据项：%s"%li[::-1])  #倒序输出li列表的数据项
print("输出三次列表中的数据项：%s"%(li*3))  #输出三次列表中的数据项[复制]
print("在Test追加元素'7'：%s"%li.append(789))  #在列表后追加元素
print(li)
print("统计'3'在Test中出现的次数：%s"%li.count(3))  #统计元素出现的次数
print(li)
print("扩展Test：%s"%li.extend([456,789,369]))  #扩展，相当于批量添加
print(li)
print("在Test中，获取'2'的索引号：%s"%li.index(2))  #获取指定元素索引号
# index(x,start,end):从列表下标为start到end查找数据项为x的下标值
print(li)
print("在Test中3的位置插入数据项'99'：%s"%li.insert(4,99))  #在位置4插入99
print(li)
li.pop()  #pop(x)：其中x为数据项下标，可移除，默认为最后一个元素
print("删除Test中最后一个元素的结果：%s"%li)
li.pop()
print("删除Test中最后一个元素的结果：%s"%li)
li.pop()
print("删除Test中最后一个元素的结果：%s"%li)
li.pop()
print("删除Test中最后一个元素的结果：%s"%li)
li.pop()
print("删除Test中最后一个元素的结果：%s"%li)
print("在Test中移除左边找到的第一个元素：%s"%li.remove(3))  #移除自左边找到的第一个元素3
print(li)
print("反转Test列表：%s"%li.reverse())  #反转列表
print(li)
print("对Test列表进行排序：%s"%li.sort())  #列表排序 reverse = True
print(li)

元组操作

是一种不可变的序列，在创建之后就不能做任何的修改
特点：
1.不可变
2.用()来创建元组类型，数据项用逗号来分隔
3.可以是任何类型
4.当元组中只有一个元素时，要加上逗号，不然解释器会当作整型来处理
5.同样可以支持切片操作

# 元组的创建 不能进行修改
tupleA = ()  #空元组
# print(id(tupleA))
tupleA = ('abcd',89,9.12,'peter',[11,22,33])
# print(id(tupleA))
# print(type(tupleA))
# print(tupleA)
# 元组的查询
# for item in tupleA:
#     print(item,end=' ')
#     pass
# print(tupleA[2])
# print(tupleA[2:4])
# print(tupleA[::-1])
# print(tupleA[::-2])
# print(tupleA[-3:-1:])  #不包括-1的元素
# print(type(tupleA[0]))
# tupleA[0] = '123'  #错误的
# tupleA[4][0] = 9999  #可以对元组中的列表类型的数据进行修改
# print(tupleA[4])
# print(type(tupleA[4]))
tupleB = (1)
print(tupleB)
print(type(tupleB))
tupleC = tuple(range(10))
print(tupleC)
print(type(tupleC))
tupleD = (1,)  #当元组中只有一个数据项时，必须在数据项后面加上逗号
print(tupleD)
print(type(tupleD))
tupleE = (1,2,3,4,5,6,3,2,5,4,3,1)
print(tupleE.count(3))  #统计3出现的次数

字典操作

Python中非常重要的数据结构，可以储存任意对象(由 键值对 组成的集合)。
字典以键值对的形式创建的{‘key’:‘value’}利用大括号包裹着。
字典中找某个元素时，是根据键、值字典的每个元素由2部分组成。键:值
通常使用键访问数据(效率高)，和list一样，支持对数据的添加
访问值的安全方式get方法，在我们不确定字典中是否存在某个键而又想获取其值时，可以使用get方法，还可以设置默认值
注意：
1.字典的键(key)不能重复，值(value)可以重复
2.字典的键(key)只能是不可变类型，如数字、字符串、元组。
特点：
1.不是序列类型 没有下标的概念 是一个无序的键值集合，是内置的高级类型
2.用 {} 表示字典对象，每个键值对用逗号(,)分割
3.键 必须是不可变的类型【元组、字符串】 值可以是任意类型
4.每个键必定是唯一的，如果存在重复的键，后者会覆盖前者
常用方法：
1.修改元素：字典中的值是可以修改的，通过键找到对应值修改
2.新增元素：如果在使用 变量名[‘键’] = 数据 时，这个’键’在字典中，不存在，那么就会新增这个元素
3.删除元素：del 删除指定元素 clear 清空字典
4.统计个数：len() 可以查看字典中有几个键值对
5.获取键:keys：返回包含字典所有 key 值的 dict keys 对象，用 for 循环取出每一个 key 值
6.获取值:value：使用 values 返回一个包含所有值(value)的dict values 对象
7.获取键值对：返回一个包含所有(键、值)元组的列表 dict items 对象
8.删除指定键：pop(‘键’)删除指定键

# 如何创建字典
from collections import defaultdict


dictA = {'pro':'啥都好专业','school':'啥都好学校'}  #空字典
# print(id(dictA))
# print("目前字典长度为：%d"%len(dictA))
dictA['name'] = '大漂亮'
dictA['age'] = '24'
dictA['sex'] = '女'
# print("目前字典长度为：%d"%len(dictA))
# print(id(dictA))
# print(type(dictA))
print(dictA)  #用逗号分隔开
# print(dictA['name'])  #通过键('name')得到它的值('大漂亮')
# print(dictA['age'])  #通过键('age')得到它的值(24)
# print(dictA.get('name'))  #通过键('name')得到它的值('大漂亮')
# print(dictA.get('age'))  #通过键('age')得到它的值(24)
# print(dictA.get('sex'))  #通过键('sex')得到它的值('女')
# print(dictA.get('pro'))  #通过键('pro')得到它的值('啥都好专业')
# print(dictA.get('school'))  #通过键('school')得到它的值('啥都好学校')
# dictA['name'] = '大帅锅'
dictA.update({'name':'大帅锅'})  #若执行的键存在，则进行修改操作
dictA.update({'hight':'1.80'})  #若执行的键不存在，则进行添加操作
# print(dictA['name'])  #通过键('name')得到它的值('大漂亮')
#获取所有的键
# print(dictA.keys())
#获取所有的值
# print(dictA.values())
#获取所有键值对
# print(dictA.items())
# for item in dictA.items():
#     print(item)
# for key,value in dictA.items():
#     print('%s == %s'%(key,value))
#删除操作
# dictA.pop('hight')  
# print(dictA)
# del dictA['pro']
# print(dictA)
print(dictA)
#如何对字典进行排序
print(sorted(dictA.items(),key=lambda d:d[0]))  #按照key排序
print(sorted(dictA.items(),key=lambda d:d[1]))  #按照value排序 类型必须一样，否则不能排序

公用操作

合并操作 + ：两个对象相加操作，会合并两个对象
适用于字符串、列表、元组
复制 * ：对象自身按指定次数进行 + 操作
适用于字符串、列表、元组
判断元素是否存在 in ：(返回值为bool类型)
判断指定元素是否存在于对象中
适用于字符串、列表、元组、字典

#公用操作 + * in

# 字符串
strA = '人生苦短'
strB = '啥也不是'
print(strA+strB)
print(strA*5)
print('生' in strA)
print('人' in strB)

#列表
listA = list(range(10))
listB = list(range(11,21))
print(listA+listB)
print(listA*2)
print(3 in listA)

#元组
tupleA = [1,2,3]
tupleB = [4,5,6]
print(tupleA+tupleB)
print(tupleA*3)
print(2 in tupleA)
print(2 in tupleB)

#字典
dictA = {'A':'a','B':'b'}
print('A' in dictA.keys())
print('A' in dictA.values())