python的列表和元组

序列

成员有序排列的,且可以通过下标偏移量访问到它的一个或者几个成员,这类类型统称为序列。
序列数据类型包括:字符串,列表,和元组类型。
特点: 都支持下面的特性

索引与切片操作符
成员关系操作符(in , not in)
连接操作符(+) & 重复操作符(*)

列表

先首先需要建立列表
数组: 存储同一种数据类型的集和。scores=[12,95.5]

列表(打了激素的数组): 可以存储任意数据类型的集和。

创建空列表：

li = []
print(type(li))

输出结果如下：
种类：列表！！

创建一个包含元素的列表，元素可以是任意类型，
包括数值类型，列表，字符串等均可, 也可以嵌套列表。

list = [1,2,3]
print(type(list))
list1 = [1,2,['hello','westos']]
print(type(list1))

结果如下：

列表的基本性质

连接操作符，重复操作符

比如：

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

列表之间可以直接相加输出，或者乘以数字，重复输出！

成员操作符

包括in,not in
来判断真假（true/flase）
比如：

print(1 in [1,2,3])
print(4 in [1,2,3])

结果如下：

索引

输出某个位置的数字！
后面的列表嵌套列表形式，嵌套内的列表整体表示一个索引！！！

list = [1,2,3,[4,5,6]]
print(list[0])
print(list[-1])
print(list[-1][1])
print(list[-1][-1])

结果如下：

切片

比如：

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

结果如下：

for 循环

n = ['westos','linux','python']
for items in n:
    print(f'obj is {items}')

结果如下：

处理列表的方法有：

1.增加
增加分为好几种类别：追加，开头加，索引添加！

#(1)追加4
list = [1,2,3]
list.append(4)
print(list)
#(2)在列表开头添加4
list = [1,2,3]
list.insert(0,4)
print(list)
#(3)在索引2前面添加4
list = [1,2,3]
list.insert(2,4)
print(list)
#(4)扩展多个元素
list = [1,2,3]
list.extend([4,5,6])
print(list)

操作如下：

2.修改

直接在列表里用索引替换！

list = [1,2,3]
list[0] = 'westos'
list[2] = 'hello'
print(list)

结果如下：

查看

方式：
(1)通过索引和切片查看元素
(2)通过索引值和出现次数

count()统计某数字出现的次数！！
index()统计某数字的索引是多少！！

list = [1,2,3,4,2,3,3,2,1,1,4,6]
print(list.count(3))
print(list.index(3))

结果如下：

删除

删除也有多种删除方式：
索引删除，vaule删除，全部清除
例如：

list = [1,2,3,4]
del_list = list.pop(0)
print(list)
list = [1,2,3]
list.remove(2)
print(list)
list = [1,2,3]
list.clear()
print(list)

结果如下：

拷贝，反转，排序

list = [4,2,5,1,3]
list.sort() ##排序
print(list)
list.reverse() ##反转
print(list)

list1 = list.copy() ##复制
print(id(list),id(list1))

结果如下：

排序sort本来是从小到大的排列，如果加上reverse=True就可以实现从大到小的排列 !!

元组

元组tuple（戴了紧箍咒的列表）
当元组中只有一个元素的时候，要加逗号，如：（1，），不然输出类型就为整型（int）

t1 = ()
print(t1,type(t1))
t2 = (1,)
print(t2,type(t2))

结果如下：

元组的特点

元组是不可变数据类型（不能增删改）

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

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

结果如下:

命名元组

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

from collections import namedtuple
user = namedtuple('user',('name','age','city'))
user1 = user('westos',18,'xian')
print(user1)
print(user1.name)
print(user1.age)
print(user1.city)

执行结果如下：

is和==的不同

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

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

==用来比较判断两个对象的value(值)是否相等；(type和value)
is也被叫做同一性运算符， 会判断id是否相同;(id, type 和value)
所以is判断的比较全面，比 双等 要条件多！！

【或者说：== 是判断类型和值是否相同！ is :是判断类型和值，以及内存地址是否相等！】

例如：

print(1 == '1')
li = [1,2,3]
li1 = li.copy()
print(li == li1)
print(li is li1)
print(id(li),id(li1))

结果如下：

练习

