list列表 tuple元组 (range操作) dict字典 set集合 及相关操作

list列表

1. 什么是列表
定义: 能装对象的对象
在python中使用[]来描述列表, 内部元素用逗号隔开. 对数据类型没有要求

列表存在索引和切片. 和字符串是一样的.

2. 相关的增删改查操作(重点)
添加:
  1. append() 追加
  2. insert(位置, 元素) 插入指定元素到指定位置
删除:
  1. pop(index) 根据索引删除
  2. remove(元素) 根据元素删除
修改:
索引修改
lst[索引] = 元素
查询:
for循环.

索引和切片
lst = ["天龙八部", "西游记", "红楼梦", "银平煤", "绿平煤"]
print(lst[3])
print(lst[-3])
print(lst)
print(lst[1:4]) # 切片，原来是什么类型. 得到的就是什么类型
print(lst[-1::-2]) # 倒着切

lst = ["凡人修仙传", "诛仙", "神墓"]
# 添加 append() 追加. 在后面添加
lst.append("看见")
lst.append("追风筝的人")

# 插入 insert(位置, 元素), 效率相对比较低
lst.insert(1, "琴帝")

# 迭代添加, 把传递进去的参数进行迭代. 把每一项添加到列表的末尾
lst.extend(["胡辣汤","猪蹄子", "猪头肉", "五花肉"])

print(lst)

# 删除
lst = ["斗破苍求", "手机", "爵迹", "满城尽带黄金甲", "三生三世十里桃花"]

# # pop() 默认从后往前删
# lst.pop()
# # pop(索引) 按照索引位置删除
# lst.pop(1)

# remove(元素) 移除
# lst.remove("满城尽带黄金甲") # 当元素不存在的时候会报错

# del lst[::2] # 用切片或者索引删除 不常用
lst.clear() # 清空.

print(lst)

修改
lst = ["苏秦", "武大", "武二", "宝元", "李诞", "池子", "王建国"]
# lst[3] = "松江" # 通过索引修改 index out of range 索引下标越界
# print(lst)
# lst[1:3] = ["麻花藤"] # 迭代更新(不常用)
# print(lst)
lst[1:5:2] = ["麻花藤", "码云"] # 坑: 如果步长不是1. 元素的个数必须要和切片的个数一致
print(lst)

lst = ["alex", "wusir", "胡辣汤"]
# 把列表中的wusir替换成大写 WUSIR
# 首先你要获取到2元素
# 变成大写
# 塞回去(必须要放回去)
lst[1] = lst[1].replace("wusir", "WUSIR")
print(lst)

查询, 列表是一个可迭代对象
lst = ["jay", "wlh", "lzw", "wf"]
for item in lst:      # item是lst中的每一项
print(item)

for i in 123:      # 'int' object is not iterable
print(i)

3. 列表的嵌套
多个列表互相嵌套

例如:

lst = [["张艺谋", "冯小刚", "陈凯歌"], ["李安", "王家卫", "王晶"], ["周杰伦",["abc", "alex_wusir", ["胡辣汤", "c"]], "风扇哥"]]
print(lst[1][1][2])

# 把王晶换成"贾樟柯"

lst[1][2] = "贾樟柯"

 print(lst)
# 降维操作 ["哈哈", "hehe", "houhou"] 一维 [[1,2,3], [12,4,5], [6,7,8]] 二维
# 数数
lst[2][1][1] = lst[2][1][1].replace("_", "$")
print(lst)

4. 列表的其他操作
1. count() 计数
2. sort() 排序 reverse = True
3. reverse() 翻转
4. len() 求长度

lst = ["太白", "太白", "太黑", "日天", "女神", "alex", "太白"]

print(lst.count("太白")) # 查看xxx元素出现的次数

lst = [1, 8,12,22,1,1,2,33,4,5]
# lst.sort() # 排序. 默认升序
lst.sort(reverse=True) # reverse 反向, 降序
print(lst)

lst = ["赤木", "樱木花道", "流川枫", "三井"]
lst.reverse() # 把列表翻转
print(lst)

lst= [1,2,3,4,5,"胡辣汤"]
print(len(lst)) # 查看列表中元素的个数

list # 按住ctrl +鼠标左键

 

tuple元组

元组用()表示, 只读列表. 
tu = ("DNF", "LOL", "王者荣耀", "QQ飞车", "炫舞", {}, tuple(), [])
print(tu)
# tu[1] = "呵呵" # 'tuple' object does not support item assignment
print(tu)

元组也有索引和切片
print(tu[3:5])
print(tu[3:7:2])

元组有坑
空元祖
tu = tuple() # 固定写法
元组中如果只有一个元素
tu = (1) # 不是元组 <class 'int'>
tu = (1, ) # 这个是元组 <class 'tuple'>
print(type(tu))

