python升序内置函数 python内置函数降序

python 8个常用内置函数解说

8个超好用内置函数set（），eval（），sorted（），reversed（），map（），reduce（），filter（），enumerate（）

让客户满意是我们工作的目标，不断超越客户的期望值来自于我们对这个行业的热爱。我们立志把好的技术通过有效、简单的方式提供给客户，将通过不懈努力成为客户在信息化领域值得信任、有价值的长期合作伙伴，公司提供的服务项目有：空间域名、雅安服务器托管、营销软件、网站建设、寻甸网站维护、网站推广。

python中有许多内置函数，不像print那么广为人知，但它们却异常的强大，用好了可以大大提高代码效率。

这次来梳理下8个好用的python内置函数

1、set()

当需要对一个列表进行去重操作的时候，set()函数就派上用场了。

用于创建一个集合，集合里的元素是无序且不重复的。集合对象创建后，还能使用并集、交集、差集功能。

2、eval()之前有人问如何用python写一个四则运算器，输入字符串公式，直接产生结果。用eval()来做就很简单：eval(str_expression)作用是将字符串转换成表达式，并且执行。

3、sorted()在处理数据过程中，我们经常会用到排序操作，比如将列表、字典、元组里面的元素正/倒排序。这时候就需要用到sorted() ，它可以对任何可迭代对象进行排序，并返回列表。对列表升序操作：

对元组倒序操作：

使用参数：key，根据自定义规则，按字符串长度来排序：

根据自定义规则，对元组构成的列表进行排序：

4、reversed()如果需要对序列的元素进行反转操作，reversed()函数能帮到你。reversed()接受一个序列，将序列里的元素反转，并最终返回迭代器。

5、map()做文本处理的时候，假如要对序列里的每个单词进行大写转化操作。这个时候就可以使用map()函数。

map()会根据提供的函数，对指定的序列做映射，最终返回迭代器。也就是说map()函数会把序列里的每一个元素用指定的方法加工一遍，最终返回给你加工好的序列。举个例子，对列表里的每个数字作平方处理：

6、reduce()前面说到对列表里的每个数字作平方处理，用map()函数。那我想将列表里的每个元素相乘，该怎么做呢？这时候用到reduce()函数。

reduce()会对参数序列中元素进行累积。第一、第二个元素先进行函数操作，生成的结果再和第三个元素进行函数操作，以此类推，最终生成所有元素累积运算的结果。再举个例子，将字母连接成字符串。

你可能已经注意到，reduce()函数在python3里已经不再是内置函数，而是迁移到了functools模块中。这里把reduce()函数拎出来讲，是因为它太重要了。

7、filter()一些数字组成的列表，要把其中偶数去掉，该怎么做呢？

filter()函数轻松完成了任务，它用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象。filter()函数和map()、reduce()函数类似，都是将序列里的每个元素映射到函数，最终返回结果。我们再试试，如何从许多单词里挑出包含字母w的单词。

8、enumerate()这样一个场景，同时打印出序列里每一个元素和它对应的顺序号，我们用enumerate()函数做做看。

enumerate翻译过来是枚举、列举的意思，所以说enumerate()函数用于对序列里的元素进行顺序标注，返回(元素、索引)组成的迭代器。再举个例子说明，对字符串进行标注，返回每个字母和其索引。

什么是Python内置函数

所谓的内置函数，就是Python给你提供的，直接可以拿来使用的函数，比如说print、input等。常见的内置函数如下：

第一、help()函数

Help()函数的参数分为两种：如果传一个字符串做参数的话，它会自动搜索以这个字符串命名的模块、方法等;如果传入的是一个对象，就会显示这个对象的类型的帮助。比如输入help(‘print’)，它就会寻找以‘print’为名的模块、类等，找不到就会看到提示信息;而print在Python里是一个保留字，和pass、return同等，而非对象，所以help(print)也会报错。

第二、dir()函数

