测试-python筑基1.1-（列表/元组/字典/集合/字符串）

列表

• 列表

""""""
"""
列表——一种将多个数据组合到一起的容器
标识符：[]
关键字：list ——给列表赋值变量名的时候，不要用关键字
"""
list_1 = []  #定义一个空列表
list_2 = [1,2,3,4,5]  #定义一个有值的列表（不是数组）
print(type(list_1))   #类型=====执行结果====>   <class 'list'>
print(type(list_2))   #类型=====执行结果====>   <class 'list'>
#直接获取它的长度——len()
print(len(list_2))

#翻转列表
list_2.reverse()
print(list_2)  #===执行结果===>[5 4 3 2 1]

#  变量后面用 .     表示调用函数（方法）
# 调用的函数返回什么东西，是规定好的
# 一旦这个函数不返回，你打印出来，赋值给变量的 就是个none
print(list_2.reverse()) #错误示范，打印结果为None，函数执行是从上到下从左到右执行，所以不能连着写函数，不能连续调用函数

• 列表的增删查改

""""""
"""
列表：有序，可变
有序：列表每个元素都有索引，从0开始
列表取值：变量名[索引值]

可变：修改，添加， 删除
"""
# list_1 =[1,2,3,4]
# print(list_1[1])  #取出里面的二，因为索引从0 开始

#升级  怎么套就怎么取
list_1 = [100,2.14,True,"Huace",[1,2,3,4]]
print(list_1[4][1]) #执行结果为2 ，先取出列表里面的第四个 再取第四个值里面的第二个元素所以得2
# 分解：
# lst =list_1[4]
# print(lst)
# print(lst[1])

"""
向列表后面增加元素—— append（） 增加元素
增加在列表的后面，一次添加一个
推荐使用
"""
lst1=[1,2]
lst1.append("python")
print(lst1)

"""
insert() 添加元素，一次添加一个 通过索引来添加
需要给两个参数 第一个是索引 第二是插入的值
insert(索引数字，插入的值)
"""
lst1.insert(1,"小美") #原来那个数字2会怎么办，
print(lst1)  # 小明插入后，原有的所有元素向后移动一位
#插入的时候，性能没有append的性能高，不便于使用

"""
列表 进行合并， 老列表元素并入新列表中,推荐写法
extend() 列表名
"""
# lst2=[7,8,9]
# lst1.extend(lst2)
# print(lst1)  #lst2 直接并入 lst1 执行结果===>[1, '小明', 2, 'python', 7, 8, 9]
# print(lst1+lst2)  #不推荐

lst1.extend('小明')
print(lst1)#可以并入，字符串，在python 中它会认为每一个字符都是一个列表元素
# 执行结果====>[1, '小美', 2, 'python', '小', '明']
lst1.extend([100]) #不可，数字在python 中是独立的 在100外面家[100]可行，加了[]就是列表可以并入
print(lst1)   #打印结果====>[1, '小美', 2, 'python', '小', '明', 100]

"""
删除元素
remove(值)  不推荐使用
"""
lst1.remove(100)
print(lst1)  #====》[1, '小美', 2, 'python', '小', '明']

"""
pop删除
带索引删除pop索引——不带索引 删除最后一个
"""
lst1.pop(0)
print(lst1)  #删除索引为0的值 =====> ['小美', 2, 'python', '小', '明']
lst1.pop()
print(lst1) #默认删除最后一个元素 ======> ['小美', 2, 'python', '小']

"""
修改 变量名[索引]=新值
"""
lst1[0]="廖廖"
print(lst1)  #=======>['廖廖', 2, 'python', '小']
list_1[4][2]="216" #将函数list_1里面的第一个对象里面的第二个元素修改成216
print(list_1)  #=======>[100, 2.14, True, 'Huace', [1, 2, '216', 4]]

• 列表的切片

""""""
"""
lst[index] index是下标——正数，负数
当我们写负数的时候 倒过来 -1 代表最后一位 倒过来数
切片：取某一段数字
"""
lst =[0,1,2,3,4]
print(lst[-1])
lst1 = []   #append 是将对象加在列表末尾
# lst1.append(lst[1])
# lst1.append(lst[2])
# lst1.append(lst[3])
# 通过for循环简化
for i in range(1,len(lst)-1):
    lst1.append(lst[i])
