Python基础笔记-列表(list)-元组(tuple)-字典(dict)-集合运算

最新推荐文章于 2024-05-24 09:16:22 发布
最新推荐文章于 2024-05-24 09:16:22 发布
阅读量1.1k 收藏
点赞数
分类专栏： Python基础 文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46567096/article/details/124415223
版权

列表 （list）

  • 列表是Python中的一个对象
  • 列表中可以保存多个有序的数据
  • 列表是可以存储对象的对象
列表的使用：

  1. 列表的创建

    • #列表存储的数据，我们称为元素
#一个列表中可以存储多个元素，也可以在创建列表时，来指定列表中的元素
my_1ist=[10]			#创建一个只包含一个元素的列表

#当向列表中添加多个元素时，多个元素之间使用，隔开
my_1ist=[10,20,30,40,50]			#创建了一个保护有5个元素的列表

print(my_1ist)
#列表中的对象都会按照插入的顶序存储到列表中
#第一个插入的对象保存到第一个位置，第二个保存到第二个位置
#我们可以通过索引(index)来获取列表中的元素
#索引是元素在列表中的位置，列表中的每一个元素都有一个索引
#索引是从开始的整数，列表第一个位置索引为0，第二个位置索引为1，第三个位置索引为2，以此类推

#通过索引获取列表中的元素
#语法：my_list[ 索引值 ]
print(my_1ist[0])
#如果使用的索引超过了最大的范围，会抛出异常
#print(my_1ist[5])		#IndexError: list index out of range

#获取列表长度： len( ) 
print(len(my_1ist))

    • 切片

      #切片
#切片指从现有列表中，获取一个子列表
#创建一个列表，一般创建列表时，变量的名字会使用复数
my_list=[1, 2, 3, 4, 5, 6]
#列表的索引可以是负数
#如果索引是负数，则从后向前获取元素，-1表示倒数第一个，-2表示倒数第二个以此类推
print(my_list[-2])

#通过切片来获取指定的元素
# 语法：列表[起始 : 结束 : 步长]  #步长默认为 1
#做切片操作时，返回的是一个新列表对原列表没影响
#通过切片获取元素时，会包括起始位置的元素，不会包括结束位置的元素（包前不包后）
print(my_list[1:4])
print('my_list[1:5:2]:',my_list[1:5:2])
print(my_list[0:])

    • 序列通用操作

      #+可以将两个列表拼接为一个列表
a = [1,2,3]+[3,5,6]
print(a)
#* 可以将列表重复指定的次数
b =[1,2,3]*5
print(b)

# in和not in
# in用来检查指定元素是否存在于列表中
# 如果存在，返回True,否则返回False

#not in用来检查指定元素是否不在列表中
#如果不在，返回True,否则返回False
print(2 in a)
print(100 not in a)

#len( ) 获取列表中元素个数

#min() 获取列表中最小值
#max() 获取列表中最大值
print(min(a),max(a))

#列表.index() 获取指定元素在列表中第一次出现的索引
print(a.index(3))
#列表.count() 统计指定元素在列表中出现的次数
print(a.count(3))

  2. 操作列表中的数据

    • 列表的方法
a = [1,2,3,3,5,6]
# append()  --> 向列表的最后添加一个元素
a.append('jen')	
print(a)		#[1, 2, 3, 3, 5, 6, 'jen']

#insert(i,x) --> 向列表的指定位置插入一个元素
a.insert(6,'kang')
print(a)   		#[1, 2, 3, 3, 5, 6, 'kang', 'jen']

#extend（）
#使用新的序列来扩展当前序列
#需要一个序列作为参数，它会将该序列中的元素添加到当前列表中
a.extend(['jk', 12])	
print(a)		#[1, 2, 3, 3, 5, 6, 'kang', 'jen', 'jk', 12]

#clear()
#清空列表
#a.clear（）

#pop()
#根据索引删除并返回被册删除的元素
resu1t=a.pop(2)#删除索引为2的元素
print(a) 		#[1, 2, 3, 5, 6, 'kang', 'jen', 'jk', 12]
result=a.pop()  #删除最后一个
print(a) 	#[1, 2, 3, 5, 6, 'kang', 'jen', 'jk']
print('result:',result) 	#12
  • 遍历列表
a = [1,2,3,3,5,6]
'''
#通过wehile
i = 0
while i < len(a) :
	print(a[i])
	i += 1

'''
#嵌套循环
i = 0
while i < 5 :
	j = 0
	while j < i + 1 :
		print("*",end='')
		j += 1
	print()
	i += 1
