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
[<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}

本图文内容来源于网友网络收集整理提供,作为学习参考使用,版权属于原作者。
THE END
分享
二维码
< <上一篇
下一篇>>