文章目录

  • Python 私有属性、单继承和方法重写
    • 1. 私有属性和方法
    • 2. 伪 私有属性和私有方法
    • 3. 继承
      • 3.1 继承的概念
      • 3.2 继承的语法
      • 3.3 继承的传递性
      • 3.4 多继承
    • 4. 多态
    • 5. 类属性
      • 5.1类的结构
      • 5.2 类属性和实例属性
      • 5.3 类的获取机制
    • 6. 类方法和静态方法
      • 6.1 类方法
      • 6.2 静态方法
      • 6.3 案例综合
    • 7.单例设计模式
      • 7.1 设计模式
      • 7.2 __new__ 方法
      • 7.3 Python 中的单例

Python 私有属性、单继承和方法重写

1. 私有属性和方法

  • 在实际开发中，对象 的 某些属性或方法 可能只希望 在对象的内部被使用，而 不希望在外部被访问到
  • 私有属性 就是 对象 不希望公开的 属性
  • 私有方法 就是 对象 不希望公开的 方法
  • 在 定义属性或方法时，在 属性名或者方法名前 增加 两个下划线，定义的就是 私有 属性或方法
设置私有属性之前：
class Girl:def __init__(self, name):self.name = nameself.age = 18def secret(self):print("{}的年龄是{}岁".format(self.name, self.age))
Anna = Girl("小美")
Anna.secret()
print("小美")
print(Anna.age)  # 可以从外部访问属性

私有属性在外界不能被直接访问：
class Girl:def __init__(self, name):self.name = nameself.__age = 18  # 将 age 设置成私有属性def secret(self):print("{}的年龄是{}岁".format(self.name, self.__age))
Anna = Girl("小美")
Anna.secret()
print(Anna)
# 私有属性，不能被外界访问！
print(Anna.__age)
"""
程序运行结果：
AttributeError: 'Girl' object has no attribute '__age'
"""

私有方法,在外界不能直接被调用
class Girl:# 定义属性def __init__(self, name):self.__name1 = nameself.__age = 18  # 如果希望属性不能在 外部被调用，可以定义该属性为私有 属性def __secret(self):  # 如果希望方法不能在外部被调用，可以定义该方法为 私有方法print(f"{self.__name1}的年龄是{self.__age}")
xiaomei = Girl("小美")
""" 对象不能在类的外部 访问私有属性 调用私有方法
print(xiaomei.__age)  # 对象访问属性
xiaomei.__secret()  # 对象调用方法
"""
""""
程序运行结果：
AttributeError: 'Girl' object has no attribute '__secret'
"""

2. 伪 私有属性和私有方法

Python 中，并没有 真正意义 的 私有
在给 属性、方法 命名时，实际是对 名称 做了一些特殊处理，使得外界无法访问
处理方式： 在 名称 前面加上 _类名 --> _类名__名称

提示：在日常开发中，不要使用这种方式，访问对象的 私有属性 或 私有方法

Anna = Girl("小美")
Anna._Girl__secret()
print(Anna._Girl__age)
print(Anna)

3. 继承

面向对象三大特性

  1. 封装 根据 职责 将 属性 和 方法 封装 到一个抽象的 类 中
  2. 继承 实现代码的重用，相同的代码不需要重复的编写
  3. 多态 不同的对象调用相同的方法，产生不同的执行结果，增加代码的灵活度

3.1 继承的概念

子类 拥有 父类 的所有 方法 和 属性

class Animal:def __init__(self):self.color = "grey"def eat(self):  #print("eat")def drink(self):print("drink")def run(self):print("run")def sleep(self):print("sleep")
# 创建 Dog 类，继承自 Animal类
class Dog(Animal):def bark(self):print("旺旺")
# 根据 Dog 类 创建对象
wangcai = Dog()
print(wangcai.color)  # 子类对象 能够 访问 父类 封装的 属性
wangcai.bark()  # 子类，可以根据自己的需求，来单独开发自己的 方法
# 子类对象，能够访问 父类 封装的方法
wangcai.eat()
wangcai.drink()
wangcai.run()
wangcai.sleep()
class XTQuan(Dog):def fly(self):print(" i can fly....")
xtdog = XTQuan()
xtdog.fly()
xtdog.bark()
xtdog.eat()
xtdog.sleep()