print(lst1)
"""
切片操作：变量名[start:end:step]——range 取值范围一样
左闭右开
"""
lst3 = [100,3.14,True,"Haaa",[1,3,4]]
print(lst3[0:3])
print(lst3[:3])#0可以省略
print(lst3[0::1]) #end可以省略
# lst4 = lst3  #不能用列表直接赋值给另外一个列表
# lst4.append("廖廖")
# print("lst4的值：{}".format(lst4))    #=====>lst4的值：[100, 3.14, True, 'Haaa', [1, 3, 4], '廖廖']
# print("lst3的值：{}".format(lst3))    #=====>lst3的值：[100, 3.14, True, 'Haaa', [1, 3, 4], '廖廖']
# lst3 出现的脏数据，不应该出现廖廖 涉及到数据的安全性

lst4 =lst3[0:] #复制列表——需要复制列表，用这个
lst4.append("廖廖")
print("lst4的值：{}".format(lst4))  #====>lst4的值：[100, 3.14, True, 'Haaa', [1, 3, 4], '廖廖']
print("lst3的值：{}".format(lst3))  #lst3的值：[100, 3.14, True, 'Haaa', [1, 3, 4], ]


"""
找元素在列表中的索引
index(元素)
"""
print(lst3.index("Haaa"))    #===>3
# print(lst3.index(1111))   #=====> 1111 is not in list  获取列表中没有元素下标页面会报错 ，这个功能可以用于异常捕获
#例如：
try:
    print(lst3.index(1111))
except Exception:
    print("没有这个元素，你自己再看看？")



"""
统计元素的个数：
count(元素 ——这个元素在列表中多少个？？？？)
"""
print(lst3.count(3.14))   #====>1 这个列表中只要一个3.14  统计列表中没有元素 会报错

字典

• 字典的定义

""""""
"""
字典：具有键值对映关系的一组数据
K-V == 通过key:获取到对应的value 数字，字符串，列表，字典
关键字：dict
无序 没有索引
字典元素是用key:value 形态存储，key不能重复，一旦添加重复的key字典会认为你在修改value，从而
永远不会生成一个新的key：value 出现
key:不能重复也不能修改，一个字典内是唯一的，常用str
value:可以修改，可以是任何一个数据类型
"""
map = {
    "name":"廖廖",
    "sno":"001",
    "class":"216",
    "lst":[1,2,3,4,5]
}
print(map["lst"])  #取map里面的name   =====>[1, 2, 3, 4, 5]
print(type(map))  #<class 'dict'> 类型为字典

• 字典的增删查改

""""""
"""
字典的增加和修改比较简单：
新增：变量名[”字典里不存在的key“]= value ——向字典里面添加数据
修改：变量名[”字典里存在的key“]= value ——修改字典里面原有的数据value

"""
map = {
    "name":"廖廖",
    "sno":"001",
    "class":"216",
    "lst":[1,2,3,4,5]
}

#新增
map["teacher"]="小明"

#修改
map["teacher"]="长丰"

#字典里面取值
print(map["lst"][2])   #=====>3
print(map["class"])    #======>216

"""
删除：
pop(key) 通过key删除数据， key 不能为空如：map.pop()  推荐使用
popitem() 随机删除 以官方为准                         不推荐
clear() 清空
"""
map.pop("name")
print(map)    #========>{'sno': '001', 'class': '216', 'lst': [1, 2, 3, 4, 5], 'teacher': '长丰'} 名字廖廖被删除

map.popitem()
print(map)     #=======>{'sno': '001', 'class': '216', 'lst': [1, 2, 3, 4, 5]}

map.clear()
print(map)   #=====>{}

• 小练习1

""""""
"""
烤鸭店需求升级：
  1、录入商品的功能
  2、查询功能——搜索：输入烤鸭，烤鸭详细信息，价格 ，产地，日期 商品名
  3、退出
  
具体编码前，先想清楚，我们要做什么事情
【代码应该怎么写，用到哪些知识】
让老板去输入，自己要干什么
当老板选择查询，进入查询逻辑
当老板选择了退出，直接退出
"""
# 1.相对友好的提示界面
print("烤鸭店利润计算器卡开始工作")
#转义字符：键盘上的一些特殊的按键，空格，回车，F1-12，这些按钮没法像字母一样打印在屏幕上
#但是 这些特殊按键 可以通过另外的一个方式来约定
# 回车 == \n
projects=[] #商品，装多个元素
while True:
    oper_type=input("1-录入商品\n2-查询商品\n3-退出\n请做出你的选择")
    if oper_type=="1":
        print("录入逻辑开始") #对应的商品有多个属性
        load_name = input("请输入你要录入的商品名:")
        projects.append(load_name)
        price =input("请输入你的成本价：")
        projects.append(price)
        s_value=input("请输入你的产地：")
        projects.append(s_value)
        date_time = input("请输入你的生产日期：")
        projects.append(date_time)
    elif oper_type=="2":
        print("查询逻辑")
        print(projects)
    elif oper_type =="3":
        print("------系统退出----")
        break
    else:
        print("输入错误，请重试")

