Python基础快速入门

基础语法

变量和数据类型

• Python 中有多种数据类型，如整数（int）、浮点数（float）、字符串（str）、布尔值（bool）等。
• 变量的命名规则：由字母、数字和下划线组成，不能以数字开头。
• 示例：

age = 25
name = "Alice"
is_student = True
pi = 3.14

运算符

• 算术运算符：+、-、*、/、%、**、//。
• 比较运算符：==、!=、>、<、>=、<=。
• 逻辑运算符：and、or、not。
• 赋值运算符：=、+=、-=、*=、/= 等。
• 示例：

a = 10
b = 3
print(a + b)
print(a > b)
print(not a > b)
c = 5
c += 2
print(c)

控制流语句

在 Python 中，主要有三种基本程序结构：顺序结构、选择结构和循环结构。

一、顺序结构

顺序结构是最简单的程序结构，按照代码的先后顺序依次执行。

例如： 

a = 10
b = 20
c = a + b
print(c)

二、选择结构

选择结构根据条件判断来决定执行哪些代码。

在 Python 中主要使用`if`语句、`if...else`语句和`if...elif...else`语句。

1. `if`语句： 

num = 5
if num > 0:
    print("数字是正数")

2. `if...else`语句： 

num = -5
if num > 0:
    print("数字是正数")
else:
    print("数字是负数或零")

3. `if...elif...else`语句：

num = 0
if num > 0:
    print("数字是正数")
elif num < 0:
    print("数字是负数")
else:
    print("数字是零")

三、循环结构

循环结构用于重复执行一段代码。

Python 中有`for`循环和`while`循环。

1. `for`循环： 

for i in range(5):
    print(i)

2. `while`循环： 

count = 0
while count < 5:
    print(count)
    count += 1

数据结构

列表（List）

• 列表是一种可变序列，可以存储不同类型的元素。
• 列表的操作：索引、切片、添加元素、删除元素、排序等。
• 示例：

my_list = [1, 2, "three", True]
print(my_list[1])
print(my_list[1:3])
my_list.append(5)
my_list.remove("three")
my_list.sort()
print(my_list)

元组（Tuple）

• 元组是一种不可变序列，可以存储不同类型的元素。
• 元组的操作：索引、切片等。
• 示例：

my_tuple = (1, 2, "three", True)
print(my_tuple[1])
print(my_tuple[1:3])

 字典（Dictionary）

• 字典是一种无序的键值对集合，键必须是唯一的且不可变的数据类型。
• 字典的操作：添加键值对、删除键值对、访问值等。
• 示例：

my_dict = {"name": "Alice", "age": 25, "is_student": True}
print(my_dict["name"])
my_dict["city"] = "New York"
del my_dict["is_student"]
print(my_dict)

集合（Set）

• 集合是一种无序的、不包含重复元素的集合。
• 集合的操作：添加元素、删除元素、交集、并集、差集等。
• 示例：

my_set = {1, 2, 3, 4}
my_set.add(5)
my_set.remove(2)
set1 = {1, 2, 3}
set2 = {3, 4, 5}
print(set1.intersection(set2))
print(set1.union(set2))
print(set1.difference(set2))

函数

定义函数

• 使用def关键字定义函数，函数可以有参数和返回值。
• 示例：

def add_numbers(a, b):
    return a + b

result = add_numbers(5, 3)
print(result)

函数参数

• 位置参数：按照参数的位置传递。
• 关键字参数：通过参数名传递。
• 默认参数：在函数定义时指定参数的默认值。
• 可变参数：使用*args和**kwargs接收任意数量的位置参数和关键字参数。
• 示例：

def my_function(a, b, c=0, *args, **kwargs):
    print(a, b, c)
    print(args)
    print(kwargs)

my_function(1, 2, 3, 4, 5, x=6, y=7)

面向对象的编程

        在 Python 中，面向对象编程（Object-Oriented Programming，OOP）是一种编程范式，它将数据和对数据的操作封装在对象中，通过定义类来创建对象。

一、类和对象

        类是对象的模板或蓝图，它定义了对象的属性（数据）和方法（行为）。对象是类的实例化，每个对象都有自己的独立状态和行为。

        例如，定义一个名为 “Person” 的类：

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def introduce(self):
        return f"Hi, I am {self.name} and I am {self.age} years old."

        可以通过以下方式创建 “Person” 类的对象：

person1 = Person("Alice", 25)
person2 = Person("Bob", 30)

二、属性和方法

1. 属性：

• 类的属性可以分为实例属性和类属性。
• 实例属性是每个对象独有的，通过在__init__方法中定义并使用self关键字来访问。
• 类属性是所有对象共享的，可以在类定义中直接定义，通过类名或对象名访问。

例如：

class Circle:
    pi = 3.14  # 类属性

    def __init__(self, radius):
        self.radius = radius  # 实例属性

    def area(self):
        return self.pi * self.radius * self.radius

