python-数据结构

字符串相关：

• 切片

str = "abcde12345"
print(str)
print(str[0])
print(str[0:5])
print(str[0:5:2]) #str[起始:结尾:步长]

# 执行结果：
'''
abcde12345
a
abcde
ace
'''

list(列表)：

• list基本格式

# 列表名 = [" "," "," "]
nums = ["a",1,"b"]

• 遍历列表

names = ["李华", "小明", "马瑞"]
for name in names:
    print(name)

# 执行结果：
'''
李华
小明
马瑞
'''

• 增

a = [1,2]
b = [3,4]
#******append******
a.append(b) #将列表b内的每个元素，看做一个整体追加在列表a的最后面
print(a)
#******extend******
a.extend(b) #将列表b内的每个元素，拆分开逐一追加在列表a的最后面
print(a)
#******insert******
a.insert(1,5)  #将元素5插入到列表a元素下标为1的位置
print(a)

#执行结果：
'''
[1, 2, [3, 4]]
[1, 2, [3, 4], 3, 4]
[1, 5, 2, [3, 4], 3, 4]
'''

• 删

nums = ["a","b","c",1,2,3]
#******del******
del nums[2] #删除列表nums下标为2的元素
print(nums)
#******pop******
nums.pop()  #删除列表nums最后一个元素
print(nums)
#******remove******
nums.remove("b") #删除指定内容的元素
print(nums)

#执行结果：
'''
['a', 'b', 1, 2, 3]
['a', 'b', 1, 2]
['a', 1, 2]
'''

• 改

names = ["张三","李四"]
print(names)
names[0] = "小三"
print(names)

#执行结果：
'''
['张三', '李四']
['小三', '李四']
'''

• 查

names = ["张三","李四","张三"]
name = input("请输入要查的元素：")
if name in names:
#index查询的元素有多个时，则输出第一个元素的下标
    print("该元素存在，该元素的下标为：%d"%names.index(name))
else:
    print("该元素不存在")
#count查询该元素在列表中出现的次数
print("该列表存在 %d 个%s"%(names.count(name),names[names.index(name)]))

#执行结果：
'''
请输入要查的元素：张三
该元素存在，该元素的下标为：0
该列表存在 2 个张三
'''

• 列表生成式：

# 一般写法：
l = ['a_666','b_666','c_666',"d"]
new_l1 = []
for i in l:
    if i.endswith('666'):
        new_l1.append(i)
print(new_l1)
# 生成式写法：
new_l2 = [i for i in l if i.endswith('666')]
print(type(new_l2), new_l2)

#执行结果：
'''
['a_666', 'b_666', 'c_666']
<class 'list'> ['a_666', 'b_666', 'c_666']
'''

• 列表排序：
  • 内置排序函数：

  • nums = [1,2,3,6,5,4]
    print(nums)
    #******reverse******
    nums.reverse() #逆序
    print(nums)
    #******sort******
    nums.sort() #升序
    print(nums)
    nums.sort(reverse=True) #降序
    print(nums)
    #执行结果：
    '''
    [1, 2, 3, 6, 5, 4]
    [4, 5, 6, 3, 2, 1]
    [1, 2, 3, 4, 5, 6]
    [6, 5, 4, 3, 2, 1]
    '''
    

  • 冒泡排序：

  •  def bubbleSort(alist):
         n = len(alist)
         for i in range(n):
             for j in range(0, n-i-1):
                 if alist[j] > alist[j+1] :
                     alist[j], alist[j+1] = alist[j+1], alist[j]
     alist = [64, 34, 25, 12, 22, 11, 90]
     print ("排序前的数组:", alist)
     bubbleSort(alist)
     print ("排序后的数组:", alist)
     # 执行结果：
     '''
     排序前的数组: [64, 34, 25, 12, 22, 11, 90]
     排序后的数组: [11, 12, 22, 25, 34, 64, 90]
     '''
    

  • 插入排序：

  • def insertSort(alist):
        n = len(alist)
        for i in range(1,n):
            while i > 0:
                if alist[i] < alist[i-1]:
                    alist[i], alist[i-1] = alist[i-1], alist[i]
                    i -=1
                else:
                    break
    alist = [64, 34, 25, 12, 22, 11, 90]
    print ("排序前的数组:", alist)
    insertSort(alist)
    print ("排序后的数组:", alist)
    # 执行结果：
    '''
    排序前的数组: [64, 34, 25, 12, 22, 11, 90]
    排序后的数组: [11, 12, 22, 25, 34, 64, 90]
    '''
    

