2020-09-22

03-高级数据类型

Catalogue

1. 一.01_列表的创建
2. 二.02_列表的索引和分片
3. 三.03_列表的加号和乘号
4. 四.04_列表的常用方法
5. 五.05_列表推导式
6. 六.06_元组的基本操作
7. 七.07_元组的基本操作2
8. 八.08_range的基本操作
9. 九.09_set集合的基本操作
10. 十.10_set集合的常用操作
11. 十一.11_字典dict的基本操作
12. 十二.12_字典dict常用方法
13. 十三.13_字典dict推导式
14. 十四.14_图书管理系统
15. 十五.15_对象的拷贝
16. 十六.16_对象的拷贝2
1. 16.1. 参考资料

一.01_列表的创建

"""
列表的基本描述：
1，列表的创建方式 a = [1,2,3]
2，列表是有序的集合，可以通过索引，分片进行元素的操作
3，列表是一个可变对象，对于列表的元素，可以进行修改，删除等操作
4，列表中元素的数据类型可以是任意的数据类型，数字，字符串
5，列表可以嵌套，列表中的原酸可以是列表数据类型
6，列表中存放的是每个元素的对象的引用
7，列表的数据的表示方式是使用一对中括号[],每个元素之间使用逗号隔开
"""

list1 = [1,2,3]
print(list1)
print(type(list1))
print(len(list1))

#可变对象，长度可以修改，元素可以添加，删除，修改
list2 = [1,2,"a"]
print(list2)

list3 = [1,2,[2,3]]
print(list3)
print(len(list3))

二.02_列表的索引和分片

"""
"""
list1 = [1,2,3]
print("list1:",list1)

#索引操作
print(list1[1])
list1[1] = 100
print(list1)

#删除
del list1[1]
print("删除后，list1:",list1)

#分片操作, [:]操作 【:), 前包括后不包括
list2 = list1[0:2]
print("list2:",list2)
print("id,list1=，",id(list1))
print("id,list2= ",id(list2))

print("="*50)

list1[2:2] = [4,5] 
print("插入之前：",list1)

#先删除,在插入 【0:）操作，在0的位置上，插入["a","b","c"]
list1[1:2] = ["a","b","c"]
print(list1) 

#只删除第0个元素
list1[0:1] = []
print(list1)

#只添加操作
list1[0:0] = [100,200]
print(list1)

#for 遍历
for item in list1:
    print(item)

三.03_列表的加号和乘号

"""
+ 连接符
* 复制符号
"""

#必须是相同类型的序列， list()函数，可以将字符串分解成list
list1 = [1,2,3] + list("abc")
print(list1)

# * 复制符号
list2 = [1,[2]] * 2
print(list2)        # [1,[2],1,[2]]

#把第一个元素改成100
list2[0] = 100
print(list2)        #[100,[2],1,[2]]

#把第二个元素中的第一个元素改成200
list2[1][0] = 200
print(list2) #[100,[200],1,[200]], 这里你会发现，第2个元素和第4个元素，同时修改了值

list2[1] = [300]
print(list2) # 只改第2个元素

四.04_列表的常用方法


list1 = [1,2,3]

#append， 在末尾增加一个元素，在原来的list1的基础上进行修改，返回值是None
ret = list1.append(50)

#插入 索引
list1.insert(1,100)
#如果索引不在范围内，如果索引是正数，则会插入到末尾，如果是负数，则会插入到第一个元素
list1.insert(1000,1000)

#删除，根据值来删除, 如果没有，直接报错 ValueError
#list1.remove(500)

#查询
#返回查到的次数，如果没有，返回0
print(list1.count(4))

#返回查到的索引，如果没有，直接报错 ValueError
print(list1.index(1))

#返回True ，False
print(500 in list1)

#合并两个元素
list1.append(["x","y","z"]) #这里是追加元素，把["x","y","z"] 当成一个元素
list1.extend(["a","b","c"])  #这里是将两个列表合并，["x","y","z"] 合并之后，成为3个元素

print(list1)

#翻转,倒叙
list1.reverse()
print(list1)

五.05_列表推导式

"""
需求：将字符串wolfcode中每一个字符取出来，放到list中

#第一种方式，常见for循环
list1 = []
for item in text:
    list1.append(item)

print(list1)

"""
text = "wolfcode"

#列表推导式
list1 = [item for item in text]
print(list1)

#需求，将字符串 MF 和 SMLX 中每一个字符去除，交叉组成新的字符串，放到list中

"""
#for循环
list2 = []
for sex in "MF":
    for size in "SMLX":
       list2.append(sex+size)

print(list2)
"""

#列表推导式
#刨除FX型号
list2 = [sex+size for sex in "MF" for size in "SMLX" if not (sex=="F" and size=="X")]
print(list2)

