python-数据类型（下） ：byte、列表、元组、集合

byte：

msg = '我爱北京天安门'
print(msg.encode(encoding='utf-8').decode(encoding='utf-8'))

字符串转成byte类型，再转回来

列表：

定义一个空列表
my_list = []  或者 list()
my_list = list()
打印下元素个数
l = len(my_list)

可以定义空的列表 只要是列表那么就应该有[]
也支持下标索引获取元素
保存数据的元素 可以是任意类型

列表和字符串一样 是有序的

my_list = [1, 3, "hello", "哈哈"]
# 遍历列表的元素
# for循环
for value in my_list:
    print(value)
# while循环
index = 0
l = len(my_list)
while index < l:
    # 通过下标索引获取列表中的元素
    value = my_list[index]
    print(value)
    index += 1

# 添加元素(append, extend, insert)
# 列表是可变的(如果对当前列表的操作 是在原有的列表上进行更改)
my_list = [1, 3, 5, 8]
# append 添加一个整体(一个对象)
my_list.append([4, 5])  #后面追加
print(my_list)  # [1, 3, 5, 8, [4, 5]]
# extend 添加一个可以遍历的对象(有序的字符序列)
my_list.extend([4, 6, 9])  # [1, 3, 5, 8, [4, 5], 4, 6, 9]
print(my_list)   # [1, 3, 5, 8, [4, 5], 4, 6, 9]
# insert 插入到指定位置
my_list.insert(0, "hello")
print(my_list)   # ['hello', 1, 3, 5, 8, [4, 5], 4, 6, 9]

# 修改元素
my_list = ["ab", 11, 3.14]
# 把my_list中的11 改成"hello"
my_list[1] = "hello"
print(my_list)  # ['ab', 'hello', 3.14]
# 3.14改成3000
my_list[-1] = 3000
print(my_list)  # ['ab', 'hello', 3000]

# 删除元素 del, pop, remove
my_list = ["小明", 20, "小红", 50]
# del 删除指定的元素 (通过下标索引)
# 格式: del 列表名[下标索引]
# del 这个函数 是python内置函数(len  del)
del my_list[1]  # 某个位置的删除
print(my_list)
# pop是属于列表的方法
# pop 默认情况下 会从列表的后面开始删除
# .pop() 会有一个返回值 告知删除元素的值
print(my_list.pop())  # 删除最后一个
print(my_list)
# pop(下标索引)
print(my_list.pop(0))  # 删除某个位置
print(my_list)
# remove 通过对象(数值)来删除列表中的元素
my_list.remove("小红")
print(my_list)
# del 第二种用法 了解
# 提前杀死对象 提前释放内存
# del my_list
# clear 清空列表(列表中所有的元素全部删除)
my_list.clear() # 等价于 my_list = [] 或者 my_list = list()
print(my_list)

# 排序(sort, reverse)
# 导入模块
import random
# 定义一个列表列表中有6个元素
my_list = []  # 定义一个空的列表 用来保存数据
for i in range(6):
    value = random.randint(-10, 50)  # 获取随机数，六个元素每个数值范围 [-10, 50]
    # 把随机数添加到列表中
    my_list.append(value)
print(my_list)
# sort方法是将list按特定顺序重新排列，默认为由小到大，参数reverse=True可改为倒序，由大到小。
# reverse方法是将list逆置。
# 进行排序 -> 升序 (从小到大)
# 列表名.sort() 等价于 列表名.sort(reverse=False)
my_list.sort()
print(my_list)
# 降序 (从大到小)
my_list.sort(reverse=True)
print(my_list)
# python3.x中列表的排序只能是数字类型
names = ["ZhangYang","Guyun","XiangPeng","ChengRongHua","XuLiangChen"]
names.sort()  # 排序，按ascii码的顺序
print(names)  # ['ChengRongHua', 'Guyun', 'XiangPeng', 'XuLiangChen', 'ZhangYang']

 

