python元组字典集合类型及其内置方法（下）

列表补充

补充方法

　　清空列表 clear

# clear  清空列表
l = [1, 2, 3, 4, 4]
print(l.clear())  # clear没有返回值（None）
print(l)
# None
# []

　　统计列表中指定元素出现的次数 count

# count 统计一个元素在列表中出现了几次
l = [1, 2, 3, 4, 4]
print(l.count(4))
# 2

　　列表反向、排序   reverse   sort（带参数，可指定按正序/ 反序排）

# reverse 将列表翻转
l = [1, 2, 3, 4, 4, 2]
print(l.reverse())  # reverse没有返回值（None）
print(l)
# None
# [2, 4, 4, 3, 2, 1]

# sort  排序，默认从小到大排序
l = [1, 2, 3, 4, 4, 2]
print(l.sort())  # sort没有返回值（None）
print(l)
# None
# [1, 2, 2, 3, 4, 4]

l = [1, 2, 3, 4, 4, 2]
print(l.sort(reverse=True))  # sort可以指定参数来确定排序规则
print(l)
# None
# [4, 4, 3, 2, 2, 1]

# 可以排序字符串、标点符号、数字（混排注意点，可能报错）
l = list('dasb41564s5.*/-^&#$84')
# l.append(1.1)  # 包含浮点型的时候不可以排
print(l.sort())  # sort方法可以将列表元素按ASCII码排序
print(l)
# None
# ['#', '$', '&', '*', '-', '.', '/', '1', '4', '4', '4', '5', '5', '6', '8', '^', 'a', 'b', 'd', 's', 's']

　　总结

# ------- 列表总结 ---------
# 能存多个值
# 有序的
# 可变类型

# 队列:先进先出  (排队)
# 堆栈:先进后出  (叠书、叠衣服 拿出来)

元组

简介

# 作用：能存储多个元素
# 定义：与列表一致，只不过把 [] 变成了 ()
# 特点
# 能存多个值
# 有序（能用索引取值）
# 不可变，不可以改值，不可以加值，删值
# 只能看不能改的场景，推荐用元组
# 存相同的数据，列表比元组占的空间更多（列表多出来的那堆方法也会占很多空间）

内置方法

　　定义元组

t = (1, 2, 3, 4)  # tuple((1, 2, 3, 4))
print(type(t))
# <class 'tuple'>

t = tuple(1)  # 报错，内部基于for循环，必须传容器类型
print(type(t))

# 定义元组时如果只有一个元素，也得加上 , 逗号 不然会被python 解释成 其他类型
t = (1)
print(type(t))
# <class 'int'>

t = (1, )
print(type(t))
# <class 'tuple'>

t = ('a')
print(type(t))
# <class 'str'>

t = ('a', )
print(type(t))
# <class 'tuple'>

　　验证是否可变类型  --->不可变类型

t2 = (1, 2, 3, [1, 2, 3])
print(id(t2))
# 2270010972424
t2[3][0] = 666666
print(t2)
print(id(t2))
# (1, 2, 3, [666666, 2, 3])
# 2270010972424
#  ---> 内存地址不变，所以他是不可变类型

　　索引取值

# 索引取值  可取不可改
t = (2, 3, 4)
print(t[0])

# t[0] = 4  # TypeError: 'tuple' object does not support item assignment 元组的元素不可以改（如果元素是可变类型，那么可以改）

t = (2, 3, 4, [5, 6, 7])
t[3][0] = '我改了'  # 不报错，因为改的是列表（具体看原理图（内存指向，实际元组没有改动））
print(t)
# (2, 3, 4, ['我改了', 6, 7])

　　切片

# 切片，顾头不顾尾 暂不举例，与列表和字符串一样的用法

　　元组中的元素个数 len

# 元组中的元素个数 len， 获取元素的个数 暂不举例，与列表一样的用法

　　成员运算 in / not in

# 成员运算 in / not in  暂不举例，与列表一样的用法

　　作为循环的迭代器对象 for in

# 作为循环的迭代器对象  for ... in ...:  暂不举例，与列表一样的用法

　　统计某个元素在元组中出现的次数 count

# count 统计某个元素在元组中出现的次数
t = ('hello', 'thank', 'you', 1, 1.1, ['hello', 3, 'thank'], 'thank', 'you', 'very', 'much')
print(type(t))
print(t.count('hello'))  # 元素内部不管，只管第一层
print(t.count('thank'))
# <class 'tuple'>
# 1
# 2

