Python基础

Python基础

数据类型

1. 整数（int）：例如 5、-10 等。
2. 浮点数（float）：例如 3.14、-0.5 等。
3. 字符串（str）：使用单引号 ' ' 或双引号 " " 括起来的字符序列，例如 'Hello'、"World" 。
4. 布尔值（bool）：只有两个值，True和 False。
5. 列表（list）：用方括号 [ ] 表示，元素之间用逗号分隔，例如 [1, 2, 3]、['a', 'b', 'c'] 。
6. 元组（tuple）：用小括号 ( ) 表示，元素之间用逗号分隔，例如 (1, 2, 3) 。元组中的元素不可修改。
7. 字典（dict）：由键值对组成，用花括号 { } 表示，键和值之间用冒号 : 分隔，元素之间用逗号分隔，例如 {'name': 'zhang3', 'age': 21} 。
8. 集合（set）：用花括号 { } 表示，但元素是无序且不重复的，例如 {1, 2, 3} 。

# 整数
num1 = 5
num2 = -10

# 浮点数
pi = 3.14
decimal = -0.5

# 字符串
str1 = 'Hello'
str2 = "World"

# 布尔值
is_true = True
is_false = False

# 列表
my_list = [1, 2, 3]
fruits = ['apple', 'banana', 'orange']

# 元组
my_tuple = (1, 2, 3)

# 字典
person = {'name': 'John', 'age': 25}

# 集合
my_set = {1, 2, 3}

元组

元组在 Python 中是一种不可变的数据结构，这意味着一旦创建，其元素就不能被修改。

元组使用小括号 () 来定义，元素之间用逗号 , 分隔。

my_tuple = (1, 2, 3)
another_tuple = ('a', 'b', 'c')
mixed_tuple = (1, 'hello', 3.14)

元组的主要特点和用途包括：

1. 元组可以包含不同类型的元素。
2. 由于其不可变性，元组适合在需要保证数据不被意外修改的情况下使用，比如作为函数的返回值，或者存储一些不应被更改的数据。

集合

集合是一种不允许重复元素且元素无序的数据结构。

集合使用花括号 {} 来定义，或者使用 set() 函数创建。

my_set = {1, 2, 3}
another_set = set([1, 2, 2, 3, 3, 3])  # 重复元素会被自动去除

集合的主要特点和用途包括：

1. 快速判断元素是否存在于集合中。
2. 进行集合的运算，如并集、交集、差集等。

set1 = {1, 2, 3}
set2 = {2, 3, 4}

# 并集
union_set = set1 | set2  # 或者 set1.union(set2)

# 交集
intersection_set = set1 & set2  # 或者 set1.intersection(set2)

# 差集
difference_set = set1 - set2  # 或者 set1.difference(set2)

字典

1.创建字典

• 使用花括号 {} 并以 键: 值 的形式添加元素来创建字典

  my_dict = {'key1': 'value1', 'key2': [1,2,3]}
  

• 也可以使用 dict() 函数创建字典。

  my_dict = dict(key1='value1', key2=[1,2,3])
  

• 还可以通过包含键值对的元组列表来创建字典。

  my_dict = dict([('key1', 'value1'), ('key2', 'value2')])
  

2.访问字典中的值

• 通过键来获取对应的值。

  print(my_dict['key1']) 
  

• 如果键不存在，会引发 KeyError 错误。为了避免错误，可以使用 get() 方法，它在键不存在时返回 None 或指定的默认值。

  print(my_dict.get('key3'))  # 返回 None
  print(my_dict.get('key3', 'default_value'))  # 返回 'default_value'
  

3.修改字典中的值

my_dict['key1'] = 'new_value1'

4.添加新的键值对

my_dict['key3'] = 'value3'

5.删除键值对

• 使用 del 关键字。

  del my_dict['key2']
  

6.检查键值对是否存在

if 'key1' in my_dict:
    print('Key exists')