# 查找元素("查"in, not in, index, count)
# 所谓的查找，就是看看指定的元素是否存在
# in, not in
# python中查找的常用方法为：
#     in（存在）,如果存在那么结果为true，否则为false
#     not in（不存在），如果不存在那么结果为true，否则false
my_list = ["老李", "老张", "小明", 400, 400]
# 使用in 判断一个元素是否存在列表中
if "老李" in my_list:
    print("存在在列表中")
# 使用not in 判断一个元素不存在列表中
if "小红" not in my_list:
    print("小红不存在")
# index 通过index 获取某个元素在列表中的下标索引
ret1 = my_list.index(400)
print(ret1)  # 3
# count 查找某个元素的值在列表中出现的次数
ret2 = my_list.count(400)
print(ret2)  # 2
# 查询400 如果有给我下标索引 如果没有 什么也不做
# 使用count 配合完成
count = my_list.count(400)
if count > 0:
    index = my_list.index(400)
    print(index)
# 使用in 配合完成
if 400 in my_list:
    index = my_list.index(400)
    print(index)

 列表的嵌套

schoolNames = [['北京大学','清华大学'],
               ['南开大学','天津大学','天津师范大学'],
               ['山东大学',["新东方", "蓝翔"],'中国海洋大学']]

# 获取天津大学字符串
my_list = schoolNames[1]
print(my_list)
name = my_list[1]
print(name)
# 简写
name = schoolNames[1][1]
print(name)
name = schoolNames[2][1][0]
print(name)

# 编程实现对一个元素全为数字的列表，求最大值、最小值
my_list = [-1, -5, -10, -200, -300, -40]
# 定义一个变量 记录最终的最大值
# 不是所有的默认值都要设置为0 考虑到语境
my_max = my_list[0]
for value in my_list:
    #判断如果列表中的元素值大于最大值
    if value > my_max:
        # 赋值
        my_max = value
print(my_max)

 

names = ["ZhangYang","Guyun","XiangPeng","XuLiangChen"]
print(names)
print(names[0],names[2])
print(names[1:3]) #切片，顾头不顾尾，不包含第3个
print(names[-1]) #从右边开始数
print(names[-3:]) #取后面三个
print(names[-3:-1]) #取中间2个
print(names[:3]) #0可以省略

names = ["ZhangYang","Guyun","XiangPeng","ChengRongHua","XuLiangChen"]
print(names)
print(names.index("Guyun")) #"Guyun"的位置
print(names[names.index("Guyun")])
print(names.count("ChengRongHua")) #统计个数
names.clear() #清空列表中的元素
print(names)
names.reverse() #反转
print(names)

names = ["ZhangYang","Guyun","XiangPeng",["Alex","Jack"],"ChengRongHua","XuLiangChen"]
name2 = names.copy() #复制
print(names)
print(name2)
names[2] = "向鹏"
print(names)
print(name2) #不变
names[3][0] = "alex"
print(names)
print(name2) #也变
name2 = names #names列表内容改变。name2 也改变

import copy
names = ["ZhangYang","Guyun","XiangPeng",["Alex","Jack"],"ChengRongHua","XuLiangChen"]
name2 = copy.copy(names) #浅copy ,与name2 = names.copy()效果一样

其它浅copy

person = ['name',['a',100]]
p1 = person[:]
p2 = list(person)

import copy
names = ["ZhangYang","Guyun","XiangPeng",["Alex","Jack"],"ChengRongHua","XuLiangChen"]
name2 = copy.deepcopy(names) #深copy
print(names)
print(name2)
names[2] = "向鹏"
print(names)
print(name2) #不变
names[3][0] = "alex"
print(names)
print(name2) #不变

 

元组

元组其实跟列表差不多，也是存一组数，只不过它一旦创建，便不能再修改，所以又叫只读列表
names = (“alex”,”jack”,”eric”)
它只有两个方法，一个是count，一个是index

