2020.3.22 python笔记

最新推荐文章于 2024-07-26 21:19:18 发布
最新推荐文章于 2024-07-26 21:19:18 发布
阅读量213 收藏
点赞数
文章标签： python 设计模式 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Crammerhj/article/details/105022211
版权

文章目录

方法没有重载

在其他语言中，可以定义多个重名的方法，只要保证方法签名唯一即可。方法签名包含3个部分：方法名、参数数量、参数类型。
python中，方法的参数没有类型（调用时确定参数的类型），参数的数量也可以由可变参数控制。因此，python中是没有方法的重载的。定义一个方法即可有多种调用方式，相当于实现了其他语言中的方法的重载。
如果我们在类体中定义了多个重名的方法，只有最后一个方法有效，前面的全被覆盖。
建议：不要使用重名的方法！python中方法没有重载。

方法的动态性

python是动态语言，我们可以动态的为类添加新的方法，或者动态的修改类的已有的方法。

#测试方法的动态性
class Person:
    def work(self):
        print("努力上班")

def play_game(s):
    print("{0}在玩游戏".format(s))

def work2(s):
    print("好好工作，努力上班，赚钱")

Person.play = play_game;
p = Person()
p.work()
p.play()    #Person.play(p)

Person.work = work2

p.work()

努力上班
<__main__.Person object at 0x01A80E90>在玩游戏
好好工作，努力上班，赚钱

私有属性和私有方法（实现封装）

python对于类的成员没有严格的访问控制限制，这与其他面对对象语言有区别。关于私有属性和私有方法，有如下要点：

  1. 通常我们约定，两个下划线开头的属性是私有的（private）。其他为公共的（public）.
  2. 类内部可以访问私有属性（方法）
  3. 类外部不能直接访问私有属性（方法）
  4. 类外部可以通过“ _类名__私有属性（方法）名” 访问私有属性（方法）

【注】方法本质上也是属性！只不过是可以通过（）执行而已。所以此处讲的私有属性和公有属性，同时也讲了私有方法和公有方法的用法。如下测试中，同时也包含了私有方法和公有方法的例子。

#测试私有属性

class Employee:

    __company ="ABC"  #类变量也可以私有

    def __init__(self,name,age):
        self.name = name
        self.__age = age   #前面有下划线，变成私有属性

    def __work(self):   #此为私有方法
        print("好好工作")
        print("年龄：{0}".format(self.__age))   #自己的方法调自己的属性没有问题，别人调用不了,对外封闭
        print(Employee.__company)  #内部能调用，外部调用只能像最后一行那样调用

e = Employee("hj",18)

print(e.name)
#print(e.age)
print(e._Employee__age)   #这么写才能调用私有属性
print(dir(e))

e._Employee__work()  #调用私有方法
print(Employee._Employee__company)  #外部调用只能这么调用

hj
18
['_Employee__age', '_Employee__company', '_Employee__work', '__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__', 'name']
好好工作
年龄：18
ABC
ABC

@property装饰器

@property可以将一个方法的调用方式变成属性调用。

#测试@prorperty
class Employee:

    @property
    def salary(self):
        print("salary run ...")
        return 10000

empl = Employee(a)
#empl.salary()
print(empl.salary)

#empl.salary = 20000  #报错，不能设置属性

salary run ...
10000

例2

#@property装饰器的用法

class Employee:
    def __init__(self,name,salary):
        self.__name = name
        self.__salary = salary

    def get_salary(self):
        return self.__salary

    def set_salary(self,salary):
        if 1000<salary<50000:
            self.__salary = salary
        else:
            print("录入错误")

empl = Employee("hj",10000)
print(empl.get_salary())
empl.set_salary(-20000)
print(empl.get_salary())

利用@property装饰器的写法：

#@property装饰器的用法

class Employee:
    def __init__(self,name,salary):
        self.__name = name
        self.__salary = salary

    @property
    def salary(self):
         return self.__salary

    @salary.setter
    def salary(self,salary):
        if 1000<salary<50000:
            self.__salary = salary
        else:
            print("录入错误")



'''
    def get_salary(self):
        return self.__salary

    def set_salary(self,salary):
        if 1000<salary<50000:
            self.__salary = salary
        else:
            print("录入错误")
'''


empl = Employee("hj",10000)
#print(empl.get_salary())
#empl.set_salary(-20000)
#print(empl.get_salary())

