【python基础知识】——数据类型、封装、继承、多态

在Python中，数据是通过各种类型来表示的。这些类型决定了数据可以进行哪些操作以及可以存储什么样的值。下面是一些Python中常见的数据类型。

数据类型

1. 整数（int）

整数类型用于表示没有小数部分的数。它可以是正数、负数或零。

positive_integer = 10
negative_integer = -5
zero_integer = 0

2. 浮点数（float）

浮点数用于表示有小数部分的数。它可以是正数或负数。

positive_float = 10.5 negative_float = -3.14159

3. 字符串（str）

字符串用于表示文本。在Python中，字符串可以用单引号、双引号或三引号来定义。

simple_string = "Hello, World!"
single_quoted_string = 'Hello, World!'
multiline_string = """This is a"""
multi-line_string=""""""

• 字符串（str）的方法：

  • .upper() - 将字符串中的所有字符转换为大写字母。
  • .lower() - 将字符串中的所有字符转换为小写字母。
  • .split() - 根据指定的分隔符将字符串分割成一个列表。
  • .join() - 将列表中的字符串合并成一个字符串，使用指定的字符串作为分隔符。
  • .replace() - 替换字符串中的子串为另一个子串。

# Example 1: Joining a list of strings with a space
words = ['Hello', 'world']
sentence = ' '.join(words)
print(sentence)  # Output: Hello world

# Example 2: Joining with a comma and a space
names = ['Alice', 'Bob', 'Charlie']
name_list = ', '.join(names)
print(name_list)  # Output: Alice, Bob, Charlie

# Example 3: Joining with a newline character to create a multiline string
lines = ['Line 1', 'Line 2', 'Line 3']
paragraph = '\n'.join(lines)
print(paragraph)
# Output:
# Line 1
# Line 2
# Line 3

# Example 4: Joining with an empty string
letters = ['P', 'y', 't', 'h', 'o', 'n']
word = ''.join(letters)
print(word)  # Output: Python

4. 列表（list）

列表是一种有序的集合，可以包含不同类型的元素，并且元素是可变的，即可以被修改。

my_list = [1, "Hello", 3.14, [2, 4, 6]]

• 列表（list）的方法：

  • .append() - 向列表末尾添加一个元素。
  • .remove() - 移除列表中的某个元素。
  • .pop() - 移除列表中的一个元素（默认是最后一个），并返回该元素的值。
  • .sort() - 将列表中的元素进行排序。
  • .reverse() - 将列表中的元素顺序反转。

5. 元组（tuple）

元组是一个不可变的有序集合，意味着一旦创建，其内容不能被修改。

my_tuple = (1, "Hello", 3.14)

7. 集合（set）

集合是一个无序的不重复元素集。它主要用于测试成员资格、移除重复项以及数学上的集合操作。

my_set = {1, 2, 3, "Hello"}
my_set_empty=set()

• 集合（set）的方法：

  • .add() - 向集合中添加元素。
  • .discard() - 移除集合中的一个元素，如果不存在则不做任何操作。
  • .union() - 返回两个集合的并集。
  • .intersection() - 返回两个集合的交集。
  • .difference() - 返回两个集合的差集。

8. 布尔（bool）

布尔类型用于表示逻辑值True或False。

is_valid = True
is_empty = False

9. NoneType

这是一个特殊的类型，用于表示空值或者无值的情况。

nothing = None

10、字典 字典（dictionary）是一种可变的、无序的数据结构，它存储了键（key）和值（value）之间的映射关系。字典中的每个元素都是一个键值对。键必须是不可变的数据类型，如字符串、数字或元组，而值可以是任何数据类型，如数字、字符串、列表或另一个字典等。 字典是通过一对大括号 {} 来定义的，键值对之间用逗号,分隔，冒号:用来分隔键和值。

1. 创建字典 : 创建一个字典是通过一对大括号 {} 来完成的，也可以使用 dict() 函数。

# 创建一个字典
my_dict = {
    'name': 'Alice',
    'age': 25,
    'is_student': True
}

# 使用dict函数 person = dict(name='John', age=30)

# 访问字典中的值 ------使用键来访问与之对应的值。
print(my_dict['name'])  # 输出: Alice

#使用 `.get()` 方法可以避免在键不存在时引发错误，它允许你为找不到的键指定一个默认返回值。
print(my_dict.get('age'))  # 输出: 25

# 添加或修改键值对
my_dict['age'] = 26  # 修改已有键对应的值
my_dict['city'] = 'New York'  # 添加新的键值对

#使用 `del` 语句或 `.pop()` 方法删除键值对。
# 删除键值对 
del my_dict['is_student']
# 或者使用 pop 方法
# age = my_dict.pop('age')

# 遍历字典
for key, value in my_dict.items():
    print(f"{key}: {value}")

# 检查键是否在字典中
if 'name' in my_dict:
    print("Name is present in the dictionary")

# 获取所有键或所有值
keys = my_dict.keys()
values = my_dict.values()


#使用 `in` 关键字来检查一个键是否存在于字典中。

if 'name' in person:
    print("Name is present in the dictionary")
    
    
7.  **字典合并**: 使用 `update()` 方法合并两个字典，如果有重复的键，合并后的字典会包含最新的值。

   other_info = {'job': 'Developer', 'age': 31}
   person.update(other_info)  # 更新person字典
   
8.  **字典推导式**: 字典推导式提供了一种简洁的方式来创建字典。
   squares = {x: x*x for x in range(6)}  # 生成一个键为数字，值为其平方的字典
 
9.  **清空字典**: 使用 `.clear()` 方法可以清空字典中的所有元素。

   person.clear()  # 清空person字典
 
