Python-Class___函数与常用内置函数

一、函数

1.1、定义函数

在Python中，定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号“ : ”，然后，在缩进块中编写函数体，函数的返回值用return语句返回。

>>def func():
    print("---hello word---")
    return 0
>>func()
---hello word---

函数执行完毕也没有return语句时，自动return None。 

>>def func():
    print("---hello word---")
    return 0
>>print(func())
---hello word---
0
------------------------------------
>>def func():
    print("---hello word---")
>>print(func())
---hello word---
None

1.2、空函数

def func():
    pass

1.3、函数作用域

country为全局变量，可以被函数体内调用；

函数体内“func_name”和“csdn_name”为局部变量，无法被其他函数调用。

>>country = "China"
>>def func():
    func_name = "FUNC"
    print(country + "_"+func_name)
>>def csdn():
    csdn_name = "CSDN"
    print(country + "_"+csdn_name)
>>func()
>>csdn()
China_FUNC
China_CSDN

二、内置函数

2.1、abs()

返回一个数字的绝对值

>>a = -1
>>b = 2
>>c = 0
print(abs(a))
print(abs(b))
print(abs(c))

2.2、all()

在一个可迭代元素里，如果有一个元素为假及返回False（如果为空返回True）。

>>print(all([0, -1, 2]))
False
---------------------------
>>print(all([-1, 2]))
True
---------------------------
>>print(all([]))
True

 2.3、any()

在一个可迭代元素里，如果有一个元素为真及返回True（如果为空返回False）。

>>print(any([0, -1, 2]))
True
---------------------------
>>print(any([-1, 2]))
True
---------------------------
>>print(any([]))
False

2.4、ascii()

返回包含对象的可打印表示的字符串，如果对象是非ascii使用\x、\u或\u转义

>>print(ascii('中国'))
'\u4e2d\u56fd'

2.5、bin()

十进制转二进制

>>print(bin(255))
0b11111111

2.6、 bool()

布尔运算，判断真假

>>print(bool([]))
>>print(bool(()))
>>print(bool(0))
--------------------------------
False
False
False

2.7、callable()

判断是否能被调用

>>def func():
    pass

print(callable(func))

2.8、chr()

返回ascii码对应表中数字对应的字符

>>print(chr(97))

a

2.9、dict()

生成一个空字典

>>a = dict()
>>print(a)

{}

2.10、dir()

返回对象可调用的方法

>>a = dir(dict())

>>for i in a:
    print(i)

__class__
__contains__
__delattr__
__delitem__
__dir__
__doc__
__eq__
__format__
__ge__
__getattribute__
__getitem__
__gt__
__hash__
__init__
__init_subclass__
__iter__
__le__
__len__
__lt__
__ne__
__new__
__reduce__
__reduce_ex__
__repr__
__setattr__
__setitem__
__sizeof__
__str__
__subclasshook__
clear
copy
fromkeys
get
items
keys
pop
popitem
setdefault
update
values

2.11、 divmod()

除法运算，返回商和余数

>>print(divmod(5, 2))

(2, 1)

2.12、 enumerate（）

返回一个包含计数(从开始时默认为0)和迭代获得的值的元组。

>>a = list(enumerate(["张三", "李四", "王五"]))

>>print(a[0])
>>print(a[0][1])

(0, '张三')
张三

2.13、 eval()

字符串变为字典

>>x = 1

>>print(eval("x+1"))

2

2.14、filter()

从一个可迭代元素中，根据一定的规则进行筛选，从而生成一个新的迭代器

>>res = filter(lambda n: n > 5, [0, 2, 3, 6, 8, 10, 23])

>>for i in res:
    print(i)

6
8
10
23

2.15、float()

>>> float('+1.23')
1.23
>>> float('   -12345\n')
-12345.0
>>> float('1e-003')
0.001
>>> float('+1E6')
1000000.0
>>> float('-Infinity')
-inf

2.16、format()

格式化字符串

#通过关键字
>>print('{名字今天{动作}'.format(名字='陈某某',动作='拍视频'))