print(empl.salary)
empl.salary = 2000
print(empl.salary)

10000
2000

面向对象三大特征介绍

python是面向对象的语言，也支持面向对象编程的三大特性：继承、封装（隐藏）、多态。

  1. 封装（隐藏）：隐藏对象的属性和实现细节，只对外提供必要的方法。相当于将细节封起来，只对外暴露相关调用方法。
  2. 继承：继承可以让子类具有父类的特性，提高了代码的重要性。从设计上是一种增量进化，原有父类设计不变的情况下，可以增加新的功能，或者改进已有的算法。
  3. 多态：多态是指同一个方法调用由于对象不同会产生不同的行为。生活中这样的例子比比皆是：同样是休息方法，人不同休息方法不同。

继承

继承是面对对象程序设计的重要特征，也是实现代码复用的重要手段。
如果一个新类继承自一个设计好的类，就直接具备了已有类的特征，就大大降低了工作难度。已有的类，我们称为父类或者基类，新的类，我们称为子类或者派生类。
语法格式
python支持多重继承，一个子类可以继承多个父类。

class 子类类名(父类1[,父类2,...])
	类体

如果在类定义中没有指定父类，则默认父类是object类。也就是说，object是所有类的父类，里面定义了一些所有类共有的默认实现，比如：__new__()。
定义子类时，必须在其构造函数中调用父类的构造函数。调用格式如下：父类名.__init__(self,参数列表)

#测试继承的基本使用
class Person:

    def __init__(self,name,age):
        self.name = name
        self.__age = age  #私有属性,私有的，继承了但不能直接用

    def say_age(self):
        print("年龄，年龄，我也不知道")

class Student(Person):  #Student继承了Person

    def __init__(self,name,age,score):
        Person.__init__(self,name,age)  #必须显式的调用父类初始化方法，不然解释器不会去调用
        self.score = score

#Student-->Person-->object类
print(Student.mro())

s = Student("hj",18,60)
s.say_age()
print(s.name)
#print(s.age)  #报错，私有的继承了，但不能直接用
print(dir(s))   #查属性
print(s._Person__age)   #这样才能调用继承的私有属性

[<class '__main__.Student'>, <class '__main__.Person'>, <class 'object'>]
年龄，年龄，我也不知道
hj
['_Person__age', '__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__', 'name', 'say_age', 'score']
18

类成员的继承和重写

  1. 成员继承：子类继承了父类除构造方法之外的所有成员
  2. 方法重写：子类可以重新定义父类中的方法，这样就会覆盖父类的方法，也称为重写。
#测试方法的重写
class Person:

    def __init__(self,name,age):
        self.name = name
        self.__age = age  #私有属性,私有的，继承了但不能直接用

    def say_age(self):
        print("我的年龄：",self.__age)

    def say_introduce(self):
        print("我的名字是{0}".format(self.name))

class Student(Person):

    def __init__(self,name,age,score):
        Person.__init__(self,name,age)  #必须显式的调用父类初始化方法，不然解释器不会去调用
        self.score = score

    def say_introduce(self):
        '''子类重写了父类的方法，相当于把父类覆盖了，再调用就是子类'''
        print("报告老师，我的名字是：{0}".format(self.name))


s = Student("hj",18,80)
s.say_age()
s.say_introduce()

我的年龄： 18
报告老师，我的名字是：hj

object根类

object类是所有类的父类，因此所有的类都有object类的属性和方法。我们显然有必要深入研究一下object类的结构。

dir（）查看对象属性

他可以让我们看到指定对象所有的属性。

#查看对象的所有属性以及和object进行对比
class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def say_age(self):
        print(self.name,"的年龄是：",self.age)

obj = object()
print(dir(obj))

s2 = Person("hj",18)
print(dir(s2))

执行结果：

['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']
['__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', 'say_age']

从上述结果看出以下要点：

  1. Person对象增加了留个属性:__dict__,__module__,__weakref__,age,name,say_age
  2. object的所有属性，Person类作为object的子类，显然包含了所有的属性
  3. 我们打印age、name、say_age，发现say_age虽然是方法，实际上也是属性。只不过，这个属性的类型是method而已
    age<class’int’>
    name<class’str’>
    say_age<class’method’>

查看类的继承层次结构

通过类的方法mro()或者类的属性__mro__可以输出这个类的继承层次结构。