10. **复制字典**: 使用 `.copy()` 方法或 `dict()` 函数可以复制一个字典。

  person_copy = person.copy()  # 创建person的一个浅拷贝
      

11. 要执行深拷贝 ，可以使用copy模块中的deepcopy()函数。这会递归地复制所有的键和值，包括嵌套的对象

  import copy

original_dict = {
    'a': 1,
    'b': {'c': 2, 'd': [3, 4, 5]},
}

# 执行深拷贝
deep_copied_dict = copy.deepcopy(original_dict)

# 修改深拷贝后的字典
deep_copied_dict['b']['d'].append(6)

# 原始字典保持不变
print(original_dict)        # 输出: {'a': 1, 'b': {'c': 2, 'd': [3, 4, 5]}}
print(deep_copied_dict)     # 输出: {'a': 1, 'b': {'c': 2, 'd': [3, 4, 5, 6]}}

Python字典的常用操作有：

• 创建和访问字典

• 添加、修改和删除键值对

• 遍历字典中的元素

• 字典的合并

• 字典推导式（类似于列表推导式）

• 字典（dict）的方法：

  • .keys() - 返回字典中的键集合。
  • .values() - 返回字典中的值集合。
  • .items() - 返回字典中的键值对集合。
  • .get() - 返回字典中键对应的值，如果键不存在则返回默认值。
  • .update() - 更新字典中的键值对。

类型转换

int() - 将一个数值或字符串转换为整数。

float_to_int = int(2.8)  # 结果为 2
str_to_int = int("5")    # 结果为 5

float() - 将一个字符串或整数转换为浮点数。

int_to_float = float(5)    # 结果为 5.0
str_to_float = float("2.5")  # 结果为 2.5

str() - 将数值转换为字符串。

int_to_str = str(10)    # 结果为 "10"
float_to_str = str(8.2)  # 结果为 "8.2"

list() - 将元组、集合、字符串等转换为列表。

tuple_to_list = list((1, 2, 3))    # 结果为 [1, 2, 3]
set_to_list = list({4, 5, 6})      # 结果为 [4, 5, 6]

tuple() - 将列表、集合、字符串等转换为元组。

list_to_tuple = tuple([7, 8, 9])   # 结果为 (7, 8, 9)

set() - 将列表、元组、字符串等转换为集合。

list_to_set = set([1, 2, 2, 3])    # 结果为 {1, 2, 3}，自动去重

dict() - 可以将包含键值对的列表转换为字典。

list_to_dict = dict([("a", 1), ("b", 2)])  # 结果为 {'a': 1, 'b': 2}

bool() - 将给定的值转换为布尔值。

zero_to_bool = bool(0)       # 结果为 False
non_zero_to_bool = bool(42)  # 结果为 True
empty_str_to_bool = bool("") # 结果为 False

假值

0,None,[],(),{},set(),"",'',"""""",False

封装（Encapsulation）

封装是将数据（属性）和行为（方法）捆绑在一起的过程。在Python中，封装通常是通过创建类（class）来实现的。类中的方法通常可以访问和修改类的内部状态，但是这些内部状态对于外部代码来说是隐藏的，这就是"封装"的含义。

class Car:
    def __init__(self, color, brand):
        self.color = color  # 公有属性
        self.__brand = brand  # 私有属性，通过双下划线来实现

    def drive(self):
        print(f"The {self.color} {self.__brand} car is driving.")

# 创建Car类的实例
my_car = Car("red", "Toyota")
my_car.drive()  # 可以访问公有方法drive
print(my_car.color)  # 可以访问公有属性color
# print(my_car.__brand)  # 访问私有属性会产生错误

继承（Inheritance）

继承是一种创建新类的方法，新创建的类（子类）继承了一个或多个类（父类）的特征（属性和方法）。子类可以添加新的属性和方法，也可以覆盖或扩展父类的行为。

# 父类
class Vehicle:
    def __init__(self, category):
        self.category = category

    def move(self):
        print("Moving...")

# 子类
class Car(Vehicle):
    def __init__(self, category, brand):
        super().__init__(category)  # 调用父类的构造方法
        self.brand = brand

    def move(self):
        super().move()  # 调用父类的方法
        print(f"The {self.brand} car is driving.")

# 创建Car类的实例
my_car = Car("Land Vehicle", "Toyota")
my_car.move()  # 输出: Moving...
               # 输出: The Toyota car is driving.

多态（Polymorphism）

多态是指不同类的对象对于相同的方法有着不同的响应。在Python中，多态通常是通过方法重写来实现的，即子类可以提供父类方法的一个新版本。

class Animal:
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        print("Woof!")

class Cat(Animal):
    def speak(self):
        print("Meow!")

def animal_speak(animal):
    animal.speak()  # 调用传入对象的speak方法

# 创建Dog和Cat类的实例
dog = Dog()
cat = Cat()

animal_speak(dog)  # 输出: Woof!
animal_speak(cat)  # 输出: Meow!

在上面的例子中，animal_speak 函数接受任何一个Animal或Animal子类的实例，并调用其speak方法。由于Dog和Cat都重写了speak方法，所以它们有着不同的行为，这就体现了多态。

适用范围

• 封装是为了保护对象的内部状态和隐藏对象的实现细节，使得代码模块化。
• 继承用于创建与已存在的类有共同特征的新类，它支持代码复用并建立类之间的关系。
• 多态允许我们使用统一的接口来操作不同的底层形式（数据类型），它使得代码更加灵活和可扩展。

在面向对象设计中，合理运用这三个概念可以让代码更加清晰、灵活和易于维护。