• 枚举

nums = ["a","b","c","d"]
for i,j in enumerate(nums):
    print(i,j)

#执行结果：
'''
0 a
1 b
2 c
3 d
'''

• 嵌套列表(二位数组)基本格式

列表名 = [["",""],["",""],["",""]]
print(列表名[外列表下标][内列表下表])

• list列表实例

products = [["redmi k30",1499],\
            ["redmi k30 pro",2699],\
            ["redmi k30 pro变焦版",2999],\
            ["redmi k30至尊纪念版",1999],\
            ["redmi k30S至尊纪念版",2599],\
            ["手机壳",20],\
            ["钢化膜",10],\
            ["OTG",8]]
print("\n------商品列表------")
#遍历商品列表和价格
for x,phones in enumerate(products):
    print(x+1,"%-20s"%phones[0],"%d元"%phones[1])
print("\n------选购环节------")
#用户自行选购
shopping_cart = []
num = input("请输入需要添加进购物车商品的编号：")

while num != "exit":
    if num.isdigit() and int(num)>0 and int(num)<=len(products):
        shopping_cart.append(products[int(num)-1])
        print("请问还需添加其他商品到购物车吗？")
        print("若需添加请输入对应编号，结账请输入：exit")
        num = input("请输入需要添加进购物车商品的编号：")
    else:
        num = input("该商品不存在，请重新输入：")
else:
    print("\n------结账环节------")
    money = 0
    if len(shopping_cart) != 0:
        print("以下是您购物车内的商品：")
        for shopping in shopping_cart:
            print(shopping[0],"：%d元"%shopping[1])
            money = money + shopping[1]
        print("您本次共需支付：%d元"%money)
    else:
        print("购物车空空如也。")
print("******感谢您的光临，下次再见~******")

