educoder平台课-Python程序设计-6.序列类型

6.1 元组

元组：组合数据类型之一，使用一对圆括号“( )”来存放一组数据，数据项之间用逗号“,”隔开。
元组是序列类型数据的一种，和列表非常相像，可以用来存储一组数据。
输出时，元组都要由圆括号标注，这样才能正确地解释嵌套元组。输入时，圆括号可有可无。

元组和列表最大的区别在于：列表是可变数据类型（mutable），而元组是不可变数据类型（immutable）。 元组数据产生后，其内部元素无法增加、删除和修改，可近似将元组看作为“常量列表”。元组中的每个数据项称为一个元素，各元素类型可以相同，也可以不同，也可以将列表或元组作为元组的元素。

如下例所示：创建的三个元组中，tupa中有5个整型数据，tupb中有4个字符串型数据，tupc中有4个元素，其中包括2个字符串型数据、1个整型数据和1个列表。

元组是序列类型，因此支持使用切片的方法访问元组中的元素，但不能使用切片的方法修改、增加或删除元组中的元素。

元组切片得到的是一个新的元组，其中的数据也不能被修改和删除。

使用del命令可以删除整个元组，但不能用del删除元组中的元素。

Python 中有一些针对元组的优化策略，对元组的访问和处理速度远快于列表。当一组数据仅被用于遍历或类似操作，而不进行任何修改操作时，一般建议应用处理速度更快的元组而不用列表。 当程序运行需要的传递参数时，可以使用元组，以避免传递的参数在函数中被修改。

元组的创建有以下几种方法：

1. 用一对空的圆括号“()”或无参数的tuple()函数创建一个空元组。例如：()和tuple()
2. 只有一个单独元素的元组可以通过在元素后加逗号来构建，例如：a, 或 (a,)
3. 用逗号分隔的多个元素，例如：a,b,c 或 (a,b,c)
4. 用内置的tuple()函数，参数为空或可迭代对象，例如：tuple() 或 tuple(iterable)。

当元组的元素包含列表等可变元素时，情况有些特殊，虽然不可直接改变元组元素的值，但可以修改作为元素的列表的值。

因为元组数据是不可变类型的，使用dir(tuple)或dir(元组名)可以看到，除“魔法方法”外，元组的内置方法非常少，只有两个：count和index，其用法和含义与列表完全相同。

区别一个对象是可变类型还是不可变类型，可以通过dir 函数查看其是否有“__hash__”魔法方法，或者说是否可以使用Python内置hash方法对其求“哈希值”。如下示例：

由上例可以看到，元组数据是可哈希的，为不可变数据类型；而列表数据是不可哈希的，为可变数据类型。

在Python中，元组（tuple）在某些情况下比列表（list）有性能优势，但差异可能不显著。

1. 不可变性

元组是不可变的，而列表是可变的。这意味着元组的内容一旦创建就不能改变，因此Python可以对其进行优化，保证其在内存中的存储是连续的。这使得访问元组元素的速度比访问列表元素快。 列表是可变的，需要考虑插入、删除和修改操作，因此在内存中可能不连续存储。 

2. 内存效率 

由于元组的不可变性，Python可以更高效地管理和存储元组。这主要体现在以下几个方面：

内存分配：元组在创建时一次性分配所需内存，而列表可能需要动态调整其大小，这会增加额外的开销。 内存占用：元组的内存占用通常小于列表，特别是小规模数据时。 

3. 哈希值和缓存 

元组是不可变对象，可以被用作字典的键或存储在集合中，这要求它们是可哈希的。这些特性允许Python在某些情况下缓存元组，提高访问速度。

4. 操作优化

由于元组的不可变性，Python解释器可以对元组进行更多的优化。例如：

常量折叠：编译时可以将一些操作提前计算和优化。 缓存和引用：在函数调用中使用元组来传递固定数量的参数比使用列表更高效，因为不需要重新分配内存。

虽然元组的访问和处理速度确实通常比列表快，但这主要是由于其不可变性和由此带来的内存和优化优势。在需要频繁修改的数据结构中，列表仍然是更合适的选择。元组适用于需要不可变性和轻量级存储的场景。

lsa = [1, 2, 3, 4, 5]
lsb = ['湖北', '河北', '山东', '山西']
lsc = ['Susan', 'Female', 19, [85, 74, 99, 89, 92]]
print(lsa, lsb, lsc, sep = '\n')

Ls = [3,4,5,6,7]
print(Ls)
print(list())             # list()函数的参数为空时，产生一个空列表，输出结果为：[]
L1= list((1,2,3,4,5))     # 将元组(1,2,3,4,5) 转为列表
print(L1)                 # 输出结果为：[1, 2, 3, 4, 5]
L2 = list(range(5))       # 将range对象转为列表
print(L2)                 # 输出结果为：[0, 1, 2, 3, 4]
L3 = list('12345')        # 将字符串转为列表
print(L3)                 # 输出结果为：['1', '2', '3', '4', '5']
s = '我,是,中,国,人'      # 这是一个字符串
L = s.split(',')          # 根据逗号（,）对字符串s进行切分并转为列表
print(L)                  # 输出结果为：['我', '是', '中', '国', '人']

6.4 列表的更新

赋值语句是改变对象值的最简单的方法，在列表中，也可以通过索引赋值改变列表中指定序号元素值。

1.索引赋值的方法为：

ls[i] = a

其中i 为列表中的元素序号，要求i为整数且在列表序号范围内（-len(ls) <= i < len(ls)），当i值超出列表序号范围时，抛出错误：IndexError: list assignment index out of range。 a 为新值，其值可以与列表中原有元素的数据类型相同，也可以是不同的数据类型，甚至可以是一个列表或元组。

ls = [88,56,95,46,100,77]  # 通过赋值创建列表L
ls[2] = 66
print(ls)                  # 序号为2的元素被替换为66，输出：[88, 56, 66, 46, 100, 77]ls[3] = 'pass'             # 序号为3的元素赋字符串类型新值
print(ls)                  # 序号为3的元素被替换，输出：[88, 56, 66, 'pass', 100, 77]ls[5] = ['True','False']   # 序号为5的元素赋列表类型新值
print(ls)                  # 序号为5的元素被替换， [88, 56, 66, 'pass', 100, ['True', 'False']]

除了按索引赋值以外，还可以用切片赋值的方法更新列表中的数据，切片赋值要求新值也为列表。
其操作相当于将原列表中切片中元素删除，同时用新的列表中的元素代替切片的位置。
当切片连续时（如ls[i:j]），此时新列表长度不限，可为空列表、与切片等长列表或超出切片长度的列表。

当切片不连续时（如，ls[i:j:step]），要求新列表与切片元素数量相等，再按顺序一一替换。

ls = [88,56,95,46,100,77]  # 通过赋值创建列表ls
print(ls)                  # 输出原列表中元素[88, 56, 95, 46, 100, 77]ls[1:3] =[33,44]           # 序号为1和2的元素被替换为新列表中的33和44
print(ls)                  # 输出：[88, 33, 44, 46, 100, 77]ls[1:3] = []               # 序号为1和2的元素被替换为新列表中空值
print(ls)                  # 输出[88, 46, 100, 77]，列表长度减少2ls = [88,56,95,46,100,77]  # 通过赋值创建列表ls
ls[1:3] =[33,44,55,66]     # 序号为1和2的元素被替换为33、44、55、66
print(ls)                  # 输出[88, 33, 44, 55, 66, 46, 100, 77]，列表长度增加2

ls = [88, 56, 95, 46, 100, 77]  # 通过赋值创建列表ls
print(ls[0:6:2])                # 切片返回结果，3个元素，输出[88, 95, 100]ls[0:6:2] = [10, 20, 30]        # 将切片返回的3个元素用新列表中对应位置的元素替代
print(ls)                       # 输出[10, 56, 20, 46, 30, 77]ls = [88, 56, 95, 46, 100, 77]  # 通过赋值创建列表ls
ls[0:6:2] = ['Python', 'C语言', 'VB']  # 新列表元素的数据可为任意类型
print(ls)                       # 输出['Python', 56, 'C语言', 46, 'VB', 77]

如果输出id(ls)查看每次操作前后列表ls的id，可以发现，当列表长度没有增加且新加入的数据类型与原数据类型相同时，更新前后列表的id没有发生变化，也就是说，此时的更新是原地操作。而当更新列表后长度增加的操作，或更新后新加入的数据的类型与原数据类型不同时，更新前后列表的id会发生变化。也就是说，此时的更新是重新创建了新的列表，并将原列表和更新的数据一起放入新列表。
可以这样理解列表被创建后，就不能再往列表中增加元素了，如需增加新的元素，需要将整个列表中的元素复制一遍，再添加需要增加的元素。

