平常在使用Python的过程中，难免会需要用到各种内置函数或者自己写的函数，掌握内置函数能够帮助我们更好地进行开发，下面就介绍一下Python3的内置函数
1.abs()
绝对值或复数的模
示例
print(abs(-17))
运行结果
17
=================================================================================
2.all()
接受一个迭代器，如果迭代器的所有元素都为真，那么返回True，否则返回False
示例
print(all([1,2,3,4,5]))
print(all([0,1,2,3,4]))
运行结果
True
True
=================================================================================
3.all()
接受一个迭代器，如果迭代器里有一个元素为真，那么返回True，否则返回False
示例
print(any([0,0,0,1]))
print(any([0,0,0,0]))
运行结果
True
False
=================================================================================
4.ascii()
返回任何对象（字符串，元组，列表等）的可读版本，用转义字符替换所有非ASCII字符
示例
print(ascii("Ståle"))
运行结果
St\xe5le
=================================================================================
5.bin()
将十进制转换为二进制
示例
print(bin(35))
运行结果
0b100011
=================================================================================
6.oct()
将十进制转换为八进制
示例
print(oct(10))
运行结果
0o12
=================================================================================
7.hex()
将十进制转换为十六进制
示例
print(hex(15))
运行结果
0xf
=================================================================================
8.bool()
测试一个对象是True, 还是False
示例
print(bool([0,0,0]))
print(bool([0]))
print(bool([1]))
print(bool([]))
print(bool(['a']))
运行结果
True
True
True
False
True
=================================================================================
9.bytes()
将一个字符串转换成字节类型
示例
string = "test"
print(bytes(string,encoding="utf-8"))
运行结果
b'test'
=================================================================================
10.str()
将字符类型、数值类型等转换为字符串类型
示例
integ = 10
print(type(integ))
integ = str(integ)
print(type(integ))
运行结果
int
str
=================================================================================
11.callable()
判断对象是否可以被调用，能被调用的对象就是一个callable 对象，比如函数 str, int 等都是可被调用的
示例
print(callable(int))
print(callable(str))
class struts():
def __init__(self,id,name):
self.id = id
self.name = name
def __repr__(self):
return "id="+self.id,"name="+self.name
print(callable(struts))
运行结果
True
True
True
=================================================================================
12.chr()
查看十进制整数对应的ASCII字符
示例
print(chr(53))#5
运行结果
5
=================================================================================
13.ord()
查看某个ascii对应的十进制数
示例
print(ord("5"))
运行结果
53
=================================================================================
14.classmethod()
classmethod 修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等。
示例
class struts():
def __init__(self,id,name):
self.id = id
self.name = name
def __repr__(self):
return "id="+self.id,"name="+self.name
@classmethod
def f(cls):
print(cls)
运行结果（结果为空）
=================================================================================
15.compile()
将字符串编译成python 能识别或可以执行的代码，也可以将文字读成字符串再编译。
示例
string = "test"
print(string)
string = (string,"compile","exec")
print(string)
运行结果
test
('test', 'compile', 'exec')
=================================================================================
16.complex()
创建一个复数
示例
print(complex(1,2))
运行结果
(1+2j)
=================================================================================
17.delattr()
删除对象的属性
示例
class test():
a = 1
b = 2
print(test.a)
print(test.b)
delattr(test,"a")
print(test.a)#这里会报错，因为对象中的a属性已经被删除
print(test.b)
运行结果
1
2
报错信息：type object 'test' has no attribute 'a'
=================================================================================
18.dict()
创建字典
示例
print(dict(a="1",b="2"))
print(dict(zip(["a","b","c"],[1,2,"c"])))
print(dict([("a","1"),("b","2")]))
运行结果
{'a': '1', 'b': '2'}
{'a': 1, 'b': 2, 'c': 'c'}
{'a': '1', 'b': '2'}
=================================================================================
19.dir()
不带参数时返回当前范围内的变量，方法和定义的类型列表；带参数时返回参数的属性，方法列表。
示例
class test():
a = "1"
b = "2"
class test1():
c = "3"
print(dir(test))
运行结果
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__',
'__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'a', 'b', 'test1']
=================================================================================
20.divmod()
分别取商和余数
示例
print(divmod(10,3))
运行结果
(3,1)
=================================================================================
21.enumerate()
返回一个可以枚举的对象，该对象的next()方法将返回一个元组。
示例
string = ["a","b","c"]
for x,y in enumerate(string,1):
print(x,y)
string = ["a","b","c"]
for x,y in enumerate(string,10):
print(x,y)
运行结果
1 a
2 b
3 c
10 a
11 b
12 c
=================================================================================
22.eval()
将字符串str 当成有效的表达式来求值并返回计算结果取出字符串中内容，静态执行
示例
string = "1+2+3"
print(eval(string))
运行结果
6
=================================================================================
23.exec()
动态执行字符串，返回值永远为None
示例
x = 10
y = 20
string = 'print(x+y)'
print(exec(string))
运行结果
30,None
=================================================================================
24.filter()
对于可迭代对象的过滤器，过滤掉不符合条件的元素
示例1-过滤掉无内容的字符串
listing = [1,2,"",4,"5"," "]
print(list(filter(None,listing)))#None会过滤掉'' 而不是过滤掉空字符串
运行结果
[1, 2, 4, '5', ' ']
示例2-过滤掉不是偶数的数
def is_oushu(x):
return x%2==0
new_list=list(filter(is_oushu,list(range(1,11))))
print(new_list)
运行结果
[2, 4, 6, 8, 10]
示例3-过滤列表内容不是2的元素
a=[1,2,3,4,5,6,2,2,2,]
print(list(filter(lambda x:x!=2,a)))
运行结果
[1, 3, 4, 5, 6]
=================================================================================
25.float()
用于将整数和字符串转换成浮点数
示例
print(float(1))
print(float(112.0))
print(float('123'))
print(float(True))
print(float(False))
运行结果
1.0
112.0
123.0
1.0
0.0
=================================================================================
26.format()
函数可以快速处理各种字符串
示例1-通过索引输出结果
print('{0},{2},{1}'.format('test',20,111))
print ('{},{}'.format('test',20))
print ('{1},{0},{1}'.format('test',20))
运行结果
test,111,20
test,20
20,test,20
示例2-通过关键字输出结果
print('{name},{age}'.format(name='test',age=20))
class Person:
def __init__(self,name,age):
self.name = name
self.age = age
def __str__(self):
return 'This guy is {self.name},is {self.age} old'.format(self=self)
print (str(Person('chuhao',18)))
运行结果
test,20
This guy is chuhao,is 18 old
示例3-通过映射list输出结果
a_list = ['chuhao',20,'china']
print ('my name is {0[0]},from {0[2]},age is {0[1]}'.format(a_list))
运行结果
my name is chuhao,from china,age is 20
示例4-通过映射dict输出结果
b_dict = {'name':'chuhao','age':20,'province':'bejing'}
print ('my name is {name}, age is {age},from {province}'.format(**b_dict))
运行结果
my name is chuhao, age is 20,from beijing
示例5-填充与对齐
print ('{:>8}'.format('189'))#输出到八位数，不足部分使用空格填充
print ('{:0>8}'.format('189'))#输出到八位数，不足部分使用0填充
print ('{:a>8}'.format('189'))#输出到八位数，不足部分使用a填充
运行结果
189
00000189
aaaaa189
示例6-精度与类型f
print ('{:.2f}'.format(321.33345))#保留两位小数点
运行结果
321.33
示例7-用来做金额的千位分隔符
print ('{:,}'.format(1234567890))
运行结果
1,234,567,890
示例8-其他类型
主要就是进制了，b、d、o、x分别是二进制、十进制、八进制、十六进制。
print ('{:b}'.format(18))
print ('{:d}'.format(18))
print ('{:o}'.format(18))
print ('{:x}'.format(18))
运行结果
10010
18
22
12
=================================================================================
27.frozenset()
返回一个冻结的集合，冻结后集合不能再添加或删除任何元素
示例
a=frozenset(range(10))
print(a)
b=frozenset('1a2b3c')
print(b)
运行结果
frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
frozenset({'b', '1', '3', 'c', '2', 'a'})
=================================================================================
28.getattr()
用于返回一个对象属性值
示例
class People():
sex='男'
obj=getattr(People,'sex')
print(obj)
运行结果
男
=================================================================================
29.globals()
函数会以字典类型返回当前位置的全部全局变量。
示例
def zero_promo():
return 0
def one_promo():
return 1
def two_promo():
return 2
def hello():
print("Hello")
if __name__ == '__main__':
promos = [name for name in globals()if name.endswith("_promo")]#输出带有_promo关键字的函数名
print(promos)
promos = [globals()[name] for name in globals() if name.endswith("_promo")]#调用函数
print(promos[0]())
运行结果
['zero_promo', 'one_promo', 'two_promo']
0
=================================================================================
30.hasattr()
用于判断是否包含对应的属性
示例
class People():
sex='男'
def __init__(self,name):
self.name=name
def peopleinfo(self):
print('欢迎%s访问'%self.name)
obj=People('zhangsan')
print(hasattr(People,'sex'))
print('sex'in People.__dict__)
print(hasattr(obj,'peopleinfo'))
运行结果
True
True
True
=================================================================================
31.hash()
用于获取取一个对象（字符串或者数值等）的哈希值
示例
print(hash('test'))
print(hash(1))
print(hash(str([1,2,3])))
print(hash(str(sorted({'1':1}))))
name1='正常程序代码'
name2='正常程序代码带病毒'
print(hash(name1))
print(hash(name2))
运行结果
2096959652#结果不固定
1
-1681135788#结果不固定
1339326551#结果不固定
543212275#结果不固定
2081298532#结果不固定
=================================================================================
32.id()
函数用于获取对象的内存地址
示例
string='zhangsan'
print(id(string))
b=1
print(id(b))
a=10.21
b=10.21
print(id(a))
print(id(b))
print(a is b)
print(a == b)
运行结果
53369176#动态分配id每一次会改变
1723939072
50306096
50306096
True
True
=================================================================================
33.input()
接受一个标准输入数据，返回为 string 类型
示例
a=input('请输入一个数:') #输入 10
print(a)
print(type(a))
#b=a+10 #报错 TypeError: must be str, not int
b=int(a)+10
print(b)
a=input('请输入一个字符串:') #输入 ltf1234
print(a)
print(a.split('1'))
运行结果
10
<class 'str'>
20
ltf1234
['ltf', '234']
=================================================================================
34.int()
将一个数字或base类型的字符串转换成整数。
示例
print(int(2.2))
运行结果
2
=================================================================================
35.isinstance()
函数来判断一个对象是否是一个已知的类型，类似 type()
示例
#isinstance() 会认为子类是一种父类类型，考虑继承关系。
#如果要判断两个类型是否相同推荐使用 isinstance()。
a=2
print(isinstance(a,int))
print(isinstance(a,str))
print(isinstance(a,(str,int,list)))
class A:
pass
class B(A):
pass
print(isinstance(A(), A) )
print(type(A()) == A )
print(isinstance(B(), A))
print(type(B()) == A)
运行结果
True
Fasle
True
True
True
True
Fasle
=================================================================================
36.issubclass()
判断参数 class 是否是类型参数 classinfo 的子类。
示例
class A:
pass
class B(A):
pass
class C(A):
pass
print(issubclass(B, A))
print(issubclass(C, A))
print(issubclass(C, B))
#class参数是classinfo的子类，并且classinfo是元组
print(issubclass(C, (A, object)))
print(issubclass(C, (A, int, object)))
print(issubclass(C, (int, str)))
print(issubclass(C, (int, str, type)))
运行结果
True
True
False
True
True
False
False
=================================================================================
37.iter()
生成迭代器
示例
lst = [1,2,3,4,5,6,7]
for i in iter(lst):
print(i)
class counter:
def __init__(self, _start, _end):
self.start = _start
self.end = _end
def get_next(self):
s = self.start
if(self.start < self.end):
self.start += 1
else:
raise StopIteration
return s
c = counter(1, 5)
iterator = iter(c.get_next, 3)
print(type(iterator))
for i in iterator:
print(i)
运行结果
#输出1,2,3,4,5,6,7
<class 'callable_iterator'>
1 2
=================================================================================
38.ord()
查看某个ascii对应的十进制数
示例
print(ord("5"))
运行结果
53
=================================================================================
39.lambda()
是指一类无需定义标识符（函数名）的函数或子程序,lambda 函数不能包含命令，包含的表达式不能超过一个。
lambda匿名函数的格式：冒号前是参数，可以有多个，用逗号隔开，冒号右边的为表达式
示例
def sum(x,y):
return x+y
print(sum(4,6))
f=lambda x,y:x+y
print(f(4,6))
#这俩个例子的效果是一样的，都是返回x+y
a = lambda x:x*x
print(a(4))
b=lambda x,y,z:x+y*z
print(b(1,2,3)) #返回x+y*z 即1+2*3=7
#2.方法结合使用
from functools import reduce
foo=[2, 18, 9, 22, 17, 24, 8, 12, 27]
print(list(filter(lambda x:x%3==0,foo))) #筛选x%3==0 的元素
print(list(map(lambda x:x*2+10,foo))) #遍历foo 每个元素乘2+10 再输出
print(reduce(lambda x,y:x+y,foo)) #返回每个元素相加的和
运行结果
10
10
16
7
[18, 9, 24, 12, 27]
[14, 46, 28, 54, 44, 58, 26, 34, 64]
139
=================================================================================
40.len()
方法返回对象（字符、列表、元组等）长度或项目个数
示例
str1='ltf1234'
print(len(str1))
list1=[1,2,3,4,5,6,7,8]
print(len(list1))
for i in range(len(list1)):
print(i)
dict = {'num':777,'name':"anne"}
print(len(dict))
运行结果
7
8
#list
0
1
2
3
4
5
6
7
#list
2
=================================================================================
41.list()
构造列表
示例
list=[1,2,3,4,5,6,7,8,9] #构建列表
print(list)
list.append(10) #列表追加 10
print(list)
list.insert(2,18) #在列表索引为2 的位置 插入 18 其余的后移
print(list)
print(list.count(1)) #输出 列表里1 的数量
list2=[-1,-2,-3]
list.extend(list2) #列表追加列表
print(list)
list.remove(1) #删除列表里的第一个1
print(list)
list.sort() #列表排序
print(list)
list.reverse() #列表反转
print(list)
print(max(list))
print(min(list))
运行结果
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[1, 2, 18, 3, 4, 5, 6, 7, 8, 9, 10]
1
[1, 2, 18, 3, 4, 5, 6, 7, 8, 9, 10, -1, -2, -3]
[2, 18, 3, 4, 5, 6, 7, 8, 9, 10, -1, -2, -3]
[-3, -2, -1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 18]
[18, 10, 9, 8, 7, 6, 5, 4, 3, 2, -1, -2, -3]
18
-3
=================================================================================
42.locals()
函数会以字典类型返回当前位置的全部局部变量。
示例
def test(string):
a = 1
print(locals())
test('a')
def foo(arg,a):
x = 100
y = 'test'
for i in range(0,3):
b = 100
print(locals())
foo(1,2)
运行结果
{'string': 'a', 'a': 1}
{'arg': 1, 'a': 2, 'x': 100, 'y': 'test', 'i': 2, 'b': 100}
=================================================================================
43.map()
map是 Python 内置的高阶函数，它接收一个函数 f 和一个 list，并通过把函数 f 依次作用在 list 的每个元素上，得到一个新的 list 并返回。
注意：map()函数不改变原有的 list，而是返回一个新的 list。
示例
list=[1,2,3,4,5,6,7,8,9]
def f(x):
return x*x
list1=map(f,list)
print(list1)
for i in list1:
print('新列表中的值：' + str(i))#(1*1,2*2,3*3，4*4,5*5,6*6,7*7,8*8,9*9)
def format_name(s):
s1=s[0:1].upper()+s[1:].lower()
return s1
names=['adam', 'LISA', 'barT']
for i in map(format_name,names):
print(i)
运行结果
新列表中的值：1
新列表中的值：4
新列表中的值：9
新列表中的值：16
新列表中的值：25
新列表中的值：36
新列表中的值：49
新列表中的值：64
新列表中的值：81
Adam
Lisa
Bart
=================================================================================
44.max()
方法返回给定参数的最大值，参数可以为序列
示例
print (max(80, 100, 1000))
print(max(1,2,3,4))
s = [
{'name': 'sumcet', 'age': 18},
{'name': 'bbu', 'age': 11}
]
a = max(s, key=lambda x: x['age'])
print(a)
运行结果
1000
4
{'name': 'sumcet', 'age': 18}
=================================================================================
45.min()
方法返回给定参数的最小值，参数可以为序列
示例
print (max(80, 100, 1000))
print(max(1,2,3,4))
s = [
{'name': 'sumcet', 'age': 18},
{'name': 'bbu', 'age': 11}
]
a = min(s, key=lambda x: x['age'])
print(a)
运行结果
80
1
{'name': 'bbu', 'age': 11}
=================================================================================
46.next()
返回迭代器的下一个项目
示例
obj = iter([1,2,3,4,5])
while True:
try:
x = next(obj)
print(x)
except:
break
a = iter('abcde')
for i in range(2):
print(next(a))
运行结果
1
2
3
4
5
a
b
=================================================================================
47.open()
打开一个文件，创建一个 file 对象，相关的方法才可以调用它进行读写
参数
| 打开方式 | 说明 |
|---|---|
| r | 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。 |
| rb | 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。 |
| r+ | 打开一个文件用于读写。文件指针将会放在文件的开头。 |
| rb+ | 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。 |
| w | 打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。 |
| wb | 以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。 |
| w+ | 打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。 |
| wb+ | 以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。 |
| a | 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 |
| ab | 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 |
| a+ | 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。 |
| ab+ | 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。 |
对象方法
| 打开方式 | 说明 |
|---|---|
| file.read([size]) | size 未指定则返回整个文件，如果文件大小 >2 倍内存则有问题，f.read()读到文件尾时返回""(空字串)。 |
| file.readline() | 返回一行。 |
| file.readlines([size]) | 返回包含size行的列表, size 未指定则返回全部行。 |
| for line in f: print line | 通过迭代器访问。 |
| f.write(“hello\n”) | 如果要写入字符串以外的数据,先将他转换为字符串。 |
| f.tell() | 返回一个整数,表示当前文件指针的位置(就是到文件头的比特数)。 |
| f.seek(偏移量,[起始位置]) | 用来移动文件指针。偏移量: 单位为比特，可正可负起始位置: 0 - 文件头, 默认值; 1 - 当前位置; 2 - 文件尾 |
| f.close() | 关闭文件 |
示例
f=open('fileopen.txt','r',encoding='utf-8')
print(f.read())
运行结果
#文件内容
1
2
3
4
5
6
=================================================================================
48.pow()
返回 xy（x的y次方） 的值
示例
import math # 导入 math 模块
print(math.pow(100, 2))
print(math.pow(100, -2))
print(math.pow(2, 4))
print(math.pow(3, 0))
运行结果
10000.0
0.0001
16.0
1.0
=================================================================================
49.property()
在新式类中返回属性值
示例
class Money(object):
def __init__(self):
self.__money = 0
# 使用装饰器对money进行装饰，那么会自动添加一个叫money的属性，当调用获取money的值时，调用装饰的方法
@property
def money(self):
return self.__money
# 使用装饰器对money进行装饰，当对money设置值时，调用装饰的方法
@money.setter
def money(self, value):
if isinstance(value, int):
self.__money = value
else:
print("error:不是整型数字")
a = Money()
print(a.money)
a.money = 100
print(a.money)
运行结果
0
100
=================================================================================
50.range()
函数可创建一个整数列表，一般用在 for 循环中
示例
print("输出 0-9")
for i in range(10):
print(i)
print("输出 0,2,4,6,8,10")
for i in range(0,11,2):
print(i)
print("输出 0,-3,-6,-9")
for i in range(0,-10,-3):
print(i)
print("输出 [5, 4, 3, 2, 1, 0, -1, -2, -3, -4]")
list=[]
for i in range(5,-5,-1):
list.append(i)
print(list)
print("依次输出字符")
for i in 'ahfgohiauf':
print(i)
运行结果
输出 0-9
0
1
2
3
4
5
6
7
8
9
输出 0,2,4,6,8,10
0
2
4
6
8
10
输出 0,-3,-6,-9
0
-3
-6
-9
输出 [5, 4, 3, 2, 1, 0, -1, -2, -3, -4]
[5, 4, 3, 2, 1, 0, -1, -2, -3, -4]
依次输出字符
a
h
f
g
o
h
i
a
u
f
=================================================================================
51.reduce()
函数会对参数序列中元素进行累积
示例
from functools import reduce
lst=[1,2,3,4,5,6]
def f(x,y):
return x+y
print(reduce(f,lst))#21
print(reduce(lambda x,y:x*y,lst))#运行过程为1*2*3*4*5*6=720
print(reduce(lambda x,y:x*y+1,lst))
"""
运算步骤：1*2+1=3
3*3+1=10
10*4+1=41
41*5+1=206
206*6+1=1237
"""
print(reduce(lambda x,y:x+y,lst,5))
"""
计算步骤：5+1=6
6+2=8
8+3=11
11+4=15
15+5=20
20+6=26
"""
运行结果
21
720
1237
26
=================================================================================
52.repr()
函数将对象转化为供解释器读取的形式，返回一个对象的 string 格式
示例
s='qwerasdf'
print(s)
print(repr(s))
运行结果
qwerasdf
'qwerasdf'
=================================================================================
53.reversed()
反转迭代器
示例
str='wasdqwer'
print(list(reversed(str)))
tuple=('r', 'e', 'w', 'q', 'd', 's', 'a', 'w')
print(list(reversed(tuple)))
seqRange = range(5, 9)
print(list(reversed(seqRange)))
seqList = [1, 2, 4, 3, 5]
print(list(reversed(seqList)))
a=[1,2,3,4,5,6]
b=reversed(a)
print(b)
print(list(b))
print(list(b))
运行结果
['r', 'e', 'w', 'q', 'd', 's', 'a', 'w']
['w', 'a', 's', 'd', 'q', 'w', 'e', 'r']
[8, 7, 6, 5]
[5, 3, 4, 2, 1]
<list_reverseiterator object at 0x0329D330>
[6, 5, 4, 3, 2, 1]
[]
=================================================================================
54.round()
方法返回浮点数x的四舍五入值
示例
print ("round(70.23456) : ", round(70.23456))
print ("round(80.264, 2) : ", round(80.264, 2))
print ("round(100.000056, 3) : ", round(100.000056, 3))
print ("round(-100.000056, 3) : ", round(-100.000056, 3))
运行结果
70
80.26
100.0
-100.0
=================================================================================
55.setattr()
设置属性值，该属性必须存在
示例
class People():
sex='男'
def __init__(self,name):
self.name=name
def peopleinfo(self):
print('欢迎%s访问'%self.name)
obj=People('zhangsan')
setattr(People,'x',123)#等同于 Peopel.x=123
print(People.x)
setattr(obj,'age',18)
print(obj.__dict__)
print(People.__dict__)
运行结果
123
{'name': 'zhangsan', 'age': 18}
{'__module__': '__main__', 'sex': '男', '__init__': <function People.__init__ at 0x033AE270>, 'peopleinfo': <function People.peopleinfo at 0x033AE2B8>, '__dict__': <attribute '__dict__' of 'People' objects>, '__weakref__': <attribute '__weakref__' of 'People' objects>, '__doc__': None, 'x': 123}
=================================================================================
56.set()
函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。
示例1-去重
a=set('www.baidu.com')
b=set('www.gogle.com')#重复的元素被删除 元素唯一 可以用来去重
print(a)#输出a去重结果
print(b)#输出b去重结果
print(a&b)#输出交集，即a跟b变量中重复的值
print(a|b)#输出并集，即a跟b变量合并，去掉重复的值
print(a-b)#输出差集，即a跟b变量对比，取出不重复的值
运行结果
{'o', 'i', 'm', 'a', 'b', 'w', 'd', 'u', 'c', '.'}
{'o', 'm', 'l', 'w', 'e', 'g', 'c', '.'}
{'o', 'm', 'w', 'c', '.'}
{'o', 'i', 'm', 'l', 'a', 'b', 'w', 'd', 'e', 'u', 'g', 'c', '.'}
{'i', 'a', 'b', 'd', 'u'}
示例2-比较
se = {11, 22, 33}
be = {22, 55}
temp1 = se.difference(be)#找到se中存在，be中不存在的集合，返回新值
print(temp1)
print(se)
temp2 = se.difference_update(be)#找到se中存在，be中不存在的集合，覆盖掉se
print(temp2)
print(se)
运行结果
{33, 11}
{33, 11, 22}
None
{33, 11}
示例3-删除
se = {11, 22, 33}
se.discard(11)
se.discard(44) # 移除不存的元素不会报错
print(se)
se = {11, 22, 33}
se.remove(11)
#se.remove(44)# 移除不存的元素会报错
print(se)
se = {11, 22, 33}# 移除末尾元素并把移除的元素赋给新值
temp = se.pop()
print(temp)
print(se)
运行结果
{33, 22}
{33, 22}
33
{11, 22}
示例4-取交集
se = {11, 22, 33}
be = {22, 55}
temp1 = se.intersection(be)#取交集，赋给新值
print(temp1)
print(se)
temp2 = se.intersection_update(be)#取交集并更新自己
print(temp2)
print(se)
运行结果
{22}
{33, 11, 22}
None
{22}
示例5-判断
se = {11, 22, 33}
be = {22}
print(se.isdisjoint(be)) #判断是否不存在交集（有交集False，无交集True）
print(se.issubset(be)) #判断se是否是be的子集合
print(se.issuperset(be)) #判断se是否是be的父集合
运行结果
False
False
True
示例6-合并
se = {11, 22, 33}
be = {22}
temp1 = se.symmetric_difference(be) # 合并不同项，并赋新值
print(temp1)
print(se)
temp2 = se.symmetric_difference_update(be) # 合并不同项，并更新自己
print(temp2)
print(se)
运行结果
{33, 11}
{33, 11, 22}
None
{33, 11}
示例7-取并集
se = {11, 22, 33}
be = {22,44,55}
temp=se.union(be) #取并集，并赋新值
print(se)
print(temp)
运行结果
{33, 11, 22}
{33, 22, 55, 11, 44}
示例8-更新
se = {11, 22, 33}
be = {22,44,55}
se.update(be) # 把se和be合并，得出的值覆盖se
print(se)
se.update([66, 77]) # 可增加迭代项
print(se)
运行结果
{33, 22, 55, 11, 44}
{33, 66, 22, 55, 11, 44, 77}
示例9-集合的转换
se = set(range(4))
li = list(se)
tu = tuple(se)
st = str(se)
print(li,type(li))
print(tu,type(tu))
print(st,type(st))
运行结果
[0, 1, 2, 3] <class 'list'>
[0, 1, 2, 3] <class 'tuple'>
[0, 1, 2, 3] <class 'str'>
=================================================================================
57.slice()
函数实现切片对象，主要用在切片操作函数里的参数传递
示例
myslice=slice(5) #设置一个 截取五个元素的切片
print(myslice)
arr=list(range(10))
print(arr)
print(arr[myslice])
print(arr[3:6])
运行结果
slice(None, 5, None)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 2, 3, 4]
[3, 4, 5]
=================================================================================
58.sorted()
函数对所有可迭代的对象进行排序操作。
示例
print(sorted([2,3,4,1,5,6]))
#另一个区别在于list.sort() 方法只为 list 定义。而 sorted() 函数可以接收任何的 iterable。
print(sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'}))
#利用key进行倒序排序
example_list = [5, 0, 6, 1, 2, 7, 3, 4]
result_list = sorted(example_list, key=lambda x: x*-1)
print(result_list)
#要进行反向排序，也通过传入第三个参数 reverse=True：
example_list = [5, 0, 6, 1, 2, 7, 3, 4]
result_list=sorted(example_list, reverse=True)
print(result_list)
#sorted 的应用，也可以通过 key 的值来进行数组/字典的排序，比如
array = [{"age":20,"name":"a"},{"age":25,"name":"b"},{"age":10,"name":"c"}]
array = sorted(array,key=lambda x:x["age"])
print(array)
运行结果
[1, 2, 3, 4, 5, 6]
[1, 2, 3, 4, 5]
[7, 6, 5, 4, 3, 2, 1, 0]
[7, 6, 5, 4, 3, 2, 1, 0]
[{'age': 10, 'name': 'c'}, {'age': 20, 'name': 'a'}, {'age': 25, 'name': 'b'}]
=================================================================================
59.staticmethod()
返回函数的静态方法。
示例
class C(object):
@staticmethod
def f():
print('hello world')
C.f() # 静态方法无需实例化
cobj = C()
cobj.f() # 也可以实例化后调用
class A(object):
def foo(self, x):
print("executing foo(%s,%s)" % (self, x))
print('self:', self)
@classmethod
def class_foo(cls, x):
print("executing class_foo(%s,%s)" % (cls, x))
print('cls:', cls)
@staticmethod
def static_foo(x):
print("executing static_foo(%s)" % x)
a = A()
print(a.foo)
print(a.class_foo)
print(a.static_foo)
运行结果
hello world
hello world
<bound method A.foo of <__main__.A object at 0x0313D2F0>>
<bound method A.class_foo of <class '__main__.A'>>
<function A.static_foo at 0x0349E198>
=================================================================================
60.str()
将对象转化为适于人阅读的形式。
示例
print(str(1))
print(type(str(1)))
print(str(b'\xe5\xbc\xa0\xe4\xb8\x89',encoding='utf-8'))
dict={'zhangsan':'zhang1234','lisi':'li1234'}
print(type(dict))
a=str(dict)
print(str(dict))
print(type(a))
运行结果
1
<class 'str'>
张三
<class 'dict'>
{'zhangsan': 'zhang1234', 'lisi': 'li1234'}
<class 'str'>
=================================================================================
61.sun()
对系列进行求和计算
示例
print(sum([0,1,2])) # 列表总和 3
print(sum((2,3,4),1)) # 元组计算总和后再加 1
print(sum([2,3,4,5,6],8)) # 列表计算总和后再加 8
a = list(range(1,11))
b = list(range(1,10))
c = sum([item for item in a if item in b])
print(c)
运行结果
3
10
28
45
=================================================================================
62.vars()
返回对象object的属性和属性值的字典对象
示例
class A:
a=1
__dict__ = 'ltf'
print(vars(A))
a=A()
print(vars(a))
print(a.__dict__)
运行结果
{'__module__': '__main__', 'a': 1, '__dict__': 'ltf', '__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None}
ltf
ltf
=================================================================================
63.zip()
接受任意多个可迭代对象作为参数,将对象中对应的元素打包成一个tuple,然后返回一个可迭代的zip对象
示例
#循环获取指定迭代器中的值
x=[1,2,3]
y=[4,5,6]
z=[7,8,9]
h=['a','b','c','d']
zip1=zip(x,y,z)
print(zip1)
for i in zip1:
print(i)
zip2=zip(x,y,h)
for i in zip2:
print(i)
#输出单个迭代器的值
zip3=zip(h)
for i in zip3:
print(i)
#输出多个迭代器结果
zip4=zip(h*3)
for i in zip4:
print(i)
l1=[[1,2,3],[4,5,6],[7,8,9]]
print(l1)
print([[j[i] for j in l1] for i in range(len(l1[0])) ])
zip5=zip(*l1)
for i in zip5:
print(i)
运行结果
#输出循环获取指定迭代器中的值
(1, 4, 7)
(2, 5, 8)
(3, 6, 9)
(1, 4, 'a')
(2, 5, 'b')
(3, 6, 'c')
#输出单个迭代器的值
('a',)
('b',)
('c',)
('d',)
#输出多个迭代器结果
('a',)
('b',)
('c',)
('d',)
('a',)
('b',)
('c',)
('d',)
('a',)
('b',)
('c',)
('d',)
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
[[1, 4, 7], [2, 5, 8], [3, 6, 9]]
(1, 4, 7)
(2, 5, 8)
(3, 6, 9)
=================================================================================
64__import__()
函数用于动态加载类和函数
示例
先定义两个模块mian.py和index.py，两个文件在同一目录下：
index.py
print ('index')
def sayHello():
print('hello index')
def sayHelloZhCn():
print('你好 index')
main.py
print ('main')
index = __import__('index')
dir(index)
index.sayHello()
index.sayHelloZhCn()
运行结果
main
index
hello index
你好 index
=================================================================================
65.type()
返回对象的类型
示例
print(type(1))
print(type("1"))
print(type(["a"]))
print(type({"a":"1"}))
运行结果
<class 'int'>
<class 'str'>
<class 'list'>
<class 'dict'>
=================================================================================
66.tuple()
将列表转换为元组
示例
string = (["a","b","c"])
print(type(string))
tupleing = tuple(string)
print(type(tupleing))
运行结果
<class 'list'>
<class 'tuple'>
=================================================================================
67.print()
打印输出
示例
print("test")
a = 1
b = 2
print(a,b)
print("a""b")
print("a","b")
print("a","b","c",sep=".")
运行结果
test
1 2
ab
a b
a.b.c
=================================================================================
68.super()
调用父类
示例
class A:
def add(self, x):
y = x+1
print(y)
class B(A):
def add(self, x):
super().add(x)
b = B()
b.add(2) # 3
class FooParent(object):
def __init__(self):
self.parent = 'I\'m the parent.'
print ('Parent')
def bar(self,message):
print ("%s from Parent" % message)
class FooChild(FooParent):
def __init__(self):
# super(FooChild,self) 首先找到 FooChild 的父类（就是类 FooParent），然后把类 FooChild 的对象转换为类 FooParent 的对象
super(FooChild,self).__init__()
print ('Child')
def bar(self,message):
super(FooChild, self).bar(message)
print ('Child bar fuction')
print (self.parent)
if __name__ == '__main__':
fooChild = FooChild()
fooChild.bar('HelloWorld')
运行结果
3
Parent
Child
HelloWorld from Parent
Child bar fuction
I'm the parent.
=================================================================================
69.bytearray()
返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256
示例
print(bytearray([1,2,3]))#bytearray(b'\x01\x02\x03')
print(bytearray("test",encoding="utf-8"))#bytearray(b'test')
运行结果
bytearray(b'\x01\x02\x03')
bytearray(b'test')
=================================================================================
70.memoryview()
返回给定参数的内存查看对象，内存查看对象，是指对支持缓冲区协议的数据进行包装，在不需要复制对象基础上允许Python代码访问。
示例
string = memoryview(bytearray("abcdefg","utf-8"))
print(string[0])
print(string[-7])
运行结果
ascii 97
97
来源：CSDN
作者：T_Snail_T
链接：https://blog.csdn.net/T_Snail_T/article/details/104042763