Python基础知识点全面总结

Python基础知识点全面总结

Python作为一种简洁、易读且功能强大的编程语言，已经成为编程学习和应用领域中的热门选择。本文将对Python的基础部分进行全面总结，涵盖数据类型、条件判断、循环、函数、数据结构等重要知识点，并附上相关代码示例。

一、数据类型

Python中的数据类型主要分为五大类：数值、布尔、字符串、容器、None。

1. 数值类型

   • 整型（int）：在Python 3中，int表示长整型，没有long类型。

     a = 23
     print(type(a))  # 输出: 
     

   • 浮点型（float）：用于表示小数。

     weight = 55.5
     print(type(weight))  # 输出: 
     

   • 复数（complex）：表示为a+bi，也可以为complex(a, b)，a和b都是浮点型。

     c = 3 + 4j
     print(type(c))  # 输出: 
     

   • 除法：有两种除法运算符，‘/‘和’//’。'/‘返回浮点数，’//'返回整数。

     print(2 / 4)  # 输出: 0.5
     print(2 // 4)  # 输出: 0
     

2. 布尔类型

   • 布尔值有两个：True和False，常用于条件判断中。

     is_true = True
     is_false = False
     print(is_true)  # 输出: True
     print(is_false)  # 输出: False
     

3. 字符串类型

   • 字符串用单引号或双引号括起来，Python中的字符串无法改变。

     str1 = '今年是2023年'
     str2 = "不是8102年"
     str3 = str1 + ',' + str2
     print(str3)  # 输出: 今年是2023年,不是8102年
     

   • 字符串索引从0开始，从后往前索引从-1开始。

     print(str1[0])  # 输出: 今
     print(str1[-1])  # 输出: 年
     

   • 字符串格式化：

     name = '止水'
     age = 23
     formatted_str = '我叫%s,我今年%d岁了' % (name, age)
     print(formatted_str)  # 输出: 我叫止水,我今年23岁了
     
     # 快速格式化
     formatted_str_fast = f'我叫{name},我今年{age}岁了'
     print(formatted_str_fast)  # 输出: 我叫止水,我今年23岁了
     

4. 容器类型

   • 列表（list）：相当于C语言中的数组，但其内部可以存放不同类型的数据。

     name_list = ['科比', '麦迪', '姚明', '霍华德']
     print(len(name_list))  # 输出: 4
     
     # 增加
     name_list.append('杜兰特')
     print(name_list)  # 输出: ['科比', '麦迪', '姚明', '霍华德', '杜兰特']
     
     # 删除
     del name_list[2]
     print(name_list)  # 输出: ['科比', '麦迪', '霍华德', '杜兰特']
     
     # 查询
     name1 = name_list[0]
     print(name1)  # 输出: 科比
     
     # 修改
     name_list[1] = '乔丹'
     print(name_list)  # 输出: ['科比', '乔丹', '霍华德', '杜兰特']
     

   • 元组（tuple）：属于不可变对象，一旦定义就不能修改。

     name_tuple = ('萌萌', '老朱', '宸宸')
     print(name_tuple)  # 输出: ('萌萌', '老朱', '宸宸')
     
     # 查找
     name = name_tuple[1]
     print(name)  # 输出: 老朱
     

   • 集合（set）：基本功能是进行成员关系测试和删除重复元素。

     team_set = {'湖人', '马刺', '雷霆', '勇士', '快船', '热火', '湖人'}
     print(team_set)  # 输出: {'湖人', '马刺', '热火', '勇士', '快船', '雷霆'}
     
     # 添加
     team_set.update(['Tencent', 'Alibaba', 'Baidu'])
     print(team_set)  # 输出: {'Tencent', 'Baidu', 'Alibaba', '湖人', '马刺', '热火', '勇士', '快船', '雷霆'}
     
     # 删除
     team_set.discard('Baidu')
     print(team_set)  # 输出: {'Tencent', 'Alibaba', '湖人', '马刺', '热火', '勇士', '快船', '雷霆'}
     
     # 查找
     tx_bool = 'Tencent' in team_set
     print(tx_bool)  # 输出: True
     

   • 字典（dict）：一种映射类型，用"{}"标识，是一个无序的键(key): 值(value)对集合。

     name_dic = {'001': '张萌', '002': '老朱', '003': '阿轲', '004': '木兰'}
     print(name_dic)  # 输出: {'001': '张萌', '002': '老朱', '003': '阿轲', '004': '木兰'}
     
     # 添加
     name_dic['005'] = '李白'
     print(name_dic)  # 输出: {'001': '张萌', '002': '老朱', '003': '阿轲', '004': '木兰', '005': '李白'}
     
     # 删除
     del name_dic['005']
     print(name_dic)  # 输出: {'001': '张萌', '002': '老朱', '003': '阿轲', '004': '木兰'}
     
     # 查询
     name1 = name_dic['002']
     print(name1)  # 输出: 老朱
     
     # 修改
     name_dic['002'] = '小乔'
     print(name_dic)  # 输出: {'001': '张萌', '002': '小乔', '003': '阿轲', '004': '木兰'}
     

二、条件判断

条件判断用于根据表达式的真假来决定执行哪段代码。

1. if语句

   a = 10
   if a > 5:
       print("a大于5")  # 输出: a大于5
   

2. if-else语句

   a = 3
   if a > 5:
       print("a大于5")
   else:
       print("a不大于5")  # 输出: a不大于5
   

3. if-elif-else语句

   a = 7
   if a > 10:
       print("a大于10")
   elif a > 5:
       print("a大于5但小于等于10")  # 输出: a大于5但小于等于10
   else:
       print("a不大于5")
   

4. 判断语句的嵌套

   a = 8
   if a > 5:
       if a < 10:
           print("a在5和10之间")  # 输出: a在5和10之间
       else:
           print("a大于等于10")
   else:
       print("a小于等于5")
   

三、循环

循环用于重复执行某段代码，直到满足特定条件为止。

1. while循环

   count = 0
   while count < 5:
       print(count)
       count += 1
   # 输出: 0 1 2 3 4
   

2. for循环

   for i in range(5):
       print(i)
   # 输出: 0 1 2 3 4
   

3. 循环嵌套

#Python for 循环嵌套语法
for iterating_var in sequence:
   for iterating_var in sequence:
      statements(s)
   statements(s)
#Python while 循环嵌套语法：
while expression:
   while expression:
      statement(s)
   statement(s)

四、函数

函数是Python编程中的核心概念之一，它允许你将代码块组织成可重用的单元。

1. 定义函数

   使用def关键字定义函数，后面跟着函数名和括号（可能包含参数），以及冒号和函数体。

   def greet(name):
       print(f"Hello, {name}!")
   

2. 调用函数

   定义函数后，可以通过函数名（可能跟着参数）来调用它。

   greet("Alice")  # 输出: Hello, Alice!
   

3. 返回值

   函数可以使用return语句返回一个值。

   def add(a, b):
       return a + b
   
   result = add(3, 5)
   print(result)  # 输出: 8
   

4. 参数类型

   • 位置参数：按位置顺序传递参数。
   • 关键字参数：通过参数名传递参数，位置可以随意。
   • 默认参数：在函数定义时，为参数提供默认值。
   • 可变参数：使用*args和**kwargs来处理不确定数量的参数。

   def func(a, b=10, *args, **kwargs):
       print(a, b)
       print(args)
       print(kwargs)
   
   func(1, 2, 3, 4, key1="value1", key2="value2")
   # 输出:
   # 1 2
   # (3, 4)
   # {'key1': 'value1', 'key2': 'value2'}
   

5. 匿名函数

   使用lambda表达式创建匿名函数，通常用于简单操作或作为其他函数的参数。

   square = lambda x: x ** 2
   print(square(5))  # 输出: 25
   

6. 递归函数

   函数直接或间接调用自身。

   def factorial(n):
       if n == 0:
           return 1
       else:
           return n * factorial(n - 1)
   
   print(factorial(5))  # 输出: 120
   

五、数据结构

Python提供了多种内置数据结构，如列表、元组、集合和字典，以及更高级的数据结构，如栈、队列和链表（这些通常通过列表或其他数据结构来实现）。

1. 列表

   列表是Python中最常用的数据结构之一，它是一个有序的集合，可以随时添加和删除其中的元素。

   my_list = [1, 2, 3, 4, 5]
   my_list.append(6)  # 添加元素
   my_list.remove(3)  # 删除元素
   print(my_list)  # 输出: [1, 2, 4, 5, 6]
   

2. 元组

   元组与列表类似，但它是不可变的，即一旦创建，就不能修改其内容。

   my_tuple = (1, 2, 3, 4, 5)
   # my_tuple[0] = 10  # 这将引发TypeError
   print(my_tuple)  # 输出: (1, 2, 3, 4, 5)
   

3. 集合

   集合是一个无序的不重复元素集。它支持数学上的集合运算，如并集、交集、差集等。

   set1 = {1, 2, 3}
   set2 = {3, 4, 5}
   print(set1.union(set2))  # 并集: {1, 2, 3, 4, 5}
   print(set1.intersection(set2))  # 交集: {3}
   print(set1.difference(set2))  # 差集: {1, 2}
   

4. 字典

   字典是一个无序的键值对集合。每个键值对将键映射到值。

   my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}
   print(my_dict['name'])  # 输出: Alice
   my_dict['email'] = '[email protected]'  # 添加键值对
   print(my_dict)  # 输出: {'name': 'Alice', 'age': 25, 'city': 'New York', 'email': '[email protected]'}
   

