赞
踩
Python中有很内置数据类型,数值类型int float complex
,序列类型str list tuple range
,集合类型set frozenset
,映射类型dict
,布尔类型bool
,二进制类型bytes,bytearray
。需要使用时,他们都可以去创建实例对象。
内置数据类型可直接使用,隐式创建,不用关键字int,str等:
print(type(10))
输出<class 'int'>
print(type(10.007))
输出<class 'float'>
print(type(4 + 5j))
输出<class 'complex'>
print(type('10'))
输出<class 'str'>
print(type([1, 3, '1', 4]))
输出<class 'list'>
;print(type((1, 3, '1', 4)))
输出<class 'tuple'>
;对应可变、不可变序列。print(type(range(10)))
输出<class 'range'>
,range是内置函数,返回一个可迭代对象print(type({1, 2, 3, 3, 4}))
输出<class ‘set’>;对应可变、不可变集合;集合无序,无索引,不能切片。print(type({1: 'rat', 2: 'bat', 3: 'bird', 4: 'feather', 5: 'leather'}))
输出<class 'dict'>
;键值对形式。print(type(b'\x01\x02\x03\x04'))
输出<class 'bytes'>
同时,也可使用关键字创建实例,或实现类型转换。
在Python中,类(Class)是一种用户定义的数据类型,它允许你创建具有相同属性和方法的对象(Object)。类是对象的蓝图或模板,而对象则是根据这个蓝图创建的实例。
class Dog: # 类变量(静态变量),属于类本身,不属于类的任何实例 species = "Canis lupus familiaris" # 初始化方法,当创建类的新实例时自动调用 def __init__(self, name, age): # 实例变量(成员变量),属于类的每个实例 self.name = name self.age = age # 实例方法,属于类的实例 def bark(self): print(f"{self.name} says Woof!") # 类方法,通过装饰器@classmethod定义,属于类本身,但可以通过类实例访问 @classmethod def class_method(cls): print(f"The species of {cls.__name__} is {cls.species}") # 静态方法,通过装饰器@staticmethod定义,不属于类也不属于类的实例,只是和类关联在一起 @staticmethod def static_method(): print("This is a static method.") # 创建一个Dog类的实例 my_dog = Dog("Buddy", 3) # 访问实例变量 print(my_dog.name) # 输出: Buddy print(my_dog.age) # 输出: 3 # 调用实例方法 my_dog.bark() # 输出: Buddy says Woof! # 调用类方法 Dog.class_method() # 输出: The species of Dog is Canis lupus familiaris my_dog.class_method() # 同样可以通过实例调用类方法,但不建议这样做,因为这可能使代码更难以理解 # 调用静态方法 Dog.static_method() # 输出: This is a static method. my_dog.static_method() # 也可以通过实例调用静态方法,但同样不建议这样做
类可以将数据(属性)和操作数据的方法(函数)封装在一起,形成一个独立的单元。这种封装隐藏了对象的内部细节,只提供公共的接口供外部使用,从而实现了数据抽象:长方形
class Rectangle:
def __init__(self, width, height):
self.width = width
self.height = height
def area(self):
return self.width * self.height
# 创建一个Rectangle对象
rect = Rectangle(10, 5)
print(rect.area()) # 输出:50
类是对象的蓝图或模板,你可以使用类来创建(实例化)多个具有相同属性和方法的对象。每个对象都是类的一个实例,并且具有自己的状态(属性值)。
class Dog:
def __init__(self, name, breed):
self.name = name
self.breed = breed
# 创建两个Dog对象实例
dog1 = Dog("Buddy", "Labrador")
dog2 = Dog("Max", "Poodle")
print(dog1.name) # 输出:Buddy
print(dog2.breed) # 输出:Poodle
代码重用:通过继承(Inheritance),子类可以重用父类的属性和方法,从而避免了代码的重复编写。这有助于减少代码量,提高代码的可维护性。
实现多态性:多态性允许你使用相同的接口(方法名)来处理不同类型的对象。在Python中,这通常通过定义接口(如使用abc模块定义的抽象基类)或约定来实现。多态性使得代码更加灵活和可扩展。
class Animal: def __init__(self, name): self.name = name def speak(self): pass # 抽象方法,具体实现在子类中 def getLeatherColor(self): pass # 抽象方法,具体实现在子类中 class Dog(Animal): def speak(self): return "Woof!" def getLeatherColor(self): return 'a white dog' class Cat(Animal): def speak(self): return "Tiger!" def getLeatherColor(self): return 'an orange cat' d = Dog("Fido") c = Cat("Anne") print(d.name) # 初始化函数-重用,继承。输出:Fido print(d.speak()) # 输出:Woof! 多态 print(d.getLeatherColor()) # 输出:'a white dog' 多态 print(c.name) # 输出:Anne! 多态 print(c.speak()) # 输出:Tiger! 多态 print(c.getLeatherColor()) # 输出:'an orange cat'
类提供了一种将相关的代码组织在一起的方式。通过将相关的属性和方法封装在类中,你可以更容易地理解和维护代码。此外,类还可以用于创建模块和包,进一步组织和管理代码。
# 文件名:math_operations.py
class MathUtils:
@staticmethod
def add(a, b):
return a + b
@staticmethod
def multiply(a, b):
return a * b
# 在其他文件中
from math_operations import MathUtils
print(MathUtils.add(5, 3)) # 输出:8
注:静态方法,通过装饰器@staticmethod定义,不属于类也不属于类的实例,只是和类关联在一起 。它们就像普通的函数一样,但可以在类的命名空间下调用。
设计模式是解决常见软件设计问题的最佳实践。类是实现这些设计模式的基础。例如,你可以使用类来实现单例模式、工厂模式、观察者模式等。
以单例模式(如果此类还没有实例,就生成一个实例,如果一创建过,则返回那一个实例。)为例:
class Singleton:
_instance = None
def __new__(cls, *args, **kwargs):
if cls._instance is None:
cls._instance = super().__new__(cls)
return cls._instance
a = Singleton()
b = Singleton()
print(a is b) # 输出:True,证明a和b是同一个实例
print('a-id:', id(a)) # 输出id值
print('b-id:', id(b)) # 输出id值同上,说明是同一个内存上的同一个东西。
注: 输出id值一样,说明是同一个内存上的同一个东西。
在类的内部,你可以编写用于验证数据有效性的代码,并封装与数据相关的逻辑。这有助于确保数据的完整性和正确性,并减少错误的可能性。
class BankAccount: def __init__(self, balance): if balance < 0: raise ValueError("Balance cannot be negative.") self._balance = balance # 余额 def deposit(self, amount): # 存款:验证数据,封装逻辑 if amount < 0: raise ValueError("Deposit amount cannot be negative.") self._balance += amount #金额 def withdraw(self, amount): # 取款::验证数据,封装逻辑 if amount > self._balance or amount < 0: raise ValueError("Insufficient funds or withdrawal amount cannot be negative.") # 余额不足 self._balance -= amount def get_balance(self): # 查询余额 return self._balance
类可以用于模拟现实世界中的事物,如人、动物、汽车、房屋等。通过定义这些事物的属性和方法,你可以使用代码来模拟它们的行为和交互。
class Person: def __init__(self, name, age, gender): self.name = name self.age = age self.gender = gender def introduce(self): print(f"Hello, my name is {self.name} and I am {self.age} years old.") def greet(self, other_person): print(f"{self.name} says hello to {other_person.name}!") class Man(Person): def __init__(self, name, age): super().__init__(name, age, "Male") def goto_date(self, woman): if isinstance(woman, Woman): # 类型限定 print(f"{self.name} go to date {woman.name}!") else: print(f"{self.name} can only go to date a Woman, not a {type(woman).__name__}!") class Woman(Person): def __init__(self, name, age): super().__init__(name, age, "Female") def smile(self, man): if isinstance(man, Man): print(f"{self.name} smiles at {man.name}!") else: print(f"{self.name} can only smile at a Man, not a {type(man).__name__}!") # 创建对象并调用方法 john = Man("John", 30) alice = Woman("Alice", 25) john.introduce() alice.introduce() # 数据交互:问候 john.greet(alice) alice.greet(john) # 数据交互:特定于男人和女人的行为-约会 john.goto_date(alice) alice.smile(john) # 尝试不合适的交互(只是为了演示) john.goto_date(john) # 这应该输出一个错误消息
在这个示例中,Person
类有一个greet
方法,它允许任何Person
对象与其他Person
对象打招呼。Man
类添加了一个goto_date
方法,专门用于与Woman
对象约会。类似地,Woman
类添加了一个smile
方法,专门用于对Man
对象微笑。添加了一些类型检查,以确保flirt和smile方法只与预期的对象类型一起使用。如果传递了错误的对象类型,则会打印出错误消息。
使用类,可简化复杂系统:对于大型和复杂的系统,使用类可以帮助你简化和组织代码。通过将系统的不同部分划分为不同的类,你可以更容易地理解和维护系统的各个组件。
类提供了一个公共的接口,使得外部代码可以通过该接口与类的实例进行交互。这有助于隐藏类的内部实现细节,并使得代码更加模块化和可维护。
# 公共接口模块 class PersonInterface: @staticmethod def interact_with_person(person1, person2): person1.introduce() person2.introduce() person1.greet(person2) person2.greet(person1) # 使用示例 # Man,Woman接上一个示例 john = Man("John", 30) alice = Woman("Alice", 25) # 通过公共接口进行交互 PersonInterface.interact_with_person(john, alice)
在软件开发过程中,面向对象的分析和设计(OOAD)是一种常用的方法。类作为面向对象编程的核心概念之一,支持这种分析和设计方法,并有助于创建出更加健壮、可维护和可扩展的软件系统。
应用示例:python的GUI之计算器
Tips
__new__
方法是一个特殊的静态方法,用于实例化对象。通常不需要直接调用__new__
方法,Python
会自动调用它来分配内存空间并返回一个新对象。特殊情况下,使用__new__
方法来限制只能创建特定数量的实例;需要重写__new__
方法来控制对象的创建过程。
Copyright © 2003-2013 www.wpsshop.cn 版权所有,并保留所有权利。