'''
*
**
***
****
*****
'''

#通过for循环来 便利
#  	for 变量 in 序列 ：
#			代码块
#序列中有几个元素就执行几次

for x in a :
	print(x)
  • range() 函数和可变对象
#range(1, 2, 3) 可以用来生成一个自然数的序列
#1.起始位置(可以省略，默认是0)
#2.结束位置
#3.步长(可以省略，默认是1)
r = range(5)
r = range(0,10,2)  #[0, 2, 4, 6, 8]
#r = range(10, 0, -1)

print(list(r))

#通过range()  可以指定for循环 次数
for i in range(1,10):
	print(i)
    
'''
可变对象（list）
'''

a = [1,2,3]
print('修改前：', a, id(a))		#修改前： [1, 2, 3] 2122996012040

#通过索引修改列表
a[1] = 'tom'
print('修改后：', a, id(a))		#修改后： [1, 'tom', 3] 2122996012040

a = [1,2,3]
print('重新赋值后：', a, id(a))		#重新赋值后： [1, 2, 3] 2122996561608
a = [1,2,3]
b = a
b[0] = '100'
print('a:', a, id(a))			#a: ['100', 2, 3] 2100698789512
#两个对象指向同一个内存地址
print('b:', b, id(b))			#b: ['100', 2, 3] 2100698789512
#一般只有在为变量赋值时才是修改变量，其余的都是修改对象
  • ’==‘ ’!=‘ ‘is’ ‘is not’
# ’==‘   ’!=‘ ‘is’  ‘is not’
# ==，!=   比较对象值是否相等
#is，is not :比较的是对象的id是否相等（比较两个对象是否是同一个对象）

a = [1,2,3]
b = [1,2,3]

print(a, b)
print(id(a), id(b))
print(a == b)		#True	#a和b的值相等，使用==会返回True
print(a is b)		#False	#a和b不是同一个对象，内存地址不同，使用is会返回False

元组 tuple

  • 元组是一个不可变的序列
  • 它的操作的方式基本上和列表是一致的,所以你在操作元组时，可以把元组当成是一个不可变的列表
  • 般当我们希望数据不改变时，就使用元组，其余情况都使用列表
  1. 创建元组
#创建一个元组
my_tuple = (1,2,3)
#当元组不是空元组时，括号可以省略
#如果元组不是空元组，它里边至少要有一个，
my_tuple1 = 1,2,3,4,5
my_tuple1 = 1,
print(my_tuple1, type(my_tuple1))  		#(1,) <class 'tuple'>

#元组的解包（解构）
a,b,c = my_tuple 
print(a,b,c)		#1 2 3

#在对一个元组进行解包时，变量的数量必须和元组中的元素的数量一致
#也可以在变量前边添加一个*，这样变量将会获取元组中所有剩余的元素
# * 不能同时出现 2个 或 2个以上
a,*c = my_tuple 
#*a,c = my_tuple
print('a:',a,"c:",c) 		#a: 1 c: [2, 3]

字典（dict）

  • 产考资料： https://docs.python.org/3/library/stdtypes.html#mapping-types-dict

  • 字典属于一种新的数据结构，称为映射(mapping)

  • 字典的作用和列表类似，都是用来存储对象的容器

  • 列表存储数据的性能很好，但是查询数据的性能的很差

  • 在字典中每一个元素都有一个唯一的名字，通过这个唯一的名字可以快速的查找到指定的元素

  • 在查询元素时，字典的效率是非常快的

  • 在字典中可以保存多个对象，每个对象都会有一个唯一的名字

  • 这个唯一的名字，我们称其为键(key),通过key可以快速的查询value

    # 字典

a = { } 		#创建一个空字典

#创建一个保护有数据的字典
#语法：
#  { key:value, key:value, key:value }

#字典的值可以是任意对象
#字典的键可以是任意的 "不可变对象" -->(int、str、bool、tuple...)
#(key) 字典的键 是不可以 重复的 ，如果出现重复后面的会替换掉前面的
d = {'name':'kang','age':'l8','gender':'男'}

print(d, type(d))

#通过 键 来获取值
print(d['name'], d['age'])

#创建 字典
#使用 dict() 来创建字典
#
d = dict(name='kang',age=15,)
print(d, type(d), d['age'] )		#{'name': 'kang', 'age': 15} <class 'dict'> 15

#也可以把包含双值序列的列表转换为 字典
#双值序列，序列中只有两个值，[1,2] ('a', 3) 'ab'
#子序列，如果序列中的元素也是序列，那么我们就称这个元素为子序列