2.为了解决这个问题，python提供了三种方法向列表中添加元素：

append()
extend()
insert()

这三种方法都是原地操作，不影响列表在内存中的起始地址。

2.1 append()在列表末尾添加一个元素

append()方法的使用方式为：

ls.append(x)  
# ls为操作的列表名，x为增加的元素。  
# 相当于: 
a[len(a):] = [x]

ls = [88, 56, 95, 46, 100, 77]  # 通过赋值创建列表ls
ls.append(100)                  # 在原列表末尾增加新元素数字100
print(ls)                       # 输出[88, 56, 95, 46, 100, 77, 100]ls = [88, 56, 95, 46, 100, 77]  # 通过赋值创建列表ls
ls[len(ls):] = [100]            # 在原列表末尾增加新元素数字100
print(ls)                       # 输出[88, 56, 95, 46, 100, 77, 100]ls.append('python')             # 在原列表末尾增加新元素字符串'python'
print(ls)                       # 输出[88, 56, 95, 46, 100, 77, 100, 'python']

如果输出id(ls)可以发现，应用append()方法向列表中增加元素时，可以增加同类型元素，也可以增加不同类型元素，其列表的id不变，说明只是修改了原列表而没有重建列表。

用append()向列表末尾增加元素非常快，此时，列表的作用相当于栈（stack）

2.2 extend()是将另一个可迭代对象转为列表并追加到当前列表的末尾

extend()方法的使用方式为：

ls.extend(iterable) 
# 相当于：  
ls[len(ls):] = iterable

ls = [88, 56, 95, 46, 100, 77]
L = [10, 20, 30]
ls.extend(L)  # 在原列表末尾增加新列表中的元素10,20,30
print(ls)     # 输出[88, 56, 95, 46, 100, 77, 10, 20, 30]ls = [88, 56, 95, 46, 100, 77]
L = [10, 20, 30]
ls[len(ls):] = L  # 在原列表末尾增加新列表中的元素10,20,30
print(ls)         # 输出[88, 56, 95, 46, 100, 77, 10, 20, 30]

ls = [88, 56, 95, 46, 100, 77]
ls.extend(range(5))  # 在原列表末尾增加新列表中的元素0, 1, 2, 3, 4
print(ls)     # 输出[88, 56, 95, 46, 100, 77, 0, 1, 2, 3, 4]ls = [88, 56, 95, 46, 100, 77]
ls[len(ls):] = range(5)  # 在原列表末尾增加新列表中的元素0, 1, 2, 3, 4
print(ls)         # 输出[88, 56, 95, 46, 100, 77, 0, 1, 2, 3, 4]

与ls.extend(L)功能类似的一个操作是赋值运算+=

ls = [88, 56, 95, 46, 100, 77]
L = [10, 20, 30]ls += L    # 不创建新对象，在原列表末尾增加新列表中的元素10,20,30
print(ls)  # 输出[88, 56, 95, 46, 100, 77, 10, 20, 30]

+=运算符会调用__iadd__方法，该方法的参数类型是可迭代对象(iterable)，也就是说，L的类型并不局限于列表，可以是元组、range、字符串、集合和字典等，会先将其它类型的对象转为列表类型，再附加到列表的末尾。

ls = [88, 56, 95, 46, 100, 77]
L1 = {35,65}
L2 = range(10, 30, 10)
L3 = (1, 2, 3)
L4 = "abc"ls += L1    # 不创建新对象，在原列表末尾增加集合中的元素35,65
print(ls)   # 输出[88, 56, 95, 46, 100, 77, 35, 65]
ls += L2    # 不创建新对象，在原列表末尾增加新列元素10,20
print(ls)   # 输出[88, 56, 95, 46, 100, 77, 35, 65, 10, 20]
ls += L3    # 不创建新对象，在原列表末尾增加新元组中的元素1,2,3
print(ls)   # 输出[88, 56, 95, 46, 100, 77, 35, 65, 10, 20, 1, 2, 3]
ls += L4    # 不创建新对象，在原列表末尾增加新字符串中的元素a,b,c
print(ls)   # 输出[88, 56, 95, 46, 100, 77, 35, 65, 10, 20, 1, 2, 3, 'a', 'b', 'c']

2.3 insert()是向列表中任意位置插入一个一元素，insert()方法的使用方式为：

ls.insert(i,x)
ls为操作的列表名，i为插入位置的序号，x为增加的元素。

ls.insert(0, x)    # 在列表开头插入元素ls.insert(len(ls), x)
# 等同于 
ls.append(x)

ls = [88,56,95,46,100,77]  
ls.insert(2,99)     # 在序号为2的位置插入新值99
print(ls)           # 输出[88, 56, 99, 95, 46, 100, 77]

列表底层是通过变长数组实现的。在数组头部或中间插入或删除元素，需要逐个移动插入位置之后的每个元素。这在数据量大时会消耗大量时间，效率低下。

列表适用于处理动态数据集，特别适合用于读操作远多于写操作的场景。
列表可用来实现栈操作。
列表不适合用作队列，可使用 collections.deque 来实现队列操作。

6.5 列表的删除

L = list('7319826540')  # 将字符串转为列表L
print(L)    # 输出列表元素['7', '3', '1', '9', '8', '2', '6', '5', '4', '0']L.pop()     # 移除列表中最后一个元素
print(L)    # 输出列表元素['7', '3', '1', '9', '8', '2', '6', '5', '4']s=L.pop()   # 移除列表中最后一个元素，并将移除的元素赋值给s
print(L,s)  # 输出列表元素及移除的数据['7', '3', '1', '9', '8', '2', '6', '5'] 4L.pop(3)    # 移除列表中序号为3的元素
print(L)    # 输出列表元素['7', '3', '1', '8', '2', '6', '5']s=L.pop(-3) # 移除列表中序号为3的元素，并将移除的元素赋值给s
print(L,s)  # 输出列表元素及被移除的数据['7', '3', '1', '8', '6', '5'] 2

L = list('7319826540')                                   # 将字符串转为列表L
print(L)      # 输出列表元素['7', '3', '1', '9', '8', '2', '6', '5', '4', '0']L.remove('1') # 删除列表中元素'1'（字符串）
print(L)      # 输出修改过的列表['7', '3', '9', '8', '2', '6', '5', '4', '0']

L = list('7319826540')                                   # 将字符串转为列表L
L.remove(1)    # 删除列表中元素1（整数）
print(L)       # 删除对象在列表中不存在，抛出错误ValueError: list.remove(x): x not in list

L = list('7319826540')                                   # 将字符串转为列表L
if 1 in L:L.remove(1)    # 若列表中存在整数1，则删除列表中元素1（整数）
print(L)           # 查看结果['7', '3', '1', '9', '8', '2', '6', '5', '4', '0']

L = list('7319826540')    # 将字符串转为列表L
print(L)      # 输出列表元素['7', '3', '1', '9', '8', '2', '6', '5', '4', '0']
L.clear()                 # 删除列表中全部元素
print(L)                  # 输出修改过的列表[]

L = list('7319826540')    # 将字符串转为列表L
del L[:]                  # 删除列表中全部元素
print(L)                  # 输出修改过的列表[]

L = list('7319826540')    # 将字符串转为列表L
del L                     # 删除列表对象L
print(L)                  # NameError: name 'L' is not defined

ls= list(range(5))  # 将range对象转为列表ls
print(ls)           # 输出结果为：[0, 1, 2, 3, 4]del ls[1]           # 索引，删除列表ls中序号为“1”的元素
print(ls)           # 输出结果为：[0, 2, 3, 4]del ls[1:3]         # 切片，删除列表对象ls中序号1，2的元素
print(ls)           # [0, 4]

ls= list(range(5))  # 将range对象转为列表ls
print(ls)           # 输出结果为：[0, 1, 2, 3, 4]del ls              # 删除列表对象ls
print(ls)           # 列表ls不存在了，抛出错误， NameError: name 'ls' is not defined。

L = ['73','13','9','82','6','5','04'] # 通过赋值创建列表L
print(L)            # 输出列表原始元素['73', '13', '9', '82', '6', '5', '04']
L.sort()            # 比较字符串大小，缺省升序排序
print(L)            # 输出修改过的列表['04', '13', '5', '6', '73', '82', '9']，字符串'13'< '5'
print(L.sort())     # L.sort()无返回值，输出None