　　获取元素的索引  index （找不到会报错）

# index 获取元素的索引（试试字符串类型的？）
print(t.index('thank'))
# 1
# print(t.index('your'))  # 找不到值会报错 ValueError: tuple.index(x): x not in tuple
# 可以用count 判断在不在里面(为0 则不在里面，为其他值则在)，再用index 找该元素的索引

字典

简介

# 能存储多组key: value键值对，可存可取
# key是对value的描述，并且key 通常情况下都是字符串，其实这个key 只能是不可变类型，value可以是任意数据类型
# 字典的key 是唯一性标识，同一个字典中key 不能重复
# 如果重复了，只会按照最后一组键值对存储
# 无序
# 可变
# 不可变类型： 数字类型（int、float），字符串，元组  都可以作为字典的 key

内置函数

　　定义字典

d = {'name': 'jason', 'password': 123}  # d = dict({'name': 'jason', 'password': 123})
d1 = {1: '1', 0: '0', 1.1: '1.1', 'string': 'string', (1, 2): '到底行不行呢？'}
print(d1)
print(type(d1))
# {1: '1', 0: '0', 1.1: '1.1', 'string': 'string', (1, 2): '到底行不行呢？'}
# <class 'dict'>
print(d1[1])
print(d1[1.1])
print(d1['string'])
print(d1[(1, 2)])
# 1
# 1.1
# string
# 到底行不行呢？

# 定义字典的三种方式
# 1  直接定义
d1 = {'name': 'jason', 'password': '123'}

# 2  ----> 通过关键字传参来定义   ***重点掌握（后期面向对象的时候好用）***
d2 = dict(name='jason', password=123, age=18)

# 3  直接dict 类型转换
l = [
    ['name', 'jason'],
    ['age', 18],
    ['hobby', 'read']
]
# 简便写法
d3 = {}
d3 = dict(l)
print(d3)
# {'name': 'jason', 'age': 18, 'hobby': 'read'}

# 上面写法的原理
d3 = {}
for k, v in l:  # ['name', 'jason'],['age', 18]....
    # 这里的 k,v 利用了解压赋值
    d3[k] = v
print(d3)
# {'name': 'jason', 'age': 18, 'hobby': 'read'}

　　创建字典的其他方式    fromkeys   (不怎么好用)

# fromkeys() 用来创造字典
d1 = {'name': 'jaoon', 'password': '123', 'sex': 'gender', 'salary': 16000}
print(d1.fromkeys('name'))
# {'n': None, 'a': None, 'm': None, 'e': None}

# 扩展用法
l = ['name', 'password', 'age', 'hobby']
dic = {}
print(dic.fromkeys(l, 123))  # 快速创建字典，后续再去更改
# {'name': 123, 'password': 123, 'age': 123, 'hobby': 123}
# 试试第二个参数也传列表

　　给字典中的指定键值对指定默认值  setdefault

# setdefault()
d1 = {'name': 'jaoon', 'password': '123'}
print(d1.setdefault('name', 'xxoo'))  # 当键存在的情况下会返回该键的值 当键存在时不会改变字典的值
print(d1)
print(d1.setdefault('age', 18))  # 当键不存在的情况下会给字典添加一个键值对（两个参数），并且会把新增的键值对的值返回
print(d1)
# jaoon
# {'name': 'jaoon', 'password': '123'}
# 18
# {'name': 'jaoon', 'password': '123', 'age': 18}

　　更新字典的值（也可以添加键值对）  update  和 直接通过 不存在的key 赋值的方式添加键值对（具体看下方例子）

# update()
# 1
d1 = {'name': 'jaoon', 'password': '123'}
d2 = {'age': 18}
print(d1.update(d2))
print(d1)
# None
# {'name': 'jaoon', 'password': '123', 'age': 18}

# 2
d1 = {'name': 'jaoon', 'password': '123'}
print(d1.update(age=18))
print(d1)
# None
# {'name': 'jaoon', 'password': '123', 'age': 18}

# 3 推荐直接这样写 ----------->  !!!! 上面写法太麻烦，不如这个好用
d1 = {'name': 'jaoon', 'password': '123'}
print(d1)
d1['age'] = 18
print(d1)
# {'name': 'jaoon', 'password': '123'}
# {'name': 'jaoon', 'password': '123', 'age': 18}

