python的容器类型

列表 list
可以存放任何数据类型

可变数据类型 vs 不可变数据类型
在原地址内存空间里，能修改内容的就是可变数据类型，不能修改内容的就不是可变数据类型

列表元素的增加操作                                    lst=[10,20,30]
append（）（在列表末尾添加一个元素）                    lst.append(100)
extend（） （在列表的末尾至少添加一个元素）      lst2=['hello','world']  lst.exted(lst2)
insert（）  （在列表的任意位置添加一个元素）          lst.insert(1,90)
切片                    lst3=[Tru,False,'hello']  lst[1:]=lst3

切片例题:
lst3 = [print,None,1,'abd',True]
lst3
[, None, 1, 'abd', True]
lst3 = [print,None,1,'abd',True]
lst3
[, None, 1, 'abd', True]
lst3[::-2]
[True, 1, ]
lst3[::-1]
[True, 'abd', 1, None, ]
lst3[:-2]
[, None, 1]


列表元素的删除操作                    lst=[10,20,30,40,50,60,30]
remove（）（一次删除一个元素，重复元素删除第一个）    lst.remove(30)
pop（）  （删除一个指定索引位置上的元素，不指定索引，删除列表最后一个元素）  lst.pop(1)   lst.pop()
切片  （一次至少删除一个元素）    new_lst=lst[1:3](产生一个新的列表)     lst[1:3]=[] (不产生新的列表对象，而是删除原列表中的内容)
clear（）  （清空列表）         lst.clear()
del  （删除列表）             del lst


列表的排序操作    sort 进行排序       reverse 进行反转
lst=[20,40,10,98,54]
print('排序前的列表',lst)
lst.sort()     #升序排序
print('排序后的列表',lst)
lst.sort(reverse=True)      #表示降序排序
lst.sort(reverse=False)     #表示升序排序
new_lst=sorted(lst)

查找统计类：
copy复制拷贝    count出现多少次数   index出现的下标位置

例题：
有一条船，船上有40个人。船超载20个人，
每数到第九个就让他下船，最后输出哪些人下船了。
num = list(range(1,41))
while len(num) > 20:
    a = num[8]
    num = num[9:] + num[:8]
    print(f'{a}', end='#')

lst1 = [1,2,4,5,6]
for i in lst1:
    print(i)

成员关系运算符   （in）     （not in）
lst1 = [1,2,4,5,6]
if 67 in lst1:
    print('ok')
else:
    print('no')


enumerate()  可以返回数值和下标



# 从键盘接受用户输入，输入一个整数10，
# 返回两个数相加等于10这个数的下标 2,6
lst = [2,5,6,7,3,1,4]
i=0
sum = int(input('请输入一个整数：'))
for i in range(len(lst)):
    for j in range(i+1,len(lst)):
        if lst[i] + lst[j] == sum:
            print(f'{lst[i]}与{lst[j]}的和为{sum}，下标分别为{i}，{j}')

或者：
lst = [2,5,6,7,3,1,4]
num=int(input('请输入一个整数'))
for i,j in enumerate(lst):
    num1 = num - j
    if num1 in lst[i+1:] and lst.index(num1) > i :
        print(f"两数之和等于{num}的下标为{i}，{lst.index(num1)}")


元组（tuple）
有序的项目集合
可以存放任何数据类型
不可变数据类型

内建函数     工厂函数（类型转换）

#############元组的定义##############
只有一个元素，需要在元素后面加逗号
元组里面包含列表，列表是可以改变的，因为列表是可变数据类型，列表里的元素更改不会改变列表本身
不可变数据类型

例题：用户检测小工具
•欢迎语：”欢迎使用用户检测系统“
•定义一个用户列表，包含用户名密码：[('root', '123456'), ('admin', 'admin'),]
•键盘输入用户名、密码
•判断并验证用户密码，并给予相应提醒
lst=[('root','123456'),('admin','admin')]
print('欢迎使用用户检测系统')
u_name=input('请输入用户名')
u_passwd=input('请输入密码')
tup=(u_name,u_passwd)
if lst.count(tup) != 0:
    print('登陆成功')
