python_DAY07

最新推荐文章于 2021-12-12 21:56:33 发布
最新推荐文章于 2021-12-12 21:56:33 发布
阅读量134 收藏
点赞数
分类专栏： 日常 文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dongdZss/article/details/118480778
版权

文章目录

一、嵌套函数(内部函数)

#嵌套函数的定义
def outer():
    print('outer running')
    def inner():
        print('inner running')
    inner()
outer()

运行结果：
outer running
inner running
  • 一般在什么情况下使用嵌套函数？
  1. 封装 - 数据隐藏 ：外部无法访问“嵌套函数”。
  2. 贯彻 DRY(Don’t Repeat Yourself) 原则 ：嵌套函数，可以让我们在函数内部避免重复代码。
  3. 闭包
#使用嵌套函数避免重复代码
def ChineseName(mingzi,xingshi):
    print('{0},{1}'.format(xingshi,mingzi))
def EnglishName(mingzi,xingshi):
    print('{0},{1}'.format(mingzi,xingshi))
#使用一个函数替代上面的两个函数
def Name(isChineseName,mingzi,xingshi):
    if isChineseName:
        print('{0},{1}'.format(xingshi,mingzi))
    else:
        print('{0},{1}'.format(mingzi,xingshi))
Name(True,'善松','赵')
Name(False,'janmus','harden')

运行结果：
赵,善松
Harden,jamus

二、nonlocal 关键字

nonlocal:用来声明外层的局部变量
global:用来声明全局变量

#测试nonlacal,global关键字的测试
a=100
def outer():
    b=200
    def inner():
        nonlocal b #声明外部函数的局部变量
        print('inner b:',b)
        b=1000
        global a #声明全局变量
        a=3000
    inner()
    print('inner b:', b)
outer()
print('a:',a)
print(b)   #这里会报错  name 'b' is not defined

运行结果
inner b: 200
inner b: 1000 #nonlocal生效
a: 3000 #global生效

三、LEGB规则

  • Python 在查找“名称”时，是按照 LEGB 规则查找的：
    Local–>Enclosed–>Global–>Built in
    Local:指的就是函数或者类的方法内部
    Enclosed:指的是嵌套函数（一个函数包裹另一个函数，闭包）
    Global:指的是模块中的全局变量
    Built in:指的是 Python 为自己保留的特殊名称。
  • 如果某个 name 映射在局部(local)命名空间中没有找到，接下来就会在闭包作用域 (enclosed)进行搜索，如果闭包作用域也没有找到，Python 就会到全局(global)命名空 间中进行查找，最后会在内建(built-in)命名空间搜索 （如果一个名称在所有命名空间 中都没有找到，就会产生一个 NameError）。
#LEGB的测试
#str='global' #3.在global里面找，找到'global'，如果将其注释掉，就会在Built in中找
def outer():
    #str='outer' #2.在enclosed里面找，找到outer，如果将其注释掉，就会在global中找
    def inner():
       #str='inner' #1.在局部(local)命名空间里面找，找到inner，如果将其注释掉，就会在enclosed中找
       print(str) #4.因为str是python自己保留的特殊名称 所以最后也可以找到，如果是非特殊名称就会报错了
    inner()
outer()

四、面向对对象编程

  • 面向对象编程使程序的扩展性更强、可读性更好，使的编程可以像搭 积木一样简单。
  • 面向对象编程将数据和操作数据相关的方法封装到对象中，组织代码和数据的方式 更加接近人的思维，从而大大提高了编程的效率。
  • Python 完全采用了面向对象的思想，是真正面向对象的编程语言，完全支持面向对象的基本功能，例如：继承、多态、封装等。
  • Python 中，一切皆对象。我们在前面学习的数据类型、函数等，都是对象。
  • 注：Python 支持面向过程、面向对象、函数式编程等多种编程范式。

1. 面向对象和面向过程的区别

(1). 面向过程(Procedure Oriented)思维

*面向过程编程更加关注的是“程序的逻辑流程”，是一种“执行者”思维，适合编写小规模的程序。 面向过程思想思考问题时，我们首先思考“怎么按步骤实现？”并将步骤对应成方法， 一步一步，最终完成。 这个适合简单任务，不需要过多协作的情况下。比如，如何开车？ 我们很容易就列出实现步骤：

  1. 发动车 2. 挂挡 3.踩油门 4. 走你
  • 面向过程适合简单、不需要协作的事务。 但是当我们思考比较复杂的问题，比如“如 何造车？”，就会发现列出 1234 这样的步骤，是不可能的。那是因为，造车太复杂，需要 很多协作才能完成。此时面向对象思想就应运而生了。