dir()函数返回任意对象的属性和方法列表，包含模块对象、函数对象、字符串对象、列表对象、字典对象等。尽管查找和导入模块相对容易，但是记住每个模块包含什么却不是这么简单，您并不希望总是必须查看源代码来找出答案。Python提供了一种方法，可以使用内置的dir()函数来检查模块的内容，当你为dir()提供一个模块名的时候，它返回模块定义的属性列表。dir()函数适用于所有对象的类型，包含字符串、整数、列表、元组、字典、函数、定制类、类实例和类方法。

第三、input与raw_input函数

都是用于读取用户输入的，不同的是input()函数期望用户输入的是一个有效的表达式，而raw_input()函数是将用户的输入包装成一个字符串。

第四、Print()函数

Print在Python3版本之间是作为Python语句使用的，在Python3里print是作为函数使用的。

第五、type()函数

Type()函数返回任意对象的数据类型。在types模块中列出了可能的数据类型，这对于处理多种数据类型的函数非常有用，它通过返回类型对象来做到这一点，可以将这个类型对象与types模块中定义类型相比较。

Python判断列表是否已排序的各种方法及其性能

本节判断列表排序的函数名格式为IsListSorted_XXX()。为简洁起见，除代码片段及其输出外，一律以_XXX()指代。

2.1 guess

def IsListSorted_guess(lst):

listLen = len(lst) if listLen = 1: return True

#由首个元素和末尾元素猜测可能的排序规则

if lst[0] == lst[-1]: #列表元素相同

for elem in lst: if elem != lst[0]: return False

elif lst[0] lst[-1]: #列表元素升序

for i, elem in enumerate(lst[1:]): if elem lst[i]: return False

else: #列表元素降序

for i, elem in enumerate(lst[1:]): if elem lst[i]: return False

return True

_guess()是最通用的实现，几乎与语言无关。值得注意的是，该函数内会猜测给定列表可能的排序规则，因此无需外部调用者指明排序规则。

2.2 sorted

def IsListSorted_sorted(lst):

return sorted(lst) == lst or sorted(lst, reverse=True) == lst

_sorted()使用Python内置函数sorted()。由于sorted()会对未排序的列表排序，_sorted()函数主要适用于已排序列表。

若想判断列表未排序后再对其排序，不如直接调用列表的sort()方法，因为该方法内部会判断列表是否排序。对于已排序列表，该方法的时间复杂度为线性阶O(n)——判断为O(n)而排序为O(nlgn)。

2.3 for-loop

def IsListSorted_forloop(lst, key=lambda x, y: x = y):

for i, elem in enumerate(lst[1:]): #注意，enumerate默认迭代下标从0开始

if not key(lst[i], elem): #if elem lst[i]更快，但通用性差

return False

return True

无论列表是否已排序，本函数的时间复杂度均为线性阶O(n)。注意，参数key表明缺省的排序规则为升序。

2.4 all

def IsListSorted_allenumk(lst, key=lambda x, y: x = y):

return all(key(lst[i], elem) for i, elem in enumerate(lst[1:]))import operatordef IsListSorted_allenumo(lst, oCmp=operator.le):

return all(oCmp(lst[i], elem) for i, elem in enumerate(lst[1:]))def IsListSorted_allenumd(lst):

return all((lst[i] = elem) for i, elem in enumerate(lst[1:]))def IsListSorted_allxran(lst, key=lambda x,y: x = y):

return all(key(lst[i],lst[i+1]) for i in xrange(len(lst)-1))def IsListSorted_allzip(lst, key=lambda x,y: x = y):

from itertools import izip #Python 3中zip返回生成器(generator)，而izip被废弃

return all(key(a, b) for (a, b) in izip(lst[:-1],lst[1:]))

lambda表达式与operator运算符速度相当，前者简单灵活，后者略为高效(实测并不一定)。但两者速度均不如列表元素直接比较(可能存在调用开销)。亦即，_allenumd()快于_allenumo()快于_allenumk()。