六.06_元组的基本操作

"""
"""
#创建元组
t1 = (1,2,3)
print(len(t1))
print(t1)
print(type(t1))

t2 = (1,[1,2])
print(t2)

#元组是不可变的，这里会报错
#t2[0] = 1000

#这里是正确的，因为，元组中最后一个元素是一个列表，列表是可变的
t2[-1][1] = 100
print(t2)

#分片操作
print("分片:",t1[1:])
t1 = t1[1:]
print(t1)

七.07_元组的基本操作2

"""
"""

t1 = (1,2,3)
print(t1)
print(type(t1))

#count()
print(t1.count(10))
print(t1.index(2))

for item in t1:
    print(item)

#元组的装包和拆包
#在赋值符号的右边，会把多个值包装成一个元组
a = 3,4,5
print(a)
print(type(a))

print("="*50)

#把一个元组拆分成三个赋值给a,b,c
#在元组拆包的时候，变量的个数必须和元组的数据个数一致，否则报错
a,b,c = (3,4,5)
print(a)
print(b)

八.08_range的基本操作

"""
range是一个不可变的序列对象，主要用于生产整数的序列，
通常是配合for循环用于生成循环次数，可以把range对象的数据
转换为list数据
"""

#创建一个range
#创建一个[0,10) 的一个整数的数据
r1 = range(10)
print(r1)
print(len(r1))
print(type(r1))
print(list(r1))

#有序序列
print(r1[0])
print(r1[-1])

for item in r1:
    print(item)

print("="*50)

list1 = list(r1)
print(list1)
print(100 in r1)

#生成[5,10)的range数据
r2 = range(5,10,2)   #start,stop, step
print(list(r2))

九.09_set集合的基本操作

"""
set集合：
没有顺序，不允许元素重复
"""

s1 = {1,2,4,3}
print(type(s1))
print(len(s1))
print(s1)

#报错
#print(s1[0])

s2 = {1,2,1,3,1,4}
print(s2)

list1 = {1,2,1,100,200}
s3 = set(list1)
print(s3)
print(list(s3))

#创建空集合
s4 = set(), #并不是{},这个{}的类型是dict
print(type(s4))

十.10_set集合的常用操作

"""
"""
s1 = {1,3,2,4}
s2 = {3,1,8,0}
s1.add(100)

#在set集合中，可以存放不可变的数据，但是对于可变的数据列表list, 集合数据set不行, 元组可以
s1.add((200,300))

#删除100这个元素
s1.remove(100)

#随机删除一个元素
# s1.pop()

#清空集合
# s1.clear()

#两个集合的交集
print("交集:",s1 & s2)

#两个集合的并集
print("并集:",s1 | s2)

#两个集合的差集
print("差集:",s1 - s2)

print(s1)
print(s2)

#循环遍历集合
for item in s1:
    print(item)

print("="*50)
#集合推导式
s3 = {index for index in range(10) if index%2 == 0}
print(s3)

十一.11_字典dict的基本操作

"""
字典：
1, 创建方式 a = {"number":"001", "score":100}
2, 数据是无序的，不能通过索引，分片操作，获取字典元素需要通过键来获取
    键值对一一对应的
3，字典是一个可变的集合，可以对字典进行添加，删除，修改等操作
4，字典的key 通常是一个字符串类型，也可以是数字，元组等不可变类型，
    但不能是集合set和列表list以及字典类型，但是对于字典的值可以是任意类型

"""

d1 = {"姓名":"张三","语文":90, "数学":85,"英语":60}
print(d1)
print(len(d1))
print(type(d1))

print(d1["姓名"])

#这儿报错，key不能是list
#d3 = {[1,2]:3}

#key可以是元组
d3 = {(1,3):3}
print(d3)

十二.12_字典dict常用方法

"""
"""
d1 = {"姓名":"张三","语文":90,"数学":85,"英语":60}
d2 = {"姓名":"李四","语文":100,"数学":70,"英语":75}

print(d1["姓名"])


#设置总成绩，添加字段
d1["总成绩"] = 240
d2["总成绩"] = 245

#修改，如果有key, 则进行修改，如果没有，则添加
d1["英语"] = 100
d1["历史"] = 75

#删除
del d1["历史"]

#通过方法
print("获取成绩:",d1.get("语文"))
#get方法，第一个参数为key值，第二个参数为默认值，如果没有key, 
#则将默认值返回
print("获取成绩:",d1.get("地理",95))

#删除语文
#d1.pop("语文")

#同时修改姓名和数学成绩
d1.update([("姓名","王五"),("数学",20)])

print(d1)
print(d2)

print("="*100)

#把两个学生放到list集合
list1 = [d1,d2]
for item in list1:
    print(item)

