python列表，元组，集合，字典

最新推荐文章于 2022-09-07 18:25:54 发布

MAGICbrook

最新推荐文章于 2022-09-07 18:25:54 发布

阅读量387

点赞数

分类专栏： python

本文链接：https://blog.csdn.net/qq_41829386/article/details/84587694

版权

python 专栏收录该内容

29 篇文章 2 订阅

订阅专栏

一.列表

1.列表的创建

数组：存储同一种数据类型的集合：scores：[1,2,3,4}
列表：打了激素的数组，可以存储任意数据类型的集合
例：

li = [1,2,2,True,'hello']
print(li,type(li))

在这里插入图片描述

（1）列表里是可以嵌套列表的

li = [1,2,3,False,'python',[1,2,3,4,5]]
print(li,type(li))

在这里插入图片描述

import  random
li = list(range(10))
random.shuffle(li)
pritn(li)

在这里插入图片描述

（2）空列表

li=[]
print(li,type(li))

在这里插入图片描述

2.列表的特性

1.索引

service = ['http','ssh','ftp']
#正向索引
print(service[0])
#反向索引
print(service[-1])

在这里插入图片描述

2.切片

service = ['http','ssh','ftp']
#列表的反转
print(service[::-1])
#除了第一个之外的其他元素
print(service[1:])
#除了最后一个之外的其他元素
print(service[:-1])

在这里插入图片描述

3.重复

service = ['http','ssh','ftp']
print(service * 3)

在这里插入图片描述

4.连接

service = ['http','ssh','ftp']
service1=['mysql','firewalld']
print(service+service1)

在这里插入图片描述

5.成员操作符

service = ['http','ssh','ftp']
print('firewalld' in service)
print('ftp' in service)
print('firewalld' not in service)
print('ftp' not in service)

在这里插入图片描述

6.列表里嵌套列表

service2 = [['http',80],['ssh',22],['ftp',21]]
# 索引
print(service2[0][0])
print(service2[-1][1])

在这里插入图片描述

3.列表元素的增加，删除，修改和查看

列表的增加（append，extend，insert）

service = ['http', 'ssh', 'ftp']
print(service + ['firewalld'])

append：追加，追加一个元素到列表中（默认在末尾添加）

service = ['http', 'ssh', 'ftp']
service.append('firewalld')
print(service)

extend：拉伸，追加多个元素到列表中（默认在末尾添加）

service = ['http', 'ssh', 'ftp']
service.extend(['hello','python'])
print(service)

insert：在索引位置插入元素

service = ['http', 'ssh', 'ftp']
service.insert(0,'firewalld')
print(service)

列表的删除（pop，remove，clear，del）

pop：弹出指定索引对应的元素

service=['http','ssh','ftp']
print(service.pop(0))
print(service)
service=['http','ssh','ftp']
print(service.pop(2))
print(service)

在这里插入图片描述
remove:删除列表中的指定元素

service = ['http', 'ssh', 'ftp']
service.remove('ftp')
print(service)
service.remove('https')
print(service)

在这里插入图片描述
clear：清空列表里面的所有元素

service = ['http', 'ssh', 'ftp']
service.clear()
print(service)

del：（python关键字）从内存中删除列表

service = ['http', 'ssh', 'ftp']
del service
print(service)

service = ['http', 'ssh', 'ftp']
print('删除列表第一个索引对应的值：',end='')
del service[1]
print(service)

service = ['http', 'ssh', 'ftp']
print('删除前两个元素之外的其他元素:',end='')
del service[2:]
print(service)

列表的修改

service = ['ftp','http', 'ssh', 'ftp']
# 通过索引，重新赋值
service[0] = 'mysql'
print(service)

在这里插入图片描述

service = ['ftp','http', 'ssh', 'ftp']
# 通过slice(切片)
service[:2] = ['mysql','firewalld']
print(service)

在这里插入图片描述

列表的查看（count，index，sort，）

查看元素出现的次数

service = ['ftp','http', 'ssh', 'ftp','ssh','ssh']
print(service.count('ftp'))

查看指定元素的索引值(也可以指定范围)

service = ['ftp','http', 'ssh', 'ftp','ssh','ssh']
print(service.index('ssh'))
print(service.index('ssh',4,8))

排序查看(按照ascii码进行排序)

service = ['ftp','http', 'ssh', 'ftp','ssh','ssh']
print(service.sort(reverse=True))
print(service)

对字符串排序不区分大小写

phones = ['alice','bob','harry','Borry']
#对字符串不区分小写
phones.sort(key=str.lower)
print(phones)
#对字符串不区分大写
phones.sort(key=str.upper)
print(phones)

二.元组

1.列表的创建

元组:带了紧箍咒的列表
不可变数据类型，没有增删改查
可以存储任意数据类型

定义元组

t = (1,1.2,True,'westos')
print(t,type(t))

如果元组里面包含可变数据类型，可以间接修改元组内容

t1 = ([1,2,3],4)
t1[0].append(4)
print(t1)

