列表 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
[<built-in function print>, None, 1, 'abd', True]
lst3 = [print,None,1,'abd',True]
lst3
[<built-in function print>, None, 1, 'abd', True]
lst3[::-2]
[True, 1, <built-in function print>]
lst3[::-1]
[True, 'abd', 1, None, <built-in function print>]
lst3[:-2]
[<built-in function print>, 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())
<class 'dict_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 "<input>", line 1, in <module>
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}
|