好习惯: 写元组的时候末尾加个逗号

tu = ("锅包肉", "酸菜炖粉条+五花肉", "红烧鲤鱼", "红烧肉")
# 元组也是可迭代的
for item in tu: # 可以使用for循环
print(item)

tu = (1, "哈哈", "胡辣汤", ["忍者", "神龟"])
# tu[1] = "呵呵" # 元组不可变
tu[3] = ["我是新列表"] # 改变了指向. 报错
tu[3].append("孙悟空") # 元组没改. 该的是元素内部 没有改变元组的指向. 不报错
print(tu)

range操作

i = 1
while i <=100:
print(i)
i += 1

range(参数) [0,参数)
for i in range(20):     # range()可以被迭代 0-9
print(i)

range(参数1, 参数2) [参数1, 参数2) 切片
for i in range(10, 20):
print(i)

range(参数1, 参数2, 参数3) [参数1, 参数2) 每隔参数3个位置取一个
for i in range(10, 20, 3):
print(i)

lst = ["周杰伦", "动画城", "大风车", "随便加", "宝宝", "孟孟", "萌萌", "孟萌"]

for item in lst:      # 只能拿到元素. 获取不到索引
print(item)

for i in range(len(lst)): # i就是索引 lst[i]元素    *****利用for   in 拿到索引
print(i, lst[i])

dict字典

1. 什么是字典
字典是以   key:value   的形式来保存数据
用{}表示. 存储的是key:value
2. 字典的增删改查(重点)
1. 添加
dic[新key] = 值

setdefault()
2. 删除
pop(key)

3. 修改
dic[老key] = 值
update() 跟新字典
4. 查询
dic[key]
get(key, 值)
setdefault(key, value)
5. 遍历,字典是一个可迭代对象

增加

dic = {"意大利": "李云龙", "美国": "美国往事"}

# dic["日本"] = "东京审判" # 新key表示添加
# dic['韩国'] = "釜山行"

# setdefault (难点)********
# 有添加的功能,如果key是存在的. 不添加
# 流程: 判断你给的key是否在字典中存在了.如果已经存在了. 就不再新增. 如果不存在. 执行新增操作
dic.setdefault("美国", "三傻大闹宝莱坞")
print(dic)

删除

dic = {"张艺谋":"红高粱", "李安":"断臂山", "陈凯歌":"霸王别姬", "郭德纲":"祖宗十九代"}
# dic.pop("郭德纲") # 你要记住的
# dic.popitem() # 随机删除一项. 在python早期版本 字典是无序的.
del dic["李安"]
dic.clear() # 清空
print(dic)

修改
dic = {"河南":"胡辣汤", "开封": "灌汤包", "武汉":"热干面"}
# dic['河南'] = "烩面" # 老key = 值
print(dic)

dic1 = {"赵四":"刘晓光", "刘能":"王晓利", "王木生":"范伟"}
dic2 = {"赵四":"宝宝", "刘能":"萌萌", "皮校长":"皮长山"}

dic1.update(dic2) # 把dic2怼到dic1里面. 把dict2中的内容更新到dic1
print(dic1)
print(dic2)

查询

dic1 = {"赵四":"刘晓光", "刘能":"王晓利", "王木生":"范伟"}

1. 直接使用key就可以拿到value
print(dic1["赵四四"]) # KeyError: '赵四四' key不存在

2. get(key)
print(dic1.get("刘能能")) # None 当key不存在返回None
print(dic1.get("刘能能", "没有这个人")) # 当key不存在. 返回第二个参数. 默认第二个参数是None

3. setdefault() 第一个功能是添加(当key不存在). 第二个功能是查询(根据你给的key查询)
整个执行流程: 判断给的key是否存在. 如果存在. 就不执行新增流程.直接查询出这个key对应的value
如果key不存在. 先执行新增操作. 再使用key把对应的value查询出来
ret = dic1.setdefault("皮长山", "皮校长")
print(ret) # 皮校长

ret = dic1.setdefault("王木生", "宝宝")
print(ret) # 范伟

字典的相关操作

遍历

dic = {"赵四":"刘晓光", "刘能":"王晓利", "王木生":"范伟"}
直接for循环
for key in dic: # 直接循环字典拿到的是key, 有key直接拿value
print(key)
print(dic[key])

dic = {"赵四":"刘晓光", "刘能":"王晓利", "王木生":"范伟"}

不常用的

1. keys() 获取到所有的键
2. values() 获取到所有的值
3. items() 拿到所有的键值对
print(dic.keys()) # dict_keys(['赵四', '刘能', '王木生']) 像列表. 山寨列表
for k in dic.keys(): # 拿到的是字典中的每一个key
print(k)