(2).面向对象(Object Oriented)思维

  • 面向对象更加关注的是“软件中对象之间的关系”，是一种“设计者”思维，适合编大规模的程序。 面向对象(Object)思想更契合人的思维模式。我们首先思考的是“怎么设计这个事物？” 比如思考造车，我们就会先思考“车怎么设计？”，而不是“怎么按步骤造车的问题”。这 就是思维方式的转变。 面向对象方式思考造车，发现车由如下对象组成：
  1. 轮胎
  2. 发动机
  3. 车壳
  4. 座椅
  5. 挡风玻璃
  • 为了便于协作，我们找轮胎厂完成制造轮胎的步骤，发动机厂完成制造发动机的步骤；这样，发现大家可以同时进行车的制造，最终进行组装，大大提高了效率。但是，具体到轮胎厂的一个流水线操作，仍然是有步骤的，还是离不开面向过程思想！ 因此，面向对象可以帮助我们从宏观上把握、从整体上分析整个系统。 但是，具体到 实现部分的微观操作（就是一个个方法），仍然需要面向过程的思路去处理。 我们千万不要把面向过程和面向对象对立起来。他们是相辅相成的。面向对象离不开面 向过程！
  • 面向对象和面向过程的总结
  1. 都是解决问题的思维方式，都是代码组织的方式。
  2. 解决简单问题可以使用面向过程
  3. 解决复杂问题：宏观上使用面向对象把握，微观处理上仍然是面向过程。

2. 对象的进化

随着编程面临的问题越来越复杂，编程语言本身也在进化，从主要处理简单数据开始， 随着数据变多进化“数组”； 数据类型变复杂，进化出了“结构体”； 处理数据的方式和逻辑变复杂，进化出了“对象”。

  1. 简单数据 像 30,40，50.4 等这些数字，可以看做是简单数据。最初的计算机编程，都是像这样 的数字。
  2. 数组将同类型的数据放到一起。比如：整数数组[20,30,40]，浮点数数组[10.2, 11.3, 12.4]， 字符串数组：[“aa”,”bb”,”cc”] 。
  3. 结构体 将不同类型的数据放到一起，是 C 语言中的数据结构。比如： struct resume{ int age; char name[10]; double salary; }。
  4. 对象将不同类型的数据、方法（即函数）放到一起，就是对象。
    比如：
class Student:
	 company = "SXT" #类属性 
	 count = 0 #类属性 
	 def __init__(self,name,score): 
	 	self.name = name #实例属性
	 	self.score = score 
	 	Student.count = Student.count+1 
	 	def say_score(self): #实例方法 
	 		print("我的公司是：",Student.company)
	 		print(self.name,'的分数是：',self.score)

我们前面学习的数字也是对象。
比如：整数 9，就是一个包含了加法、乘法等方法的对象。

3. 类的定义

我们把对象比作一个“饼干”，类就是制造这个饼干的“模具”。
我们通过类定义数据类型的属性（数据）和方法（行为）,也就是说，“类将行为和状态打包在一起”。
在这里插入图片描述

  • 对象是类的具体实体，一般称为“类的实例”。类看做“饼干模具”，对象就是根据这个“模具”制造出的“饼干”。
  • 从一个类创建对象时，每个对象会共享这个类的行为（类中定义的方法），但会有自己的属性值（不共享状态）。更具体一点：“方法代码是共享的，属性数据不共享”。
    在这里插入图片描述
  • Python 中，“一切皆对象”。类也称为“类对象”，类的实例也称为“实例对象”。
    定义类的语法格式如下：
    class 类名：
    类体
    要点如下：
  1. 类名必须符合“标识符”的规则；一般规定，首字母大写，多个单词使用“驼峰原则”。
  2. 类体中我们可以定义属性和方法。
  3. 属性用来描述数据，方法(即函数)用来描述这些数据相关的操作。

