列表 - list-[]
输入内存储存容器 发生改变通常直接变化, 让我们看看下面列子
增 --- 默认在最后添加
- #append()-- 括号中可以是数字, 可以是字符串, 可以是元祖, 可以是集合, 可以是字典
- #lst=[1,2,3,'afdsf',6]
- #1print(lst.append(233))#---none-- 没有返回值 所以 none
- #2
- '''lst=lst.append(233)
- print(lst)'''#---none--- 没有返回值 所以 none
- #lst.append(223)#---int
- #print(lst)#--true
- #---- 另类的 + 在列表我们指定位置
- # lst.insert(2,1)# 在列表索引为 2 位置添加 1, 那么原本 lst 中索引为 2 的数据且它后面数据就得依次往后排
- # print(lst)
- # lst.append('eva')#---str
- # print(lst)
- # tu1 = ('a', 'b',3, 666)
- # lst.append(tu1)
- # print(lst)#----[1, 2, 3, 'afdsf', 6, ('a', 'b', 3, 666)]
- # set = ('a', 'b',3, 666)
- # lst.append(set)
- # print(lst)
- #
- #
- # dct = {'a':'b','c':666}
- # lst.append(dct)
- # print(lst)
- #-- 从底层结构来看, 列表变化都是在操作增删改时 直接放生变化, 不会生成返回值
- # 好比我同时打开下面两个操作
- # set = ('a', 'b',3, 666)
- #dct = {'a':'b','c':666}
- # lst.append(set)
- #
- # lst.append(dct)
- # print(lst)
- # 根据 python 解释器 从上至下特点 结果如下
- #[1, 2, 3, 'afdsf', 6, ('a', 'b', 3, 666), {'a': 'b', 'c': 666}]
删 --- 仅 pop 有返回值 ---
- # 删 pop---() 中什么不写 默认删除最后一个
- #lst=[1,2,3,'afdsf',6]
- # ret=lst.pop(1)# 只有索引删, 且有返回值, 别的没有返回值 ] , 也就是说直接在 [本身] 上打印, 或者赋值给某一 (变量再打印), 都是 --none
- # print(lst,ret)
- # clear 清空列表
- # lst.clear()
- # print(lst)
- #del--del lst[列表索引]-----del 和 lst 中间什么符号也不需要 -- 死规定
- # 按照索引删除该元素
- # del lst[0]
- # print(lst)#---[2, 3, 'afdsf', 6]
- # 按照切片删除该元素 -- 顾头不顾尾
- # del lst[0:2]
- # print(lst)#----[3, 'afdsf', 6]
- # 按照步长删除该元素 -
- # del lst[::2]
- # print(lst)#---[2, 'afdsf']
- # 也可以直接删除列表, 但一般不会这么用
- # del lst
- # print(lst)#---NameError: name 'lst' is not defined
- # 改
- # 改
- # 按照索引改值
- # l = ['a','jiazeng','2','xiaohei']
- # l[0] = '男神'
- #print(l) # ['男神', 'jiazeng', '2', 'xiaohei']
- #l[0]=l[0].upper()
- #print(l)#---['A','jiazeng','2','xiaohei']
- #
- # 按照切片改值 (迭代着增加)
- # l = ['a', 'jiazeng', '2', 'xiaohei']
- # tup1=(1,2,'sa','sha',[1,2,3],{
- 'a':1,'b':2
- })
- # dic={
- 'a':1,'b':2
- }
- # l[1:3] = 'abcdefg'#--- 必须是可迭代数据类型 str-- 就是拆散开放入, 字典就是把键迭代添加, 其它就是打开括号 --- 注意 数字 bool 是不可迭代数据类型
- # print(l) # ['a', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'xiaohei']
- # 按照切片 (步长) 改值 (必须一一对应)
- # l = ['a', 'jiazeng', '2', 'xiaohei']
- # dic={
- 'a':1,'b':2
- }
- # lst=[1,2]
- # l[::2] = '帅傻'# 对需要对改的位置一一对应 多一个不行少一个也不行
- # print(l) #['帅', 'jiazeng', '傻', 'xiaohei']
查
- # 通过索引查
- # l = ['a', 'jiazeng', '2', 'xiaohei']
- # print(l[0])
- # #通过步长
- # print(l[::2])
- # #通过切片
- # print(l[:3])
- # #也可以通过 for 循环或者推导式
- # print([i for i in l if i.isdigit() ])
列表其它操作
- count(数)(方法统计某个元素在列表中出现的次数).
- 1 a = ["q","w","q","r","t","y"]
- 2 print(a.count("q"))
- sort (方法用于在原位置对列表进行排序).
- reverse (方法将列表中的元素反向存放)
- 1 a = [2,1,3,4,5]
- 2 a.sort()# 他没有返回值, 所以只能打印 a
- 3 print(a)
- 4 a.reverse()# 他也没有返回值, 所以只能打印 a
- 5 print(a)
列表也可以相加与整数相乘
- l1 = [1, 2, 3]
- l2 = [4, 5, 6]
- # print(l1+l2) # [1, 2, 3, 4, 5, 6]
- print(l1*3) # [1, 2, 3, 1, 2, 3, 1, 2, 3]
列表小练习
'''l1 = [1, 2,'bai', [1,'al', 3,]]
# 1, 将 l1 中的'bai'变成大写并放回原处.
# 2, 给小列表 [1,'al',3,] 追加一个元素,'亲亲'.
# 3, 将列表中的'al'通过字符串拼接的方式在列表中变成'als'
l1[2]=l1[2].upper()# 用到索引找我们想要的内容时一定要注意 索引到那个是什么数据类型,
# 如果是字符串, 你需要先炒作你想改的某样, 再把他赋值或者说覆盖掉原先索引位置上
print(l1)
l1[-1].append('亲亲')
print(l1)
l1[-1][1]=l1[-1][1]+'s'
print(l1)'''
字典 --dict---{}
概念
'''不可变 (可哈希) 的数据类型: int,str,bool,tuple.
可变 (不可哈希) 的数据类型: list,dict,set.
字典是 Python 语言中的映射类型, 他是以 {} 括起来, 里面的内容是以键值对的形式储存的:
Key: 不可变 (可哈希) 的数据类型. 并且键是唯一的, 不重复的.
Value: 任意数据 (int,str,bool,tuple,list,dict,set), 包括后面要学的实例对象等.
在 Python3.5 版本 (包括此版本) 之前, 字典是无序的.
在 Python3.6 版本之后, 字典会按照初建字典时的顺序排列 (即第一次插入数据的顺序排序).
当然, 字典也有缺点: 他的缺点就是内存消耗巨大.'''
增
- # 通过键值对直接增加
- # --- 注意没有返回值 所以不可以 print(dic['weight'] = 75)
- '''dic = {'name':'jiazeng','age': 18}
- dic['weight'] = 75 # 没有 weight 这个键, 就增加键值对
- print(dic) # {'name': 'jiazeng', 'age': 18, 'weight': 75}
- dic['name'] = 'self_brother' # 有 name 这个键, 就成了字典的改值
- print(dic) '''# {'name':'self_brothe','age': 18,'weight': 75}
- # setdefault
- '''dic = {'name':'jiazeng','age': 18}
- dic.setdefault('height',175) # 没有 height 此键, 则添加 --- 注意格式:'键','值'
- print(dic) # {'name': jiazeng','age': 18,'height': 175}
- dic.setdefault('name','barry') # 有此键则 - 原字典不变 -- 什么变化没有
- print(dic) # {
- 'name': jiazeng','age': 18,'height': 175}
- # 注意 setdefault 它有返回值
- dic = {'name': 'jiazeng', 'age': 18}
- ret = dic.setdefault('name')
- print(ret) # jiazeng
- print(dic.setdefault('name'))#---# jiazeng'''
删
- # pop
- # 通过 key 删除字典的键值对, 有返回值, 可设置返回值.---- 推荐应用程序首选 pop
- dic = {
- 'name': 'xiaohei', 'age': 88
- }
- #ret = dic.pop('name')#- 直接输入健名就可以, 返回是值
- # ret = dic.pop()--- 如果 () 中不写 还会报错 --- 字典中 pop() 中必须写键
- #print(ret,dic) # xiaohei {
- 'age': 18
- }
- # ret1 = dic.pop('b','爱你')#---- 当没有这个键时 返回就是爱你, 有这个键 返回还是所删除的键对应的值
- # print(ret1,dic) # 爱你 {
- 'name': 'xiaohei', 'age': 18
- }
- #popitem 3.5 版本之前, popitem 为随机删除, 3.6 之后为删除最后一个, 有返回值
- # dic = {
- 'name': 'xiaohei', 'age': 88
- }
- # ret = dic.popitem()
- # print(type(ret),dic) # ('age', 88) {
- 'name': 'xiaohei'
}---- 返回的是键值对所拼车的元祖形式
- # {
- 'name': 'xiaohei'
- }
- #
- # #clear 清空字典
- # dic = {
- 'name': 'xiaohei', 'age': 88
- }
- # dic.clear()
- # print(dic) # {
- }
- #
- # # del
- # # 通过键删除键值对 -- 注意没有返回值 所以不可 print(del dic['name'])<>
- #dic = {
- 'name': 'xiaohei', 'age': 88
- }
- #print(del dic['name'])
- # del dic['name']
- # print(dic) # {
- 'age': 88
- }
- # #删除整个字典
- # del dic
改
- # 改也可以说增
- # 通过键值对直接改
- # dic = {
- 'name': '太白', 'age': 18
- }
- # dic['name'] = 'barry'
- # print(dic) # {
- 'name': 'barry', 'age': 18
- }
- # update
- # 第一种写法 --- 键 ='值'
- # 有相同覆盖, 无则在后添加
- # dic = {
- 'name': 'jiazeng', 'age': 18
- }
- # #dic.update(sex='男', height=175)
- # dic.update(name='男', age=175)#----{
- 'name': '男', 'age': 175
- }
- # print(dic) # {
- 'name': 'jiazeng', 'age': 18, 'sex': '男', 'height': 175
- }
- # 第二种写法 如果我们想加入多个键值对 并且他们是列表中套有个个小元祖 ---
- # 他们会在 update 打开列表 [] 和元祖小括号 并将元祖中元素 按照 键, 值划分 加入到字典中
- # 有相同覆盖 无则从字典后添加
- # dic = {
- 'name': 'jiazeng', 'age': 18
- }
- # # l1=[(1, '购物车'),(2, '登入系统'),(3, '计算机'),(4, '选课系统')]
- # # print(type(l1[0]))
- # dic.update([(1, '购物车'),(2, '登入系统'),(3, '计算机'),(4, '选课系统')])
- # print(dic) # {
- 'name': 'jiazeng', 'age': 18, 1: '购物车', 2: '登入系统', 3: '计算机', 4: '选课系统'
- }
- # 第三种 用字典方法去改, 有相同键覆盖 无相同键添加键值对
- # 被修改的. update(用你需要的)
- # dic1 = {
- "name":"jin","age":18,"sex":"male"
- }
- # dic2 = {
- "name":"jiazeng","weight":75
- }
- # dic1.update(dic2)
- # print(dic1) # {
- 'name': 'jiazeng', 'age': 18, 'sex': 'male', 'weight': 75
- }
- # print(dic2) # {
- 'name': 'alex', 'weight': 75
- }
查
- # 通过键查询
- # 直接 dic[key](没有此键会报错)
- # dic = {
- 'name': 'xiaohei', 'age': 18
- }
- # print(dic['name']) # xiaohei
- #
- # # get-- 强烈推荐查用 get 没有此键不会报错 还可以设置返回值
- # dic = {
- 'name': 'xiaohei', 'age': 18
- }
- # v = dic.get('name')
- # print(v) # 'xiaohei'
- # #get-- 设置返回值
- # v = dic.get('name1')
- # print(v) # None
- # v = dic.get('name2','没有此键')
- # print(v) # 没有此键
- #
- # #查看字典中所有键 ---keys()-- 返回一个类似列表容器, 并不改变原本数据结构
- # dic = {
- 'name': 'xiaohei', 'age': 18
- }
- # print(dic.keys()) # dict_keys(['name', 'age'])
- # #查看字典中所有值 ---values()
- # dic = {
- 'name': 'xiaohei', 'age': 18
- }
- # print(dic.values()) # dict_values(['xiaohei', 18])
- # #查看字典中所有键值对 ---items()
- # dic = {
- 'name': 'xiaohei', 'age': 18
- }
- # print(dic.items()) # dict_items([('name', 'xiaohei'), ('age', 18)])
还有集合 不过集合只有 增 --- 删两大天王
集合 set {}--- 我理解为变异是字典 只有键 没有值
- # 只有增删两大天王
- # set1 = set({
- 1,2,'barry'
- })
- # set2 = {
- 1,2,'barry'
- }
- # print(set1,set2) # {
- 1, 2, 'barry'
- } {
- 1, 2, 'barry'
- }
- # 增 --- 无序增
- #set1 = {
- 'alex','wusir','ritian','egon','barry'
- }
- # set1.add('景女神')
- # print(set1)
- #update: 迭代着增加 -- 且无序
- # set1.update('A')
- # print(set1)
- # set1.update('老师')
- # print(set1)
- # set1.update([1,2,3])
- # print(set1)
- # 集合删
- set1 = {
- 'alex','wusir','ritian','egon','barry'
- }
- # set1.remove('alex') # 删除一个元素
- # print(set1)
- # set1.pop() # 随机删除一个元素
- # print(set1)
- #
- # set1.clear() # 清空集合
- # print(set1)
- #
- # del set1 # 删除集合
- # print(set1)
元祖更可怜 因为他是号称不动明王 所以只能查啦
元组 tuple--- 元组: 俗称不可变的列表, 又被成为只读列表 -- 基本数据类型之一
- #() 括号括起来
- # 里面可以放任何数据类型的数据,
- # 查询可以, 循环也可以, 切片也可以.
- # 但就是不能改 - 只剩下查天王, 增删改天王都不是对手
- # 元组的索引切片
- # tu1 = ('a', 'b', 'xioahei', 3, 666)
- # print(tu1[0]) # 'a'
- # print(tu1[-1]) # 666
- # print(tu1[1:3]) # ('b', 'xioahei')
- # print(tu1[:-1]) # ('a', 'b', 'xioahei, 3)
- # print(tu1[::2]) # ('a', 'xioahei', 666)
- # print(tu1[::-1]) # (666, 3, 'xioahei', 'b', 'a')
- # 因为元组的特性, 直接从属于元组的元素不能更改, 所以元组只能查看.
- # 可以利用 for 循环查询
- #index: 通过元素找索引 (可切片), 找到第一个元素就返回, 找不到该元素即报错
- # tu1 = ('a', 'b', 'xioahei', 3, 666)
- # print(tu1.index('xioahei'))#----2 实现某 set 一功能 是 . 操作
来源: http://www.bubuko.com/infodetail-3012789.html