列表 元组 字典 集合

# 列表  中括号括起来 都好分割每个元素
# 列表中的元素可以是元素，字符串 布尔值 所有的都放进去
ls = [1, 2, "周", 3, ["a", "b", "c"], True]  # 通过list 类创建的对象，对象名字 li

print(ls[0], ls[4:6])  # 通过下标或者 切片取值

print(ls[0:1])  # 切片取值结果也是列表

# for 打印
for item in ls:
    print(item)

# 列表元素可以被修改的
#修改
# 索引修改
ls[0] = [11,22];
#切片修改
ls[1:3] = [20,300]
print(ls)
#删除 的第一种方式
#del ls[0]
#删除切片
print(ls)
del ls[0:2]
print(ls)

#in 操作
v = 300 in ls
print(v)


s = "fdafasfijoasjkf";
# 字符串转换列表
new_ls= list(s)
print(new_ls)

# 列表转字符串
# 第一种方式，自己写for 循环，既有数字又又字符串
# 第二种，如果元素只有字符串 li =["123","alex"] v= "".join(li)

li=["hello",11,22,"fhsaj"]
stchar = ""
for item in li:
    stchar= stchar+str(item)
print(stchar)

# 参数
li.append(5)
print(li)
# 清空列表
#li.clear()
# 拷贝 浅拷贝
tescopy = li.copy()
#计算元素出现的次数
v = li.count(11)
print(v)

li.extend([9304,"合理"])#  扩展原每一个元素添加后面 参数是可迭代对象  内部有for循环
li.append([9304,"合理"]) # 整体追加到最后面
print(li)
#根据值获取当前值的索引位置 最左边优先
li.index(11)

li.insert(0,99) # 指定索引位置插入
print("sssssssssssssssssssss")
v = li.pop() # 默认删除最后一个 ，删除某个值 ，并获取被删除的值
li.pop(1) # 删除指定索引
print(li)
li.remove(11) # 删除列表中的指定值，左边优先
#PS pop, remove ,del li[0] del li[7:9] clear

li.reverse()# 将当前列表进行反转


li = [12,90,124,56]
#li.sort() # 从小到大
li.sort(reverse=True) # 从大到小排序
print(li)

列表是有序的，列表可以被修改

元组

#列表 list
li=[12,3,4]

# 元组 tuple 对列表的二次加工。元素不可被修改，并且不能增加或者删除
tu = (11,22,33,"呵呵",[1,2,3],)
# 一般写元组的时候，推荐在后面加上逗号,

#索引
v = tu[0]
print(v)
#切片
v = tu[0:2]
print(v)

# del tu[0]  error 不能删除

# 可以被for 循环  是可迭代对象
for item in tu:
    print(item)


s = "avdaf"
li= ["faf",123]
tu = (1234,"呵呵",[(33,44)])
# 字符串 转 元组
v = tuple(s)
print(v)
# 列表 转 元组
v = tuple(li)
print(v)

# 元组转列表
v = list(tu)
print(v)

# 元组只有字符串的时候,可以使用join 转字符串 "".join(tu)

# 元组也是有序的 ,元组的1级元素不可修改
print(tu) #(1234, '呵呵', [(33, 44)])
tu[2][0] = 324
print(tu)
# count 获取指定元素在元组中出现的次数 tu.count(22)
# index  

字典

# 字典 dict

inro = {"k1": "v1", "k2": "v2"} # 键值对
# 字典的value 可以是任何值
info = {
    "k1":18,
    "k2":True,
    "k3":[11,22,33,{
        "kk1":"vv1",
        "kk2":"vv2",
        "kk3":(11,22)
    }],
    "k4":(11,2233,44),
    1:123,
    (123,234):"fdas"
}


# 列表，字典 不能作为key ,元组可以  value 是什么都行
# boolean 值可以作为key ,但是有可能会和1，0 重复
info2 = {
    1:"afdas",
    True:"123",
    (123,234):"fdas"
}
# 字典无序
print(info[1],info[(123,234)],info["k1"])

# 由于是无序的，不能切片查找

# 删除
#del info["k1"]
print(info)


# 默认循环所有的key
for item in info:
    print(item)

for item in info.values():
    print(item)


# key value 的形式循环
for k,v in info.items():
    print(k,v)





# 根据序列 来创建字典， 统一的值
v = dict.fromkeys(["k1",123,999],1)

v2 = info["k1"] # 没有的话 会报错
v3 = info.get("k111",[1,2,3])# 不会报错，如果没有key 可以返回指定值
print(v3)


# 删除
v = info.pop("k1")

k,v = info.popitem() # 没有顺序 随机删除

# 设置值 ，已经存在，不设置，获取到当前key 对应的值
v=info.setdefault("k111",123)
print(k,v)


dic = {
    "k1":"v1",
    "k2":"v2"
}

dic.update({"k1":123,"k3":234}) # 已经存在的覆盖掉 ，不存在的更新上去

dic.update(k1=23424,k5=333333) # 参数名写成**keaygs 自动转换成为字典

print(dic)

tempalte = "i am {name},age:{age}"
#v = tempalte.format(name='alex',age=19)
print("............")
v = tempalte.format(**{"name":'alex','age':19}) # **keaygs 这种参数 可以写成name='' 也可以写成字典
print(v)

分页案例

arrays = [
];

for i in range(301):
    item = {"username":"name"+str(i),"email":"zkk"+str(i)+"@153.com","pwd":"passowrd"+str(i)}
    arrays.append(item)

print(arrays)


while(True):
    n = input("请输入页码")
    n = int(n)
    #10 个每页
    start = (n-1)*10
    end = n*10
    allitems = arrays[start:end]
    for item in allitems:
        dataitem = []
        for k,v in item.items():
            dataitem.append("\t"+k+"\t")
            dataitem.append(v)
        result ="".join(dataitem)
        print(result)

集合

# 无序

s = set('hello')
print(s)

s= set(['alex','sb'])
print(s)


s = {1,2,3,4,5,6}
# 添加
s.add('s')
print(s)
# 清空
# s.clear()
# print(s)

#s.pop() # 随机的删除
s.remove(1) # 删除元素，不存在会报错
s.discard('afdas') # 删除元素，不存在的话不会报错

print(s)


# 关系测试
python_l = ['a','b','c','a']
linux_l = ['b','c','d']
p_s = set(python_l)
l_s = set(linux_l)

print(p_s&l_s)
print(p_s.intersection(l_s)) #求交际

#求并集
print(p_s.union(l_s))
print(p_s|l_s)

#求差集
print(p_s-l_s)  # 存在左边的不存在右边的叫差集

#交叉补集  合到一起 抠出相同的部分

print("..........")
print(p_s.symmetric_difference(l_s))
print(p_s^l_s)



# 求完差集 赋值给第一个集合
p_s.difference_update(l_s)
#p_s=p_s-l_s
print(p_s,l_s)

s1 = {1,2}
s2 = {3.5}
print(s1.isdisjoint(s2)) # 没有交集返回True 否则返回false

print(s1.issubset(s2)) # s1 是s2 的子集
print(s2.issuperset(s2)) # s1 是s2 的父集

s1.update(s2) # s2 赋值给s1 更新多个值
print()

s= frozenset('hello') #这个定义不可变集合