【Python】6.python函数与面向对象，文件读写与第三方库

柔光的暖阳◎ 2022-05-25 20:05 44阅读 0赞

**一、Python函数**

定义：函数是对功能代码的一种封装，可以反复调用，python中的函数用"def"定义。

1、函数返回值

如果没有设置返回值，会默认返回一个NoneType类型的返回值。

def printhello1(num,strcontent):
        for i in range(num):
            print(strcontent)
    #     return 'Done!'
    a=printhello1(5,'python!')
    print(type(a))
    # 有返回值与无返回值 None

执行结果如下：

![20180430190539494][]

2、函数执行

函数的执行要加“（）”，如果不加“（）”那只是函数的出处，并不是在执行函数

def printhello1(num,strcontent): 
        for i in range(num):
            print(strcontent)
    #     return 'Done!'
    printhello1(2,'python!')
    printhello

执行结果如下：

![20180430191057245][]

3、函数参数的传递

如下函数示例，python函数的形参与实参是一一对应的，如果不对应就会报错，这是Python函数的定位性，那么如何实现传递n多个参数的情况呢，这就要用到参数的打包了，把参数打包成为一个变量，关键是参数前面的“\*”，可以添加任意多个参数。

# 参数，两个参数
    def myadd0(a,b):
        return a+b
    myadd0(1,2)
    print(myadd0(1,2))
    # 三个参数
    def myadd1(a,b,c):
        return a+b+c
    myadd1(1,2,3)
    print(myadd1(1,2,3))
    # 四个参数
    def myadd2(a,b,c,d):
        return a+b+c+d
    myadd2(1,2,3,4)
    print(myadd2(1,2,3,4))
    # n个参数（位置参数不定长）
    def myadd(*num):
        print(type(num))
        print(num)
        return sum(num)
    
    myadd(1,2,4,6,7,8,9,10)

执行结果如下：

![20180430193141564][]

4、位置参数不定长

位置参数也就是给参数定位，形式参数对应实际参数，位置也是一一对应的，如下函数mydd2，第一个参数是arg,其他的参数都打包到变量args里面，args是一个元组类型的数据。

def myadd2(arg,*args):
        print(type(args))
        print(arg)
        print(args)
        return sum(args)
    
    myadd2(6,3,5,3)

执行结果如下：

![2018050109410979][]

5、关键字参数

关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值，使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为Python解释器能够用参数名匹配参数值。

# 关键字参数
    def myadd0(args,lastnum=1000):
        print(args+lastnum)
        return args+lastnum
    myadd0(5)
    # 关键字参数不定长
    def myaddkw(**names):
        print(type(names))
        print(list(names.keys()))
        print(list(names.values()))
        return list(names.values())
        
    myaddkw(name='david',gender='male',age=0)

执行结果如下：

![20180501095717327][]

6、偏函数

偏函数就是设置了一部分参数的函数，适用于需要传递很多参数，部分参数固定，需要传递个别参数的情况。如下代码，首先要先导入functools，"base=16"固定，传递参数a，用functools.partial()重新定义一个函数hex2int，输出类型是functools.partial证明是偏函数，partical起到固定参数的作用。

# 偏函数
    # 设置了一部分参数的函数
    import functools
    
    a=0x24
    print(int(str(a),base=16))
    
    hex2int=functools.partial(int,base=16)
    
    print(type(hex2int)) # 类型为functools.partial证明是偏函数
    hex2int(str(a))

执行结果如下：

![20180501102558240][]

7、高阶函数

高阶函数就是能够接收函数作为参数的这个函数就叫高阶函数，这里介绍三个高阶函数map，reduce，filter

map函数有两个参数：map(func, \*iterables) --> map object，一个是函数，一个是可迭代的列表，返回值是一个map object，执行的时候列表数据一个一个弹出来执行匿名函数操作。

# map
    # 用map实现一个list所有元素都减一的功能
    # 不需要用for循环，列表推导，直接用map函数
    l1=[1,2,3,4,5,6,7]
    print(list(map(lambda x:x-1,l1)))
    help(map)

执行结果如下：  
![20180501112118721][]

reduce函数有两个参数：reduce(function, sequence\[, initial\]) -> value，一个是函数，一个是可迭代的列表，根据函数的定义做迭代操作，最后返回一个结果值，执行的时候，列表是两个两个的执行匿名函数操作。

# reduce
    # 在python2里面可以直接用reduce
    # 在python3里面被删除掉了，要先导入functools
    # 实现迭代相加的功能
    from functools import reduce
    l1=[1,2,3,4,5,6,7]
    reduce(lambda a,b:a+b,l1)
    print(reduce(lambda a,b:a+b,l1))
    help(reduce)

执行结果如下：

![20180501113315998][]

filter函数跟map函数很像，其实是做了一个过滤，会将每一个值根据我们定义的函数进行过滤，filter函数有两个参数：filter(function or None, iterable) --> filter object，一个函数和一个可迭代对象，返回一个filter对象。

执行结果如下：

![20180501115109664][]

8、匿名函数

匿名函数顾名思义其实就是不需要用“def”定义的函数，直接用lambda定义的函数，后面直接跟参数和函数体，而且函数体不用写return，就会直接把执行结果返回，在高阶函数中会用到lambda函数。

