Python核心笔记1-一切皆是对象-XAMPP中文组官网

1、一切皆是对象

Python中很重要的一个特性就是，一切都是对象，包括你的代码，函数，类，方法，都是对象，函数和类相对来说比较高级，属于Python的一等公民，具有如下特性：

可以赋值给一个变量

def test():
  print('赋值给一个变量')
tt = test
tt()

可以添加到集合对象中

def test1():
    print('添加到集合对象中-1')
    
def test2():
    print('添加到集合对象中-2')
test = []
test.append(test1)
test.append(test2)
for fun in test:
    fun()

可以作为参数传递给函数

def test1(arg):
    return arg
def test2(func):
    print(func)
t1 = test1('test1 return')
test2(t1)

可以当作函数的返回值

def test1():
    return 'test1 return'
def test2():
    return test1()
print(test2())

2、类和对象

对象是面向对象编程的核心，在使用对象的过程中，为了将具有共同特征和行为的一组对象抽象定义，类。

定义类和创建对象：

# 定义类
class Car:
    # 初始化
    def __init__(self):
        self.type = 'SUV'
        self.color = '蓝色'
    # 方法
    def get_car_info(self):
        print('车类型:%s, 颜色%s' % (self.type, self.color))
    def run_car(self):
        print("启动车辆") 
        
# 创建一个对象，并用变量BMW来保存它的引用
BMW = Car()BMW.runCar()

定义类有2种写法：新式类和经典类，上面的Car为经典类，如果是Car(object)则为新式类；

__init__()方法，在创建一个对象时默认被调用，不需要手动调用

__init__(self)中，默认有1个参数名字为self，如果在创建对象时传递了2个实参，那么__init__(self)中的self作为第一个形参外还需要2个形参，例如__init__(self,x,y)

__init__(self)中的self参数，不需要开发者传递，python解释器会自动把当前的对象引用传递进去

可以把self当做C++中类里面的this指针一样理解，就是对象自身的意思

某个对象调用其方法时，python解释器会把这个对象作为第一个参数传递给self，所以开发者只需要传递后面的参数即可

在python中方法名如果是__xxxx__()的，那么就有特殊的功能，因此叫做“魔法”方法，例如__init__()

3、type，class，object三者关系

object类是所有类(class)的父类，包括type类，object类的父类为空。
type类是所有类的类型，即为所有类(class)都可由type实例化而来，包括type类自己。

4、继承

继承描述的是事物之间的所属关系，例如猫和狗都属于动物，程序中便可以描述为猫和狗继承自动物。

单继承, suv的车是车的子类；

# 定义一个父类，如下:
class Car(object):
    def __init__(self, name, color='red'):
        self.name = name
        self.color = color
      
    def run_car(self):
        print('s% -- run ...' % self.name)
# 定义一个子类，继承Car类如下:
class SuvCar(Car):
    def set_name(self, name):
        self.name = name
    
    def cross_country(self):
        print('s% -- cross_country' % self.name)
        
car_obj = SuvCar('mini')
car_obj.run_car()
car_obj.set_name('suv')
car_obj.cross_country()

多继承，报警门具备门和报警器的属性和方法

# 定义一个父类
class Base(object):
    def test(self):
        print('----base test----')
        
class A(Base):
    def test(self):
        print('----A test----')
class B(Base):
    def test(self):
        print('----B test----')
# 定义一个子类，继承自A、B
class C(A,B):
    pass

obj_C = C()
obj_C.test()
print(C.__mro__) #可以查看C类的对象搜索方法时的先后顺序

5、多态（鸭子类型）

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

所谓多态：定义时的类型和运行时的类型不一样，此时就成为多态

鸭子类型是编程语言中动态类型语言中的一种设计风格，一个对象的特征不是由父类决定，而是通过对象的方法决定的。

python的“鸭子类型”

class Base(object):
    def show(self):
        print('Base.show')
        
class AA(Base):
    def show(self):
        print('AA.show')
        
class BB(Base):
    def show(self):
        print('BB.show')
        
def func(obj):
    obj.show()
    
aa = AA()
func(aa)
bb = BB()
func(bb)