2. 方法：

• 方法是与类相关联的函数，用于定义对象的行为。
• 方法可以分为实例方法、类方法和静态方法。
• 实例方法第一个参数是self，代表对象本身，可以访问对象的属性和其他方法。
• 类方法第一个参数是cls，代表类本身，可以访问类属性和其他类方法，使用@classmethod装饰器定义。
• 静态方法与类和对象无关，不能访问类属性和实例属性，使用@staticmethod装饰器定义。

例如：

class MathUtils:
    @classmethod
    def add(cls, a, b):
        return a + b

    @staticmethod
    def multiply(a, b):
        return a * b

三、封装、继承和多态

封装：

• 封装是将数据和操作数据的方法封装在类中，对外提供访问接口，隐藏内部实现细节。
• 通过使用私有属性（以双下划线开头，如__private_attr）和私有方法（以双下划线开头，如__private_method）来实现封装。

例如：

class BankAccount:
    def __init__(self, balance):
        self.__balance = balance

    def deposit(self, amount):
        self.__balance += amount

    def withdraw(self, amount):
        if amount <= self.__balance:
            self.__balance -= amount
        else:
            print("Insufficient balance.")

    def get_balance(self):
        return self.__balance

继承：

• 继承是一种创建新类的方式，新类可以继承现有类的属性和方法，并且可以添加新的属性和方法。
• 在 Python 中，使用类名后的括号中指定父类来实现继承。

例如：

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        pass

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

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

多态：

• 多态是指不同的对象对同一消息有不同的响应方式。
• 在 Python 中，多态通过方法重写和方法重载来实现。
• 方法重写是子类重写父类中的方法，以实现不同的行为。
• 方法重载在 Python 中可以通过使用默认参数或可变参数来实现类似的效果。

例如：

class Shape:
    def area(self):
        pass

class Rectangle(Shape):
    def __init__(self, length, width):
        self.length = length
        self.width = width

    def area(self):
        return self.length * self.width

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14 * self.radius * self.radius

Python文件操作

        通过面向对象编程，可以提高代码的可维护性、可扩展性和可重用性。在 Python 中可以方便地进行文件操作，主要包括文件的打开、读取、写入和关闭等操作。

一、打开文件

使用open()函数来打开文件，它返回一个文件对象。

语法：file_object = open(file_name, mode)

• file_name：要打开的文件名，可以是相对路径或绝对路径。
• mode：打开文件的模式，常见的模式有：
  • 'r'：只读模式，文件必须存在，否则会抛出错误。
  • 'w'：写入模式，如果文件存在则会被覆盖，如果文件不存在则会创建一个新文件。
  • 'a'：追加模式，如果文件存在，新内容会被追加到文件末尾，如果文件不存在则会创建一个新文件。
  • 'x'：独占创建模式，文件必须不存在，否则会抛出错误。
  • 'b'：二进制模式，可以与其他模式结合使用，如'rb'表示以二进制只读模式打开文件。
  • 't'：文本模式（默认），可以与其他模式结合使用，如'rt'表示以文本只读模式打开文件。

例如：

# 以只读模式打开一个文本文件
file = open('example.txt', 'r')

二、读取文件

1.使用read()方法可以读取文件的全部内容。

content = file.read()
print(content)

2.使用readline()方法可以读取文件的一行内容。

line = file.readline()
print(line)

3.使用readlines()方法可以读取文件的所有行，并以列表形式返回。

lines = file.readlines()
for line in lines:
    print(line)

三、写入文件

1. 使用`write()`方法可以向文件写入内容。

file = open('example.txt', 'w')
file.write('Hello, world!')

2. 使用`writelines()`方法可以向文件写入一个字符串列表。

lines = ['Line 1\n', 'Line 2\n', 'Line 3\n']
file = open('example.txt', 'w')
file.writelines(lines)

四、关闭文件使用close()方法关闭文件，释放资源。

使用close()方法关闭文件，释放资源。

file.close()

为了确保文件在使用后被正确关闭，也可以使用with语句，它会在代码块执行完毕后自动关闭文件

with open('example.txt', 'r') as file:
    content = file.read()
    print(content)

五、文件指针操作

文件对象有一个指针，指向当前读取或写入的位置。可以使用seek()方法移动文件指针。

file = open('example.txt', 'r')
file.seek(10)  # 将指针移动到文件的第 10 个字节处
content = file.read()
print(content)
file.close()

六、文件属性和方法

文件对象有一些属性和方法可以获取文件的信息和进行其他操作。

• name属性：返回文件的名称。
• closed属性：判断文件是否已关闭。
• flush()方法：刷新文件内部缓冲区，将数据立即写入文件。

例如：

file = open('example.txt', 'r')
print(file.name)
print(file.closed)
file.close()
print(file.closed)