Python内置函数

常用数学运算函数

函数名	功能说明	示例
abs()	返回参数的绝对值	abs(-2)、abs(3.77)
divmod()	返回两个数值的商和余数	divmod(10,3)
max()	返回可迭代对象的元素的最大值或者所有参数的最大值	max(-1,1,2,3,4)、max('abcef989')
min()	返回可迭代对象的元素的最小值或者所有参数的最小值	min(-1,12,3,4,5)
pow()	求两个参数的幂运算值	pow(2,3)、pow(2,3,5) 注:2的3次方 2的3次方对5求余
round()	返回浮点数的四舍五入值	round(1.456778)、round(1.45677,2)
sum()	对元素类型是数值的可迭代对象的每个元素求和	sum((1,2,3,4))、sum((1,2,3,4),-10)

常用的转换函数

函数名	功能说明	示例
bool()	根据传入的参数返回一个布尔值	bool('str')、bool(O)
int()	根据传入的参数返回一个整数	int(3)、int(3.6)
float()	根据传入的参数返回一个浮点数	float(3)、float('3.4')
complex()	根据传入参数返回一个复数	complex('1+2j')、complex(1,2)
str()	返回一个对象的字符串表现形式	str(123)、str('abc')
ord()	返回 Unicode字符对应的整数	ord('a')
chr()	返回整数所对应的 Unicode字符	chr(97)
bin()	将整数转换成二进制字符串	bin(3)
oct()	将整数转换成八进制数字符串	oct(10)
hex()	将整数转换成十六进制字符串	hex(15)

常用的序列操作函数

函数名	功能说明
all()	判断可迭代对象的每个元素是否都为True值
any()	判断可迭代对象的元素是否有为True值的元素
range()	产生一个序列,默认从0开始
map()	使用指定方法去操作传入的每个可迭代对象的元素,生成新的可迭代对象
filter()	使用指定方法过滤可迭代对象的元素
reduce()	使用指定方法累积可迭代对象的元素
zip()	聚合传入的每个迭代器中相同位置的元素，返回一个新的元组类型迭代器
sorted()	对可迭代对象进行排序,返回一个新的列表
reversed()	反转序列生成新的可迭代对象

all()    #是括号中每个元素都为true返回为true
any()    #是括号中一个个元素为true则返回为true
range()    #函数在前面介绍过不做过多介绍

m1=map(lambda x,y:x*y,[3,4,5],[4,5,6])   #运用lambda进行循环运算
type(m1)     #查看m1的属性
print(m1)    #打印m1
print(list(m1))    #打印将m1转换为列表并打印出来

f1=filter(lambda x:x%2,[1,2,3,4,5])    #筛选奇数
print(list(f1))
[1,2,3]

reduce()   #reduce在Python3中已经不是内置函数了，
from functools import reduce
r1=reduce(lambda x,y:x+y,(1,2,3,4,5))
print(r1)
15

z1=zip([1,3,5],[2,4,6])
print(list(z2))
[(1,2),(3,4),(5,6)]

r1=range(10)
r2=reversed(r1)    #反转可迭代对象
print(r2)

类与对象

对象(object)：是对应客观世界的事物，将描述事物的一组数据和与这组数据有关的操作封装在一起，形成一个实体，这个实体就是对象（object）

类(Class)：具有相同或相似性质的对象的抽象就是类（Class）

封装性：将数据和数据操作组织在一起，定义一个新类的过程就是封装

继承性：类之间的关系，一个类共享了一个或多个其他类定义的数据和操作，继承的子类可以对被继承的父类的操作进行扩展和重新定义

多态性：通常指类中的方法重载，即一个类中有多个同名（不同参数）的方法，方法调用时，根据不同参数执行不同的方法。

理解方法：“cut”这个单词，理发师是开始剪头发，演员则是停止表演

私有方法：在类中，__name、__department、title等，以两个“”下划线开头的方法叫做私有方法，私有方法只能在类内部使用。

创建类：

class Dog:     #创建Dog类
    num=0       #类变量
    def __init__(self):    #构造方法
        self.id=0       #成员变量
        self.color="yellow" 
    def enjoy(self):    #成员方法
        print("wangwang")
        print(self.color,self.id)
