python基础——数据的访问

数据的访问

基本类型的访问：

直接根据变量名去访问

元组和列表的数据访问：

1、根据下标去访问

list_data = [1,2,3,(3,4,5,),7,] print(list_data[0]) print(list_data[3][2]) 输出结果： 1 5

2、add,只能元组与元组之间，列表与列表之间相加，否则会出现类型错误

tuple_data = (1,2,3,4)
tuple_data1 = (4,5)
tuple_data2 = tuple_data.__add__(tuple_data1)
1、print(tuple_data)
2、print(tuple_data1)
3、print(tuple_data2)
tuple_data3= tuple_data2+tuple_data#可以直接使用“+”
4、print(tuple_data3)
tuple_data.__add__(tuple_data3)#相加的结果需要定义一个新元组去接收
5、print(tuple_data)
输出结果：
1、(1, 2, 3, 4)
2、(4, 5)
3、(1, 2, 3, 4, 4, 5)
4、(1, 2, 3, 4, 4, 5, 1, 2, 3, 4)
5、(1, 2, 3, 4)

3、*元组只能与整型相乘，否则会出现类型错误

tuple_data = (1,2,3,4)
tuple_data2 = tuple_data*2
print(tuple_data2,type(tuple_data2))
输出结果:
(1, 2, 3, 4, 1, 2, 3, 4) <class 'tuple'>

4、conut:统计某个元素在元组或列表中出现的次数，元组或列表内的元组或列表中的元素无法统计

tuple_data = (1,2,2,2,3,4)
print(tuple_data.count(2))
print(tuple_data.count(6))#统计不在元组中的元素
输出结果：
3
0
list_data = [1,2,4,[3,3,4,5,],7,]
print(list_data.count(3))#列表内部的列表元素无法统计
tuple_data =(1,2,4,[3,3,4,5,],7,)
print(tuple_data.count(3))#元组内部的列表中的元素无法统计
输出结果：
0
0

5、index：输出检索到元组或列表中某个元素的第一个下标，检索不到时会报错如：TypeError: index expected at least 1 argument，预期至少有一个参数，元组或列表中的元组或列表中的元素不能用index检索到

tuple_data = (1,2,2,2,3,4,)
print(tuple_data.index(2))
print(tuple_data.index(4))
输出结果：
1
5

6、append：在列表的末尾添加一个元素，该元素可以列表元组等其他数据类型，但只能是一个元素，超过一个会出现错误：TypeError: list.append() takes exactly one argument (2 given)只接受一个参数

list_data = [1,2,4,[3,3,4,5,],7,]
list_data.append(8)
print(list_data)
list_data.append(("元素"))
print(list_data)
输出结果：
[1, 2, 4, [3, 3, 4, 5], 7, 8]
[1, 2, 4, [3, 3, 4, 5], 7, 8, '元素']

7、clear：从列表中移除所有元素，不接受参数给定

list_data = [1,2,4,[3,3,4,5,],7,]
list_data.clear()
print(list_data)
输出结果：
[]

8、extend：通过从可迭代对象（包含序列的数据类型）中添加元素扩展list，

list_data = [1,2,4,[3,3,4,5,],7,]
list_data.extend(("可迭代的数据类型"))
print(list_data)
list_data.extend({1:2,3:4})#只在列表上扩展了key？？？
print(list_data)
输出结果：
[1, 2, 4, [3, 3, 4, 5], 7, '可', '迭', '代', '的', '数', '据', '类', '型']
[1, 2, 4, [3, 3, 4, 5], 7, '可', '迭', '代', '的', '数', '据', '类', '型', 1, 3]

list_data = [1,2,4,[3,3,4,5,],7,]
list_data.extend([("可迭代的")])#只有通过列表迭代的元素可以是个序列？？？
print(list_data)
list_data.extend((("数据类型")))
print(list_data)
输出结果：
[1, 2, 4, [3, 3, 4, 5], 7, '可迭代的']
[1, 2, 4, [3, 3, 4, 5], 7, '可迭代的', '数', '据', '类', '型']

9、copy：浅拷贝，不接受参数给定，只拷贝列表的空间，不拷贝元素的空间（也就是拷贝的列表中的元素和原列表的元素属于同一空间，同一磁盘地址）

