Python内置数据结构列表与元组(基本操作和特性)

1.序列

成员有序排列的,且可以通过下标偏移量访问到它的一个或者几个成员,这类类型统称为序列。
序列数据类型包括:字符串,列表,和元组类型。
特点: 都支持下面的特性
索引与切片操作符
成员关系操作符(in , not in)
连接操作符(+) & 重复操作符(*)

2.列表

数组: 存储同一种数据类型的集和。scores=[12,95.5]
列表(打了激素的数组): 可以存储任意数据类型的集和。

2.1列表的创建

创建空列表
li = []
创建一个包含元素的列表，元素可以是任意类型，
包括数值类型，列表，字符串等均可, 也可以嵌套列表。
list = [“fentiao”, 4, ‘gender’]
list = [[‘粉条’, 100], [“粉丝”, 90], [“粉带”, 98]]

2.2列表的基本特性(参考字符串学习)

2.2.1. 连接操作符和重复操作符

print([1, 2] + [2, 3]) # [1, 2, 2, 3]
print([1, 2] * 3) # [1, 2, 1, 2, 1, 2]

2.2.2. 成员操作符(in, not in)

print(1 in [1, 2, 3])# True
特殊情况
布尔类型:
True: 1
False:0
print(1 in ["a", False, [1, 2]]) # False False相当于0
即使列表里面嵌套的列表里面有1值，也显示False

2.2.3. 索引

li = [1, 2, 3, [1, ‘b’, 3]]

print(li[0])	# 1
print(li[-1])	# [1, ‘b’, 3] 打印列表最后一个元素
print(li[-1][0])	# 1
print(li[3][-1])	# 3

2.2.4. 切片

li = [‘172’, ‘25’, ‘254’, ‘100’]
print(li[:2])
print(li[1:])
print(li[::-1])
需求: 已知['172', '25', '254', '100']， 输出: "100-254-25"
(在上文中也同样的题，172.25.254.100 将此字符串以"."为分隔符，ip.split(’.’)，其思想就是将其分割成列表，再将其拼接)

li = ['172', '25', '254', '100']
print("-".join(li[1:][::-1]))

2.2.5. for循环

names = [“粉丝”, ‘粉条’, ‘粉带’]
for name in names:
print(f"西部开源猫大佬的姓名是:{name}")

2.3列表的常用方法

2.3.1. 增加

1). 追加

li = [1, 2, 3]
li.append(4) #添加单个元素
print(li) # [1,2,3,4] 默认添加在末尾

2). 在列表开头添加

li = [1, 2, 3]
li.insert(0, 'cat')
print(li) #['cat',1,2,3]

在索引2前面添加元素cat

li = [1, 2, 3]
li.insert(2, ‘cat’)
print(li)

3). 一次追加多个元素

li = [1, 2, 3] # 添加4， 5， 6
li.extend([4, 5, 6])
print(li) ##[1,2,3,4,5,6]

2.3.2. 修改: 通过索引和切片重新赋值的方式。

li = [1, 2, 3]
li[0] = ‘cat’ ##将原列表中第一个元素1改为cat
li[-1] = ‘westos’ ##3—> westos
print(li) ##['cat',2,'westos']

li = [1, 2, 3]
li[:2] = [‘cat’, ‘westos’]
print(li) ##[‘cat’,‘westos’,3] 将前两个元素换为。。。

2.3.3. 查看: 通过索引和切片查看元素。 查看索引值和出现次数。

li = [1, 2, 3, 1, 1, 3]
print(li.count(1)) # 3
print(li.index(3)) # 2

2.3.4. 删除

1). 根据索引删除

li = [1, 2, 3]

将pop方法的结果存储到delete_num变量中。

delete_num = li.pop(-1) 会删除掉列表中最后一个元素
print(li) ##[1,2]
print(“删除的元素是:”, delete_num)

2). 根据value值删除

li = [1, 2, 3]
li.remove(1)
print(li)

3). 全部清空

li = [1, 2, 3]
li.clear()
print(li)

2.3.5. 其他操作

li = [1, 2, 3, 4]
li.reverse() #类似于li[::-1]
print(li)

sort排序默认由小到大。 如果想由大到小排序，设置reverse=True

li.sort(reverse=True)
print(li)

li1 = li.copy()
print(id(li), id(li1))
print(li, li1)

3.元组（tuple(戴了紧箍咒的列表, 不能修改元素)）

3.1元组的创建

t1 = () # 空元组

t2 = (1,) # 重要(易错点):元组只有一个元素时一定要加逗号
print(t2, type(t2))

t3 = (1, 1.2, True, [1, 2, 3]) 仍然是元组类型

3.2元组基本特性

3.2.1连接操作符和重复操作符

print((1, 2, 3) + (3,))
print((1, 2, 3) * 2)

3.2.2成员操作符

print(1 in (1, 2, 3))

3.2.3索引，切片

