1690_Python中的复数数据类型

news2024/11/16 1:18:08

全部学习汇总：GreyZhang/python_basic: My learning notes about python. (github.com)

之前总结的知识中设计的数据类型有整形、浮点、字符串等，这些类型表示的都是一个单独的独立数据对象。在Python有也有表示复数改变的数据类型，也就是下面将要总结整理的袁术、列表以及字典。

元组

元组的语法表达方式是把一系列的数据对象放到小括号里，用逗号分开。在IDLE环境中做相应的演示如下：

>>> t1 = (1,2,1.8,2.0,'a','bcd')

>>> t1

(1, 2, 1.8, 2.0, 'a', 'bcd')

其中，元组的数据成员可以是整形、浮点、字符串等。另外，元组的数据成员的数据类型也可以使元组。例如：

>>> t2 = (t1,123)

>>> t2

((1, 2, 1.8, 2.0, 'a', 'bcd'), 123)

需要注意的式，t1是作为一个整体成为了t2的一个成员而不是，每个t1的成员都是t2的组成成员。

另外，需要注意的是单元素的元组定义的时候需要加上一个逗号分隔符，否则定义的其实是一个单数的数据类型。如下：

>>> t_single = (1)

>>> type(t_single)

>>> t_single = (1,)

>>> type(t_single)

>>> t_single

(1,)

从上面的运行结果可以看出，(1)构造的仅仅是一个整形的数据。

下面再看一下元组的加法，两个元组可以相加构造出一个新的元组对象。例如，接着上面的操作，利用t1以及t_single来构造一个新的元组t3，利用t1以及t2构造新的元组t4：

>>> t3 = t1 + t_single

>>> t4 = t1 + t2

>>> t3

(1, 2, 1.8, 2.0, 'a', 'bcd', 1)

>>> t4

(1, 2, 1.8, 2.0, 'a', 'bcd', (1, 2, 1.8, 2.0, 'a', 'bcd'), 123)

元组元素的遍历

可以使用for循环去遍历元组中的每一个元素，例如设计如下程序：

在IDLE中load执行的结果：

>>> ================================ RESTART ================================

>>>

>>> WalkTuple(t1)

1.8

2.0

bcd

(1, 2, 1.8, 2.0, 'a', 'bcd')

123

元组元素的访问与切片：

如同字符串，元组也支持索引访问以及切片操作。在IDLE环境中进行相关演示如下：

>>> t1 = (1,3,5,7,9)

>>> t1[3]

>>> t1[:4]

(1, 3, 5, 7)

>>> t1[0:3]

(1, 3, 5)

需要注意的是元组是不可以修改的。当尝试修改元组中的元素时会报错：

>>> t1[3] = 8

Traceback (most recent call last):

File "<pyshell#21>", line 1, in <module>

t1[3] = 8

TypeError: 'tuple' object does not support item assignment

元组的使用（寻找公约数）：

设计代码如下：

在IDLE环境中load执行结果：

>>> ================================ RESTART ================================

>>>

>>> Divisors(20,100)

(1, 2, 4, 5, 10, 20)

>>> Divisors(6,12)

(1, 2, 3, 6)

列表

列表在形式上与元组有一定的相似性，但是在单元素定义以及表现形式上有一定的差异。同时，列表是可以修改的。

列表在语法形式上，使用的式方括号括起它的每个元素。而在单个元素的列表定义时，不用担心会跟单数的数据类型发生混淆，因此不用像元组一样增加一个逗号。在IDLE环境中示范如下：

>>> l1 = [1]

>>> l1

[1]

列表的每个元素都可以通过索引的方式访问以及修改，同时也支持切片。在IDLE环境中示范如下：

>>> L2 = [1,2,3,4,'abc','def']

>>> L2

[1, 2, 3, 4, 'abc', 'def']

>>> L2[3]

>>> L2[3] = 'abcd'

>>> L2

[1, 2, 3, 'abcd', 'abc', 'def']

>>> L2[:3]

[1, 2, 3]

>>> L2[0:4]

[1, 2, 3, 'abcd']

关于列表的可变性，可以通过一个更加形象的例子来说明：

>>> L3 = ['abc','def']

>>> L4 = [1,2,3]

>>> L5 = [L3,L4]

>>> L6 = [['abc','def'],[1,2,3]]

>>> L5

[['abc', 'def'], [1, 2, 3]]

>>> L6

[['abc', 'def'], [1, 2, 3]]

>>> L3.append(12345)

>>> L5

[['abc', 'def', 12345], [1, 2, 3]]

>>> L6

[['abc', 'def'], [1, 2, 3]]

通过以上例子可以更好地看出列表的可变性。尽管第一次构造后，L5与L6在IDLE中输出的信息是一致的，但是两者并不相同。由于L5是对两个列表L3，L4的引用，因此当L3发生变化时，L5随之变化而L6并不会有任何改变。这有时候会在程序设计时给我们带来很多麻烦，当然，也会带来很多好处。如果我们不期望发生一个被引用列表变化时影响到我们引用它的列表，那我们设计程序的时候最好采用列表拷贝的方式。如下：

>>> L1 = [1,2,3]

>>> L2 = [4,5,6]

>>> L3 = [L1[:],L2[:]]

>>> L4 = [L1,L2]

>>> L1.remove(3)

>>> L3

[[1, 2, 3], [4, 5, 6]]

>>> L4

[[1, 2], [4, 5, 6]]

以上示范中，L3的构造采用了列表的拷贝而L4的构造则是采用了引用。当L1发生变化时，拷贝不受影响但是引用随之变化。

列表元素的增加和删除：

上面的例子中，分别用到了append()以及remove()的方法，这两个方法分别是列表增加以及删除元素的内置方法。