ls = [88,56,95,46,100,77]         # 通过赋值方式创建列表ls
ls.sort(reverse=True)             # 比较数字大小，降序排序
print(ls)                         # 输出修改过的列表[100, 95, 88, 77, 56, 46]

L = ['app', 'Apple', 'at', 'AM']
L.sort()  # 按字符串大小排序，依序比较各字符Unicode值
print(L)  # ['AM', 'Apple', 'app', 'at']   # 默认排序规则排序L.sort(key=str.lower)  # 按转小写后排序
print(L)  # ['AM', 'app', 'Apple', 'at']  # 字符串中的字符按小写顺序排序L.sort(key=lambda x: x.lower())  # 按转小写后排序
print(L)  # ['AM', 'app', 'Apple', 'at']  # 字符串中的字符按小写顺序排序L.sort(key=len)  # 按字符串长度排序
print(L)  # ['AM', 'at', 'app', 'Apple']  # 字符串中的字符按小写顺序排序L.sort(key=lambda x: len(x))  # 按字符串长度排序
print(L)  # ['AM', 'at', 'app', 'Apple']  # 字符串中的字符按小写顺序排序

sorted(iterable, /, *, key=None, reverse=False)

L = ['app', 'Apple', 'at', 'AM']
print(sorted(L))  # ['AM', 'Apple', 'app', 'at']   默认排序规则排序
print(sorted(L, key=str.lower))  # ['AM', 'app', 'Apple', 'at']  字符串中的字符按小写顺序排序
print(sorted(L, key=lambda x: x.lower()))  # ['AM', 'app', 'Apple', 'at']  字符串中的字符按小写顺序排序
print(sorted(L, key=len))  # ['at', 'AM', 'app', 'Apple'] ,  字符串中的字符按长度排序 
print(sorted(L, key=lambda x: len(x)))  # ['at', 'AM', 'app', 'Apple']  字符串中的字符按长度排序

L = ['73','13','9','82','6','5','04']  #通过赋值创建元素为字符串的列表L
print(L)           # 输出列表原始元素['73', '13', '9', '82', '6', '5', '04']
L.reverse()        # 将列表元素逆序
print(L)           # 输出修改过的列表['04', '5', '6', '82', '9', '13', '73']ls = [88,56,95,46,100,77]        # 通过赋值方式创建元素为整数的列表ls
ls.reverse()                     # 将列表元素逆序
print(ls)                        # 输出修改过的列表[77, 100, 46, 95, 56, 88]

L = ['73','13','9','82','6','5','04']  # 通过赋值创建列表L
print(L)        # 输出列表原始元素    ['73', '13', '9', '82', '6', '5', '04']
print(sorted(L))# 将列表元素排序输出  ['04', '13', '5', '6', '73', '82', '9']
print(L)        # 列表L元素顺序不变  ['73', '13', '9', '82', '6', '5', '04']ls = [88,56,95,46,100,77]       # 创建列表ls,值为： [88, 56, 95, 46, 100, 77]
print(reversed(ls))   # <list_reverseiterator object at 0x00000126AC5CA6E0>print(list(reversed(ls)))     # 将列表元素逆序并转为列表输出 [77, 100, 46, 95, 56, 88]
print(ls)             # 列表ls元素顺序不变            [88, 56, 95, 46, 100, 77]

# 利用列表存储数据，统计平均成绩、中位数、最高三个成绩和最低三个成绩
scores = [94, 89, 96, 88, 92, 86, 69, 95, 78, 85]
scores.sort()          # 对成绩列表排序，默认升序，scores 中原来顺序丢失print(sum(scores)/10)  # 利用sum()函数对序列元素求和计算平均成绩
print('最高3个成绩为：', scores[-1: -4: -1]) # 后面3个成绩，步长-1表示逆序
print('最低3个成绩为：', scores[0: 3])       # 前面3个成绩，顺序输出，升序count = len(scores)# 取得成绩个数if count % 2 == 0: # 当列表元素数目为偶数时，中位数为中间两个数据的算术平均数median = (scores[count // 2 -1] + scores[count // 2 ])/2
else:              # 当列表元素数目为奇数时，中位数即列表中间的数字median = scores[ count // 2 ]print('成绩中位数是：{:.2f}'.format(median))
print(scores)   
# sort()方法使原列表排序发生变化，[69, 78, 85, 86, 88, 89, 92, 94, 95, 96]

scores = [94, 89, 96, 88, 92, 86, 69, 95, 78, 85]print(sum(scores)/10)
print('最高3个成绩为：',sorted(scores)[-1: -4: -1])#输出时排序，不影响原列表
print('最低3个成绩为：', sorted(scores)[0: 3])count = len(scores)   # 取得成绩个数
if count % 2 == 0: # 当列表元素数目为偶数时，中位数为中间两个数据的算术平均数median = (sorted(scores)[count // 2 -1] + sorted(scores)[count // 2 ])/2
else:              # 当列表元素数目为奇数时，中位数即列表中间的数字median = sorted(scores)[ count // 2 ]print('成绩中位数：{:.2f}'.format(median))
print(scores)   
# sorted()函数不改变原列表顺序[94, 89, 96, 88, 92, 86, 69, 95, 78, 85]

scores = []                   # 创建空列表
with open('6.1 score.txt','r',encoding='utf-8') as data:for line in data:           # 遍历文件对象line = line.strip()      # 去除行末的换行符line = line.split()      # 根据空白字符将字符串切分为列表line = int(line[1])      # 索引方法获取列表中序号为1的元素scores.append(line)      # 将其转为整数附加到列表末尾
print(scores)                  # 输出列表

# 字符串的处理方法可以连续使用，上述代码可以简化为下面形式
scores = []                      # 创建空列表
with open('6.1 score.txt','r',encoding='utf-8') as data:for line in data:             # 遍历文件对象scores.append(int(line.strip().split()[1]))      
print(scores)                    # 输出列表
# [94, 89, 96, 88, 92, 86, 69, 95, 78, 85]

# 二维列表元素排序以及根据多个字段用不同的排序规则进行排序
score = [[ 'Angle', '0121701100106',99], [ 'Jack', '0121701100107',86], [ 'Tom', '0121701100109',77], [ 'Smith', '0121701100111', 100], ['Bob', '0121701100115',77], ['Lily', '0121701100117', 59]]
print('按姓名排序')
print(sorted(score, key=lambda x:x[0])) # 按元素中序号为0的元素“姓名”排序
print('按学号排序')
print(sorted(score, key=lambda x:x[1])) # 按元素中序号为1的元素“学号”排序
print('优先按成绩排序再按姓名排序')
print(sorted(score, key=lambda x:(x[2],x[0])))  
#先按成绩升序排序，成绩相同时再按学号升序排序

city = [('hubei', 'wuhan'), ('hubei', 'huangshi'), ('hubei', 'huanggang'), ('hunan', 'shangsha')]print(sorted(city))
print(sorted(city, key=lambda x: (x[1], x[0])))
print(sorted(city, key=lambda x: ([-ord(i) for i in x[0]], [ord(i) for i in x[1]])))

# 只拷贝第一层的叫浅拷贝，如元素为可变数据类型，只拷贝其首地址，可变数据类型元素值发生变化，会影响用浅拷贝创建的对象。
# 递归拷贝到底的叫深拷贝，拷贝结果完全独立于原对象
import copyls = [2,5,['a',[22,33],'c'],9] # 创建一个对象ls
ls1 = ls                       # ls对象加一个新标签，值随ls变化而变化
ls2 = ls[1:3]                  # 切片，得到新对象
ls3 = ls.copy()                # 产生新对象
ls4 = [x for x in ls]          # 列表推导式ls5 = copy.deepcopy(ls)        # 产生新对象，递归拷贝ls中所有元素，对象创建后完全独立于ls
ls.append(10)                  # ls 末尾增加一个元素
ls[2][1].append(44)            # ls 中序号为2的元素['a',[22,33],'c']中序号为1的元素[22,33]末尾增加一个元素
print(id(ls),id(ls1),id(ls2),id(ls3),id(ls4),id(ls5))print(ls,ls1,ls2,ls3,ls4,ls5)

ls = [[ ]] * 3   # ls[0]被复制3次
print(ls)        # [[], [], []]
print(id(ls[0]),id(ls[1]),id(ls[2])) 
# ls[0]，ls[1]，ls[2]id相同，是同一对象的不同标签
# 输出2438949169160 2438949169160 2438949169160
ls[0].append(3)   # 列表ls[0]新增一个元素
print(ls)     # [[3], [3], [3]]，对象值改变，通过不同标签访问的都是修改过的值
ls[0].append(5)   # 列表ls[0]新增一个元素
print(ls)
# [[3, 5], [3, 5], [3, 5]]，对象值改变，通过不同标签访问的都是修改过的值

