Python 学习6-Lambda 表达式、类与对象

八、Lambda 表达式

(1)Lambda 关键词定义的是匿名函数.

def good(a):
    return a**2
print(good(3)) # 9
b=lambda x:x**2
print(b(3)) # 9
c=[b(i) for i in range(13)]
print(c) #[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144]

(2)匿名函数的应用
函数式编程是指代码中每一块都是不可变的,都由纯函数的形式组成,这里的纯函数是指相互独立、互不影响对于相同的输入总有相同的输出没有任何的副作用
非函数式编程

def f(x):
    for i in range(0, len(x)):
        x[i] += 10
    return x
x = [1, 2, 3]
print(f(x))
# [11, 12, 13]

函数式编程

def f(x):
    y = []
    for item in x:
        y.append(item + 10)
    return y
x = [1, 2, 3]
print(f(x))
# [11, 12, 13]

匿名函数 主要有两种形式：
参数是函数 (filter, map)
返回值是函数 (closure)
**filter(function,iterable)**用于过滤序列,过滤掉不符合规则的元素,返回迭代器对象,要是转换为列表就用list()

good=lambda x:x%2==1
day=filter(good,[42,657,789,0,908435,23,452,7,3])
print(day) #<filter object at 0x7ff3b009e390>
print(list(day)) #[657, 789, 908435, 23, 7, 3]

*map(function,iterables)根据提供的函数对序列做指定的映射

m1 = map(lambda x: x ** 2, [1, 2, 3, 4, 5])
print(list(m1))  # [1, 4, 9, 16, 25]
m2 = map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
print(list(m2))  # [3, 7, 11, 15, 19]

九、类与对象

(1)对象=属性+方法
对象是类的实例
类主要定义对象的结构,以类为模板创建对象,类不包含方法定义,还包含所有实例共享的数据, Python中的类名约定以大写字母开头

1. 封装:信息隐蔽技术
   可以用class定义python类,关键字后边跟类的名称、分号和类的实现

class Monkey():
    #属性
    colour='red'
    high='314'
    run='fast'
    food='peach'
    #方法
    def words():
        print(123)
    def cool():
        print('fsd')
print(Monkey(),type(Monkey)) 
# <__main__.Monkey object at 0x7f1ecec680b8> <class 'type'>
Monkey.cool() # fsd
Monkey.words() #123

a=Monkey()
print(a.run) # fast
print(Monkey().colour) # red
print(a.__class__ ) # <class '__main__.Monkey'>
print(a.__class__.__name__) # Monkey

2. 继承:子类共享父类之间的数据和方法的控制

class MyList(list):
    pass
lst = MyList([1, 5, 2, 7, 8])
lst.append(9)
lst.sort(reverse=True)
print(lst) # [9, 8, 7, 5, 2, 1]

3. 多态:不同对象对同一方法相应不同的行动

class Animal:
    def run(self):
        raise AttributeError('子类必须实现这个方法')
class People(Animal):
    def run(self):
        print('人正在走')
class Pig(Animal):
    def run(self):
        print('pig is walking')
class Dog(Animal):
    def run(self):
        print('dog is running')
def func(animal):
    animal.run()
func(Pig())
# pig is walking

(2)self是什么
self相当于this指针(在成员函数内部,它可以用来指向调用对象)
类的方法与普通的函数只有一个特别的区别 —— 它们必须有一个额外的第一个参数名称(对应于该实例,即该对象本身),按照惯例它的名称是 self,在调用方法时,我们无需明确提供与参数 self 相对应的参数

class Ball:
    def setName(self, name):
        self.name = name

    def kick(self):
        print("我叫%s,该死的，谁踢我..." % self.name)
a = Ball()
a.setName("球A")
b = Ball()
b.setName("球B")
a.kick()
# 我叫球A,该死的，谁踢我...
b.kick()
# 我叫球B,该死的，谁踢我...

(3)Python的魔方方法
如果你的对象实现了这些方法中的某一个，那么这个方法就会在特殊的情况下被 Python 所调用，而这一切都是自动发生的…
类有一个名为__init__(self[, param1, param2…])的魔法方法，该方法在类实例化时会自动调用

class Ball:
    def __init__(self, name):
       self.name = name
    def kick(self):
        print("我叫%s,该死的，谁踢我..." % self.name)
