Python元组-操作-拷贝
Python的元组与列表类似，不同之处在于元组的元素不能修改。元组中的元素也不能被删除，但可以删除整个元组
元组使用小括号，列表使用方括号。
元组创建，只需要在括号中添加元素，并使用逗号隔开即可。
1.元组的定义
[笛卡尔积]中每一个素（d1，d2，…，dn），叫作一个n元组（n-tuple）或简称元组。当关系是一张表，二维表中的行表中的每行(即中的每条记录)就是一个元组，每列就是一个属性。在二维表里，元组也称为记录。
元组是一系列不可变的Python对象。元组是一种序列，就像列表一样。元组和列表之间的主要区别是元组不能像列表那样改变元素的值，可以简单地理解为“只读列表”。 元组使用小括号 - ()，而列表使用方括号 - [] 。
列表通常用来存储相同类型的数据；而元组在实际开发中，通常用来存储不同类型的数据。
- .是否可以动态改变元素 不可变：TypeError: ‘tuple’ object does not support item assignment
- 元组(Tuple)与列表相似，不同之处在于元组的元素不能修改；
- 元组表示多个元素组成的序列；用于存储一串信息，不同数据之间用逗号隔开；
- 元组的索引从0开始；
元组的定义语法
变量名 = (数据1， 数据2， 数据3，...)
eg:
uesr_tuple = ("zhangsan", "lisi", "xiaoming")
元组中各元素之间用逗号隔开。元组不支持修改或删除其所包含的元素。如果要修改，则可以使用list函数把它转化成列表，然后在列表上进行修改创建元组的方法有三种：
1、使用括弧“0”来创建，例如，a=(1，2，3)；
2、使用逗号来创建，例如，b=2，4；
3、使用 tuple0函数把其他种类的序列转化为元组，例如，c= tuple(“Good!”)。 [3]
2、元组的创建
创建一个元组只需使用逗号分隔值放入小括号的一个序列。 或者，也可以将这些逗号分隔值放在括号之间。 例如
tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
tup3 = "a", "b", "c", "d"
Python
空的元组写成两个不含任何东西的小括号 -
tup1 = ();
Python
要编写一个包含单个值的元组，必须包含一个逗号，即使只有一个值(这是规范写法) -
t1 = (50,)
## 也可以这样写
t2 = (50)
Python
3、访问元组中的值
要访问元组中的值，请使用方括号进行指定索引切片或索引，以获取该索引处的值。 例如 -
#!/usr/bin/python3
tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
print ("tup1[0]: ", tup1[0])
print ("tup2[1:5]: ", tup2[1:5])
Shell
当执行上述代码时，会产生以下结果 -
tup1[0]: physics
tup2[1:5]: (2, 3, 4, 5)
Python
# 定义空元组；
empty_tuple = ()
type(empty_tuple) # tuple
# 定义一个单元素元组；
# 如果元组中只有一个数据，要在那一个数据后面加逗号，否则该元组变量会被python解释器认为是括号内数据的数据类型；
single_tuple = (5)
type(single_tuple) # int
single_tuple = (5,)
type(single_tuple) # tuple
4、更新元组
元组是不可变的，这意味着我们无法更新或更改元组元素的值。 但是可以使用现有元组的一部分来创建新的元组，如下例所示：
#!/usr/bin/python3
tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
# Following action is not valid for tuples
# tup1[0] = 100;
# So let's create a new tuple as follows
tup3 = tup1 + tup2
print (tup3)
Python
当执行上述代码时，会产生以下结果 -
(12, 34.56, 'abc', 'xyz')
Shell
5、删除元组元素
删除单个元组元素是不可能的。 当然，将不必要的元素放在另一个元组中也没有什么错。
要显式删除整个元组，只需使用del语句。 例如 -
#!/usr/bin/python3
tup = ('physics', 'chemistry', 1997, 2000);
print (tup)
del tup;
print "After deleting tup : "
print (tup)
Python
执行上面代码，将产生以下结果 -
注 - 引发异常。这是因为在del tup之后，元组不再存在。
('physics', 'chemistry', 1997, 2000)
After deleting tup :
Traceback (most recent call last):
File "test.py", line 9, in <module>
print tup;
NameError: name 'tup' is not defined
Shell
6、基本元组操作
元组响应+和*运算符很像字符串; 它们执行连接和重复操作，但结果是一个新的元组，而不是一个字符串。
事实上，元组中类似字符串操作和使用的所有常规序列操作都有作了讲解。
print(len(t))
print(t.count(1))
print(t.index(1))
| Python表达式 |
结果 |
描述 |
| len((1, 2, 3)) |
3 |
长度 |
| (1, 2, 3) + (4, 5, 6) |
(1, 2, 3, 4, 5, 6) |
连接操作 |
| (‘Hi!’,) * 4 |
(‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’) |
重复 |
| 3 in (1, 2, 3) |
True |
成员关系 |
| for x in (1,2,3) : print (x, end = ’ ') |
1 2 3 |
迭代 |
7.索引，切片和矩阵
由于元组是序列，索引和切片的工作方式与列表的工作方式相同，假设输入以下值：
T=('c', 'Java', 'Python')
Python
| Python表达式 |
结果 |
| T[2] |
‘Python’ |
| T[-2] |
‘Java’ |
| T[1:] |
(‘Java’, ‘Python’) |
8、元组 循环遍历
元组遍历就是 从头到尾 依次从元组中取数据；
每次循环都将 从元组中顺序的读取出来的数据放在临时变量中，然后执行相同的操作。
使用for进行迭代遍历。
user_tuple = ["zhangsan", 20, 181]
for i in user_tuple:
# 因为通常元组的元素数据类型不同，所以一般很少遍历元组做操作，
# 除非确定元组中每一个元素的数据类型
print(i)
在Python中，可以使用for循环遍历所有非数字型类型的变量：列表，元组，字典以及字符串；
9、 元组应用场景
- 函数的参数和返回值；一个函数可以接收任意多个参数，或者一次返回多个数据。
- 格式字符串，格式化字符串后面的()本质上就是一个元组。
- 保护数据安全，列表不能被修改。
10、元组和格式化字符串
格式化后面的括号和内容，本质上就是元组；我们可以先定义一个元组，然后在格式化后面%元组，一样能输出；
同时，我们甚至可以将print括号里面的函数拿出来，定义成一个变量，再用print输出。
# 四者的输出结果都一样
# zhangsan 的年龄是 20， 身高是 181
name = "zhangsan"
age = 20
height = 181
print("%s 的年龄是 %d， 身高是 %d" % (name, age, height))
userinfo = ("zhangsan", 20, 181)
print("%s 的年龄是 %d， 身高是 %d" % (userinfo[0], userinfo[1], userinfo[2]))
# 也可以这样玩
print("%s 的年龄是 %d， 身高是 %d" % userinfo)
# 还可以这样玩
info = "%s 的年龄是 %d， 身高是 %d" % userinfo
print(info)
11、元组和列表之间的转换
元组转列表：list()
列表转元组：tuple()
num_list = [2,1,4,3]
type(num_list) # list
num_tuple = tuple(num_list)
type(num_tuple) # tuple
num_list2 = list(num_tuple)
type(num_list2) # list
12.Python元组内置函数
| 序号 |
函数 |
描述 |
| 1 |
cmp(tuple1, tuple2) |
#比较两个元组元素。 |
| 2 |
len(tuple) |
#计算元组元素个数。 |
| 3 |
max(tuple) |
#返回元组中元素最大值。 |
| 4 |
min(tuple) |
#返回元组中元素最小值。 |
| 5 |
tuple(seq) |
#将列表转换为元组。 |
13.Python元组操作
1、简介
我在之前的博客《Python列表（“数组”）操作》中讲解了Python列表的一些主要操作方法，由于元组与列表有许多相同之处，所以今天就把元组的操作也讲解一下。
元组与列表最大的区别就在于你可以任意修改列表中的元素，可以任意插入或者删除一个元素，而在元组中这些都是不可以的，但是我们有其他的方法来实现这些，具体的操作方法会在后文中讲解。
注：本博客所有代码均在IDLE下完成。
2、元组操作简介
（1）创建元组
创建元组时大部分使用的是小括号，具体操作如下：
tuple = (1,2,3,4,'罗思洋')
tuple
(1, 2, 3, 4, '罗思洋')
和列表一样，元组中可以包含整形、字符串、浮点型数据，还可以包含另一个元组。
（2）从元组中获取元素
由于元组中的元素不能随意插入或更改，所以插入或更改的方法在后文中讲解，我们先来讲解简单一点的元素获取方法（其方法与列表中获取元素方法相同）。
1）从元组中获取元素可以一次获取一个或多个，获取一个的操作如下：
tuple = (1,2,3,4,'罗思洋')
tuple[0]
1
2）获取多个的方法如下：
tuple = (1,2,3,4,'罗思洋')
tuple[0:3]
(1, 2, 3)
tuple[0:3]中0为开始位置，3为结束位置；
3）访问元组中元组的方法如下：
tuple = (1,2,(3,4),'罗思洋')
tuple[2][1]
4
tuple[2][1]2指第一层元组的元素，1指第二层元组中的元素。
（3）元组反转
1）其反转方法和列表的第一种方法一样，通过分片操作即可，分片操作中当步长为-1就可以实现列表反转，操作如下：
tuple = (1,2,3,4)
tuple[::-1]
(4, 3, 2, 1)
2）那么我们可不可以使用reverse（）方法呢，试试不就知道了吗？操作如下：
tuple = (1,2,3,4)
tuple.reverse()
Traceback (most recent call last):
File "<pyshell#13>", line 1, in <module>
tuple.reverse()
AttributeError: 'tuple' object has no attribute 'reverse'
由此可见使用reverse（）方法宣告失败，提示说元组中没有reverse这种属性，所以以后要实现元组反转我们就使用分片的方法吧。
（4）元组的重复
元组重复的操作与列表类似，具体如下：
tuple = (123,)
tuple*3
(123, 123, 123)
tuple *= 3
tuple
(123, 123, 123)
需要注意的是当创建的元组只包含一个元素时，里面的逗号是必不可少的，有逗号才可以证明我们创建的是元组，证明如下（我们使用type方法查看类型）：
temp = (123)
type(temp)
<class 'int'>
temp = (123,)
type(temp)
<class 'tuple'>
当没有逗号时我们创建的是int型，而有逗号时我们创建的才是元组，由此可见逗号才是元组的关键！
（5）元素是否存在于元组中的判断
1）元组中元素判断的方法与列表一样，in的操作如下：
tuple = (1,2,3,4)
1 in tuple
True
5 in tuple
False
not in的操作如下：
tuple = (1,2,3,4)
1 not in tuple
False
5 not in tuple
True
2）对于二层元组中元素的判断与列表一样，操作如下：
tuple = (1,(2,3),4)
2 in tuple[1]
True
3 not in tuple[1]
False
（6）向元组中添加元素
讲了这么多，重头戏终于来了，既然不可以在元组中随意插入元素，那么我们就使用构造新元组的方法来解决这个问题，操作如下：
tuple = ('罗','思','洋')
tuple = tuple[0:2]+('lsy',)+tuple[2:]
tuple
('罗', '思', 'lsy', '洋')
这样我们就可以向元组中添加一个元素，并且添加的位置还可以自己来定，其实原理是使用分片的方法将元组拆分为两部分，再使用连接操作符+合并为一个新元组，最后将tuple名指向新元组，需要注意的是被添加元素(‘lsy’,)的逗号不可缺少！切记切记！！！
（7）从元组中删除元素
1）既然讲了插入的方法，那么删除的方法自然是必不可少的，删除的原理和插入原理类似，都需要采用列表分片的方法，然后使用连接操作符+合并一个新元组，操作如下：
tuple = ('罗','思','洋')
tuple = tuple[:1] + tuple[2:]
tuple
('罗', '洋')
2）如果需要删除整个元组，我们可以使用del语句，操作如下：
tuple1 = (1,2,3,4)
del tuple1
tuple1
Traceback (most recent call last):
File "<pyshell#38>", line 1, in <module>
tuple1
NameError: name 'tuple1' is not defined
元组拼接的方法在插入和删除中我们都已经有所涉及，自己总结即可。
元组中是不可以使用sort（）方法和reverse（）方法来实现升序排序的。
3、总结
从上面的操作中可以看出Python元组的许多操作方法和列表是一样的，由于元组不可以随意的插入和删除，所以我们需要使用分片的方法来实现这两个功能，关于元组大家还可以通过菜鸟教程进行学习，但是我认为我写的更加详细，并且将主要操作都进行了验证。
Python深浅复制
Python对对象进行拷贝时有三种方式：复制、浅拷贝和深拷贝。三种复制的实现逻辑都各不相同，使用不同的拷贝方式，会产生不同的结果。区别好这三种方式，在编程的时候可以提高效率，降低错误率。
1.复制
复制就是使用“=”。使用“=”的时候，实际上是传递的是对象的引用，当对象发生修改的时候，复制体也会发生同等的改变，无论何种改变。
2.浅拷贝
*浅拷贝，字面理解，就是只拷贝浅层的东西。他只会拷贝目标对象，目标的子对象（深层东西）不进行拷贝。
浅拷贝的使用方法：
copy.copy(object)
例如：
import copy
a = [1,[2]]
print('目标对象原件：',a)
b = copy.copy(a)
a.append('3') #目标对象进行浅层改变
print('目标对象改变：',a)
print('复制体的结果：',b)
>>>
目标对象原件： [1, [2]]
目标对象改变： [1, [2], '3']
复制体的结果： [1, [2]]
import copy
a = [1,[2]]
print('目标对象原件：',a)
b = copy.copy(a)
a[1].append('3') #目标对象的子对象进行改变，即深层改变
print('目标对象改变：',a)
print('复制体的结果：',b)
目标对象原件： [1, [2]]
目标对象改变： [1, [2, '3']]
复制体的结果： [1, [2, '3']]
3.深拷贝
深拷贝，字面理解，就是深层次的拷贝。不仅拷贝了目标对象，也拷贝了目标对象的子对象。
- 当无论对目标对象或者目标对象的子对象进行改变，复制体都不会改变！
深拷贝的使用方法：
copy.deepcopy(object)
例如：
import copy
a = [1,[2]]
print('目标对象原件：',a)
b = copy.deepcopy(a)
a[1].append('3') #目标对象以及其子对象进行改变，即深层改变+浅层改变
a.append('3')
print('目标对象改变：',a)
print('复制体的结果：',b)
目标对象原件： [1, [2]]
目标对象改变： [1, [2, '3'], '3']
复制体的结果： [1, [2]]
Python排序
#从小到大
t = (9,6,5,4,2,8,4,)
t = sorted(t)
print(t)
#从大到小
t1 = (9,6,5,4,2,8,4,)
t = sorted(t1)
print(sorted(t1,reverse=True))