# 列表是可变的，元组是不可变的
# 定义一个字符串 "" 或者 ''
# 定义一个列表 []
# 定义一个元组 ()
my_tuple = (1, 3.14, True, "HELLO")
print(type(my_tuple))  # 查看数据类型<class 'tuple'>
# 定义一个空元组
my_tuple = ()
print(type(my_tuple))  # <class 'tuple'>
my_tuple = tuple()
print(type(my_tuple))  # <class 'tuple'>
# 特列
# 如果元组中只有一个元素
# 人为是把一个整数用小括号包裹起来 还是认识int类型
# (1,) -> 元组  (1) -> int
my_tuple = (1)
print(type(my_tuple))  # <class 'int'>
my_tuple = (1,)
# 通过下标获取元组中的元素
my_tuple = (1, 3.14, True, "HELLO")
value = my_tuple[1]  # 获取3.14
print(value)
# 通过下标修改元组的元素
# 因为元组是不可变的 不可以修改元素 或者删除元素
# 只能查看元素 或者遍历元组中的元素
# my_tuple = (1, 3.14, True, "HELLO")
# my_tuple[3] = 666   # 报错
# index count
my_tuple = (1, 3.14, True, "HELLO", 3.14)
# 元组中元素的位置
index = my_tuple.index(3.14)
print(index)
# 获取某个元素在 元组中出现的次数
count = my_tuple.count(3.14)
print(count)
# for循环遍历
for value in my_tuple:
    print(value)
# while循环遍历
index = 0
while index < len(my_tuple):
    # 通过下标获取指定的元素
    value = my_tuple[index]
    print(value)
    index += 1

元组是不可变的  列表是可变的?
有时候我们需要保存一些数据 而这些数据不会改变 那么久应该使用元组进行保存
元组的不可变 是为了数据安全考虑
定义一个空的元组 只要定义完成 就已经决定了数值 是不能改变的 -> 不可变的

# 问题讲解
# True 为 1  False 为 0
my_tuple = (3.14, True, "HELLO", 3.14)
ret = my_tuple.index(True)
print(ret)  # 1

 

集合操作

集合是一个无序的，不重复的数据组合，它的主要作用如下：
去重，把一个列表变成集合，就自动去重了
关系测试，测试两组数据之间的交集、差集、并集等关系

常用操作
s = set([3,5,9,10]) 　  #创建一个数值组合
t = set("Hello") 　　   #创建一个数值组合
a = t | s 　　　　　　 #t和s的并集
b = t & s 　　　　　  #t和s的交集
c = t - s 　　　　　  #求差集（项在t中，但不在s中）
d = t ^ s 　　　　　  #对称差集（项在t或s中，但不会同时出现在二者中）

如：

list_1 = [1,4,5,7,3,6,7,9]
list_1 = set(list_1)

list_2 = set([2,6,0,66,22,8,4])
print(list_1,type(list_1))
print(list_2,type(list_2))
print(list_1.intersection(list_2))  #交集
print(list_1.union(list_2))         #并集
print(list_1.difference(list_2))    #差集in list_1 but not in list_2
print(list_1.issubset(list_2))      #子集,false,list_1不是list_2的子集
print(list_1.issuperset(list_2))    #父集
list_3 = set([1,3,7])
print(list_3.issubset(list_1))      #子集,true,list_3不是list_1的子集
print(list_1.issuperset(list_3))    #父集,true
print(list_1.symmetric_difference(list_2))  #对称差集，两个互相没有的取出来
list_4 = set([5,6,8])
print(list_3.isdisjoint(list_4))    #两个没有交集返回true

print(list_1 & list_2)  #交集
print(list_1 | list_2)  #并集
print(list_1 - list_2)  #差集
print(list_1 ^ list_2)  #对称差集

基本操作
t.add('x')　　　　　　　　#添加一项
s.update([10,37,42])　　  #在s中添加多项

t.remove('H')#使用remove()可以删除一项
len(s)
set的长度
x in s
测试x是否是s的成员
x not in s
测试x是否不是s的成员

如：

list_1 = [1,4,5,7,3,6,7,9]
list_1 = set(list_1)
list_1.add(999)
list_1.update([888,777,555])
print(list_1.pop())     #任意删一个，并返回删除的值
list_1.remove(5)        #删除，如果不存在会报错
list_1.discard(666)     #删除，如果不存在不会报错
print(list_1)