# 匿名函数
    type (lambda a,b:a-b)
    # 定义，lambda
    # 函数体不用写return

执行结果如下：

![2018050110503214][]

**二、Python面向对象**

面向对象就是从一类的事物中抽取出来的共性，我们把它叫做类，然后再去创建属于这个类的一个实体的时候，我们就给它叫做实例化对象，Python中一切皆对象，类实际上就是封装了数据与方法，类与方法的区别就在于，类既封装了数据又封装了方法，而方法只是封装了方法。

1、Python中一切皆对象

# type() # 返回对象类型
    def a():
        pass
    def b():
        pass
    print(type(a))
    
    # 每个对象的id身份证号,每个对象是不一样的
    print(id(a))
    print(id(b))
    
    # dir()

执行结果如下：

![20180501134608266][]

2、类的创建与对象的初始化

在创建类和初始化的过程中self就相当于指针，指向要创建的对象，相当于java中的this，\_\_init\_\_方法可以理解为相当于java中的构造函数，定义在其中的变量称为实例变量，实例变量是不能少的，如果不定义就使用会报错，类变量是全局变量，所以要定义在\_\_init\_\_方法之外，python中带双下划线的函数都是魔法函数，例如\_\_init\_\_函数，改写这些函数的函数体，实际上就是方法的重写

# 类的创建与对象的初始化
    # 学生类设计
    # 总学生的人数，全部学生的姓名，已经毕业的学生的数量
    # 实现考试这个方法，分数>60代表pass,计入总分，否则fail
    # 查分功能，如果某位学员的总分大于500分，代表您可以毕业
    # 查所有已经毕业学员的姓名
    
    class Student():
        student_total=0
        student_namelist=[]
        student_graduated=0
        student_graduated_name_list=[]
        pass_score=500
        
        # 指针指向实例，相当于构造函数
        def __init__(self,name,age,gender):
            self.name=name
            self.age=age
            self.gender=gender
            self.score=0
            Student.student_total+=1
            Student.student_namelist.append(name)
            
        def exam(self,examscore):
            if examscore<60:
                print('sorry')
            else:
                self.score+=examscore
                if self.score>500:
                    Student.student_graduated+=1
                    Student.student_graduated_name_list.append(self.name)
        def check(self):
            if self.score<500:
                return '还差',500-self.score
            else:
                return '您已经毕业！'
            
        @classmethod # 定义类函数
        def get_graducated_student(cls,):
            return Student.student_graduated
        
        @classmethod
        def get_graducated_student_name_list(cls,):
            return Student.student_graduated_name_list
            
    no21=Student('shengli',22,'male')
    no22=Student('liment',23,'male')
    print(type(no21))
    print(type(no22))
    no21.exam(59)
    no21.exam(80)
    no21.exam(100)
    no21.exam(100)
    no21.exam(100)
    no21.exam(100)
    no21.exam(100)
    no22.exam(600)

执行结果如下：

![20180501134750583][]

![20180501134801124][]

3、继承与多态

子类继承父类的方法

![20180501141728185][]

多态是在有继承的情况下实现的，子类重写父类的方法

![2018050114212173][]

**三、文件读写**

1、读文件：

![20180501164619450][]

# 文件读写
    file=open('read.txt','rb')
    file.readlines()

![20180501164546566][]

2、写文件：

file=open('list.txt','wb')
    # dir(file)
    # help(open)

**四、python内置库与其他第三方库**

python内置库os，sys，random，re不需要安装可直接使用，python第三方库requests，scrapy，numpy，pandas需要安装才能使用。

[20180430190539494]: /images/20220526/e46cb6dfdaf94790baa74e8c6354dc8a.png
[20180430191057245]: /images/20220526/d49dae085ca94abd8956b2f5b526780d.png
[20180430193141564]: /images/20220526/4a13d690cfcc4cf98619170f73cf59db.png
[2018050109410979]: /images/20220526/5f36dff089d14d20846ae3fa4de631d9.png
[20180501095717327]: /images/20220526/c3b12d9641f0472bb28652190542b707.png
[20180501102558240]: /images/20220526/f65e958680db4bec83a5af35bb444c8d.png
[20180501112118721]: /images/20220526/c52d464ff14d4827922a33e9b898c64a.png
[20180501113315998]: /images/20220526/ed48b04612c94a45848c7fc301dd5b90.png
[20180501115109664]: /images/20220526/9f43a69e3e684428922506acdefccddf.png
[2018050110503214]: /images/20220526/4ec88f146fc843b78b7d92f6e467cff5.png
[20180501134608266]: /images/20220526/0e2beac9c54b4519b9b6ce3843efee04.png
[20180501134750583]: /images/20220526/bd10c8c47f164d728c40225df310bf85.png
[20180501134801124]: /images/20220526/e8eb54d2bdc54eb39648ee01c723decb.png
[20180501141728185]: /images/20220526/abd7a248cb8840bea6a1ad7d80d00072.png
[2018050114212173]: /images/20220526/c2e8cf4874e84c7982e3e070b21c1e0d.png
[20180501164619450]: /images/20220526/e38c0ffbc957416ab89fe00c1dc697be.png
[20180501164546566]: /images/20220526/8dcf56a251274ea38fc4b33d75fdb19b.png