数据类型操作方法（二）

1、列表的常用方法

　　sort()的用法

l = [1, 2, 3, 4, 5, 6, 7]

l.sort()  # 排序 默认情况下是从小到大(升序)
l1 = [43,6,1,7,99]
l1.sort(reverse=True)  # 可以通过指定参数来修改默认的拍讯规则(降序)
print(l1)  # [99, 43, 7, 6, 1]

　　总结：列表能存多个值，内部元素是有序的，列表是可变数据类型

　　　　PS：队列和堆栈

# 队列   先进先出
l1 = []
# 先进
l1.append('first')
l1.append('second')
l1.append('third')
# 先出
print(l1.pop(0))  # first
print(l1.pop(0))  # second
print(l1.pop(0))  # third


# 堆栈   先进后出
# 先进
l1.append('first')
l1.append('second')
l1.append('third')
# 后出
print(l1.pop())  # third
print(l1.pop())  # second
print(l1.pop())  # first

2、元组及其常用方法

　　1、定义：与列表类型比，只不过[]换成()

　　　　可以写成：age=(11,22,33,44,55)，本质age=tuple((11,22,33,44,55))

2、作用：能够存储多个元素，元素与元素之间逗号隔开。元组中的元素可以是任意类型，元组不能被修改

　　3、优先掌握的操作

　　　　1、按索引取值(正向取+反向取)：只能取　

t = (1, 2, 3, 'a', 'b', [1, 2, 3])

print(t[0])

t[1] = 'hahah'
t[-1] = 'hahaha'
t[-1][0] = '我改了'
print(t)

