Python中的"公式"

实验介绍

• 实验介绍了对于Python中函数组成、定义及使用，以及Python高阶函数的使用

实验代码

步骤1，新建名称为Python函数的使用文件

步骤2，使用def实现Python中的自定义函数

'''
使用函数的形式实现如下功能：返回一个序列（长度为10），序列中每个数字都是之前两个数字的和
（斐波那契数列，前两位是0和1）
'''


def fibonaccis():
    result = [0, 1]  # 新建列表存储数列的值
    for i in range(2, 10):  # 循环num-2次
        a = result[i - 1] + result[i - 2]
        result.append(a)  # 将值追加至列表
    return result


print(fibonaccis())  # [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

步骤3，函数中返回值的使用

'''
定义函数，实现输出一个正方形，不添加返回值
'''
# def square():
#     print('''
#             ------
#             |    |
#             ------
#     ''')
# a=square()
# print(a)
'''
定义函数，在函数内部定义多个变量，并且全部返回
'''
# def func():
#     a='a'
#     b='b'
#     c='c'
#     return a,b,c
# print(func()) #('a', 'b', 'c')
'''
定义函数，在函数内部再次定义一个函数，将内部函数作为返回值返回
'''
# def func1():
#     def func2():
#         print('内函数调用')
#     return func2
# b=func1()
# print(b) #<function func1.<locals>.func2 at 0x00000268645EBE50>
# b() #内函数调用

步骤4，在函数中使用参数

'''
定义函数，用于计算两数之和，参与计算的数字使用参数的形式传递给函数
'''


def add(a, b, c):
    return a + b + c


print(add(1, 2, 3))  # 6
'''
在函数中使用位置参数
'''
print(add(a=5, c=1, b=8))  # 14
'''
使用默认参数
'''


def add(a=4, b=9, c=1):
    return a + b + c


print(add())  # 14
print(add(1, 2))  # 4
print(add(c=3))  # 16
'''
定义函数实现对于接收的数据求和（使用不定长函数）
'''


def add(*args):
    print(args)  # (1, 2, 3, 4, 5, 6)
    return sum(args)


print(add(1, 2, 3, 4, 5, 6))  # 21
'''
字典形式的不定长参数
'''


def add(**args):
    print(args)  # {'a': 4, 'b': 5, 'c': 6}
    return sum(args.values())


print(add(a=4, b=5, c=6))  # 15
'''
使用多种参数，参数的位置顺序
'''


def add(a, b=1, *args, **kwargs):
    print(args)  # (1, 2, 3, 4)
    print(kwargs)  # {'c': 4, 'd': 6}


add(1, 0, 1, 2, 3, 4, c=4, d=6)

步骤5，函数的说明文档

def add(a, b):
    '''
    用于计算两个数字之和
    :param a: 数值类型
    :param b: 数值类型
    :return: 两个数字之和
    '''
    return a + b


help(add)
'''
Help on function add in module __main__:

add(a, b)
    用于计算两个数字之和
    :param a: 数值类型
    :param b: 数值类型
    :return: 两个数字之和
'''

步骤6，在函数中使用全局变量

a = 10


def func():
    print(a)


func()  #10
'''
修改全局变量
'''
a = 10


def func():
    print(a)
    a += 1
    return a


func()  #UnboundLocalError: local variable 'a' referenced before assignment

步骤7，全局变量和局部变量重名

# name='吴彦祖'
# def func():
#     name='小吴'
#     print('有人喊你，%s'%(name))
# func() #有人喊你，小吴
'''
使用global关键字在函数中声明这是一个全局变量
'''
# name='吴彦祖'
# def func1():
#     global name
#     print('我就是，%s'%(name)) #我就是，吴彦祖
#     name='小吴'
#     print('有人喊你，%s'%(name)) #有人喊你，小吴
# func1()
'''
在函数中修改全局变量
'''
a = 10


def func():
    global a
    a += 1
    return a


func()
print(a)  # 11

步骤8，可变类型的数据作为参数对于函数的影响

'''
在函数中使用可变数据类型作为参数时，即使不使用return和global，也会影响结果
'''
list1 = [1, 2, 3]