• 小练习2

""""""
"""
烤鸭店需求升级：
  1、录入商品的功能
  2、查询功能——搜索：输入烤鸭，烤鸭详细信息，价格 ，产地，日期 商品名
  3、退出

具体编码前，先想清楚，我们要做什么事情
【代码应该怎么写，用到哪些知识】
让老板去输入，自己要干什么
当老板选择查询，进入查询逻辑
当老板选择了退出，直接退出
"""
# 1.相对友好的提示界面
print("烤鸭店利润计算器卡开始工作")
# 转义字符：键盘上的一些特殊的按键，空格，回车，F1-12，这些按钮没法像字母一样打印在屏幕上
# 但是 这些特殊按键 可以通过另外的一个方式来约定
# 回车 == \n
projecties = {} # 商品，装多个元素（字典）
#{烤鸭：[名字，价格，产地，日期]}  我们希望这么存进去数据
while True:
    oper_type = input("1-录入商品\n2-查询商品\n3-退出\n请做出你的选择")
    if oper_type == "1":
        print("------录入逻辑开始------")  # 对应的商品有多个属性
        projects=[]   #为啥把列表放这，因为每一次循环需要清空原有数据
        load_name = input("请输入你要录入的商品名:")
        projects.append(load_name)
        price = input("请输入你的成本价：")
        projects.append(price)
        s_value = input("请输入你的产地：")
        projects.append(s_value)
        date_time = input("请输入你的生产日期：")
        projects.append(date_time)
        projecties[load_name]=projects  #根据商品名筛选显示它的详情
    elif oper_type == "2":
        print(projecties)
        po_name = input("请输入你要查询的商品名称")
        print(projecties[po_name])
    elif oper_type == "3":
        print("------系统退出----")
        break
    else:
        print("输入错误，请重试")

元组

• 元组的定义

""""""
"""
元组
和列表几乎完全一样 
1、有序的——索引去查询——正数或者负数
2、标识符 （） 元素 用逗号分割开来
3、关键字 tuple
和列表的不同点，它不能修改
"""
tp = ()
print(type(tp))
tp=(1,2,3,4)
print(tp[0])

tp1 = ("hello world",) #单个元素 元组需要加个逗号 反正系统会认为是str类型
print(type(tp1))

tp3=(100,3.14,True,"ddd",[1,2,3])
print(len(tp3))  #元组不提供 添加 删除 修改 统计等方法 但是提供查询长度等等
#因为元组不可修改 所以不会产生脏数据 数据安全性高
# 常量 ——不发生改变 可用来处理环境 重启 热部署
#元组可以相加 相乘
print(tp1+ tp)
print(tp1 * 2)

字符串

• 字符串操作

""""""
"""
一个字符串当一个列表用
获取字符串的某个字符  变量名[索引]
切片：变量名[start:end:step]
"""
str = "hello python"
res = str[1]  #===>hlo
print(res)
print(str[0:5:2])  #=====>
#步长——把100个学生排成队，从其中每隔一个人拉出来一个组成的结果是切片，此时步长为2

# 字符串的空格问题
"""
strip() 去除两端的空格
lstrip() 去除前端的空格
rstrip()  去除结尾空格
"""
str1 ="  hello liaoliao  "
print(str1)
print(str1.strip())
print(str1.lstrip())
print(str1.rsplit())


""""
replace()替换
old 原因的字符
new 替换后的字符
"""
print(str1.replace("h","k")) #替换str1总的h替换成k
print(str1.replace(" ",""))  #空格替换成没有空格 通常用于字符中间的空格


"""
切割：按某个规则去切割
split()
"""
str2 = "a.? c. ,v"
lst1=str2.split(".")
print(lst1)   #===>['a', '? c', ' ,v']

小项目-烤鸭店优化4