若使用lambda表达式指示排序规则，更改规则时只需要改变x和y之间的比较运算符；若使用operator模块指示排序规则，更改规则时需要改变对象比较方法。具体地，lt(x, y)等效于x y，le(x, y)等效于x = y，eq(x, y)等效于x == y，ne(x, y)等效于x != y，gt(x, y)等效于x y，ge(x, y)等效于x = y。例如，_allenumo()函数若要严格升序可设置oCmp=operator.lt。

此外，由all()函数的帮助信息可知，_allenumk()其实是_forloop()的等效形式。

2.5 numpy

def IsListSorted_numpy(arr, key=lambda dif: dif = 0):

import numpy try: if arr.dtype.kind == 'u': #无符号整数数组执行np.diff时存在underflow风险

arr = numpy.int64(lst) except AttributeError: pass #无dtype属性，非数组

return (key(numpy.diff(arr))).all() #numpy.diff(x)返回相邻数组元素的差值构成的数组

NumPy是用于科学计算的Python基础包，可存储和处理大型矩阵。它包含一个强大的N维数组对象，比Python自身的嵌套列表结构(nested list structure)高效得多。第三节的实测数据表明，_numpy()处理大型列表时性能非常出色。

在Windows系统中可通过pip install numpy命令安装NumPy包，不建议登录官网下载文件自行安装。

2.6 reduce

def IsListSorted_reduce(iterable, key=lambda x, y: x = y):

cmpFunc = lambda x, y: y if key(x, y) else float('inf') return reduce(cmpFunc, iterable, .0) float('inf')

reduce实现是all实现的变体。累加器(accumulator)中仅存储最后一个检查的列表元素，或者Infinity(若任一元素小于前个元素值)。

前面2.1~2.5小节涉及下标操作的函数适用于列表等可迭代对象(Iterable)。对于通用迭代器(Iterator)对象，即可以作用于next()函数或方法的对象，可使用_reduce()及后面除_rand()外各小节的函数。迭代器的计算是惰性的，只有在需要返回下一个数据时才会计算，以避免不必要的计算。而且，迭代器方式无需像列表那样切片为两个迭代对象。

2.7 imap

def IsListSorted_itermap(iterable, key=lambda x, y: x = y):

from itertools import imap, tee

a, b = tee(iterable) #为单个iterable创建两个独立的iterator

next(b, None) return all(imap(key, a, b))

2.8 izip

def IsListSorted_iterzip(iterable, key=lambda x, y: x = y):

from itertools import tee, izip

a, b = tee(iterable) next(b, None) return all(key(x, y) for x, y in izip(a, b))def pairwise(iterable):

from itertools import tee, izip

a, b = tee(iterable) next(b, None) return izip(a, b) #"s - (s0,s1), (s1,s2), (s2, s3), ..."def IsListSorted_iterzipf(iterable, key=lambda x, y: x = y):

return all(key(a, b) for a, b in pairwise(iterable))

第三节的实测数据表明，虽然存在外部函数调用，_iterzipf()却比_iterzip()略为高效。

2.9 fast

def IsListSorted_fastd(lst):

it = iter(lst) try:

prev = it.next() except StopIteration: return True

for cur in it: if prev cur: return False

prev = cur return Truedef IsListSorted_fastk(lst, key=lambda x, y: x = y):

it = iter(lst) try:

prev = it.next() except StopIteration: return True

for cur in it: if not key(prev, cur): return False

prev = cur return True

_fastd()和_fastk()是Stack Overflow网站回答里据称执行最快的。实测数据表明，在列表未排序时，它们的性能表现确实优异。

2.10 random

import randomdef IsListSorted_rand(lst, randNum=3, randLen=100):

listLen = len(lst) if listLen = 1: return True

#由首个元素和末尾元素猜测可能的排序规则

if lst[0] lst[-1]: #列表元素升序

key = lambda dif: dif = 0

else: #列表元素降序或相等

key = lambda dif: dif = 0

threshold, sortedFlag = 10000, True

import numpy if listLen = threshold or listLen = randLen*2 or not randNum: return (key(numpy.diff(numpy.array(lst)))).all() from random import sample for i in range(randNum):

