[Python][华为云Python编程创造营][课堂实验代码][进阶篇]

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) #.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中的面向对象

''' 创建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!

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)

''' 在创建类并实例化对象后，动态的修改类 ''' 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'

# 定义父类 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 '''

''' 创建父类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) #哈士奇开始搞破坏啦 # 当继承多个类时，优先继承排在前面的类（同名属性和方法）

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'

''' 通过字符串的形式开判断当前对象是否存在该属性或者方法 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) ''' 输出结果： 你要喂它吃什么：- 大宝吃- 大宝吃饱了 '''

isinstance(dog, Dog) # True

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()) #这是一个静态方法

魔法方法的使用

# 在同一个类中使用这两个魔法方法 class person(): def __init__(self): print('调用init') def __new__(cls, *args, **kwargs): print('调用new') return object.__new__(cls, *args, **kwargs) p = person() ''' 输出结果： 调用new 调用init '''

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

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

# 定义对象时，不重构__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中类的属性的操作

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 --- '''

# 让方法像属性一样调用 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 #汪汪汪

''' 获取私有属性并赋值 ''' 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对应的方法即为只读

设计模式基础

# 实现手机类，通过工厂来生产不同的手机 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

# 实例化一个单例 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, '李四')

# 此处通过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文件读写

''' 使用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'

''' 使用不同模式写入文本到文件中，使用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()

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

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() # 输出为空

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）

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

# 使用上下文管理器打开文件 with open('text.txt', 'a', encoding='utf8') as f: f.write('这本小说很好看') with open('text.txt', 'r', encoding='utf8') as f: print(f.read()) ''' 输出内容 一二三四五 六七八九十 射雕英雄传/金庸 这本小说很好看 '''

Python读取其他数据文件

''' 使用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)

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

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

Python

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。