#查看类的继承层次结构
class A:pass
class B(A):pass  #B继承了A
class C(B):pass   #C继承了B

print(C.mro())

[<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>]

在这里插入图片描述

重写__str__()方法

用于返回一个对于对象的描述，对应与内置函数str()经常用于print()方法，帮助我们查看对象的信息。
__str__()方法可以重写。

#测试重写object的__str__()方法

class Person:  #默认继承object类

    def __init__(self,name):
        self.name = name

    def __str__(self):
        return"名字是：{0}".format(self.name)

p = Person("hj")
print(p)

名字是：hj

多重继承

python支持多重继承，一个子类可以有多个直接父类。这样，就具备了多个父类的特点。但是由于，这样会被类的整体层次搞的异常复杂，尽量避免使用。
在这里插入图片描述

MRO()

python支持多继承，如果父类中有相同名字的方法，在子类没有指定父类名时，解释器将从左到右按顺序搜索。
MRO(Method Resolution Order):方法解析顺序。我们可以通过mro（）方法获得类的层次结构，方法解析顺序也是按照这个类的层次结构寻找的。

#测试mro()方法解析顺序

#多重继承
class A:
    def aa(self):
        print("aa")

    def say(self):
        print("say AAA!")

class B:
    def bb(self):
        print("bb")

    def say(self):
        print("say BBB!")

class C(B,A):  #B在前面，就解析B
    def cc(self):
        print("cc")

c = C()
c.cc()
c.bb()
c.aa()
print(C.mro())   #打印类的层次结构
c.say()    #解释器寻找方法是从左到右的方式寻找，此时会执行B类中的say()

cc
bb
aa
[<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>]
say BBB!

super()获得父类定义

在子类中，如果想要获得父类的方法时，我们可以通过super()来做。
super()代表父类的定义，不是父类对象。

#测试super()，代表父类的定义，而不是父类的对象

class A:

    def say(self):
        print("A:",self)

class B(A):

    def say(self):
        #A.say(self)或下行
        super().say()
        print("B:",self)

B().say()



A: <__main__.B object at 0x00730A30>
B: <__main__.B object at 0x00730A30>

多态

多态（polymorphism）是指同一个方法调用由于对象不同可能会产生不同的行为。在现实生活中，我们有很多例子，比如：中国人用筷子吃饭，英国人用刀叉吃饭。
关于多态要注意以下2点：

  1. 多态是方法的多态，属性没有多态
  2. 多态的存在有2个必要条件：继承、方法重写
#测试多态

class Man:
    def eat(self):
        print("饿了，吃饭啦！")

class Chinese(Man):
    def eat(self):
        print("中国人用筷子吃饭")

class English(Man):
    def eat(self):
        print("英国人用叉子吃饭")

class Indian(Man):
    def eat(self):
        print("印度人用右手吃饭")

def manEat(m):
    if isinstance(m,Man):
        m.eat()   #多态，一个方法调用，根据对象不同调用不同的方法
    else:
        print("不能吃饭")

manEat(Chinese())
manEat(English())

中国人用筷子吃饭
英国人用叉子吃饭

特殊方法和运算符重载

python的运算符实际上是通过调用对象的特殊方法实现的。

常见的特殊方法统计如下：
在这里插入图片描述在这里插入图片描述

每个运算符实际上都对应了相应的方法，统计如下：
在这里插入图片描述测试

#测试运算符的重载

class Person:
    def __init__(self,name):
        self.name = name

    def __add__(self,other):
        if isinstance(other,Person):
            return"{0}--{1}".format(self.name,other.name)
        else:
            return"不是同类对象，不能相加"

    def __mul__(self,other):
        if isinstance(other,int):
            return self.name*other
        else:
            return "不是同类对象，不能相乘"

p1 = Person("hj")
p2 = Person("hj2")

x = p1 + p2
print(x)

print(p1*3)

hj--hj2
hjhjhj

特殊属性

python对象中包含了很多双下划线开始和结束的属性，这些是特殊属性，有特殊用法。
这里我们列出常见的特殊属性：
在这里插入图片描述

#测试特殊属性

class A:
    pass

class B:
    pass

class C(B,A):

    def __init__(self,nn):
        self.nn = nn

    def cc(self):
        print("cc")

c = C(3)