sortedRandList = sorted(sample(xrange(listLen), randLen))

flag = (key(numpy.diff(numpy.array([lst[x] for x in sortedRandList])))).all()

sortedFlag = sortedFlag and flag return sortedFlag

_rand()借助随机采样降低运算规模，并融入其他判断函数的优点。例如，猜测列表可能的排序规则，并在随机采样不适合时使用相对快速的判断方式，如NumPy。

通过line_profiler分析可知，第20行和第21行与randLen有关，但两者耗时接近。因此randLen应小于listLen的一半，以抵消sorted开销。除内部限制外，用户可以调节随机序列个数和长度，如定制单个但较长的序列。

注意，_rand()不适用于存在微量异常数据的长列表。因为这些数据很可能被随机采样遗漏，从而影响判断结果的准确性。

python基础：内置函数、方法、转义字符大全

在写python程序时，常能用到一些函数和方法，总结一下，保存起来，方便查询。

一、内置函数

# abs()获取数字绝对值

# chr(i)数字转换为字符类型

# divmod() 获取两个数值的商和余数

# enumerate() 将可遍历序列组合为索引序列

# float()转换为浮点数

# format() 格式化字符串

# int()转换为整数 

# input() 接受用户输入内容

# len() 计算元素个数

# max() 返回最大值

# min() 返回最小值

# math.ceil() 返回指定数值的上舍整数

# open()打开文件并返回文件对象

# pow() 幂运算

# print()打印输出 

# range() 生成器

# reversed()反转所有元素

# round()四舍五入求值

# sorted()对可迭代对象进行排序 

# str() 转换为字符串

# sum() 求和

# set() 创建集合

# tuple() 将序列转换为元组

# zip()将可迭代对象打包成元组

二、方法

# append() 添加列表元素

# capitalize()首字母转换为大写 

# count()字符出现次数

# close() 关闭文件

# decode() 解码字符串

# dict.keys() 获取字典所有的键

# find()字符串首次出现的索引

# f.read() 读取文件内容

# dict.update()更新字典

# dict.items() 获取字典键/值对

# dict.get() 返回指定键的值

# encode() 编码字符串

# list.sort() 排序列表元素

# index() 元素首次出现的索引

# isdigit() 判断字符串是否只由数字组成

# isupper() 是否所有字母都为大写

# isnum() 判断字符串是否由字母和数字组成

# islower() 是否所有字母都为小写

# isdecimal() 检查字符串是否只包含十进制字符

# isalpha() 检测字符串是否为纯字母

# random.shuffle()随机排序

# random.sample()返回无重复随机数列表

# random.choice() 返回一个随机元素

# random.randint() 生成指定范围的随机整数

# random.randrange() 生成指定范围的指定递增基数随机整数

# pop() 删除列表中的元素

# remove()删除列表中的指定元素

# strip()去除空格

# lstrip()去除左侧空格

# rstrip() 去除右侧空格

# readline() 读取单行内容

# root.after() Tkinter中等待一段时间后再执行命令

# str.isnumeric() 验证字符串是否为数字（适用于Unicode）

# split()分割字符串

# ord() 将字符转换为整数

# replace() 字符串替换

# ljust() 左对齐填充

# rjust() 左对齐填充

# readlines() 读取所有行内容

# datetime.datetime.now() 返回指定时区的本地日期时间

# datetime.datetime.today() 获取当前本地日期的date对象

# datetime.utcnow() 返回当前UTC时间的datetime对象

# time.strptime()把时间字符串解析为元组

# time.time()返回当前时间的时间戳

# time.sleep()暂停指定秒数

# time.strftime() 返回指定格式的日期字符串

# time.mktime() 接收时间元组并返回时间戳

# os.getcwd() 获取当前工作目录

# os.listdir() 获取指定路径下的目录和文件列表

# os.makedirs() 递归创建目录

# os.rename() 重命名目录或文件

# os.path.exists() 判断路径是否存在

# upper() 全部转换为大写字母