4. __init__构造方法和__new__方法

  • 类是抽象的，也称之为“对象的模板”。我们需要通过类这个模板，创建类的实例对象，然 后才能使用类定义的功能。 我们前面说过一个 Python 对象包含三个部分：id（identity 识别码）、type（对象类型）、 value（对象的值）。
  • 现在，我们可以更进一步的说，一个 Python 对象包含如下部分：
  1. id（identity 识别码）
  2. type（对象类型）
  3. value（对象的值）
    (1) 属性（attribute）
    (2) 方法（method）
  • 创建对象，我们需要定义构造函数＿＿init＿＿()方法。构造方法用于执行“实例对象的初始化工作”，即对象创建后，初始化当前对象的相关属性，无返回值。
  • ＿＿init＿＿()的要点如下：
  1. 名称固定，必须为：＿＿init＿＿()
  2. 第一个参数固定，必须为：self。 self 指的就是刚刚创建好的实例对象。
  3. 构造函数通常用来初始化实例对象的实例属性，
    如下代码就是初始化实例属性：name 和 score
    def ＿＿init ＿＿(self,name,score):
    　　self.name = name 　#实例属性
    　　self.score = score
  4. 通过“类名(参数列表)”来调用构造函数。调用后，将创建好的对象返回给相应的变量。 比如：s1 = Student(‘张三’, 80)
  5. ＿＿init＿＿()方法：初始化创建好的对象，初始化指的是：“给实例属性赋值”
  6. ＿＿new＿＿()方法: 用于创建对象，但我们一般无需重定义该方法。
  7. 如果我们不定义_＿init＿＿方法，系统会提供一个默认的＿＿init＿＿方法。如果我们定义了带参 的＿＿init＿＿方法，系统不创建默认的＿＿init＿＿方法。
  • 注： Python 中的 self 相当于 C++中的 self 指针，JAVA 和 C#中的 this 关键字。Python 中， self 必须为构造函数的第一个参数，名字可以任意修改。但一般遵守惯例，都叫做 self。

5. 实例属性和实例方法

(1). 实例属性

实例属性是从属于实例对象的属性，也称为“实例变量”。他的使用有如下几个要点：

  1. 实例属性一般在＿＿init＿＿()方法中通过如下代码定义：
    　　　self.实例属性名 = 初始值
  2. 在本类的其他实例方法中，也是通过 self 进行访问：
    　　　self.实例属性名
  3. 创建实例对象后，通过实例对象访问：
    obj01 = 类名(). 　#创建对象，调用__init__()初始化属性
    obj01.实例属性名 = 值 　#可以给已有属性赋值，也可以新加属性
class Student:
    def __init__(self,name,age): #self必须位于第一个参数
        self.name=name　　#实例属性
        self.age=age
    def say_score(self):  #self必须位于第一个参数
        print('{0}的成绩为{1}'.format(self.name,self.age))
s=Student('Zfloss',23)  #通过类名调用构造函数，调用__init__()初始化属性
s.say_score()
s.salary=30000　　#可以给已有属性赋值，也可以新加属性
print(s.salary)
s1=Student('floss',23)
s1.say_score()

运行结果：
Zfloss的成绩为23
30000
floss的成绩为23

(2). 实例方法

  • 实例方法是从属于实例对象的方法。实例方法的定义格式如下：

def 方法名(self [, 形参列表])：
　　函数体
方法的调用格式如下：
　　对象.方法名([实参列表])

  • 要点：
  1. 定义实例方法时，第一个参数必须为 self。和前面一样，self 指当前的实例对象。
  2. 调用实例方法时，不需要也不能给 self 传参。self 由解释器自动传参。·
#实例方法：
class Student:
    def __init__(self,name,age): #self必须位于第一个参数
        self.name=name
        self.age=age
    def say_score(self):  #self必须位于第一个参数
        print('{0}的成绩为{1}'.format(self.name,self.age))
s=Student('Zfloss',23)  #通过类名调用构造函数
s.say_score()
s.salary=30000
print(s.salary)
s1=Student('floss',23)
s1.say_score()
Student.say_score(s1)
print(dir(s)) #可以获得对象的所有属性、方法
print(s.__dict__)  #对象的属性字典
print(isinstance(s,Student)) #判断“对象”是不是“指定类型”

运行结果：
Zfloss的成绩为23
30000
floss的成绩为23
floss的成绩为23
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'age', 'name', 'salary', 'say_score']
{'name': 'Zfloss', 'age': 23, 'salary': 30000}
True
  • 函数和方法的区别
  1. 都是用来完成一个功能的语句块，本质一样。
  2. 方法调用时，通过对象来调用。方法从属于特定实例对象，普通函数没有这个特点。
  3. 直观上看，方法定义时需要传递 self，函数不需要。

6. 类对象、类属性、类方法、静态方法

