python第三周总结知识

1.函数的使用

函数的作用

函数可以解决重复代码的问题，因为"代码有很多种坏味道， 重复是最坏的一种"，可以把代码封装在一个函数中， 当我们需要它是直接调用函数即可

函数的定义

1.例子

"""
求阶乘

"""
def factorial(num):
    result = 1
    for n in range(1, num + 1):
        result *= n
    return result

函数参数

1. 必选参数
2. 默认参数
3. 可变参数
4. 命名关键字参数
5. 关键字参数

   def f1(a, b, c = 0, *args, **kw):
    print(q, b, c, args, kw)
   """
   a,b 为必选参数
   c = 0 为默认参数
   *args 为可变参数，可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个元组
   **kw 为关键字参数， 关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内自动组装成一个字典
   """
   

def person(name,age, *,city = 'hongkong'):
    print(name,age,city)
person('liai', 23. city = 'china')
"""
* 后面的两个参数为命名关键字参数
与关键字参数**kw不同，命名关键字参数需要一个特殊分隔符*，*后面的参数被视为命名关键字参数，如果没有*号，那么后面的参数将被视为普通的未位置参数。
命名关键字参数必须传入参数名，而命名关键字参数可以有缺省值，这和位置参数不同
"""

2.面向对象

类

类：类是对象的蓝图和模板，类是抽象的概念 对象： 对象时类的实例，对象就是具体的东西，对象都有属性（静态特征）和行为（动态特征）

类的定义

class Student(object):
    # __init__是一个特殊方法用于在创建对象进行初始化操作
    # 通过这个方法我们可以为学生对象绑定name和age两个属性
    def __init__(self, name, age):
        self._name = name
        self._age = age


    def study(self, course):
            print('%s正在学习%s' % (self._name, course))

对象的创建和使用

def main():
    # 创建学生对象
    stu1 = Student('张三', 35)
    # 给对象发消息
    stu1.study('英语')

面向对象的三大特征：封装，继承，多态

class person(object):
    # 人

    def __init__(self, name, age):
        self._name = name 
        sel._age = age

    # 访问器 - getter方法  
    @property
    def name(self):
        return self._name

    # 访问器 - getter方法 
    @property
    def age(self):
        return self._age

    # 修改器 - seyyer方法
    @age.setter
    def age(self, age):
        self._age = age

    def play(self):
        print('%s正在愉快的玩耍.' % self._name)

    def watch_av(self):
        if self._age >= 18:
            print('%s正在观看爱情动作片.' % self._name)
        else:
            print('%s只能观看《熊出没》.' % self._name)

# 继承了‘人’ 类
class Student(Person):
    """学生"""

    def __init__(self, name, age, grade):

        # 使用父类的属性
        super().__init__(name, age)
        self._grade = grade

    @property
    def grade(self):
        return self._grade

    @grade.setter
    def grade(self, grade):
        self._grade = grade

    def study(self, course):
        print('%s的%s正在学习%s.' % (self._grade, self._name, course))


class Teacher(Person):
    """老师"""

    def __init__(self, name, age, title):
        super().__init__(name, age)
        self._title = title

    @property
    def title(self):
        return self._title

    @title.setter
    def title(self, title):
        self._title = title

    def teach(self, course):
        print('%s%s正在讲%s.' % (self._name, self._title, course))


def main():

    # 这里学生和老师在调用同一个watch_av方法时而实现了不同动作(一个看《熊出没》 一个看岛国动作片)，这个就叫多态
    stu = Student('王大锤', 15, '初三')
    stu.study('数学')
    stu.watch_av()
    t = Teacher('骆昊', 38, '老叫兽')
    t.teach('Python程序设计')
    t.watch_av()

if __name__ == '__main__':
    main()

类和类之间的关系三种: is- a, has-a, use-a

1. is-a关系叫继承，比如学生和人的关系就是学生继承人

2. has-a关系叫关联，比如部门和员工的关系，关联关系如果是整体和部分的关联，那么我们称之为聚合关系；如果整体进一步负责了部分的生命周期（整体和部分是不可分割的，同时同在也同时消亡），那么这种就是最强的关联关系，我们称之为合成关系。

3. use-a关系通常称之为依赖，比如司机有一个驾驶的行为（方法），其中（的参数）使用到了汽车，那么司机和汽车的关系就是依赖关系

文件

文件的读取

def main():
    # 异常机制 - 处理程序在运行过程中出现的意外状况的手段
    # 因为不是所有的问题都能够在写程序调试程序的时候就能发现
    try:
        # 参数1.文件名 2. r表示读取，w表示写入，rb读取二进制，wb写入二进制
        # open（）返回的是文件流
        fs = open('abc'，'r', encoding = 'utf-8')

        # 表示读取文件流
        content = fs.read()
        """
        把读出的文件放在一个列表容器中
        mylist = fs.readlines()
        print(mylist)
        """

        print(content)
        fs.close()
    except FileNotFoundError:
            print('指定文件无法打开')

    print('文件运行成功')

写入文件

def main():
    try:
        fs = open('./abc', 'w', encoding='utf-8')
        fs.write('儿子 儿子 我是你爸爸\n')
        fs.write('贪玩蓝月，爆爆爆，爆炸输出')
        fs.close()
    except FileNotFoundError:
        print('程序错误')

例题：把1到10000的素数放在3个文件里面

from math import sqrt


def is_prime(n):
    assert n > 0
    for x in range(2,int(sqrt(n))+1):
        if n % x == 0:
            return False
    return True if n != 1 else False


def main():
    filenames = ('a.txt', 'b.txt', 'c.txt')
    fs_list = []
    try:
        for filename in filenames:
            fs_list.append(open(filename,'w',encoding='utf-8'))
        for number in range(1,10000):
            if is_prime(number):
                if number < 100:
                    fs_list[0].write(str(number) + '\n')
                elif number < 1000:
                    fs_list[1].write(str(number) + '\n')
                elif number < 10000:
                    fs_list[2].write(str(number) + '\n')
    except IOError:
        # 如果try中出现了状况就通过except来捕获错误(异常)进行对应的处理
        print('读写文件发生错误')
    else:
        # 如果没有出状况可以把无风险代码放到else中执行
        pass
    finally:
        print('程序运行成功')
        # 不管程序正常还是异常最后这里的代码一定会执行
        # 所以此处最适合做释放外部资源的操作
        for fs in fs_list:
            fs.close()


if __name__ == '__main__':
    main()

图片的复制，图片是二进制

def main():
    try:
        with open('./we/we.jpeg', 'rb', ) as fs1:
            data = fs1.read()
        with open('./omg/sb.jpeg','wb') as  fs2:
            fs2.write(data)
    except FileNotFoundError:
        print('指定的文件无法打开')
    print('程序执行结束')

json格式写和读取

import json

def main():

    my_dict = {'name': '张三',
               'age': 38,
               'car': [{'brand': '奔驰', 'speed': 300},
                       {'brand': '法拉利', 'speed': 500},
                       {'brand': '兰博基尼', 'speed': 600}
    ]
               }
    try:
        with open('data.json', 'w', encoding='utf-8') as fs:
            json.dump(my_dict, fs)

    except FileNotFoundError as e:
        print(e)
    print('程序成功')

    # 读取 json格式文件
    try:
        with open('data.json', 'r', encoding='utf-8') as fs:
            dict1 = json.load( fs)
            print(dict1)

    except FileNotFoundError as e:
        print(e)
    print('程序成功')

if __name__ == '__main__':
    main()

In [ ]:

​