python学习笔记-day7

高阶函数

abs():求绝对值
round():四舍五入

内置高阶函数

map(func,list):将传入的函数变量func作用到list变量中的每个元素，并将结果组成新的迭代器（python3）返回

需求：计算 list1 序列中各个数字的2次⽅。
list1 = [1, 2, 3, 4, 5]
def func(x):
 return x ** 2
result = map(func, list1)
print(result) # <map object at 0x0000013769653198>
print(list(result)) # [1, 4, 9, 16, 25]

reduce(func(x,y)，list):其中func必须有两个参数。每次func计算的结果继续和序列的下⼀个元素做累积计算。

需求：计算 list1 序列中各个数字的累加和。
import functools
list1 = [1, 2, 3, 4, 5]
def func(a, b):
 return a + b
result = functools.reduce(func, list1)
print(result) # 15

filter(func, lst):函数⽤于过滤序列, 过滤掉不符合条件的元素, 返回⼀个 filter 对象,。如果要转换为列表,可以使⽤ list() 来转换

list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
def func(x):
return x % 2 == 0
result = filter(func, list1)
print(result) # <filter object at 0x0000017AF9DC3198>
print(list(result)) # [2, 4, 6, 8, 10]

类

类是对⼀系列具有相同特征和⾏为的事物的统称，是⼀个抽象的概念，不是真实存在的事物。（特征即是属性，⾏为即是⽅法）

定义类：

类名要满⾜标识符命名规则，同时遵循⼤驼峰命名习惯。
class 类名():
 代码
 ......

创建对象：

对象名 = 类名()

selt

self指的是调⽤该函数的对象。

# 1. 定义类
class Washer():
 def wash(self):
   print('我会洗⾐服')
   # <__main__.Washer object at 0x0000024BA2B34240>
   print(self)
  #注意：打印对象和self得到的结果是⼀致的，都是当前对象的内存中存储地址。

  haier1 = Washer()

  # <__main__.Washer object at 0x0000018B7B224240>
  print(haier1)

  # haier1对象调⽤实例⽅法
  haier1.wash()

添加和获取对象属性：

对象属性既可以在类外⾯添加和获取，也能在类⾥⾯添加和获取。

类外⾯添加对象属性:

对象名.属性名 = 值

类外⾯获取对象属性:

对象名.属性名 

类⾥⾯获取对象属性:self.属性名

# 定义类
class Washer():
    def print_info(self):
        # 类⾥⾯获取实例属性
        print(f'haier1洗⾐机的宽度是{self.width}')
        print(f'haier1洗⾐机的⾼度是{self.height}')
# 创建对象
haier1 = Washer()
# 添加实例属性
haier1.width = 500
haier1.height = 800
haier1.print_info()

魔法方法

在Python中， __ xx__() 的函数叫做魔法⽅法，指的是具有特殊功能的函数。

__ init __()

 __ init__() ⽅法的作⽤：初始化对象

注意：

__init__() ⽅法，在创建⼀个对象时默认被调⽤，不需要⼿动调⽤
__init__(self) 中的self参数，不需要开发者传递，python解释器会⾃动把当前的对象引
⽤传递过去。

class Washer():

    # 定义初始化功能的函数
    def __init__(self):
        # 添加实例属性
        self.width = 500
        self.height = 800
    def print_info(self):
        # 类⾥⾯调⽤实例属性
        print(f'洗⾐机的宽度是{self.width}, ⾼度是{self.height}')
        
haier1 = Washer()
haier1.print_info()

思考：⼀个类可以创建多个对象，如何对不同的对象设置不同的初始化属性呢？答：传参数。

带参数的__init__() :