六、模块与包

Python的模块和包机制允许你将代码组织成更大的组件，并可以重用和分发这些组件。

1. 模块

   模块是一个包含Python代码的文件，文件名就是模块名。你可以使用import语句来导入模块。

   import math
   print(math.sqrt(16))  # 输出: 4.0
   

2. 包

   包是一个包含多个模块的目录，目录中必须有一个__init__.py文件（可以为空），用于标识该目录是一个Python包。

   # 假设有一个名为mypackage的包，其中包含一个名为mymodule的模块
   from mypackage import mymodule
   mymodule.some_function()
   

七、文件操作

Python提供了内置的文件操作函数，允许你读取、写入和修改文件。

1. 打开文件

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

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

2. 读取文件

   使用文件对象的read()、readline()或readlines()方法读取文件内容。

   content = file.read()  # 读取整个文件内容
   print(content)
   file.close()  # 关闭文件
   

3. 写入文件

   使用open()函数以写入模式（‘w’）或追加模式（‘a’）打开文件，然后使用write()方法写入内容。

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

4. 异常处理

   在处理文件时，使用try...except语句来捕获和处理可能的异常，如文件不存在或权限不足等。

   try:
       file = open('nonexistent_file.txt', 'r')
   except FileNotFoundError:
       print("文件不存在")
   