如期是多态，在func(obj)中传入的参数必须为Base类型或者他的子类；

6、类变量和实例变量

类变量

class People(object):
    name = 'eg'  #公有的类属性
    __age = 35   #私有的类属性
p = People()
print(p.name)           #正确
print(People.name)      #正确
print(p.__age)          #错误，不能在类外通过实例对象访问私有的类属性
print(People.__age)     #错误，不能在类外通过类对象访问私有的类属性

实例变量

class People(object):
    address = '山东' #类属性
    def __init__(self):
        self.name = 'xiaowang' #实例属性
        self.age = 20 #实例属性
p = People()
p.age =12 #实例属性
print(p.address) #正确
print(p.name)    #正确
print(p.age)     #正确
print(People.address) #正确
print(People.name)    #错误
print(People.age)     #错误

x : 公有变量

_x：私有话属性和方法，from xx import xx 禁止导入，类对象和子类可以访问

__x：类中私有，避免与子类重名，无法在外部直接访问

__x__ ：用户名字空间的魔法对象或属性

7、类方法、静态方法、实例方法

实例方法

定义：第一个参数必须是实例对象，该参数名一般约定为“self”，通过它来传递实例的属性和方法（也可以传类的属性和方法）；

调用：只能由实例对象调用。

类方法

定义：使用装饰器@classmethod。第一个参数必须是当前类对象，该参数名一般约定为“cls”，通过它来传递类的属性和方法（不能传实例的属性和方法）；

调用：类和实例对象都可以调用。

静态方法

定义：使用装饰器@staticmethod。参数随意，没有“self”和“cls”参数，但是方法体中不能使用类或实例的任何属性和方法；

调用：类和实例对象都可以调用。

class Date:
  def __init__(self, year, month, day):
    print "2"
    self.year = year
    self.month = month
    self.day = day
  def tomorrow(self):  # 实例方法
    self.day += 1
  @staticmethod
  def parse_from_string(date_str):
    year, month, day = tuple(date_str.split("-"))
    return Date(int(year), int(month), int(day))
  @classmethod
  def from_string(cls, date_str):     # cls为当前类
    year, month, day = tuple(date_str.split("-"))
    return cls(int(year), int(month), int(day))  #返回的是对象
  def __str__(self):
    print "1"
    return "{year}/{month}/{day}".format(year=self.year, month=self.month, day=self.day)
if __name__ == "__main__":
  new_day = Date(2020, 12, 31)
  new_day.tomorrow()
  print new_day
  # 2020-12-31
  data_str = "2020-12-31"
  year, month, day = tuple(date_str.split("-"))
  new_day = Date(int(year), int(month), int(day))
  print new_day
  # 用staticmethod完成初始化
  new_day = Date.parse_from_string(date_str)
  print new_day
  # 用classmethod完成初始化
  new_day = Date.from_string(date_str)
  print new_day

8、设计模式

工厂模式

工厂模式，顾名思义就是我们可以通过一个指定的“工厂”获得需要的“产品”。使用专门的工厂类将选择实现类、创建对象进行统一的管理和控制。解耦了生产实例和使用实例的代码，降低了维护的复杂性。

class BMW:
    pass
class BYD:
    pass
    
class CarFactory:
    def create_car(self,brand):
        if brand =="宝马":
            return BMW()
        elif brand == "比亚迪":
            return BYD()
        else:
            return "未知品牌"
factory = CarFactory()
car_byd = factory.create_car("比亚迪")

单例模式

确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类。

class Singleton(object):
    __instance = None
    __init_flag = False
   
    def __new__(cls, *args, **kwargs):
        if cls.__instance is None:
            cls.__instance = object.__new__(cls)
        return cls.__instance
        
    def __init__(self, name):
        self.name = name
        Singletion.__init_flag = True
                
test1 = Singleton('test1')
test2 = Singletion('test2')
print(id(test1))
print(id(test2))

转载请注明：XAMPP中文组官网 » Python核心笔记1-一切皆是对象

Python核心笔记1-一切皆是对象

与本文相关的文章

您必须登录才能发表评论！

与本文相关的文章

您必须 登录 才能发表评论！

您必须登录才能发表评论！