def func():
    list1.append(4)


func()
print(list1)  #[1, 2, 3, 4]

步骤9，匿名函数

'''
使用lambda定义匿名函数，实现两个数相加
'''
y = lambda x1, x2: x1 + x2
print(y(1, 2))  #3

步骤10，函数的执行顺序

print(1)


def func():
    print(2)


print(3)
func()
'''
输出结果：
1 3 2
'''

步骤11，def和lambda的嵌套使用

def func():
    temp = [lambda x: x * i for i in range(4)]
    return temp


for m in func():
    print(m(3))  # 9 9 9 9
'''
思考：为什么输出结果是这样？
答案就在官方文档里面https://docs.python.org/3.9/library/stdtypes.html#range
range(stop) -> range object range(start, stop[, step]) -> range object
Return an object that produces a sequence of integers from start (inclusive) to stop (exclusive) by step. 
range(i, j) produces i, i+1, i+2, ..., j-1. start defaults to 0, and stop is omitted! 
range(4) produces 0, 1, 2, 3. These are exactly the valid indices for a list of 4 elements. 
When step is given, it specifies the increment (or decrement).
'''

步骤12，高阶函数的使用

def add(x, y, f):
    return f(x) + f(y)


# print(add(-5,6,abs())) #TypeError: abs() takes exactly one argument (0 given)
print(add(-5, 6, abs))  # 11

步骤13，Python中内置的强大函数

'''
zip函数，同时遍历多个序列
'''
a = [1, 2, 3, 4]
b = 'ABCDE'
c = ('a', 'b', 'c',)
for i in zip(a, b, c):
    print(i, end=' ')  #(1, 'A', 'a') (2, 'B', 'b') (3, 'C', 'c')
'''
sorted，对序列进行排序
'''
list1 = [99, -101, 15, 0]
print('排序：', sorted(list1))  #排序： [-101, 0, 15, 99]
print('按照绝对值排序：', sorted(list1, key=abs))  #按照绝对值排序： [0, 15, 99, -101]
print('排序后源数据：', list1)  #排序后源数据： [99, -101, 15, 0]
'''
filter，过滤序列
'''
list2 = [99, -100, 15, 0]
print(list(filter(lambda x: x % 2 == 0, list2)))  #[-100, 0]
'''
map，序列映射
'''
f = lambda x: x ** 2 + +1
left = [1, 2, 3, 4, 5]
right = map(f, left)
print(list(right))  #[2, 5, 10, 17, 26]
'''
reduce，累计计算
'''
from functools import reduce


def fn(x, y):
    return x * 10 + y


print(reduce(fn, [1, 3, 5, 7, 9]))  #13579

步骤14，递归

'''
使用递归实现快速排序算法
'''