list_data = [1,2,4,[3,3,4,5,],7,]
list_data1= list_data.copy()
1、print(list_data1)
2、print(id(list_data))
3、print(id(list_data1))
4、print(id(list_data1[3]))
5、print(id(list_data[3]))
list_data1[3][0]=2#在拷贝的列表上修改数据类型为列表的元素中的元素，原列表也发生变化
6、print(list_data1)
7、print(list_data)
list_data1[0]=9#修改数据类型为基本数据类型的元素，原列表不发生改变
8、print(list_data1)
9、print(list_data)
输出结果：
1、[1, 2, 4, [3, 3, 4, 5], 7]
2、1366598126400
3、1366598115264
4、1366598112448
5、1366598112448
6、[1, 2, 4, [2, 3, 4, 5], 7]
7、[1, 2, 4, [2, 3, 4, 5], 7]
8、[9, 2, 4, [2, 3, 4, 5], 7]
9、[1, 2, 4, [2, 3, 4, 5], 7]

10、深拷贝，与浅拷贝不同的是将列表中序列的元素的空间也拷贝了

from copy import deepcopy#导入deepcopy模块
list_data = [1,2,4,[3,3,4,5,],7,]
copy_list= deepcopy(list_data)
1、print(copy_list)
2、print(id(list_data))
3、print(id(copy_list))
4、print(id(copy_list[3]))
5、print(id(list_data[3]))
copy_list[3][0]=2#在深拷贝的列表上修改数据类型为列表的元素中的元素，原列表不发生变化
6、print(copy_list)
7、print(list_data)
输出结果：
1、[1, 2, 4, [3, 3, 4, 5], 7]
2、2770667138496
3、2770667331200
4、2770667330944
5、2770667185600
6、[1, 2, 4, [2, 3, 4, 5], 7]
7、[1, 2, 4, [3, 3, 4, 5], 7]

11、insert： 在列表中指定的下标位置插入元素，可以插入不同的数据类型的元素

list_data = [1,2,3,4,5]
list_data.insert(5,6)#在下标5处添加元素6
print(list_data)
list_data.insert(0,0)#在下标0处添加元素0
print(list_data)
输出结果：
[1, 2, 3, 4, 5, 6]
[0, 1, 2, 3, 4, 5, 6]

12、pop：Remove and return item at index (default last)——删除并返回索引处的项目(默认为last)，参数为下标，可以删除列表中的为复杂数据类型的元素，检索超出范围时会报错

list_data = [1,2,3,4,5]
print(list_data.pop())
print(list_data.pop(3))
print(list_data)
输出结果：
5
4
[1, 2, 3]

13、remove：Remove first occurrence of value——移除第一次检索出现的值，参数为列表中的元素，当参数不在列表中时会报错

list_data = [1,2,3,4,5]
list_data.insert(2,[2,2,2])

print(list_data)
list_data.remove([2,2,2])
print(list_data)
输出结果：
[1, 2, [2, 2, 2], 3, 4, 5]
[1, 2, 3, 4, 5]

14、reverse：倒序排列列表里的元素，不传参

list_data = [1,2,3,4,5]
list_data.reverse()
print(list_data)
list_data.reverse()
print(list_data)
输出结果：
[5, 4, 3, 2, 1]
[1, 2, 3, 4, 5]

15、sort：按升序对列表进行排序，返回None。排序是原位的(即列表本身被修改)和稳定的(即保持两个相等元素的顺序)。如果给定了键函数，则对每个列表项应用一次，并根据它们的函数值升序或降序排序。可以将反向标志设置为降序排序。

list_data = [1,2,3,4,5]
list_data.sort(reverse=True)#倒序
print(list_data)
list_data.sort()#默认reverse=False顺序
print(list_data)
list_data.sort(reverse=False)
print(list_data)
输出结果：
[5, 4, 3, 2, 1]
[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5]

list_data = ["231","908","345","876","432","563","934"]
def sort_key(value):#定义取出元素中下标为1的数为参数的函数
    return value[1]
list_data.sort(key=sort_key)#调用函数为为参数进行排序
print(list_data)
输出结果：
['908', '231', '432', '934', '345', '563', '876']

字典数据的访问：

1、使用key值去访问

dict_data = {"condition":"条件","format":"格式","break":"打破"}
print(dict_data["condition"])
print(dict_data["format"])
print(dict_data["break"])
输出：
条件
格式
打破


dict_data = {"condition":"条件","format":"格式","break":"打破"}
print(dict_data["continue"])#访问一个字典中不存在的key
print(dict_data["condition"])
print(dict_data["format"])
print(dict_data["break"])
输出：KeyError: 'continue'#直接去访问一个字典中不存在的key时，会出现报错，影响程序的运行，建议使用下面的get去访问字典中的数据