# lower()  全部转换为小写字母

# sys.stdout.write() 标准输出打印

# sys.stdout.flush()刷新输出 

# shutil.copy() 复制单个文件到另一文件或目录

# write() 写入文件内容

# winsound.Beep() 打开电脑扬声器

# zfill() 在字符串前面填充0

三、循环语句

# break终止当前循环

# continue 终止本循环进入下一次循环

# with open() as file 以with语句打开文件（数据保存）

四、转义字符

\ 行尾续行符

\' 单引号 

\'' 双引号

\a 响铃

\e 转义

\n 换行

\t 横向制表符

\f 换页

\xyy 十六进制yy代表的字符

\\反斜杠符号

\b 退格

\000 空

\v 纵向制表符

\r 回车

\0yy 八进制yy代表的字符

\other 其他的字符以普通格式输出

请教如何用python按字母顺序排序英文名字但是不可以用sort函数

代码如下：

list = ['banana', 'apple', 'orange', 'blueberry', 'watermelon', 'strawberry', 'mango']

print(list)

list.sort()  #根据字母顺序排序

print(list)  #['apple', 'banana', 'blueberry', 'mango', 'orange', 'strawberry', 'watermelon']

list.sort(reverse = True) #根据字母相反顺序排序

print(str(list) + "\n")  #['watermelon', 'strawberry', 'orange', 'mango', 'blueberry', 'banana', 'apple']

扩展资料

sorted()函数四种重要的特性：

1、sorted()函数不需要定义。它是一个内置函数，可以在标准的Python安装中使用。

2、在没有额外的参数的情况下，sorted()函数按照升序对值进行排列，也就是按照从小到大的顺序。

3、原始的numbers不会改变，因为sorted()函数提供了一个新的有序的输出结果，并且不改变原始值的顺序。

4、当sorted()函数被调用时，它会提供一个有序的列表作为返回值。

最后一点意味着列表可以使用sorted()函数，并且输出结果可以立刻赋值给一个变量。

Python中冷门但非常好用的内置函数

Python中有许多内置函数,不像print、len那么广为人知,但它们的功能却异常强大,用好了可以大大提高代码效率，同时提升代码的简洁度，增强可阅读性

Counter

collections在python官方文档中的解释是High-performance container datatypes，直接的中文翻译解释高性能容量数据类型。这个模块实现了特定目标的容器，以提供Python标准内建容器 dict , list , set , 和 tuple 的替代选择。在python3.10.1中它总共包含以下几种数据类型：

容器名简介

namedtuple() 创建命名元组子类的工厂函数

deque 类似列表(list)的容器，实现了在两端快速添加(append)和弹出(pop)

ChainMap 类似字典(dict)的容器类，将多个映射集合到一个视图里面

Counter 字典的子类，提供了可哈希对象的计数功能

OrderedDict 字典的子类，保存了他们被添加的顺序

defaultdict 字典的子类，提供了一个工厂函数，为字典查询提供一个默认值

UserDict 封装了字典对象，简化了字典子类化

UserList 封装了列表对象，简化了列表子类化

UserString 封装了字符串对象，简化了字符串子类化

其中Counter中文意思是计数器，也就是我们常用于统计的一种数据类型，在使用Counter之后可以让我们的代码更加简单易读。Counter类继承dict类，所以它能使用dict类里面的方法

举例

#统计词频

fruits = ['apple', 'peach', 'apple', 'lemon', 'peach', 'peach']

result = {}

for fruit in fruits:

if not result.get(fruit):

result[fruit] = 1

else:

result[fruit] += 1

print(result)

#{'apple': 2, 'peach': 3, 'lemon': 1}下面我们看用Counter怎么实现：

from collections import Counter

fruits = ['apple', 'peach', 'apple', 'lemon', 'peach', 'peach']

c = Counter(fruits)

print(dict(c))

#{'apple': 2, 'peach': 3, 'lemon': 1}显然代码更加简单了，也更容易阅读和维护了。

elements()

