最新消息:XAMPP默认安装之后是很不安全的,我们只需要点击左方菜单的 "安全"选项,按照向导操作即可完成安全设置。

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

XAMPP案例 admin 440浏览 0评论

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类自己。

ew69

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-一切皆是对象

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