函数、内置函数

def func(): #函数定义规范，这是一个无参数的函数定义
    print("the first function")
func() #函数的调用

def func(x, y):  #这里定义是x，y都是形参表量
    print(x**y)
x, y = 1, 2
func(x, y) #这里调用函数，x，y都是实参变量，有确定的值

def func(x, y):
    print(x**y)
a, b = 1, 2
func(a, b)  #这是位置参数传递，与函数参数的位置一一对应
func(y = a, x = b) #这是关键字参数传递，与函数参数名一一对应，与顺序无关

#运行结果是：
1
2

def func(*args): #*args是非固定参数的第一种形式，返回元组，args这个名字可以随便改，但是不推荐改
    print(args)
a, b = 1, 2
func(a, b) #这种形式传递的时候要以位置参数的形式传递
#运行结果是：
(1,2)

def func(**kwargs): #**kwargs是非固定参数的另外一种形式，返回字典
    print(kwargs)
func(a = 1, b =2) #参数传递的时候只能用关键字参数的形式传递
#运行结果是：
{‘a‘: 1, ‘b‘: 2}

>>> abs(-1) #对传入的参数取绝对值
1
>>> all([1,2,3,4]) #传入一个Iterable对象，若所有值都是非0，返回True，否则False
True
>>> any([0,0,1])#传入一个Iterable对象，若所有值都是0，返回False，否则True
True
>>> ascii(‘a‘) #自动执行传入参数的__repr__方法，将对象转为字符串
"‘a‘"
>>> ascii([1,2,3,4])
‘[1, 2, 3, 4]‘
>>> bin(3) #将一个十进制的数转换为一个 二进制的数
‘0b11‘
>>> oct(10)#将一个十进制的数转换为一个 八进制的数
‘0o12‘
>>> hex(17)#将一个十进制的数转换为一个 十六进制的数
‘0x11‘
>>> bool(1) #判断传入参数真假
True
>>> bytes(‘a‘,encoding = ‘gbk‘) #将传递参数转为字节类型，第二个参数为编码格式
b‘a‘
>>> bytes(‘你好‘,encoding = ‘gbk‘)
b‘\xc4\xe3\xba\xc3‘
>>> str([1,2,3,4]) #将传入参数转为字符串
‘[1, 2, 3, 4]‘
>>> char(65)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name ‘char‘ is not defined
>>> chr(65) #查看十进制对应的ASCII码值
‘A‘
>>> ord(‘A‘) #查看ASCII码所对应的十进制数
65
>>> compile("hello",‘‘,‘exec‘) #将字符串编译成python能够识别或者可以执行的代码
<code object <module> at 0x000001EA0E813810, file "", line 1>
>>> eval("1+2+3") #把字符串去掉编程可执行的代码，并返回结果
6
>>> exec(compile("print(12)",‘‘,‘exec‘))#执行python代码
12
>>> dir(‘A‘) #获取传入参数对象的所有方法
>>>help() #获取传入参数（函数）的使用帮助文档
>>> divmod(100,9) #获取商和余数
(11, 1)
>>> enumerate([‘a‘,‘b‘,‘c‘]) #接收序列化数据，返回一个迭代器
<enumerate object at 0x000001EA0EE6E678>
>>> for i, item in enumerate([‘a‘,‘b‘,‘c‘]):
...  print(i,item)
...
0 a
1 b
2 c
>>> isinstance(‘a‘,str) #判断第一个参数是否属于第二个参数（数据类型）
True
>>> filter(lambda a:a>3,[2,3,4,5]) #过滤器，第一个参数是一个函数，第二个是一个可迭代对象
<filter object at 0x000001EA0EE38DD8>
>>> list(filter(lambda a:a>3,[2,3,4,5]))
[4, 5]
>>> map(lambda a:a*3,[1,2,3,4]) #第一个参数是函数，第二个是一个可迭代的对象，对可迭代的对象每个元素都执行第一个函数
<map object at 0x000001EA0EE38DD8>
>>> list(map(lambda a:a*3,[1,2,3,4]))
[3, 6, 9, 12]
>>> "you are a good %s"%"boy" #字符串的格式输出
‘you are a good boy‘
>>> "you are a good {}, age is {}".format("boy",22) #字符串的格式输出
‘you are a good boy, age is 22‘
>>> frozenset([1,2,3]) #将参数转变为不可变集合
frozenset({1, 2, 3})
>>> dict() #创建字典
{}
>>> float(11) #转为浮点数据类型
11.0
>>> print(globals())#获取当前的所有全局变量
{‘__name__‘: ‘__main__‘, ‘__doc__‘: None, ‘__package__‘: None, ‘__loader__‘: <class ‘_frozen_importlib.BuiltinImporter‘>, ‘__spec__‘: None, ‘__annotations__‘: {}, ‘__builtins__‘: <module ‘builtins‘ (built-in)>, ‘i‘: 2, ‘item‘: ‘c‘}
>>> a = 1
>>> print(id(a)) #获取对象的内存地址
1584488608
>>> int(11.0) #转为整形数据
11
>>> iter() #将可迭代对象转为迭代器
>>> iter([1,2,3])
<list_iterator object at 0x000001EA0EE37518>
>>> len("hello") #获取对象的长度
5
>>>issubclass()　　检查一个类是否是另一个类的子类。返回True或False
>>>list()  #列表构造器
>>>locals() #获取局部变量
>>> max([1,2,3,4]) #获取最大值
4
>>> min([1,2,3,4]) #获取最小值
1
>>> open() #用来打开文件
>>> pow(1,3) #幂操作
1
>>> pow(2,3)
8
>>> range(10) #获取一个迭代器，默认从0开始
range(0, 10)
>>> repr([1,4,5,2]) #把传入值转换为字符串
‘[1, 4, 5, 2]‘
>>> reversed([12,3,4,5,]) #反转对象
<list_reverseiterator object at 0x000001EA0EE3B898>
>>> list(reversed([12,3,4,5,1]))
[1, 5, 4, 3, 12]
>>> round(3.6) #四舍五入
4
>>> set() #创建集合
set()
>>> slice(1,3,[‘a‘,‘b‘,‘c‘,‘d‘]) #切片功能
slice(1, 3, [‘a‘, ‘b‘, ‘c‘, ‘d‘])
>>> print(slice(1,3,[‘a‘,‘b‘,‘c‘,‘d‘]))
slice(1, 3, [‘a‘, ‘b‘, ‘c‘, ‘d‘])
>>> sorted([3,2,1,4])#排序
[1, 2, 3, 4]
>>> sum([1,2,3]) #求和
6
>>> tuple() #创建元组
()
>>> type(‘b‘) #判断参数数据类型
<class ‘str‘>
>>> zip([1,2,3],[‘a‘,‘b‘,‘c‘]) #拉链操作，可用来生成字典
<zip object at 0x000001EA0E714D48>
>>> for (i,x) in zip([1,2,3],[‘a‘,‘b‘,‘c‘]):
...  print(i ,x )
...
1 a
2 b
3 c
>>>rars()  #返回当前模块的所有变量
>>>super() #返回基类
>>>property()#获取对象的所有属性
>>> pow(2,3,3) # 返回 2**3%3 的结果
2
>>>delattr(object,name) #删除对象object的属性name
>>>getattr(object,name) #获取对象object的属性name值
>>>setattr(object,name)#修改或设置object的属性name的值
>>>hasattr(object,name) #判断对象object是否有那么属性