《Python数据分析基础》第一章-Python基础（1.4.5-1.4.7）
1.4 Python语言基础要素
续前篇：《Python数据分析基础》第一章-Python基础（1.4-1.4.4）—— Flerken101
1.4.5 列表
列表中的元素可以包含数值、字符串、其他列表、元组和字典的任意组合。
1.4.5.1 创建列表
注意：len() 方法只返回最外层方括号中的元素个数。
# 使用方括号创建一个列表
a_list = [1,2,3]
print("Output #58: {}".format(a_list)) # 此处不需要在{}中指定索引
print("Output #59: a_lisy has {} elemects.".format(len(a_list)))
print("Output #60: the maximum value in a_list is {}.".format(max(a_list)))
print("Output #61: the minimum value in a_list is {}".format(min(a_list)))
another_list = ['printer',5,['star','circle',9]]
print("Output #62: {}".format(another_list))
print("Output #63: another_list also has {} elements.".format(len(another_list)))
# 用count()计算出列表中某个值出现的次数
print("Output #64: 5 is in another_list {} time.".format(another_list.count(5)))
1.4.5.2 索引值
# 使用方括号创建列表
a_list = [1,2,3]
another_list = ['printer',5,['star','circle',9]]
print("Output #65:{}".format(a_list[0]))
print("Output #66:{}".format(a_list[1]))
print("Output #67:{}".format(a_list[2]))
print("Output #68:{}".format(a_list[-1]))
print("Output #69:{}".format(a_list[-2]))
print("Output #70:{}".format(a_list[-3]))
print("Output #71:{}".format(another_list[2]))
print("Output #72:{}".format(another_list[-1]))
1.4.5.3 列表切片
列表切片引用的是列表中从第一 个索引值到第二个索引值的前一个元素。
# 使用方括号创建列表
a_list = [1,2,3]
another_list = ['printer',5,['star','circle',9]]
print("Output #73:{}".format(a_list[0:2])) #从索引0到索引1
print("Output #74:{}".format(another_list[:2])) #从索引0到索引1
print("Output #75:{}".format(a_list[1:3])) #从索引1到索引2
print("Output #76:{}".format(another_list[1:])) #从索引1直到列表的最后一个索引
1.4.5.4 列表复制
# 使用方括号创建列表
a_list = [1,2,3]
# 使用[:]复制一个列表
a_new_list= a_list[:]
print("Output #77: {}".format(a_new_list))
1.4.5.5 列表连接
得到的 被加列表 中 包含参与相加的列表中的所有元素。
# 使用方括号创建列表
a_list = [1,2,3]
another_list = ['printer',5,['star','circle',9]]
# 使用[:]复制一个列表
a_new_list= a_list[:]
# 使用+将两个或更多个列表连接起来
double_lists = a_list + a_new_list
a_longer_list = a_list + a_new_list + another_list
print("double_lists: {}".format(double_lists))
print("Output #78: {}".format(a_longer_list))
1.4.5.6 使用in和not in
# 使用方括号创建列表
a_list = [1,2,3]
a = 2 in a_list
print("Output #79: {}".format(a))
if 2 in a_list: # 或者写为 if a:
print("Output #80: 2 is in {}".format(a_list))
b = 6 not in a_list
print("Output #81: {}".format(b))
if 6 not in a_list: # 或者写为 if b:
print("Output #82: 6 is not in {}.".format(a_list))
1.4.5.7 追加、删除和弹出元素
# 使用方括号创建列表
a_list = [1,2,3]
a_list.append(4) # 使用append()向列表末尾追加一个新元素
a_list.append(5)
a_list.append(6)
print("Output #83: {}".format(a_list))
a_list.remove(5) # 使用remove()从列表中删除一个特定元素
print("Output #84: {}".format(a_list))
a_list.pop() # 使用pop()从列表末尾删除一个元素
a_list.pop()
print("Output #85: {}".format(a_list))
1.4.5.8 使用reverse()将列表原地反转
将列表 原地 修改为顺序颠倒的新列表。
要想使用列表的 原地反转（in-place反转） 形式，而不修改原列表，可以先复制列表，然后对列表副本进行 reverse 操作。
# 使用方括号创建列表
a_list = [1,2,3]
a_list.reverse()
print("Output #86: {}".format(a_list))
a_list.reverse()
print("Output #87: {}".format(a_list))
reverse()函数针对的仅仅是：元素为一个字符的列表
my_lists = [[1,2,3,4], [4,3,2,1], [2,4,1,3]] print("Output : {}".format(my_lists.reverse()))
1.4.5.9 使用sort()将列表原地排序
将列表 原地 修改为排好顺序的新列表。
# 使用sort()对列表进行原地排序会修改原列表
# 要想对列表进行排序同时又不修改原列表，可以先复制列表
unordered_list = [3, 5, 1, 7, 2, 8, 4, 9, 0, 6]
print("Output #88: {}".format(unordered_list))
list_copy = unordered_list[:] # 先复制
list_copy.sort() # 再原地排序
print("Output #89: {}".format(list_copy))
print("Output #90: {}".format(unordered_list)) # 原列表中的顺序不变
1.4.5.10 sorted排序函数
1.4.5.10.1 匿名函数
Python lambda（匿名函数）
Python 之 lambda 函数完整详解 & 巧妙运用 —— 置顶 Nick Peng
在Python中，匿名函数通常指的是使用lambda关键字创建的函数。
（1）产生背景：在编程中，我们经常需要定义一些简单的、一次性的函数。如果每次都使用标准的def语句来定义这些简单的函数，代码可能会显得冗长和繁琐。为了简化这种情况，Python引入了匿名函数的概念。
（2）作用
- 简化代码：匿名函数可以让代码更加简洁，特别是当我们需要一个简单的函数，但又不想为其命名时。
- 临时使用：在需要临时定义一个函数的场景下，比如排序、映射等操作，匿名函数非常方便。
- 传递函数：匿名函数可以将返回的函数，作为一个参数，传递给其他函数，这在函数式编程中非常有用。
（3）具体解释
- 匿名：意味着这个函数没有名字，就像我们在生活中有时候会临时找一个帮忙的人，用完之后就不会再记起他一样。
- 该函数的返回值：匿名函数的返回值仍然是一个函数，可以接收参数，执行操作，并返回结果。
（4）示例
假设我们想对一组数字进行排序，但不是按照数字本身排序，而是按照每个数字的平方排序。如果使用常规函数，我们可能这样做：
def square(x):
return x ** 2
# 这里的square函数有形参x，有要完成的计算x^2，也有整数型返回值
# 这里将函数square传递给形参key
numbers = [1, 3, 2, 4]
sorted_numbers = sorted(numbers, key=square)
使用匿名函数，我们可以这样写：
numbers = [1, 3, 2, 4]
sorted_numbers = sorted(numbers, key=lambda x: x ** 2)
''' 这里的lambda匿名函数，其本身同square函数一样，有形参x，有要完成的计算x^2.
因为其本身也是函数，因此调用该lambda函数时，给其形参x传递一定的实参，就会得到返回值。
这里也是将lambda函数【而不是将其在特定实参下的函数返回值】，传递给了形参key. '''
在这里，lambda x: x ** 2就是一个匿名函数，它接收一个参数x，返回x的平方。我们直接将它作为sorted函数的key参数，省去了定义一个单独函数的步骤。
总结来说：
Python 使用 lambda 来创建匿名函数。匿名函数不需要使用 def 关键字定义完整函数。
lambda函数是一种快速定义简单函数的便捷方式，它可以具有任意数量的参数(多个时用逗号隔开)，但只能有一个表达式。 是一种小型、匿名的、内联函数。
lambda 函数返回的并不是某一个数值，而是某一个函数，通过该函数作用在一个对象上才能获取最终的值。
> lambda函数通常用于编写简单的、单行的函数，通常在 需要函数作为参数传递 的情况下使用，例如在sorted()、map()、filter()、reduce() 等函数中。
1.4.5.10.2 sorted() 函数
（1）描述：sorted() 函数对所有可迭代的对象进行排序操作。
sort函数 与 sorted函数 区别：
sort函数 是列表list 的一个方法，在原列表上进行排序操作，排序后改变了原列表的元素顺序，无返回值；
sorted函数 不是在原列表基础上进行排序操作，排序后会返回一个新的排好序的列表，并不改变原列表的元素顺序。
（2）PY3语法：
sorted(iterable, key=None, reverse=False)
参数说明：
① iterable ----> 可迭代对象。
【一定是列表，列表中的元素可以时列表，也可以时元组。即sorted函数一定针对的是 列表集合/元组集合 ，即要求 列表iterable 中的每个元素都是列表/元组。
每个元素不是列表/元组类型，或集合中只含有 空列表/元组元素（ 如：[ [ ], [ ], [ ] ] 和 [ (), (), () ] ） 都无法完成迭代。】
② key ----> 主要是用来进行比较的元素，只有一个参数，具体的函数参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
这里的形参key接受的不是一个具体的值，而是一个具体的函数，这个函数定义了：
在每次迭代中，从可迭代对象的 每个列表元素中，获取元素以进行排序的方式。
每次迭代，key函数获取到/返回的值都会被更新一次，直到迭代结束。
【在下面的sorted函数中，key = lambda index_value: index_value[3]
首先：给一个列表名称index_value，然后返回该列表index_value索引为3的值index_value[3]，这是lambda 匿名函数要完成的简单任务。
在这里lambda 函数的形参为index_value，每次传入的实参为iterable 中每个列表元素的名称，然后返回该列表元素 中索引为3的元素【此时lambda 函数（就是key函数）的该次任务已结束】，让其为sorted函数形参key此次的函数值。
如传递给lambda 函数（即key函数）的实参为第一个子列表[1,2,3,4]的名称（源代码中，取到该子列表元素后，会将其赋值为index_value变量），该lambda函数（即key函数）返回的函数值是其中索引为3的元素的4. 】
③reverse ----> 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
返回值： 新的，排好序的列表。
# 使用sorted()对一个列表集合按照列表中某个位置的元素进行排序
my_lists = [[1,2,3,4], [4,3,2,1], [2,4,1,3]]
my_lists_sorted_by_index_3 = sorted(my_lists,key = lambda index_value: index_value[3])
print("Output #91: {}".format(my_lists_sorted_by_index_3))
1.4.5.11 使用 operator 标准模块 和 sorted() 函数通过多个关键字进行排序
该方法不止适用于列表，也同样适用于 元组 和 字典。
python之itemgetter()函数——江小枫
operator模块中的 itemgetter() 函数：
主要用于获取某一对象 特定维度的数据，其中的参数为特定维度的序号。from operator import itemgetter a = [1,2,3,4,5] b = itemgetter(0) # 获取索引为0的元素，将返回的函数赋值给b b(a) # 给函数b传递实参：为列表类型的a >>>1 # 说明 b(a) ⇔ a[0]itemgetter函数返回的并不是某一个数值，而是某一个函数，这一点从调用的形式b(a)就能看出来，通过该函数作用在一个对象（列表名称）上才能获取最终的值。
Python中的operator.itemgetter函数 — 白阳——只看前半部分
itemgetter() 方法 与 匿名函数lambda 不同之处是：
如果在 itemgetter() 中指定了多个特定维度（k1,k2,k3），
则当调用 itemgetter(k1,k2,k3) 返回的函数时，就会返回由查找值的形成的元组。from operator import itemgetter a = [1,2,3,4,5] c = itemgetter(0,1,2) # 获取索引为0、1、2的元素，将返回的函数赋值给c c(a) >>> (1, 2, 3) # 说明 c(a) ⇔ (a[0],a[1],a[2])
在下面代码中，前一种单索引位置排序： key = itemgetter(3)
就相当于上面的： key = lambda index_value: index_value[3]key = itemgetter(3) 的作用也是：
获取索引为3的元素，将 返回的函数 赋值给key.
当每次调用函数key时，就可得到迭代对象iterable 中，每个列表元素中索引为3的元素，仅一个元素。每次迭代，key的函数值都会被更新一次，直到迭代结束。
而在后一种多索引位置排序中，key = itemgetter(3,0)
获取的是 索引为3和0的元素形成的元组，将 返回的函数 赋值了给key.
因此，当每次调用函数key时，就可得到包含 迭代对象iterable 中每个列表元素中索引为3和索引为0的元素形成的元组，即一次性获得两个元素。
同样，每次迭代，key的函数值——元组，都会被更新一次，直到迭代结束。
但第一次排序时，总是会先按该元组中前一个元素（即每个列表元素中索引为3的元素 ）进行排序。
只有当元组中前一个元素的排序，全部完成时，在这个排序的基础上，才会按每次获得的元组中第二个元素（即每个列表元素中索引为0的元素 ）进行排序。
from operator import itemgetter
# 使用sorted() 和 itemgetter()对一个列表集合按照两个索引位置来排序
my_lists = [[123,2,2,444], [22,6,6,444], [354,4,4,678], [236,5,5,678], [578,1,1,290], [461,1,1,290]]
print("原列表 : {}".format(my_lists))
my_lists_sorted_by_index_3 = sorted(my_lists,key = lambda index_value: index_value[3])
''' # 也可以写为，使用itemgetter函数：
my_lists_sorted_by_index_3_and_0 = sorted(my_lists,key = itemgetter(3)) '''
print("按索引值3进行排序后: {}".format(my_lists_sorted_by_index_3))
# 在按索引值3排序后的基础上，再按照索引位置 0 中的值对列表进一步排序。
my_lists_sorted_by_index_3_and_0 = sorted(my_lists,key = itemgetter(3,0))
print("Output #92: {}".format(my_lists_sorted_by_index_3_and_0))
1.4.6 元组（元素不能被修改）
元组与列表相同的操作：
使用count()计算出元组中某个值出现的次数
元组索引、元组索引切片、元组复制：都还是使用方括号，且规则还是与列表相同
使用+号进行元组连接
使用in和 not in 判断一个元素是否在、不在元组中
以下方式会修改元组，因此仅适用于列表，不适用于元组：
使用append()向末尾追加一个新元素
使用remove()从中删除一个特定元素
使用pop()从末尾删除一个元素
使用reverse()进行原地反转 【 reverse()函数针对的仅仅是：元素为一个字符的列表 】
使用sort()进行原地排序
下面这两种操作，对元组集合进行非原地排序之后，原元组集合中的元素都不会被改变。
sorted函数返回的是一个排好序的列表，但里面的元素是元组（仍然不可以对该列表使用reverse）：
（1）使用sorted()和 lambda函数 对一个元组集合按照元组中某个位置的元素进行排序
（2）使用 operator 标准模块 和 sorted() 函数通过单/多个关键字对元组集合进行排序
from operator import itemgetter
my_tuples = ((123,2,2,444), (22,6,6,444), (354,4,4,678), (236,5,5,678), (578,1,1,290), (461,1,1,290))
my_tuples_sorted_by_index_3 = sorted(my_tuples,key = lambda index_value: index_value[3])
print("使用 sorted() 和 lambda函数排序： {}".format(my_tuples_sorted_by_index_3))
print("使用 sorted() 和 lambda函数排序之后，再原地反转： {}".format(my_tuples_sorted_by_index_3.reverse()))
print("使用 sorted() 和 lambda函数排序之后，再转化为元组： {}".format(tuple(my_tuples_sorted_by_index_3)))
# print(" {}".format(my_tuples)) #原元组集合没有被改变
my_tuples_sorted_by_index_3 = sorted(my_tuples,key = itemgetter(3))
print("使用 sorted() 和 itemgetter() 函数进行单索引值排序： {}".format(my_tuples_sorted_by_index_3))
my_tuples_sorted_by_index_3 = sorted(my_tuples,key = itemgetter(3,0))
print("使用 sorted() 和 itemgetter() 函数进行多索引值排序： {}".format(my_tuples_sorted_by_index_3))
1.4.6.1 创建元组
# 使用圆括号创建元组
my_tuple = ('x','y','z')
print("Output #93: {}".format(my_tuple))
print("Output #94: my_tuple has {} elements.".format(len(my_tuple)))
print("Output #95: {}".format(my_tuple[1]))
longer_tuple = my_tuple + my_tuple
print("Output #96: {}".format(longer_tuple))
1.4.6.2 元组解包
# 使用赋值操作符左侧的变量对元组进行解包
one, two, three = my_tuple
print("Output #97: {0} {1} {2}".format(one, two, three))
# 在变量之间交换彼此的值
var1 = 'red'
var2 = 'robin'
print("Output #98: {} {}".format(var1,var2))
var1, var2 = var2, var1
print("Output #99: {} {}".format(var1,var2))
1.4.6.3 元组与列表相互转换
my_list = [1, 2, 3]
print("Output #100: {}".format(tuple(my_list))) # 将列表转换成元组
my_tuple = ('x', 'y', 'z')
print("Output #101: {}".format(list(my_tuple))) # 将元组转换成列表
1.4.7 字典
1.4.7.1 创建字典
empty_dict = { } # 使用花括号创建字典
a_dict = {'one':1, 'two':2, 'three':3} # 用冒号分隔键-值对
print("Output #102: {}".format(a_dict))
print("Output #103: a_dict has {:d} elemtents".format(len(a_dict))) # 用len()计算出字典中键-值对的数量
another_dict = {'x':'printer', 'y':5, 'z':['star','circle',9]}
print("Output #104: {}".format(another_dict))
# 此处将len()返回的整数值int型，强制转换为字符型char型，再输出
print("Output #105: another_dict also has {!s} elements".format(len(another_dict)))
1.4.7.2 使用字典键引用字典中的值
a_dict = {'one':1, 'two':2, 'three':3} # 使用花括号创建字典，用冒号分隔键-值对
another_dict = {'x':'printer', 'y':5, 'z':['star','circle',9]}
# 使用（字典）键来引用字典中特定的值
print("Output #106: {}".format(a_dict['two']))
print("Output #107: {}".format(another_dict['z']))
1.4.7.3 使用copy()复制字典
a_dict = {'one':1, 'two':2, 'three':3} # 使用花括号创建字典，用冒号分隔键-值对
# 使用copy()复制一个字典
a_new_dict = a_dict.copy()
print("Output #108: {}".format(a_new_dict))
1.4.7.4 使用keys()引用键、使用values()引用值、使用items()引用项目
a_dict = {'one':1, 'two':2, 'three':3}
# 使用花括号创建字典，用冒号分隔键-值对
print("Output #109: {}".format(a_dict.keys()))
# 使用 字典名称.keys()引用字典中所有的字典键
# 结果是包含字典中所有的字典键的一个列表
print("Output #111: {}".format(a_dict.values()))
# 使用 字典名称.values()引用字典中所有的字典值
# 结果是包含字典中所有的字典值的一个列表
print("Output #112: {}".format(a_dict.items()))
# 使用 字典名称.items()引用字典中所有的 键-值对
# 结果是一个列表，其中包含的是 “键-值”对 形成的元组
1.4.7.5 使用in、not in和get测试字典中是否存在某个键值
a_dict = {'one':1, 'two':2, 'three':3} # 使用花括号创建字典，用冒号分隔键-值对
another_dict = {'x':'printer', 'y':5, 'z':['star','circle',9]}
# 方式一：使用 if 语句、in 或 not in 以及字典名称，测试字典中是否存在某个键值
if 'y' in another_dict:
print("Output #114: y is a key in another_dict: {}.".format(another_dict.keys()))
if 'c' not in another_dict:
print("Output #115: c is not a key in another_dict: {}".format(another_dict.keys()))
# 方式二：使用 get 函数,测试具体键值
# 如果字典中存在这个键，get 函数就返回键值对应的 字典值
print("Output #116: {!s}".format(a_dict.get('three')))
# 如果字典中不存在这个键，则返回 None
print("Output #117: {!s}".format(a_dict.get('four')))
# 使用第二个参数，表示如果字典中不存在键值时函数的返回值
print("Output #118: {!s}".format(a_dict.get('four', 'Not in dict')))
1.4.7.6 使用sorted() 对字典进行排序
a_dict = {'one':98, 'two':22, 'three':51} # 使用花括号创建字典，用冒号分隔键-值对
print("Output #119: {}".format(a_dict))
dict_copy = a_dict.copy() #不进行复制也可以。sorted函数对 列表集合/元组集合/字典 进行排序时，本身就不会修改原来的 列表集合/元组集合/字典 。
# 将字典中的键-值对按照字典键值key升序排序（按照字母表的顺序，第一个字母相同的，按第二字母，以此类推）
ordered_dict1 = sorted(dict_copy.items(), key = lambda item: item[0])
print("Output #120: (ordey by keys) : {}".format(ordered_dict1))
# 将字典中的键-值对按照字典值value升序排序（按照整数的大小）
ordered_dict2 = sorted(dict_copy.items(), key = lambda item: item[1]) # 默认就为升序
print("Output #121: (order by values) : {}".format(ordered_dict2))
# 将字典中的键-值对按照字典值value降序排序
ordered_dict3 = sorted(dict_copy.items(), key = lambda x: x[1], reverse = True)
print("Output #122: (order by values) : {}".format(ordered_dict3))
# 仅修改lambda函数的形参，再将字典中的键-值对按照字典值value升序排序
ordered_dict4 = sorted(dict_copy.items(), key = lambda x: x[1], reverse = False)
print("Output #123: (order by values) : {}".format(ordered_dict4))
Output #121 与 #123 的区别仅在于lambda函数（即sorted的形参key函数）的形参：
而lambda函数（即sorted的形参key函数）的形参，仅仅是对 列表中每个元组元素的名称。
key = lambda item: item[1]
当lambda函数的形参，被定义为item时，只说明在取到每个元组时，就会将该元组命名为item，然后取其中索引为1的元素的值。
key = lambda x: x[1]
当lambda函数的形参，被定义为x时，就会将取到的元组都命名为x，然后也是取其中索引为1的元素的值。
原文地址：https://blog.csdn.net/qq_44883214/article/details/142342575
免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！