本文详细介绍了Python中的列表，包括创建、访问元素、切片、序列操作、列表方法等。通过实例演示了如何添加、删除、修改列表元素，以及遍历列表。此外，还涉及到了列表与其他数据结构如元组、字典和集合的操作和转换。
列表 （list）
- 列表是Python中的一个对象
- 列表中可以保存多个有序的数据
- 列表是可以存储对象的对象
列表的使用：
-
列表的创建
-
#列表存储的数据，我们称为元素 #一个列表中可以存储多个元素，也可以在创建列表时，来指定列表中的元素 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))
-
-
操作列表中的数据
- 列表的方法
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
- 元组是一个不可变的序列
- 它的操作的方式基本上和列表是一致的,所以你在操作元组时，可以把元组当成是一个不可变的列表
- 般当我们希望数据不改变时，就使用元组，其余情况都使用列表
- 创建元组
#创建一个元组
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 '''
集合
- 参考资料：https://docs.python.org/3/library/stdtypes.html#set-types-set-frozenset
- 集合和列表非常相似
- 不同点：
- 集合中只能存储不可变对象
- 集合中存储的对象是无序（不是按照元素的插入顺序保存）
- 集合中不能出现重复的元素
#创建 集合
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
#>=, >
扫一扫
399
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
