欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

python高级编程——入门语法(一)

程序员文章站 2022-03-25 23:08:08
元类 在python中一切皆对象,类也是对象,只不过类是一个创建对象的对象,我们可以在类中动态的创建一个类,比如 虽然根据上述代码可以动态创建一个类,但是整个类的代码仍需要我们编写的 type()有两种作用: 1、检查对象类型 2、还有一个高大上的作用就是动态的创建类 语法:type(类名, 由父类 ......

元类

  在python中一切皆对象,类也是对象,只不过类是一个创建对象的对象,我们可以在类中动态的创建一个类,比如

def func(name):
    if name == "plane":
        class plane(object):
            pass
        return plane
     else:
        class metrorolite(object):
            pass
        return mrtroolite

  虽然根据上述代码可以动态创建一个类,但是整个类的代码仍需要我们编写的

  type()有两种作用:

    1、检查对象类型

class people(object):
    def __init__(self, id, name, employees):
        self.id = id
        self.name = name
    
    def func(self):
        return

if __name__ == "__main__":
    id = 1001
    name = "abc"
    employees = [1,2,3]
    people = people(id, name, employees)
    # 检查整型
    print(type(id))   # <class 'int'>
    # 检查字符串型
    print(type(name))   # <class 'str'>
    # 检查列表型
    print(type(employees))  # <class 'list'>
    # 检查类的对象型
    print(type(people))    #  <class '__main__.people'>
    # 检查类类型
    print(type(people))    # <class 'type'>
    # 检查函数型
    print(type(people.func))   #   <class 'method'>

# 如果我们对其结果再次type()得到的结果都是type类型,这就验证了一切解释对象

  2、还有一个高大上的作用就是动态的创建类

      语法:type(类名, 由父类名称组成的元组(可以为空), 包含属性的字典(名称和值))

      返回值是一个类

# 空类
chinese = type("people", (), {})

# 继承父类,父类以元组的形式表达
chinses = type("people", (object, ), {})

# 给类一些属性(下述都是类属性)和方法(方法可以自定义,依次是实例方法、类方法、静态方法)

def sayhi(self):
    print("hi")

@classmethod
def sayhello(cls):
    print("hello")

@staticmethod
def saybye():
    print("bye")

chinese = type("people", (object, ), {"id": 1001, "name": "zhangsan", "func1": sayhi, "func2": sayhello, "func3": saybye})

# chinese 不是类名,people是类名,chinese是一个引用变量

  元类的定义:

    元类就是用来创建类的“东西” 

    元类是类的类, 是类的模板

    元类是用来控制如何创建类的, 正如类是创建对象的模板一样,而元类的主要目的是为了控制类的创建行为 

    元类的实例化结果是我们用class定义的类,正如类的实例为对象 

    type是python的一个内建元类, 用来直接控制生成类 

    python中任何class定义的类其实都是type类实例化的对象 

    当然了,你也可以创建自己的元类,需要继承 type。

  元类的定义和使用:

    通过函数返回一个元类:

# 自定义函数
def summary(a, b):
    return a+b


# 这个函数的作用是修改当前类的属性的值和方法的功能,并且返回一个类
def upper_attr(future_class_name, future_class_parent, future_class_attr):

    # 可以修改当前类定义的属性的值和方法的功能
    newattr = {}
    for name, value in future_class_attr.items():
        if name == "bar":
            newattr[name] = "变量值修改了"
        if name == "func":
            newattr[name] = summary

    return type(future_class_name, future_class_parent, newattr)


class operation(object, metaclass=upper_attr):
    bar = "修改之前的值"
    func = none


if __name__ == "__main__":
    print(operation.bar)    # 变量值修改了
    print(operation.func(2, 4))    # 返回值6

    通过继承type生成元类(博主也没有看懂,了解即可,用到极少):

class meta(type):
    def __init__(cls, *args, **kwargs):
        super().__init__(*args)

    def __new__(cls, *args, **kwargs):
    name, bases, attrs = args
    return super().__new__(cls, name, bases, attrs)
class m_class(metaclass=meta):
  def __new__(cls, *args, **kwargs):
    return super().__new__(cls)
  def __init__(self):
    pass

 

动态语言

  静态语言和动态语言的区别:

静态语言(强类型语言)
  静态语言是在编译时变量的数据类型即可确定的语言,多数静态类型语言要 求在使用变量之前必须声明数据类型。

  例如:c++、java、delphi、c#等。

动态语言(弱类型语言)
  动态语言是在运行时确定数据类型的语言。变量使用之前不需要类型声明, 通常变量的类型是被赋值的那个值的类型。

   例如:php/asp/ruby/python/perl/abap/sql/javascript/unix shell等等。

  动态语言的特性:

    运行的过程中给对象绑定(添加)属性

    运行的过程中给类绑定(添加)属性

    运行的过程中给类绑定(添加)方法

    运行的过程中删除属性、方法

class person(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age

def show():
    print("通过类动态增加类方法.")
@classmethod
def show2(cls):
    print("通过类动态增加类方法,并且打印id.", cls.id)
    
if __name__ == "__main__":
    person = person("张三", 22)

    # 运行过程中,给对象添加属性
    person.phone = "1847015xxxx"
    print(person.phone)       # 1847015xxxx

    # 运行过程中,对象是不能添加方法,否则会报错
    # person.func = show
    # person.func()

    # 运行过程中,给类增加属性
    person.id = 10001
    print("对象访问类属性", person.id)  # 对象访问类属性10001
    print("类访问类属性", person.id)    #  类访问类属性10001
    # 运行过程中给类增加方法
    person.func = show
    person.func()               #  通过类动态增加类方法.
    # 运行过程中给类增加类方法
    person.func = show2
    person.func()           #   通过类动态增加类方法,并且打印id。10001

__slots__

  __slots__作用:

    python允许在定义class的时候,定义一个特殊变量__slots__来限制该 class能添加的属性,当前类就不能定义或者增加__slots__之外的属性了

  __slots__注意事项:

    __slots__只对类的实例化对象进行限制,不对类进行限制,__slots__变量值是以元组形式表示

    __slots__不仅限制类对象的属性,还限制类对象的方法

    __slots__仅对当前类起作用,对继承的子类不起作用

    在子类中定义__slots__,子类允许定义的属性就是自身的__slots__加上父类的 __slots__

class person(object):
    __slots__ = ("name", "age")
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
if __name__ == "__main__":
    person = person("张三", 22)
    # 运行过程中,给对象添加属性实例对象属性只限于name,age 
    # person.phone = "1847015xxxx"
    # print(person.phone)
    
    # 运行过程中,给类增加属性,__slots__ 不限制类
    person.id = 10001
    print("对象访问类属性", person.id)  # 对象访问类属性 10001
    print("类访问类属性", person.id)   # 类访问类属性 10001

 

生成器

  概念:python中,这种一边循环一边计算的机制,称为生成器:generator。

  创建生成器的两种方式:

     方法1:列表生成式的 [ ] 改成 ( )

      numbers = ( i for i in range(100))

      通过 next() 函数获得生成器的下一个返回值 

      没有更多的元素时,抛出 stopiteration 的异常 

      正确的方法是使用 for 循环,因为生成器也是可迭代对象,并且不需要关心 stopiteration 异

     方法2:使用函数创建生成器(实例)

# 斐波那契数列
def fibonacci(num):
    a = 0
    b = 1
    count = 0
    temp = 1
    while count < num:
        yield b
        a, b = b, a+b
        count += 1

fi = fibonacci(4)
print(next(fi))    # 1
print(next(fi))    # 1
print(next(fi))    # 2
print(next(fi))    # 3

# 没有更多的元素时,抛出 stopiteration 的异常
# 正确的方法是使用 for 循环,因为生成器也是可迭代对象,并且不需要关心stopiteration 异常
print(next(fi))    # error

# 所以在使用生成器的时候,需要捕获异常
fi = fibonacci(10)
while true:
    try:
        print(next(fi))
    except stopiteration as e:
        print(e)
        break

    另外生成器也可以传递参数通过send(参数值):

# 斐波那契数列
def fibonacci(num):
    a = 0
    b = 1
    count = 0
    temp = 1
    while count < num:
        temp = yield temp*b
        print("temp{}:{}".format(count, temp))
        a, b = b, a+b
        count += 1
fi = fibonacci(10)

print(next(fi))
while true:
    try:
        print(fi.send(1))
    except:
        break

迭代器

  可迭代对象:   

    这里先提一下迭代器对象,如果一个对象可以通for循环进行遍历的对象一般都是迭代器对象;python提供了一个iterable类就是鉴别对象是否是迭代器对象,在鉴别的过程中需要借助isinstance()方法,这个方法是鉴别对象是否属于一个类的对象,这里不能用type()方法,因为type()的作用是鉴别对象是否是类的实例化对象(通过继承的是false)

    首先先简单介绍两者检验对象类型的区别:

class a:
    def __init__(self):
        pass

class b(a):
    def __init__(self):
        super().__init__()

if __name__ == "__main__":
    a = 123
    # 两者检验整型,类似这种,字符串、列表、元组、集合、字典都是一样的结果
    print(type(a) == int)     # true
    print(isinstance(a, int))    # true
    
    # 两者主要的区别 直接通过类生成的对象,两者检验的结果是一样的
    b = b()
    print(type(b) == b)    # true
    print(isinstance(b, b))    # true
    # 若是父类就会有不一样的结果
    print(type(b) == a)    # false
    print(isinstance(b, a))   # true

    所以在检验对象时,采用isinstance()比较好,

from collections import iterable

class a:
    def __init__(self):
        pass

class b(a):
    def __init__(self):
        super().__init__()
    
    # 实例生成器函数
    def func(self, a):
        yield a
        a = a + 1
        if a == 5:
            return

if __name__ == "__main__":
    b = b()
    print(isinstance(b, iterable))   #  false
    # 像集合数据类型都是可迭代对象,字符串、列表、元组、集合、字典
    b = ""
    print(isinstance(b, iterable))   # true
    # 前面提到的生成器,他也是可迭代对象
    a = b()
    b = a.func(0)
    print(isinstance(b, iterable))   # true

  迭代器:

    可以被next()函数调用并不断返回下一个值的对象称为迭代器:iterator。

    可以使用 isinstance() 判断一个对象是否是 iterator 对象: 

    有两种情况是迭代器:

      1、通过生成器函数生成的生成器就是迭代器

      2、通iter()函数将可迭代对象转换成迭代器

from collections import iterator

class a:
    def __init__(self):
        pass

class b(a):
    def __init__(self):
        super().__init__()
    
    # 实例生成器函数
    def func(self, a):
        yield a
        a = a + 1
        if a == 5:
            return

if __name__ == "__main__":
    b = b()
    print(isinstance(b, iterator))   #  false
    # 像集合数据类型都是可迭代对象,字符串、列表、元组、集合、字典
    b = ""
    print(isinstance(b, iterator))   # true
    # 前面提到的生成器,他也是可迭代对象
    a = b()
    b = a.func(0)
    print(isinstance(b, iterator))   # true
    
    # 通过iter()函数将字符串、列表、元组、集合、字典转换成迭代器
    b = {}
    b = iter(b)
    print(isinstance(b, iterator))

    迭代器是可以自定义,只要重写迭代器协议的两个方法    

      迭代器对象符合迭代器协议,提供两种方法: __iter__() 和 __next__()      

      __iter__ 返回迭代器对象,并在循环开始时隐式调用。 

       __next__方法返回下一个值,并在每个循环增量处隐式调用。    

       __next__在没有更多值返回时引发stopiteration异常,循环结构隐式捕获该 异常以停止迭代。 

class counter:
    def __init__(self, low, high):
        self.current = low
        self.high = high
    
    # 生成器的一般固定写法
    def __iter__(self):
        return self
    
    # 在下面函数可以改变迭代器返回的下一个值
    def __next__(self):
        if self.current > self.high:
            raise stopiteration
        else:
            self.current += 2
            return self.current -2