【Python入门】Python 63个内置函数超级详解

abs(-6)
6
 
abs(5j+4)
6.4031242374328485

all([1,0,3,6])
False

all([1,9,3,6])
True
 
all(['a', 'b', '', 'd'])
False

all([]) #空列表为真
True
 
all(()) #空元组为真
True

any([0,0,0,[]])
False
 
any([0,0,1])
True
 
any((0, '', False))  
False
 
any([]) # 空列表
False
 
any(()) # 空元组
False

ascii('中国')
"'\\u4e2d\\u56fd'"

ascii('新冠肺炎')
"'\\u65b0\\u51a0\\u80ba\\u

ascii("My name is Ståle")
"'My name is St\\xe5le'"

print(ascii((1,2))) #元组
(1, 2)
print(type(ascii((1,2))))
<class 'str'>

print(ascii([1,2])) #列表
[1, 2]
print(type(ascii([1,2])))
<class 'str'>

print(ascii('？')) #字符串，非 ASCII字符，转义
'\uff1f'
print(type(ascii("？")))
<class 'str'>

print(ascii({1:2,'name':5})) #字典
{1: 2, 'name': 5}
print(type(ascii({1:2,'name':5})))
<class

bin(2)
'0b10'

bin(20)
'0b10100'

oct(8)
'0o10'

oct(43)
'0o53'

将十进制转换为十六进制
hex(43)
'0x2b'#43等于2B

hex(15)
'0xf'

bool([0,0,0])
True

bool([])
False

issubclass(bool, int)  # bool 是 int 子类
True

s = "apple"
bytes(s,encoding='utf-8')
b'apple'

bytes([1,2,3,4])
b'\x01\x02\x03\x04'

integ = 100

str(integ)
'100'

dict = {'baidu': 'baidu.com', 'google': 'google.com'};
str(dict)
"{'baidu': 'baidu.com', 'google': 'google.com'}"

callable(0)
False

def add(x, y):
  return x + y

callable(add)
True

查看十进制整数对应的ASCII字符
chr(65)
'A'
可以参考4案例中的表

ord('A')
65

ord('~')
126

class Sample(object):
    bar = 1
    def fun1(self):  
        print ('foo') 
        
    @classmethod
    def fun2(cls):
        print ('fun2')
        print (cls.bar)
        cls().fun1()   # 调用 foo 方法
 
Sample.fun2()  # 不需要实例化
fun2
1
foo

将字符串编译成python能识别或可以执行的代码，也可以将文字读成字符串再编译。
s = "print('helloworld')"
r = compile(s,"<string>", "exec")
 
r
<code object <module> at 0x000000000F819420, file "<string>", line 1>
exec(r)
helloworld
str = "for i in range(0,5): print(i)" 
c = compile(str,'','exec')   # 编译为字节代码对象 
c
<code object <module> at 0x000001EB82C91ED0, file "", line 1>
exec(c)
0
1
2
3
4

complex(1,2)
(1+2j) 

complex('1')
(1+0j)
complex("1+2j")
(1+2j)

class Coordinate:
    x = 10
    y = -5
    z = 0
 
point1 = Coordinate() 

print('x = ',point1.x)
x =  10
print('y = ',point1.y)
y =  -5
print('z = ',point1.z)
z =  0
delattr(Coordinate, 'z')
 
print('--删除 z 属性后--')

print('z = ',point1.z)# 触发错误
AttributeError: 'Coordinate' object has no attribute 'z'