(1). 类对象

  • 我们在前面讲的类定义格式中，“class 类名：”。实际上，当解释器执行 class 语句时， 就会创建一个类对象。
【操作】测试类对象的生成 
class Student: 
	pass #空语句 
print(type(Student)) 
print(id(Student)) 
Stu2 = Student 
s1 = Stu2() 
print(s1) 

执行结果如下： 
<class 'type'> 
51686328
 <__main__.Student object at 0x0000000002B5FDD8>
  • 我们可以看到实际上生成了一个变量名就是类名“Student”的对象。我们通过赋值给新变量 Stu2，也能实现相关的调用。说明，确实创建了“类对象”。
    【注】pass 为空语句。就是表示什么都不做，只是作为一个占位符存在。当你写代码时， 遇到暂时不知道往方法或者类中加入什么时，可以先用 pass 占位，后期再补上。

(2). 类属性

  • 类属性是从属于“类对象”的属性，也称为“类变量”。由于，类属性从属于类对象，可以被所有实例对象共享。
    类属性的定义方式：

class 类名：
　　类变量名= 初始值

  • 在类中或者类的外面，我们可以通过：“类名.类变量名”来读写。
【操作】 类属性的使用测试 
class Student: 
	company = "SXT" #类属性
	count = 0 #类属性 
	def __init__(self,name,score): 
		self.name = name #实例属性
		self.score = score
		Student.count = Student.count+1 
	def say_score(self): #实例方法 
		print("我的公司是：",Student.company) 
		print(self.name,'的分数是：',self.score) 
s1 = Student('张三',80) #s1 是实例对象，自动调用__init__()方法
s1.say_score() 
print('一共创建{0}个 Student 对象'.format(Student.count)) 

执行结果： 
我的公司是： SXT 
张三 的分数是： 80 
一共创建 1 个 Student 对象

(3). 类方法

  • 类方法是从属于“类对象”的方法。类方法通过装饰器@classmethod 来定义，格式如下：

@classmethod
def 类方法名(cls [，形参列表]) ：
　　　　函数体

  • 要点如下：
  1. @classmethod 必须位于方法上面一行
  2. 第一个 cls 必须有；cls 指的就是“类对象”本身；
  3. 调用类方法格式：“类名.类方法名(参数列表)”。 参数列表中，不需要也不能给 cls 传 值。
  4. 类方法中访问实例属性和实例方法会导致错误
  5. 子类继承父类方法时，传入 cls 是子类对象，而非父类对象
#类方法的使用测试
class student:
    company='SXT'
    @classmethod
    def printCompany(cls):
        print(cls.company)
student.printCompany()

运行结果：
SXT

(4). 静态方法

  • Python 中允许定义与“类对象”无关的方法，称为“静态方法”。 “静态方法”和在模块中定义普通函数没有区别，只不过“静态方法”放到了“类的名字空 间里面”，需要通过“类调用”。
  • 静态方法通过装饰器@staticmethod 来定义，格式如下：

@staticmethod
def 静态方法名([形参列表]) ：
　　　　函数体

要点如下：

  1. @staticmethod 必须位于方法上面一行。
  2. 调用静态方法格式：“类名.静态方法名(参数列表)”。
  3. 静态方法中访问实例属性和实例方法会导致错误。
#静态方法的使用测试，
class student:
    @staticmethod
    def add(a,b):
        print('{0}+{1}={2}'.format(a,b,a+b))       
student.add(2,3)

运行结果：
2+3=5

7. 内存分析实例对象和类对象创建过程（重要）

  • 分析整个创建过程：
class student:
    company='拜师教育'
    count=0
    def __init__(self,name,age):
        self.name=name
        self.age=age
        student.count += 1
    def say(self):
        print('名字是{0}，年龄为{1}'.format(self.name,self.age))
        print('我的公司是{0}'.format(student.company))

s1=student('zz',18)
s1.say()
s1=student('zz',18)
s1.say()
print('一共创建{0}个 Student 对象'.format(student.count))

运行结果：
名字是zz，年龄为18
我的公司是拜师教育
名字是zz，年龄为18
我的公司是拜师教育
一共创建2个 Student 对象

在这里插入图片描述

8. 析构方法和垃圾回收机制

  • __del__方法称为“析构方法”，用于实现对象被销毁时所需的操作。比如：释放对象 占用的资源，例如：打开的文件资源、网络连接等。
  • Python 实现自动的垃圾回收，当对象没有被引用时（引用计数为 0），由垃圾回收器 调用__del__方法。
  • 我们也可以通过 del 语句删除对象，从而保证调用__del__方法。 系统会自动提供__del__方法，一般不需要自定义析构方法。