3.2 继承的语法

class 子类名(父类名)：
pass
子类 继承自 父类，可以直接 享受 父类中已经封装好的方法,不需要再次开发
子类 中应该根据 职责，封装 子类特有的 属性 和 方法

专业术语
Dog 类 是 Animal 类的 子类，Animal 类是 Dog 类的 父类，Dog 类从Animal 类 继承
Dog 类 是 Animal 类的 派生类，Animal 类是 Dog 类的 基类，Dog 类从Animal 类 派生

3.3 继承的传递性

C 类从 B 类继承，B类又从 A 类继承
那么 C 类就具有 B 类和 A 类的所有属性和方法
子类 拥有 父类 以及 父类的父类 中封装的所有 属性 和 方法

class Animal:def __init__(self):self.color = "grey"def eat(self):  #print("站起前脚，吃东西")def drink(self):print("drink"def run(self):print("run")def sleep(self):print("sleep")
class Dog(Animal):def eat(self):  # 虽然父类 有  eat 方法，但是子类在使用该方法的时候，不适合，需要对父类的方法进行重写""" 重写父类方法，1. 完全覆盖父类方法  只保留父类方法的名字，父类方法的功能不保留， 全部重写2. 在父类方法的基础上，对方法进行 扩展(保留父类方法的功能)"""super().eat()  # super().的方式，保留父类方法的功能，对父类方法进行扩展print("狗狗喜欢用盆吃东西~")def bark(self):print("旺旺")
# python 2.x 扩展继承 的写法def run(self):# print("run")Animal.run(self)  # super().run()print("蹦蹦跳跳的跑了。。。。")
wangcai = Dog()
wangcai.eat()
wangcai.run()

父类的 私有属性 和 私有方法

  • 子类对象 不能 在自己的方法内部，直接 访问 父类的 私有属性 或 私有方法
  • 子类对象 可以通过 父类 的 公有方法 间接 访问到 私有属性 或 私有方法
    • 私有属性、方法 是对象的隐私，不对外公开，外界 以及 子类 都不能直接访问
    • 私有属性、方法 通常用于做一些内部的事情
class A:def __init__(self):self.num1 = 100self.__num2 = 200  # 私有属性def __test(self):  # 私有方法print(f"我是私有方法，但是我在类的内部，可以访问 num1---> {self.num1}  &  num2--->{self.__num2}")def pub(self): # 父类的公有方法# 父类的公有方法，可以访问自己的私有属性、 调用自己的私有方法print(f"父类的公有方法，可以访问自己的私有属性--->{self.__num2}")# 父类的公有方法，可以调用自己的 私有方法self.__test()
class B(A):# 在子类的内部，能否访问 父类的私有属性def demo(self):print(f"子类能否访问父类的公有属性{self.num1}")  ## print(f"子类能否访问父类的私有属性 ? --->{self._A__num2}")  # 伪私有属性， 不推荐使用"""print(f"子类能否访问父类的私有属性 ? --->{self.__num2}") # 报错信息如下：AttributeError: 'B' object has no attribute '_B__num2'. Did you mean: '_A__num2'?"""# 在子类的内部，能否调用父类的私有方法# self._A__test()  # 伪私有方法  不推荐使用# 想要在 子类访问父类的私有方法  调用父类的私有属性？# 思路1： 在父类创建一个 共有方法，在这个方法中，访问父类的私有属性 可行！  调用父类的私有方法  可行！# 思路2： 子类能否调用父类的 公有方法？ --->可以，因为 ，子类能够继承父类的方法
obj_b = B()
obj_b.demo()
obj_b.pub()

3.4 多继承

子类 可以拥有 多个父类，并且具有 所有父类 的 属性 和 方法
例如： 孩子 会继承自己 父亲 和 母亲 的 特性

