2020-10-14

我的博客第十一篇

面向对象（上）

补充：.迭代器

。迭代器是访问集合元素的一种方式。是一个可以记住遍历位置的对象。迭代器对象从集合第一个元素开始访问，指导所有元素被访问完结束。
。可以被next()函数调用并不断返回下一个值的对象称为迭代器iterator。
。生成器是可迭代的，也是迭代器。
。列表是可迭代的，但不是迭代器。
。通过iter(）函数可以将可迭代的变成一个迭代器。
。可迭代对象：序列，字典，迭代器，生成器iter
。迭代器：iter next
。去一次就不能使用了
。会记住你上一次停留的位置
。实现语法：
。生成器会更加灵活。

list1 = [1,2,3,4,5]
it = iter(list1)
print(type(it))

#可迭代对象 __iter__
#list
#for i in list:
#迭代器 __iter__  __next__
list1 = [1,2,3,4,5,6]
iterator = iter(list1)
print(type(iterator))
print(next(iterator))
print(next(iterator))
#结果
<class 'list_iterator'>
1
2

list1 = [1,2,3,4,5,6]
iterator = iter(list1)
li = [i for i in iterator]
li1 = [i for i in iterator]
print(li)
print(li1)
#结果
[1, 2, 3, 4, 5, 6]
[]

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

2. 类(class)
。我们目前学习的都是Python的内置对象，但是内置对象并不都能满足我们的需求，所以我们在开发中经常要自定义一些对象
。类简单理解它就是相当于一个图纸，在程序汇总我们需要根据类来创建对象。
。类就是对象的图纸
。我们也称对象是类的实例(instance)
。如果多个对象是通过一个类创建的，我们称这些对象是一类对象
。语法：

class 类名([父类]):
	pass

。类也是一个对象，类就是用来创建对象的对象
。可以像对象中添加变量，对象中的变量称之为属性 语法：对象.属性名 = 属性值

3.类的使用
。 类和对象都是对现实生活中事物的抽象
。 事物包含两部分
。 1. 数据(属性)
。 2. 行为(方法)
。 调用方法 对象.方法名()
。 方法调用和函数调用的区别：如果是函数调用，调用时有几个形参，就会传递几个实参。如果是方法调用，默认传递一个参数，所以方法中至少得有一个形参
。 在类代码块中，我们可以定义变量和函数
。 变量会成为该类实例的公共属性，所有的该实例都可以通过 对象.属性名的形式访问
。 函数会成为该类实例的公共方法，所有该类实例都可以通过 对象.方法名的形式访问

#可以创建对象的对象
#定义一个类，其实就是定义了一个type类型的对象
class MyClass():
    pass
print(id(MyClass),type(MyClass))
#结果
1335246300520 <class 'type'>

#可以向对象中添加变量，对象中的变量称之为属性
#语法：对象.属性名 = 属性值
class MyClass():
    pass
mc = MyClass()    #创建一个实例对象
mc.name = '葫芦娃' #对象里面有了属性值

class MyClass():
    pass
MyClass.name = '奥特曼'
mc = MyClass()    #创建一个实例对象
mc.name = '葫芦娃' #对象里面有了属性值
mc1 = MyClass()
print(mc.name)
#print(mc1.name)
#结果
葫芦娃          #同时有奥特曼 和 葫芦娃  由近及远访问
#当实例中有属性值，类中也有属性，那么实例第一会调用实例本身的属性，没有才会调用类中的属性

#当实例中有属性值，类中也有属性，那么实例第一会调用实例本身的属性，没有才会调用类中的属性

class Person():
    name = "奥特曼"

a = Person()
b = Person()
a.name = '葫芦娃' 
print(a.name)
print(b.name)
#结果
葫芦娃
奥特曼   #b的值为空，但是类的本身里有类的属性值，相当于” name = '奥特曼' “是个公共属性

#类和对象都是现实生活中的抽象，实际上都是由两部分构成
#1.属性 （数据）
#2.方法 （行为）

class Person():
    name = "奥特曼"
    def speak(self):   #定义一个方法，调用方法的时候，默认要指定一个形参，所以方法中至少要有一个形参
        print('我能说话！')

a = Person()
b = Person()
a.name = '葫芦娃' 
#print(a.name)
#print(b.name)
print(a.speak())
print(b.speak())
#结果
我能说话！
None
我能说话！
None

4.属性和方法
。 类中定义的属性和方法都是公共的，任何该类实例都可以访问
。 属性和方法的查找流程
。 当我们调用一个对象的属性时，解析器会先在当前的对象中寻找是否还有该属性，如果有，则直接返回当前的对象的属性值。如果没有，则去当前对象的类对象中去寻找，如果有则返回类对象的属性值。如果没有就报错
。 类对象和实例对象中都可以保存属性(方法)
。 如果这个属性(方法)是所有的实例共享的，则应该将其保存到类对象中
。 如果这个属性(方法)是某个实例独有的。则应该保存到实例对象中
。 一般情况下，属性保存到实例对象中 而方法需要保存到类对象中

5.self参数
。self在定义时需要定义，但是在调用时会自动传入。
。self的名字并不是规定死的，但是最好还是按照约定是用self
。self总是指调用时的类的实例
。self参数如果要在方法中使用，必须携带
。self参数 self参数就是指的调用该方法的实例本身

class Person():
    def speak(self):
        print('你好我是%s' % self.name)

a = Person()
b = Person()
a.name = '葫芦娃'
b.name = '奥特曼'
a.speak()
b.speak()

补充

实例成员：对象.成员名
实例变量
对象.变量名
实例方法
对象.方法名()