高级编程&面向对象一

1.推导式

• Python 推导式是一种独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体

1.1列表推导式

• 用的最多列表推导式
• 列表推导式是Python构建列表（list）的一种快捷方式。
• 语法：
  1.列表推导式的格式

[表达式 for 变量 in iteration]
或者
[表达式 for 变量 in iteration if 条件]

表达式可以是有返回值的函数。
2. 例子

list1 = [1, 2, 3, 4, 5, 6]
list2 = [x for x in list1]
print(list2)
list3 = [x for x in list1 if x % 2 == 0]
print(list3)
list4 = [x for x in range(11)]
print(list4)
list5 = [x for x in range(11) if x % 5 == 0]
print(list5）

#结果
[1, 2, 3, 4, 5, 6]
[2, 4, 6]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[0, 5, 10]

3. 嵌套循环表达式

[表达式 for 变量1 in 可迭代对象 for 变量2 in 可迭代对象]

li = [i+j for i in "123" for j in "abc"]

1.2 字典推导式

是为了生成字典

格式：
{ key_expr: value_expr for value in 可迭代对象 }

或

{ key_expr: value_expr for value in 可迭代对象 if condition }

dic1 = {0:"0",1:"1",2:"2"}
dic2 = {v:k for k,v in dic1.items()}
print(dic2)

1.3 集合推导式

• 基本格式
  { expression for item in Sequence }
  或
  { expression for item in Sequence if conditional }

a = {x for x in 'abracadabra' if x not in 'abc'}
print(a)
#{'d', 'r'}
print(type(a))
#<class 'set'>

1.4 元组推导式

元组推导式和列表推导式用法完全一样，只是返回的是一个生成器对象，还有使用（）不是[]
 tuple(a)可以使a转换成一个元组。实际上是从一个生成器中取值，一次性取完之后就成为一个空生成器了。

2.生成器

• 生成器的特征：生成一个生成器，用一次取一次值，一旦数据取完了，那么数据就不存在了,再取就报错。
• 在Python中，一边循环一边计算的机制，称为生成器：generator。

2.1.创建生成器的方式

2.1.1.列表推导式法

list1 = [1, 2, 3, 4, 5, 6]
list2 = (x for x in list1)
print(list2, type(list2))
list3 = (x for x in list1 if x % 2 == 0)
print(list3, type(list2))
print(list3.__next__())
print(list3.__next__())
print(list3.__next__())

<generator object <genexpr> at 0x000001A21ED878E0> <class 'generator'>
2
4
6

2.1.2.函数法（生成器函数）

# 只要在函数中出现yield关键字它就是一个生成器，不再是一个普通的函数。
def gen():
    n = 0
    while True:
        n += 1
        yield n           #yield返回一个值，并且记住这个返回值的位置，下次遇到next()调用时，代码从yield的下一条语句开始执行。与return的差别是，return也是返回一个值，但是直接结束函数。

i = gen()       #调用函数就是创建一个生成器对象
print(next(i))
print(next(i))
print(next(i))

• 序列类型包括字符串、列表、元组、集合和字典

迭代器和生成器简单区别

• 迭代器通过iter(iteration)函数创建，通过next()函数取值
• 生成器通过推导式和带有yield的函数创建，使用next()取值。
• 生成器是一边循环一边计算，有需要才会生成，不占用过多内存。
• 生成器本质上是一个函数
• 生成器是生成元素,迭代器是访问集合元素的一中方式，占内存。
• 生成器记住了上一次返回时在函数体中的位置,对生成器函数的第二次调用,跳转到函数上一次挂起的位置,而且记录了程序执行的上下文,生成器不仅仅记住了它的数据状态,也记住了它执行的位置。

3.迭代器

3.1可迭代对象

• 1.迭代器 ,2.生成器也是迭代器,3.序列
  ** 此过程就是一个迭代过程，用for语句表示的迭代，数据一个挨一个的进行操作的过程可以理解为迭代。迭代的每一次重复都是从上一次结束开始。

mylist = [1, 2, 3, 4, 5, 6]
for i in mylist:
	print(i)

• 可迭代的对象有个共同的特点就是是有序。迭代是从一个元素开始到最后一个元素结束
• 序列当中一定能按照顺序迭代的有 list,tuple,string。而dict 和set迭代的时候不知道哪一个元素是上一个，哪一个元素是下一个。也就是说迭代的顺序不是有序的。
  可迭代对象都是能够变成迭代器的可迭代对象：list str tuple dictionary set。
• iter()函数(返回值是一个迭代器）将可迭代对象变成迭代器，迭代器用next（）函数去迭代。可迭代对象包含了iter()函数。迭代器包括iter()和next()函数

mylist = [1, 2, 3, 4, 5, 6]
iter1 = iter(mylist)
print(next(iter1))

• next(迭代器)函数里面是迭代器，生成迭代器中的每一个元素。
• • 迭代器是访问集合元素的一种方式。迭代器是一个可以记住遍历位置的对象。迭代器对象从集合的第一个元素开始访问，直到所有元素被访问完结束。
    可以被next()函数调用并不断返回下一个值的对象称为迭代器Iterator
    生成器是可迭代的，也是迭代器
    列表是可迭代的，但不是迭代器
    通过iter()函数可以将可迭代对象变成一个迭代器
• 列表迭代，但不是迭代器，可以通过iter()函数的方法将列表转换成list_iterator（列表迭代器）。通过iter()函数可以将可迭代的变成一个迭代器

list = [1, 2, 3, 4]
iterator = iter(list)
print(iterator,type(iterator))

<list_iterator object at 0x00000278698AD7F0> <class 'list_iterator'>

• 迭代器可以遍历

list = [1, 2, 3, 4]
iterator = iter(list)
print(iterator,type(iterator))
list2 = [x for x in iterator]
print(list2)
#结果
<list_iterator object at 0x0000022B4100D7F0> <class 'list_iterator'>
[1, 2, 3, 4]
#---------------------------------------------------
list = [1, 2, 3, 4]
iterator = iter(list)
print(iterator,type(iterator))
print(next(iterator))
print(next(iterator))
print(next(iterator))
list2 = [x for x in iterator]
print(list2)
#结果
<list_iterator object at 0x0000020940E8D7F0> <class 'list_iterator'>
1
2
3
[4]

• 判断是否为可迭代对象

from collections import Iterable,Iterator
print(isinstance('abc',Iterable))  

• 迭代过程中只要超出范围则直接报StopIteration的错误。

import sys       
 
list=[1,2,3,4]
it = iter(list) 
 
while True:
    try:
        print (next(it))
    except StopIteration:
        sys.exit()

4.面向对象

面向对象的基本概念

● 实例变量：定义在实例中的变量，只作用于当前实例。self修饰的变量
● 类变量：类变量是所有实例公有的变量。类变量定义在类中，但在方法体之外。 通常不作为实例变量使用
局部变量：定义在方法中的变量，只作用于当前实例的类
● 数据成员：类变量、实例变量、方法、类方法、静态方法和属性等的统称。
● 静态方法：不需要实例化就可以由类执行的方法
● 类方法：类方法是将类本身作为对象进行操作的方法

• 对对象的直接操作就是面向对象
• 面线对象注重结果，面向过程注重过程。
  • Python是一门面向对象的编程语言
  • 所谓面向对象的语言，简单理解就是语言中的所有操作都是通过对象来进行的
  • 面向过程
  • 面向过程指将我们的程序分解为一个一个步骤，通过对每个步骤的抽象来完成程序
  • 这种编写方式往往只适用于一个功能，如果要实现别的功能，往往复用性比较低
  • 这种编程方式符号人类的思维，编写起来比较容易
  • 1.妈妈穿衣服穿鞋出门
  • 2.妈妈骑上电动车
  • 3.妈妈到超市门口放好电动车
  • 4.妈妈买西瓜
  • 5.妈妈结账
  • 6.妈妈骑电动车回家
  • 7.到家孩子吃西瓜
  • 面向对象的编程语言，关注的是对象，而不注重过程，对于面向对象一切皆对象
  • 以上方式可以用 孩子妈妈给孩子买瓜来解决
  • 面向对象的编程思想，将所有功能统一保存到对应的对象中，要使用某个功能，直接找到对应的对象即可
  • 这种编码方式比较容易阅读，并且易于维护，容易复用。但是编写的过程中不太符合常规的思维，编写相对麻烦

4.1.类

4.1.1.类的简介

• 我们目前学习的都是Python的内置对象，但是内置对象并不都能满足我们的需求，所以我们在开发中经常要自定义一些对象
• 类简单理解它就是相当于一个图纸，在程序汇总我们需要根据类来创建对象。
• 类就是对象的图纸
• 我们也称对象是类的实例(instance)
• 自定义类，大驼峰方式命名
• 类也是一个对象，类就是用来创建对象的对象

# 定义一个空类
#语法
class 类名称():
	pass

• 类必须被定义之后才能使用，定义一个类就是定义了这一类对象的模板。
• 创建对象也成为类的实例化，如下

变量名 = 类名称（）
class MyLei():
	pass
	
My = MyLei()#类的实例化

• isinstance 检测一个对象是不是这个类的对象

r = isinstance(My, MyLei)#返回值是True或者False
print(r)

4.1.2.类的使用

• 类中有方法，有属性。

class Person():
	name = '刘亦菲' #数据（属性）
	def  speak(self):#方法
		print('我唱歌很好听')

p1 = Person()#创建对象，类的实例化。
p2 = Person()
p1.name = '周慧敏'#给实例对象中的属性添加内容
print(p1.name)
print(p2.name)#如果类中没有此项属性，则会报错。
p1.speak()#类中方法的使用。