【Python】基础之面向对象

第四章 Python 面向对象

---

---

前言

上三篇了解了基础的数据类型以及代码块、注释等语法， 讲判断、运算、循环、lamda、函数等基础语法，==这一篇讲面向对象==

一、对象/类

1.创建对象/类

类就是对象，对象就是类

同java一样

类也是用class标识
类中的构造函数是 __init__() 注意是双下划线
所有类都有一个名为 __init__() 的函数，它始终在启动类时执行。 使用 __init__() 函数将值赋给对象属性，或者在创建对象时需要执行的其他操作:

class user:
	def __init__(self, a, b):
		self.a=a
		self.b=b
		self.c=a
		self.d=b
		print("我创建了个类",self)
		
	## 这个自定义的方法,第一个参数永远是对象本身,作用是用于访问本身的成员变量,但他不需要命名为self
	def myf(a,b):
		print(a.a,b)
x=user('1','2')

print(x.a,x.b,x.c,x.d)

x.myf(False)
	

2.修改类的属性

修改属性就像js一样 直接赋值就行

class user:
	def __init__(self, a, b):
		self.a=a
		self.b=b
		self.c=a
		self.d=b
		print("我创建了个类",self)
		
	## 这个自定义的方法,第一个参数永远是对象本身,作用是用于访问本身的成员变量,但他不需要命名为self
	def myf(a,b):
		print(a.a,b)
x=user('1','2')

print(x.a,x.b,x.c,x.d)

x.myf(False)

x.a=9
print(x.a,x.b,x.c,x.d)

3.删除属性/删除类/pass关键字

删除属性/删除类

del x.a
del x

pass关键字
类不允许为空,如果有需要,可以用pass跳过限制 例如 子类完全继承父类

class User:
	pass

class Father:
	def __init__(a,b,c):
		a.a=b+c
	def pt(a):
		print(a.a)
		
class Son(Father):
	pass

x=Son(1,1)
x.pt()
		
	

二、继承

继承就是子类继承父类的属性/方法,但是并不意味着子类继承父类之后就无法添加自己的方法和属性了

class Father:
	def __init__(a,b,c):
		a.a=b+c
	def pt(a):
		print(a.a)
		
class Son(Father):
	## 子类可以覆盖继承父类的方法
	def pt(a):
		print(int(a.a)+5)
	def mypt(a):
		super().pt()
		## 等同于 Father.pt()		
class LittleSon(Father):
	# 这样可以完全继承
	pass
x=Son(1,1)
y=LittleSon(1,1)
x.mypt()
x.pt()
y.pt()

三、多态

“多态”（polymorphism）一词意为“多种形式”，在编程中，它指的是可以在许多对象或类上执行的具有相同名称的方法/函数/操作符。

类多态

多态经常在类方法中使用，我们可以在其中有多个具有相同方法名的类。

例如，假设我们有三个类：Car、Boat 和 Plane，并且它们都有一个名为 move() 的方法：

# car 类
class Car:
  def __init__(self, brand, model):
    self.brand = brand
    self.model = model
# car类的move方法
  def move(self):
    print("Drive!")
# boat类
class Boat:
  def __init__(self, brand, model):
    self.brand = brand
    self.model = model
# boat类的move方法
  def move(self):
    print("Sail!")
# plane类
class Plane:
  def __init__(self, brand, model):
    self.brand = brand
    self.model = model

# plane类的move方法
  def move(self):
    print("Fly!")

car1 = Car("Ford", "Mustang")       #Create a Car class
boat1 = Boat("Ibiza", "Touring 20") #Create a Boat class
plane1 = Plane("Boeing", "747")     #Create a Plane class

#依次调用各个类的move方法
for x in (car1, boat1, plane1):
  x.move()

继承类多态
那么具有相同名称的子类的类呢？我们可以在那里使用多态吗？

可以。如果我们使用上面的例子并创建一个名为 Vehicle 的父类，并使 Car、Boat、Plane 成为 Vehicle 的子类，则子类将继承 Vehicle 的方法，但可以覆盖它们：

实例
创建一个名为 Vehicle 的类，并使 Car、Boat、Plane 成为 Vehicle 的子类：

class Vehicle:
  def __init__(self, brand, model):
    self.brand = brand
    self.model = model

  def move(self):
    print("Move!")

class Car(Vehicle):
  pass

class Boat(Vehicle):
  def move(self):
    print("Sail!")

class Plane(Vehicle):
  def move(self):
    print("Fly!")

car1 = Car("Ford", "Mustang") # 创建 Car 对象
boat1 = Boat("Ibiza", "Touring 20") # 创建 Boat 对象
plane1 = Plane("Boeing", "747") # 创建 Plane 对象

for x in (car1, boat1, plane1):
  print(x.brand)
  print(x.model)
  x.move()

子类从父类继承属性和方法。

在上面的例子中，您可以看到 Car 类是空的，但它从 Vehicle 继承了 brand、model 和 move()。

Boat 和 Plane 类也从 Vehicle 继承了 brand、model 和 move()，但它们都覆盖了 move() 方法。

由于多态性，我们可以为所有类执行相同的方法。

四、迭代

迭代就像一种循环一样
有编程基础可能会好理解一点

迭代器是一种对象，该对象包含值的可计数数字。

迭代器是可迭代的对象，这意味着您可以遍历所有值。

从技术上讲，在 Python 中，迭代器是实现迭代器协议的对象，它包含方法 iter() 和 next()。

字符串、列表、元组、字典和集合都是可迭代的对象。它们是可迭代的容器，您可以从中获取迭代器（Iterator）。

字符串可以看作是字符的数组

所有这些对象都有用于获取迭代器的 iter() 方法：

mystr = "banana"
mylist=['1','2','3']
mytuple=('1','2','3')
mydiction={"a":"1","b":"2","c":"3"}
myset={"1","2","3"}

#for循环本质就是遍历了迭代器
for x in mystr:
  print(x)
## 等同于
myit = iter(mystr)
print(next(myit))
print(next(myit))
print(next(myit))
print(next(myit))
print(next(myit))
print(next(myit))

创建迭代器

自建迭代器呢 需要在类中实现__iter__()方法 和__next__()方法

StopIteration关键字可以跳出迭代

iter() 方法允许执行操作（初始化等），但必须始终返回迭代器对象本身。

next() 方法也允许您执行操作，并且必须返回序列中的下一个项目。

class MyNumbers:
  def __iter__(self):
    self.a = 1
    return self

  def __next__(self):
    if self.a <= 20:
      x = self.a
      self.a += 1
      return x
    else:
      raise StopIteration

myclass = MyNumbers()
myiter = iter(myclass)

for x in myiter:
  print(x)

总结

文章总结：

天道从不酬勤,机缘是抢来的