Day1 PythonWeb全栈课程课堂内容

最新推荐文章于 2024-08-16 18:55:06 发布
最新推荐文章于 2024-08-16 18:55:06 发布
阅读量270 收藏
点赞数 4
文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/FyCcheng/article/details/111148502
版权

Day1 PythonWeb全栈课程课堂内容

1. 深入类和对象

Python中一切对象，Python中的函数和类也是对象

# Python中的函数和类也是对象，证明1：
def func(name='Sam'):
    print(name)
    

if __name__ == '__main__':    
	my_func = func
	my_func('Janice')
    
    # isinstance()判断类型
    print(isinstance(my_func, object)) # True 证明myfunc是一个对象

# Python中的函数和类也是对象，证明2：
def func(name='Sam'):
    print(name)
    
    
class Func(object):
    def __init__(self, name='Janice'):
        print(name)
    

if __name__ == '__main__':
    my_func = func
    lsts = [] # 创建列表存储内容
    lsts.append(my_func)
    lsts.append(Func)
   
    for lst in lsts:# 建立循环，打印列表内容
        print(lst)
'''
<function func at 0x00000000003F2E18> # func的类型是function函数
<class '__main__.Func'> # Func的类型是class类
'''
    for lst in lsts:
        print(lst())
'''
Sam # 打印内容为func函数中print(name)的内容。
None # 函数内如果没有返回值得话，直接打印的就是空值None。
Janice # 打印内容为Func类中，方法__init__的print(name)中的内容。
<__main__.Func object at 0x0000000009FD5F28> # 返回一个类对象,类实例化。
'''
# 证明函数和类都是对象

# Python中的函数和类也是对象，证明3：中
        
def func_demo(name = 'Mike'):
    print(name)
    
    
# 构成装饰器，创建闭包
def dec():
    print('Start')
    return func_demo
    
if __name__ == '__main__':
    dec = dec()
    dec('Sam')
    
'''
Start 
Sam
'''

# dec = dec() 如同在文件中创建一个class类, 并且创建一个实例对象，例如：
class Demo:
    def er(self, name = 'Janice'):
        print('Start')
        print('name')
        
        
if __name__ == '__main__':
    dec = Demo('Sam')
    dec
'''
Start 
Sam
'''
  • 注意点：
  1. 禁止使用中文名来命名文件名。
  2. 书写规范——来自菜鸟教程

2. 魔法函数

在这里插入图片描述

class Company(object):
    def __init__(self, empl_list):
        self.emplovee = empl_list
  

company = Company(['Sam', 'Janice', 'Mike'])

for em in company.emplovee:
    print(em)
'''
Sam
Janice
Mike
'''
#----------------------------------------------------------------------------------
# 有了__getitem__的魔法函数，就不用输入company.emplovee,可以直接循环这个实例对象。例如：
class Company(object):
    def __init__(self, empl_list):
        self.emplovee = empl_list
    
    def ___getitem__(self.item):
        return self.emplovee[item]
  

company = Company(['Sam', 'Janice', 'Mike'])
for em in company:
    print(em)
'''
Sam
Janice
Mike
'''

__repr__ , __str__

class Sam(object):
    def __str__(self):
        return "this is Sam __str__"
sam = Sam()
print(sam)
'''
this is Sam __str__
'''
  • __str__ 魔法函数直接类的直接打印。把类变成一个字符串的形式。
