Python list 存放结构体 list数据结构python

1. Python的数据类型简介

数据结构是以某种方式（如通过编号）组合起来的数据元素（如数、字符乃至其他数据结构）集合。在Python中，最基本的数据结构为序列（sequence）。Python内置了多种序列，如列表，元组，字符串（由字符组成的序列）。

Python支持一种数据结构的基本概念，名为容器（container）。容器基本上就是可包含其他对象的对象。两种主要的容器是序列（列表和元组）和映射（字典）。

在序列中，每个元素都有编号。在映射中，每个元素都有名称（也叫键）。有一种既不是序列也不是映射的容器，它就是集合（set）。

列表和元组的主要不同在于，列表是可以修改的，而元组不可以。

这意味着列表适用于需要中途添加元素的情形，而元组适用于出于某种考虑需要禁止修改序列的情形。禁止修改序列通常出于技术方面的考虑，与Python的内部工作原理相关，这也是有些内置函数返回元组的原因所在。

在我们编写程序时，几乎在所有情况下都可使用列表来代替元组。据我目前所知，当元组用作字典键时，不能用列表来代替元组（原因是因为字典键不允许修改）

元素都有编号，即其位置或索引，其中第一个元素的索引为0，第二个元素的索引为1，依此类推。在有些编程语言中，从1开始给序列中的元素编号，但从0开始指出相对于序列开头的偏移量。这显得更自然，同时可回绕到序列末尾，用负索引表示序列末尾元素的位置。

2. Python序列之列表：Python主力军

索引、切片、相加、相乘和成员资格检查适用于所有的序列。另外， Python还提供了一些内置函数，可用于确定序列的长度以及找出序列中最大和最小的元素。

列表是可变的，即可修改其内容。另外，列表有很多特有的方法。

通过列表可以对数据实现最方便的存储、修改等操作。

列表用中括号括起。

2.1 函数list

