python之组合数据类型

python之组合数据类型 1 认识组合数据类型

Python中常用的序列类型有字符串、列表和元组。

Python集合具备确定性、互异性和无序性三个特性.

Python要求放入集合中的元素必须是不可变类型。

Python中的整型、浮点型、字符串类型和元组属于不可变类型

列表、字典及集合本身都属于可变的数据类型。

确定性

给定一个集合，那么任何一个元素是否在集合中就确定了.

无序性集合中的元素没有顺序，顺序不同但元素相同的集合可视为同一集合。互异性 集合中的元素互不相同 。 2 列表 (1)列表的定义和基本使⽤

# 列表 是python中的一种数据类型，可以存放多个数据，列表中的数据可以是任意类型的
# 列表 list，定义使用[]进行定义

# 定义空列表
my_list = []
print(my_list,type(my_list))
my_list1 = list() #空列表
print(my_list1,type(my_list1))

#定义带数据的列表，数据元素之间使用逗号隔开
my_list2 = [1,1.23,True,'isaac']
print(my_list2,type(my_list2))
#求列表数据元素的个数，即列表长度
num = len(my_list2)
print(num)

#列表支持下标和切片
print(my_list2[1])
print(my_list2[-1])

print(my_list2[1:3])


#下标 *** 作和字符串不同的是，字符串不能使用下标修改数据
#但是列表可以
my_list2[0]=19
my_list2[-1]="hello word"

(2）遍历

my_list = ['嘉然'，'向晚','贝拉'，'珈乐'，'乃琳']
for i in my_list:
    print(i)
    
print('*' * 30)

j = 0
while j  
（3）添加数据 
#向列表中添加数据是在原列表中添加，不会返回新的表格。
my_list = ['嘉然'，'向晚','贝拉'，'珈乐'，'乃琳']
print(my_list)
#列表。append（数据）向列表尾追加数据
my_list.append('泠鸢')
print(my_list)

#列表。insert（下标，数据）在指定的下标位置进行添加数据
my_list.insert(0,'hanser')
print(my_list)

#列表。exten（可迭代对象）会将可迭代对象中的数据逐个添加到原列表的末尾
my_list.extend('love')
print(my_list)
my_list.extend([1,'python'3])
print(my_list)
 
（4）查询 *** 作 
my_list = ['嘉然'，'向晚','贝拉'，'珈乐'，'乃琳']
#index() 根据数据值，查找元素所在的下标，找到返回元素的下标 没有找到，程序报错。
#列表没有find方法，只有index（）方法
#查找嘉然在列表的下标
num = my_list.index(嘉然)
print(num)

#count()统计出现的次数
num3 = my_list.count(1)
print(num3)

#in/not in 判断是否存在，存在是true，不存在false，一般和if配合使用
num4 = 嘉然 in my_list
print(num4)

num4 = 向晚 not in my_list
print(num4)
 
（5）删除 *** 作 
my_list = ['嘉然'，'向晚','贝拉'，'珈乐'，'乃琳']
#1.根据元素的数据值删除remove（数据值），源列表中的数据
my_list.remove(贝拉)
print(my_list)

#2.根据下标删除
#2.1pop（下标）默认删除最后一个数据，返回删除的内容
num = my_list.pop()     #删除最后一个数据
print(num)
print(my_list)

num = my_list.pop(2)    #删除下标为2的数据
print(num)
print(my_list)

#2.2 del 列表[下标]
del my_list[1] #删除下标为1的数据2
print(my_list)

#del my_list[10] #删除不存在的下标会报错。
 
(6) 列表排序和逆置 
#想要对列表的数据进行排序，前提是列表中的数据类型一样
my_list = [1,3,32,534,5467,341]

#列表。sort（）直接在原列表中进行排序
#my_list.sort 默认是从小到大排序，即升序
#my_list,sort(reverse=true) 通过reverse=true，从小到大排序
print(my_list)

#sorted（列表）  排序，不会在原列表中进行排序，会得到一个新的列表
my_list1 = sorted(my_list)
my_list2 = sorted(my_list,reverse=True)
print(my_list)
print(my_list1)
print(my_list2)

print("=" *30)
my_list3 = ['a', 'b','c','d','e']
#逆置，
my_list4 = my_list3[::-1]#得到一个新列表
print(my_list3)
print(my_list4)

#在原列表直接逆置 列表。reverse()
my_list3.reverse()
 
（7）列表嵌套 
ouxiang_names = [['泠鸢'，'hanser']]，
                 ['七海nana7mi','鹿乃'，'阿梓']
                 ['向晚'，'嘉然']]

print(ouxiang_names[1])         #['七海nana7mi','鹿乃'，'阿梓']
print(ouxiang_names[1][1])      #七海nana7mi
print(ouxiang_names[1][1][1])      #乃


#向晚
print(ouxiang_names[2][0])

for ouxinag in ouxiang_names:
    #print(ouxiang) #列表
    for name in ouxinag
        print(name)
 
3 元组 
# 元组和列表非常相似，都可以存放多个数据，可以存放不同数据类型的数据
# 不同点：列表使用[] 定义，元组使用（）定义
# 列表中的数据可以修改，元组中的数据不能修改