# 父类1
class Base1:def demo1(self):print("我是Base1的  demo1 方法")
# 父类2
class Base2:def demo2(self):print("我是Base2的  demo2 方法")# 子类继承自 父类
class Derived(Base1,Base2):def test(self):self.demo1()self.demo2()
obj = Derived()  # 创建的  子类对象
obj.test()
obj.demo1()
obj.demo2()

如果 不同的父类 中存在 同名的方法，子类对象 在调用方法时，会调用 哪个父类中的方法呢？
提示： 开发时，应该尽量避免这种容易产生混淆的情况！

  • 如果 父类之间 存在 同名的属性或者方法，应该 尽量避免 使用多继承

# 父类1
# class Base1:  # 本质上，父类 也继承自 object 类
class Base1(object):  # 该书写方式，默认和 class Base1: 是一样的def demo1_1(self):print("我是Base1的  demo1 方法")
# 父类2
class Base2:def demo2(self):print("我是Base2的  demo1 方法")# 子类继承自 父类
class Derived(Base2, Base1):  #def test(self):self.demo1()
obj = Derived()
# obj.test()
obj.demo1()
print(Derived.__mro__)  # 查看 Derivde 类 调用方法 或者 访问属性的 顺序
"""
(<class '__main__.Derived'>, <class '__main__.Base2'>, <class '__main__.Base1'>, <class 'object'>)
当 Derived 类的对象，在调用方法或访问属性的时候， 一个查找的路径
object  如果按照查找顺序，都找不到，最后 会在 object 类中进行查找,
如果，最后找到 object类，也没有该方法，或者属性，就会报错
object 类 是所有类的父类
"""
"""
在多继承中，父类的方法 出现重名， 子类在调用父类方法的时候，会选择先继承的 父类方法注意： 在开发中，尽量不要出现 方法同名的情况，避免出现混淆。建议： Base1---> demo1 可以修改成 demo1_1Base2--->  demo1 可以修改成  demo2_1
"""

4. 多态

  • 封装 根据 职责 将 属性 和 方法 封装 到一个抽象的 类 中 定义类的准则–
  • 继承 实现代码的重用，相同的代码不需要重复的编写
    • 设计类的技巧
    • 子类针对自己特有的需求，编写特定的代码
  • 多态 不同的 子类对象，调用相同的 父类方法，产生不同的执行结果
    • 多态 可以增加代码的灵活度
    • 以 继承 和 重写父类方法 为前提
    • 是调用方法的技巧，不会影响到类的内部设计

"""
1.在 Dog 类中封装方法 game
普通狗只是简单的玩耍
2.定义 XiaoTianDog 继承自 Dog，并重写 game 方法
哮天犬需要在天上玩耍
3.定义 Person 类，并且封装一个 和狗玩 的方法
在方法内部，直接让 狗对象 调用 game 方法
"""
class Dog(object):def __init__(self, name):self.name = namedef game(self):print(f"{self.name}在完飞盘~")
class XTDog(Dog):# 1 属性name,继承自 Dog 类，不需要重写# 2 重写 game 方法def game(self):super().game()  # 扩展父类方法print(f"{self.name} 在天上玩耍~")
wangcai = Dog("旺财")  # Dog类产生的对象
xt = XTDog("飞天旺财")  # XTDog 类产生的对象
class Person(object):def __init__(self, name):self.name = namedef game_with_dog(self, dog):print(f"{self.name}和{dog.name}快乐的玩耍~")dog.game()
xiaoming = Person("小明")
xiaoming.game_with_dog(wangcai)
xiaoming.game_with_dog(xt)

案例小结
Person 类中只需要让 狗对象 调用 game 方法，而不关心具体是 什么狗
game 方法是在 Dog 父类中定义的
在执行程序时，传入不同的 狗 对象 （这些对象可以继承自统一个父类，也可以是父类、子类的对象）实参，就会产生不同的执行效果