print(dir(c))
print(c.__dict__)
print(c.__class__)  #属于哪类
print(C.__bases__)
print(C.mro())
print(A.__subclasses__())  #子类列表

['__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__', 'cc', 'nn']
{'nn': 3}
<class '__main__.C'>
(<class '__main__.B'>, <class '__main__.A'>)
[<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>]
[<class '__main__.C'>]

对象的浅拷贝和深拷贝

  1. 变量的赋值操作：只是形成两个变量，实际上还是指向同一个对象。
  2. 浅拷贝：python拷贝一般都是浅拷贝。拷贝时，对象包含的子对象内容不拷贝。因此，源对象和拷贝对象会引用同一个子对象。
  3. 深拷贝：使用copy模块的deepcopy函数，递归拷贝对象中包含的子对象。源对象和拷贝对象所有的子对象也不同。
#测试对象的浅拷贝和深拷贝
import copy

class MobilePhone:
    def __init__(self,cpu,screen):
        self.cpu = cpu
        self.screen = screen

class CPU:
    def calculate(self):
        print("算你个12345")
        print("cpu对象：",self)

class Screen:
    def show(self):
        print("显示一个好看的画面")
        print("screen对象：", self)

'''
#测试变量赋值
m1 = MobilePhone()
m2 = m1
print(m1)
print(m2)
'''

#测试变量赋值
c1 = CPU()
c2 = c1
print(c1)
print(c2)

#测试浅拷贝
print("测试浅拷贝....")
s1 = Screen()
m1 = MobilePhone(c1,s1)
m2 = copy.copy(m1)  #浅拷贝

print(m1,m1.cpu,m1.screen)
print(m2,m2.cpu,m2.screen)

#测试深拷贝
print("测试深拷贝")
m3 = copy.deepcopy(m1)
print(m1,m1.cpu,m1.screen)
print(m3,m3.cpu,m3.screen)


<__main__.CPU object at 0x00DCED50>
<__main__.CPU object at 0x00DCED50>
测试浅拷贝....
<__main__.MobilePhone object at 0x00E50A50> <__main__.CPU object at 0x00DCED50> <__main__.Screen object at 0x00E50AB0>
<__main__.MobilePhone object at 0x00E50D30> <__main__.CPU object at 0x00DCED50> <__main__.Screen object at 0x00E50AB0>
测试深拷贝
<__main__.MobilePhone object at 0x00E50A50> <__main__.CPU object at 0x00DCED50> <__main__.Screen object at 0x00E50AB0>
<__main__.MobilePhone object at 0x00F26390> <__main__.CPU object at 0x00F26470> <__main__.Screen object at 0x00F264B0>

组合

“is-a"关系，我们可以使用"继承”。从而实现子类拥有的父类的方法和属性。“is-a”关系指的是类似这样的关系：狗是动物，dog is a animal.狗类就应该继承动物类。
“has-a”关系，我们可以使用"组合"，也能实现一个类拥有另一个类的方法和属性，“has-a”关系指的是这样的关系：手机拥有CPU。MobilePhone has a CPU.

#测试组合

#使用继承实现代码的复用
class A1:
    def say_a1(self):
        print("a1,a1,a1")

class B1(A1):
    pass

b1 = B1()
b1.say_a1()

#同样的效果，使用组合实现代码的复用
class A2:
    def say_a2(self):
        print("a2,a2,a2")

class B2:
    def __init__(self,a):
        self.a = a
a2 = A2()
b2 = B2(a2)
b2.a.say_a2()


a1,a1,a1
a2,a2,a2

例2

#测试has-a关系，使用组合

class MobilePhone:
    def __init__(self,cpu,screen):
        self.cpu = cpu
        self.screen = screen

class CPU:
    def calculate(self):
        print("算你个12345")
        print("cpu对象：",self)

class Screen:
    def show(self):
        print("显示一个好看的画面")
        print("screen对象：", self)


m = MobilePhone(CPU(),Screen())
m.cpu.calculate()
m.screen.show()

算你个12345
cpu对象： <__main__.CPU object at 0x0040ED50>
显示一个好看的画面
screen对象： <__main__.Screen object at 0x00E50750>

设计模式_工厂模式实现