dir(Coordinate)
['__class__
省略部分
 'x',
 'y'

#创建空字典

dict()                       
{}

#传入关键字
dict(a='a', b='b', t='t')   
{'a': 'a', 'b': 'b', 't': 't'}
# 映射函数方式来构造字典
dict(zip(['one', 'two', 'three'], [1, 2, 3]))  
{'three': 3, 'two': 2, 'one': 1} 
#可迭代对象方式来构造字典
dict([('one', 1), ('two', 2), ('three', 3)])    
{'three': 3, 'two': 2, 'one':

dir()   #  获得当前模块的属性列表
['In',
 'Out',
 '_',
 '__',
 '___',
 '__builtin__',
 '__builtins__',
 '__doc__',
 '__loader__',
 '__name__',
 '__package__',
 '__spec__',
 '_dh',
 '_i',
 '_i1',
 '_ih',
 '_ii',
 '_iii',
 '_oh',
 'exit',
 'get_ipython',
 'quit']

dir([ ])# 查看列表的方法
dir(list())# 查看列表的方法
['__add__',
 '__class__',
 '__contains__',
 '__delattr__',
 '__delitem__',
 '__dir__',

 '__str__',
 '__subclasshook__',
 'append',
 'clear',
 'copy',
 'count',
 'extend',
 'index',
 'insert',
 'pop',
 'remove',
 'reverse',
 'sort']

print(dir(str))#获取所有的方法
print(dir(list))#获取所有的方法
print(dir(dict))#获取所有的

不带参数时返回当前范围内的变量，方法和定义的类型列表；带参数时返回参数的属性，方法列表。

divmod(11,3)
(3, 2)

divmod(20,4)
(5, 0)

L = ['Spring', 'Summer', 'Fall', 'Winter']

enumerate(L)
<enumerate at 0x226e1ee1138>#生成的额迭代器，无法直接查看
list(enumerate(L))#列表形式，可以看到内部结构，默认下标从0开始
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
 
list(enumerate(L, start=1)) #下标从 1 开始
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

for i,v in enumerate(L):
    print(i,v)
0 Spring
1 Summer
2 Fall
3 Winter
for i,v in enumerate(L,1):
    print(i,v)

1 Spring
2 Summer
3 Fall
4 Winter

s = ["a","b","c"]
 
for i ,v in enumerate(s,2):
    print(i,v)
2 a
3 b
4 c
普通的 for 循环
i = 0
seq = ['one', 'two', 'three']
for element in seq:
    print (i, seq[i])
    i+= 1
0 one
1 two
2 three

在看一个普通循环的对比案例    
for 循环使用 enumerate
 
seq = ['one', 'two', 'three']
for i, element in enumerate(seq):
    print (i, element)
0 one
1 two
2 three
 
seq = ['one', 'two', 'three']
for i, element in enumerate(seq,2):
    print (i, element)
2 one
3 two

s = "1 + 3 +5"
eval(s)
9
#要统计图片的数量
str1 = "['https://ww1.sin5n.jpg', 'https://ww1.siqk4he.jpg']"
len(eval(str1))
2

len(str1)
5

执行字符串或compile方法编译过的字符串，没有返回值
s = "print('helloworld')"
r = compile(s,"<string>", "exec")
exec(r)
helloworld

x = 10
expr = """
z = 30
sum = x + y + z
print(sum)
"""
def func():
    y = 20
    exec(expr)
    exec(expr, {'x': 1, 'y': 2})
    exec(expr, {'x': 1, 'y': 2}, {'y': 3, 'z': 4})
    
func()
60
33
34

fil = filter(lambda x: x>10,[1,11,2,45,7,6,13])

fil
 <filter at 0x28b693b28c8>
list(fil)
[11, 45, 13]

def is_odd(n):
    return n % 2 == 1
 
newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
print(list(newlist))
[1, 3, 5, 7, 9]

float(3)
3.0


float('123')     # 字符串
 123.0

# 位置参数
'{}:您{}购买的{}到了！请下楼取快递。'.format('快递小哥','淘宝','快递')
'快递小哥:您淘宝购买的快递到了！请下楼取快递。'
#给批量客户发短息
n_list=['马云','马化腾','麻子','小红','李彦宏','二狗子']
for name in n_list:
    print('{0}：您淘宝购买的快递到了！请下楼取快递！'.format(name))
马云：您淘宝购买的快递到了！请下楼取快递！
马化腾：您淘宝购买的快递到了！请下楼取快递！
麻子：您淘宝购买的快递到了！请下楼取快递！
小红：您淘宝购买的快递到了！请下楼取快递！
李彦宏：您淘宝购买的快递到了！请下楼取快递！
二狗子：您淘宝购买的快递到了！请下楼取快递！
    
#名字进行填充    
for n in n_list:
    print('{0}：您淘宝购买的快递到了！请下楼取快递！'.format(n.center(3,'*')))
    
*马云：您淘宝购买的快递到了！请下楼取快递！
马化腾：您淘宝购买的快递到了！请下楼取快递！
*麻子：您淘宝购买的快递到了！请下楼取快递！
*小红：您淘宝购买的快递到了！请下楼取快递！
李彦宏：您淘宝购买的快递到了！请下楼取快递！
二狗子：您淘宝购买的快递到了！请下楼取快递！
'{0}, {1} and {2}'.format('gao','fu','shuai')
'gao, fu and shuai'

x=3
y=5
'{0}+{1}={2}'.format(x,y,x+y)


# 命名参数
'{name1}, {name2} and {name3}'.format(name1='gao', name2='fu', name3='shuai')
'gao, fu and shuai'
# 混合位置参数、命名参数
'{name1}, {0} and {name3}'.format("shuai", name1='fu', name3='gao')
'fu, shuai and gao'
#for循环进行批量处理
["vec_{0}".format(i) for i in range(0,5)]
['vec_0', 'vec_1', 'vec_2', 'vec_3', 'vec_4']


['f_{}'.format(r) for r in list('abcde')]
['f_a', 'f_b', 'f_c', 'f_d',

创建一个不可修改的集合。
frozenset([1,1,3,2,3])
frozenset({1, 2, 3})

class Age(object):
      age = 1
  
my_a = Age()
getattr(my_a, 'age')        # 获取属性 bar 值
 1
getattr(my_a, 'age1')
'Age' object has no attribute 'age1'

a='runoob'
print(globals()) # globals 函数返回一个全局变量的字典，包括所有导入的变量

class Coordinate:
    x = 10
    y = -5
    z = 0
 
point1 = Coordinate() 
print(hasattr(point1, 'x'))
True
print(hasattr(point1, 'y'))
True
print(hasattr(point1, 'z'))
True
print(hasattr(point1, 'no'))  # 没有该属性
False

hash() 函数可以应用于数字、字符串和对象，不能直接应用于 list、set、dictionary。
在 hash() 对对象使用时，所得的结果不仅和对象的内容有关，还和对象的 id()，也就是内存地址有关。
class Test:
    def __init__(self, i):
        self.i = i
for i in range(10):
    t = Test(1)
    print(hash(t), id(t))
    
hash(point1)
16294976

hash('返回对象的哈希值')
4919828709165481160

hash() 函数的用途
hash() 函数的对象字符不管有多长，返回的 hash 值都是固定长度的，也用于校验程序在传输过程中
是否被第三方（木马）修改，如果程序（字符）在传输过程中被修改hash值即发生变化，如果没有被
修改，则 hash 值和原始的 hash 值吻合，只要验证 hash 值是否匹配即可验证程序是否带木马（病毒）。
 
name1='正常程序代码'
name2='正常程序代码带病毒'
 
print(hash(name1)) # -3048480827538126659
print(hash(name2)) # -9065726187242961328

help('sys')             # 查看 sys 模块的帮助
help('str')             # 查看 str 数据类型的帮助
a = [1,2,3]
help(a)                 # 查看列表 list 帮助信息
 
help(a.append)       # 显示list的append方法的帮助

返回对象的内存地址
a = 'runoob'
id(a)
260316720

a = input("input:")
input:1234
print(a)
123

int('12',16)
18

int('12',10)
12

a = 2
isinstance (a,int)
True
isinstance (a,str)
False
isinstance (a,(str,int,list))#是元组中的一个返回 True
True

class A:
    pass
class B(A):
    pass
    
print(issubclass(B,A))    # 返回 True

lst = [1,3,5]
iter(lst)
<list_iterator at 0xf8359e8>


for i in iter(lst):
    print(i)
1
3
5

#字典的长度
dic = {'a':1,'b':3}
len(dic)
2

#字符串长度
s='aasdf'
len(s)
5

#列表元素个数
l = [1,2,3,4,5]
len(l)

atuple = (123, 'xyz', 'zara', 'abc')
aList = list(atuple)

aList
[123, 'xyz', 'zara', 'abc']
 

def square(x) :            # 计算平方数
    return x ** 2
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]


list(map(lambda x: x%2==1, [1,3,2,4,1]))
[True, True, False, False, True

最大值：
max(3,1,4,2,1)
4

di  {'a':3,'b1':1,'c':4}
max(di)
'c'

min(80, 100, 1000)
80
min([80, 100, 1000])
80

v = memoryview(bytearray("abcefg", 'utf-8'))
v[1]
98
v[-1]
98
 v[1:4]
<memory at 0x0000028B68E26AC8>
v[1:4].tobytes()
b'bce'

it = iter([5,3,4,1])
next(it)
5
 
next(it)
3
 
next(it)
4

f=open('test.txt',encoding='utf-8')   #打开文件
data=f.read()#文件操作
print(data)
f.close()  #关闭文件

pow(10, 2)
100

pow(4,3,5)
 4
等价于4**3%5

 

暂不解释

list(range(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))
[0, 5, 10, 15, 20, 25]

for i in range(5):
    print(i)
0
1
2
3

#反转列表
rev = reversed([1,4,2,3,1])
list(rev)
[1, 3, 2, 4, 1]


for i in rev:
    print(i)
1
3
2
4
1 
#反转字符串
rev = reversed('我爱中国')
list(rev)
['国', '中', '爱', '我']

for i in rev:
    print(i)
国
中
爱

round(10.0222222, 3)
10.022

#返回一个set对象，可实现去重：
a = [1,4,2,3,1]
set(a)
{1, 2, 3, 4}

a = [1,4,2,3,1]
a[slice(0,5,2)] #等价于a[0:5:2]
[1, 2, 1]

a = [5,7,6,3,4,1,2]
b = sorted(a)       # 保留原列表
a 
[5, 7, 6, 3, 4, 1, 2]
b
[1, 2, 3, 4, 5, 6, 7]
 
#利用key
L=[('b',2),('a',1),('c',3),('d',4)]


sorted(L, key=lambda x:x[1])  
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]

#按年龄排序
students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
sorted(students, key=lambda s: s[2]) 
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
#按降序
sorted(students, key=lambda s: s[2], reverse=True)  
[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
 
#降序排列
a = [1,4,2,3,1]
sorted(a,reverse=True) 
[4, 3, 2, 1, 1]

class C(object):
    @staticmethod
    def f():
        print('runoob');
 
C.f();          # 静态方法无需实例化
cobj = C()
cobj.f()        # 也可以实例化后调用

dict = {'runoob': 'runoob.com', 'google': 'google.com'};
str(dict)
"{'google': 'google.com', 'runoob': 'runoob.com'}"

a = [1,4,2,3,1]
sum(a)
11
 
sum(a,10) #求和的初始值为10
21

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
3

tuple([1,2,3,4])
(1, 2, 3, 4)
 
tuple({'a':2,'b':4})    #针对字典 会返回字典的key组成的tuple
 ('a', 'b')

type([2])
list

type({0:'zero'})
dict
x = 1          
type( x ) == int    # 判断类型是否相等
True
 
# 三个参数
class X(object):
    a = 1
X = type('X', (object,), dict(a=1))  # 产生一个新的类型 X
X
 __main_

创建一个聚合了来自每个可迭代对象中的元素的迭代器：
x = [3,2,1]
y = [4,5,6]
list(zip(y,x))
[(4, 3), (5, 2), (6, 1)]

#搭配for循环，数字与字符串组合 
a = range(5)
b = list('abcde')
[str(y) + str(x) for x,y in zip(a,b)]
['a0', 'b1', 'c2', 'd3', 'e4']

list1 = [2,3,4]
list2 = [5,6,7]
for x,y in zip(list1,list2):
    print(x,y,'--',x*y)
2 5 -- 10
3 6 -- 18
4 7 -- 28
#元素个数与最短的列表一致
list(zip(x,b))
 [(3, 'a'), (2, 'b'), (1, 'c')]
#与 zip 相反，zip(* ) 可理解为解压，返回二维矩阵式
a1, a2 = zip(*zip(a,b))          
a1
(0, 1, 2, 3, 4)
a2
('a', 'b', 'c', 'd', 'e'