189 8069 5689
在学习Python的过程中，有几个比较重要的内置函数：help()函数、dir()函数、input()与raw_input()函数、print()函数、type()函数。
成都创新互联主营商都网站建设的网络公司,主营网站建设方案,成都app软件开发,商都h5重庆小程序开发搭建,商都网站营销推广欢迎商都等地区企业咨询
第一、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 函数
函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。
函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。
定义一个函数
你可以定义一个由自己想要功能的函数，以下是简单的规则：
函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容以冒号起始，并且缩进。
return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
语法
def functionname( parameters ): "函数_文档字符串"
function_suite
return [expression]
默认情况下，参数值和参数名称是按函数声明中定义的顺序匹配起来的。
实例
以下为一个简单的Python函数，它将一个字符串作为传入参数，再打印到标准显示设备上。
实例(Python 2.0+)
def printme( str ): "打印传入的字符串到标准显示设备上"
print str
return
函数调用
定义一个函数只给了函数一个名称，指定了函数里包含的参数，和代码块结构。
这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从Python提示符执行。
如下实例调用了printme（）函数：
实例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
# 定义函数def printme( str ): "打印任何传入的字符串"
print str
return
# 调用函数printme("我要调用用户自定义函数!")printme("再次调用同一函数")
以上实例输出结果：
我要调用用户自定义函数!再次调用同一函数
参数传递
在 python 中，类型属于对象，变量是没有类型的：
a=[1,2,3]
a="Runoob"
以上代码中，[1,2,3] 是 List 类型，"Runoob" 是 String 类型，而变量 a 是没有类型，她仅仅是一个对象的引用（一个指针），可以是 List 类型对象，也可以指向 String 类型对象。
可更改(mutable)与不可更改(immutable)对象
在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。
不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。
可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。
python 函数的参数传递：
不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。
可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响
python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。
python 传不可变对象实例
实例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
def ChangeInt( a ): a = 10
b = 2ChangeInt(b)print b # 结果是 2
实例中有 int 对象 2，指向它的变量是 b，在传递给 ChangeInt 函数时，按传值的方式复制了变量 b，a 和 b 都指向了同一个 Int 对象，在 a=10 时，则新生成一个 int 值对象 10，并让 a 指向它。
传可变对象实例
实例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
# 可写函数说明def changeme( mylist ): "修改传入的列表"
mylist.append([1,2,3,4])
print "函数内取值: ", mylist
return
# 调用changeme函数mylist = [10,20,30]changeme( mylist )print "函数外取值: ", mylist
实例中传入函数的和在末尾添加新内容的对象用的是同一个引用，故输出结果如下：
函数内取值: [10, 20, 30, [1, 2, 3, 4]]函数外取值: [10, 20, 30, [1, 2, 3, 4]]
参数
以下是调用函数时可使用的正式参数类型：
必备参数
关键字参数
默认参数
不定长参数
必备参数
必备参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
调用printme()函数，你必须传入一个参数，不然会出现语法错误：
实例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
#可写函数说明def printme( str ): "打印任何传入的字符串"
print str
return
#调用printme函数printme()
以上实例输出结果：
Traceback (most recent call last):
File "test.py", line 11, in module
printme()TypeError: printme() takes exactly 1 argument (0 given)
关键字参数
关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。
使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。
以下实例在函数 printme() 调用时使用参数名：
实例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
#可写函数说明def printme( str ): "打印任何传入的字符串"
print str
return
#调用printme函数printme( str = "My string")
以上实例输出结果：
My string
下例能将关键字参数顺序不重要展示得更清楚：
实例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
#可写函数说明def printinfo( name, age ): "打印任何传入的字符串"
print "Name: ", name
print "Age ", age
return
#调用printinfo函数printinfo( age=50, name="miki" )
以上实例输出结果：
Name: mikiAge 50
默认参数
调用函数时，默认参数的值如果没有传入，则被认为是默认值。下例会打印默认的age，如果age没有被传入：
实例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
#可写函数说明def printinfo( name, age = 35 ): "打印任何传入的字符串"
print "Name: ", name
print "Age ", age
return
#调用printinfo函数printinfo( age=50, name="miki" )printinfo( name="miki" )
以上实例输出结果：
Name: mikiAge 50Name: mikiAge 35
不定长参数
你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述2种参数不同，声明时不会命名。基本语法如下：
def functionname([formal_args,] *var_args_tuple ): "函数_文档字符串"
function_suite
return [expression]
加了星号（*）的变量名会存放所有未命名的变量参数。不定长参数实例如下：
实例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
# 可写函数说明def printinfo( arg1, *vartuple ): "打印任何传入的参数"
print "输出: "
print arg1
for var in vartuple: print var
return
# 调用printinfo 函数printinfo( 10 )printinfo( 70, 60, 50 )
以上实例输出结果：
输出:10输出:706050
匿名函数
python 使用 lambda 来创建匿名函数。
lambda只是一个表达式，函数体比def简单很多。
lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。
虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。
语法
lambda函数的语法只包含一个语句，如下：
lambda [arg1 [,arg2,.....argn]]:expression
如下实例：
实例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
# 可写函数说明sum = lambda arg1, arg2: arg1 + arg2
# 调用sum函数print "相加后的值为 : ", sum( 10, 20 )print "相加后的值为 : ", sum( 20, 20 )
以上实例输出结果：
相加后的值为 : 30相加后的值为 : 40
return 语句
return语句[表达式]退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None。之前的例子都没有示范如何返回数值，下例便告诉你怎么做：
实例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
# 可写函数说明def sum( arg1, arg2 ): # 返回2个参数的和."
total = arg1 + arg2
print "函数内 : ", total
return total
# 调用sum函数total = sum( 10, 20 )
以上实例输出结果：
函数内 : 30
变量作用域
一个程序的所有的变量并不是在哪个位置都可以访问的。访问权限决定于这个变量是在哪里赋值的。
变量的作用域决定了在哪一部分程序你可以访问哪个特定的变量名称。两种最基本的变量作用域如下：
全局变量
局部变量
全局变量和局部变量
定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。
局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。如下实例：
实例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
total = 0 # 这是一个全局变量# 可写函数说明def sum( arg1, arg2 ): #返回2个参数的和."
total = arg1 + arg2 # total在这里是局部变量.
print "函数内是局部变量 : ", total
return total
#调用sum函数sum( 10, 20 )print "函数外是全局变量 : ", total
以上实例输出结果：
函数内是局部变量 : 30函数外是全局变量 : 0
点击上方 "Python人工智能技术" 关注，星标或者置顶
22点24分准时推送，第一时间送达
后台回复“大礼包”，送你特别福利
编辑：乐乐 | 来自：pypypypy
上一篇：
正文
大家好，我是Pythn人工智能技术。
内置函数就是Python给你提供的，拿来直接用的函数，比如print.，input等。
截止到python版本3.6.2 ，python一共提供了68个内置函数，具体如下
abs() dict() help() min() setattr()
all() dir() hex() next() slice()
any() divmod() id() object() sorted()
ascii() enumerate() input() oct() staticmethod()
bin() eval() int() open() str()
bool() exec() isinstance() ord() sum()
bytearray() filter() issubclass() pow() super()
bytes() float() iter() print() tuple()
callable() format() len() property() type()
chr() frozenset() list() range() vars()
classmethod() getattr() locals() repr() zip()
compile() globals() map() reversed() __import__()
complex() hasattr() max() round()
delattr() hash() memoryview() set()
本文将这68个内置函数综合整理为12大类，正在学习Python基础的读者一定不要错过，建议收藏学习！
和数字相关 1. 数据类型
bool : 布尔型(True,False)
int : 整型(整数)
float : 浮点型(小数)
complex : 复数
2. 进制转换
bin() 将给的参数转换成二进制
otc() 将给的参数转换成八进制
hex() 将给的参数转换成十六进制
print(bin(10)) # 二进制:0b1010
print(hex(10)) # 十六进制:0xa
print(oct(10)) # 八进制:0o12
3. 数学运算
abs() 返回绝对值
divmode() 返回商和余数
round() 四舍五入
pow(a, b) 求a的b次幂, 如果有三个参数. 则求完次幂后对第三个数取余
sum() 求和
min() 求最小值
max() 求最大值
print(abs(-2)) # 绝对值:2
print(divmod(20,3)) # 求商和余数:(6,2)
print(round(4.50)) # 五舍六入:4
print(round(4.51)) #5
print(pow(10,2,3)) # 如果给了第三个参数. 表示最后取余:1
print(sum([1,2,3,4,5,6,7,8,9,10])) # 求和:55
print(min(5,3,9,12,7,2)) #求最小值:2
print(max(7,3,15,9,4,13)) #求最大值:15
和数据结构相关 1. 序列
（1）列表和元组
list() 将一个可迭代对象转换成列表
tuple() 将一个可迭代对象转换成元组
print(list((1,2,3,4,5,6))) #[1, 2, 3, 4, 5, 6]
print(tuple([1,2,3,4,5,6])) #(1, 2, 3, 4, 5, 6)
（2）相关内置函数
reversed() 将一个序列翻转, 返回翻转序列的迭代器
slice() 列表的切片
lst = "你好啊"
it = reversed(lst) # 不会改变原列表. 返回一个迭代器, 设计上的一个规则
print(list(it)) #['啊', '好', '你']
lst = [1, 2, 3, 4, 5, 6, 7]
print(lst[1:3:1]) #[2,3]
s = slice(1, 3, 1) # 切片用的
print(lst[s]) #[2,3]
（3）字符串
str() 将数据转化成字符串
print(str(123)+'456') #123456
format() 与具体数据相关, 用于计算各种小数, 精算等.
s = "hello world!"
print(format(s, "^20")) #剧中
print(format(s, "20")) #左对齐
print(format(s, "20")) #右对齐
# hello world!
# hello world!
# hello world!
print(format(3, 'b' )) # 二进制:11
print(format(97, 'c' )) # 转换成unicode字符:a
print(format(11, 'd' )) # ⼗进制:11
print(format(11, 'o' )) # 八进制:13
print(format(11, 'x' )) # 十六进制(⼩写字母):b
print(format(11, 'X' )) # 十六进制(大写字母):B
print(format(11, 'n' )) # 和d⼀样:11
print(format(11)) # 和d⼀样:11
print(format(123456789, 'e' )) # 科学计数法. 默认保留6位小数:1.234568e+08
print(format(123456789, '0.2e' )) # 科学计数法. 保留2位小数(小写):1.23e+08
print(format(123456789, '0.2E' )) # 科学计数法. 保留2位小数(大写):1.23E+08
print(format(1.23456789, 'f' )) # 小数点计数法. 保留6位小数:1.234568
print(format(1.23456789, '0.2f' )) # 小数点计数法. 保留2位小数:1.23
print(format(1.23456789, '0.10f')) # 小数点计数法. 保留10位小数:1.2345678900
print(format(1.23456789e+3, 'F')) # 小数点计数法. 很大的时候输出INF:1234.567890
bytes() 把字符串转化成bytes类型
bs = bytes("今天吃饭了吗", encoding="utf-8")
print(bs) #b'\xe4\xbb\x8a\xe5\xa4\xa9\xe5\x90\x83\xe9\xa5\xad\xe4\xba\x86\xe5\x90\x97'
bytearray() 返回一个新字节数组. 这个数字的元素是可变的, 并且每个元素的值得范围是[0,256)
ret = bytearray("alex" ,encoding ='utf-8')
print(ret[0]) #97
print(ret) #bytearray(b'alex')
ret[0] = 65 #把65的位置A赋值给ret[0]
print(str(ret)) #bytearray(b'Alex')
ord() 输入字符找带字符编码的位置
chr() 输入位置数字找出对应的字符
ascii() 是ascii码中的返回该值 不是就返回u
print(ord('a')) # 字母a在编码表中的码位:97
print(ord('中')) # '中'字在编码表中的位置:20013
print(chr(65)) # 已知码位,求字符是什么:A
print(chr(19999)) #丢
for i in range(65536): #打印出0到65535的字符
print(chr(i), end=" ")
print(ascii("@")) #'@'
repr() 返回一个对象的string形式
s = "今天\n吃了%s顿\t饭" % 3
print(s)#今天# 吃了3顿 饭
print(repr(s)) # 原样输出,过滤掉转义字符 \n \t \r 不管百分号%
#'今天\n吃了3顿\t饭'
2. 数据集合
字典：dict 创建一个字典
集合：set 创建一个集合
frozenset() 创建一个冻结的集合，冻结的集合不能进行添加和删除操作。
3. 相关内置函数
len() 返回一个对象中的元素的个数
sorted() 对可迭代对象进行排序操作 (lamda)
语法：sorted(Iterable, key=函数(排序规则), reverse=False)
Iterable: 可迭代对象
key: 排序规则(排序函数), 在sorted内部会将可迭代对象中的每一个元素传递给这个函数的参数. 根据函数运算的结果进行排序
reverse: 是否是倒叙. True: 倒叙, False: 正序
lst = [5,7,6,12,1,13,9,18,5]
lst.sort() # sort是list里面的一个方法
print(lst) #[1, 5, 5, 6, 7, 9, 12, 13, 18]
ll = sorted(lst) # 内置函数. 返回给你一个新列表 新列表是被排序的
print(ll) #[1, 5, 5, 6, 7, 9, 12, 13, 18]
l2 = sorted(lst,reverse=True) #倒序
print(l2) #[18, 13, 12, 9, 7, 6, 5, 5, 1]
#根据字符串长度给列表排序
lst = ['one', 'two', 'three', 'four', 'five', 'six']
def f(s):
return len(s)
l1 = sorted(lst, key=f, )
print(l1) #['one', 'two', 'six', 'four', 'five', 'three']
enumerate() 获取集合的枚举对象
lst = ['one','two','three','four','five']
for index, el in enumerate(lst,1): # 把索引和元素一起获取,索引默认从0开始. 可以更改
print(index)
print(el)
# 1
# one
# 2
# two
# 3
# three
# 4
# four
# 5
# five
all() 可迭代对象中全部是True, 结果才是True
any() 可迭代对象中有一个是True, 结果就是True
print(all([1,'hello',True,9])) #True
print(any([0,0,0,False,1,'good'])) #True
zip() 函数用于将可迭代的对象作为参数, 将对象中对应的元素打包成一个元组, 然后返回由这些元组组成的列表. 如果各个迭代器的元素个数不一致, 则返回列表长度与最短的对象相同
lst1 = [1, 2, 3, 4, 5, 6]
lst2 = ['醉乡民谣', '驴得水', '放牛班的春天', '美丽人生', '辩护人', '被嫌弃的松子的一生']
lst3 = ['美国', '中国', '法国', '意大利', '韩国', '日本']
print(zip(lst1, lst1, lst3)) #
for el in zip(lst1, lst2, lst3):
print(el)
# (1, '醉乡民谣', '美国')
# (2, '驴得水', '中国')
# (3, '放牛班的春天', '法国')
# (4, '美丽人生', '意大利')
# (5, '辩护人', '韩国')
# (6, '被嫌弃的松子的一生', '日本')
fiter() 过滤 (lamda)
语法：fiter(function. Iterable)
function: 用来筛选的函数. 在filter中会自动的把iterable中的元素传递给function. 然后根据function返回的True或者False来判断是否保留留此项数据 , Iterable: 可迭代对象
搜索公众号顶级架构师后台回复“面试”，送你一份惊喜礼包。
def func(i): # 判断奇数
return i % 2 == 1
lst = [1,2,3,4,5,6,7,8,9]
l1 = filter(func, lst) #l1是迭代器
print(l1) #
print(list(l1)) #[1, 3, 5, 7, 9]
map() 会根据提供的函数对指定序列列做映射(lamda)
语法 : map(function, iterable)
可以对可迭代对象中的每一个元素进行映射. 分别去执行 function
def f(i): return i
lst = [1,2,3,4,5,6,7,]
it = map(f, lst) # 把可迭代对象中的每一个元素传递给前面的函数进行处理. 处理的结果会返回成迭代器print(list(it)) #[1, 2, 3, 4, 5, 6, 7]
和作用域相关
locals() 返回当前作用域中的名字
globals() 返回全局作用域中的名字
def func():
a = 10
print(locals()) # 当前作用域中的内容
print(globals()) # 全局作用域中的内容
print("今天内容很多")
func()
# {'a': 10}
# {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__':
# _frozen_importlib_external.SourceFileLoader object at 0x0000026F8D566080,
# '__spec__': None, '__annotations__': {}, '__builtins__':
# (built-in), '__file__': 'D:/pycharm/练习/week03/new14.py', '__cached__': None,
# 'func': }
# 今天内容很多
和迭代器生成器相关
range() 生成数据
next() 迭代器向下执行一次, 内部实际使⽤用了__ next__()⽅方法返回迭代器的下一个项目
iter() 获取迭代器, 内部实际使用的是__ iter__()⽅方法来获取迭代器
for i in range(15,-1,-5):
print(i)
# 15
# 10
# 5
# 0
lst = [1,2,3,4,5]
it = iter(lst) # __iter__()获得迭代器
print(it.__next__()) #1
print(next(it)) #2 __next__()
print(next(it)) #3
print(next(it)) #4
字符串类型代码的执行
eval() 执行字符串类型的代码. 并返回最终结果
exec() 执行字符串类型的代码
compile() 将字符串类型的代码编码. 代码对象能够通过exec语句来执行或者eval()进行求值
s1 = input("请输入a+b:") #输入:8+9
print(eval(s1)) # 17 可以动态的执行代码. 代码必须有返回值
s2 = "for i in range(5): print(i)"
a = exec(s2) # exec 执行代码不返回任何内容
# 0
# 1
# 2
# 3
# 4
print(a) #None
# 动态执行代码
exec("""
def func():
print(" 我是周杰伦")
""" )
func() #我是周杰伦
code1 = "for i in range(3): print(i)"
com = compile(code1, "", mode="exec") # compile并不会执行你的代码.只是编译
exec(com) # 执行编译的结果
# 0
# 1
# 2
code2 = "5+6+7"
com2 = compile(code2, "", mode="eval")
print(eval(com2)) # 18
code3 = "name = input('请输入你的名字:')" #输入:hello
com3 = compile(code3, "", mode="single")
exec(com3)
print(name) #hello
输入输出
print() : 打印输出
input() : 获取用户输出的内容
print("hello", "world", sep="*", end="@") # sep:打印出的内容用什么连接,end:以什么为结尾
#hello*world@
内存相关
hash() : 获取到对象的哈希值(int, str, bool, tuple). hash算法:(1) 目的是唯一性 (2) dict 查找效率非常高, hash表.用空间换的时间 比较耗费内存
s = 'alex'print(hash(s)) #-168324845050430382lst = [1, 2, 3, 4, 5]print(hash(lst)) #报错,列表是不可哈希的 id() : 获取到对象的内存地址s = 'alex'print(id(s)) #2278345368944
文件操作相关
open() : 用于打开一个文件, 创建一个文件句柄
f = open('file',mode='r',encoding='utf-8')
f.read()
f.close()
模块相关
__ import__() : 用于动态加载类和函数
# 让用户输入一个要导入的模块
import os
name = input("请输入你要导入的模块:")
__import__(name) # 可以动态导入模块
帮 助
help() : 函数用于查看函数或模块用途的详细说明
print(help(str)) #查看字符串的用途
调用相关
callable() : 用于检查一个对象是否是可调用的. 如果返回True, object有可能调用失败, 但如果返回False. 那调用绝对不会成功
a = 10
print(callable(a)) #False 变量a不能被调用
def f():
print("hello")
print(callable(f)) # True 函数是可以被调用的
查看内置属性
dir() : 查看对象的内置属性, 访问的是对象中的__dir__()方法
print(dir(tuple)) #查看元组的方法
你还有什么想要补充的吗？
免责声明：本文内容来源于网络，文章版权归原作者所有，意在传播相关技术知识行业趋势，供大家学习交流，若涉及作品版权问题，请联系删除或授权事宜。
技术君个人微信
添加技术君个人微信即送一份惊喜大礼包
→ 技术资料共享
→ 技术交流社群
--END--
往日热文：
Python程序员深度学习的“四大名著”：
这四本书着实很不错！我们都知道现在机器学习、深度学习的资料太多了，面对海量资源，往往陷入到“无从下手”的困惑出境。而且并非所有的书籍都是优质资源，浪费大量的时间是得不偿失的。给大家推荐这几本好书并做简单介绍。
获得方式：
2.后台回复关键词：名著
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几种冷门但好用的函数，更多内容以后会陆陆续续更新~