编写一个云主机的管理系统！！
要求如下：
- 添加云主机(IP, hostname,IDC)
- 搜索云主机(顺序查找)
- 删除云主机
- 查看所有的云主机信息

from collections import namedtuple
menu = """
1).add host
2).search host
3).deleted host
4).list all host
5).exit
input your choice: """
hosts = []
host = namedtuple('host',('ip','hostname','id'))
while True:
    choice = input(menu)
    if choice == '1':
        print('add host: '.center(50,'*'))
        ip = input('ip: ')
        hostname = input("hostname: ")
        id = input('id(eg:alibaba,huawei,xiaomi..):')
        host1 = host(ip,hostname,id)
        hosts.append(host1)
        print(f"add{id}is ok!.IP is {ip}")
    elif choice == '2':
        print('search host: '.center(50,'*'))
        search_hostname = input('hostname: ')
        for host in hosts:
            if search_hostname in host.hostname:
                print(f"{host.id}\t{host.ip}\t\t{host.hostname}")
                break
        else:
            print(f"not found hostname: {search_hostname}")
            print(f"{hostname.ip}\t{hostname.hostname}\t{hostname.id}")
    elif choice == '3':
        print('deleted host: '.center(50,'*'))
        delete_id = input('input id: ')
        for host in hosts:
            if host.id == delete_id:
                hosts.remove(host)
                print(f"delete vn host {host.hostname} sucess!!")
                break
        else:
           print(f"not found : {delete_hostname}")
    elif choice == '4':
        print('list all: '.center(50,'*'))
        print("IP\t\t\thostname\tid")
        count = 0
        for host in hosts:
            count += 1
            print(f"{host.ip}\t{host.hostname}\t{host.id}")
        print('sum is: ', count)
    elif choice == '5':
       print("系统正在退出，欢迎下次使用......")
        exit()
    else:
        print("请输入正确的选项")

操作如下：
输入1添加信息！

输入2查询信息！

输入4列出信息！

输入3删除信息！

删除之后，再输入4查询信息，没有数据！

输入5退出系统！！

重点：深拷贝，浅拷贝

思维图：
浅拷贝对应的关系：

深拷贝对应如下：

对于深拷贝和浅拷贝的区别：
浅拷贝： 对另外一个变量的内存地址的拷贝，这两个变量指向同一个内存地址的变量值。(li.copy(), copy.copy())如上图！
同时公用一个值；这两个变量的内存地址一样；对其中一个变量的值改变，另外一个变量的值也会改变；

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

深拷贝的方式如下图：、

值的引用：

对于深浅拷贝：

浅拷贝：

n1 = [1,2,3]
n2 = n1.copy()
print(id(n1),id(n2))
n1.append(4)
print(n2)

1。 和前面值的引用不同：n2 = n1后，n1的改变，也会让n2改变！
2。但是n2 =n1.copy()拷贝后，n1的改变不会使得n2改变！！

结果如下：
深拷贝：

为什么需要深拷贝?

如果列表的元素包含可变数据类型, 一定要使用深拷贝！！

那么什么是可变类型：

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

例如：

n1 = [1,2,3,[1,2]]
n2 =n1.copy()
print(id(n1),id(n2))
print(id(n1[-1]),id(n2[-1]))
n1[-1].append(4)
print(n2)

结果如下：
浅拷贝：

判断的最佳方式：

深拷贝和浅拷贝最根本的区别在于是否真正获取一个对象的复制实体，而不是引用。
假设B复制了A，修改A的时候，看B是否发生变化：
如果B跟着也变了，说明是浅拷贝，拿人手短！（修改堆内存中的同一个值）
如果B没有改变，说明是深拷贝，自食其力！（修改堆内存中的不同的值）

那么如何实现深拷贝呢！

import copy
n1 = [1, 2,3， [1, 2]]
n2 = copy.deepcopy(n1)
n1和n2的内存地址:拷贝！
print(id(n1), id(n2))
n1[-1]和n2[-1]的内存地址:
print(id(n1[-1]), id(n2[-1]))
n1[-1].append(4) # n1 = [1, 2, [1, 2, 4]]
print(n2)

结果如下：
说明深拷贝也将列表里面的列表拷贝了！
所以再查看id的最后一位时，id不同！