设计模式是面向对象语言特有的内容，使我们在面临某一类问题时候固定的做法，设计模式有很多种，比较流行的是·GOF（group of four）23种设计模式。当然我们没有必要全部学习，学习几个常用的即可。
对于初学者，我们学习两个最常用的模式：工厂模式和单例模式。
工厂模式实现了创建者和调用者的分离，使用专门的工厂类将选择实现类、创建对象进行统一的管理和控制。

#测试工厂模式

class CarFactory:
    def create_car(self,brand):
        if brand == "奔驰":
            return Benz()
        elif brand == "宝马":
            return BNM()
        elif brand == "比亚迪":
            return BYD()
        else:
            return "未知品牌，无法创建"

class Benz:
    pass

class BNM:
    pass

class BYD:
    pass

factory = CarFactory()
c1 = factory.create_car("奔驰")
c2 = factory.create_car("比亚迪")
print(c1)
print(c2)



<__main__.Benz object at 0x01A60810>
<__main__.BYD object at 0x01A60870>

设计模式_单例模式实现

单例模式（Singleton Pattern）的核心作用是确保一个类只有一个实例，并且提供一个访问该实例的全局访问点。
单例模式只生成一个实例对象，减少了对系统资源的开销。当一个对象的产生需要比较多的资源，如读取配置文件、产生其他依赖对象时，可以产生一个单例对象，然后永久驻留内存中，从而极大的降低开销。

#测试单例模式

class MySingleton:

    __obj = None     #类属性
    __init_flag = True


    def __new__(cls, *args, **kwargs):
        if cls .__obj == None:
            cls.__obj = object.__new__(cls)
        return cls.__obj

    def __init__(self,name):
        if MySingleton.__init_flag:
            print("int.....")
            self.name = name
            MySingleton.__init_flag = False

a = MySingleton("aa")
b = MySingleton("bb")
print(a)
print(b)
c = MySingleton("cc")
print(c)

int.....
<__main__.MySingleton object at 0x00A30A30>
<__main__.MySingleton object at 0x00A30A30>
<__main__.MySingleton object at 0x00A30A30>

例2

#测试工厂模式和单例模式的整合使用

class CarFactory:
    __obj = None     #类属性
    __init_flag = True


    def create_car(self,brand):
        if brand == "奔驰":
            return Benz()
        elif brand == "宝马":
            return BNM()
        elif brand == "比亚迪":
            return BYD()
        else:
            return "未知品牌，无法创建"


    def __new__(cls, *args, **kwargs):
        if cls .__obj == None:
            cls.__obj = object.__new__(cls)
        return cls.__obj

    def __init__(self):
        if CarFactory.__init_flag:
            print("int CarFactory.....")
            CarFactory.__init_flag = False

class Benz:
    pass

class BNM:
    pass

class BYD:
    pass

factory = CarFactory()
c1 = factory.create_car("奔驰")
c2 = factory.create_car("比亚迪")
print(c1)
print(c2)

factory2 = CarFactory()
print(factory)
print(factory2 )