　　获取字符串中键值对个数   len

dit2 = {'name': 'egon', 'name': 'jason', 'name': 'alex', 'age': 18}
print(dit2)
print(len(dit2))
# {'name': 'alex', 'age': 18}
# 2

　　成员运算 in / not in （只能取到key 值）

# 成员运算 in/ not in  字典在for循环只暴露出 key， value无法取不到做成员运算
d3 = {'name': 'jaoon', 'password': '123'}
print('123' in d3)
print('password' in d3)
# False
# True

　　按key 取值 （类似列表中的索引取值  ---> 字典是无序的，字典中没有索引取值）

# 按key 存取值：可存可取
d3 = {'name': 'jaoon', 'password': '123'}
print(id(d3))
# 2364215340992
print(d3['name'])
# jaoon
d3['name'] = 'egon'  # 改的是指向，不是索引， 字典是无序的，  key 重复了是替换的意思

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

　　取值的其他方法    keys   values   items   get

# 获取字典value的方法 ----》 keys values items 跟python2.x 产生的结果不同 （记得添加到笔记中去）
# 1. 粗暴的循环获取（通过key ）

# 字典的 keys()  values()  items() 方法在 python 2.x 和 3.x 中有区别，像老母猪
# 2. keys()
d1 = {'name': 'jaoon', 'password': '123', 'sex': 'gender', 'salary': 16000}
print(d1.keys())
# dict_keys(['name', 'password', 'sex', 'salary']) ，像老母猪
for k in d1.keys():
    print(k)
    # name
    # password
    # sex
    # salary

# 3. values() 与上面类似
d1 = {'name': 'jaoon', 'password': '123', 'sex': 'gender', 'salary': 16000}
print(d1.values())
# dict_values(['jaoon', '123', 'gender', 16000])
for i in d1.values():
    print(i)
    # jaoon
    # 123
    # gender
    # 16000

# 4. items() 列表套元组，元组的第一个元素是字典的key ， 第二个元素是字典的value
d1 = {'name': 'jaoon', 'password': '123', 'sex': 'gender', 'salary': 16000}
print(d1.items())
# dict_items([('name', 'jaoon'), ('password', '123'), ('sex', 'gender'), ('salary', 16000)])
for i in d1.items():
    print(i)
    # ('name', 'jaoon')
    # ('password', '123')
    # ('sex', 'gender')
    # ('salary', 16000)

# 作为迭代器对象循环取值
# for i in  ...

# get() 根据key 获取 value， 可以传第二个参数，当传入的key 不存在，会返回（提示信息）该参数， 存在则会返回该key 对应的值， 第二个参数不写的话，key 不存在会返回None ,如果存在则会返回该key 对应的value
# 推荐字典取值统一用 get   **********
d1 = {'name': 'jaoon', 'password': '123', 'sex': 'gender', 'salary': 16000}
print(d1.get('name'))
# jaoon
print(d1.get('hahah'))  # 当key 不存在时不会报错，返回None，   用 []取不存在的会直接报错
# None
print(d1.get('name', '你给我的name 不在字典的key 中'))
print(d1.get('hahah', '你给我的hahah 不在字典的key 中'))
# jaoon
# 你给我的hahah 不在字典的key 中

　　删除字典中的键值对或清空字典   del      pop     popitem     clear

# 删除
# del
d3 = {'name': 'jaoon', 'password': '123'}
del d3['name']
print(d3)
# {'password': '123'}

# pop  传key， key 不存在会直接报错
d3 = {'name': 'jaoon', 'password': '123'}
print(d3.pop('name'))  # pop 返回的是value
print(d3)
# jaoon
# {'password': '123'}
# print(d3.pop('age'))  # 当键不存在的时候，直接报错，KeyError: 'age'

# popitem 不需要参数，弹出"最后"一个键值对
d3 = {'name': 'jaoon', 'password': '123'}
print(d3.popitem())
print(d3)
# ('password', '123')
# {'name': 'jaoon'}
print(d3.popitem())
# ('name', 'jaoon')
# print(d3.popitem())  # 会报错，弹空了

# clear 清空字典
d3 = {'name': 'jaoon', 'password': '123'}
print(d3.clear())
print(d3)
# None
# {}

集合

简介