class Animal:def __init__(self, name):self.name = namedef eat(self):print(f"{self.name}在 eating。。。。")
class Cat(Animal):def __init__(self, name):# super(Cat, self).__init__(name)super().__init__(name)  # super(Cat, self).__init__(name)def eat(self):super(Cat, self).eat()print(f"{self.name}要吃鱼。。。")
class Mouse(Animal):def __init__(self, name):super(Mouse, self).__init__(name)def eat(self):super(Mouse, self).eat()print(f"f{self.name}吃大米。。。")
class Tiger(Animal):def __init__(self, name):super(Tiger, self).__init__(name)def eat(self):super(Tiger, self).eat()print(f"{self.name}吃肉。。。")
tom = Cat("汤姆")
jerry = Mouse("杰瑞")
tiger = Tiger("跳跳虎")
class Person(object):def feedAnimal(self,ani):print(f"饲养员喂养{ani.name}")ani.eat()
feeder = Person()
feeder.feedAnimal(tom)  # 同样是 饲养员  调用自己的  feedAnimal 这个方法，当 调用的 子类对象
feeder.feedAnimal(jerry)
feeder.feedAnimal(tiger)

5. 类属性

5.1类的结构

术语 — 实例

  1. 使用面向对象开发，第 1 步 是设计 类
  2. 使用 类名( ) 创建对象， 创建对象 的动作有两步：
    • 在内存中为对象 分配空间----》 new
    • 调用初始化方法 init 为 对象初始化
  3. 创建对象后，内存 中就有了一个对象的实实在在 的存在 — 实例

    因此，通常也会把：
  4. 创建出来的 对象 叫做 类 的 实例
  5. 创建对象的 动作 叫做 实例化
  6. 对象的属性 叫做 实例属性
  7. 对象调用的方法 叫做 实例方法

在程序执行时

  • 对象各自拥有自己的 实例属性
  • 调用对象方法，可以通过 self
    • 访问自己的属性
    • 调用自己的方法
      结论
      每一个对象，都有自己 独立的内存空间，保存各自不同的属性
      多个对象的方法，在内存中只有一份，在调用方法时，需要把对象的引用，传递到方法内部

类是一个特殊的对象
Python 中 一切皆对象：
class AAA： 定义的类属于 类对象
obj1 = AAA( ) 属于 实例对象
在程序运行时，类 同样 会被加载到内存
在 python 中，类 是一个特殊的对象 —— 类对象
在程序运行时，类对象 在内存中 只有一份，使用 一个类 可以创建出 很多个对象实例
除了封装 实例 的 属性 和 方法 外，类对象 可以拥有自己的 属性 和 方法
1.类属性
2.类方法
通过 类名. 的方式可以 访问类的属性或者 调用类的方法

5.2 类属性和实例属性

概念和使用
类属性 就是给 类对象 中定义的 属性
通常用来记录 与这个类相关 的特征
类属性 不会用于 记录 具体对象的特征

"""
定义一个 工具类
每件工具都有自己的 name 实例属性
需求 -- 知道使用这个类，创建了多少个工具对象 类属性
"""
class Tools(object):count = 0  # 类属性，用来描述 这个类 创建了多少个 实例def __init__(self, name):  # 初始化方法，是用来给对象(实例赋予属性值的)self.name = name  # 实例属性# 通过这个类创建了 多少个 对象 ，做一个计数  count# 思路： 每创建一个对象，就会调用一次 __init__(self) 方法 ，每调用一次 __init__ ，就对 count做一个 +1 的操作Tools.count += 1
tool1 = Tools("手电筒")  # 创建实例
tool2 = Tools("扳手")
tool3 = Tools("菜刀")
print(Tools.count)  # 输出  通过类创建的对象数
print(tool1.count)  # 注意： count属性，是 Tools 这个类的，但是 可以被实例访问
print(id(tool1.count), id(Tools.count))  # 1759695208752 1759695208752
tool1.count = 100  # 该定义方式，只是给 tool1 增加了一个属性 count，增加了一个 tool1.count的内存空间# 而不会改变 类属性的值
print(id(tool1.count), id(Tools.count))  # 1759695211856 1759695208752
print(Tools.count)  # --->3

5.3 类的获取机制