class Sam(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age 
        
    def __str__(self):
        return "name: %s, age: %s"%(self.name, self.age)

       
sam = Sam('Sam', 26)
print(sam)
'''
name: Sam, age: 26
'''

# 如果不是用__str__魔法函数，我们则比较麻烦。需要调用类中的方法。
class Sam(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age 
    def speak(self):
        return "name: %s, age: %s"%(self.name, self.age)
    
    
sam = Sam('Sam', 26)
print(sam.speak())  
'''
name: Sam, age: 26
'''
  • __repr__ 和__str__ 所得功能相同。
class Sam(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age 
        
    def __repr__(self):
        return "name: %s, age: %s"%(self.name, self.age)

       
sam = Sam('Sam', 26)
print(sam)
'''
name: Sam, age: 26
'''

在这里插入图片描述

由此显示str比较易读，主要给用户看的。而repr主要给开发人员看的。

  • 数学函数
    在这里插入图片描述

3. 鸭子类型和多态

  • 多态的概念是应用于Java和C#这一类强类型语言中，而Python崇尚"鸭子类型"

  • 动态语言调用实例方法时不检查类型，只要方法存在，参数正确，就可以调用。这就是动态语言的“鸭子类型”，它并不要求严格的继承体系，一个对象只要“看起来像鸭子，走起路来像鸭子”，那它就可以被看做是鸭子。

a = [1, 2]
b = [3, 4]
 
a.extend(b) # [1, 2, 3, 4]
print(b)
'''
def extend(self, iterable): # real signature unknown; restored from __doc__
    """ L.extend(iterable) -> None -- extend list by appending elements from the iterable """
    pass
''' # iterable 可迭代, 说明只要可迭代的就可使用extend
c = (3, 4) 
d = {3, 4} 
a.extend(c) # [1, 2, 3, 4]
a.extend(d) # [1, 2, 3, 4]
# 这就是鸭子类型
  • 多态：定义时的类型和运行时的类型不一样，就称为多态。
class Dog(object):
    def eat(self):
        print("I want to eat dog's food")


class Cat(object):
    def eat(self):
        print("I want to eat cat's food")


class Fish(object):
    def eat(self):
        print("I want to eat fish's food")
        
        
alist = [Dog, Cat, Fish]
for animal in alist:
    animal().eat()
'''
I want to eat dog's food
I want to eat cat's food
I want to eat fish's food
'''

4. type和isinstance区别

  • type 不考虑 继承关系

  • isinstance 考虑继承关系

在这里插入图片描述

a = 1
s = 'a'
print(isinstance(a, int)) # True
print(isinstance(s, str)) # True


class A:
    pass


class B(A):
    pass


b = B()
print(isinstance(b, B))  # True isinstance考虑继承关系
print(isinstance(b, A))  # True


# is 判断地址 == 判断数值上的相等
print(type(b) is B) # True type 不会考虑继承关系
print(type(b) is A) # False

5. 类属性和实例属性

  • 基本查找顺序
class Case:
    c = 3 # 类属性
    def __init__(self, a, b):
        self.a = a # 实例属性
        self.b = b
        
case = Case(1, 2)
print(case.a, case.b, case.c) # 1, 2, 3
  • 多继承查找顺序

在这里插入图片描述

  • 实际上，python2.2(经典类)之前的算法：MRO算法，DFS(deep first search) 深度优先。

在这里插入图片描述

  • 如下图，菱形继承，执行顺序如何？

在这里插入图片描述

  • 在python2.2版本之后，引入BFS(广度优先)。

  • 在python新式类，就引入了C3算法，通过className.mro来查看。

在这里插入图片描述

# 菱形例子
class D:
    pass


class B(D):
    pass


class C():
    pass


class A(B, C):
    pass
   
print(A.__mro__)
'''
(<class '__main__.A'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.D'>, <class 'object'>)
'''

# U型例子
class D:
    pass


class B(D):
    pass


class E:
    pass


class C(E):
    pass


class A(B, C):
    pass
   
print(A.__mro__)
'''
(<class '__main__.A'>, <class '__main__.B'>, <class '__main__.D'>, <class '__main__.C'>, <class '__main__.E'>, <class 'object'>)
'''
  • 实例方法 类方法 静态方法
# 案例
class Date(object):
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day

    def tomorrow(self):  # 加一日
        self.day += 1

    def __str__(self):
        return "%s/%s/%s" % (self.year, self.month, self.day)


if __name__ == '__main__':
    day = Date(2020, 12, 9)
    day.tomorrow()
    print(day)
'''
2020/12/10
'''
# ------------------------------
# 需求将 2020-12-9 转成 2020/12/10 输出
class Date(object):
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day

    def tomorrow(self):  # 加一日
        self.day += 1

    def __str__(self):
        return "%s/%s/%s" % (self.year, self.month, self.day)


if __name__ == '__main__':
    date_str = '2020-12-9'
    year, month, day = tuple(date_str.slipt('-'))
    days = Date(int(year), int(month), int(day))
    days.tomorrow()
    print(days)
'''
2020/12/10
'''

---------------------------------------------------------
# 完善代码，将后面的需求进入方法中。
class Date(object):
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day

    def tomorrow(self):  # 加一日
        self.day += 1
    
    # 由于没有用到self，所以可以使用静态方法
    @staticmethod # 静态方法
    def parse_from_string(date_str): 
        year, month, day = tuple(date_str.slipt('-'))
        return Date(int(year), int(month), int(day)) 
        # 其中有Date 硬方法，不够完善, 如果Date类修改，则这个里面的Date也同样要修改

    def __str__(self):
        return "%s/%s/%s" % (self.year, self.month, self.day)

if __name__ == '__main__':
    date_str = '2020-12-9'
    days.parse_from_string(date_str)
    print(days)  
'''
2020/12/10
'''
------------------------------------------------
class Date(object):
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day

    def tomorrow(self):  # 加一日
        self.day += 1
    
    @classmethod # 类方法
    def parse_from_string(cls, date_str):
        year, month, day = tuple(date_str.slipt('-'))
        return cls(int(year), int(month), int(day))

    def __str__(self):
        return "%s/%s/%s" % (self.year, self.month, self.day)

if __name__ == '__main__':
    date_str = '2020-12-9'
    days.parse_from_string(date_str)
    print(days)  
'''
2020/12/10
'''

6. super()函数

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


class B(A):
    def __init__(self, name, age, weight):
        # super调用父类中的属性，不用重复输入
        super().__init__(name, age)
        self.weight = weight
        

if __name__ == '__main__':
    b = B('Sam', 26, 66)
  • super()继承
class A(object):
    def __init__(self):
        print("A")


class C(A):
    def __init__(self):
        print("B")
        super().__init__()


class B(A):
    def __init__(self):
        print("C")
        super().__init__()


class D(B,C):
    def __init__(self):
        print("D")
        super().__init__()


# D->C->A->B->A ×
if __name__ == '__main__':
    
    d = D()
'''
D
C
B
A
'''
    print(d.__mro__)
'''
(<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)
'''

7. Python对象自省机制

  • 自省是通过一定的机制查询到对象的内部结构

  • Python中比较常见的自省（introspection）机制(函数用法)有： dir()，type(), hasattr(), isinstance()，通过这些函数，我们能够在程序运行时得知对象的类型，判断对象是否存在某个属性，访问对象的属性

class Person():
    name = 'Sam'


class Student(Person):
    def __init__(self, school_name):
        self.school_name = school_name


if __name__ == '__main__':
    s = Student('Ningda')
    print(s.__dict__) # {'school_name': 'Ningda'} 查看类内部的属性，但不能查看父类的属性。
    s.__dict__['addres'] = 'Zhejiang'
    print(s.addres) # Zhejiang 打印内容
    
    print(dir(s))
    '''
    ['__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__', 'addres', 'name', 'school_name']
    '''
    print(hasattr(Student, 'school_name')) # False
    print(hasattr(s, 'school_name')) # True
小學玍
关注
  • 4
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Django+Vue：Python Web全栈开发
01-09
给大家分享一套课程——Django+Vue：Python Web全栈开发（基于Django4.1），已完结10章，附源码。
python全栈学习
10-28
通过上述内容，我们可以看出“Python全栈学习”涵盖的知识面非常广泛，从基础的Python语言学到前端技术、博客搭建、数据库操作，再到人工智能领域的机器学习和深度学习。这不仅为学习者提供了全面的技术栈学习路径，...
Django+Vue：Python Web全栈开发（附源码）
05-20
在过去的几年里，Python在Web开发领域取得了显著的成功，这主要是由于其强大的Web框架和库。在这篇文章中，我们将讨论如何使用Python构建Web应用，以及相关的核心概念、算法原理、代码实例等。 一、Python的优势 ...
Python web全栈学习路线.docx
01-10
Python Web 全栈学习路线 本资源摘要信息涵盖了 Python Web 全栈开发的学习路线，从 Linux 运维到 Python 基础、前端开发、数据库和缓存等方面都有所涉及。 Linux 运维 * Linux 安装 * 网络基础知识点 * ISO 七层...
【Python】入门到放弃之第九章《字典》
MP13537560060的博客
08-15 681
这是本系列的第九章节内容，《字典》。在Python中，字典（Dictionary）是一种内置的数据结构，用于存储键值对（key-value pairs）。字典是可变的，意味着你可以在创建字典后添加、删除或修改其中的元素。字典的键（key）必须是唯一的，并且是不可变的（即，它们必须是不可变数据类型，如字符串、数字或元组，但不能是列表或字典等可变类型）。字典的值（value）则可以是任何数据类型，包括列表、元组、字典等。以上，就是Python中字典的全部内容。
GraphRAG：复杂查询的知识图谱新框架
YeJuliaLi的博客
08-14 936
微软最近发布了名为 GraphRAG（Graphs + Retrieval Augmented Generation）的创新 RAG 框架，这是一个将文本提取、语义网络分析，与大语言模型（LLM）的提示和总结功能结合在一起的端到端系统，用于深入理解文本数据集。在对私有数据中的复杂文本信息进行文档分析时，GrahRAG 使用 LLM 生成的知识图谱来大幅提高问答性能。这里的私有数据集是指 LLM 没...
汽车免拆诊断案例 | DAF（达富）汽油尾气处理液故障警示
虹科Pico汽车示波器的博客
08-14 899
一辆DAF（达富）故障警示灯亮，提示DEF系统故障，使用虹科Pico汽车示波器检查发现故障的原因是......
C++_基本语法笔记_模板
qq_45629864的博客
08-14 439
思想是Java里的泛型（不确定用什么类型的数据）这里template这一句，意思是声明T是泛型，后面写用到泛型T的函数。建议都用应用场景：不同数据类型的交换函数。
【Python使用】嘿马头条项目从到完整开发教程第1篇：简介,1. 内容【附代码文档】
最新发布
一诺的博客
08-16 600
本教程的知识点为:简介 1. 内容 2. 目标 产品效果 ToutiaoWeb虚拟机使用说明 数据库 理解ORM 作用 思考： 使用ORM的方式选择 数据库 SQLAlchemy操作 1 新增 2 查询 all() 数据库 分布式ID 1 方案选择 2 头条 使用雪花算法 （代码 toutiao-backend/common/utils/snowflake) 数据库 Redis 1 Redis事务 基本事务指令 Python客户端操作 Git工用流 调试方法 JWT认证方案 JWT & JWS & JWE
importlib库介绍
m0_51579041的博客
08-14 217
importlib
Java读写EM4305卡、将4305卡制做成4100ID卡
zhangjin7422的专栏
08-14 405
Java读写em4305低频RFID源码，支持将EM4305卡配置成4100ID卡
SciPy：基于 NumPy 的算法库和数学工具包，用于数学、科学和工程领域。
LS_Ai的博客
08-15 953
无论是进行线性代数运算、优化问题求解、积分与微分方程处理，还是进行信号和图像处理，SciPy都提供了高度优化的工具，使得复杂的科学计算任务变得更加简单和高效。SciPy的目标是为用户提供一个全面的科学计算环境，其中涵盖了常见的线性代数、优化、积分、插值、傅里叶变换、信号处理、统计、图像处理、以及ODE（常微分方程）求解等功能。SciPy与NumPy紧密结合，同时也与Pandas、Matplotlib等库有很好的兼容性，这使得它在科学研究、数据分析和工程计算中占据了重要地位。
Android声音播放与录制
轻口味的专栏
08-16 667
例如你在听music的时候接到电话，这个时候music播放肯定会停止，此时你只能听到电话，如果你调节音量的话，这个调节肯定只对电话起作用。当电话打完了，再回到music，你肯定不用再调节音量了。而STATIC的意思是一开始创建的时候，就把音频数据放到一个固定的buffer，然后直接传给audiotrack，后续就不用一次次得write了。其实系统将这几种声音的数据分开管理，所以，这个参数对AudioTrack来说，它的含义就是告诉系统，我现在想使用的是哪种类型的声音，这样系统就可以对应管理他们了。
利用python写一个可视化的界面
huanghm88的专栏
08-08 4033
这段代码创建了一个窗口，并在窗口中添加了一个标签和一个按钮。当按钮被点击时，标签的文本会变成"Hello, World!你可以根据自己的需求修改窗口的布局和添加其他控件。要利用Python编写一个可视化界面，你可以使用一些图形库来实现，例如Tkinter、PyQt、wxPython等。
练习题：猜数字游戏、求1-100 的和 简单复习一下！
weixin_47515798的博客
08-16 171
通过while循环计算从1累加到100的和。2.有3次猜测机会，通过3层嵌套判断实现。1.数字自己产生，范围1-10。
【算法】有效的字母异位词
时清云的博客
08-13 309
针对字母异位词的问题，还有一种较为直观且高效的解法，那就是使用哈希映射（在 JavaScript 中通常是对象或 Map）。要判断两个字符串s和t是否是字母异位词，核心思想是检查两个字符串中每个字符出现的次数是否完全相同。要判断两个字符串s和t是否是字母异位词，核心思想是检查两个字符串中每个字符出现的次数是否完全相同。注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
python 字符串 详细使用方法
书山有路
08-16 224
Python中的字符串是由一系列字符组成的，可以用单引号或双引号括起来。字符串可以进行各种操作，如拼接、索引、切片等。
在Java项目中集成Jackson JSON和YAML处理库
2301_77695569的博客
08-14 649
本文将指导您如何在Java项目中集成Jackson库，用于处理JSON和YAML数据格式。通过Maven依赖配置，我们将探索如何使用进行JSON的序列化和反序列化，以及如何使用yamlMapper处理YAML格式的数据。介绍如何通过注解和配置来自定义序列化和反序列化的行为。
解决ModuleNotFoundError: No module named ‘distutils‘
che_lys的博客
08-15 218
使用python组件过程中，可能有些时候兼容问题。也可能是其他问题，网上查阅了下，也可能是跟python的版本相关，这边使用的是3.12.4，较新的版本，但是实际上我是在使用har2case组件的时候才弹出的错误，之前正常使用大部分组件没有错误。经过查阅资料，说切换或安装一个低版本的distutils组件可以解决，但是我这里实际上还不清楚使用到的组件到底是什么。
java全栈，pythonweb全栈还是啥
07-29
在选择Java全栈、Python Web全栈或其他技术栈时，取决于项目需求、团队背景和开发者个人偏好。以下是关于这两种常见选项的一些特点： **Java全栈**： - Java以其强大的企业级支持闻名，Spring Boot等框架简化了快速...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值