空元组

t2 = ()
print(t2)
t3 = tuple([])
print(t3)

元组如果只有一个元素，后面一定要加逗号，否则数据类型不确定

t4 = (1,)
print(t4,type(t4))

2.元组的特性

1.索引

tuple = (1,1.0,True,'westos')
print(tuple[0])
print(tuple[-1])

2.切片

tuple = (1,1.0,True,'westos')
print(tuple[1:])
print(tuple[:-1])
print(tuple[::-1])

3.连接

tuple = (1,1.0,True,'westos')
print(tuple + (1,2,3))
print(tuple + [4,5,6])
print(tuple + 'westos')

在这里插入图片描述

4.重复

tuple = (1,1.0,True,'westos')
print(tuple * 5)

5.for循环

tuple = (1,1.0,True,'westos')
for i in tuple:
    print(i)

6.成员操作符

tuple = (1,1.0,True,'westos')
print(1 in tuple)
print(i not in tuple)

3.元组的常用方法

查看元素的索引值

t = (1,2,'a','c','a')
print(t.index('c'))

查看元素在元组中出现的次数

t = (1,2,'a','c','a')
print(t.count('a'))

4.元组的应用场景

1.变量交换数值

a = 1
b = 2
b,a = a,b
print(a,b)

1.先把(a,b)封装成了一个元组 (1,2)
2. b,a = a,b ===> b,a = (1,2)
3. b = (1,2)[0] a =(1,2)[1]

2.打印变量值

name = 'westos'
age = 11
t = (name,age)
print('name:%s,age:%d' %(name,age))
print('name:%s,age:%d' %t)

3.元组的赋值：有多少个元素，就用多少个变量接收

t = ('Westos',10,100)
name,age,score = t
print(name,age,score)

4.元组的排序

（1）

scores = (100,89,45,78,65)
# 先对元组进行转换
# scoreli = list(scores)
# scoreli.sort()
# # print(scoreli)

（2）

# scores = (100,89,45,78,65)
# scores_sort = sorted(scores)
# print(scores_sort)

5.比赛计数器

scores = (100,89,98,60,90,67)
scores = sorted(scores)
# python2中*middle不能使用的
min_score,*middle,max_score = scores
print(min_score,'~~~~',*middle, '~~~~~~',max_score)
print('最终成绩为:%s' %(sum(middle)/4))

深拷贝和浅拷贝

浅拷贝:copy.copy()
深拷贝:copy.deepcopy()

1.

如果,用copy.copy() ，copy.deepcopy()对一个全部是不可变类型的数据进行数据拷贝,那么它们的结果相同,都是引用

2.

如果用copy.copy()对元组进行拷贝（元组里含有可变类型数据），那么它

三.集合

1.集合的定义

集合里面的元素是不可重复的

s = {1,2,3,4,5,6,6,3,3,2}
print(s,type(s))
s1 = {1}
print(s1,type(s1)

定义空集合

s2 = {}  #默认情况是dict,称为字典
print(s2,type(s2))
# 定义一个空集和
s3 = set([])
print(s3,type(s3))

2.集合的特性（可变数据类型）

集和支持的特性只有成员操作符(索引切片重复连接均不支持)

s = {1,2,3}

print(1 in {1,2,3})
print(1 not in s)

for循环

s = {1,2,3}
for i in s:
    print(i,end=' ')
print()
print('~~~~~~')

在这里插入图片描述

for + index

s = {1,2,3}
for i,v in enumerate(s):
    print('index: %s,value:%s' %(i,v))

在这里插入图片描述

3.集合的常用方法

1.列表去重

li = [1,2,3,4,1,2,3]
print(list(set(li)))

2.增加

s = {6,7,3,1,2,3}
# # 增加
s.add(8)
s.add(4)
print(s)

在这里插入图片描述
增加多个元素

s = {6,7,3,1,2,3}
s.update({9,10,11})
print(s)

在这里插入图片描述

3.删除

s = {6,7,3,1,2,3}
s.pop()
print(s)

在这里插入图片描述
删除指定元素

s = {6,7,3,1,2,3}
s.remove(3)
print(s)

4.交集并集差集对等差分子集超级

s1 = {1, 2, 3}
s2 = {2, 3, 4}
# 并集
print('并集:', s1.union(s2))
print('并集:', s1 | s2)

s1 = {1, 2, 3}
s2 = {2, 3, 4}
# 交集
print('交集:',s1.intersection(s2))
print('交集:',s1 & s2)

s1 = {1, 2, 3}
s2 = {2, 3, 4}
# 差集
# 可以理解为s1中有哪些s2中没有的元素
print('差集:',s1.difference(s2)) # s1 - (s1&s2)
# 可以理解为s2中有哪些s1中没有的元素
print('差集:',s2.difference(s1)) # s2 - (s1&s2)
print('差集:',s1-s2)
print('差集:',s2-s1)

s1 = {1, 2, 3}
s2 = {2, 3, 4}
# 对等差分:并集 - 交集
print('对等差分:',s1.symmetric_difference(s2))
print('对等差分:',s1^s2)

s3 = {1,2}
s4 = {1,2,3}
# s3是否为s4的子集
print(s3.issubset(s4))

s3 = {1,2}
s4 = {1,2,3}
# s3是否为s4的超集
print(s3.issuperset(s4))

s3 = {1,2}
s4 = {1,2,3}
# 两个集和是不是不相交
print(s3.isdisjoint(s4))

四.字典

1.字典的创建

字典:key-value 键值对存储的一种数据结构
value值可以是任意数据类型:int float long list tuple set dict

d = {}
print(type(d))

d = {
    'tom':[18,'男','玩手机'],
    'tony':[18,'男','修手机']
}
print(d)
print(d['tom'])

d2 = {
    'a':1,
    'b':2
}
print(d2)

d3 = {

    'a':{1,2,3},
    'b':{2,3,4}
}

print(d3)

工厂函数

d5 = dict(a=1,b=2)
print(d5)

字典的嵌套

students = {
    '06163012':{
        'name':'王凯',
        'age':18,
        'score':90
    },
    '03162003':{
        'name':'管良虎',
        'age':19,
        'score':80
    }
}

print(students['03162003']['name'])

2.字典的特性

字典不支持索引，切片，重复和连接

1.成员操作符（判断的是某个值是否为字典的key）

d = {
    '1':'a',
    '8':'b',
    '2':'a'
}
print('1' in d)
print('1' not in d)

2.for循环：默认遍历字典的key值

d = {
    '1':'a',
    '8':'b',
    '2':'a'
}
for key in d:
    print(key)

遍历字典

d = {
    '1':'a',
    '8':'b',
    '2':'a'
}
for key in d:
    print(key,d[key])

3.字典的增加

1.增加一个元素

1).如果key值存在，则更新对应的value值
2).如果key值不存在，则添加对应的key-value值