c = dict([('name',"ads"), ('a', 3)])
print(c, type(c), c['a'])		#{'name': 'ads', 'a': 3} <class 'dict'> 3


#len() 获取键值对的 个数
print(len(c))		#2

#in 检查字典中是否包含指定的键
#not in 检查字典中是否不包含指定的键
print('test'in c)		#False


#通过 [ ] 来获取值时，如果键不存在，会抛出异常KeyError
# get(key[, default ]) 		该方法用来根据键来获取字典中的值
# 如果获取的键在字典中不存在，会返回None
#print(c.get('test'))		#None
print(c.get('test', '返回值'))		#返回值


#修改字典
#d[key]=value如果key存在则覆盖，不存在则添加
c['name'] = 'aaaa'			#修改字典的key-value
c['test'] = 'test'			#向字典中添加key-value	
print(c)			#{'name': 'aaaa', 'a': 3, 'test': 'test'}


#setdefault(key[,default])		可以用来向字典中添加key-value
#	如果key已经存在于字典中，则返回key的值，不会对字典做任何操作
#	如果key不存在，则向字典中添加这个key,并设置value
result=d.setdefault('name','小明')
print(result)		#kang
result=d.setdefault('hello','小明')
print(result)		#小明
print(d)			#{'name': 'kang', 'age': 15, 'hello': '小明'}


# update([other])
# 将其他的字典中的 key-value 添加到当前字典中
# 如果有重复的key,则后边的会替换到当前的
t = dict(a='kang', b=12, c='kang')
t1 = dict(a='相同键', b1=12, c2='kang')

t.update(t1)
print('t:',t)			#t: {'a': '相同键', 'b': 12, 'c': 'kang', 'b1': 12, 'c2': 'kang'}

    删除和遍历

    t = {'a': '相同键', 'b': 12, 'c': 'kang', 'b1': 12, 'c2': 'kang'}
# 删除，可以更用 del( ) 来删除子典中的key-value
# 删除不存在的 key  会报错
del t['a']
print(t)		#{'b': 12, 'c': 'kang', 'b1': 12, 'c2': 'kang'}

# pop(key[,default])
# 根据key删除字典中的key-value
# 会将被删除的value返回！
# 如果删除不存在的key,会抛出异常
# 如果指定了默认值，再删除不存在的key时，不会报错，而是直接返回默认值
r = t.pop('b')
print(r, t)			#12  {'c': 'kang', 'b1': 12, 'c2': 'kang'}
r = t.pop('z','返回值')
print(r, t)			#返回值 {'c': 'kang', 'b1': 12, 'c2': 'kang'}


#popitem()
#	随机删除字典中的一个键值对，一般都会删除最后一个键值对
#	删除之后，它会将删除的key-value作为返回值返回
#返回的是一个元组，元组中有两个元素，第一个元素是删除的key,第二个是删除的value
#t.popitem()
#result=t.popitem()

#### clear()  清空字典
#t.clear()
#print(t)			#{}


# copy（）
# 该方法用于对字典进行浅复制
# 复制以后的对象，和原对象是独立，修改一个不会影响另一个
# 注意，浅复制会简单复制对象 内部的值 ，如果值也是一个可变对象，这个可变对象不会被复制
a = {'a': 1, 'aa':{'name':'kang', 'age':12}, 'b': 2, 'c': 3}
cp_a = a.copy()
cp_a['aa']['age'] = 66

print(a,id(a))			#{'a': 1, 'aa': {'name': 'kang', 'age': 66}, 'b': 2, 'c': 3} 3194286571256

print(cp_a,id(cp_a))		#{'a': 1, 'aa': {'name': 'kang', 'age': 66}, 'b': 2, 'c': 3} 3194286579784



### 字典的遍历

# keys()  该方法会返回字典的所有的key
# 该方法会返回一个序列，序列中保存有字典的所有的键
ss  = {'name':'kang', 'age':12, 'b': 2, 'c': 3}
#ss = {'a': 1, 'aa':{'name':'kang', 'age':12}, 'b': 2, 'c': 3}
#通过遍历 keys()  来获取所有key 或 value
for k in ss.keys() :
	print(k, ss[k])
'''
name kang
age 12
b 2
c 3
'''

# values()
# 该方法会返回一个序列，序列中保存有字典的值
'''
for k1 in ss.values() :
	print(k1)
'''

# items（）
# 该方法会返回字典中所有的项
# 它会返回一个序列，序列中包含有双值子序列
# 双值分别是，字典中的key和value
print(ss.items()) 			#dict_items([('name', 'kang'), ('age', 12), ('b', 2), ('c', 3)])
for k3,v in ss.items() :
	print(k3, '--', v)