可将字符串转化为列表，可将任何序列（不仅仅是字符串）作为list的参数。函数list实际上是一个类，也是一个工厂函数，目前，这种差别不重要。
>>> list('function')
['f', 'u', 'n', 'c', 't', 'i', 'o', 'n']
View Code
提示：要将字符列表（如前述代码中的字符列表）转换为字符串，可使用下面的表达式（字符串操作方法）：
>>> test = ['f', 'u', 'n', 'c', 't', 'i', 'o', 'n']>>> print(''.join(test))
function
View Code
2.2 基本列表操作
2.2.1 索引（indexing）
序列中所有元素都有编号——从0开始递增。-1是最后一个元素的位置。不同于其他语言，Python没有专门用于表示字符串的类型，因此一个字符就是只包含一个元素的字符串。
#索引操作实例#Print out a date, given year, month, and day as numbers
months = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December']#A list with one ending for each number from 1 to 31
endings = ['st', 'nd', 'rd'] + 17 * ['th'] \+ ['st', 'nd', 'rd'] + 7 * ['th'] \+ ['st']
year= input('Year:')
mnotallow= input('Month (1-12):')
day= input('Day (1-31):')
month_number=int(month)
day_number=int(day)#Remember to subtract 1 from month and day to get a correct index（The index starts from 0）
month_name = months[month_number-1]
ordinal= day + endings[day_number-1]print(month_name + ' ' + ordinal + ',' +year)
执行结果：
Year:2018Month (1-12): 3Day (1-31): 3March 3rd,2018
View Code
2.2.2 切片
第一个数字表示切片开始位置（默认0）
第二个数字表示切片截止（但不包括）位置（默认位列表长度）
第三个数字表示切片的步长（默认1）
number = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]print(number[0:10:1]) #0，1全部可省略
print(number[:]) #print(number[:]) = print(number[:10]) = print(number[:100])
print(number[::2])print(number[1::2])print(number[2::3]) #切片，从第二个元素开始，第一个元素的索引（下标）为0，那么3的索引为2，每隔3位取一个元素
执行结果：
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[1, 3, 5, 7, 9]
[2, 4, 6, 8, 10]
[3, 6, 9]
View Code
names = ["DJ", "ZhangYang", "YanYun", "WangYa", "LiLei"]print(names)print(names[0], names[2])print(names[1:3]) #切片，顾头不顾尾！取位置为1~2的字符串
print(names[-1]) #切片，从左往右数，-4，-3，-2，-1 取最后一个元素
print(names[-2:]) #切片，取最后两个值
print(names[-3:-1]) #切片，从左往右数，顾头不顾尾！取倒数第三个和倒数第二个元素
print(names[0:3]) #切片，0可以省略，取前三个元素
执行结果：
['DJ', 'ZhangYang', 'YanYun', 'WangYa', 'LiLei']
DJ YanYun
['ZhangYang', 'YanYun']
LiLei
['WangYa', 'LiLei']
['YanYun', 'WangYa']
['DJ', 'ZhangYang', 'YanYun']
View Code
2.2.3 追加
names = ["DJ", "ZhangYang", "YanYun", "WangYa", "LiLei"]print(names)
names.append("LiLei")print(names)
执行结果：
['DJ', 'ZhangYang', 'YanYun', 'WangYa', 'LiLei']
['DJ', 'ZhangYang', 'YanYun', 'WangYa', 'LiLei', 'LiLei']
View Code
2.2.4 插入
names = ["DJ", "ZhangYang", "YanYun", "WangYa", "LiLei"]
names.insert(1, "FFF") #插入，1——>下标
names.insert(3, "ppp") #插入，3——>下标
print(names)
执行结果：
['DJ', 'FFF', 'ZhangYang', 'ppp', 'YanYun', 'WangYa', 'LiLei']
View Code
2.2.5 修改（替换）
names = ["DJ", "ZhangYang", "YanYun", "WangYa", "LiLei"]
names[1] = "XXXXX" #替换
print(names)
执行结果：
['DJ', 'XXXXX', 'YanYun', 'WangYa', 'LiLei']
View Code
2.2.6 删除
#delete
names = ["DJ", "ZhangYang", "YanYun", "WangYa", "LiLei"]#names.remove("YanYun")#del names[3] = names.pop(3)
names.pop() #如果不输入下标，默认删除最后一个
print(names)
执行：
['DJ', 'ZhangYang', 'YanYun', 'WangYa']
View Code
2.2.7 统计
names = ["DJ", "ZhangYang", "YanYun", "WangYa", "LiLei"]print(names.count("ZhangYang"))
执行：1
View Code
2.2.8 扩展（合并）
names = ["DJ", "ZhangYang", "YanYun", "WangYa", "LiLei"]
names2= ['1', '5', 'FFF', 'DJ']#合并，如果不删除names2，仍然存在
names.extend(names2)delnames2print(names)
执行：
['DJ', 'ZhangYang', 'YanYun', 'WangYa', 'LiLei', '1', '5', 'FFF', 'DJ']
View Code
2.2.9 清空
>>> names = ["DJ", "ZhangYang", "YanYun", "WangYa", "LiLei"]>>> print(names.clear())
None
View Code
2.2.10排序（特殊符号，数字，大写，小写）
names = ["DJ", "ZhangYang", "zhangYang", "YanYun", "WangYa", "LiLei"]
names.sort()print(names)
names2= ['LiLei', '#!WangYa', '4DDD', 'aFFF', 'ZhangYang', 'FFF', 'DJ']
names2.sort()print(names2)
执行：
['DJ', 'LiLei', 'WangYa', 'YanYun', 'ZhangYang', 'zhangYang']
['#!WangYa', '4DDD', 'DJ', 'FFF', 'LiLei', 'ZhangYang', 'aFFF']
View Code
2.2.11 反转排序
names = ["DJ", "ZhangYang", "zhangYang", "YanYun", "WangYa", "LiLei"]
names.reverse()print(names)
names2= ['LiLei', '#!WangYa', '4DDD', 'aFFF', 'ZhangYang', 'FFF', 'DJ']
names2.reverse()print(names2)
执行：
['LiLei', 'WangYa', 'YanYun', 'zhangYang', 'ZhangYang', 'DJ']
['DJ', 'FFF', 'ZhangYang', 'aFFF', '4DDD', '#!WangYa', 'LiLei']
View Code
2.2.12 浅copy
importcopy
persnotallow= ['name', ['saving', 1000]]
p1= person.copy() #浅copy，只复制上一层的子列表，子列表是一个独立的内存指针，是一个内存地址，复制的是内存地址
p2 =person[:]
p3=list(person)
p1[0]= 'alex'p2[0]= 'A_Wife'p1[1][1] = 500
print(p1)print(p2)print(p3)
执行：
['alex', ['saving', 500]]
['A_Wife', ['saving', 500]]
['name', ['saving', 500]]
View Code
2.2.13 深copy
importcopy
names= ["DJ", "ZhangYang", "YanYun",['alex', 'Jack'], "WangYa", "LiLei"]#浅copy，只复制上一层的子列表，子列表是一个独立的内存指针，是一个内存地址，复制的是内存地址#names2 = names.copy()#深copy，占两份独立的地址空间
names2 =copy.deepcopy(names)print(names)print(names2)
names[0]= "帝姬"names[3][0] = "ALEX" #由于指向同一块地址空间，names[3][0] = names2[3][0]
print(names)print(names2)
执行：
['DJ', 'ZhangYang', 'YanYun', ['alex', 'Jack'], 'WangYa', 'LiLei']
['DJ', 'ZhangYang', 'YanYun', ['alex', 'Jack'], 'WangYa', 'LiLei']
['帝姬', 'ZhangYang', 'YanYun', ['ALEX', 'Jack'], 'WangYa', 'LiLei']
['DJ', 'ZhangYang', 'YanYun', ['alex', 'Jack'], 'WangYa', 'LiLei']
View Code
3. Python序列之元组：不可修改的序列
元组其实跟列表差不多，也是存一组数，只不是它一旦创建，便不能像列表式的增删改，只能查，切片，所以元组又叫只读列表。
元组用圆括号括起（这是通常采用的做法）。
3.1 函数tuple
函数tuple的工作原理与list类似：它将一个序列作为参数，并将其转换为元组。如果参数已经是元组，就原封不动地返回它。它同样是工厂函数。
>>> tuple([1, 2, 3])
(1, 2, 3)>>> tuple('abc')
('a', 'b', 'c')>>> tuple((1, 2, 3))
(1, 2, 3)>>>
View Code
3.2 基本元组操作（方法）
2个方法：一个是count（计数），一个是index（索引），当然，它同样可以切片
names = ('alex', 'jack', 'DJ', 'alex', 'Alex')print(names.count('alex'))print(names[names.index('DJ')])print(names.index('DJ'))
执行：2DJ2
View Code
它们用作映射中的键（以及集合的成员），而列表不行。
有些内置函数和方法返回元组，这意味着必须跟它们打交道。只要不尝试修改元组，与
元组“打交道”通常意味着像处理列表一样处理它们（需要使用元组没有的index和count等方法时例外）。
一般而言，使用列表足以满足对序列的需求。
3. 购物车小程序
product_list =[
('IPhone', 6000),
('Mac Pro', 12000),
('Starbucks Latte', 50),
('Bicycle', 800),
("Watches", 12000)
]
shopping_list=[]
salary= input("Input your salary:")ifsalary.isdigit():#判断用户输入的工资是否为数字类型
salary =int(salary)whileTrue:for index, item inenumerate(product_list):print(index,item)#取出列表元素对应下标，并打印下标和数据
user_choice = input("Please choose goods:")ifuser_choice.isdigit():
user_choice=int(user_choice)#判断输入的元素下标是否是数字类型(判断用户的输入是否为数字类型)
if not user_choice >= len(product_list) and user_choice >=0:
p_item=product_list[user_choice]#通过下标把商品取出来
if p_item[1] <= salary: #买得起
shopping_list.append(p_item)
salary-= p_item[1]print('Added \033[32m %s \033[m into shopping cart,'
'Your curent balance is \033[31m %s \033[m' %(p_item, salary))else:print("\033[41m 你的余额只剩[%s]啦!\033[m" %salary)else:print("\033[42m product code [%s] is not exits!\033[m" %user_choice)elif user_choice == 'q':print("------shopping list------")for p inshopping_list:print(p)print("\033[45m Your current balance:\033[0m", salary)print("------shopping list------")
exit()else:print("invalid option!")
View Code