my_list = ['泠鸢','hanser','鹿乃','七海nana7mi','阿梓']         #列表

my_tuple = ('泠鸢','hanser','鹿乃','七海nana7mi','阿梓')         #元组
print(my_tuple,type(my_tuple))

#   元组支持下标和切片 *** 作
print(my_tuple[1])          #hanser

#定义空元组，没有意义
my_tuple1=()
print(my_tuple1,type(my_tuple1))
my_tuple2=tuple()

#  定义一个数据元素的元组，数据元素后边，必须有一个逗号
my_tuple3=(3)       #3
my_tuple4=(3,)

print(my_tuple3,type(my_tuple3))
print(my_tuple4,type(my_tuple4))
 
4 字典 
（1）定义与访问 
# 字典dict 定义使用{}定义，是由键值对组成（key-value）
# 变量 = {key1：value1，key2：value，....} 一个key：value键值对是一个元素
# 字典的key 可以是 字符窜类型和数字类型（int float）不能是 列表
# value值可以是任何类型


# 1.定义空字典
my_dict = {}
my_dict1 = dict()
print(my_dict,type(my_dict))
print(my_dict1,type(my_dict1))

# 2.定义带数据的字典
my_dict2 = {'name':"泠鸢",'age':50,'like':['hanser','做词'],1:[1,4,8]}
print(my_dict2)

#3.访问value 值，在字典中没有下标的概念，使用key值访问对应的value值
#18
print(my_dict2['age'])
#hanser
print(my_dict2['like'][1])

#如果key值不存在
#print（my_dict2['gender']）   #代码报错，key值不存在
#字典。get（key） 如果key值不存在，不会报错，返回的是none
print(my_dict2.get('gender'))

#my_dict2.get(key,数据值)    如果key存在，返回key对应的value值，如果key不存在，返回书写的数据值值

print(my_dict2.get('gender','男'))
print(my_dict2.get('age',1))

print(len(my_dict2))
 
（2）添加和修改数据 
my_dict={'name':'isaac'}
print(my_dict)
#字典中添加和修改数据，使用key值进行添加和修改
#字典[ key] =数据值; 如果key值存在,就是修改,如果key值不存在,就是添加


my_dict[ 'age'] = 18 # key 值不存在,添加print(my_dict)
print(my_dict)

my_dict[ 'age'] =19# key值已经存在,就是修改数据
print(my_dict)

#注意点key值int的1和fLoat的1.0代表一个key值
my_dict[1] =‘int'
print(my_dict)
my_dict[1.0]='f1oat'
print(my_dict)
 
（3）删除数据 
my_dict = { 'name ' : 'isaac ', 'age ': 19，1: 'float'， 2: 'aa'}

#根据key 值删除数据del字典名[key]
del my_dict[1]
print(my_dict)

#|字典.pop( key)根据key值删除，返回值是删除的Rey对应的value值
result = my_dict.pop( ' age ' )
print(my_dict)
print(result)

#字典.clear()清空字典，删除所有的键值对
my_dict.clear()
print(my_dict)

# del字典名直接将这个字典删除了，不能使用这个字典了
del my_dict#后边的代码不能再直接使用这个变量了,除非再次定义

# print(my_dict)代码报错，变量为定义
 
（4）字典中遍历数据 
    1. for 循环直接遍历字典, 遍历的是字典的 key 值
 
my_dict = { ' name ' : 'isaac', 'age' : 18， 'gender ' : '男'}

#for循环体直接遍历字典，遍历的字典的key值

for key in my_dict:
    print(key, my_dict[key])
 
   2. 字典.keys()
 
#字典.keys()获取字典中所有的Rkey值，得到的类型是 dict_keys，该类型具有的特点是
#1．可以使用list()进行类型转换，即将其转换为列表类型
#2.可以使用for循环进行遍历
result = my_dict.keys()
print(result, type(result))
for key in result:
    print(key)
 
 3. 字典.values()
 
#字典.values()获取所有的vaLue值，类型是dict_values
#1．可以使用List()进行类型转换,即将其转换为列表类型
#2.可以使用for循环进行遍历
result = my_dict.values()
print(result, type( result))
for value_in my_dict.values( ):
    print(value)
 
 4.字典.items()
 
#字典.items()获取所有的键值对，类型是 dict_items， key , value 组成元组类型
#1．可以使用List()进行类型转换,即将其转换为列表类型
#2.可以使用for循环进行遍历

result = my_dict.items()
print(result， type(result))
foritem in my_dict.items():
    print( item[o], item[1])


print( '='* 30)

for k，v in my_dict.items(:# k 是元组中的第一个数据，v是元组中的第二个数据
    print(k， v)
 
5 enumerate 函数  
my_list = [ 'a', 'b', 'c', 'd', 'e']

# for i in my_List:
#    print(i)

for i in my_list:
    print(my_list.index(i)，i)#下标，数据值


# enemerate将可迭代序列中元素所在的下标和具体元素数据组合在一块,变成元组for j in enumerate(my_list) :
    print(j)
 
 在字典中可以包含列表，列表中能包含字典.
					
										


					

						
欢迎分享，转载请注明来源：内存溢出
原文地址: https://outofmemory.cn/zaji/5680352.html