7.遍历字典

• 遍历键

  for key in my_dict:
      print(key)
  

• 遍历值

  for value in my_dict.values():
      print(value)
  

• 遍历键值对

  for key, value in my_dict.items():
      print(f'Key: {key}, Value: {value}')
  

8.清空字典

my_dict.clear()

占位符

使用 % 进行格式化输出时，常见的占位符有以下几种：

1. %d：表示整数。
2. %f：表示浮点数，默认保留 6 位小数。
3. %.nf：表示浮点数，保留 n 位小数。例如 %.2f 表示保留 2 位小数。
4. %s：表示字符串。
5. %c：表示单个字符。

num = 10
pi = 3.14159
name = "Alice"
char = 'A'

print("整数: %d" % num)
print("浮点数: %.2f" % pi)
print("字符串: %s" % name)
print("字符: %c" % char)

在 Python 3.6 及以上版本中，更推荐使用 f-string 进行格式化输出

num = 10
pi = 3.14159
name = "Alice"
char = 'A'

print(f"整数: {num}")
print(f"浮点数: {pi:.2f}")
print(f"字符串: {name}")
print(f"字符: {char}")

函数

定义函数使用 def 关键字，其基本语法如下：

def function_name(parameters):
    """Docstring (可选)"""
    # 函数体
    return result  # 可选的返回值

1. 函数名：遵循 Python 的变量命名规则，通常使用具有描述性的名称，以便清楚地表明函数的功能。
2. 参数：在函数名后的括号内指定。参数可以有零个或多个，用于向函数传递数据。
3. Docstring（文档字符串）：是一个可选的字符串，放在函数定义的开头，用于描述函数的功能、参数和返回值等信息。它可以通过 help(function_name) 来查看。
4. 函数体：包含了实现函数功能的代码。
5. 返回值：使用 return 语句指定函数的返回结果。如果没有 return 语句，函数默认返回 None

定义一个计算两数和的函数

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

全局变量

定义全局变量

在 Python 中，全局变量是在函数外部定义的变量，可以在整个程序的任何地方被访问和修改。

示例：

global_variable = 10  # 定义一个全局变量

def my_function():
    print(global_variable)  # 在函数内部访问全局变量

my_function() # 调用函数

修改全局变量

在函数内部，如果要修改全局变量的值，需要使用 global 关键字进行声明，否则 Python 会认为是在函数内部创建一个新的局部变量。

global_variable = 10

def modify_global_variable():
    global global_variable  # 声明要修改全局变量
    global_variable = 20

modify_global_variable()
print(global_variable)  # 输出 20

with语句

在 Python 中，with 语句用于创建一个上下文管理器，它能够确保在代码块执行完毕后，相关的资源能够被正确地清理或释放，常用于文件操作、数据库连接等场景。

示例：

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

在上述示例中，open('example.txt', 'r') 作为上下文管理器，当代码进入 with 代码块时，文件会被打开。在代码块执行完毕后，无论是否发生异常，with 语句都会自动确保文件被正确关闭，无需手动调用 close() 方法。

with 语句的工作原理是基于上下文管理器对象的 __enter__ 和 __exit__ 方法。当进入 with 代码块时，会调用上下文管理器的 __enter__ 方法；当退出代码块时（无论是正常退出还是因异常退出），都会调用 __exit__ 方法来进行必要的清理操作。

除了文件操作，with 语句还可以用于自定义的上下文管理器。

示例：

class MyContextManager:
    def __enter__(self):
        print("Entering the context")
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        print("Exiting the context")

with MyContextManager() as cm:
    print("Inside the context")

在上述自定义的上下文管理器中，__enter__ 方法在进入 with 代码块时执行，__exit__ 方法在退出时执行。

class语句

class 关键字用于定义类。

类是一种面向对象编程（OOP）的概念，它是对象的模板或蓝图。通过类，可以定义对象的属性（数据）和方法（行为）。