copy.copy(x)             # 返回 x 的浅层复制。
copy.deepcopy(x[, memo]) # 返回 x 的深层复制。
exception copy.error     # 针对模块特定错误引发。

import copy
ls = [1,2,'123',[4,5,(7,8,[9,10])]]
ls2 = copy.copy(ls)  
ls3 = copy.deepcopy(ls) 

copied_list = original_list[:]

# 以下两种方法都可以获得包含以3个空列表为元素的列表
lists = [[]] * 3
print(lists)  # [[], [], []]ls = [[] for i in range(3)]
print(ls)    # [[], [], []]

# 以下两种方法都可以获得包含以3个空列表为元素的列表
lists = [[]] * 3
lists[0].append(3)
print(lists)  # [[3], [3], [3]]
# 上述代码中3个元素中由lists[0]重复得到，都引用自lists[0],是同一个对象。
# 当这个对象的改变时，引用这个对象的所有名字的值也会发生相应的变化ls = [[] for i in range(3)]
ls[0].append(3)
ls[1].append(5)
ls[2].append(7)
print(ls)   # [[3], [5], [7]]

# 以下两种方法都可以获得包含以3个空列表为元素的列表
lists = [[]] * 3
lists[0].append(3)
lists[1].append(6)
lists[2].append(9)
print(lists)  # [[3, 6, 9], [3, 6, 9], [3, 6, 9]]
# 上述代码中3个元素中由lists[0]重复得到，都引用自lists[0],是同一个对象。
# 当这个对象的改变时，引用这个对象的所有名字的值也会发生相应的变化ls = [[] for i in range(3)]
ls[0].append(3)
ls[1].append(5)
ls[2].append(7)
print(ls)   # [[3], [5], [7]]

squares = []               # 创建空列表squares
for x in range(10):        # x依次取0-10中的数字squares.append(x**2)   # 向列表中增加x的平方
print(squares)       # 输出列表squares，[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]#用lambda函数实现，将0-9中每个数映射为其平方并转为列表
squares = list(map(lambda x: x**2, range(10)))   
print(squares)       # 输出列表squares，[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

squares = [x**2 for x in range(10)]#计算range(10)中每个数的平方，推导出新列表
print(squares)      # 输出新列表squares，[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

def fun(x):return x + x ** 2 + x ** 3     # 返回x + x ** 2 + x ** 3y = [fun(i) for i in range(10)]    # 列表推导式，按函数fun(x)，推导出新列表
print(y)               # 输出列表[0, 3, 14, 39, 84, 155, 258, 399, 584, 819]

def fun(x):return x + x**2 + x ** 3  # 返回x + x ** 2 + x ** 3# 列表推导式，根据原列表中的偶数，推导新列表
y = [fun(i) for i in range(10) if i%2 is 0]  
print(y)                                     # 输出列表[0, 14, 84, 258, 584]

