八、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中的类名约定以大写字母开头
- 封装:信息隐蔽技术
可以用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
- 继承:子类共享父类之间的数据和方法的控制
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]
- 多态:不同对象对同一方法相应不同的行动
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)一些内置函数
- 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实在没有内容时,能自动运行下去的一个语句
- 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
- 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
- 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'
- 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
- 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