'''
name -- kang
age -- 12
b -- 2
c -- 3
'''

集合

#创建 集合
a = {1,2,3,4,5,6,1,1,1,1,}
print(a, type(a))			#{1, 2, 3, 4, 5, 6} <class 'set'>

a = set() # 创建空集合
# 可以使用 set()  将列表和字典转换为集合 
a = set([1,2,3,4,5,6,1,1,1,1])
a1 = set({'name':'kang', 'age':12, 'b': 2, 'c': 3})
print(a, type(a))			#{1, 2, 3, 4, 5, 6} <class 'set'>
print(a1, type(a1))			#{'name', 'c', 'b', 'age'} <class 'set'>  -->字典转换为集合时 只保留 键(key)
#使用 in 和 not in 来检查集合中的元素

#使用 len() 来获取集合中元素的数量

# add()  向集合中添加元素
a.add(10)
print(a, type(a))			#{1, 2, 3, 4, 5, 6, 10} <class 'set'>

# update() 将一个集合中的元素添加到当前集合中
# update()  可以传递序列或字典作为参数，字典只会使用键
a3 = set('tom')
a.update(a3)
a.update(('a', 's', 'ss', 420))

print(a, type(a))			#{1, 2, 3, 4, 5, 6, 't', 'm', 'o', 10, 'a', 's', 'ss', 420} <class 'set'>



###删除

#pop() 随机删除一个元素
r = a.pop()
print(a, r) 	#{2, 3, 4, 5, 6, 't', 420, 10, 'm', 's', 'ss', 'a', 'o'} 1
# remove()  删除集合中指定元素
#a.remove(2)	

#clear()   清空集合
#a.clear()

#copy()  对集合进行浅复制

集合运算

#在对集合做运算时，不会影响原来的集合，而是返回一个运算结果
a = {1,2,3,4,5,6}
a1 = {3,5,7,10,2}
# & 交集运算
r = a & a1
print(r)			#{2, 3, 5}

# |  并集运算
r = a1 | a 
print(r)			#{1, 2, 3, 4, 5, 6, 7, 10}

# -  差集
r = a - a1
print(r)			#{1, 4, 6}

#  ^   异或集获取只在一个集合中出现的元素
r = a ^ a1
print(r)			#{1, 4, 6, 7, 10}

#<=   检查一个集合是否是另一个集合的子集
r = a <= a1
print(r)			#False

# < 检查一个集合是否是另一个集合的真子集
# 如果 超集b 中含有 子集a 中所有元素，并且b中还有a中没有的元素，则b就是a的真超集，a是b的真子集
# r = a < b
r = {1, 2, 3} < {1, 2, 3, 4} 
print(r)			#True

