>>>dir(__builtins__) # 查看python自带的方法，返回的是一个列表
>>>bool('set' in dir(__builtins__)) # 查看某个方法是否只内置的，站在列表的角度思考
>>>__builtins__.set() # 查看某个方法是否是内置的，站在方法的角度去思考
>>>list1 = []
>>>list1.__dir__() # 查看这个实例有哪些方法，返回的是一个列表--> py -3 环境
# python内置方法63种
---------------------------------------------------------------------------------------------------
abs #返回数字的绝对值
>>>abs(-3)
3
---------------------------------------------------------------------------------------------------
all #用于判断给定的可迭代参数中的所有元素是否都为True(元素除了是 0、空、None、False,空序列 外都算 True)
>>> all([1,2,3,4])
True
>>> all((0,2,3))
False
---------------------------------------------------------------------------------------------------
any #用于判断给定的可迭代参数是否全部为 False，则返回 False(元素除了是 0、空、False、None，空序列外都算 TRUE)
>>> any([0,2,4])
True
>>> any((False,0,'',None))
False
---------------------------------------------------------------------------------------------------
bool # 判断括号里面内容的真假，返回True 或 False
0,False,空的数据结构：[],(),{},set([])，None，"",''
>>> bool('i' in 'hello')
False
---------------------------------------------------------------------------------------------------
bytes # 返回一个新的 bytes 对象 (utf8是可以处理中文的，而ascii是不能处理中文的)
>>> bytes('南北', 'utf8')
b'\xe5\x8d\x97\xe5\x8c\x97'
>>> bytes('hello', 'ascii')
b'hello'
>>> '南北'.encode('utf-8') # 这个和 bytes('南北', 'utf8')没什么区别
b'\xe5\x8d\x97\xe5\x8c\x97'
---------------------------------------------------------------------------------------------------
classmethod # 修饰符：修饰对应的函数不需要实例化，不需要self参数，但第一个参数必须是cls参数
class A():
bar = 'aaa'
def func1(self):
print(self.bar)
@classmethod
def func2(cls):
print(cls.bar)
# 调用：
a = A()
a.func1() #需要实例化才能调用
A.func2() #无需实例化就可以直接调用
---------------------------------------------------------------------------------------------------
property # 装饰函数后，可以像访问属性一样访问函数, 该函数不能有参数
>>> class A():
... @property
... def a(self):
... print('a')
... def b(self):
... print('b')
...
>>> A = A()
>>> A.b()
b
>>> A.a
a
---------------------------------------------------------------------------------------------------
complex # 创建复数
>>> complex(1,2)
(1+2j)
>>> complex(3)
(3+0j)
---------------------------------------------------------------------------------------------------
dict # 创建字典的函数
>>> dict(a=1, b=2, c=3)
{'a': 1, 'b': 2, 'c': 3}
---------------------------------------------------------------------------------------------------
dir # 函数不带参数时，返回当前范围内的属性，方法列表， 带参数时，返回参数的属性、方法列表
>>> dir([])
返回列表的所有属性和方法
---------------------------------------------------------------------------------------------------
divmod # 接收两个数字类型（非复数）参数，返回一个包含商和余数的元组(a // b, a % b)
>>> divmod(4,5)
(0, 4)
>>> divmod(8,-2)
(-4, 0)
---------------------------------------------------------------------------------------------------
enumerate # 将可遍历的数据对象组合为一个索引序列，同时列出数据下标和数据
# start参数是指定下标的起始位置
>>> list1 = ['a', 'b', 'c', 'd']
>>> enumerate(list1)
<enumerate object at 0x02CFFB20>
>>> list(enumerate(list1))
[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')]
>>> dict(enumerate(list1, start=1))
{1: 'a', 2: 'b', 3: 'c', 4: 'd'}
---------------------------------------------------------------------------------------------------
zip # 创建多维序列
>>> list1 = [1,2,3]
>>> list2 = [4,5,6]
>>> list3 = [7,8,9,0]
>>> zip(list1)
<zip object at 0x011D7210>
>>> list(zip(list1))
[(1,), (2,), (3,)]
>>> zip(list1, list2, list3)
<zip object at 0x011D7288>
>>> list(zip(list1, list2, list3))
[(1, 4, 7), (2, 5, 8), (3, 6, 9)]
>>> list1 = ['aa', 'bb', 'cc']
>>> list2 = ['11', '33', '55']
>>> dict(zip(list1, list2))
{'aa': '11', 'bb': '33', 'cc': '55'}
---------------------------------------------------------------------------------------------------
filter # 用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象
>>> def is_odd(n):
... return n % 2 == 1
...
>>> list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> a = filter(is_odd, list1)
>>> a
<filter object at 0x03569B90>
>>> list(a)
[1, 3, 5, 7, 9]
>>> list(filter(lambda x:x%2==1, list1))
[1, 3, 5, 7, 9]
---------------------------------------------------------------------------------------------------
map # 根据提供的函数对指定序列做映射
>>>def square(x) : # 计算平方数
... return x ** 2
...
>>> list1
[0, 1, 2, 3, 4]
>>>list( map(lambda x:x>2, list1))
[False, False, False, True, True]
>>> list(map(square, [1,2,3,4,5])) # 计算列表各个元素的平方
[1, 4, 9, 16, 25]
>>> list(map(lambda x: x ** 2, [1, 2, 3, 4, 5])) # 使用 lambda 匿名函数
[1, 4, 9, 16, 25]
>>> list(map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10]))
[3, 7, 11, 15, 19]
>>> list1 = ['1','2','3']
>>> list(map(int, list1))
[1, 2, 3]
---------------------------------------------------------------------------------------------------
eval # 用来执行一个字符串表达式，并返回表达式的值
>>> eval('3'+'4')
34
>>> eval('3+4')
7
>>> eval('pow(3,4)')
81
---------------------------------------------------------------------------------------------------
exec # exec 执行代码块，但是没有返回值
---------------------------------------------------------------------------------------------------
float # 用于将整数和字符串转换成浮点数
>>> float(12)
12.0
>>> float('12')
12.0
---------------------------------------------------------------------------------------------------
format # 格式化
>>> "{} {}".format("hello", "world") # 不指定按默认的顺序输出
'hello world'
>>> "{1} {0} {1}".format("hello", "world")
'world hello world'
---------------------------------------------------------------------------------------------------
frozenset # 返回一个冻结的集合，冻结后集合不能再添加、删除、修改任何元素。
>>> list2
['11', '33', '55']
>>> list3
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> a = frozenset(list3)
>>> a
frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10})
>>> b = frozenset(list2)
>>> b
frozenset({'33', '55', '11'})
>>> a+b
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'frozenset' and 'frozenset'
---------------------------------------------------------------------------------------------------
setattr # 用于设置类属性值，该属性不一定是存在的，对应函数 getattr()：用于获取/查询属性值。
>>>class A(object):
... bar = 1
...
>>> a = A()
>>> getattr(a, 'bar') # 获取属性 bar 值
1
>>> setattr(a, 'bar', 5) # 设置属性 bar 值， 如果存在则修改
>>> a.bar
5
>>> setattr(a, "age", 18)
>>>a.age
18
---------------------------------------------------------------------------------------------------
getattr # 用于返回一个对象属性值
>>>class A(object):
... bar = 1
...
>>> getattr(A, 'bar') # 直接通过类获取
1
>>> a = A()
>>> getattr(a, 'bar') # 也可以通过实例 获取属性 bar 值
1
>>> getattr(a, 'bar2', 3) # 属性 bar2 不存在，会报错，但设置了默认值就会返回默认值
3
---------------------------------------------------------------------------------------------------
hasattr # 用于判断对象是否包含对应的属性
>>> class A():
... a ='aaa'
... b ='bbb'
...
>>> hasattr(A, 'a')
True
>>> hasattr(A, 'c')
False
---------------------------------------------------------------------------------------------------
delattr # 删除属性 相等于： del A.c
class A():
a = 'hello'
b = 'python'
c = 'world'
delatter(A, 'c')
---------------------------------------------------------------------------------------------------
globals # 以字典类型返回当前位置的全部全局变量
在函数里面 global 用来指定全局变量(少个S)
>>>globals()
---------------------------------------------------------------------------------------------------
locals # 以字典类型返回当前位置的全部局部变量
>>> def func(a):
... z=1
... print(locals())
...
>>> func(2)
{'z': 1, 'a': 2}
---------------------------------------------------------------------------------------------------
id # 用于获取对象的内存地址
>>> a ='aaa'
>>> id(a)
56007584
---------------------------------------------------------------------------------------------------
input # 键盘输入，以字符串返回
>>> input()
1212
'1212'
---------------------------------------------------------------------------------------------------
int # 用于将一个字符串或数字转换为整型
>>> int('1233')
1233
>>> int() # 不传参默认为0
0
>>> int(3.6)
3
---------------------------------------------------------------------------------------------------
isinstance # 函数来判断一个对象是否是一个已知的类型,第二个参数可以传序列类型
>>> a = 'aa'
>>> isinstance(a, int)
False
>>> isinstance(a, str)
True
_PROTECTED_TYPES = (type(None), int, float, Decimal, datetime.datetime, datetime.date,datetime.time,)
isinstance(obj, _PROTECTED_TYPES)
---------------------------------------------------------------------------------------------------
iter # list、tuple等都是可迭代对象，我们可以通过iter()函数获取这些可迭代对象的迭代器。然后我们可以对获取到的迭代器不断使⽤next()函数来获取下⼀条数据。for循环就是通过自动调用next()方法来实现的
>>> list1 = [1,2,3]
>>> iter(list1)
<list_iterator object at 0x03569B30>
>>> a = iter(list1)
>>> next(a)
1
>>> next(a)
2
>>> next(a)
3
>>> next(a) # 当超出范围是就会报错
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration
---------------------------------------------------------------------------------------------------
len # 返回对象（字符、列表、元组等）长度
>>> list1 = [1,2,3]
>>> len(list1)
3
>>> len(str1)
5
---------------------------------------------------------------------------------------------------
list # 将元组或字符串转换为列表
>>> list("hello")
['h', 'e', 'l', 'l', 'o']
>>> list((1,2,3))
[1, 2, 3]
---------------------------------------------------------------------------------------------------
max # 方法返回给定参数的最大值，参数可以为序列
>>> max([1,2,3,4])
4
>>> max([1,1,1],[2], [3,4]) # 当序列之间比较是依次从第一个开始比，如果第一个一样大那么比较第二个。。。。
[3, 4]
>>> max([1,1,1],[2], [3,4],key=len) # 加上参数 key=len 比长度
[1, 1, 1]
>>> max({'a':1, 'b':2})
'b'
---------------------------------------------------------------------------------------------------
min # 方法返回给定参数的最小值，参数可以为序列
>>> min([1,2,3,4])
1
>>> min([1,1,1], [2], [3,4]) # 当序列之间比较是依次从第一个开始比，如果第一个一样大那么比较第二个。。。。
[1, 1, 1]
>>> min([1,1,1], [2], [3,4], key=len) # 加上参数 key=len 比长度
[2]
>>> min({'a':1, 'b':2})
'a'
---------------------------------------------------------------------------------------------------
next # 迭代器的下一个项目
>>> a =iter([1, 2, 3, 4, 5])
>>> next(a)
1
>>> next(a)
2
>>> next(a)
---------------------------------------------------------------------------------------------------
open # 用于打开一个文件，进行读写操作 （这个在文件的读写会详细阐述）
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
file: 必需，文件路径（相对或者绝对路径）。
mode: 可选，文件打开模式
buffering: 设置缓冲
encoding: 一般使用utf8
errors: 报错级别
newline: 区分换行符
closefd: 传入的file参数类型
---------------------------------------------------------------------------------------------------
pow # 幂运算 等价于 x**y
>>> pow(2,3)
8
>>> 2**3
8
---------------------------------------------------------------------------------------------------
print # 输出:注意print输出省去了引号
>>> 'aaa'
'aaa'
>>> print('aaa')
aaa
# print(*objects, sep=' ', end='\n', file=sys.stdout)
objects -- 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。
sep -- 用来间隔多个对象，默认值是一个空格。
end -- 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符串。
file -- 要写入的文件对象。
>>> print("aaa""bbb")
aaabbb
>>> print("aaa","bbb")
aaa bbb
>>> print("www","baidu","com",sep=".") # 设置间隔符
www.baidu.com
---------------------------------------------------------------------------------------------------
range # 可创建一个整数列表,但并没有返回列表，返回的是迭代对象，所以输出需要序列化
range(start, stop，step)
start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;
stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)
>>>list(range(10)) # 从 0 开始到 10
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(range(1, 11)) # 从 1 开始到 11
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> list(range(0, 30, 5)) # 步长为 5
[0, 5, 10, 15, 20, 25]
---------------------------------------------------------------------------------------------------
repr # 一个对象的 string 格式 和 ascii类似
>>> repr("hello")
"'hello'"
>>> repr([1,2,3])
'[1, 2, 3]'
---------------------------------------------------------------------------------------------------
reversed # 返回一个反排的迭代器。
>>> reversed(range(5))
<range_iterator object at 0x0105FE18>
>>> list(reversed(range(5)))
[4, 3, 2, 1, 0]
---------------------------------------------------------------------------------------------------
round # 回浮点数x的五舍六入值
>>> round(0.5)
0
>>> round(0.6)
1
---------------------------------------------------------------------------------------------------
set # 把其他序列变为集合
>>> set('hello')
{'o', 'e', 'l', 'h'}
---------------------------------------------------------------------------------------------------
slice # 截取， 跟切片是一个意思， 都是写在[]这个里面，且效果一样
>>> my_slice = slice(5) # 截取对象前5个值
>>> list1 = list(range(10))
>>> list1
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list1[my_slice]
[0, 1, 2, 3, 4]
--------------------------------------------------------------------------------------------------
sorted # 对所有可迭代的对象进行排序操作 sort 只是对列表进行排序
>>>a=[5,2,3,1,4]
>>> a.sort()
>>> a
[1,2,3,4,5]
sorted(iterable, key=None, reverse=False)
iterable -- 可迭代对象。
key -- 主要是用来指定比较的元素
reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
>>>example_list = [5, 0, 6, 1, 2, 7, 3, 4]
>>> sorted(example_list, reverse=True)
[7, 6, 5, 4, 3, 2, 1, 0]
>>> a = [(1,44),(2,33), (3,22)]
>>> sorted(a, key=lambda x:x[1], reverse=True)
[(1, 44), (2, 33), (3, 22)]
>>> sorted(a, key=lambda x:x[1], reverse=True) # 按第二个数倒序
[(1, 44), (2, 33), (3, 22)]
>>> sorted(a, key=lambda x:x[1], reverse=False) # 按第二个数升序
[(3, 22), (2, 33), (1, 44)]
>>> array = [{"age":20,"name":"a"},{"age":25,"name":"b"},{"age":10,"name":"c"}]
>>> array = sorted(array,key=lambda x:x["age"])
>>> print(array)
---------------------------------------------------------------------------------------------------
str # 返回一个对象的string格式
>>> str([1,2,3,4])
'[1, 2, 3, 4]'
---------------------------------------------------------------------------------------------------
sum # 对序列进行求和计算
>>> sum((1,2,3))
6
>>> sum([1,2,3,4],5) # 列表计算总和后再加 5
15
---------------------------------------------------------------------------------------------------
super # 继承父类的一个方法（后面在函数模块会详细阐述）
Python3.x 和 Python2.x 的一个区别是:
Python 3 可以使用直接使用 super().xxx 代替 super(Class, self).xxx
---------------------------------------------------------------------------------------------------
tuple # 转换为元组的方法
>>> tuple('hello')
('h', 'e', 'l', 'l', 'o')
>>> tuple([1,2,3])
(1, 2, 3)
---------------------------------------------------------------------------------------------------
type # 获取对象的类型
>>> a = 'hello'
>>> type(a)
<class 'str'>
浙公网安备 33010602011771号