当需要单独获取到所有value的时候
print(dic.values()) # dict_values(['刘晓光', '王晓利', '范伟']) 所有的value的一个数据集
for v in dic.values():
print(v)

print(dic.items()) # 所有的键值对 dict_items([('赵四', '刘晓光'), ('刘能', '王晓利'), ('王木生', '范伟')])
for k, v in dic.items(): # 遍历字典最简单的方案
# print(item) # ('赵四', '刘晓光')
# k, v = item # 解构
# k = item[0]
# v = item[1]
print(k, v)

a, b = 1,2 # 把后面的两个值分别赋值给前面两个变量. 解构, 解包
print(a)
print(b)

c = 1,2,3
print(c) # (1, 2, 3) # 元组和列表是可以解包的

d, e, f = [1,2,3]
print(d)
print(e)
print(f)

遍历字典两套方案
dic = {"赵四":"刘晓光", "刘能":"王晓利", "王木生":"范伟"}
1. 使用for循环直接遍历字典的key
for key in dic:
print(key)
print(dic[key])

2. 可以使用字典的items()+解构可以直接获取到key和value
for k, v in dic.items():
print(k)
print(v)

4. 字典的嵌套
字典的嵌套. 字典套字典

例如:

wf = {
    "name":"汪峰",
    "age":52,
    "hobby":["唱歌", "上头条", "穿皮裤"],
    "wife": {
        "name": "章子怡",
        "age": 49,
        "hobby":["演戏", "上电视", "当导师"],
        "tishen": {
            "name":"萌萌",
            "age":28
        },
        "zhuli":{
           "name":"磊磊",
           "age": 20
        }
    },
    "zhuli":{
        "name":"宝宝",
        "age":23,
        "hobby":["抽烟","喝酒","烫头"]
    },
    "children":[{"name":"汪老大"}, {"name":"汪老二"}]
}
wf['children'][1]["age"] = 2
print(wf)
# print(wf['zhuli']['name'])

# 汪峰老婆替身的名字
print(wf['wife']['tishen']['name'])
# 汪峰老婆的第二个爱好
print(wf['wife']['hobby'][1])
# 汪峰助理的第三个爱好
print(wf['zhuli']['hobby'][2])


# 汪峰的助理+10岁
wf['zhuli']['age'] = wf['zhuli']['age'] + 10
# 汪峰的老婆添加一个爱好("导戏")
wf['wife']['hobby'].append("导戏") # 添加完毕了
# 删除汪峰助理的"抽烟"爱好
wf["zhuli"]["hobby"].remove("抽烟")
print(wf)

set 集合(不重要). 去重复
集合中的元素是不重复的. 必须是可哈希的(不可变), 字典中的key
空集合:set()
空元组:tuple()
空列表:list()
非空集合: {123}集合, 集合其实就是不存value的字典

s = {"周润发", "大润发", "王润发", "周润发"} # 不重复的
print(s)

# 唯一能用到的点. 去重复
lst = ["麻将", "牌九", "骰子", "扑克", "骰子", "扑克", "扑克", "扑克"]

# 把列表转化成集合 x 转化成y类型 y()
s = set(lst)
# print(s)
# 把集合变回列表
lst = list(s)
print(lst) # 顺序是乱的

s = {"刘嘉玲", "赵本山", "莱昂纳多迪卡普里奥", "罗纳尔多"}
s.add("刘嘉玲") # 记  随机添加   无序
print(s)

s.update({"刘嘉玲", "刘能", "赵四"}) # 迭代更新
print(s)

ret = s.pop() # 随机删除一个
print(s)
print(ret)

s.remove("罗纳尔多")
print(s)

集合还有字典. 是没有索引和切片的

集合的修改
s = {"刘嘉玲", "赵本山", "莱昂纳多迪卡普里奥", "罗纳尔多"}
把罗纳尔多修改成梅西
s.remove("罗纳尔多")
s.add("梅西")
print(s)

迭代
for el in s:
print(el)

s1 = {"门神", "灯神", "灯神你在笑什么?"}
s2 = {"门神", "灯神", "你俩在干什么?"}

交集
print(s1 & s2)
print(s1.intersection(s2))

并集
print(s1 | s2)
print(s1.union(s2))

# 差集
print(s1 - s2) # s1中特有的内容
print(s1.difference(s2))

# 反交集
print(s1 ^ s2) # 两个集合中特有的内容
print(s1.symmetric_difference(s2))

集合本身是可变的数据类型 . 不可哈希
集合套集合->不能互相嵌套的
集合中的元素必须可哈希(不可变的)
s = {123}

如果非要集合套集合
s = frozenset({"哈哈","呵呵"}) # 不可变的数据类型(集合)
for el in s:
print(el)

from random import randint
for i in range(100):
print(randint(1,36))####从1-36随机出现    验证码