#in 在字典中，用来判断key是否存在
print("姓名" in d1)

#获取所有的key
print("keys:",d1.keys())

#获取所有的value
print("values:",d1.values())

#获取所有的键值对
print("键值对:",d1.items())

十三.13_字典dict推导式

"""
d1 = {"姓名":"张三","语文":90,"数学":85,"英语":60}
需求：通过循环的方式打印所有的信息
"""

d1 = {"姓名":"张三","语文":90,"数学":85,"英语":60}

print("方法一：")
#方法一：
keys = d1.keys()
for key in keys:
    print("{0}-->{1}".format(key,d1[key]))

print("方法二：")
#方法二：
items = d1.items()
#这里本来应该是item, 通过拆包操作，将元组item拆分为key,value
for key,value in items:
    print("{0}-->{1}".format(key,value))
    

print("方法三：")
#方法三, 对于字典的for=遍历，默认情况下是遍历所有的keys
for key in d1:
    print("{0}-->{1}".format(key,d1[key]))


#需求2， 生成1-10之间所有数字的平法，并且对应起来 {1:1,2:4,3:9,...9:81}
d3 = {key:key**2 for key in range(1,10)}
print("d3:",d3)

十四.14_图书管理系统

"""
图书管理系统
1.查找图书
2.借阅图书
3.归还图书
4.显示所有图书
5.退出系统
"""

print("="*50)
print("图书管理系统")
print("1.查找图书")
print("2.借阅图书")
print("3.归还图书")
print("4.显示所有图书")
print("5.退出系统")
print("="*50)

books = [
    {"名称":"python","数量":10},
    {"名称":"java","数量":10},
    {"名称":"c","数量":10},
]

while True:
    model = int(input("请输入你的选择序号:"))
    if model == 1:
        print("1.查找图书")
        book_name = input("请输入图书名称:")
        for book in books:
            if book_name == book["名称"]:
                print("找到你需要的图书信息:",book)
                break
        #循环中的else, 一般都是配合break使用，当没有执行break的时候，会执行else中的语句
        #如果执行了break,就不会执行else的语句
        else:
            print("未找到当前图书,",book_name)
    elif model == 2:
        #print("2.借阅图书")
        book_name = input("请输入你要借阅的图书书名:")
        for book in books:
            if book_name == book["名称"] and book["数量"] > 0:
                print("借阅成功")
                book["数量"] -= 1
                break
        else:
            print("没有找到你需要的图书,",book_name)
    elif model == 3:
        #print("3.归还图书")
        book_name = input("请输入你要归还的图书书名:")
        for book in books:
            if book_name == book["名称"] :
                book["数量"] += 1
                break
        else:
            books.append({"名称":book_name,"数量":1},)
        print("归还成功")
    elif model == 4:
        #循环遍历图书信息
        for book in books:
            print(book)
    elif model == 5:
        break
    else :
        print("输入序号错误")

十五.15_对象的拷贝

"""
list1 = [1,2,3]
list2 = list1;
print(list1)
print(list2)

#修改list2里面的值
print("="*50)
list2[0] = 100

print(list1)
print(list2)

#内存地址
print("list1:",id(list1))
print("list2:",id(list2))
"""

list1 = [1,2,3]
list2 = list1[:] #通过分片操作，拷贝对象

print(list1)
print(list2)

print("="*50)
list2[0] = 100

print(list1)
print(list2)

#内存地址
print("list1:",id(list1))
print("list2:",id(list2))

十六.16_对象的拷贝2

"""
对于浅拷贝和深拷贝，在python中，有专门的copy模块，有2个方法,
copy 和 deepcopy

#列表中没有集合元素
#导入拷贝的模块
import copy
a = [1,2,3]
b = copy.copy(a)
print("浅拷贝:",id(a),id(b))
b[1] = 100
print(a)
print(b)
"""

#导入拷贝的模块
import copy
a = [1,[2]]
b = copy.copy(a)
#a[1] 和 b[1] 是相同的内存地址
print("浅拷贝:",a,b, id(a),id(b), id(a[1]),id(b[1])),

c = copy.deepcopy(a)
print("深拷贝:",a,c, id(a),id(c), id(a[1]),id(c[1])),

一.01_列表的创建

二.02_列表的索引和分片

三.03_列表的加号和乘号

四.04_列表的常用方法

五.05_列表推导式

六.06_元组的基本操作

七.07_元组的基本操作2

八.08_range的基本操作

九.09_set集合的基本操作

十.10_set集合的常用操作

十一.11_字典dict的基本操作

十二.12_字典dict常用方法

十三.13_字典dict推导式

十四.14_图书管理系统

十五.15_对象的拷贝

十六.16_对象的拷贝2

参考资料