int CarFactory.....
<__main__.Benz object at 0x01A70AD0>
<__main__.BYD object at 0x01A70A30>
<__main__.CarFactory object at 0x01A50850>
<__main__.CarFactory object at 0x01A50850>
Crammerhj
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
PyCharm 2020.3正式发布：新增一整套可提高使用Python语言开发效率工具
qq_42444778的博客
12-03 4266
PyCharm是一种Python IDE，其带有一整套可以帮助用户在使用Python语言开发时提高其效率的工具。此外，该IDE提供了一些高级功能，以用于Django框架下的专业Web开发。 PyCharm 2020.3正式发布！在2020年的最终主要版本中，我们集中精力改善一般用户体验和入门过程。 下载PYCHARM 2020.3 重点： 导入或克隆项目的环境自动配置 使用“Searcheverwhere”查找Git提交 新的Welcome界面可加快初始设置 学习和掌握Py...
2020最全面的python3安装
程序员-小枫的博客
09-17 982
Windows下python3安装 Windows下python3安装 官网下载最新版本>=3.0 https://www.python.org/downloads/ 有win，linux，mac3个版本，是什么系统就安装对应版本，注意还要看看自己的系统是32位还是64位的系统，下载的时候选择对应的 x86指32系统 x86-64指64位系统 查看方法如下 计算机，右键---属性 下载对应版本 下载后会有一个python-3.6.2-amd64.exe文件，...
求知讲堂Python2020-3.函数
the_water的博客
08-10 341
Python-函数函数基础函数参数传参调用不定长参数缺省参数函数返回值return函数嵌套调用 函数基础 函数定义： def 函数名(): 代码块 函数 函数参数 传参 调用 不定长参数 缺省参数 函数返回值 return 函数嵌套调用 ...
python学习笔记2020.3.28
qq_42758555的博客
03-28 124
#TempConvert.py TempStr = input(“请输入带有符号的温度值：”). If TempStr[-1] in ['F','f']: c = (eval(TempStr[0:1]) - 32)/1.8 print("转换后的温度是{:.2f}C".format(C)) elif TempStr[-1] in ['C','c']: F = 1.8*eval(TempS...
2020.3.21 python笔记
Crammerhj的博客
03-21 374
文章目录嵌套函数（内部函数)nanlocal关键字LEGB规则第六章 面向对象编程面向对象和面向过程区别面向过程（Procedure Oriented）思维面向对象（Object Oriented）思维面向对象和面向过程的总结对象的进化类的定义构造函数__init__()实例属性实例方法类对象类属性和类方法类属性类方法静态方法__del__()方法（析构函数）和垃圾回收机制__call__方法和可...
pycharm2019.3对应的python版本_PyCharm最新版本2019.3发布，支持Python 3.8功能的代码帮助（上）...
weixin_39678103的博客
12-08 2991
PyCharm是一种Python IDE，其带有一整套可以帮助用户在使用Python语言开发时提高其效率的工具。此外，该IDE提供了一些高级功能，以用于Django框架下的专业Web开发。PyCharm最新版本2019.3现已发布，增加用于Jupyter笔记本的交互式小部件，MongoDB支持以及所有Python 3.8功能的代码帮助，还有其他功能改进提高Python语言开发效率！PyCharm ...
python time.sleep精确延时_python3 sleep 延时秒 毫秒实例
weixin_39969568的博客
12-29 2916
一、概念理解1、json.dumps()和json.loads()是json格式处理函数(可以这么理解，json是字符串)(1)json.dumps()函数是将一个Python数据类型列表进行json格式的编码(可以这么2020-12-17 18:09:26今天有同学问，用os模块的access()能否判断一个文件是否被占用？直觉上，这是行不通的，因为access()返回的是文件的读写属性。为了确...
python语法笔记-2020.9.14
qq_40609712的博客
09-16 118
python语法笔记-2020.9.14 以下为学习python语法的一些小笔记 学习链接：https://www.runoob.com/python3/python3-basic-syntax.html 注意点： 多行注释可以用多个 # 号，还有 ‘’’ 和 “”" python最具特色的就是使用缩进来表示代码块，不需要使用大括号 {} 反斜杠可以用来转义，使用r可以让反斜杠不发生转义。。 如 r"this is a line with \n" 则\n会显示，并不是换行 字符串的截取的语法格式如下：
2020.3.19 python笔记
12-22
在本篇笔记中，我们将深入探讨函数、变量的作用域、参数传递以及相关的概念。 首先，函数在Python中被视为对象，这意味着它们可以被赋值给变量、作为参数传递给其他函数，甚至可以作为返回值。例如，`test01`函数...
python基础教程-学习笔记.pdf
10-17
- **版本选择**：推荐使用Python 3.6及以上版本，因为Python 2与Python 3存在诸多不兼容之处，且Python 2已于2020年停止支持。 - **交互式解释器**：在命令行或终端中输入`python`即可启动Python交互式环境。 - **...
Python笔记01-Python简介.pdf
06-20
在此之后，Python经历了多个版本迭代，包括2.4、2.5、2.6，直到Python 2.7，这是最后一个主要的2.x系列版本，支持将持续到2020年。同时，Python 3.x系列也在2008年开始，带来了许多重大改变，鼓励用户向更现代的3.x...
2020年秋Python大作业.zip
06-14
2020年秋Python大作业的压缩包文件，很可能是针对这个时间段内某门课程或学习小组的学习成果汇总，包含了学员们对Python语言深入理解和实践的记录。这些学习笔记和作业能够帮助我们系统地了解Python的基础知识、进阶...
Anaconda3-2020.11-Windows-x86_64.exe.zip
02-02
这个"Anaconda3-2020.11-Windows-x86_64.exe.zip"文件是Anaconda针对64位Windows系统的2020.11版本的安装程序。在下载和安装Anaconda时，用户通常会遇到速度较慢的问题，因为它是从官方服务器获取的大型文件。 ...
全网最详细Gradio教程系列5——Gradio Client: python
shao918516的博客
07-26 738
程序部署完成后，如何将Gradio App作为API访问使用呢，这就用到Gradio Client。本章讲解Gradio Client的三种使用方式：python、javascript和curl，受字数限制，所以分三篇博客发布。 使用Gradio Python Client非常易于将Gradio应用程序作为API使用，本节讲述gradio_client安装、如何连接Gradio应用程序、查看可用API及其使用方式、job及session等用法。 通过Gradio Python Cli
随机数种子的作用
帆的博客
07-23 1259
设置随机数种子（random seed）的目的是为了确保随机数生成器在每次运行时产生相同的随机数序列，从而保证实验结果的一致性。随机数种子通过初始化随机数生成器的内部状态，使得在相同的种子值下，随机数生成器每次调用时生成的序列是相同的。
安卓手机部署大模型实战
奇舞周刊
07-25 519
本文作者系360奇舞团前端开发工程师前言自ChatGPT发布以来，大语言模型（Large language model, LLM)就成了AI乃至整个计算机科学的话题中心。学术界，工业界围绕大语言模型本身及其应用展开了广泛的讨论，大量的新的实践层出不穷。由于LLM对计算资源的需求极大，有能力部署大语言模型的公司和实验室一般通过搭建集群，然后开放API或者网页demo的方式让用户可以使用模型。在人们纷...
Java实现拼图小游戏
Aishangyuwen的博客
07-22 1564
Java实现拼图小游戏
【Python】 基于Q-learning 强化学习的贪吃蛇游戏（源码+论文）【独一无二】
最新发布
测试开发自动化
07-26 998
贪吃蛇环境模块：定义了游戏规则、状态空间、动作空间，并实现了环境的重置和步进逻辑。Q-learning 算法代理模块：实现了 Q-learning 算法，用于学习和决策游戏中的动作选择。游戏窗口模块：使用 Tkinter 创建图形界面展示游戏过程，并与环境和 Q-learning 代理进行交互。该设计使得贪吃蛇游戏能够通过强化学习算法进行自动训练，并通过图形界面展示训练过程。👉👉👉 源码获取 关注【测试开发自动化】公众号，回复 “ 强化贪吃蛇 ” 获取，拿来即用。👈👈👈。
第G2周：人脸图像生成（DCGAN）
lihuhelihu的博客
07-23 967
除了生成器模型的输出层和判别器模型的输入层，在整个对抗网络的其它层上都使用了Batch Normalization，原因是Batch Normalization可以稳定学习，有助于优化初始化参数值不良而导致的训练问题。通过这些层的组合，输入的图像逐渐被降维并提取特征，最终输出一个标量值，表示输入图像被判别为真实图像的概率。总体来说，这段代码实现了GAN的训练过程，通过交替更新判别器和生成器的参数，目标是使生成器生成逼真的图像样本，同时判别器能够准确区分真实图像样本和生成图像样本。
anaconda3-2020.02-windows-x86_64.exe
08-29
anaconda3-2020.02-windows-x86_64.exe是Anaconda Python发行版的一个可执行文件。Anaconda是一个非常受欢迎的Python数据科学工具包，集成了许多常用的数据科学库和工具，使得数据科学家、研究人员和开发人员能够更轻松地进行数据分析和机器学习任务。 该可执行文件适用于Windows 64位操作系统。安装这个文件将为您提供一个完整的Python环境，包括Python解释器、命令行工具、IDE（集成开发环境）和许多常用的第三方库，如NumPy、Pandas、Matplotlib等。 安装Anaconda是数据科学家和开发人员的一个常见选择，因为它提供了一个方便的方式来管理多个Python环境，并且它的包管理器（conda）使得安装和更新各种库非常简单。 除了常用的Python库外，Anaconda还提供了许多非常有用的工具，例如Jupyter Notebook，它是一个交互式的笔记本环境，可以在其中编写和运行Python代码、查看数据可视化和分享研究成果。 总之，anaconda3-2020.02-windows-x86_64.exe是安装Anaconda Python发行版的可执行文件，它为数据科学家和开发人员提供了一个强大的Python环境和许多常用的数据科学工具，使他们能够更方便地进行数据分析和机器学习任务。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值