a = Ball("球A")
b = Ball("球B")
a.kick()
# 我叫球A,该死的，谁踢我...
b.kick()
# 我叫球B,该死的，谁踢我...

在这里就是直接命名
(4)公有和私有
私有变量:在函数或变量名前上加上2个下划线(’__’)这个函数或变量名就变成私有的,只能在一个类中使用,另一个类中不可用,即类的外部不可用
私有属性

class JustCounter:
    __secretCount = 0  # 私有变量
    publicCount = 0  # 公开变量
    def count(self):
        self.__secretCount += 1
        self.publicCount += 1
        print(self.__secretCount)
counter = JustCounter()
counter.count()  # 1
counter.count()  # 2
print(counter.publicCount)  # 2
# Python的私有为伪私有
print(counter._JustCounter__secretCount)  # 2 
print(counter.__secretCount)  
# AttributeError: 'JustCounter' object has no attribute '__secretCount'

私有方法

class Site:
    def __init__(self, name, url):
        self.name = name  # public
        self.__url = url  # private
    def who(self):
        print('name  : ', self.name)
        print('url : ', self.__url)
    def __foo(self):  # 私有方法
        print('这是私有方法')
    def foo(self):  # 公共方法
        print('这是公共方法')
        self.__foo()
x = Site('老马的程序人生', 'https://blog.csdn.net/LSGO_MYP')
x.who()
# name  :  老马的程序人生
# url :  https://blog.csdn.net/LSGO_MYP
x.foo()
# 这是公共方法
# 这是私有方法
x.__foo()
# AttributeError: 'Site' object has no attribute '__foo'

(5)继承

class People():
    name=' '
    age=0
    __weight=0
    def __init__(self,n,a,w):
        self.name=n
        self.age=a
        self.__weight=w
    def say(self):
        print("%s年龄是%d体重是%d" %(self.name,self.age,self.__weight))
a=People('梨花',423,312).say() #梨花年龄是423体重是312
#继承 单继承
class Stu(People):
    grade=0
    def __init__(self,n,a,w,g):
        #调用父类的
        people.__init__(self,n,a,w)
        self.grade=g
    def speak(self):
        print("%s年龄是%d体重是%d年级是%d" %(self.name,self.age,self.__weight,self.grade))
    def speak1(self):
        print("%s年龄是%d年级是%d" %(self.name,self.age,self.grade))
b1=Stu('啥的大苏打',42,1,6).speak1() 
# 啥的大苏打年龄是42年级是6
b2=Stu('啥的大苏打',42,54,6).speak()  
# AttributeError: 'Stu' object has no attribute '_Stu__weight'

多重继承

class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
#单继承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))
#另一个类，多重继承之前的准备
class speaker():
    topic = ''
    name = ''
    def __init__(self,n,t):
        self.name = n
        self.topic = t
    def speak(self):
        print("我叫 %s，我是一个演说家，我演讲的主题是 %s"%(self.name,self.topic))
#多重继承
class sample(speaker,student):
    a =''
    def __init__(self,n,a,w,g,t):
        student.__init__(self,n,a,w,g)
        speaker.__init__(self,n,t)

test = sample("Tim",25,80,4,"Python")
test.speak()   #方法名同，默认调用的是在括号中排前地父类的方法

多重继承和单继承类似,就是多个类去继承之前的类
在单继承中若把speak改为say就成了第二个覆盖了第一个
(6)组合

class Turtle:
    def __init__(self, x):
        self.num = x
class Fish:
    def __init__(self, x):
        self.num = x
class Pool:
    def __init__(self, x, y):
        self.turtle = Turtle(x)
        self.fish = Fish(y)
    def print_num(self):
        print("水池里面有乌龟%s只，小鱼%s条" % (self.turtle.num, self.fish.num))
p = Pool(2, 3)
p.print_num()
# 水池里面有乌龟2只，小鱼3条

(7)类、类对象、类绑定实例

类对象:创建一个类,其实也是一个对象也在内存开辟了一块空间,称为类对象,类对象只有一个
实例对象:就是通过实例化类创建的对象,称为实例对象,实例对象可以有多个

class A(object):
    pass
# 实例化对象 a、b、c都属于实例对象。
a = A()
b = A()
c = A()

类属性:类里面方法外面定义的变量称为类属性,类属性所属于类对象并且多个实例对象之间共享同一个类属性,说白了就是类属性所有的通过该类实例化的对象都能共享