返回一个迭代器，其中每个元素将重复出现计数值所指定次。元素会按首次出现的顺序返回。如果一个元素的计数值小于1，elements()将会忽略它。

c = Counter(a=4, b=2, c=0, d=-2)

sorted(c.elements())

['a', 'a', 'a', 'a', 'b', 'b']most_common([n])

返回一个列表，其中包含n个最常见的元素及出现次数，按常见程度由高到低排序。如果n被省略或为None，most_common()将返回计数器中的所有元素。计数值相等的元素按首次出现的顺序排序：

Counter('abracadabra').most_common(3)

[('a', 5), ('b', 2), ('r', 2)]这两个方法是Counter中最常用的方法，其他方法可以参考 python3.10.1官方文档

实战

Leetcode 1002.查找共用字符

给你一个字符串数组words，请你找出所有在words的每个字符串中都出现的共用字符（包括重复字符），并以数组形式返回。你可以按任意顺序返回答案。

输入：words = ["bella", "label", "roller"]

输出：["e", "l", "l"]

输入：words = ["cool", "lock", "cook"]

输出：["c", "o"]看到统计字符，典型的可以用Counter完美解决。这道题是找出字符串列表里面每个元素都包含的字符，首先可以用Counter计算出每个元素每个字符出现的次数，依次取交集最后得出所有元素共同存在的字符，然后利用elements输出共用字符出现的次数

class Solution:

def commonChars(self, words: List[str]) - List[str]:

from collections import Counter

ans = Counter(words[0])

for i in words[1:]:

ans = Counter(i)

return list(ans.elements())提交一下，发现83个测试用例耗时48ms，速度还是不错的

sorted

在处理数据过程中，我们经常会用到排序操作，比如将列表、字典、元组里面的元素正/倒排序。这时候就需要用到sorted()，它可以对任何可迭代对象进行排序，并返回列表

对列表升序操作：

a = sorted([2, 4, 3, 7, 1, 9])

print(a)

# 输出：[1, 2, 3, 4, 7, 9]对元组倒序操作：

sorted((4,1,9,6),reverse=True)

print(a)

# 输出：[9, 6, 4, 1]使用参数：key，根据自定义规则，按字符串长度来排序：

fruits = ['apple', 'watermelon', 'pear', 'banana']

a = sorted(fruits, key = lambda x : len(x))

print(a)

# 输出：['pear', 'apple', 'banana', 'watermelon']all

all() 函数用于判断给定的可迭代参数iterable中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。元素除了是 0、空、None、False外都算True。注意：空元组、空列表返回值为True。

all(['a', 'b', 'c', 'd']) # 列表list，元素都不为空或0

True

all(['a', 'b', '', 'd']) # 列表list，存在一个为空的元素

False

all([0, 1，2, 3]) # 列表list，存在一个为0的元素

False

all(('a', 'b', 'c', 'd')) # 元组tuple，元素都不为空或0

True

all(('a', 'b', '', 'd')) # 元组tuple，存在一个为空的元素

False

all((0, 1, 2, 3)) # 元组tuple，存在一个为0的元素

False

all([]) # 空列表

True

all(()) # 空元组

Trueany函数正好和all函数相反：判断一个tuple或者list是否全为空，0，False。如果全为空，0，False，则返回False；如果不全为空，则返回True。

F-strings

在python3.6.2版本中，PEP 498提出一种新型字符串格式化机制，被称为 “字符串插值” 或者更常见的一种称呼是F-strings，F-strings提供了一种明确且方便的方式将python表达式嵌入到字符串中来进行格式化：

s1='Hello'

s2='World'

print(f'{s1} {s2}!')

# Hello World!在F-strings中我们也可以执行函数：

def power(x):

return x*x

x=4

print(f'{x} * {x} = {power(x)}')

# 4 * 4 = 16而且F-strings的运行速度很快，比传统的%-string和str.format()这两种格式化方法都快得多，书写起来也更加简单。

本文主要讲解了python几种冷门但好用的函数，更多内容以后会陆陆续续更新~