#执行结果：
'''
------商品列表------
1 redmi k30            1499元
2 redmi k30 pro        2699元
3 redmi k30 pro变焦版     2999元
4 redmi k30至尊纪念版       1999元
5 redmi k30S至尊纪念版      2599元
6 手机壳                  20元
7 钢化膜                  10元
8 OTG                  8元

------选购环节------
请输入需要添加进购物车商品的编号：5
请问还需添加其他商品到购物车吗？
若需添加请输入对应编号，结账请输入：exit
请输入需要添加进购物车商品的编号：7
请问还需添加其他商品到购物车吗？
若需添加请输入对应编号，结账请输入：exit
请输入需要添加进购物车商品的编号：exit

------结账环节------
以下是您购物车内的商品：
redmi k30S至尊纪念版 ：2599元
钢化膜 ：10元
您本次共需支付：2609元
******感谢您的光临，下次再见~******

tuple(元组)：

• tuple基本格式

#元组名 = (" "," "," ")
tup = (123,) #单个元素时结尾加逗号
tup = (1,2,3)

• 遍历元组
  • 和list列表操作相同
• 增删改查
  • 增：只能通过连接2个不同的元祖生成一个新元组
  • 删：只能通过del 元组名删除整个元组
  • 改：元组元素不支持修改
  • 查：和list列表操作相同

dict(字典)：

• dict基本格式

#字典名 = {"":"", "":""}
peoples = {"张三":18, "李四":15}
#创建空字典
person = dict()

• 遍历字典

peoples = {"张三":18, "李四":15}
for key,value in peoples.items():
    print(key,value)

#执行结果：
'''
张三 18
李四 15
'''

• 增

peoples = {"张三":18, "李四":15}
age = input("请输入年龄：")
peoples["王五"] = age
print(peoples)

#执行结果：
'''
请输入年龄：17
{'张三': 18, '李四': 15, '王五': '17'}
'''

• 删

peoples = {"张三":18, "李四":15, "王五":17}
del peoples["张三"] #删除指定的键值对
peoples.pop("李四") #和del作用相同
print(peoples)
peoples.clear()   #清空字典内的内容
print(peoples)
del peoples #删除整个字典，删除后不可访问

#执行结果：
'''
{'王五': 17}
{}
'''

• 改

peoples = {"张三":18, "李四":15}
peoples["张三"] = 17
print(peoples)

#执行结果：
'''
{'张三': 17, '李四': 15}
'''

• 查

peoples = {"张三":18, "李四":15}
#******keys******
print(peoples.keys()) #得到所有键
#******values******
print(peoples.values()) #得到所有值
#******items******
print(peoples.items()) #得到所有键值对
#******get******
print(peoples.get("小三","该键不存在")) #查找指定键对应的值

#执行结果：
'''
dict_keys(['张三', '李四'])
dict_values([18, 15])
dict_items([('张三', 18), ('李四', 15)])
该键不存在
'''

• 其他操作
  • 合并两个字典：dict1.update(dict2)
  • 把两个列表转换为字典：dict(zip(list1,list2))
• 字典生成式

keys = [('name','cjl'),('age',18),('sex','男')]
dic = {k:v for k,v in keys if k != 'sex'}
print(type(dic), dic)

#执行结果：
'''
<class 'dict'> {'name': 'cjl', 'age': 18}
'''

set(集合)：

• set基本格式

#集合名 = {"", "", ""}
nums = {"a", 1, "b", 2}

• set独有操作

s = {1010, "张三", 78, 9}
t = {1010, "李四", 12.3, 1010}
print(s - t) # 差集
print(s & t) # 交集
print(s ^ t) # 补集
print(s | t) # 并集

#执行结果
'''
{'张三', 9, 78}
{1010}
{'张三', 9, '李四', 12.3, 78}
{1010, '张三', 9, '李四', 12.3, 78}
'''

• 集合类型的常用操作函数或方法

s = {1010, "python", 78.9}
print("初始元组为：",s) # s.add(x)：如果数据项x不在集合s中，将x增加到s
s.add('大数据')
print("添加后：",s)
s.remove(1010)          # s.remove(x)：如果x在集合s中，移除该元素;元素不存在则产生KeyError异常
print("删除后：",s)
s.clear()               # s.clear()：移除s中所有数据项
print("清空后：",s)
print("元素个数：",len(s)) # len(s)：返回集合s元素个数
print("1010是s元组内：",1010 in s) # x in s：如果x是s的元素，返回True,否则返回False
print("1010不是s元组内：",1010 not in s) # x not in s：如果x不是s的元素，返回True, 否则返回False
print("输出元组s：",s)

#执行结果：
'''
初始元组为： {'python', 1010, 78.9}
添加后： {'python', 1010, '大数据', 78.9}
删除后： {'python', '大数据', 78.9}
清空后： set()
元素个数： 0
1010是s元组内： False
1010不是s元组内： True
输出元组s： set()
'''

• set()函数将其他的组合数据类型变成集合类型，返回结果是一个无重复且排序任意的集合，set()函数也可以生成空集合变量。

a = set()
print(a)
s = set("知之为知之不知为不知")
print(s)

#执行结果：
'''
set()
{'之', '知', '为', '不'}
'''

• 集合生成式

keys = ['name','age','sex']
set_1 = {key for key in keys}
print(type(set_1), set_1)

#执行结果：
'''
<class 'set'> {'name', 'age', 'sex'}
'''

小结对比：

NULL	是否有序	是否可变类型
列表["",""]	有序	可变类型
元祖("","")	有序	不可变类型
字典{"":""}	无序	键不可变，值可变
集合{"",""}	无序	可变类型(不重复)