【python基础】内置数据结构—列表和元组

一、列表的基本特性

1、连接操作符

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

2、成员操作符

print(1 in [1,2,3])
print(0 in ['a',False,[1,2]])
#结果
True
True                             $因为这里bool值的False=0，Ture=1

3 、索引

li = [1,2,3,[1,'b',3]]
print(li[0])
print(li[-1])
print(li[-1][0])
#结果
1
[1, 'b', 3]
1

4、切片

li = ['172','25','254','100']
print(li[:2])
print(li[1:])
print(li[::-1])
#结果
['172', '25']
['25', '254', '100']
['100', '254', '25', '172']

5、练习题
将列表li = [‘172’,‘25’,‘254’,‘100’]输出为100-254-25

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

#方法2
li = ['172','25','254','100']        
print('-'.join(li[3:0:-1]))         $这里是倒序，可以看作是（0：3],然后再倒序

6、 for 循环

names = ["粉丝","粉条","粉带"]
for name in names:
    print(f'{name}')
#结果
粉丝
粉条
粉带

二、列表的常用方法

(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]

3、列表中间追加

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

4、一次追加多个

li= [1,2,3]
li.extend([4,5,6])
print(li)
#结果
[1, 2, 'cat', 3]

(2)、修改

1、修改,通过索引或者切片
方法一通过索引

li= [1,2,3]
li[0]='hello'
li[1]='westos'
print(li)
#结果
['hello', 'westos', 3]

方法二通过切片

li= [1,2,3]
li[:2]=['cat','westos']
print(li)
# 结果
['cat', 'westos', 3]

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

li=[1,2,2,2,3,4]
print(li.count(1))         $统计次数
print(li.index(3))         $统计索引的地址
#结果
1
4

(3)、删除

1、根据索引删除
pop代表探弹出的意思

li = [1,2,3]
print(li.pop(1))
print(li)
# 结果
2
[1, 3]

2、根据value值删除

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

3、全部清空

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

4、反转

li = [1,2,3,4]
li.reverse()
print(li)
#结果
[4, 3, 2, 1]

5，排序

li = [1,3,7,4]
li.sort()
print(li)
#结果
[1, 3, 4, 7]

三、元组

(1)、元组的创立

1、元组的创立
空元组

t1=()
print(t1,type(t1))
#结果
() <class 'tuple'>

注意：单个元素不算元组

t2=(1)
print(t2,type(t2))
#结果
1 <class 'int'>

元组里面可以有多种类型

t3=(1,2,True,[1,2,3,4])
print(t3,type(t3))
#结果
(1, 2, True, [1, 2, 3, 4]) <class 'tuple'>

(2)、元组的特性

print((1,2,3)+(3,))       拼接
print((1,2,3)*3)          重复
print(3 in (1,2,3))       判断
#结果
(1, 2, 3, 3)
(1, 2, 3, 1, 2, 3, 1, 2, 3)
True

t=(1,2,3)
print(t[0])         索引
print(t[-1])
print(t[::-1])      反转
print(t[1:3])       分片

#结果
1
3
(3, 2, 1)
(2, 3)

(3)、常用方法

元素是不可变数据

(4)、查看

t = (1,23,3,424,2,2,2,3)
print(t.count(2))
print(t.index(2))
#结果
3
4

四、命名元组

from collections import namedtuple                        从 collections工具箱里面导入其中的namedtuple工具
User = namedtuple('User',('name','age','city'))           使用namedtuple创建命名元组对象User
User1 = User('westos','18','xian')
print(User1)
print(User1.name)
print(User1.age)
print(User1.city)
#结果
User(name='westos', age='18', city='xian')
westos
18
xian

五、判断

python语言：
==：是判断类型和值是否相等
is：查看地址是否相同

print(1 == "1")
#结果
False          因为类型不同

li = [1,2,3]
li1= li.copy()
print(li==li1)
#结果
Ture

li = [1,2,3]
li1= li.copy()
print(li==li1)
print(li is li1)
print(id(li),id(li1))
#结果
False                                   因为地址不同
1956102874048 1956102814272

五、深拷贝和浅拷贝

1、介绍

(1) 赋值：创建了对象的一个新的引用，修改其中一个变量都会影响到另一个。
(2) 浅拷贝：对另外一个变量的内存地址的拷贝，这两个变量指向同一个内存地址的变量值
(3) 深拷贝：一个变量对另外一个变量的值拷贝。

2、值的引用（赋值）
因为指向相同的存贮地址，所有相同

nums1 = [1,2,3]
nums2 = nums1         同一个地址
nums1.append(4)
print(nums2)
#结果
[1, 2, 3, 4]

2、可变数据类型与不可变数据类型
可变数据类型：list
不可变数据类型;str,tuple,namedtuple

3、浅拷贝
拷贝出来的存放在不同的地址
.copy和[:]都是浅拷贝

n1 = [1,2,3]
n2 = n1.copy()
print(id(n1),id(n2))
n1.append(4)
print(n2)
#结果
1800894875712 1800894754048
[1, 2, 3]

4、浅拷贝的补充
注意：如果有列表嵌套列表，如果要拷贝的时，一定要用深拷贝

n1 = [1,2,[1，2]]
n2 = n1.copy()                              n2拷贝n1，但是n2也会指向n1里列表里面的地址，
n1[-1].append(4)
print(n2)
print(id(n1),id(n2))
print(id(n1[-1]),id(n2[-1]))
#结果
[1, 2, [1,2，4]]                          n2的结论也回随着改变
1800894881024 1800894875712               因为拷贝出来的，所有存储地址不同
1800894746432 1800894746432               由于列表是可变的，它回

5、深拷贝
当列表嵌套时

import copy
n1 = [1,2,[1,2]]
n2 = copy.deepcopy(n1)         深拷贝会将变量地址也拷贝出来一份
n1[-1].append(4)
print(n2)
print(id(n1),id(n2))
print(id(n1[-1]),id(n2[-1]))
#结果
[1, 2, [1, 2]]
2198068115904 2198067702912
2198068318336 2198068107968