class Washer():
    def __init__(self, width, height):
        self.width = width
        self.height = height`
    def print_info(self):
        print(f'洗⾐机的宽度是{self.width}')
        print(f'洗⾐机的⾼度是{self.height}')
        
haier1 = Washer(10, 20)
haier1.print_info()
haier2 = Washer(30, 40)
haier2.print_info()

__ str __()

当使⽤print输出对象的时候，默认打印对象的内存地址。如果类定义了 str ⽅法，那么就会打印从在这个⽅法中 return 的数据。

class Washer():
    def __init__(self, width, height):
        self.width = width
        self.height = height
    def __str__(self):
        return '这是海尔洗⾐机的说明书'
    
haier1 = Washer(10, 20)
# 这是海尔洗⾐机的说明书
print(haier1)

类的继承

⼦类默认继承⽗类的所有属性和⽅法

# ⽗类A
class A(object):
    def __init__(self):
        self.num = 1
    def info_print(self):
        print(self.num)
# ⼦类B
class B(A):
    pass

result = B()
result.info_print() # 1

在Python中，所有类默认继承object类，object类是顶级类或基类；其他⼦类叫做派⽣类。

单继承

# 1. 师⽗类
class Master(object):
   def __init__(self):
     self.kongfu = '[古法煎饼果⼦配⽅]'
   def make_cake(self):
     print(f'运⽤{self.kongfu}制作煎饼果⼦')
 
# 2. 徒弟类
class Prentice(Master):
   pass
# 3. 创建对象daqiu
daqiu = Prentice()
# 4. 对象访问实例属性
print(daqiu.kongfu) 

多继承：⼀个类同时继承了多个⽗类，当⼀个类有多个⽗类的时候，默认使⽤第⼀个⽗类的同名属性和⽅法。

class Master(object):
   def __init__(self):
     self.kongfu = '[古法煎饼果⼦配⽅]'
   def make_cake(self):
     print(f'运⽤{self.kongfu}制作煎饼果⼦')
# 创建学校类
class School(object):
   def __init__(self):
     self.kongfu = '[⿊⻢煎饼果⼦配⽅]'
   def make_cake(self):
     print(f'运⽤{self.kongfu}制作煎饼果⼦')
class Prentice(School, Master):
   pass
daqiu = Prentice()
print(daqiu.kongfu)
daqiu.make_cake()

⼦类重写⽗类同名⽅法和属性

class Master(object):
   def __init__(self):
     self.kongfu = '[古法煎饼果⼦配⽅]'
   def make_cake(self):
     print(f'运⽤{self.kongfu}制作煎饼果⼦')
class School(object):
   def __init__(self):
     self.kongfu = '[⿊⻢煎饼果⼦配⽅]'
   def make_cake(self):
     print(f'运⽤{self.kongfu}制作煎饼果⼦')
# 独创配⽅
class Prentice(School, Master):
   def __init__(self):
     self.kongfu = '[独创煎饼果⼦配⽅]'
   def make_cake(self):
     print(f'运⽤{self.kongfu}制作煎饼果⼦')

daqiu = Prentice()
print(daqiu.kongfu)
daqiu.make_cake()
print(Prentice.__mro__)#可以用__mro__方法来获取这个类的调用顺序。

⼦类调⽤⽗类的同名⽅法和属性

class Master(object):
   def __init__(self):
     self.kongfu = '[古法煎饼果⼦配⽅]'
   def make_cake(self):
     print(f'运⽤{self.kongfu}制作煎饼果⼦')

class School(object):
 def __init__(self):
   self.kongfu = '[⿊⻢煎饼果⼦配⽅]'
 def make_cake(self):
   print(f'运⽤{self.kongfu}制作煎饼果⼦')

class Prentice(School, Master):
   def __init__(self):
     self.kongfu = '[独创煎饼果⼦配⽅]'
   def make_cake(self):
     # 如果是先调⽤了⽗类的属性和⽅法，⽗类属性会覆盖⼦类属性，故在调⽤属性前，先调⽤⾃⼰⼦类的初始化
     self.__init__()
     print(f'运⽤{self.kongfu}制作煎饼果⼦')
   # 调⽤⽗类⽅法，但是为保证调⽤到的也是⽗类的属性，必须在调⽤⽅法前调⽤⽗类的初始化
   def make_master_cake(self):
     Master.__init__(self)
     Master.make_cake(self)
   def make_school_cake(self):
     School.__init__(self)
     School.make_cake(self)

daqiu = Prentice()
daqiu.make_cake()
daqiu.make_master_cake()
daqiu.make_school_cake()
daqiu.make_cake()

多层继承

class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果⼦配⽅]'
    def make_cake(self):
        print(f'运⽤{self.kongfu}制作煎饼果⼦')

class School(object):
    def __init__(self):
        self.kongfu = '[⿊⻢煎饼果⼦配⽅]'
    def make_cake(self):
        print(f'运⽤{self.kongfu}制作煎饼果⼦')

class Prentice(School, Master):
    def __init__(self):
        self.kongfu = '[独创煎饼果⼦配⽅]'

    def make_cake(self):
        self.__init__()
        print(f'运⽤{self.kongfu}制作煎饼果⼦')

    def make_master_cake(self):
        Master.__init__(self)
        Master.make_cake(self)

    def make_school_cake(self):
        School.__init__(self)
        School.make_cake(self)

# 徒孙类
class Tusun(Prentice):
    pass

xiaoqiu = Tusun()
xiaoqiu.make_cake()
xiaoqiu.make_school_cake()
xiaoqiu.make_master_cake()
#运⽤[独创煎饼果⼦配⽅]制作煎饼果⼦
#运⽤[⿊⻢煎饼果⼦配⽅]制作煎饼果⼦
#运⽤[古法煎饼果⼦配⽅]制作煎饼果⼦