陈某某今天拍视频

>>grade = {'name' : '陈某某', 'fenshu': '59'}
>>print('{name}电工考了{fenshu}'.format(**grade))

陈某某电工考了59
-----------------------------------------------------------
#通过位置
>>print('{1}今天{0}'.format('拍视频', '陈某某'))
>>print('{0}今天{1}'.format('陈某某', '拍视频'))

陈某某今天拍视频
陈某某今天拍视频
-----------------------------------------------------------
#通过精度f
>>print('{:.1f}'.format(4.234324525254))
>>print('{:.4f}'.format(4.1))

4.2
4.1000
-----------------------------------------------------------
#填充和对齐^<>分别表示居中、左对齐、右对齐，后面带宽度
>>print('{:^20}'.format('陈某某'))
>>print('{:>4}'.format('陈某某'))
>>print('{:<10}'.format('陈某某'))
>>print('{:*<14}'.format('陈某某'))
>>print('{:&>14}'.format('陈某某'))

        陈某某         
 陈某某
陈某某       
陈某某***********
&&&&&&&&&&&陈某某
-----------------------------------------------------------
#进制转化，b o d x 分别表示二、八、十、十六进制
>>print('{:b}'.format(250))
>>print('{:o}'.format(250))
>>print('{:d}'.format(250))
>>print('{:x}'.format(250))

11111010
372
250
fa
-----------------------------------------------------------
#千分位分隔符，这种情况只针对与数字
>>print('{:,}'.format(100000000))
>>print('{:,}'.format(235445.234235))

100,000,000
235,445.234235

2.17、frozenset()

创建一个不可编辑的集合

2.18、 gloables()

返回表示当前全局符号表的字典，对比参照locals()

2.19、hash()

返回对象的散列值(如果有)。散列值是整数。它们用于在查找字典时快速比较字典键。比较相等的数值具有相同的散列值(即使它们属于不同的类型，如1和1.0)。

>>> a = hash("zzl")

>>> print(a)

-1832558360181557176

2.20、 help()

帮助文档

2.21、 hex()

将一个整数转换为小写的十六进制字符串，前缀为“0x”。如果x不是Python int对象，则必须定义一个__index__()方法来返回一个整数。

>>> print(hex(255))
'0xff'
>>> print(hex(-42))
'-0x2a'

如果你想把一个整数转换成大写或小写的十六进制字符串加上前缀或不带前缀，你可以使用以下两种方法: 

>>> print("%#x" % 255, "%x" % 255, "%X" % 255)
0xff ff FF

>>> print(format(255, "#x"), format(255, "x"), format(255, "X"))
0xff ff FF

>>> print(f"{255:#x}", f"{255:x}", f"{255:X}")
0xff ff FF

2.22、id()

返回内存地址

2.23、input()

输入函数 

2.24、int()

转化成整数

2.25、isinstance()

 如果对象参数是classinfo参数的实例，或者它的(直接、间接或虚拟)子类的实例，则返回true。

>>> a = (1, 2, 3)

>>> print(isinstance(a, list))

False

2.26、iter()

返回一个迭代器，参数必须是一个可序列化的

2.27、lens()

返回一个对象的长度，参数可以是序列(如字符串、字节、元组、列表或范围)或集合(如字典、集合或冻结集)。 

2.28、locals()

更新和返回表示当前本地符号表的字典

>>> def func():
    local_var = 333
    print(locals())
    print(locals().get("local_var"))

>>> func()
>>> print(globals().get("local_var"))

>>> print(locals().get("local_var"))

{'local_var': 333}
333
None
None

2.29、map() 

从一个可迭代元素中，根据一定的规则进行处理，从而生成一个新的迭代器

>>> res = map(lambda n: n * n, [0, 2, 3, 6, 8, 10, 23])

>>> for i in res:
        print(i)
0
4
9
36
64
100
529
----------------------------------------------------------
>>> res = map(lambda n: n > 5, [0, 2, 3, 6, 8, 10, 23])

>>> for i in res:
        print(i)
False
False
False
True
True
True
True