python复习（三）

一、类和属性

1、类的定义

类是一种面向对象编程的重要概念。类是用来创建对象的模板，它定义了对象的属性和行为。类可以看作是对象的蓝图，通过类可以创建多个对象，这些对象称为类的实例。类中包含了属性和方法，属性表示对象的特征，而方法表示对象的行为。

在Python中，使用关键字class来定义一个类，类名通常采用首字母大写的驼峰命名法。类中可以包含构造方法__init__用来初始化对象的属性，以及其他方法用来定义对象的行为。通过实例化类，可以创建对象并访问对象的属性和方法。

2、类属性VS对象属性

属性是类的特征和行为的集合，是类的相关数据和方法。

类属性是指在类中定义的属性，它属于整个类，被所有实例对象共享。

对象属性是指属于实例对象本身的属性，每个实例对象都有自己的属性值，对象属性可以通过实例对象访问和修改。

class MyClass:
    class_attr = 10  # 类属性
    
    def __init__(self, obj_attr):
        self.obj_attr = obj_attr  # 对象属性
 
# 创建两个实例对象
obj1 = MyClass(20)
obj2 = MyClass(30)
 
# 访问类属性
print(MyClass.class_attr)
 
# 修改类属性
MyClass.class_attr = 20
print(MyClass.class_attr)
 
# 访问对象属性
print(obj1.obj_attr)
print(obj2.obj_attr)
 
# 修改对象属性
obj1.obj_attr = 25
print(obj1.obj_attr)

3、类中的方法

在Python中，类中的方法是用来定义类的行为和功能的。方法是类中的函数，它可以对类的属性进行操作，实现类的功能。在类中定义方法的语法和定义函数类似，但是在方法定义时需要额外传入self参数，表示方法作用于类的实例对象本身。

class Calculator:
    
    def addition(self, a, b):
        return a + b
 
# 创建类的实例对象
calc = Calculator()
 
# 调用类的方法
result = calc.addition(1, 2)
print(result)  # 输出：3

在这个例子中，addition是一个类方法，它接受两个参数a和b，并返回它们的和。在调用这个方法时，会自动将类的实例对象calc作为第一个参数传入，即self参数。

类中的方法可以访问类的属性和修改类的属性，也可以调用其他方法。通过定义类中的方法，可以实现类的功能和行为，使得类更加灵活和有用。

4、类中的特殊方法——init

__init__是一个特殊方法，用来在创建类的实例对象时进行初始化操作。__init__方法在对象创建时自动调用，它是类中定义的构造方法，用来初始化对象的属性。

当创建一个类的实例对象时，会自动调用__init__方法，将参数传递给__init__方法，在__init__方法中可以对对象的属性进行初始化赋值。这样，在创建对象时可以直接传入参数，从而确保对象在创建时已经被正确初始化。

class Person:
    
    def __init__(self, name, age):
        self.name = name
        self.age = age
 
# 创建类的实例对象并进行初始化
person = Person("Alice", 30)
 
# 访问对象的属性
print(person.name)  # 输出：Alice
print(person.age)   # 输出：30

上面的例子中,__init__方法接受name和age两个参数，并将它们赋值给对象的属性name和age，在创建Person类的实例对象时，可以直接传入参数进行初始化。通过__init__方法，可以确保对象在创建时已经被正确初始化，方便后续使用。 

5、self的理解

在Python类中，`self`参数是一个特殊的参数，它表示类的实例对象本身。当定义类的方法时，第一个参数通常都是`self`，用来指代类的实例对象。通过`self`参数，可以访问类的属性和调用类的方法，从而实现类的功能和行为。

在类的方法中，当调用方法时，会自动将类的实例对象传递给`self`参数，不需要显式地传入。这样在方法中就可以访问和操作类的属性。通过`self`参数，可以确保方法作用于类的实例对象本身，实现了面向对象的封装特性。

6、类的继承

在面向对象编程中，类的继承是一种重要的概念，它允许一个类（称为子类或派生类）继承另一个类（称为父类或基类）的属性和方法。这种继承关系使得代码重用变得更加容易，同时也使得代码结构更加清晰和易于维护。

当一个类继承另一个类时，它自动获得了父类的所有属性和方法，并可以在此基础上进行扩展或修改。子类可以添加新的属性和方法，也可以重写父类中的方法来实现特定的功能。这种机制使得我们可以建立类的层次结构，从而更好地组织和管理代码。

首先，定义一个火箭，参数可以是另一个实例

from math import sqrt
 
class Rocket():
    # Rocket simulates a rocket ship for a game,
    #  or a physics simulation.
    
    def __init__(self, x=0, y=0):
        # Each rocket has an (x,y) position.
        self.x = x
        self.y = y
        
    def move_rocket(self, x_increment=0, y_increment=1):
        # Move the rocket according to the paremeters given.
        #  Default behavior is to move the rocket up one unit.
        self.x += x_increment
        self.y += y_increment
        
    def get_distance(self, other_rocket):
        # Calculates the distance from this rocket to another rocket,
        #  and returns that value.
        distance = sqrt((self.x-other_rocket.x)**2+(self.y-other_rocket.y)**2)
        return distance
        