def quick_sort(arr):
    if len(arr) < 2:
        return arr
    # 选取基准，随便选哪个都可以，选中间的便于理解
    mid = arr[len(arr) // 2]
    # 定义基准值左右两个数列
    left, right = [], []
    # 从原始数组中移除基准值
    arr.remove(mid)
    for item in arr:
        # 大于基准值放右边
        if item >= mid:
            right.append(item)
        else:
            # 小于基准值放左边
            left.append(item)
    # 使用迭代进行比较
    return quick_sort(left) + [mid] + quick_sort(right)


print(quick_sort([1, 10, 9, 5, 8, 0]))  # [0, 1, 5, 8, 9, 10]
'''
一行代码实现快速排序
'''
quick_sort1 = lambda array: array if len(array) <= 1 else quick_sort1([item for item in array[1:] if item <= array[0]]) + [array[0]] + quick_sort1([item for item in array[1:] if item > array[0]])
print(quick_sort1([1, 10, 9, 5, 8, 0]))  # [0, 1, 5, 8, 9, 10]

让Python给你一个对象

实验介绍

• 实验介绍了对于Python中类和对象的定义及使用，以及Python中魔法方法、设计模式的使用。

实验代码

Python中的面向对象

步骤1，类的创建和使用

'''
创建Dog类，根据Dog类创建的每个实例都将存储名字和年龄。我们将赋予每条小狗蹲下(sit())和打滚(roll_over())的能力
'''


class Dog():
    '''一次模拟小狗的简单尝试'''

    def __init__(self, name, age):
        '''初始化属性name和age'''
        self.name = name
        self.age = age

    def sit(self):
        '''模拟小狗被命令时蹲下'''
        print(self.name.title() + " is now sitting")

    def roll_over(self):
        '''模拟小狗被命令时打滚'''
        print(self.name.title() + " rolled over!")


# 对类进行实例化
dog = Dog('哈士奇', 2)
dog.sit()  #哈士奇 is now sitting
dog.roll_over()  #哈士奇 rolled over!

步骤2，访问实例化对象中的属性

class Employee(object):
    '所有员工的基类'
    empCount = 0

    def __init__(self, name, salary):
        self.name = name
        self.salary = salary
        Employee.empCount += 1

    def displayCount(self):
        print('Total Employee %d' % Employee.empCount)

    def displayEmployee(self):
        print('Name: ', self.name, ', Salary: ', self.salary)


# 创建Employee类的第一个对象
emp1 = Employee('Zara', 100)
# 创建Employee类的第二个对象
emp2 = Employee('Manni', 100)
emp1.displayEmployee()
emp2.displayEmployee()
print('Total Employee %d' % Employee.empCount)

步骤3，动态的为类和对象添加属性和方法

'''
在创建类并实例化对象后，动态的修改类
'''


class Dog():
    def __init__(self, name, age):
        '''初始化属性name和age'''
        self.name = name
        self.age = age


dog = Dog('大宝', 0.5)
Dog.color = 'yellow'
print(dog.color)  #yellow
'''
为类添加方法
'''


def eat(self):
    print('%s吃东西' % self.name)


Dog.eat = eat
dog.eat()  #大宝吃东西
'''
在对类添加属性和方法时，对应的实例化的对象也会收到影响
'''
# 为实例化的对象添加属性和方法
dog.weight = 10


def bark():
    print('叫。。。')


dog.bark = bark
print(dog.weight)  #10
print(dog.bark())  #叫。。。
dog2 = Dog('旺财', 1)
print(dog2.weight)  #AttributeError: 'Dog' object has no attribute 'weight'
print(dog2.bark())  #AttributeError: 'Dog' object has no attribute 'bark'

步骤4，面向对象中继承的使用

# 定义父类
class Parent(object):
    parentAttr = 100

    def __init__(self):
        print('调用父类构造函数')

    def parentMethod(self):
        print('调用父类方法')

    def setAttr(self, attr):
        Parent.parentAttr = attr

    def getAttr(self):
        print('父类属性：', Parent.parentAttr)


# 定义子类
class Child(Parent):
    def __init__(self):
        print('调用子类构造函数')

    def childMethod(self):
        print('调用子类方法')


c = Child()  #实例化子类
c.childMethod()  #调用子类的方法
c.parentMethod()  #调用父类的方法
c.setAttr(200)  #再次调用父类的方法 - 设置属性值
c.getAttr()  #再次调用父类的方法 - 获取属性值
'''
输出结果：
调用子类构造函数
调用子类方法
调用父类方法
父类属性： 200
'''

步骤5，使用多继承的方式创建新类

'''
创建父类Dog，具备属性年龄和姓名，会吃饭，会叫
'''


class Dog(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def eat(self, food):
        print('%s吃%s' % (self.name, food))

    def bark(self):
        print('汪汪汪')


'''
创建父类Wolf，具备属性姓名、颜色，会捕猎，会叫
'''


class Wolf(object):
    def __init__(self, name, color):
        self.name = name
        self.color = color

    def bark(self):
        print('呜呜呜')

    def hunt(self, prey):
        print('%s狩猎了%s' % (self.name, prey))


'''
多继承实现新的类Husky
'''


class Husky(Dog, Wolf):
    def destory(self, master):
        if not master:
            print('哈士奇开始搞破坏啦')


husky = Husky(age='3', name='二哈')
husky.hunt('沙发')  #二哈狩猎了沙发
husky.eat('沙发')  #二哈吃沙发
husky.bark()  #汪汪汪
husky.destory(0)  #哈士奇开始搞破坏啦
# 当继承多个类时，优先继承排在前面的类（同名属性和方法）

步骤6，私有化的属性

class Person(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age
        self.__friend = ['lisi', 'wangwu']

    def __play(self):
        print('打篮球')


class child(Person):
    pass


c = child('zhangsan', 18)
# print(c.friend) #AttributeError: 'child' object has no attribute 'friend'
c.__play()  #AttributeError: 'child' object has no attribute '__play'

步骤7，反射

'''
通过字符串的形式开判断当前对象是否存在该属性或者方法
hasattr(obj,name_str):判断object是否有name_str这个方法或者属性
getattr(obj,name_str):获取object对象中与name_str同名的方法或者函数
setattr(obj,name_str,value):为object对象设置一个以name_str为名的value方法或者属性
delattr(obj,name_str):删除object对象中的name_str方法或者属性
'''


class Dog(object):
    def __init__(self, age, name):
        self.age = age
        self.name = name

    def eat(self, food):
        print('%s吃%s' % (self.name, food))

    def bark(self):
        print('汪汪汪')


dog = Dog(3, '大宝')
if hasattr(dog, 'eat'):
    eat = getattr(dog, 'eat')
    food = input('你要喂它吃什么：')
    eat(food)
    setattr(dog, 'temp', '饱')
    print('大宝吃%s了' % dog.temp)
'''
输出结果：
你要喂它吃什么：狗粮
大宝吃狗粮
大宝吃饱了
'''

步骤8，判断当前对象是否是某一个类实例化的

isinstance(dog, Dog)  # True

步骤9，静态方法与类方法

class P(object):
    num = 0

    def __init__(self):
        P.num += 1

    @classmethod
    def get_no_of_instance(cls):
        return cls.num

    @staticmethod
    def func():
        return '这是一个静态方法'


p1 = P()
p2 = P()
print(P.get_no_of_instance())  #2
print(P.func())  #这是一个静态方法
print(p1.func())  #这是一个静态方法

魔法方法的使用

步骤1，init__和__new

# 在同一个类中使用这两个魔法方法
class person():
    def __init__(self):
        print('调用init')

    def __new__(cls, *args, **kwargs):
        print('调用new')
        return object.__new__(cls, *args, **kwargs)


p = person()
'''
输出结果：
调用new
调用init
'''

步骤2，析构方法__del__

# 在对象删除时，调用的方法
class person():
    def __del__(self):
        print('这个对象被删除了')


p = person()
del (p)  #这个对象被删除了

步骤3，返回当前数据的长度，len

class obj(object):
    def __init__(self, value):
        self.value = value

    def __len__(self):
        return len(self.value) - 1


o = obj([1, 2, 3])
print(len(o))  #2

步骤4，str__和__repr

# 定义对象时，不重构__str__和__repr__
class obj(object):
    pass


o = obj()
print(o)  #<__main__.obj object at 0x0000020A41BE8FD0>
print(str(o))  #<__main__.obj object at 0x0000020A41BE8FD0>
print(repr(o))  #<__main__.obj object at 0x0000020A41BE8FD0>


class obj1(object):
    def __str__(self):
        return '这个obj1实例化的一个对象'

    def __repr__(self):
        return '调用了repr'


o = obj1()
print(o)  #这个obj1实例化的一个对象
print(str(o))  #这个obj1实例化的一个对象
print(repr(o))  #调用了repr

Python中类的属性的操作

步骤1，getattribute，设置属性被访问时的操作

class People(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __getattribute__(self, obj):  #重写__getattribute__方法，形参obj是访问的属性，是一个属性名字字符串
        if obj == 'age':
            print('问别人年龄是不礼貌的')
            return 18
        else:  #else此处为其他访问属性访问过程，如果不写，那age和show方法就访问不到了
            temp = object.__getattribute__(self, obj)
            return temp  #不写return的话，show方法无法执行

    def show(self):
        print('---')


s = People('python', 30)
print(s.age)
print(s.name)
s.show()
'''
输出结果:
问别人年龄是不礼貌的
18
python
---
'''

步骤2，property

# 让方法像属性一样调用
class Dog(object):
    def __init__(self, age, name):
        self.age = age
        self.name = name

    @property
    def bark(self):
        print('汪汪汪')


dog = Dog(1, 'BayMAX')
dog.bark  #汪汪汪

步骤3，getter和setter

'''
获取私有属性并赋值
'''


class Dog(object):
    def __init__(self, age, name):
        self.age = age
        self.name = name

    @property
    def age(self):
        return self.__age

    @age.setter  #设置属性赋值要求
    def age(self, Age):
        if 0 < Age < 100:
            self.__age = Age
            return self.__age
        else:
            self.__age = 18
            return self.__age


dog = Dog(1, 'BayMAX')
dog.age = 10
print(dog.age)  #10
dog.age = 130
print(dog.age)  #18
'''
在类中设置只读属性
'''


class Dog(object):
    def __init__(self, age, name):
        self.__age = age
        self.name = name

    @property
    def age(self):
        return self.__age

    @age.getter
    def age(self):
        return self.__age


dog = Dog(1, 'BayMAX')
print(dog.age)  #1
dog.age = 10  #AttributeError: can't set attribute
# 不设置setter对应的方法即为只读

设计模式基础

步骤1，工厂模式

# 实现手机类，通过工厂来生产不同的手机
class Phone(object):
    def __init__(self, color, price):
        self.color = color
        self.price = price

    def get_price(self):
        return self.price


class DaMi(Phone):
    def __init__(self, name):
        print('这是一台：%s' % name)


class XiaMi(Phone):
    def __init__(self, name):
        print('这是一台：%s' % name)


class Factory(object):
    def getPhone(self, name, brand):
        if brand == 'DaMi':
            return DaMi(name)
        if brand == 'XiaMi':
            return XiaMi(name)


factory = Factory()
phone = factory.getPhone('大米11', 'DaMi')  #这是一台：大米11

步骤2，使用__new__实现单例模式

# 实例化一个单例
class Singlton(object):
    __instance = None


def __new__(cls, age, name):
    # 如果类属性__instance的值为None
    # 那么就创建一个对象，并且赋值为这个对象的引用，保证下次调用这个方法时
    # 能够知道之前已经创建过对象了，这样就保证了只有1个对象
    if not cls.__instance:
        cls.__instance = object.__new__(cls)
    return cls.__instance


a = Singlton(18, '张三')
b = Singlton(8, '李四')

步骤3，使用装饰器实现单例模式

# 此处通过Python中的装饰器实现单例模式（了解）
def singleton(cls):
    # 单下划线的作用是这个变量只能在当前模块里访问，仅仅是一种提示作用
    # 创建一个字典用来保存类的实例对象
    _instance = {}

    def _singleton(*args, **kwargs):
        # 先判断这个类有没有对象
        if cls not in _instance:
            _instance[cls] = cls(*args, **kwargs)  #创建一个对象，并保存到字典当中
        # 将实例对象返回
        return _instance[cls]

    return _instance


@singleton
class A(object):
    a = 1

    def __init__(self, x=0):
        self.x = x
        print('这是A的类的初始化方法')


a1 = A(2)
a2 = A(3)
a1 is a2

“发明轮子"和"造轮子”

实验介绍

• 实验介绍了对于Python中常用标准模块的使用

实验代码

步骤1，导入模块

'''
# 新建一个Python文件a.py
'''


def funca():
    print('funca被调用')


A = '我来自funca'


def funcb():
    print('funcb被调用')


# 调用写好的a.py
import a

a.funca()  #funca被调用
print(a.A)  #我来自funca

from a import funcb

funcb()  #funcb被调用

from a import *

funca()  #funca被调用

import a as AAA

AAA.funca()  #funca被调用

步骤2，os模块常用函数的使用

import os

# os.getpid() 获取当前进程id
print('当前进程的ID：', os.getpid())
# os.getppid() 获取当前父进程id
print('当前父进程的ID：', os.getppid())
# os.getcwd() 获取当前所在路径
cwd = os.getcwd()
print('当前所在路径为：', cwd)
# os.chdir(path) 改变当前工作目录
os.chdir('C:\\')
print('修改后当前所在路径为：', os.getcwd())
# os.listdir() 返回目录下所有文件
print('当前目录下的文件有：', os.listdir(cwd))
# os.walk() 输出当前路径下的所有文件
for root, dirs, files in os.walk(cwd, topdown=False):
    for name in files:
        print(os.path.join(root, name))
    for name in dirs:
        print(os.path.join(root, name))

步骤3，os文件操作

import os

# 获取当前工作目录的名称
os.curdir
# 父目录字符串名称
os.pardir
# 删除指定文件
os.remove()
# 删除文件夹
os.removedirs(path)
# 重命名文件
os.rename(src, dst)  # 命名前，命名后

步骤4，os path子模块

import os

# os.path.abspath(path):返回绝对路径
print('text.txt的绝对路径为：', os.path.abspath('text.txt'))  #text.txt为当前文件夹下的一个文件
# os.path.exists(path):文件存在则返回True，不存在返回False
print('text.txt是否存在：', os.path.exists('text.txt'))
# os.path.getsize(path):返回文件大小，如果文件不存在就返回错误
print('text.txt的文件大小：', os.path.getsize('text.txt'))
# os.path.isfile(path):判断路径是否为文件
print('text.txt是否为文件：', os.path.isfile('text.txt'))
# os.path.isdir(path):判断路径是否为文件夹
print('text.txt是否为文件夹：', os.path.isdir('text.txt'))

步骤5，sys模块的使用

'''
sys.exit([n]) 此方法可以是当前程序退出，n为0时表示正常退出，其它值表示异常退出
'''
import sys

for i in range(100):
    print(i)
    if i == 5:
        sys.exit(0)
'''
输出结果
0
1
2
3
4
5
'''
'''
sys.path 获取模块搜索路径
'''
sys.path
'''
sys.argv 从程序外部向程序传参数，参数以列表形式传递，第一个为当前文件名
'''
# 新建test.py文件（在当前文件夹下或者桌面），写入以下代码
print(sys.argv[1])
# 在命令行中切换到文件路径，运行程序
# python text.py hello
# 获取Python解释器版本
sys.version
# 获取默认编码格式
sys.getdefaultencoding()

步骤6，time模块的使用

from logging import logThreads
import time

# time.time() 用于获取当前时间戳
time_now = time.time()
print('时间戳：', time_now)  #时间戳： 1646606123.3409111
# time.localtime() 获取时间元组
localtime = time.localtime(time_now)
print('本地时间为：', localtime)  #本地时间为： time.struct_time(tm_year=2022, tm_mon=3, tm_mday=7, tm_hour=6, tm_min=39, tm_sec=21, tm_wday=0, tm_yday=66, tm_isdst=0)
# time.asctime() 获取格式化时间
localtime = time.asctime(localtime)
print('本地时间为：', localtime)  #本地时间为： Mon Mar  7 06:40:08 2022
# time.strftime(format[,t]) 接收时间元组，并返回以可读字符串表示的当地时间，格式由参数format决定
print(time.strftime('%Y-%m-%d %H:%M:%S', time.localtime()))  #2022-03-07 06:41:44

步骤7，random模块的使用

import random

print(random.randint(1, 10))  # 产生1到10的一个整数型随机数
print(random.random())  # 产生0到1之间的随机浮点数
print(random.uniform(1.1, 5.4))  # 产生1.1到5.4之间的随机浮点数，区间可以不是
'''
整数
'''
print(random.choice('tomorrow'))  # 从序列中随机选取一个元素
print(random.randrange(1, 100, 2))  # 生成1到100的间隔为2的随机整数
print(random.sample('python', 3))  # 取3个值
list1 = [1, 2, 3, 4]
random.shuffle(list1)  # 洗牌，打乱序列
print(list1)

Python也要你的文件读写权限

实验介绍

• 本实验介绍了Python open函数的使用和Python读取常见格式的数据文件

实验代码

Python文件读写

步骤1，使用Python打开一个文本文件

'''
使用Python内建的open函数打开一个文本文件（本地已经存在的）
'''
f = open('text.txt', 'r', encoding='utf8')
print(f.read())
f.close()
'''
输出结果：
hello world
text.txt
'''
'''
文件太大时，只读取一部分
'''
f = open('text.txt', 'r', encoding='utf8')
print(f.read(1))  #h
f.close()
'''
打开一个不存在的文件（使用只读模式）
'''
f = open('t.txt', 'r', encoding='utf8')
f.read()  #FileNotFoundError: [Errno 2] No such file or directory: 't.txt'

步骤2，写入内容到文本中

'''
使用不同模式写入文本到文件中，使用w模式
'''
str_ = '''
一二三四五
六七八九十
'''
f = open('text.txt', 'w', encoding='utf8')
f.write(str_)
f.close()
'''
文本内容：

一二三四五
六七八九十

'''
'''
使用a模式写入
'''
str_ = '''
射雕英雄传/金庸
'''
f = open('text.txt', 'a', encoding='utf8')
f.write(str_)
f.close
'''
文本内容：

一二三四五
六七八九十

射雕英雄传/金庸

'''
'''
使用r模式尝试写入
'''
str_ = '''
--射雕英雄传/金庸
'''
f = open('text.txt', 'r', encoding='utf8')
f.write(str_)  #io.UnsupportedOperation: not writable
f.close()

步骤3，换个姿势读文件

'''
读取一行
'''
f = open('text.txt', 'r', encoding='utf8')
line = f.readline()
lines = f.readlines()
print(line)
print(lines)  # ['一二三四五\n', '六七八九十\n', '\n', '射雕英雄传/金庸\n']

步骤4，写入文件不关闭的后果

str_ = '''
--射雕英雄传/金庸
'''
f = open('text_new.txt', 'a', encoding='utf8')
f.write(str_)
# 此处不使用close关闭文件
'''
读取这个没保存的文件
'''
f_new = open('text_new.txt', 'r', encoding='utf8')
f_new.read()
# 输出为空

步骤5，使用flush写入硬盘

str_ = '''
射雕英雄传/金庸
'''
f = open('text_new.txt', 'a', encoding='utf8')
f.write(str_)
f.flush()
'''
不保存，直接读取
'''
f_new = open('text_new.txt', 'r', encoding='utf8')
print(f_new.read())
'''
输出内容

射雕英雄传/金庸

射雕英雄传/金庸


'''
# 在flush方法中一并写入到文件中（模式为a）

步骤6，文件操作函数

# tell
f = open('text.txt', 'r', encoding='utf8')
a = f.read(10)
print(f.tell())  #28

步骤7，上下文管理器

# 使用上下文管理器打开文件
with open('text.txt', 'a', encoding='utf8') as f:
    f.write('这本小说很好看')
with open('text.txt', 'r', encoding='utf8') as f:
    print(f.read())
'''
输出内容

一二三四五
六七八九十

射雕英雄传/金庸
这本小说很好看
'''

Python读取其他数据文件

步骤1，读取图片

'''
使用open函数读取
'''
with open('huawei_logo.png', 'r', encoding='utf8') as f:
    print(f.read())
'''
使用二进制形式打开
'''
with open('huawei_logo.png', 'rb') as f:
    img = f.read()
    print(type(img))
    print(img)
# bytes类型是指一堆字节的集合，在Python中以b开头的字符串都是bytes类型
'''
获取图片的像素矩阵
'''
import cv2

# 此处使用opencv读取，可以换其他工具
img = cv2.imread('huawei_logo.png')
print(img)

步骤2，读取音频文件

'''
使用open函数读取
'''
with open('music.wav', 'rb') as f:
    print(f.read())
'''
获取音频的矩阵表示
'''
from scipy.io import wavfile

wav_data = wavfile.read('music.wav')
wav_data

步骤3，读取CSV文件

import pandas as pd

df = pd.read_csv('air.csv', names=['city', 'pm2.5', 'level'], encoding='utf8')
df
# 读取excel文件使用read_excel方法即可，但是需要事先安装额外的依赖包xlrd