在 python 中 属性的获取 存在一个 向上查找机制

因此，要访问类属性有两种方式：

  • 类名.类属性
  • 对象.类属性 (不推荐)
    注意
    如果使用 对象.类属性 = 值 赋值语句，只会 给对象添加一个属性，而不会影响到 类属性的值

6. 类方法和静态方法

6.1 类方法

  • 类属性 就是针对 类对象 定义的属性

    • 使用 赋值语句 在 class 关键字 下方可以定义
    • 类属性 类属性 用于记录 与这个类相关的特征
  • 类方法 就是记录 与这个类相关 的方法
    • 在 类方法 内部可以直接访问 类属性 或者调用其他的 类方法
  • 类方法需要用 修饰器 @classmethod 来标识，告诉解释器这是一个类方法
  • 类方法的 第一个参数 应该是 cls
    • 由 哪一个类调用的方法，方法内的 cls 就是 哪一个类的引用
    • 这个参数 和 实例方法 的第一个参数 和 self 类似
    • 提示使用其他名称也可以，不过习惯使用 cls
  • 通过 类名，调用 类方法，调用方法时，不需要传递 cls 参数
    • 在方法内部 可以通过 cls，访问 类属性
    • 也可以通过 cls 调用其他的类方法
# 类属性 是用来描述 类对象  的属性
# 类方法  描述 类的 方法
"""
在 类方法 内部可以直接访问 类属性 或者调用其他的 类方法
需求:
定义一个 工具类
每件工具都有自己的 name
需求 – 在 类 封装一个 show_tool_count 的类方法，输出使用当前这个类，创建的对象个数
"""
class Tools(object):count = 0def __init__(self, name):self.name = nameTools.count += 1# 创建类方法@classmethoddef show_tool_count(cls):print(f"目前创建了 {cls.count}个 工具实例了！")  # 类方法内部，访问了类属性，也可以调用其他类方法# print(self.name)  # 类方法内部，不能访问 实例属性，也不能调用实例方法
tool1 = Tools("burpsuit")
tool2 = Tools("冰蝎")
Tools.show_tool_count()

6.2 静态方法

  • 在开发时，如果需要在 类 中封装一个方法，这个方法：

    • 既 不需要 访问 实例属性 或者 调用 实例方法
    • 也 不需要 访问 类属性 或者调用 类方法
  • 这个时候，可以把这个方法封装成一个 静态方法
  • 静态方法 需要用 修饰器 @staticmethod 来标识，告诉解释器这是一个静态方法
  • 通过 类名，调用 静态方法
class Dog:def __init__(self):self.name = "旺财"@staticmethoddef run():"""定义了一个 静态方法  静态方法不需要访问实例属性 也不需要 调用实例方法静态方法不需要访问类属性 也不需要 调用类方法"""print(f"狗跑了。。。")
wangcai = Dog()  # 根据类创建实例
wangcai.run()

6.3 案例综合

"""
1.设计一个 Game 类
2.属性
定义一个 类属性 top_score 记录游戏的 历史最高分
定义一个 实例属性 player_name 记录 当前游戏的玩家姓名
3.方法
静态方法 show_help 显示游戏帮助信息
类方法 show_top_score 显示历史最高分
实例方法 start_game 开始当前玩家的游戏
4.主程序步骤
查看帮助信息
查看历史最高分
创建游戏对象，开始游戏
"""
import random
class Game(object):top_score = 0  # 类属性，用来记录历史最高分，默认为0def __init__(self, name):  # 实例属性 ，通过__init__进行实例化self.player_name = name@staticmethod  # 静态方法def show_help():print("欢迎来到猜数字游戏。。。。")@classmethoddef show_top_score(cls):  # 类方法 ，访问了 类属性print(f"当前历史最高分是{cls.top_score}")def start_game(self):  # 实例方法print(f"{self.player_name}进入了游戏。。。。")# 开始游戏，产生了分数Game.top_score = random.randint(50, 1000)print(f"{self.player_name}在游戏中获得了{Game.top_score}分")
Game.show_help()
Game.show_top_score()
xiaoming = Game("小明。。。")
xiaoming.start_game()
Game.show_top_score()
xiaomei = Game("小美")

