20201121 第十二堂 面向对象（上）

20201121 第十二堂 面向对象（上）

列表推导式

• 旧列表 -> 新列表
• 语法：
  • [表达式 for 变量 in 旧列表]
  • [表达式 for 变量 in 旧列表 if 条件]
• 练习：

  • 过滤长度小于等于3的人名

    names = [‘Amy’,‘Clara’,‘Apple’,‘Tom’,‘Chanel’]

    result = [name for name in names if len(name) > 3]

    print(result)

    结果：
    [‘Clara’, ‘Apple’, ‘Chanel’]

  • 再将所有名字首字母都大写

    names = [‘Amy’,‘clara’,‘Apple’,‘tom’,‘chanel’]

    result = [name.capitalize() for name in names if len(name) > 3]

    print(result)

    结果：
    [‘Clara’, ‘Apple’, ‘Chanel’]

  • 将 1-100之间能够被3整除的组成一个新的列表

    new_list = [i for i in range(1,101) if i % 3 ==0]

    print(new_list)

    结果：
    [3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48, 51, 54, 57, 60, 63, 66, 69, 72, 75, 78, 81, 84, 87, 90, 93, 96, 99]

  • 将 1-100之间既能够被3和5整除的组成一个新的列表

    new_list = [i for i in range(1,101) if i % 3 == 0 and i % 5 == 0]

    print(new_list)

    结果：
    [15, 30, 45, 60, 75, 90]

生成器（了解）

• 生成器的作用：解决资源优化的问题，节省内存

• 当我们创建一些代码的时候，运算出来的结果非常大，但是我们往往只运用其中几个数据，那么这种情况会很浪费以及占用内存资源。因此使用生成器，我们可以在使用数据的时候，将需要运动的数据提取出来，就不需要全部数据运行一遍。

• 生成器该如何创捷？

  • 可以通过列表推导式来得到生成器，将中括号变成括号
    0-10之内分别和3相乘的列表

    new_list = [x * 3 for x in range(21)]
    print(type(new_list)) 列表

    g = (x * 3 for x in range(21))

    print(type(g)) 生成器只需要变成括号

  方法一：调用_ next _ ( )得到元素
  方法二：通过next（）来得到元素
  g = (x * 3 for x in range(21))
  print(type(g))
  print(g.next())
  print(g.next())
  print(next(g))

  调用第一次，提取的是第一个元素，第二次是第二个元素，第三次是第三个元素，以此类推

  • 通过函数的方式来得到生成器
    只要函数中出现了yield，那么这个函数就是生成器
    def fn1():
    num = 0
    while True:
    num += 1
    yield num
    g = fn1()
    print(g)
    print(g.next())
    print(g.next())
    print(next(g))

    结果：
    <generator object fn1 at 0x000001F7D554CA50>
    1
    2
    3

迭代器

• 迭代：获取元素的一个过程
• 可迭代对象：
  • 列表，集合，元组，字符串…只要能够遍历，就是可迭代对象
  • 生成器
• 如何来判断一个对象是否是可迭代的？

  • isinstance（）检查一个对象是否是另一个对象的实例
    lst = [1,2,3,4,5]
    print(isinstance(lst,Iterable))
    列表True
    print(isinstance(‘123’,Iterable))
    字符串True
    print(isinstance(123,Iterable))
    整数False
    g = (x * 3 for x in range(21))
    print(isinstance(g,Iterable))
    生成器True

  • 可以被next()函数调用，并不断返回下一个值的对象称之为迭代器，Iterator

  • 可迭代的对象不是迭代器
    lst = [1,2,3,4,5]
    print(next(lst))
    TypeError: ‘list’ object is not an iterator

  • 通过iter（）将可迭代对象变成一个迭代器

    lst = [1,2,3,4,5]
    
    lst = iter(lst)
    
    print(next(lst))
    print(next(lst))
    
    结果：
    1
    2
    

面向对象

面向的基本结构

• 程序在运行当中，所有的数据都是存在内存当中运行
• 对象就是内存中专门用来存储指定数据的一块区域
• 对象实际上就是一个容器。专门用来存储数据的容器
• 对象的结构
  • id（标识）
  • type（类型）类型决定了对象有那些功能
  • value（值）对象中存储的具体数据

面向对象的简介

• Python就是一个面向对象的语言
  1.我穿衣服出门
  2.我骑上了自行车
  3.我把自行车放到停车处
  4.我去买了瓶水
  5.我结账
  6.我起自行车回家
  7.我回到家喝水
  整个结果就是我在家喝水
• 面向过程
  • 在程序当中把整个的逻辑分解成一个个小的步骤去完成
  • 好处：非常清晰，符合人的思维逻辑
  • 缺点：复用性比较低，可能只适用一个功能
• 面向对象
  • 我出去买水回家喝水
  • 面向对象编写的代码比较容易维护，容易服用。但是不太符合人的思维逻辑，编写起来有点麻烦。

类的简介

• 类（class）

  • 类是一张图纸，在程序中我们需要根据类来创建多个对象

  • Python内置的对象，如：int，str，list，tuple…

  • 在开发的时候，只用Python提供的对象是不能够满足我们的需求，这个时候要自定义对象

  • 对象是类的实例（instance）

  • 类就是用来创建对象的对象，类是type类型的对象

    ‘’’
    class 类名([父类])：
    代码块
    ‘’’
    class MyClass():
    pass

    print(MyClass)

    <class ‘main.MyClass’>

    mc = MyClass()
    mc是MyClass这个类创建出来的对象，mc是MyClass类的实例

    mc2 = MyClass()
    mc3 = MyClass()
    mc4 = MyClass()

    r = isinstance(mc2,MyClass)
    print®
    True

• 类的定义：类和对象都是对现实生活中事物的抽象

• 实际上所有事物是由两部分组成：数据（属性）和行为（方法）

• 在类的代码块当中，我们可以定变量和函数
  在类中定义的变量，我们称之为属性（或者说是所有实例的公共属性）。也就是所有实例都可以访问这些变量

  尝试定义一个人类：
  class Person:
  a = 1
  b = 2
  p1 = Person()
  p2 = Person()
  print(p1.a,p2.b)
  结果： 1 2

  调用方法：对象.方法名()
  class Person:
  name = ‘葫芦娃’
  公共属性，所有实例都可以访问
  p1 = Person()
  p2 = Person()
  print(p1.name,p2.name)
  结果：葫芦娃 葫芦娃

• 在类中定义函数我们称之为方法，这些方法都可以通过该类的实例来访问

  class Person:
       def speak(a): 
       TypeError: speak() takes 0 positional arguments but 1 was given需要添加一个实参
          print('hello...')
    
  p1.speak()
  
  结果：hello...
  

• 方法调用和函数调用的区别:
  如果是函数调用，函数由几个形参，我们就会传递几个实参
  如果是方法调用，默认传递一个参数，所以方法中至少要定义一个形参