#>=, >
禅荣
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python编程基础 | Python编程基础元组（tuple)和字典（dict）
前程算法屋的博客
07-07 365
Python编程基础 | Python编程基础元组（tuple)和字典（dict）
python基础--字符串、列表、元组、集合、字典
m0_46506670的博客
06-23 216
** python基础 ** 1、基础 函数 2、进阶 面对对象、多线程、 1、为什么学python python比较好学： 语法简单 python更加贴近于人类的自然语言 python具有丰富的第三方库 python笔记好用： 人工智能 数据处理 自动化测试 web开发 2、解释性语言呵编译型语言？ 解释性语言：编译官，一句一句的翻译执行 编译型语言：文字翻译人员，一次性全部翻译完成 3、python解释器的安装 1）python3.5开始不再支持xp 2）win7要安装sp1补
Python学习笔记 - 数据结构：元组、列表、集合和字典
yunfan
06-27 2425
本文主要介绍Python中的几种常见数据结构。其中包括序列、元组、列表、集合和字典。
python学习笔记--字典，列表，元组，集合
qq_39487799的博客
07-14 323
字典 字典是另一种可变容器模型，且可存储任意类型对象。 键一般是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一。 >>> dict = {'a': 1, 'b': 2, 'b': '3'} >>> dict['b'] '3' >>> dict {'a': 1, 'b': '3'} #值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。 一个简单的字典实例： dict2 = { ‘abc’: 123, 98.6: 37 } 访问字
python列表可以作为集合的元素吗_Python笔记3---列表，元组，字典，集合
weixin_39601641的博客
12-10 3908
列表及方法列表是python内置的数据结构或者说是类型之一,可以包含各种数据类型作为元素.有点类似于C语言里的链表.列表变量是一个引用,还好学过C语言,所以要注意,对于引用的修改就是用指针操作,会直接修改原本的列表对象,只有部分方法是不修改的.list()用来转换列表,另外列表还有列表生成式,是非常灵活的写法,也是很python的写法.除了正常的切片,索引,通过赋值修改某个位置的元素,in 等内置...
python学习笔记-列表，元组，集合，字典
qq_43227756的博客
02-11 118
list(列表) list的创建 直接创建，用中括号，其中内容用英文逗号隔开 L1 = [1,2,3,a,b,c] 第二种方法 L2 = list() 列表的常见操作 访问 使用下标操作，也叫索引 元素索引从零开始 切片 对列表进行任意一段的截取 截取后生成新的列表 # del 删除 a = [1,2,3,4,5,6] del a[2] print(a) [1, 2, ...
python笔记Ⅴ--元组、字典、集合
gaoxiaochan的博客
09-01 523
python中的元组、字典和集合
2022-11-21 Python学习笔记--元组、字典、集合
m0_73809176的博客
11-21 133
元组、字典、集合
学习笔记-Python基础篇04—元组、集合与字典
可以叫我才哥
05-25 315
文章目录元组 tuple创建空元组创建元组元组元素的访问元组的不可改变序列解包集合 set创建空集合创建集合集合的数学运算字典 dict创建字典访问字典中的值获取键或值获取键值对字典的操作方法 元组 tuple 上一节我们介绍了列表List，在对列表进行使用的时候是可以修改其内部元素值的。有时候我们需要创建一系列不可修改的元素，便会用到元组。 创建空元组 元组用圆括号来标识，创建空元组可以使用()或者内建函数tuple >>> Atuple = () >>> Atuple
python学习笔记之列表(list)与元组(tuple)详解
01-20
现在读到了列表(list)、元组(tuple)、集合(set)和字典(dict)四种在python内置的重要的数据结构。我只是想记录一下列表(list)和元组(tuple)比较容易搞混的地方和阐述一遍列表(list)和元组(tuple)比较常用的一些方法。...
02-python-列表-可变和不可变类型-元组-列表与元组的速度比较
02-08
python学习笔记，包含python列表-可变和不可变类型-元组-列表与元组的速度比较
Python全套课程笔记-chap2-列表、元组和字典
01-02
适合小白了解python
Python 的内置数据类型：列表 list、元组 tuple、字典 dict、集合 set.
12-21
list 是一种有序集合，由于Python是动态语言，所以 list 中包含的元素并不要求都必须是同一种数据类型，我们完全可以在 list 中包含各种数据。 访问列表中最后一个元素：L[-1]，索引值为 -1。同理倒数第二个元素索引...
【hackmyvm】Slowman靶机
woshicainiao666的博客
05-20 1180
发现/secretLOGIN/login.html为登录地址，根据账号密码登录发现一个zip，但是需要密码。在FTP中得到的账号，爆破一下SSH。上传linpeas.sh文件，报一下。SSH爆破无果，试试mysql。得到用户名和加密的密码。
【Python爬虫】案例_github模拟登录
qq_45951891的博客
05-21 650
【代码】【Python爬虫】案例_github模拟登录。
python中用“*”运算符复制列表时子列表实际上引用的是同一个列表，列表和嵌套列表的坑
ThreeS_tones的博客
05-21 597
当你修改了一个子列表的元素时，所有的子列表都会随之改变。因为他们实际上都是同一个子列表的引用。输出如下，可以看到每个子列表中的第5个元素相同，并没有实现从0.8-1.2分布。先看一个例子，我想改变load的子列表中第五个元素，从0.8-1.2分布。的时候，Python实际上。
《Python编程从入门到实践》day36
m0_37565294的博客
05-22 1103
我们要编写一个名为“学习笔记”的Web应用程序，让用户能够记录感兴趣的主题，并在学习每个主题的过程中添加日志条目。django-admin startproject learning_log . # 新建一个名为learning_log的项目，末尾的句点让新项目使用合适的目录结构。运行命令ls，其输出表明Django有创建一个db.sqlite3.SQLite使用一种使用单个文件的数据库。# 包含4个文件（settings.py、urls.py、wsgi.py、__init__.py）
python 异常处理 try
最新发布
qq_64993426的博客
05-24 527
异常处理，主动抛出异常，断言
python列表元组集合字典
05-14
Python中的数据结构有四种：列表（List）、元组（Tuple）、集合（Set）和字典（Dictionary）。 列表（List）是一种有序的可变容器，可以存储不同类型的元素。 元组（Tuple）也是一种有序的容器，但是是不可变的，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值