t = (1, 2, 3)
print(t[0])
print(t[-1])
print(t[:2])
print(t[1:])
print(t[::-1])

3.3. 常用方法: 元组是不可变数据类型(不能增删改)

查看: 通过索引和切片查看元素。 查看索引值和出现次数。

t = (1, 2, 3, 1, 1, 3)
print(t.count(1)) # 3
print(t.index(3)) # 2

4.命名元组

Tuple还有一个兄弟，叫namedtuple。虽然都是tuple，但是功能更为强大。

tuple = (“westos”, 18, “西安”)
print(tuple[0], tuple[1], tuple[2])
从collections模块中导入namedtuple工具。
from collections import namedtuple
1.创建命名元组对象User
User = namedtuple(‘User’, (‘name’, ‘age’, ‘city’))
2.给命名元组传值
user1 = User(“westos”, 18, “西安”)
3 打印命名元组
print(user1)
4 获取命名元组指定的信息
print(user1.name)
print(user1.age)
print(user1.city)

5 is 和==的区别

1). Python中对象的三个基本要素，分别是：id(身份标识)、type(数据类型)和value(值)。

2). is和==都是对对象进行比较判断作用的，但对对象比较判断的内容并不相同。

3). ==用来比较判断两个对象的value(值)是否相等；(type和value)
is也被叫做同一性运算符， 会判断id是否相同;(id, type 和value)

python语言:
   ==: 类型和值是否相等
   is: 类型和值是否相等， 内存地址是否相等
`

print(1 == '1') # False
li = [1, 2, 3]
li1 = li.copy() ##copy的时候li和li1的内存地址不一样

 id(li)  #查看内存地址
 id(li1)

print(li == li1) # True
print(li is li1)#False

6.深拷贝与浅拷贝

赋值： 创建了对象的一个新的引用，修改其中任意一个变量都会影响到另一个。(=)
nums1 = [1, 2, 3]
nums2 = nums1
nums1.append(4)
print(nums2) # 1, 2, 3, 4
浅拷贝： 对另外一个变量的内存地址的拷贝，这两个变量指向同一个内存地址的变量值。(li.copy(), copy.copy())
公用一个值；
这两个变量的内存地址一样；
对其中一个变量的值改变，另外一个变量的值也会改变；
n1 = [1, 2, 3]
n2 = n1.copy()# n1.copy和n1[:]都可以实现拷贝。
print(id(n1), id(n2))
n1.append(4)
print(n2)

深拷贝： 一个变量对另外一个变量的值拷贝。(copy.deepcopy())
两个变量的内存地址不同；
两个变量各有自己的值，且互不影响；
对其任意一个变量的值的改变不会影响另外一个；

可变数据类型(可增删改的): list
不可变数据类型:数值，str， tuple， namedtuple

n1 = [1, 2, [1, 2]]
n2 = n1.copy()
n1和n2的内存地址:的确拷贝了
print(id(n1), id(n2))
n1[-1]和n2[-1]的内存地址: 地址相同
print(id(n1[-1]), id(n2[-1]))
n1[-1].append(4)
print(n2) #[1,2,[1,2,4]]

test:列表练习题：编写云主机

待更新

"""
编写一个云主机管理系统：
    - 添加云主机(IP, hostname,IDC)
    - 搜索云主机(顺序查找)
    - 删除云主机
    - 查看所有的云主机信息
"""
from collections import  namedtuple
menu = """
                云主机管理系统
        1). 添加云主机
        2). 搜索云主机(IP搜索)
        3). 删除云主机
        4). 云主机列表
        5). 退出系统
        
请输入你的选择: """

# 思考1. 所有的云主机信息如何存储?选择哪种数据类型存储呢?  选择列表
# 思考2: 每个云主机信息该如何存储?IP, hostname,IDC   选择命名元组
hosts = []
Host = namedtuple('Host', ('ip', 'hostname', 'idc'))
while True:
    choice = input(menu)
    if choice == '1':
        print('添加云主机'.center(50, '*'))
        ip = input("ip:")
        hostname = input("hostname:")
        idc = input('idc(eg:ali,huawei..):')
        host1 = Host(ip, hostname, idc)
        hosts.append(host1)
        print(f"添加{idc}的云主机成功.IP地址为{ip}")
    elif choice == '2':
        print('搜索云主机'.center(50, '*'))
        # 今天的作业: for循环(for...else),判断, break
    elif choice == '3':
        print('删除云主机'.center(50, '*'))
        # 今天的作业:(选做)
    elif choice == '4':
        print('云主机列表'.center(50, '*'))
        print("IP\t\t\thostname\tidc")
        count = 0
        for host in hosts:
            count += 1
            print(f'{host.ip}\t{host.hostname}\t{host.idc}')
        print('云主机总个数为', count)
    elif choice == '5':
        print("系统正在退出，欢迎下次使用......")
        exit()
    else:
        print("请输入正确的选项")