services = {

    'http': 80,
    'ftp': 21,
    'ssh': 22
}
services['mysql'] = 3306
print(services)
services['http'] = 443
print(services)

2.添加多个key-value值

1).如果key值存在，则更新对应的value值
2).如果key值不存在，则添加对应的key-value值

services = {

    'http': 80,
    'ftp': 21,
    'ssh': 22
}
service_backup = {
     'tomcat':8080,
     'https':443,
     'http':8888
 }
services.update(service_backup)
print(services)
services.update(flask=9000,http=999)
print(services)

3.setdefault添加key值

1).如果key值存在,则不做修改
2).如果key值不存在,则添加对应的key-value值

services = {

    'http': 80,
    'ftp': 21,
    'ssh': 22
}
services.setdefault('http',9000)
print(services)
services.setdefault('oracle',44575)
print(services)

4.字典的删除

1.del关键字

services = {

    'http': 80,
    'ftp': 21,
    'ssh': 22,
    'mysql':3306
}
del services['http']
print(services)

2.pop删除指定的key的key-value值

1.)如果key存在,删除,并且返回删除key对应的value值
2.)如果key不存在,直接报错

services = {

    'http': 80,
    'ftp': 21,
    'ssh': 22,
    'mysql':3306
}
item = services.pop('http')
print(item)
print(services)

3.popitem删除最后一个key-value

services = {

    'http': 80,
    'ftp': 21,
    'ssh': 22,
    'mysql':3306
}
item = services.popitem()
print('删除的key-value对应的是:',item)
print(services)

4.清空字典内容

services = {

    'http': 80,
    'ftp': 21,
    'ssh': 22,
    'mysql':3306
}
services.clear()
print(services)

5.字典的修改和查看

1.查看字典的key值

service = {
    'http':80,
    'mysql':3306
}
print(service.keys())

2.查看字典的value值

service = {
    'http':80,
    'mysql':3306
}
print(service.values())

3.遍历字典

service = {
    'http':80,
    'mysql':3306
}

#（1）遍历
for k,v in service.items():
    print(k,'---->',v)
#（2）遍历
for k in service:
    print(k,'---->',service[k])

4.查看指定key对应的value值（key值不存在,程序会报错）

service = {
    'http':80,
    'mysql':3306
}
print(service['http'])
print(service['https'])

5,。get方法获取指定key对应的value值

1).如果key值存在,返回对应的value值
2).如果key值不存在,默认返回None,如果需要指定返回的值,传值即可

service = {
    'http':80,
    'mysql':3306
}
print(service.get('https'))

MAGICbrook

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
python列表，元组，集合，字典

一.列表1.列表的创建数组：存储同一种数据类型的集合：scores：[1,2,3,4}列表：打了激素的数组，可以存储任意数据类型的集合例：li = [1,2,2,True,'hello']print(li,type(li))（1）列表里是可以嵌套列表的li = [1,2,3,False,'python',[1,2,3,4,5]]print(li,type(li))imp...
复制链接

扫一扫