案例小结

  1. 实例方法 – 方法内部需要访问 实例属性
    实例方法 内部可以使用 类名. 访问类属性
  2. 类方法 – 方法内部 只 需要访问 类属性 或 其他 类方法
  3. 静态方法 – 方法内部，不需要访问 实例属性 和 类属性

7.单例设计模式

7.1 设计模式

- 设计模式 是 前人工作的总结和提炼，通常，被人们广泛流传的设计都是针对 某一特定问题 的成熟的方案
- 使用 设计模式 是为了可重用代码、让代码更容易被他人理解、保证代码可靠性
  • 单例 设计模式

    • 目的 — 让 类 创建的对象，在系统中 只有 唯一的一个实例
    • 每一次执行 类名( ) 返回的对象，内存地址是相同的
  • 单例设计模式的应用场景
    • 音乐播放
    • 回收站
    • 对象
    • 打印机
    • 对象
    • ……

7.2 new 方法

  • 使用 类名( ) 创建对象时，Python 的解释器 首先 会 调用 new 方法为对象 分配空间
  • new 是一个 由 object 基类提供的 内置的静态方法，是要作用有两个：
    • 在内存中为对象 分配空间
    • 返回 对象的引用
  • Python 的解释器获得对象的 引用 后，将引用作为 第一个参数，传递给 __init__方法

重写 new 方法的代码非常固定！

  • 重写 new 方法 一定要 return super().new(cls)， 用来返回对象的引用
  • 否则 Python的解释器 得不到 分配了空间的 对象引用，就不会调用对象的初始化方法
  • 注意： new 是一个静态方法，在调用时需要 主动传递cls 参数

7.3 Python 中的单例

单例 — 让 类 创建的对象，在系统中 只有 唯一的一个实例– 保证 引用 的唯一性
定义一个 类属性，初始值是 None ，用于记录 单例对象的引用
重写 new 方法
如果 类属性 is None，调用父类方法：new 分配空间，并在类属性中记录结果返回 类属性 中记录的 对象引用

只执行一次初始化工作

  • 在每次使用 类名( ) 创建对象时，Python 的解释器都会自动调用两个方法：

    • new 分配空间
    • init 对象初始化
  • 在对 new 方法改造后，每次都会得到 第一次被创建对象的引用
  • 但是：初始化方法还会被再次调用
'''
需求
让 初始化动作 只被执行一次
解决办法
定义一个类属性 init_flag 标记是否 执行过初始化动作，初始化值为 False
在 __init__ 方法中，判断 init_flag ,如果为 False 就执行初始化动作
然后将 init_flag 设置为 True
这样，再次 自动 调用 __init__ 方法时，初始化动作就不会被再次执行了
'''
class MusicPlayer(object):instance = None  # instance设置为初始值 None，如果 创建过对象，# 也就是 调用过 new方法了， instance 的值就不是 None了init_flag = False  # 定义一个初始值，用于标记 __init__方法，没有被再次执行def __new__(cls, *args, **kwargs):  # 重写__new__方法if cls.instance is None:  # 如果 之前没有执行过 new方法，则 cls.instance is Nonecls.instance = super().__new__(cls)  # 将 内存id 赋值给 cls.instancereturn cls.instance  # 重写 new方法后，将 内存 id　返回def __init__(self):if MusicPlayer.init_flag == True:returnprint("播放器初始化")MusicPlayer.init_flag = True
player1 = MusicPlayer()
player2 = MusicPlayer()
print(id(player1))  # 多个实例  2918561262816引用 是通过 __new__返回的
print(id(player2))