# 群体之间作比较，不涉及单个元素 --> 推荐用集合  （见关系图，整理到博客里去）
# 作用： 做关系运算： 共同好友、共同粉丝   ---> 涉及到共同，两个群体之间作比较
#        去重
# 可以定义多个元素，用逗号分隔
# 集合的元素必须遵循的三个原则
# 1：每个元素必须是不可变类型
#       可变： 不可hash
#       不可变： 可hash
'''
    d = {[1, 2]: 'name'}  # 会报错，不可hash   TypeError: unhashable type: 'list'
    s = {1, 2, 1.1, 'string', (1, 2)}
    print('-----------', s)
    # ----------- {(1, 2), 1, 2, 1.1, 'string'}
'''
# 2：没有重复的元素
'''
    s = {1, 2, 3, 3, 4, 3}  # 自动将重复的元素去除
    print(s)
    # {1, 2, 3, 4}

    将其他类型去重成集合，再想办法转回去
    l = ['jason', 'egon', 'jason']
    s = set()
    print(s.update(l))
    print(s)
    # None
    # {'egon', 'jason'}
'''
# 3：无序
'''
    s = {1, 2, 3, 4, 5}
    print(s[1])  # 会直接报错,集合不支持索引取值 TypeError: 'set' object does not support indexing
'''

内置函数

　　定义集合

# 定义集合  (跟字典很像，但它内部不是键值对)
s = {1, 2, 3}  # s = set({1, 2, 3})
print(type(s))
# <class 'set'>

# 尝试定义空集合
s = {}  # 如果仅仅只写了 {} .那么python 会默认把它当成字典类型
print(type(s))
# <class 'dict'>

# 定义空集合  只能用关键字 set
s = set()
print(type(s))
# <class 'set'>

# 定义空元祖 就是本身的元组
t = ()
print(type(t))
# <class 'tuple'>

# print(set(1))  # 会报错，set也是迭代对象 TypeError: 'int' object is not iterable
print(set((1,)))
# {1}

　　向集合中添加元素  add

# 集合添加元素
# add
s = {1, 2, 3, 4, 5}
print(s.add(666))
print(s)
print(s.add((1, 2, 3, 4)))
print(s)
# None
# {1, 2, 3, 4, 5, 666}
# None
# {1, 2, 3, 4, 5, (1, 2, 3, 4), 666}

　　获取集合元素个数  len

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

　　集合在交集并集关系处理中的运用    &  |  ^   -   <  <=  >  >=  ==  以及他们的英语方法写法（后续补充一下）

# 交集并集等集合关系的运用
pythons = ['jason', 'nick', 'tank', 'egon', 'kevin', 'owen', 'alex']
linux = ['frank', 'jerry', 'tank', 'egon', 'alex']

# 求既在python 又在linux 的同学
# 普通循环写法
for name in pythons:
    if name in linux:
        print(name)
# tank
# egon
# alex
pythons = {'jason', 'nick', 'tank', 'egon', 'kevin', 'owen', 'alex'}
linux = {'frank', 'jerry', 'tank', 'egon', 'alex'}

# & 交集
# pythons 和 linux中都有的
print(pythons & linux)
# {'tank', 'alex', 'egon'}

# - 差集 -----------------
# 只在 pythons 中的
print(pythons - linux)
# {'kevin', 'nick', 'jason', 'owen'}

# 只在 linux 中的
print(linux - pythons)
# {'frank', 'jerry'}

# ^ 对称差集
# 没有同时在 pythons 和 linux 中的
print(pythons ^ linux)
# {'kevin', 'nick', 'jerry', 'owen', 'jason', 'frank'}

# | 合集
# pythons 和 linux 所有的元素（不重复）
print(pythons | linux)
# {'kevin', 'frank', 'alex', 'egon', 'jason', 'tank', 'jerry', 'nick', 'owen'}

# == 判断两个集合是否相等
print(pythons == linux)
# False

# 父级子级
s = {1, 2, 3, 4}
s2 = {2, 4}

# > >= 是否包含 （父级） issuperset
print(s >= s2)
# True

# < <= 是否被包含 （子级） issubset
# 父级自己反过来一样的

　　删除集合中的元素   clear    pop    remove     discard

# clear
# pop
# remove 不存在报错
# discard 不存在不报错

区分类型

# 必须分清楚下面这几种类型分别长啥样！！！别写混了
# 列表 list
# [1, 2, 3, 4]
# 元组 tuple
# (1, 2, 3, 4)
# 集合 set
# {1, 2, 3, 4}