""""""
"""
烤鸭店需求升级：
  1、录入商品的功能
  2、查询功能——搜索：输入烤鸭，烤鸭详细信息，价格 ，产地，日期 商品名
  3、退出

具体编码前，先想清楚，我们要做什么事情
【代码应该怎么写，用到哪些知识】
让老板去输入，自己要干什么
当老板选择查询，进入查询逻辑
当老板选择了退出，直接退出
"""
# 1.相对友好的提示界面
print("烤鸭店利润计算器卡开始工作")
# 转义字符：键盘上的一些特殊的按键，空格，回车，F1-12，这些按钮没法像字母一样打印在屏幕上
# 但是 这些特殊按键 可以通过另外的一个方式来约定
# 回车 == \n
projecties = {} # 商品，装多个元素（字典）
head = ("商品名","成本价","产地","生产日期")
#{烤鸭：[名字，价格，产地，日期]}  我们希望这么存进去数据
while True:
    oper_type = input("1-录入商品\n2-查询商品\n3-退出\n请做出你的选择")
    if oper_type == "1":
        print("------录入逻辑开始------")  # 对应的商品有多个属性
        projects=[]   #为啥把列表放这，因为每一次循环需要清空原有数据
        for attr in head:
            value = input("请输入你要录入的{}：".format(attr))
            projects.append(value)
        projecties[projects[0]]=projects
    elif oper_type == "2":
        print(projecties)
        po_name = input("请输入你要查询的商品名称")
        print(projecties[po_name.strip()])
    elif oper_type == "3":
        print("------系统退出----")
        break
    else:
        print("输入错误，请重试")

集合

• 集合的定义

""""""
"""
集合——不同元素组成的一个数据结构
有序：有下标  无序：无下标
特点：1、无序
     2、允许不同的值放在一起
     3、操作方法  ——可以在集合中进行关系运算 包含，不包含关系
     4、集合表示：{}元素不会重复
     5、集合里面不能放列表和字典(可变)
"""
jh = {1,2,3,4,5,6,6,6,6,6}
#特征1 元素不会重复
print(jh)  #=====>{1, 2, 3, 4, 5, 6}  重复数据不会被打印
#特征2：无序
set = {"小明","嘘辉","碧霞","abc","111",}
print(set)#====>{'嘘辉', '111', 'abc', '小明', '碧霞'}  无序，随机

• 集合的运算

""""""
"""
集合 用于多组数据的逻辑运算
交集，并集，差集，交叉补集
"""

"""交集：两个集合中相同的数据"""
stu_set = {"廖廖","嘘辉"}
stu_set1 = {"廖廖","碧霞"}
#交集方法——intersection()
print(stu_set.intersection(stu_set1))  #===>{'廖廖'}

""" 并级方法——union  把两个集合进行合并，重复的元素也合并"""
stu_set = {"廖廖","嘘辉"}
stu_set1 = {"廖廖","碧霞"}
print(stu_set.union(stu_set1))  #===>{'嘘辉', '碧霞', '廖廖'}

""" 差集——difference() 两方比较只要我有的获取出来"""
set1 = {"廖廖","白","富","美"}
set2 = {"倩倩","傻","白","甜"}
print(set1.difference(set2))  #====>{'廖廖', '美', '富'}
print(set2.difference(set1))  #=====>{'傻', '甜', '倩倩'} 集合无序 所以顺序会乱

"""
交叉补集——symmetric_difference
1、共有的部分全部移除，只留下双方独有的部分
"""
set1 = {"廖廖","白","富","美"}
set2 = {"倩倩","傻","白","甜"}
print(set1.symmetric_difference(set2)) #====>{'甜', '倩倩', '美', '傻', '富', '廖廖'}
#当两方元素都相同则打印出：set() 代表是空集合

• 集合的元素操作

""""""
"""
集合的元素操作——增删查改
集合—— 无序 不支持索引
查询集合里面的元素需要转换为列表
"""
set1 = {"小明","老师","是","大帅哥"}
# print(set1[0])  #集合是无序的无法查询
"""查询集合元素的时候，需要对集合进行转换"""
lst = list (set1) #查询需要转换成列表
print(lst[0])
#因为查询 不会改变集合的元素 所以 你不管怎么转换类型，都不会造成影响
#集合：不是获取内部的单个数据
#如果 你对查询的要求很高，不应该选择集合这个数据类型，因为集合是无序的


""" 向集合添加元素——add()"""
set1.add("才怪")
print(set1)

"""
删除元素pop() 随机删除
删除元素remove() 指定删除 的方法
"""
# remove
set1.remove("老师")
print(set1)  #====>{'是', '小明', '才怪', '大帅哥'}  当删除集合中没有的元素 页面回报错

#pop  从下标0开始往后面删除
v=set1.pop()
print(v)   #删除是
v=set1.pop()
print(v)   #删除小明
v=set1.pop()
print(v)   #删除才怪

#discard() 没有这个元素，也不会报错
set2 = {"廖廖","老师","是","大美女"}
set2.discard("廖廖")
print(set2)  #==执行结果：集合是无序的==>{'大美女', '老师', '是'}
set2.discard("嘻嘻嘻")
print(set2)  #====>'大美女', '老师', '是'}