Python第12讲

面向对象（上）

推导式

• 推导式分类 —— 列表推导式（常用）、字典推导式、集合推导式、元组推导式
• 概述 —— 将旧的列表变成新的列表
• 语法：
  • 列表推导式
  1. 变量 = [表达式 for 变量 （和表达式变量一样） in Iterable]
  2. 变量 = [表达式 for 变量 （和表达式变量一样） in Iterable if 条件]
  • 字典推导式
  1. 变量 = {表达式（k:v形式） for k,v in Iterable.items()（字典）[if 条件]}
  2. 变量 = {表达式（k:v形式） for k,v in zip(Iterable1（key值）,Iterable2（value值）)
  • 集合推导式 (与字典推导式区别为表达式为单个变量，与列表推导式区别中括号变成大括号）
    变量 = { 表达式 for 变量（和表示变量一样） in Iterable [if 条件]}
  • 元组推导式 （与生成器区别，必须增加一行tuple转换）
    变量 = (x for x in Iterable [if 条件]) （产生生成器对象generator object）
    tuple(变量) (强制将生成器对象转变为元组对象）

# 列表推导式
lst = [x for x in range(5)] 
print lst # [0,1,2,3,4]
lst = [x for x in range(10) if x % 2 == 0]
print lst # [0,2,4,6,8]

# 字典推导式
a = ['a','b','c']
b = [1,2,3]
dic = {k:v for k,v in zip(a,b)}
print(dic)  # {'a': 1, 'b': 2, 'c': 3}

a = {'a': 1, 'b': 2, 'c': 3}
dic = {k.upper():v for k,v in a.items()}
print(dic)

生成器

• 简介 —— 一个可以不占用内存的可迭代对象，在需要使用可以直接使用的一种特殊函数
• 创建方法：
  1. 变量 = (表达式 for 变量（和表示变量一样） in Iterable [if 条件])
  2. def 函数名():
     代码块
     yield 变量
• 使用方法：
  1. 变量.__next__()
  2. next(变量）
• yield代码执行流程说明：当函数执行到yield语句时返回值，再次执行时从上次yield语句处继续执行

# 推导式创建生成器
g = (x for x in range(10))
print(g)  # <generator object <genexpr> at 0x000001BD87052C10>

# 函数创建生成器
def fn():
	for x in range(10):
		yield x
fn() # <generator object fn at 0x000001BD86FFADD0>
f = fn()
f.next() # 0

迭代器

• 简介 —— 可以被next()函数调用，并不断返回下一个值的对象称为迭代器 Iterator
• 生成器与迭代器的关系 —— 生成器是迭代器的一种
• 可迭代对象变为迭代器方法：
  变量 = iter(Iterable)
• 使用方法 —— 与生成器一样使用next(变量)函数调用\

lst = [1,2,3,4,5]
lst = iter(lst)
print(lst) # <list_iterator object at 0x000001BD87017880>

dic = {'a':1, 'b':2, 'c':3}
dic = iter(dic)
print(dic) # <dict_keyiterator object at 0x000001BD871625E0>

面向对象简介

• 程序在运行时，所有数据都是存到内存中运行
• 对象是内存中专门用来存储指定数据的一块区域
• 对象是一个容器，专门用来存储数据的容器
• 对象的结构：
  • id（标识 —— 唯一标识）
  • type（类型 —— 表示当前对象所属的一个类型，类型决定了对象有哪些功能）
  • value（值 —— 对象中存储的具体数据）
• 面向过程
  • 好处
    • 在程序当中把整个逻辑分解成一个一个小的步骤去完成
    • 程序编写的方式符合人的逻辑思维
  • 坏处
    • 复用性比较低，通常只适用于一种功能
• 面向对象
  • 结果为导向
  • 程序编写后比较容易维护和复用
  • 不太符合人的逻辑，编写有点麻烦

类

• 概念 —— 类简单理解为一张图纸（可造某类东西的图纸），类可以创建对象，对象是类的实例（instance）。类是一个创建对象的对象）

• 关键字 —— class为类的关键字（类名应首字母大写）

• 类的类型 —— type类型的对象（定义类就是定义了一个type类型的对象）

• 语法：
  class 类名([父类]):
  代码块

• 创建对象（类的实例）：
  对象 = 类名()

# 查看类的类型、类的实例化对象，类属性
class Person:
	pass
print(Person) # <class '__main__.Person'> 
print(type(Person)) # <class 'type'>
p1 = Person	# p1称为Person的实例对象
print(p1) # <__main__.Person object at 0x000001BD87017580> 通过Person创建的对象
p1.name = '哈哈'
p1.name  # '哈哈'
Person.name # AttributeError: type object 'Person' has no attribute 'name'

• 定义
  • 类和对象都是实现程序的抽象事物
  • 所有事物都是由两部分组成
  1. 数据（属性）
  2. 行为（方法）
• 类属性或方法的定义方法
  • 在类的代码块当中，可以定义变量和函数
    • 在类中定义的变量，称为属性（类属性）
    • 在类中定义的函数，称为方法
    • 相当于所有实例都可以访问这些变量和函数
• 类属性或方法的调用
  • 实例对象.属性名（变量）即可调用类属性
  • 实例对象.方法名（函数名）即可调用类方法
    方法调用和函数调用的区别：
    1. 函数调用，如果函数定义几个形参，就需要传递几个实参
    2. 方法调用，默认传递一个形参，所以方法中至少要定义一个形参

# 类属性的创建和调用
class Person:
	name = '哈哈'   # 类属性
p1 = Person()
p1.name   # '哈哈'

# 类方法的创建和调用 —— 方法中不传递形参
class Person:
	def run():
		print('你跑的好快呀!')
p1 = Person()
p1.run()  # TypeError: run() takes 0 positional arguments but 1 was given

# 类方法的创建和调用 —— 方法中传递形参
class Person:
	def run(a):
		print('你跑的好快呀!')
p1 = Person()
p1.run() # 你跑的好快呀！