rocket_0 = Rocket()
rocket_1 = Rocket(10,5)
 
 
distance = rocket_0.get_distance(rocket_1)
 
if distance<12:
    rocket_2 = Rocket(10,15)
    new_distance = rocket_0.get_distance(rocket_2)
    
print(new_distance)
    
print("The rockets are %f units apart." % distance)

航天飞机继承火箭

class Shuttle(Rocket):
    # Shuttle simulates a space shuttle, which is really
    #  just a reusable rocket.
    
    def __init__(self, x=0, y=0, flights_completed=0):
        super().__init__(x, y)# 通过super函数声明继承了父类的属性#继承几个写几个
        self.flights_completed = flights_completed
    
    def ifclose(self,other_rocket):
        if self.get_distance(other_rocket)<4:
            other_rocket.move_rocket(0,10)
            
        
shuttle = Shuttle(10,0,3)
print(shuttle.flights_completed)
 
 
 
rocket_0 = Shuttle()
rocket_1 = Shuttle(10,5,3)
 
# Show the distance between them.
distance = rocket_0.get_distance(rocket_1)
 
if distance<4:
    rocket_2 =shuttle(1,1,3)
    new_distance = rocket_0.get_distance(rocket_2)
    
print(new_distance)
 
 
print("The shuttle are %f units apart." % distance)

二、日期相关函数

通过`datetime`模块来实现

1. `datetime.now()`: 返回当前日期和时间。
```python
import datetime
 
now = datetime.datetime.now()
print(now)
```
 
2. `datetime.strptime()`: 将字符串转换为日期时间格式。
```python
date_str = '2022-04-15'
date = datetime.datetime.strptime(date_str, '%Y-%m-%d')
print(date)
```
 
3. `datetime.strftime()`: 将日期时间格式转换为指定字符串格式。
```python
date = datetime.datetime.now()
date_str = date.strftime('%Y-%m-%d')
print(date_str)
```
 
4. `datetime.timedelta()`: 用于计算日期时间之间的差值。
```python
date1 = datetime.datetime(2022, 4, 15)
date2 = datetime.datetime(2022, 4, 20)
diff = date2 - date1
print(diff.days)
```
 
5. `datetime.date()`: 用于表示日期。
```python
date = datetime.date(2022, 4, 15)
print(date)
```
 
6. `datetime.time()`: 用于表示时间。
```python
time = datetime.time(10, 30, 0)
print(time)
```

三、生成字母列表

import string
 
# 生成小写字母列表
lowercase_letters = list(string.ascii_lowercase)
 
# 生成大写字母列表
uppercase_letters = list(string.ascii_uppercase)
 
print(lowercase_letters)
print(uppercase_letters)

四、可变与不可变

在Python中，常见的不可变对象包括：
- 数字（int, float, complex）
- 字符串（str）
- 元组（tuple）

而常见的可变对象包括：
- 列表（list）
- 字典（dict）
- 集合（set）

不可变对象在创建后无法被修改，如果需要改变其值，通常会创建一个新的对象。可变对象可以在原地修改，即可以通过方法更改对象的值。对于不可变对象，不能向其添加、删除或修改元素，只能通过重新赋值的方式来实现变化。而对于可变对象，则可以直接修改对象的元素。

五、字符串相关函数与运用

1、仅保留字母的部分

# 定义一个字符串
s = "Hello123World"
 
# 通过列表推导式保留字符串中的字母部分
letters_only = ''.join([char for char in s if char.isalpha()])
 
print(letters_only)

2、字符串相关函数

 `len()`: 用于获取字符串的长度。
 `upper()`: 将字符串所有字母转换为大写形式。
 `lower()`: 将字符串所有字母转换为小写形式。
 `capitalize()`: 将字符串的第一个字符转换为大写，其他字符转换为小写。
 `title()`: 将每个单词的第一个字母转换为大写。
 `split()`: 将字符串按照指定的分隔符分割成多个部分，并返回一个列表。
 `join()`: 将列表中的字符串元素连接为一个字符串。
 `strip()`: 去除字符串首尾指定字符（默认为空格）。
 `replace()`: 替换字符串中指定的子串。
 `startswith()`: 判断字符串是否以指定的前缀开头。
 `endswith()`: 判断字符串是否以指定的后缀结尾。
 `find()`: 查找指定子串在字符串中的位置。
 `index()`: 查找指定子串在字符串中的位置，如果不存在则抛出异常。
 `isdigit()`: 判断字符串是否只包含数字。
 `isalpha()`: 判断字符串是否只包含字母字符。