八、面向对象编程（OOP）

Python支持面向对象编程，允许你定义类、创建对象和使用继承等特性。

1. 定义类

   使用class关键字定义类，后面跟着类名和冒号，以及类体（包含属性和方法）。

   class Person:
       def __init__(self, name, age):
           self.name = name
           self.age = age
   
       def greet(self):
           print(f"Hello, my name is {self.name} and I am {self.age} years old.")
   

2. 创建对象

   使用类名加括号（可能包含参数）来创建对象。

   person = Person("Alice", 30)
   person.greet()  # 输出: Hello, my name is Alice and I am 30 years old.
   

3. 继承

   使用class关键字定义子类，并在括号中指定父类名。

   class Employee(Person):
       def __init__(self, name, age, employee_id):
           super().__init__(name, age)
           self.employee_id = employee_id
   
       def show_id(self):
           print(f"My employee ID is {self.employee_id}")
   
   employee = Employee("Bob", 40, "E12345")
   employee.greet()  # 输出: Hello, my name is Bob and I am 40 years old.
   employee.show_id()  # 输出: My employee ID is E12345
   

九、异常处理

异常处理允许你在程序运行过程中捕获和处理错误。

1. try…except语句

   使用try块包裹可能引发异常的代码，并在except块中处理异常。

   try:
       result = 10 / 0  # 这将引发ZeroDivisionError
   except ZeroDivisionError:
       print("除数不能为零!")
   

十、并发编程

Python提供了多种并发编程的方法，包括多线程、多进程和异步编程。

1. 多线程

   使用threading模块创建和管理线程。线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位。

   import threading
   
   def worker():
       print("Worker thread is running")
   
   thread = threading.Thread(target=worker)
   thread.start()
   thread.join()  # 等待线程完成
   

2. 多进程

   使用multiprocessing模块创建和管理进程。进程是系统进行资源分配和调度的基本单位，实现了操作系统的并发。

   from multiprocessing import Process
   
   def worker():
       print("Worker process is running")
   
   process = Process(target=worker)
   process.start()
   process.join()  # 等待进程完成
   