#析构方法
class person:
    def __del__(self):
        print('销毁对象'.format(self))
s1=person()
s2=person()
del s2   #删除s2
print("程序结束")

运行结果：
销毁对象
程序结束
销毁对象  #程序结束，s1自动被删

9. __call__方法和可调用对象

  • 定义了__call__方法的对象，称为“可调用对象”，即该对象可以像函数一样被调用。
#测试可调用方法__call__()
class SalaryAccount:
    '''工资'''
    def __call__(self, salary):
        yearsalary=salary*15
        daysalary=salary//22.5
        hoursalary=daysalary//8
        return dict(yearsalary=yearsalary,mouthsalary=salary,daysalary=daysalary,hoursalary=hoursalary)
s=SalaryAccount()
print(s(30000)) #可以像调用函数一样调用对象的__call__方法
运行结果： 
{'monthSalary': 5000, 'yearSalary': 60000, 'daySalary': 166, 'hourSalary': 20}
Zfloss
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Robin_Heath_Python_day_two
03-20
在“Robin_Heath_Python_day_two”这个主题中，我们很显然聚焦于Python编程语言的第二天学习内容。这可能是某个教程、研讨会或工作坊的一部分，由专家Robin Heath指导。Python是一种广泛使用的高级编程语言，以其...
Python零碎知识点记录
YrongA的博客
01-10 163
函数内部想要改变全局变量方式（函数内部对全局变量使用global定义）： count = 5 def test(): global count count = 10 print(count) test() print(count) 结果：10     10 什么是闭包（在一个内部函数里会在外部作用域的变量进行引用，该内部函数就是一个闭包）： 下面fun2是一个内部...
python_day1.py
10-18
python_day1.py
Python 01、python基础 7-2_PYTHON_BASE_Day07_PM.mp4
02-16
Python 01、python基础 7-2_PYTHON_BASE_Day07_PM.mp4
Python 01、python基础 7-1_PYTHON_BASE_Day07_AM.mp4
02-16
Python 01、python基础 7-1_PYTHON_BASE_Day07_AM.mp4
python_day7.py
04-07
python_day7.py
机器学习算法进阶day01
热门推荐
dongdZss的博客
12-12 2万+
fuzzywuzzy 运用了fuzzyeuzzy中的fuzz和process 复习了 apply和groupby import numpy as np import pandas as pd from fuzzywuzzy import fuzz from fuzzywuzzy import process #模糊匹配就是要导入这两个东西 暂时不细究 def enum_row(row): print(row['state']) def find_state_code(row): i
python_DAY09
dongdZss的博客
09-15 257
文章目录一、异常1.异常机制本质2. 异常解决的关键：定位3. try...一个 except 结构4. try...多个 except 结构5.try...except...else 结构6. try...except...else...finally 结构7. return 语句和异常处理问题8. 常见异常的解决9.常见异常汇总10. with上下文管理11. trackback 模块12. 自定义异常类13. pycharm开发环境的调试(1).断点(2).进入调试视图(3).调试操作区 一、异常 1
python_DAY05
dongdZss的博客
06-30 182
文章目录一、循环结构while循环 一、循环结构 while循环 while 条件表达式： 循环体语句
python_机器学习—数据科学库_DAY03
dongdZss的博客
10-10 176
numpy1. numpy基础(1). numpy创建数组(矩阵)(2). 轴(axis)(3). numpy(读取数据)(4). numpy读取和存储数据(5). numpy中的转置(6). numpy索引和切片(7). numpy中数值的修改(8). numpy中布尔索引(9). numpy中三元运算符(10). numpy中的clip(裁剪)(11). numpy中的nan和inf(12). numpy中常用统计函数(13). 解决问题(14). 数组的拼接(15). numpy更多好用的方法(16)
python_机器学习—数据科学库_DAY01&&DAY02
dongdZss的博客
10-03 166
文章目录一、matplotlib1. 相关代码操作2. 相关代码 一、matplotlib 能将数据进行可视化,更直观的呈现 使数据更加客观、更具说服力 1. 相关代码操作 直接调用matplotlib中的pyplot中的plt form matplotlib import pyplot as plt 数据在x轴上和y轴上都是可迭代对象 x=[] y=[] 传入x,y并通过plot绘制出折现图 plt.plot(x,y) plt.plot(x,y,label=’ ‘,color=’ ‘,l
python_DAY08
dongdZss的博客
07-14 164
文章目录
python_linux_DAY02
dongdZss的博客
10-27 145
linux高级命令一、重定向命令二、查看文件内容命令的使用三、链接命令(1). 软链接(2). 硬链接四、文本搜索命令五、查找文件命令六、压缩和解压缩命令七、文件权限命令八、获取管理员权限的相关命令九、用户相关操作十、用户组相关操作十一、远程登录、远程拷贝命令十二、编辑器vim十三、软件安装十四、软件卸载 一、重定向命令 重定向命令的介绍:重定向也称为输出重定向，把在终端执行命令的结果保存到目标文件。 重定向命令的使用 命令 说明 ＞如果文件存在会覆盖原有文件内容，相当于文件操作中的‘w’模式 ＞＞如果文
python_机器学习—数据科学库_DAY04&&DAY05&&DAY06
dongdZss的博客
10-12 120
pandaspandas的常用数据类型1. Series 一维，带标签数组(1). Serise的创建(2). Series切片和索引(3). Series的索引和值(4). 读取外部数据2. DataFrame 二维，Series容器(1). DataFrame的基础属性(2). DataFrame的整体情况查询3. loc与iloc4. 布尔索引5. 字符串方法6. 缺失数据的处理 numpy能够帮助我们处理数值，但是pandas除了处理数值之外(基于numpy)，还能够帮助我们处理其他类型的数据
pyhton_数据结构与算法_DAY02
dongdZss的博客
09-24 98
文章目录一、数据结构1. 算法与数据结构的区别2. 抽象数据类型(Abstract Data Type)二、顺序表 一、数据结构 1. 算法与数据结构的区别 数据结构只是静态的描述了数据元素之间的关系。 高效的程序需要在数据结构的基础上设计和选择算法。 程序 = 数据结构 + 算法 总结：算法是为了解决实际问题而设计的，数据结构是算法需要处理的问题载体 2. 抽象数据类型(Abstract Data Type) 抽象数据类型(ADT)的含义是指一个数学模型以及定义在此数学模型上的一组操作。即把数据类型
python_linux_DAY01
dongdZss的博客
10-26 98
linux基础命令一、查看目录命令的使用二、终端命令格式的组成三、查看命令帮助四、ls命令选项五、mkdir和rm命令选项cp和mv命令选项 一、查看目录命令的使用 命令 说明 ls 查看当前目录信息 tree 以树状方式显示目录信息 pwd 查看当前目录路径 clear 清除终端内容 cd 目录 切换到指定目录 cd ~ 切换到当前用户的主目录 cd … 切换到上一级目录 cd . 切换到当前目录 cd - 切换到上一次目录 绝对路径 从根目录算起的路径叫做绝对路径 相对路径 从当前目录算起的路径叫做相
python_DAY06
dongdZss的博客
07-02 95
文章目录一、测试函数也是对象二、变量的作用域(全局变量和局部变量)1. 全局变量作用的测试2. 全局变量、局部变量同名测试3. 局部变量和全局变量的效率测试三、传递对象1. 传递可变对象2. 传递不可变对象的引用三. 浅拷贝(copy)和深拷贝(deepcopy)四、参数的类型五、递归函数 一、测试函数也是对象 def test01(): print(‘我爱你，你爱我，蜜雪冰城甜蜜蜜’) pass test01() c=test01 c() print(id(test01)) print(id©) pri
python_数据结构与算法_DAY05&&DAY06&&DAY07
dongdZss的博客
09-27 81
文章目录一、栈与队列1. 栈2. 队列(1). 队列的实现(2). 双端队列二、 排序1. 冒泡排序2. 选择排序3. 插入排序 一、栈与队列 1. 栈 栈的操作 Stack() 创建一个新的空栈 push(item) 添加一个新的元素item到栈顶 pop() 弹出栈顶元素 peek() 返回栈顶元素 is_empty() 判断栈是否为空 size() 返回栈的元素个数 #coding=utf-8 class Stack(object): '''栈''' def __init__(s
使用python标识trade_day的前30天
最新发布
06-11
你可以使用Python中的pandas库来标识Trade_day的前30天，具体代码如下： ```python import pandas as pd # 读取交易日历数据集 calendar = pd.read_csv('calendar.csv') # 选择最近的交易日 latest_trade_day = ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值