else:
    print('用户名或密码错误')

Python 字典(Dictionary) items() 函数以列表返回可遍历的(键, 值) 元组数组

d = {'one': 1, 'two': 2, 'three': 3}
>>> d.items()
dict_items([('one', 1), ('two', 2), ('three', 3)])
>>> type(d.items())


字典( dict )
什么是字典( dict )
•字典是Python中一个键值映射的数据结构
•字典是无序的•字典是可变对象
•key必须是唯一的, so 天生去重

字典的定义
•元组通过花括号中用键 / 值对用冒号分割，而各个对用逗号分割

key必须是可hash对象
hash  是一类算法的统称，将任意长度的输入变成固定长度的输出
hash  是一项单向加密技术，可以通过原文得到hash值，但是不能通过hash去推导出原文
      常常用在验证文件的完成性，有没有被篡改，传输过程中有没有传完整

字典的原理
字典的本质就是一个空闲的hash表
以空间换时间

key必须是唯一的，而且必须是可hash对象
value可以使任何值

dict.get(key,default)   获取key的值，如果没有就返回default的值
                        如果没有default，不存在key的话就返回None

新增和修改
dict[key]=value

统计字符串中的每个字符出现的次数，不要重复输出
str1='hfisidjofhosif'
d1={}
for i in str1:
    d1[i]=d1.get(i,0) + 1
print(d1)


删除
pop()
popitem()


d1 = {'a':1}
d2 = {'b':2}
dict(d1,**d2)  生成一个新字典
{'a': 1, 'b': 2}
d1.update(d2)   updata会覆盖
d1
{'a': 1, 'b': 2}


print('欢迎使用用户检测系统')
d1={'root':'123456','admin':'admin'}
while 1:
    u_name=input('请输入用户名')
    u_passwd=input('请输入密码')
    if u_name == 'q' or u_passwd == 'q':
        break
    if u_name in d1 and u_passwd == d1[u_name]:
        print('验证成功')
    else:
        print('验证失败')
print('慢走不送')


集合：
无序,不重复
可变的
看做一个只有key的字典
元素唯一，天生去重
可hash对象


.add()新增
.update()添加可迭代对象

例:
x = set('runoob')
>>> y = set('google')
>>> x, y
(set(['b', 'r', 'u', 'o', 'n']), set(['e', 'o', 'g', 'l']))   # 重复的被删除
>>> x & y         # 交集
set(['o'])
>>> x | y         # 并集
set(['b', 'e', 'g', 'l', 'o', 'n', 'r', 'u'])
>>> x - y         # 差集
set(['r', 'b', 'u', 'n'])
>>>

例如：
s1
{1, 2, 3}
s1.update({'c':1,'b':3})
s1
{1, 2, 3, 'c', 'b'}
s1.add('asf')
s1
{'asf', 1, 2, 3, 'c', 'b'}
s1.update({'c':1,'b':3}.items())  #转换成元组
s1
{'asf', 1, 2, 3, 'c', ('b', 3), ('c', 1), 'b'}


remove()删除   如果删除的元素没有，会报错
discard()删除  不会报错

例如：
s1.remove(5)
Traceback (most recent call last):
  File "", line 1, in 
KeyError: 5
s1.discard(5)


s1={1,2,3,4,5,6}
s2={1,2,3,4,4,5,6,7,3}
s1&s2                    #取交集
{1, 2, 3, 4, 5, 6}
s1|s2                    #取或，都存在的,并集
{1, 2, 3, 4, 5, 6, 7}
s1 -s2                   #在s1里取s2没有的
set()
s2 -s1                   #在s2里取s1没有的
{7}
s1 ^ s2                  #并集减去交集，对称差集
{7}