3. 异步编程

   使用asyncio模块进行异步编程，允许你编写单线程的并发代码。

   import asyncio
   
   async def main():
       print("Hello")
       await asyncio.sleep(1)  # 模拟异步操作
       print("World")
   
   asyncio.run(main())
   

4. 线程锁与进程锁

   为了防止多线程或多进程同时访问共享资源导致数据竞争和不一致，可以使用锁（如threading.Lock和multiprocessing.Lock）来同步访问。

   import threading
   
   lock = threading.Lock()
   
   def worker():
       with lock:  # 使用上下文管理器自动获取和释放锁
           print("Worker thread is accessing the shared resource")
   
   threads = [threading.Thread(target=worker) for _ in range(5)]
   for thread in threads:
       thread.start()
   for thread in threads:
       thread.join()
   

十一、网络编程

Python提供了强大的网络编程支持，允许你创建客户端和服务器应用。

1. socket编程

   使用socket模块进行低级别的网络编程，可以创建TCP或UDP连接。

   import socket
   
   # 创建一个TCP/IP套接字
   sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
   
   # 连接到服务器
   server_address = ('localhost', 65432)
   sock.connect(server_address)
   
   try:
       # 发送数据
       message = 'This is the message.'
       sock.sendall(message.encode('utf-8'))
   
       # 接收数据
       data = sock.recv(1024)
       print('Received', repr(data.decode('utf-8')))
   finally:
       # 关闭连接
       sock.close()
   

2. HTTP服务器

   使用http.server模块可以快速创建一个简单的HTTP服务器。

   from http.server import SimpleHTTPRequestHandler, HTTPServer
   
   class MyHandler(SimpleHTTPRequestHandler):
       def do_GET(self):
           self.send_response(200)
           self.send_header('Content-type', 'text/html')
           self.end_headers()
           self.wfile.write(b"Hello, world!")
   
   def run(server_class=HTTPServer, handler_class=MyHandler, port=8080):
       server_address = ('', port)
       httpd = server_class(server_address, handler_class)
       print(f"Starting httpd server on port {port}")
       httpd.serve_forever()
   
   if __name__ == "__main__":
       run()
   

3. 请求库

   使用requests库（第三方库，需要安装）可以方便地发送HTTP请求。

   import requests
   
   response = requests.get('https://api.github.com')
   print(response.status_code)
   print(response.json())
   

十二、数据库操作

Python支持多种数据库，包括SQLite、MySQL、PostgreSQL等，可以使用相应的数据库驱动库进行操作。

1. SQLite

   使用sqlite3模块进行SQLite数据库操作。

   import sqlite3
   
   # 连接到SQLite数据库（如果数据库不存在，会自动创建）
   conn = sqlite3.connect('example.db')
   c = conn.cursor()
   
   # 创建表
   c.execute('''CREATE TABLE IF NOT EXISTS users
                (id INTEGER PRIMARY KEY, name TEXT, age INTEGER)''')
   
   # 插入数据
   c.execute("INSERT INTO users (name, age) VALUES (?, ?)", ('Alice', 30))
   
   # 提交事务
   conn.commit()
   
   # 查询数据
   c.execute('SELECT * FROM users')
   rows = c.fetchall()
   for row in rows:
       print(row)
   
   # 关闭连接
   conn.close()
   

2. MySQL

   使用mysql-connector-python库（第三方库，需要安装）进行MySQL数据库操作。

   import mysql.connector
   
   # 连接到MySQL数据库
   conn = mysql.connector.connect(
       host="localhost",
       user="yourusername",
       password="yourpassword",
       database="yourdatabase"
   )
   cursor = conn.cursor()
   
   # 创建表
   cursor.execute("""CREATE TABLE IF NOT EXISTS users
                     (id INT AUTO_INCREMENT PRIMARY KEY, name VARCHAR(255), age INT)""")
   
   # 插入数据
   cursor.execute("INSERT INTO users (name, age) VALUES (%s, %s)", ('Bob', 40))
   
   # 提交事务
   conn.commit()
   
   # 查询数据
   cursor.execute("SELECT * FROM users")
   rows = cursor.fetchall()
   for row in rows:
       print(row)
   
   # 关闭连接
   cursor.close()
   conn.close()
   

以上是Python编程的一些基础知识和常见库的使用介绍。Python作为一种高级编程语言，拥有丰富的库和框架，适用于各种应用场景。希望这些内容能帮助你更好地理解和使用Python。