Python基础学习第八天相关推荐

  1. Python 基础课程第八天

    提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档 Python 基础课程第八天 第6 章(1) 面向对象初步 方法没有重载 方法的动态性 私有属性和私有方法(实现封装) @proper ...

  2. python自学用什么书好-适合python基础学习的好书籍

    分享几本python基础学习的书籍给大家 <Python编程:从入门到实践> 内容简介:本书是一本针对所有层次的Python 读者而作的Python 入门书.全书分两部分:第一部分介绍用P ...

  3. python心得体会-终于懂得python基础学习心得

    为了提高模块加载的速度,每个模块都会在__pycache__文件夹中放置该模块的预编译模块,命名为module.version.pyc,version是模块的预编译版本编码,一般都包含Python的版 ...

  4. python开发需要掌握哪些知识-Python基础学习需要掌握哪些知识

    1.1Python的对象 python的内置对象类型有很多,包括数字,字符串,列表,集合,元组,字典等等,在Python中,一切皆对象 pickle腌制--在Python中,如果有一些对象需要持久性存 ...

  5. Python基础学习-Python中最常见括号()、[]、{}的区别 2015-08-13 07:54 by xuxiaoxiaoxiaolu, 1138 阅读, 0 评论, 收藏, 编辑 Pytho

    Python基础学习-Python中最常见括号().[].{}的区别 2015-08-13 07:54 by xuxiaoxiaoxiaolu, 1138 阅读, 0 评论, 收藏, 编辑 Pytho ...

  6. python基础学习_转行零基础该如何学习python？很庆幸，三年前的我选对了

    这似乎是一个如荼如火的行业,对于一直在思考着转行的我,提供了一个不错的方向. 这个行业当然就是python程序员,真正开始决定转行是在24岁的时候,到现在已经有三年多了,我从零开始,每天用业余两个小时 ...

  7. Python基础学习笔记三

    Python基础学习笔记三 print和import print可以用,分割变量来输出 import copy import copy as co from copy import deepcopy ...

  8. Python基础学习笔记之（二）

    Python基础学习笔记之(二) zouxy09@qq.com http://blog.csdn.net/zouxy09 六.包与模块 1.模块module Python中每一个.py脚本定义一个模块 ...

  9. Python基础学习笔记之（一）

    Python基础学习笔记之(一) zouxy09@qq.com http://blog.csdn.net/zouxy09 前段时间参加微软的windows Azure云计算的一个小培训,其中Pytho ...

最新文章

  1. 1、java集合：java集合详解及类关系图
  2. PING的原理以及ICMP协议
  3. 原生Js_使用setInterval() 方法实现图片轮播功能
  4. boost::geometry::radius_type用法的测试程序
  5. 阿里巴巴26个前端开源项目
  6. HTML DOM 事件
  7. MFC控件(7):Split Button
  8. 爬虫-12-发送带参数的请求
  9. matlab在activex中读取视频,[转载]matlab读取excel数据并显示在excel(activex控件)中
  10. 线性代数的相关计算(numpy)
  11. Mybatis 控制台打出Sql-Log的设置
  12. PHPExcel内存溢出解决方案
  13. 机器学习cnn如何改变权值_五个机器学习悖论将改变您对数据的思考方式
  14. Vue 面试常见知识点总结
  15. 尚品宅配、欧派激战整装市场
  16. 代码赏析：子窗口对于键盘和鼠标的响应
  17. 1599-卡斯丁狗的炉石传说 ZCMU
  18. CF1005A Tanya and Stairways
  19. springboot多数据源使用
  20. python 爬取亚马逊评论_用Python爬取了三大相亲软件评论区，结果...

热门文章

  1. 波特（Baud）与比特（bit）换算详解
  2. 我的世界java版海岛种子_我的世界孤岛种子代码 1.8海岛生存种子
  3. ffmpeg断流黑屏问题分析
  4. windows 10 清理系统盘
  5. 专注年轻一代，基于E-MapReduce梨视频推荐系统
  6. mysql string agg_【转】SQL Server一个字段串拆分成多行显示或者多行数据合并成一个字符串（STRING_AGG、STRING_SPLIT）...
  7. 第4天：C语言与画面显示的练习
  8. 浏览器网页谷歌翻译-使用js脚本
  9. 琢石成器――windows环境下32位汇编语言程序设计(第三版)笔记
  10. vue的简单使用3-v-for、v-if、v-show等指令的使用