del t[0]
print(t)

 　　　　2、切片(顾头不顾尾，具体操作与列表一样）

t = (1, 2, 3, 'a', 'b', [1, 2, 3])

print(t[::2])

 　　　　3、长度len(具体操作与列表一样）

t = (1, 2, 3, 'a', 'b', [1, 2, 3])

print(len(t))  # 6

　　　　4、成员运算in和not in(具体操作与列表一样）

t = (1, 2, 3, 'a', 'b', [1, 2, 3])


print('a' in t)  # True

　　　　5、循环

t = (1, 2, 3, 'a', 'b', [1, 2, 3])


for i in t:
    print(i)  # 1 2 3 a b [1,2,3]

　　　　6、cuont和index

具体使用和列表、字符串中的使用一样。count对相同的元素进行计数；index查找元素是若找到元素则返回元素的索引，反之返回报错

t = (1, 2, 3, 'a', 'b', [1, 2, 3])

print(t.count('a'))  # 1
print(t.index('xxx'))  # 报错

　　4、元组总结：元组能存多个值，内部存储的值是有序的，元组是不可变数据类型

t2 = (1, 2, 3, 4, [1, 2])
print(id(t2))  # 1454472798896
t2[-1].append(666)
print(t2)  # (1, 2, 3, 4, [1, 2, 666])
print(id(t2))  # 1454472798896

 

3、字典的常用方法

1、定义：能存存储多组 key:value键值对 key是对value的描述 key通常情况下都是字符串其实这个key只能是不可变类型,value可以是任意数据类型

d = {'name':'jason','password':123}  # d = dict( {'name':'jason','password':123})

d1 = {1:'1',0:'0',1.11:'1.11',(1,2):'到底能不能呢?'}
print(d1[1.11])  # 1.11
print(type(d1))  # dict
print(d1[(1,2)])  # 到底能不能呢？

d2 = {'name':'jason','name':'tank','name':'nick','password':123}

# print(len(d2))
# print(d2)
# 强调:字典的key是不能重复的 要唯一标识一条数据
# 如果重复了 只会按照最后一组重复的键值对存储

　　　　定义字典的三种方法：

# 掌握
# 1
d1 = {'name':'jason','password':123}

# 2
# 掌握
d2 = dict(name='jason',password=123,age=18)  # (******)
print(d2,type(d2))


# 3
# 了解即可
l = [
    ['name','jason'],
    ['age',18],
    ['hobby','read']
]
d = {}

for k,v in l:  # ['name','jason'],['age',18]...

    d[k] = v

d3 = dict(l)
print(d3)

 

　　2、优先掌握的操作

　　　　1、按key存取值：可存可取

d3 = {"name": "jason", "age": 18}

print(id(d3))  # 1968293842448
print(d3["name"])  # jason

d3["name"] = "alex"
print(d3["name"])  # alex

d3["pwd"] = "123"  # 赋值语句当key不存在的情况下，会自动新增一个键值对
print(d3, id(d3))  # {'name': 'alex', 'age': 18, 'pwd': '123'}  1968293842448

　　　　2、长度len：统计的键值对的个数

　　　　3、成员运算in和not in   对于字典来说只能判断key值

d3 = {'name':'jason','password':'123'}

print('123' in d3)  # False
print('name' in d3)  # True

　　　　4、删除

　　　　del和pop的使用和李彪中大致相同，不过字典中的pop利用key弹出value，当键不存在是直接报错。

d3 = {'name':'jason','password':'123'}
del d3['name']
print(d3)  # {'password':'123'}
res1 = d3.pop('name')  # 弹出仅仅是value
res2 = d3.pop('age')  # 当键不存在的时候直接报错
print(res1)  # jason
print(res2)  # 报错
print(d3)  # {'password':'123'}
d3.clear()  # 清空
print(d3)  # {}

　　　　5、获取所有的键keys()，获取所有的值values()，获取所有的键值对items()

d1 = {'name':'jason','password':123}
print(d1.keys())  # dict_keys(['name', 'password'])  老母猪
  for k in d1.keys():
     print(k)
print(d1.values())  # dict_values(['jason', 123])  老母猪  现在就把它当成一个列表来看即可

print(d1.items())  # dict_items([('name', 'jason'), ('password', 123)])
# 就把它看成是列表套元组，元组的第一个元素是字典的key 第二个元素是字典的value

　　　　　　还可以通过get()方法根据key获取value。

d1 = {'name':'jason','pwd':123}

print(d1.get("name"))  # jason
print(d1.get("pwd"))  # 123
print(d1.get("xxx"))  # None  当key不在字典中时返回None

# 可以在get中添加第二个参数，不管key在不在字典中，都返回所给的参数

print(d1.get('name','你给我的name在字典的key中'))  # 你给我的name在字典的key中
print(d1.get('xxx','你给我的xxx不在字典的key中'))  # 你给我的xxx不在字典的key中

　　　　6、dict.fromkeys()，dict.popitem()，dict.update()

# dict.fromkeys() 快速创建字典

l1 = 'name', 'password', 'age', 'hobby'
print(dict.fromkeys(l1, 123))  # {'name': 123, 'password': 123, 'age': 123, 'hobby': 123}
l1 = ('name', 'password', 'age', 'hobby')
print(dict.fromkeys(l1, 123))  # {'name': 123, 'password': 123, 'age': 123, 'hobby': 123}
l1 = 'name'
print(dict.fromkeys(l1, 123))  # {'n': 123, 'a': 123, 'm': 123, 'e': 123}

# l1可以为一个可迭代的对象，例如字符串、列表、字典，列表和字典中的元素必须为不可变数据类型

# dict.popitem()

d1 = {'name': 123, 'password': 123, 'age': 123, 'hobby': 123}
print(d1.popitem())  # 尾部以元组的形式弹出键值对 ('hobby', 123)

# dict.setdefault()  添加新的键值对

d1 = {'name': 'jason', 'pwd': 123}
res1 = d1.setdefault('name', 'xxoo')  # 当键存在的情况下 不修改值 并且将原先key对应值返回给你
print(d1, res1)  # {'name': 'jason', 'pwd': 123} jason
res2 = d1.setdefault('age', 18)  # 当键不存在的情况下 新增一个键值对 并且将新增的键值对的值返回给你
print(d1, res2)  # {'name': 'jason', 'pwd': 123, 'age': 18} 18

d1 = {'name': 'jason', 'pwd': 123}
d2 = {"num": 18}
d1.update(d2)
print(d1)  # {'name': 'jason', 'pwd': 123, 'num': 18} 当key不存在时，添加新的键值对
d1.update(num=666)
print(d1)  # {'name': 'jason', 'pwd': 123, 'num': 666} 当key存在时更新value
d1.update(age=666)
print(d1)  # {'name': 'jason', 'pwd': 123, 'num': 18, 'age': 666} 当key不存在时，添加新的键值对

　　　　7、循环

　　　　　　字典中的for循环打印得到是键key

d1 = {'name': 'jason', 'password': 123}
for i in d1:
    print(i)  # name password

　　3、字典总结：字典可以存储多个值，字典内部的元素是没有顺序的，字典是可变数据类型

4、集合及其常用的方法

　　1、什么是集合：群体间作比较，不涉及单个元素

　　　　1、集合的作用：可以用来去重，做一些关系比较

　　　　2、集合的类型

pythons = {'jason', 'nick', 'tank', 'egon', 'kevin', 'owen', 'alex'}
linux = {'frank', 'jerry', 'tank', 'egon', 'alex'}

s = {1,2,3,4,5,6}  # <class 'set'>  # s = set()

　　　　3、集合的三个原则

　　　　　　1、每个元素必须是不可变类型

s = {1,2,3,4,5,6,'a',(1,2),[1,2]}  # 报错
s = {1,2,3,4,5,6,'a',(1,2),{"name":'jason'}}  # 报错

　　　　　　2、没有重复的元素

s = {1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 4, 4, 4, 4, 4, 5}
print(s)  # {1, 2, 3, 4, 5} 自动将重复的元素 去除

　　　　　　3、无序

s = {1, 2, 3, 4, 5, 6}
print(s[1])  # TypeError: 'set' object does not support indexing

# 注意集合的目的是将不同的值存放到一起，不同的集合间用来做关系运算，无需纠结于集合中单个值

　　　　4、优先掌握的操作

　　　　　　1、长度len

s = {1, 2, 3, 4}
print(len(s))  # 4

　　2、成员运算in和not in（与列表、字符串中的成员运算方法相同），若查询的元素在集合中则返回True，反之返回False。

　　　　　　3、|合集

# 取出所有报了名的学生姓名

pythons = {'jason', 'nick', 'tank', 'egon', 'kevin', 'owen', 'alex'}
linux = {'frank', 'jerry', 'tank', 'egon', 'alex'}

print(pythons | linux)  # {'tank', 'alex', 'frank', 'nick', 'egon', 'jerry', 'kevin', 'jason', 'owen'}

　　　　　　4、&交集

pythons = {'jason', 'nick', 'tank', 'egon', 'kevin', 'owen', 'alex'}
linux = {'frank', 'jerry', 'tank', 'egon', 'alex'}

# 既报名python也报名linux的学生姓名
print(pythons & linux)  # 交集  {'tank', 'egon', 'alex'}

　　　　　　5、-差集

pythons = {'jason', 'nick', 'tank', 'egon', 'kevin', 'owen', 'alex'}
linux = {'frank', 'jerry', 'tank', 'egon', 'alex'}

# 只报名linux的学生姓名
print(linux - pythons)  # {'jerry', 'frank'}

　　　　　　6、^对称差集

pythons = {'jason', 'nick', 'tank', 'egon', 'kevin', 'owen', 'alex'}
linux = {'frank', 'jerry', 'tank', 'egon', 'alex'}

# 没有同时报名两门课程的学生姓名
print(pythons ^ linux)  # 对称差集 {'jerry', 'frank'}

　　　　　　7、==

s = {1, 2, 3}
s1 = {3, 1, 2}
print(s == s1)  # True

　　　　　　8、父集：>,>=

s1 = {1, 2, 3, 4, 55}
s2 = {1, 2, 666}
s3 = {1, 2}

print(s1 > s2)  # False
print(s1 > s3)  # True

　　　　　　9、子集：<,<=：具体用法和父集相同

s1 = {1, 2, 3, 4, 55}
s2 = {1, 2, 666}
s3 = {1, 2}

print(s2 < s1)  # False
print(s3 < s1)  # True

　　　　　　　　PS：

　　　　　　　　issubset()：判断是否是子集

　　　　　　　　issuperset()：判断是否是父集

　　2、集合总结：集合中每个元素必须是不可变类型，且没有重复的元素，元素都是无序的，集合本身是个可变数据类型。

5、数据类型总结

　　总共有八种数据类型，分别为int、float、str、list、dict、bool、tuple、set。

　　可分为可变数据类型和不可变数据类型两大类：

　　可变数据类型：list、dict、set

　　不可变数据类型：int、float、str、tuple、bool