class A():
    a = 0  #类属性
    def __init__(self, xx):  #__init__是类的方法
        A.a = xx  #使用类属性可以通过 （类名.类属性）调用。

实例属性：实例属性和具体的某个实例对象有关系,并且一个实例对象和另外一个实例对象是不共享属性的,说白了实例属性只能在自己的对象里面使用,其他的对象不能直接使用,因为self是谁调用,它的值就属于该对象

# 创建类对象
class Test(object):
    class_attr = 100  # 类属性
    def __init__(self):
        self.sl_attr = 100  # 实例属性
    def func(self):
        print('类对象.类属性的值:', Test.class_attr)  # 调用类属性
        print('self.类属性的值', self.class_attr)  
        							# 相当于把类属性 变成实例属性
        print('self.实例属性的值', self.sl_attr)  # 调用实例属性
        
a = Test()							a.class_attr = 200
a.func()							a.sl_attr = 200
									a.func()
# 类对象.类属性的值: 100				# 类对象.类属性的值: 100
# self.类属性的值 100				# self.类属性的值 200
# self.实例属性的值 100				# self.实例属性的值 200

Test.class_attr = 300
a.func()
# 类对象.类属性的值: 300
# self.类属性的值 200
# self.实例属性的值 200

a.class_attr=200只修改了a这个实例的class_attr属性的值，所有Test.class_attr还是没有变为100，self.class_attr被修改成了200
同理Test.class_attr只修改了Test这个类的属性值，示例a的属性值并没有被修改
(8)什么是绑定
Python 对象的数据属性通常存储在名为.__ dict__的字典中,我们可以直接访问__dict__,或利用 Python 的内置函数vars()获取.__ dict__

class Good():
    def setXY(self,x,y):
        self.x=x
        self.y=y
    def printXY(self):
        print(self.x,self.y)
a=Good()
print(a.__dict__) #{}
print(vars(a)) #{}
a.setXY(213,2345)
print(vars(a)) #{'x': 213, 'y': 2345}
print(Good.__dict__)
#{'__module__': '__main__', 'setXY': <function Good.setXY at 0x7f96401a5400>, 'printXY': <function Good.printXY at 0x7f96401a5488>, '__dict__': <attribute '__dict__' of 'Good' objects>, '__weakref__': <attribute '__weakref__' of 'Good' objects>, '__doc__': None}

(9)一些内置函数

1. issubclass
   issubclass(A,B)来判断A是不是B的子类,一个类被认为是自身的子类,classinfo可以是类对象的元组，只要class是其中任何一个候选类的子类，则返回True

class A:
    pass
class B:
    pass
class C(A):
    pass
print(issubclass(A,B)) #False
print(issubclass(B,A)) #False
print(issubclass(A,C)) #False
print(issubclass(C,A)) #True

pass实在没有内容时,能自动运行下去的一个语句

2. isinstance
   isinstance(object, classinfo)方法用于判断一个对象是否是一个已知的类型,类似type(),type()不会认为子类是一种父类类型,不考虑继承关系,isinstance()会认为子类是一种父类类型,考虑继承关系

a = 2
print(isinstance(a, int))  # True
print(isinstance(a, str))  # False
print(isinstance(a, (str, int, list)))  # True

3. hasattr
   hasattr(object, name)用于判断对象是否包含对应的属性

class A:
    dsad=31
    x=321
    q=-312
B=A()
print(hasattr(B,'x')) #True
print(hasattr(B,'dasd')) #False
print(hasattr(B,'d')) #False

4. getattr
   getattr(object, name[, default])用于返回一个对象属性值

class A(object):
    bar = 1
a = A()
print(getattr(a, 'bar'))  # 1
print(getattr(a, 'bar2', 3))  # 3
print(getattr(a, 'bar2'))
# AttributeError: 'A' object has no attribute 'bar2'

5. setattr
   setattr(object, name, value)对应函数 getattr(),用于设置属性值,该属性不一定是存在的

class A():
    a=1
b=A()
print(getattr(b,'a')) #1
setattr(b,'a',13)
print(b.a) #13
setattr(b,'c',312)
print(b.c) #312

6. delattr
   delattr(object, name)用于删除属性

class A():
    a=1
b=A()
print(hasattr(b,'a')) #True
print(getattr(b,'a')) #1
delattr(A,'a')
setattr(b,'d',312)
print(b.d) #312