ls = [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
print(ls)      # 输出[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

ls = [-4, -2, 0, 2, 4]
print([x*2 for x in ls])# 将原列表每个数字乘2，推导出新列表 [-8, -4, 0, 4, 8]
print([x for x in ls if x >= 0])   # 过滤列表，返回只包含正数的列表[0, 2, 4]
print([abs(x) for x in ls])        # 应用abs()函数推导新列表[4, 2, 0, 2, 4]
# 调用strip()方法去除每个元素前后的空字符,返回['banana', 'apple', 'pear']
freshfruit = ['  banana', '  apple ', 'pear  ']
print([fruit.strip() for fruit in freshfruit]) #
# 生成一个每个元素及其平方(number, square)构成的元组组成的列表
print([(x, x**2) for x in range(6)]) 
# [(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25)]

# 鄂A.27F37
# 鄂A.2737F
license_plate = input()# 鄂A.27F37->2737
license_plate_int = int(''.join([x for x in license_plate if x.isdigit()]))
if license_plate_int % 2 == 0:print('限行')
else:print('允许通行')

ls = [1,4,5,0,7,0,4,0,9]
ls_new = [x for x in ls if x]+[x for x in ls if not x]
print(ls_new)  # [1, 4, 5, 7, 4, 9, 0, 0, 0]print(sorted(ls,key=lambda x:(x==0)))  
# x!=0的元素值为False（0）,排在前面；x==0的元素值是True(1),排在后面

ls = [1,4,5,0,7,0,4,0,9]
odd = [x for x in ls if x%2]
even = [x for x in ls if not x%2]
print(odd,even)  # [1, 5, 7, 9] [4, 0, 0, 4, 0]# 奇数位是奇数，偶数位是偶数
print([x for y in zip(odd,even) for x in y])  # [1, 4, 5, 0, 7, 0, 9, 4]

# 用列表推导式写水仙花数
print(*[i for i in range(100, 1000) if i == sum([int(j) ** 3 for j in str(i)])])

# 先得到二维列表
[[0, 'Italy', "Aromas include tropical fruit, broom, brimstone and dried herb. The palate isn't overly expressive, offering unripened apple, citrus and dried sage alongside brisk acidity.", 87, 13.0, 'Sicily & Sardinia'], [10, 'US', 'Soft, supple plum envelopes an oaky structure in this Cabernet, supported by 15% Merlot. Coffee and chocolate complete the picture, finishing strong at the end, resulting in a value-priced wine of attractive flavor and immediate accessibility.', 87, 19.0, 'California'], [20, 'US', 'Ripe aromas of dark berries mingle with ample notes of black pepper, toasted vanilla and dusty tobacco. The palate is oak-driven in nature, but notes of tart red currant shine through, offering a bit of levity.', 87, 23.0, 'Virginia'], [30, 'France', 'Red cherry fruit comes laced with light tannins, giving this bright wine an open, juicy character.', 86, 15.0, 'Beaujolais'], [40, 'Italy', "Catarratto is one of Sicily's most widely farmed white grape varieties. This expression shows a mineral note, backed by citrus and almond blossom touches.", 86, 17.0, 'Sicily & Sardinia'],[50, 'Italy', "This blend of Nero d'Avola and Syrah opens with savory aromas of cured meat, dried berry, cassis, tobacco and wet earth. There's a touch of almond bitterness on the finish.", 86, 15.0, 'Sicily & Sardinia'], [60, 'US', 'Syrupy and dense, this wine is jammy in plum and vanilla, with indeterminate structure and plenty of oak. Ripe and full-bodied, it has accents of graphite and leather.', 86, 100.0, 'California'], [70, 'US', 'Aromas of vanilla, char and toast lead to light creamy stone fruit and canned-corn flavors. It provides appeal but the oak seems overweighted.', 86, 12.0, 'Washington'],[80, 'Chile', 'Caramelized oak and vanilla aromas are front and center on a barrel-heavy nose. This feels a bit choppy, with astringent tannins. Herbal salty plum flavors wear a lot of oaky makeup, while this finishes with a forced woody flavor.', 86, 12.0, 'Rapel Valley'], [90, 'US', "This blend of Sangiovese, Malbec, Cabernet Sauvignon, Petite Sirah and other varieties plays well to type. It shows a wealth of ripe, dusty black fruit that's richly round and soft on the palate, approachable and lightly oaked.", 88, 23.0, 'California']
]

import pandas as pd
import mathdf = pd.read_csv('/data/bigfiles/winemag-data.csv')
wine_ls = df.values.tolist()  # 得到数据的二维列表
# print(wine_ls[:3])  # 查看二维列表# 1. 用列表推导式，得到所有的国家列表
countries = [i[1] for i in wine_ls]  # 得到国家的列表
print(countries[:10])   # 查看列表前10个元素
print(set(countries))   # 去掉列表中的重复元素，返回集合
print(sorted(set(countries)))  # 对集合中的元素进行排序，输出排序列表# 2. 用列表推导式，得到所有的酒的评分的平均分
points = [i[3] for i in wine_ls if not math.isnan(i[3])]  # 得到所有非缺失值的酒的评分列表
print(sum(points) / len(points))# 3. 用列表推导式，得到所有的酒的价格的平均价
prices = [i[4] for i in wine_ls if not math.isnan(i[4])] # 得到所有非缺失值的酒的价格列表
print(sum(prices) / len(prices))

scores = []                      # 创建空列表
with open('5.1 score.txt','r',encoding='utf-8') as data:for line in data:             # 遍历文件对象scores.append(int(line.strip().split()[1]))      
print(scores)                    # 输出列表# 列表推导式实现
with open('5.1 score.txt','r',encoding='utf-8') as data:scores = [int(line.strip().split()[1]) for line in data]
print(scores)                    # 输出列表

# 方法一
n = int(input())
for num in range(10**(n-1),10**n):  # 遍历所有n位数sumOfnum = 0for i in str(num):       # num转为字符串，对其中的数字进行遍历,i为字符串sumOfnum = sumOfnum + int(i) ** n      # i转整数，计算其n次方累加if sumOfnum == num:                       # 若累加和与num值相同，是素数print(num)                             # 输出找到的素数

# 方法二
n = int(input())
ls = [x ** n for x in range(10)]        # 推导出0-9中每个数的n次方存于列表
for num in range(10 ** (n - 1),10 ** n):  # 遍历所有n位数if num == sum([ls[int(i)] for i in str(num)]):    print(num)         # 输出找到的素数

def isNarcissus(num):"""接收一个n位正整数为参数，判定其各位上数字的n次方的和是否与该数相等，返回布尔值"""return num == sum([int(i) ** len(str(num)) for i in str(num)])print(*[i for i in range(10, 100000) if isNarcissus(i)])
# 153 370 371 407 1634 8208 9474   

print(*[num for num in range(10, 100000) if num == sum([int(i) ** len(str(num)) for i in str(num)])])

print(*[x for x in range(2, int(input())) if not [y for y in range(2, x) if x % y == 0]])

g = ( i ** 3 for i in range(11))
print(type(g))                   # <class 'generator'>，g的数据类型为生成器
print(g)  # g是生成器对象，<generator object <genexpr> at 0x00000202A663DC00>
print(list(g))# 转为列表可输出[0, 1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]
print(list(g))                    # 生成器对象被遍历后会变成空 []g = ( i ** 3 for i in range(11))  # 重新创建生成器对象

print(next(g))                    # 输出 0

print(g.__next__())               # 输出 1。g.__next__()是next(g)另一种写法功能完全相同
print(next(g))                    # 输出 8
print(list(g))       # list(g)将生成器g中剩余的所有值转换为列表 输出[ 27, 64, 125, 216, 343, 512, 729, 1000]

map()  
zip()  
enumerate()

s= ['1','2','3']
print(map(int,s))
# 输出一个可迭代对象 <map object at 0x000002700724EEB8>
print(list(map(int,s)))            # 用list()可将其转为列表输出 [1, 2, 3]
print(list(map(float,range(5))))   # 整数序列映射为浮点数序列并转为列表
# 输出[0.0, 1.0, 2.0, 3.0, 4.0]
print(list(map(str,range(5))))     # 整数序列映射为字符串序列并转为列表
# 输出['0', '1', '2', '3', '4']
print('+'.join(map(str,range(5)))) # 整数序列映射为字符串序列并用‘+’连接
# 输出 0+1+2+3+4
print(''.join(map(str,range(5)))) # 整数序列映射为字符串序列并用空字符串连接
# 输出 01234
m,n = map(int,input().split()) 
# 将在一行中输入的用空格分隔2个数据切分开，转为整型，分别赋值给m,n
print(pow(2,64))                  # 结果为数字18446744073709551616
print(str(pow(2,64)))             # 结果为字符串'18446744073709551616'
print(map(int,str(pow(2,64))))# 可迭代对象<map object at 0x000001A4A11DEEB8>
print(sum(map(int,str(pow(2,64))))) # 输出2的64次方结果每位上的数加和 88

x = (1,2,3)
y = (4,5,6)
z = zip(x,y)   # 惰性求值，生成zip对象，可用list转为列表输出
print(list(z)) # [(1, 4), (2, 5), (3, 6)]
a = [1,2,3]  # 列表a最短，生成元组个数与a长度相同，其他列表中多余元素被丢弃
b = [11,22,33,44]
c = [111,222,333,444]
z = zip(a,b,c)  # 惰性求值，生成zip对象，可用list转为列表输出
print(list(z))  # [(1, 11, 111), (2, 22, 222), (3, 33, 333)]

a = ['apple', 'banana', 'cherry']
E = enumerate(a)              # 生成enumerate对象
print(list(E))                # [(0, 'apple'), (1, 'banana'), (2, 'cherry')]

# 利用列表推导式和zip()函数，用蒙特卡洛方法计算圆周率
import randomN = 100000
lsx = [random.random() for i in range(N)]  # 列表推导式随机生成N个小数
lsy = [random.random() for i in range(N)]  # 列表推导式随机生成N个小数
# 用zip函数将两个列表中对应序号的数据组成N对坐标值，用list()将其转为列表
ls = list(zip(lsx,lsy))
count = 0
for item in ls:if item[0]**2+item[1]**2<=1: # 判断坐标点是否落在圆内count=count + 1          # 落在圆内的点数量增加 1
PI = 4 * count/N                 # 计算圆周率值
print('{:.6f}'.format(PI))       # 输出结果3.141880（每次运行结果可能不同）

• 考虑一个单位圆（半径为1的圆）和包围它的单位正方形（边长为2，从(-1,-1)到(1,1)）。
• 单位圆的面积是π（因为圆的面积公式是πr²，这里r=1）。
• 单位正方形的面积是4（因为边长为2，面积是2×2=4）。

6.10 列表嵌套及排序

Python中列表中的元素可以仍然是列表，如果一个列表中的每个元素都仍然是列表的话，就构成了列表嵌套。例如：

scores = [['罗明', 95], ['金川', 85], ['戈扬', 80], ['罗旋', 78], ['蒋维', 99]]

scores被称为一个二维列表，它的每一个元素都仍是一个列表，这时仍然可以用索引和切片的方法对其进行访问和操作。
每多一层嵌套，索引时就用多一组方括号。

scores = [['罗明', 95], ['金川', 85], ['戈扬', 80], ['罗旋', 78], ['蒋维', 99]]
print(scores[1])    # 输出['金川', 85],这是列表scores的序号为1的元素
print(scores[3:5])  # 输出序号为3和4的[['罗旋', 78], ['蒋维', 99]]
print(scores[1][0])  #'金川'这是列表scores的序号为1的元素['金川', 85]中，序号为0的元素print(scores[1][1])  # 85,这是列表scores的序号为1的元素['金川', 85]中，序号为1的元素for ls in scores:print(ls,end = ' ') 
# ['罗明', 95] ['金川', 85] ['戈扬', 80] ['罗旋', 78] ['蒋维', 99]
print()for ls in scores:print(ls[1],end = ' ') # 输出每个元素中序号为1的元素,95 85 80 78 99 

处理数据文件时，经常用遍历的方法，利用split()函数将每行数据转为一个列表，并做为列表的一个元素，整个文件被读取后，以一个二维列表的形式存在，可以利用索引和切片等方法，方便的对其中的数据进行分析和处理。

实例 6.5 成绩统计分析进阶

现在一个包含若干学生学习成绩的文件，每位同学有4门课程的成绩，按要求完成以下任务。
文件中每行数据格式如下：

0121801101266,刘雯,92,73,72,64  
0121801101077,张佳喜,81,97,61,98  
…  
0121801101531,佘玉龙,73,89,81,93  

读取附件文件中的数据，对数据进行处理，计算每个同学4门课程成绩的平均成绩，将平均成绩置于课程成绩后一列，按照平均分升序排序后输出。‪‪‪‪‪‪‪‪‪‪‪‪‪‪‪‪‪‪‫‪‪‪‪‪‪‪‪

根据以下输入要求，输出相应的数据： ‪‪‪‪‪‪‪‪‪‪‪‪‪‪‪‪‪‪‫‪‪‪‪‪‪‪‪ 输出平均分最高的同学名字与平均成绩，名字与分数间用一个空格分隔；
‪‪‪‪‪‪‪‪‪‪‪‪‪‪‪‪‪‪‫‪‪‪‪‪‪输出平均分最低的同学名字与平均成绩，名字与分数间用一个空格分隔；
输出按平均分从低到高的排序数据，要求每个数据之间以空格间隔，每行结尾无空格。
‪‪‪‪‪‪‪‪‪‪‪‪‪‪‪‪‪‪‫‪‪‪‪‪‪‪输入一个学生的名字，输出该名同学所在行的的全部数据，各数据项间用一个空格分隔，结尾无空格；‪‪‪‪‪‪‪‪‪‪‪‪‪‪‪‪‪‪‫‪‪‪‪‪‪‪‪
如输入的姓名在文件中不存在，输出 '姓名不存在'‪‪‪‪‪‪‪‪‪‪‪‪‪‪‪‪‪‪‫‪‪‪‪‪‪‪‪

分析：可以使用列表推导式将文件中的数据转为一个二维列表：

with open('5.5 score.txt','r',encoding='utf-8') as f:  
ls = [i.strip().split(',') for i in f]  
print(ls)

查看一下列表中的数据：

[['0121801101266', '刘雯', '92', '73', '72', '64'],  ['0121801101077', '张佳喜', '81', '97', '61', '98'],  
…  ['0121801101531', '佘玉龙', '73', '89', '81', '93']]

查看读取结果，发现所有数据都是字符串类型，如需用于数学运算，需将参与运算的数据转为整数。
此例中可用map(int,x[2:])函数将列表中的成绩数据映射为整型，对映射结果用sum()函数求和再除以课程数量，即成绩列表的长度，即可得到4门课程的平均成绩。
方法如下：

sum(map(int,x[2:]))/len(x[2:])

用列表推导式推导出每位同学的平均成绩，用拼接方法（+）为列表增加一个元素：

score = [x + [sum(map(int,x[2:]))/len(x[2:])] for x in ls]

嵌套的二维列表排序可以应用lambda函数实现，语法为：

sort(key=lambda x:x[n], reverse=True)

key参数为lambda函数（lambda x:x[n]），其中x 为传入的元素，此例中为内层的列表；
x[n] 为排序关键字，此例中为内层列表中序号为n 的元素。
参数x可以是任意变量名，x[i]表示lambda函数返回列表中元素列表的第i个元素，此题中i值为1，表示根据列表中序号为1的元素（成绩）进行排序。

6.5 score.txt

!tar -xvf /data/bigfiles/ff92753b-ab25-4cf4-aefb-74823baeccf1.tar

with open('/data/bigfiles/c41b1db1-faff-4f0e-a5ef-f85b4e68e3dc.txt','r',encoding='utf-8') as f:ls = [i.strip().split(',') for i in f]      # 文件中的数据转为二维列表# 计算平均成绩并加到每个列表元素中
score = [x + [sum(map(int,x[2:]))/len(x[2:])] for x in ls] score.sort(key = lambda x:x[6])    # 根据序列为6的元素（平均成绩）升序排序# 输出排序后的最后一个列表元素中姓名和平均成绩，即平均分最高的数据
print(score[-1][1],score[-1][-1]) # 输出排序后的第一个列表元素中姓名和平均成绩，即平均分最低的数据
print(score[0][1],score[0][-1])   # 输出增加了平均成绩并排序后的数据，*表示解包输出，也可用循环方式输出
[print(*x) for x in score]        # 输入一个学生的名字，输出其全部信息，如姓名不存在，输出“姓名不存在”
name = input()                                # 输入一个同学的名字
if name in [x[1] for x in score]:             # 如果名字在列表中存在[print(*x) for x in score if x[1] == name] # 输出该同学的成绩数据
else:print('姓名不存在')

6.11 pandas读写数据

列表类型经常被用于数据处理，而数据的存在形式主要有两种，一种是文件形式，一种是数据库形式。对于文本文件中数据，可以用遍历的方法简单的读取，对于其他格式的数据文件或存储在数据库中的数据，可以借助Pandas库来读取。

Pandas是基于Numpy的一个开源库，提供了高性能和高可用性的数据结构用于解决数据分析问题，他纳入了大量的库和一些标准的数据模型，提供了可用于高效操作大型数据集的工具，是使Python成为强大而高效的数据分析工具的重要因素之一。

Pandas兼容所有Python的数据类型，除此外，还支持两种数据结构：
一维数组Series
二维表格型数据结构DataFrame
本章，我们只介绍利用Pandas读取数据的相关知识。

Pandas是第三方库，使用之前需要先安装，安装命令：

pip install pandas

通常，Pandas的引用方式为：

import pandas as pd

Pandas输入输出API提供了对文本、二进制和结构化查询语言（SQL）等不同格式类型文件的读写函数，可以方便快速的读取本地文件，如csv、txt、json和html等文本文件、Excel文件以及关系型数据库中的数据。
其主要方法如表6.2所示。 

表 6.2 Pandas常用输入输出API

这些API可以方便的把各种类型的数据读取为Dataframe格式的数据，再用利用tolist()函数便可将其转为列表类型，这样就可以利用本章学习的方法进行数据分析和处理了。

6.11.1 读Excel文件中数据

用Pandas可以读取Excel文件中的数据为Dataframe类型，Excel文件的读取主要应用read_excel()方法，使用时可能需要先用“pip install xlrd”安装xlrd模块。
read_excel()方法大部分参数都有默认值，只需要设置少量的参数便可以完成大部分的数据读取工作。
其主要参数及其意义如下：

pd.read_excel(io, sheet_name=0, header=0, names=None, usecols=None, squeeze=False, converters=None, skiprows=None, nrows=None, skipfooter=0)

1. io：Excel的存储路径
2. sheet_name：要读取的工作表名称，默认读取第一个工作表。可以是整型数字、列表名或SheetN。整型数字：目标sheet所在的位置，以0为起始，比如sheet_name = 1代表第2个工作表。列表名：目标sheet的名称，中英文皆可。SheetN：代表第N个sheet，S要大写，注意与整型数字的区别。
3. header：用哪一行作列名。默认为0 ，如果设置为[0,1]，则表示将前两行作为多重索引。
4. names：自定义最终的列名。一般适用于Excel缺少列名，或者需要重新定义列名的情况。names的长度必须和Excel列长度一致，否则会报错。
5. index_col：用作索引的列
6. usecols：需要读取哪些列。可以使用整型，从0开始，如[0,2,3]；也可以使用Excel传统的列名A、B等字母，如"A：C, E" = "A, B, C, E"，注意两边都包括。usecols 可避免读取全量数据，而是以分析需求为导向选择特定数据，提高效率。
7. squeeze：当数据仅包含一列。squeeze为True时，返回Series，反之返回DataFrame。
8. converters：强制规定列数据类型，主要用途是保留以文本形式存储的数字。
9. skiprows：跳过特定行。skiprows= n 跳过前n行； skiprows = [a, b, c] 跳过第a+1,b+1,c+1行（索引从0开始）。 
10. nrows：需要读取的行数，nrows = n 读取前n行。
11. skipfooter： 跳过末尾行数，skipfooter = n 跳过末尾的n行。

pandas默认将文本类的数据读取为整型，converters 参数可以指定各列数据的类型，如converters = {'出货量':float, '月份':str }， 将“出货量”列数据类型规定为浮点数，“月份”列规定为字符串类型。

实例 6.6 读取Excel文件中的证券数据

import pandas as pddata_df = pd.read_excel('/data/bigfiles/6,6 stock.xlsx') # 读取数据为dataframe类型
print(data_df)

import pandas as pddata_df = pd.read_excel('/data/bigfiles/6,6 stock.xlsx') # 读取数据为dataframe类型
title = data_df.columns.tolist()                         # dataframe数据中标题行转为列表类型
print('输出列表类型的表头\n',title)                      # 输出列表类型数据
print()data_ls = data_df.values.tolist()                        # dataframe数据转为列表类型
print('输出列表类型的数据\n',data_ls)                    # 输出列表类型数据

[[Timestamp('2018-01-15 00:00:00'),4.265, 4.56, 1.65, 1.736, 0.92, 1.634], 
[Timestamp('2018-01-16 00:00:00'), 4.308, 4.595, 1.7, 1.75, 0.941, 1.631], 
[Timestamp('2018-01-17 00:00:00'), 4.295, 4.59, 1.699, 1.74, 0.973, 1.639], 
[Timestamp('2018-01-18 00:00:00'), 4.323, 4.621, 1.675, 1.744, 0.98, 1.636], 
[Timestamp('2018-01-19 00:00:00'), 4.335, 4.632, 1.683, 1.74, 1.002, 1.63]]

• data_df.columns本身是一个Index对象，表示DataFrame的列名。
• .tolist()方法将其转换为Python列表，因此title是一个列表。
• print()函数在输出时会显示列表的语法（包括方括号和逗号分隔的元素），因此你会看到列表类型的输出。

值得注意的是，与遍历方法读取文件不同，用缺省参数读取的数据中，数值类型的数据直接被转为数值型，可以直接参与数值运算和统计分析。
日期读取为日期时间戳类型，可以用strftime()转为字符串。

import pandas as pddata_df = pd.read_excel('/data/bigfiles/6,6 stock.xlsx') # 读取数据为dataframe类型data_ls = data_df.values.tolist()                        # dataframe数据转为列表类型for lst in data_ls:lst[0] = lst[0].strftime("%Y-%m-%d")                 # 日期时间格式化为年-月-日形式
print('输出列表类型的数据\n', data_ls)                   # 输出列表类型数据

[['2018-01-15', 4.265, 4.56, 1.65, 1.736, 0.92, 1.634], 
['2018-01-16', 4.308, 4.595, 1.7, 1.75, 0.941, 1.631], 
['2018-01-17', 4.295, 4.59, 1.699, 1.74, 0.973, 1.639], 
['2018-01-18', 4.323, 4.621, 1.675, 1.744, 0.98, 1.636], 
['2018-01-19', 4.335, 4.632, 1.683, 1.74, 1.002, 1.63]]

pip install openpyxl

6.11.2 读文本文件中数据

读文本文件和csv文件进列表，对列表中的数据进行统计分析。将用常规分隔符分隔的文本文件读取到DataFrame可以使用read_csv()方法

其主要参数及意义如下：

pandas.read_csv(filepath_or_buffer, sep='\t', delimiter=None, header='infer', names=None, engine=None，encoding=None)

1. filepath_or_buffer：带路径文件名或URL，字符串类型。
2. sep：分隔符，缺省值为'\t'，当文本中的分隔符不是制表符时，可用sep=’分隔符’来指定。Python可自动检测分隔符。
3. delimiter：参数sep的替代参数，缺省值为None。
4. header：整型或整型列表，用作列名的行号和数据的开头。
5. names：要使用的列名的列表，如果文件不包含标题行，则应显式传递header = None。
6. engine：使用解析器引擎，其值可为'c'或'python'。c引擎速度更快，而Python引擎目前功能更加完善。
7. encoding：默认None，编码在读/写时用UTF（例如'utf-8'）

实例 6.7读取csv文件中的数据

6.7 score.csv

import pandas as pdscore_df = pd.read_csv('/data/bigfiles/6,7 score.csv',encoding='utf-8') # dataframe
print(score_df)                                          # 查看数据格式

import pandas as pdscore_df = pd.read_csv('/data/bigfiles/6,7 score.csv',encoding='utf-8') # dataframe
title = score_df.columns.tolist()                         # dataframe数据中标题行转为列表类型
score_ls = [title] + score_df.values.tolist()                            # 转为列表类型
print('输出列表类型的数据\n',score_ls)                     # 输出列表数据

[['姓名', 'C语言', 'Java', 'Python', 'C#']
['罗明', 95, 96, 85, 63, 91], 
['朱佳', 75, 93, 66, 85, 88], 
['李思', 86, 76, 96, 93, 67], 
['郑君', 88, 98, 76, 90, 89], 
['王雪', 99, 96, 91, 88, 86]]

6.11.3 读数据库中数据

在实际应用中，使用文本文件或Excel存储数据并不是最好的方式，我们能够对这些类型的文件中的数据能的操作非常有限，数据处理效率也不高，更常用的方式是将数据存储到数据库中，通过连接数据库进行相关操作。 目前应用最多的是关系型数据库，关系型数据库的主要构成是二维表。
二维表包含多行多列，把一个表中的数据用Python表现出来，可以用一个列表表示多行，列表的每一个元素用一个元组表示二维表中的一行记录。

比如一个二维表包含ID、姓名、年龄、籍贯、薪水，可以用以下形式表示：

[(1, '李明', 23, '吉林', 20000.00), 
(2, '韩雷', 26, '湖北', 25000.00), 
(3, '肖红', 30, '江西', 30000.00)]

这种表示方法无法直观的展示关系数据库的表结构，可以使用对象-关系映射 (ORM：Object-Relational Mapping)技术把关系数据库的表结构映射到对象上。在Python中，广泛应用的一个对象-关系映射框架是SQLAlchemy，这个框架可以为开发者提供高效的数据库访问设计和高性能的数据访问方法，实现了完整的企业级持久模型。

SQLAlchemy支持大部分主流数据库，如SQLite、MySQL、Postgres、Oracle、MS SQLServer 和 Firebird等。在使用之前，需要通过pip install sqlalchemy安装这个库。

SQLite是Python 内置的一个轻量级数据库，可以直接使用。使用其他数据库时，需要pip安装与数据库匹配的驱动，例如mysqlclient、 pymssql、 psycopg2、 cx-Oracle或 fdb等。只有安装数据库的驱动之后，才可以连接数据库对数据进行操作。本书以SQLite数据库作为范例进行讲解。

sqlalchemy.create_engine(args, *kwargs)函数可被用于创建数据库引擎，数据库位置可用本地路径，也可用网络URL。

from sqlalchemy import *
import pandas as pd# 定义元信息，绑定到引擎，test.db为数据库名，./表示当前路径。
engine = create_engine('sqlite:data/bigfiles/6,8 test.db', echo=True)
metadata = MetaData(engine)        # 绑定元信息

Pandas中的read_sql()方法可以查询数据库中的数据并直接返回DateFrame，在方法的参数中可以传入SQL语句。read_sql()方法的主要参数及意义如下：

pandas.read_sql(sql, con, index_col=None, coerce_float=True, params=None, parse_dates=None, columns=None, chunksize=None)

1. sql : 表名或查询语句
2. con : 连接数据库的引擎，一般可以用SQLAlchemy之类的模块创建
3. columns : 需要从表中查询的列名的列表

实例 6.8 读取SQLite数据库中的数据

SQLite数据库中文件“6.8 test.db”的score表中存储了学生的成绩数据，请将数据库中的数据读入到列表中。

6.8 test.db

from sqlalchemy import *
import pandas as pd# 定义引擎，6.8 test.db为数据库名，./表示当前路径
engine = create_engine('sqlite:data/bigfiles/6,8 test.db')  # , echo=True)
score_df = pd.read_sql('score', engine)  # 从score表读数据dataframe
print(score_df)                          # 查看输出dataframe格式数据

姓名  C语言  Java  Python  C#  C++
0  罗明   95    96      85  63   91
1  朱佳   75    93      66  85   88
2  李思   86    76      96  93   67
3  郑君   88    98      76  90   89
4  王雪   99    96      91  88   86

from sqlalchemy import *
import pandas as pd# 定义引擎，6.8 test.db为数据库名，./表示当前路径
engine = create_engine('sqlite:data/bigfiles/6,8 test.db')  # , echo=True)
score_df = pd.read_sql('score', engine)  # 从score表读数据dataframetitle = score_df.columns.tolist()             # dataframe数据转为列表类型
score_ls = score_df.values.tolist()            # dataframe数据转为列表类型
print('输出列表类型的数据:\n', [title] + score_ls)      # 输出转为列表的数据

```python
[['姓名', 'C语言', 'Java', 'Python', 'C#', 'C++'], ['罗明', 95, 96, 85, 63, 91], ['朱佳', 75, 93, 66, 85, 88], ['李思', 86, 76, 96, 93, 67], ['郑君', 88, 98, 76, 90, 89], ['王雪', 99, 96, 91, 88, 86]]
```

pip install sqlalchemy

类似的方法，也可以从json格式的文件中读取数据到列表：

import pandas as pdscore_df = pd.read_json('/data/bigfiles/6,8 scoreTest.json', encoding='utf-8') 
title = score_df.columns.tolist()             # dataframe数据转为列表类型
score_ls = score_df.values.tolist()            # dataframe数据转为列表类型
print('输出列表类型的数据:\n', [title] + score_ls)      # 输出转为列表的数据

pandas 数据显示

若csv文件的某列中有逗号，一般会将该列数据放到一对比引号中。pandas读csv文件时，可以将引号中的数据自动处理为一个元素，用pandas处理此类数据，可以避免用切分方法导致的误切分。

winemag-data.csv

import pandas as pdwine_reviews = pd.read_csv("/data/bigfiles/winemag-data.csv")
print(wine_reviews.shape)                     # ((12973, 6)
pd.set_option('display.max_columns', None)   # 显示所有列
pd.set_option('display.max_rows', None)      # 显示所有行
pd.set_option('display.width', None)         # 显示宽度是无限
print(wine_reviews.head())                   # 返回数据的前5行

6.12 内置函数all，any和filter的用法

Python中的all(), any(), 和 filter()是内置函数，用于对可迭代对象（如列表、元组等）进行操作，以实现不同的逻辑和筛选功能。

all()

all()函数用于检查可迭代对象中的所有元素是否都满足一个条件。如果可迭代对象中的所有元素都为True（或可迭代对象为空），则返回True；否则返回False。
用法：

all(iterable)

示例： 检查一个数字列表是否所有数字都大于0：

numbers = [1, 2, 3, 4, 5]
result = all(number > 0 for number in numbers)
print(result)  # 输出：True

使用all实现素数判定函数：

def is_prime_all(n):if n <= 1:return Falsereturn all(n % i != 0 for i in range(2, int(n**0.5) + 1))# 测试
print(is_prime_all(2))  # True
print(is_prime_all(17)) # True
print(is_prime_all(4))  # False

any()

any()函数用于检查可迭代对象中是否至少有一个元素满足一个条件。如果可迭代对象中至少有一个元素为True，则返回True；如果可迭代对象为空或所有元素都不满足条件，返回False。
用法：

any(iterable)

示例： 检查一个数字列表中是否至少有一个数字是正数：

numbers = [0, -1, -2, 4, -5]
result = any(number > 0 for number in numbers)
print(result)  # 输出：True

使用any实现素数判定函数：

def is_prime_any(n):if n <= 1:return Falsereturn not any(n % i == 0 for i in range(2, int(n**0.5) + 1))# 测试
print(is_prime_any(2))  # True
print(is_prime_any(17)) # True
print(is_prime_any(4))  # False

filter()

filter()函数用于从可迭代对象中过滤出满足条件的元素，返回一个filter对象，通常需要使用list()函数转换为列表。

用法：

filter(function, iterable)

function: 用于测试每个元素是否满足条件的函数。返回True或False。 iterable: 要从中过滤元素的可迭代对象。 示例： 从一个数字列表中过滤出所有的偶数：

numbers = [1, 2, 3, 4, 5, 6]
even_numbers = filter(lambda x: x % 2 == 0, numbers)
print(list(even_numbers))  # 输出：[2, 4, 6]

使用filter实现素数判定函数：

def is_prime_filter(n):if n <= 1:return Falsefactors = filter(lambda i: n % i == 0, range(2, int(n**0.5) + 1))return len(list(factors)) == 0# 测试
print(is_prime_filter(2))  # True
print(is_prime_filter(17)) # True
print(is_prime_filter(4))  # False

这些函数提供了强大的工具来处理和操作可迭代对象，使得代码更加简洁、易读。

6.13 中国近年废气污染物排放分析

数据文件下载：
废气污染物排放.csv

1.读文件，查看数据格式

def read_file(filename):"""读文件到列表，每行字符串为列表的一个元素，返回列表"""with open(filename,'r',encoding='utf-8') as fr:data_ls = [x.strip() for x in fr]print(data_ls)if __name__ == '__main__':file_name = '/data/bigfiles/废气污染物排放.csv'read_file(file_name)

['数据库：年度数据', '时间：最近20年', '指标,2020年,2019年,2018年,2017年,2016年,2015年,2014年,2013年,2012年,2011年,2010年,2009年,2008年,2007年,2006年,2005年,2004年', '二氧化硫排放量(万吨),318.22,457.30,516.10,610.80,854.90,1859.10,1974.40,2043.90,2118.00,2217.91,2185.00,2214.00,2321.00,2468.00,2588.80,2549.40,2254.90', '氮氧化物排放量(万吨),1181.65,1233.85,1785.22,1785.22,1394.31,1851.02,2078.00,2227.36,2337.76,2404.27,,,,,,,', '烟(粉)尘排放量(万吨),,,,796.26,1010.66,1538.01,1740.75,1278.14,1235.77,1278.83,,,,,,,', '颗粒物排放量(万吨),613.35,,,1684.05,,,,,,,,,,,,,', '注：1.2017年数据来源于第二次全国污染源普查。', '2.2017年全国移动源营运船舶二氧化硫、氮氧化物、颗粒物排放量，因无法以省级行政单元为对象进行调查，故未包含在各省排放总量内。', '3.自2017年，烟(粉)尘排放量指标名称改为颗粒物排放量。', '数据来源：国家统计局']

2.数据清洗

def read_file(filename):"""读文件到列表，每行字符串为列表的一个元素，返回列表"""with open(filename, 'r', encoding='utf-8') as fr:raw_data_ls = [x.strip() for x in fr]return raw_data_lsdef data_clean(raw_data_ls):"""去除无意义的数据仅保留废气污染数据，返回二维列表"""data_ls = raw_data_ls[2:7]clean_data_ls = [x.split(',') for x in data_ls]print(clean_data_ls)if __name__ == '__main__':file_name = '/data/bigfiles/废气污染物排放.csv'raw_data_lst = read_file(file_name)data_clean(raw_data_lst)

[['指标', '2020年', '2019年', '2018年', '2017年', '2016年', '2015年', '2014年', '2013年', '2012年', '2011年', '2010年', '2009年', '2008年', '2007年', '2006年', '2005年', '2004年'], ['二氧化硫排放量(万吨)', '318.22', '457.30', '516.10', '610.80', '854.90', '1859.10', '1974.40', '2043.90', '2118.00', '2217.91', '2185.00', '2214.00', '2321.00', '2468.00', '2588.80', '2549.40', '2254.90'], ['氮氧化物排放量(万吨)', '1181.65', '1233.85', '1785.22', '1785.22', '1394.31', '1851.02', '2078.00', '2227.36', '2337.76', '2404.27', '', '', '', '', '', '', ''], ['烟(粉)尘排放量(万吨)', '', '', '', '796.26', '1010.66', '1538.01', '1740.75', '1278.14', '1235.77', '1278.83', '', '', '', '', '', '', ''], ['颗粒物排放量(万吨)', '613.35', '', '', '1684.05', '', '', '', '', '', '', '', '', '', '', '', '', '']]

3. 查询历年污染物排放

def read_file(filename):"""读文件到列表，每行字符串为列表的一个元素，返回列表"""with open(filename, 'r', encoding='utf-8') as fr:raw_data_ls = [x.strip() for x in fr]return raw_data_lsdef data_clean(raw_data_ls):"""去除无意义的数据仅保留废气污染数据，返回二维列表"""data_ls = raw_data_ls[2:7]clean_data_ls = [x.split(',') for x in data_ls]return clean_data_lsdef pollution_emissions(clean_data_ls, pollutant_name):"""从清洗后的数据中查询历年某项污染物排放量，以“二氧化硫排放量(万吨)”为例，按排放量降序逐年输出，无返回值"""for x in clean_data_ls:if pollutant_name in x[0]:order = clean_data_ls.index(x)  # 先获取污染物数据序号pollutant_name = x[0][:-7]  # 切取污染物名break  # 结束循环# print(pollutant_name, order)  # 查看处理结果emissions_of_year = list(zip(clean_data_ls[0], clean_data_ls[order]))[1:]  # 将年份与对应数据组合在一起,切除首列sorted_emissions = sorted(emissions_of_year, key=lambda x: float(x[1]), reverse=True)  # 根据排放量的数值排序for x in sorted_emissions:print('{1}{0}排放量为{2}万吨'.format(pollutant_name, *x))  # 元组解包输出if __name__ == '__main__':file_name = '/data/bigfiles/废气污染物排放.csv'raw_data_lst = read_file(file_name)data_clean(raw_data_lst)clean_data_lst = data_clean(raw_data_lst)pollutant = input()  # 输入污染物名字pollution_emissions(clean_data_lst, pollutant)

2006年二氧化硫排放量为2588.80万吨 2005年二氧化硫排放量为2549.40万吨 2007年二氧化硫排放量为2468.00万吨 2008年二氧化硫排放量为2321.00万吨 2004年二氧化硫排放量为2254.90万吨 2011年二氧化硫排放量为2217.91万吨 2009年二氧化硫排放量为2214.00万吨 2010年二氧化硫排放量为2185.00万吨 2012年二氧化硫排放量为2118.00万吨 2013年二氧化硫排放量为2043.90万吨 2014年二氧化硫排放量为1974.40万吨 2015年二氧化硫排放量为1859.10万吨 2016年二氧化硫排放量为854.90万吨 2017年二氧化硫排放量为610.80万吨 2018年二氧化硫排放量为516.10万吨 2019年二氧化硫排放量为457.30万吨 2020年二氧化硫排放量为318.22万吨

结论，中国在环境保护方面做出了卓有成效的工作，污染排放逐年减少。