示例：

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

    def bark(self):
        print(f"{self.name} is barking")

    def show_info(self):
        print(f"Name: {self.name}, Age: {self.age}")

在上述 Dog 类中：

• __init__ 方法是一个特殊的方法，称为构造方法。当创建类的实例时，会自动调用这个方法来进行初始化操作，可以在这个方法中接收参数并为实例的属性赋值。
• bark 方法和 show_info 方法定义了类的行为。
• self 是一个约定俗成的参数名，它代表类的实例本身。

使用类

my_dog = Dog("zhang3", 21) # 创建一个名为 my_dog 的 Dog 类的实例
my_dog.bark() # 调用方法bark
my_dog.show_info() # # 调用方法show_info

多线程和多进程

区别点	多进程	多线程
资源独立性	每个进程拥有独立的内存空间，资源隔离	多个线程共享所属进程的内存空间和资源
系统开销	创建和切换进程的开销较大	创建和切换线程的开销相对较小
稳定性	一个进程崩溃通常不影响其他进程，稳定性高	一个线程错误可能导致整个进程崩溃
并发性	可以在多核 CPU 上真正并行执行	在单核 CPU 上是并发执行，受 GIL 限制在多核 CPU 上不能真正并行（CPython 中）
通信方式	通常使用 IPC 机制，如管道、消息队列、共享内存等	可直接通过共享变量通信，但需使用锁保证线程安全

多线程

使用 threading 模块来创建多线程。

import threading
import time

# 定义线程执行的函数
def thread_function(name):
    print(f"Thread {name} is running...")
    time.sleep(2)
    print(f"Thread {name} completed")

# 创建线程
thread1 = threading.Thread(target=thread_function, args=("Thread 1",))
thread2 = threading.Thread(target=thread_function, args=("Thread 2",))

# 启动线程
thread1.start()
thread2.start()

# 等待线程完成
thread1.join()
thread2.join()

print("All threads completed")

多进程

import multiprocessing
import time

# 定义进程执行的函数
def process_function(name):
    print(f"Process {name} is running...")
    time.sleep(2)
    print(f"Process {name} completed")

if __name__ == '__main__':
    # 创建进程
    process1 = multiprocessing.Process(target=process_function, args=("Process 1",))
    process2 = multiprocessing.Process(target=process_function, args=("Process 2",))

    # 启动进程
    process1.start()
    process2.start()

    # 等待进程完成
    process1.join()
    process2.join()

    print("All processes completed")

在 Windows 系统上，多进程的创建代码必须放在 if __name__ == '__main__': 语句块中，以避免无限递归创建子进程的错误。

文件IO

使用 open() 函数来打开文件，它接受文件名和模式作为参数，并返回一个文件对象。

常见的文件打开模式有：

• 'r' ：只读模式（默认）。

• 'w' ：只写模式，如果文件存在则清空内容，如果文件不存在则创建。

• 'a' ：追加模式，如果文件存在则在末尾追加内容，如果文件不存在则创建。

• 'b' ：二进制模式，可以与其他模式结合使用，如 'rb' 、 'wb' 等。

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

读取文件

• read() ：读取整个文件的内容作为一个字符串返回。

• readline() ：读取文件的一行内容。

• readlines() ：读取文件的所有行，并以列表形式返回。

  # 读取整个文件内容
  content = file.read()
  
  # 读取一行内容
  line = file.readline()
  
  # 读取所有行内容
  lines = file.readlines()
  

写入文件

使用 write() 方法向文件写入内容。

# 以只写模式打开文件
file = open('example.txt', 'w')
file.write('Hello, World!')

关闭文件

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

file.close()

使用 with 语句

为了确保在操作完成后文件能正确关闭，可以使用 with 语句，这样在语句块结束时会自动关闭文件。

with open('example.txt', 'r') as file:
    content = file.read()
    # 在此处进行文件的读取操作