dog=Dog(1,"red")    #创建对象dog
dog.enjoy()

创建对象：

class Dog:    #创建类
    num=0      #创建类变量
    def __init__(self,id=0,color="yellow"):    #构造方法
        self.id=id
        self.color=color
    def enjoy(self):       #成员方法
        print("wangwang")
    def show(self,weight):
        print("重量{}公斤".format(weight))
        print("颜色{}".format(self.color))

dog=Dog(color="red")    #创建对象dog
dog.weight=52      #为对象添加属性
dog.show(dog.weight)
dog.enjoy()

构造方法

类中定义的名字为__int__()的方法（以两个下划线“__”开头和结尾）被称为构造方法，既可以增加参数，又可以使用默认值

示例如上所示，不做过多阐述

析构方法

Python中__del__()方法是析构方法，析构与构造相反，是用来释放对象所占空间

class Dog:
    num=0
    def __init__(self,id=0,color="yellow"):    #构建方法
        self.id=id
        self.color=color
    def enjoy(self):
        print("wangwang")
    def __del__(self):  #构建析构方法
        print("对象已被清楚")
dog=Dog(color="red")
dog.id=52
dog.enjoy()

成员变量和类变量

理解：对象是对客观事物的抽象,类是对对象的抽象，类和对象相当于犬类和金毛，类改变属性，对象属性改变，但对象改变属性，类属性不一定更改。

方法	成员的方法	类的	方法	既可以成员使用，又可以类使用
类有四种方法	成员方法	普通方法	类方法	静态方法
区别	由对象调用，方法第一个参数默认是self，构造方法，析构方法	就是类中的函数只能由类名调用	使用@classmethod来标识方法，既可以通过对象名调用，又可以通过类名调用无区别	用@staticmethod来标识静态方法，参数列表无任何参数，既可以通过对象名调用，又可以通过类名调用无区别，

类方法

格式如下：

class 类名:
    @classmethod
    def 类方法名(cls):
        方法体

例子

class demo:
    def inst(self):
        print("inst method")
    @classmethod
    def class1(cls):
        print("class method")
a=demo()     #构建对象
a.inst()      #对象名调用
a.class1()
demo.class1()     #类名调用

静态方法

静，态方法参数列表无任何参数，所以无法访问成员变量 结构：

class 类名:
    @staticmethod
    def 静态方法名(cls):
        方法体

例子

class demo:
    def inst(self):      #成员方法
        print("inst method")
    @staticmethod    #静态方法
    def class1():
        print("class method")

a=demo()
a.inst()
a.class1()    #对象名调用
demo.class1()      #类名调用

类的继承

例子：

class anim:    #构建父类
    def __init__(self):  
         print("父类anim")
    def inst(self):
         print("父类anim成员方法")
class cat(anim):    #构建子类
    def __init__(self):
        print("构建子类cat")
    def run(self):
         print("子类cat成员方法")
a=cat()     #给子类定义对象
a.run()      #子类方法
a.inst()      #父类方法

方法重写：

class anim:
    def __init__(self):
        print("父类anim")
    def inst(self):
        print("父类anim成员方法")
    def run(self):
        print("父类run方法")
class cat(anim):
    def __init__(self):
        print("构建子类cat")
    def run(self):    #定义run方法准备重写
        super().run()     #使用super()调用父类方法进行重写
        print("子类重写run方法")
b=anim()       #构造父类类对象
b.run()
a=cat()       #构造子类对象
a.run()
a.inst()

类的多态：

由于参数类型不或参数个数不同，导致执行效果各异的现象就是多态

示例： 
class anim:
    def __init__(self,aname):
        self.name=aname
    def enjoy(self):
        print("nanana")
class cat(anim):
    def enjoy(self):
        print(self.name," miaomiao")
class dog(anim):
    def enjoy(self):
        print(self.name," wangwnang")
class per:
    def __init__(self,id,name):
        self.name=name
        self.id=id
    def drive(self,ani):
        ani.enjoy()
a=cat("mike")
b=dog("dahuang")
c=per("zhang3",9)
c.drive(a)
c.drive(b)
结果：
mike  miaomiao
dahuang wangwnang