2、.get：使用get去访问dict中的数据时，即使get的key不存在，dict中也不会报错，会返回一个“None”,None是默认的返回值可以修改

dict_data = {"condition":"条件","format":"格式","break":"打破"}
print(dict_data.get("condition"))
print(dict_data.get("break"))
print(dict_data.get("format"))
print(dict_data.get("continue"))#使用get去访问字典中不存在的key
print(dict_data.get("continue","Test"))#将返回的默认值“None”改为“Test”
输出：
条件
打破
格式
None
Test

3、keys：访问字典中所有的key

dict_data = {"condition":"条件","format":"格式","break":"打破"}
print(dict_data.keys())#访问字典中所有的key
输出：dict_keys(['condition', 'format', 'break'])

4、values：访问字典里所有的value

dict_data = {"condition":"条件","format":"格式","break":"打破"}
print(dict_data.values())#访问字典中所有的value
输出：dict_values(['条件', '格式', '打破'])

5、items：访问字典里所有的元素

dict_data = {"condition":"条件","format":"格式","break":"打破"}
print(dict_data.items())#访问字典中所有的元素
输出：dict_items([('condition', '条件'), ('format', '格式'), ('break', '打破')])

6、update：字典合并

dict_data = {"condition":"条件","format":"格式","break":"打破"}
dict_data1 = {"continue":"继续"}
dict_data.update(dict_data1)#将dict_data1更新到dict_data中
print(dict_data)
print(dict_data1)
输出：{'condition': '条件', 'format': '格式', 'break': '打破', 'continue': '继续'}

{'continue': '继续'}#dict_data1 还在

集合的数据访问：

1、set.discard () 删除集合中某个元素，如果集合中存在该元素则删除，不存在该元素则什么都不做

set_data = {1,2,3,4}
set_data.discard(4)
print(set_data)
set_data.discard(5)#不报错
print(set_data)
#set_data.discard[1]#使用下标去删除元素会报错
输出：{1, 2, 3}
     {1, 2, 3}

2、add:向集合中添加元素，只能添加单个元素

set_data = {1,2,3,4}
set_data.add(1)#添加重复元素无反应
print(set_data)
set_data.add(5)
print(set_data)
输出：{1, 2, 3, 4}
     {1, 2, 3, 4, 5}

3、集合不可以使用下标访问，使用下标访问会报错
TypeError: ‘set’ object is not subscriptable('set’对象是不可下标的)

切片

可以用来在列表中获取一段数据，python可以使用负值的下标去访问数据。适用于列表和元组

list_data = [1,2,3,4,5,6,7,8,9,0,"E",11]
1、print(list_data)
2、print(list_data[-1])#使用负的下标去访问
3、print(list_data[0:11])#使用切片获取下标大于等于0到小于11的这段数据
#print(list_data[start:stop:step])
#start 开始，默认值为0，stop、结束，默认为最大下标，step、步幅，默认值为+1
4、print(list_data[::-1])#这个负一是指检索数据的方向为负，步幅为一
5、print(list_data[2:])
6、print(list_data[2::-1])
7、print(list_data[8::-2])
8、print(list_data[2:19])
9、print(list_data[13:19])#起点大于序列最大下标，不报错，输出为空
10、print(list_data[2::-22])#步幅超过起点到终点序列数，不报错只输出起点下标对应的数据
11、print(list_data[3::-22])
输出：
1、[1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 'E', 11]
2、11
3、[1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 'E']
4、[11, 'E', 0, 9, 8, 7, 6, 5, 4, 3, 2, 1]
5、[3, 4, 5, 6, 7, 8, 9, 0, 'E', 11]
6、[3, 2, 1]
7、[9, 7, 5, 3, 1]
8、[3, 4, 5, 6, 7, 8, 9, 0, 'E', 11]
9、[]
10、[3]
11、[4]

赋空值

none_data = None
print(none_data,type(none_data))
tuple_data = ( )
print(tuple_data,type(tuple_data))
list_data = [ ]
print(list_data,type(list_data))
dict_data ={ }
print(dict_data,type(dict_data))
set_data= { }
print(set_data,type(set_data))
set_data=set( )
print(set_data,type(set_data))
输出：
None <class 'NoneType'>
() <class 'tuple'>
[] <class 'list'>
{} <class 'dict'>
{} <class 'dict'>
set() <class 'set'>