# python简明教程 **Repository Path**: z601350993/python-concise-tutorial ## Basic Information - **Project Name**: python简明教程 - **Description**: No description available - **Primary Language**: Unknown - **License**: Not specified - **Default Branch**: master - **Homepage**: None - **GVP Project**: No ## Statistics - **Stars**: 1 - **Forks**: 0 - **Created**: 2024-09-29 - **Last Updated**: 2025-03-19 ## Categories & Tags **Categories**: Uncategorized **Tags**: None ## README 本教程主要目的是：帮助读者能看懂AI生成的代码。 这是一个包含常用关键字和语法的程序，帮助读者快速熟悉python语法。 ``` # 导入必要的模块 import sys # sys模块是和系统交互的工具。 print(sys.version) # 输出python版本信息。 # 使用数据分析工具pandas,起个别名为pd. 要先在命令行安装这个模块，安装命令是：pip install pandas import pandas as pd # 使用pandas模块的一个例子。 def 创建一个CSV文件(): ''' 创建并保存一个csv文件。 ''' # 创建一个字典 data = { 'name': ['Alice', 'Bob', 'Charlie', 'David', 'Eva'], 'age': [15, 16, 14, 15, 16], 'grade': [90, 85, 92, 88, 95] } # 将字典转换为表格形式。 df = pd.DataFrame(data) #pd是前面起的别名，DataFrame是导入的pd模块中的函数。 # 保存 DataFrame 为 CSV 文件 df.to_csv('students.csv', index=False) # 运行上面写的函数。 创建一个CSV文件() # 直接运行脚本时执行这个函数。 def main(): # 使用 if-elif-else 语句，判断输入的数字与10相比的结果 x = input("请输入数字：") # input()是一个内置函数，获取用户输入的信息 x = int(x) # 将字符转换为数字，不然数据类型不一致，后面不能比较。 if x < 10: print("x 小于 10") elif x == 10: print("x 等于 10") else: print("x 大于 10") #写一个功能，作用是返回给定的值，如果值是 None 或空字符串，则返回默认值。 def get_value_or_default(value, default="默认值"): """ 三引号也可以作为注释使用。 三引号常用于编写文档字符串（docstrings），这些字符串通常位于函数、类或模块的开头， 用于描述其用途和行为。其中的空格和缩进会保留。 """ print(value or default) # 使用这个函数。 get_value_or_default(None) # 输出：默认值 # 使用 for 循环，输出数字0-99 for i in range(100): """ range(100)函数会返回一个列表：[0,1……,99]。 for i 是从列表中取内容，按顺序每次取一个数字，命名为i,并对其进行处理。 """ print(i) # 使用 while 循环，输出数字0-99 i = 0 while i < 100: """ 如果i<100,就执行代码块，直到后面 i<100不成立时，不再执行代码块。 """ print(i) i += 1 # i += 1 等同于 i = i + 1 # 写一个死循环。 def dead_XunHuan(): while True: # 一直判断通过。True和1意思相同，也可以写成： while 1: print("这是死循环") # 如果执行这个函数，会一直输出：这是死循环。 # 检查是否直接运行脚本 if __name__ == "__main__": main() ``` ## 计算机编程基本原理 计算机编程就是对计算机下指令。但计算机听不懂我们的语言，所以需要用它能听懂的语言去下指令，就是编程语言。 计算机的语言相比自然语言简单很多，只有固定的32个词（关键字），一些标点符号（运算符）还有一些内置的写好的功能（内置函数）。 对计算机下指令要用以上的单词和符号进行。 ## 相关语法 ### 基础语法 1. 语句：一条语句占一行，如果一行多条语句必须用分号隔开。 2. 注释：#号后面是注释，给人看的，计算机会忽略。 3. 缩进：Python通过冒号和空格产生代码块，不能随意在一行前面加空格或TAB。 ```python # 计算一个数据的绝对值 # 这是注释，给人类看的，计算机会忽略。 a = 100 if a >= 0: print(a) # 冒号后面的，换行后要缩进。 else: print(-a) # 这里会报错，缩进和前面不一样。 ``` ### 关键字 32个 #### 特殊数据（内置常量）：False True None ** （1）False** ：与 0 相同。 比较操作的返回结果是False，表明比较错误。 ![输入图片说明](https://cdn.nlark.com/yuque/0/2024/png/646661/1727572404324-c27166ba-6284-45a4-8620-216ad79b6fb5.png) ** （2）True ** ：与 1 相同。 比较操作的返回结果是True，表明比较正确。 ![输入图片说明](https://cdn.nlark.com/yuque/0/2024/png/646661/1727572598480-131f6d4f-d294-4796-995c-6b088da53b9e.png) ** （3） None **：代表空值**。**类似于当我们不知道某件事情的答案时说的“我不知道”。当函数执行完毕但不返回任何结果时，默认返回的就是None。 #### 逻辑判断： not and or is in **not：** 含义：表示“不是”。 例子：not True 返回 False。 **and：** 含义：表示“并且”，只有当两边都为真时结果才为真。 例子：True and False 返回 False。 **or：** 含义：表示“或者”，只要有一边为真结果就为真。 例子：True or False 返回 True。 **is：** 含义：检查两个对象是否是同一个对象（内存地址相同）。 例子：x = [1, 2, 3]; y = x; x is y 返回 True。 **in：** 含义：检查一个元素是否存在于一个序列中。 例子：5 in [1, 2, 3, 4, 5] 返回 True。 #### 函数 def lambda pass return yield 1. `def` + **含义**：给一段代码起一个标题（函数名），以便后面可以直接用标题使用它。 + **例子**： ```python def 打招呼(姓名): # “打招呼”是起的函数名，括号内的是用这一段代码需要提供的信息（参数）。 print(f"你好, {姓名}!") # print也是一个函数，功能是在终端输出给定的内容。 print("吃过了吗？") 打招呼("小明") # 输出：你好, 小明! ``` ![](https://cdn.nlark.com/yuque/0/2024/png/646661/1727575749611-201a4a09-6db5-4651-bea1-2b333addf704.png) 2. `lambda` 不常用 + **含义**：创建一个特殊的函数（即没有名字的函数）。代码只能一行。 + **例子**： ```python add = lambda x, y: x + y result = add(3, 5) print(result) # 输出：8 ``` 3. `pass` + **含义**：占位符，表示什么都不做。常用于需要语法结构但不需要实际代码的地方。 + **例子**： ```python if True: pass # 这里什么都不做 else: print("这个不会打印") ``` 4. `return` + **含义**：从函数中返回一个值，并结束函数的执行。 + **例子**： ```python def add(a, b): return a + b result = add(3, 5) print(result) # 输出：8 ``` 5. `yield` 不常用，可以不看。 + **含义**：用于定义生成器函数。生成器是一种特殊的迭代器，可以用来生成一系列的值，但不会一次性将所有值存储在内存中。每次调用生成器时，它会返回一个值，并暂停执行，直到下一次调用。 + **例子**： ```python def count_up_to(n): i = 1 while i <= n: yield i i += 1 for number in count_up_to(5): print(number) # 输出：1 2 3 4 5 ``` #### 结构控制 if elif else for while break continue `1.if` + **含义**：如果某个条件为真，则执行相应的代码块。 + **例子**： ```python x = 5 if x > 0: print("x 是正数") # 输出：x 是正数 ``` `2.elif` + **含义**：如果前面的 `if` 条件不成立，且当前的 `elif` 条件为真，则执行相应的代码块。 + **例子**： ```python x = 0 if x > 0: print("x 是正数") elif x == 0: print("x 是零") # 输出：x 是零 ``` `3.else` + **含义**：如果前面的所有 `if` 和 `elif` 条件都不成立，则执行 `else` 代码块。 + **例子**： ```python x = -5 if x > 0: print("x 是正数") elif x == 0: print("x 是零") else: print("x 是负数") # 输出：x 是负数 ``` `4.for` + **含义**：用于遍历一个序列（如列表、字符串等），对每个元素执行相同的代码块。 + **例子**： ```python for i in [1, 2, 3]: print(i) # 输出：1 2 3 ``` `5.while` + **含义**：只要某个条件为真，就重复执行相应的代码块。 + **例子**： ```python count = 0 while count < 3: print(count) count += 1 # 输出：0 1 2 ``` 6. `break` + **含义**：立即退出当前循环。 + **例子**： ```python for i in range(10): if i == 3: break print(i) # 输出：0 1 2 ``` 7. `continue` + **含义**：跳过当前循环的剩余部分，并继续下一次循环。 + **例子**： ```python for i in range(5): if i == 2: continue print(i) # 输出：0 1 3 4 ``` #### 导入代码 import from as 1. `import` + **含义**：使用其他程序员已经编写好的代码（也叫模块或包） + **例子**： ```python import os # OS模块是管理文件、目录和执行系统命令的工具。os.getcwd() 获取当前工作目录 print(os.getcwd()) ``` ![](https://cdn.nlark.com/yuque/0/2024/png/646661/1727436997813-9ba14433-fff4-4bfa-b6ad-24784ba52163.png) 2. `from ... import ...` + **含义**：从一个模块中导入特定的函数、类或变量。 + **例子**： ```python from os import path # path是路径处理相关模块。 path_one = "example.txt" if path.exists(path_one): # path.exists(path) 函数用于判断路径是否存在。 print("文件存在") else: print("文件不存在") # 输出：文件不存在 ``` ![](https://cdn.nlark.com/yuque/0/2024/png/646661/1727578059748-d1b8424b-e5fc-4204-abd9-a21bd14896ce.png) 3. `as` + **含义**：为导入的模块或对象指定一个别名。 + **例子**： ```python from os import path as p # 将path指定别名为 p path_one = "example.txt" if p.exists(path_one): # 用p 代替 path print("文件存在") else: print("文件不存在") # 输出：文件不存在 ``` 总结 + `import`：导入整个模块。 + `from ... import ...`：从模块中导入特定的函数、类或变量。 + `as`：为导入的模块或对象指定一个别名。 #### 空间变量 global nonlocal 1. `global` + **含义**：在函数内部声明一个全局变量。这样可以在函数内部修改全局作用域中的变量。 + **例子**： ```python x = 10 # 全局变量 def modify_global(): global x x = 20 # 修改全局变量 x print(x) # 输出：10 modify_global() print(x) # 输出：20 ``` 2. `nonlocal` + **含义**：在嵌套函数中声明一个非局部变量（即外部函数的局部变量）。这样可以在内层函数中修改外层函数的局部变量。 + **例子**： ```python def outer_function(): y = 5 # 外部函数的局部变量 def inner_function(): nonlocal y y = 10 # 修改外部函数的局部变量 y print(y) # 输出：5 inner_function() print(y) # 输出：10 outer_function() ``` 总结 + `global`：在函数内部声明一个全局变量，允许在函数内部修改全局作用域中的变量。 + `nonlocal`：在嵌套函数中声明一个非局部变量，允许在内层函数中修改外层函数的局部变量。 #### 类 class 　 基本不用 `class` + **含义**：`class` 用于定义一个类。类是面向对象编程的基础，它是一种创建对象的蓝图或模板。类中可以包含属性（数据）和方法（函数）。 基本结构 ```python class ClassName: def __init__(self, param1, param2): self.param1 = param1 self.param2 = param2 def method_name(self): # 方法体 pass ``` + `__init__`** 方法**：这是类的构造函数，当创建类的实例时自动调用。它通常用于初始化对象的属性。 + `self`** 参数**：在类的方法中，第一个参数通常是 `self`，它代表类的实例本身。通过 `self` 可以访问类的属性和方法。 示例代码 下面是一个简单的例子，定义一个 `Person` 类，并创建该类的实例。 ```python # 定义一个 Person 类 class Person: def __init__(self, name, age): self.name = name self.age = age def greet(self): print(f"你好，我叫 {self.name}，今年 {self.age} 岁。") # 创建 Person 类的实例 person1 = Person("小明", 20) person2 = Person("小红", 25) # 调用实例的方法 person1.greet() # 输出：你好，我叫 小明，今年 20 岁。 person2.greet() # 输出：你好，我叫 小红，今年 25 岁。 ``` 解释 1. **定义类**： ```python class Person: def __init__(self, name, age): self.name = name self.age = age ``` - `__init__` 方法用于初始化新创建的对象。`name` 和 `age` 是传入的参数，`self.name` 和 `self.age` 是对象的属性。 2. **定义方法**： ```python def greet(self): print(f"你好，我叫 {self.name}，今年 {self.age} 岁。") ``` - `greet` 方法是一个普通的方法，可以通过实例调用。它使用 `self` 来访问实例的属性。 3. **创建实例**： ```python person1 = Person("小明", 20) person2 = Person("小红", 25) ``` - 通过 `Person` 类创建两个实例 `person1` 和 `person2`，并传入不同的参数。 4. **调用方法**： ```python person1.greet() person2.greet() ``` - 通过实例调用 `greet` 方法，输出相应的问候信息。 进一步的例子：继承 继承是面向对象编程中的一个重要概念，允许你创建一个新的类，继承已有类的属性和方法。 ```python # 定义一个基类 class Animal: def __init__(self, name): self.name = name def speak(self): raise NotImplementedError("子类必须实现这个方法") # 定义一个派生类 class Dog(Animal): def speak(self): return f"{self.name} 说：汪汪！" class Cat(Animal): def speak(self): return f"{self.name} 说：喵喵！" # 创建实例 dog = Dog("旺财") cat = Cat("小花") # 调用方法 print(dog.speak()) # 输出：旺财 说：汪汪！ print(cat.speak()) # 输出：小花 说：喵喵！ ``` 解释 1. **基类 **`Animal`： - 定义了一个 `speak` 方法，但没有具体实现，而是抛出一个 `NotImplementedError` 异常，表示子类必须实现这个方法。 2. **派生类 **`Dog`** 和 **`Cat`： - 继承自 `Animal` 类，并实现了 `speak` 方法。 3. **创建实例并调用方法**： - 通过派生类创建实例，并调用 `speak` 方法，输出相应的动物叫声。 通过这些简洁的解释和示例代码，希望你能更好地理解 `class` 的作用和用法。如果有更多问题或需要进一步的例子，请随时告诉我！ #### 删除 del　　基本不用 `del` + **含义**：`del` 用于删除对象的引用。它可以删除变量、列表中的元素、字典中的键值对等。 + **作用**： - 删除变量：从内存中移除变量的引用。 - 删除列表中的元素：从列表中移除指定索引的元素。 - 删除字典中的键值对：从字典中移除指定的键及其对应的值。 - 删除集合中的元素：从集合中移除指定的元素。 示例代码 1. 删除变量 ```python x = 10 print(x) # 输出：10 del x # print(x) # 这行会引发 NameError: name 'x' is not defined ``` 2. 删除列表中的元素 ```python my_list = [1, 2, 3, 4, 5] print(my_list) # 输出：[1, 2, 3, 4, 5] del my_list[2] # 删除索引为2的元素 print(my_list) # 输出：[1, 2, 4, 5] ``` 3. 删除字典中的键值对 ```python my_dict = {'a': 1, 'b': 2, 'c': 3} print(my_dict) # 输出：{'a': 1, 'b': 2, 'c': 3} del my_dict['b'] # 删除键为 'b' 的键值对 print(my_dict) # 输出：{'a': 1, 'c': 3} ``` 4. 删除集合中的元素 ```python my_set = {1, 2, 3, 4, 5} print(my_set) # 输出：{1, 2, 3, 4, 5} del my_set # 删除整个集合 # print(my_set) # 这行会引发 NameError: name 'my_set' is not defined ``` 解释 删除变量： ```python x = 10 print(x) # 输出：10 del x # print(x) # 这行会引发 NameError: name 'x' is not defined ``` - `del x` 删除了变量 `x`，之后再访问 `x` 会引发 `NameError`。 删除列表中的元素： ```python my_list = [1, 2, 3, 4, 5] print(my_list) # 输出：[1, 2, 3, 4, 5] del my_list[2] # 删除索引为2的元素 print(my_list) # 输出：[1, 2, 4, 5] ``` - `del my_list[2]` 删除了列表 `my_list` 中索引为2的元素（即3）。 删除字典中的键值对： ```python my_dict = {'a': 1, 'b': 2, 'c': 3} print(my_dict) # 输出：{'a': 1, 'b': 2, 'c': 3} del my_dict['b'] # 删除键为 'b' 的键值对 print(my_dict) # 输出：{'a': 1, 'c': 3} ``` - `del my_dict['b']` 删除了字典 `my_dict` 中键为 `'b'` 的键值对。 删除集合中的元素： ```python my_set = {1, 2, 3, 4, 5} print(my_set) # 输出：{1, 2, 3, 4, 5} del my_set # 删除整个集合 # print(my_set) # 这行会引发 NameError: name 'my_set' is not defined ``` - `del my_set` 删除了整个集合 `my_set`，之后再访问 `my_set` 会引发 `NameError`。 通过这些简洁的解释和示例代码，希望你能更好地理解 `del` 的作用和用法。如果有更多问题或需要进一步的例子，请随时告诉我！ #### 上下文管理with 基本不用 `with` + **含义**：`with` 语句用于简化资源管理，确保在代码块执行完毕后正确地释放资源。最常见的用途是处理文件操作，但也可以用于其他需要上下文管理的场景。 + **作用**： - 自动管理资源的打开和关闭。 - 确保即使在发生异常的情况下也能正确释放资源。 - 提供更简洁和安全的代码编写方式。 示例代码 1. 处理文件 ```python # 使用 with 语句打开文件 with open("example.txt", "r") as file: content = file.read() print(content) # 文件在 with 语句块结束后自动关闭 ``` 2. 处理数据库连接 假设你使用的是一个支持上下文管理的数据库库（如 `sqlite3`）： ```python import sqlite3 # 使用 with 语句连接数据库 with sqlite3.connect("example.db") as conn: cursor = conn.cursor() cursor.execute("SELECT * FROM some_table") rows = cursor.fetchall() for row in rows: print(row) # 数据库连接在 with 语句块结束后自动关闭 ``` 3. 自定义上下文管理器 你可以通过实现 `__enter__` 和 `__exit__` 方法来自定义上下文管理器。 ```python class ManagedResource: def __enter__(self): print("资源被打开") return self def __exit__(self, exc_type, exc_value, traceback): print("资源被关闭") def do_something(self): print("执行某些操作") # 使用自定义的上下文管理器 with ManagedResource() as resource: resource.do_something() # 输出： # 资源被打开 # 执行某些操作 # 资源被关闭 ``` 解释 处理文件： ```python with open("example.txt", "r") as file: content = file.read() print(content) ``` `with open("example.txt", "r") as file:` 打开文件并将其赋值给变量 `file`。 在 `with` 语句块中，可以对文件进行读写操作。 当 `with` 语句块结束时，文件会自动关闭，无论是否发生异常。 处理数据库连接： ```python import sqlite3 with sqlite3.connect("example.db") as conn: cursor = conn.cursor() cursor.execute("SELECT * FROM some_table") rows = cursor.fetchall() for row in rows: print(row) ``` `with sqlite3.connect("example.db") as conn:` 连接数据库并将其赋值给变量 `conn`。 在 `with` 语句块中，可以执行数据库操作。 当 `with` 语句块结束时，数据库连接会自动关闭，无论是否发生异常。 自定义上下文管理器： ```python class ManagedResource: def __enter__(self): print("资源被打开") return self def __exit__(self, exc_type, exc_value, traceback): print("资源被关闭") def do_something(self): print("执行某些操作") with ManagedResource() as resource: resource.do_something() ``` `__enter__` 方法在进入 `with` 语句块时调用，返回一个对象（通常是 `self`）。 `__exit__` 方法在退出 `with` 语句块时调用，用于清理资源。 在 `with` 语句块中，可以调用 `do_something` 方法。 #### 异常处理 try except finally raise assert 基本不用 1. `try` + **含义**：用于捕获可能引发异常的代码块。 + **例子**： ```python try: result = 10 / 0 # 这里会引发一个除零错误 except ZeroDivisionError: print("不能除以零") ``` 2. `except` + **含义**：用于处理在 `try` 块中发生的特定类型的异常。 + **例子**： ```python try: result = 10 / 0 except ZeroDivisionError: print("不能除以零") # 输出：不能除以零 ``` 3. `finally` + **含义**：无论是否发生异常，`finally` 块中的代码都会执行。通常用于清理资源（如关闭文件）。 + **例子**： ```python try: file = open("example.txt", "r") content = file.read() except FileNotFoundError: print("文件未找到") else: print("未发生异常") # else在这里可以使用，未发生异常时运行。 finally: file.close() # 无论是否发生异常，文件都会被关闭 ``` 4. `raise` + **含义**：手动抛出一个指定的异常。 + **例子**： ```python def check_age(age): if age < 0: raise ValueError("年龄不能是负数") print(f"年龄是 {age}") try: check_age(-5) except ValueError as e: print(e) # 输出：年龄不能是负数 ``` 5. `assert` + **含义**：用于调试，确保某个条件为真。如果条件为假，则抛出 `AssertionError` 异常。 + **例子**： ```python def divide(a, b): assert b != 0, "除数不能为零" # 确保b不等于0。如等于0则抛出 AssertionError异常。 return a / b try: result = divide(10, 0) except AssertionError as e: print(e) # 输出：除数不能为零 ``` 总结 + `try`：捕获可能引发异常的代码块。 + `except`：处理特定类型的异常。 + `finally`：无论是否发生异常，都会执行的代码块。 + `raise`：手动抛出一个异常。 + `assert`：确保某个条件为真，否则抛出 `AssertionError`。 希望这些简洁的解释能帮助你理解这些关键字的作用和用法。如果有更多问题或需要进一步的例子，请随时告诉我！ ### 运算符 1. 算术运算符：用于执行基本的数学运算，如加法、减法、乘法、除法等。例如：+ - * / % ** // | 符号 | 描述 | 实例 | | --- | --- | --- | | + | 加 - 两个对象相加 | a + b 输出结果 30 | | - | 减 - 得到负数或是一个数减去另一个数 | a - b 输出结果 -10 | | * | 乘 - 两个数相乘或是返回一个被重复若干次的字符串 | a * b 输出结果 200 | | / | 除 - x除以y | b / a 输出结果 2 | | % | 取模 - 返回除法的余数 | b % a 输出结果 0 | | ** | 幂 - 返回x的y次幂 | a**b 为10的20次方， 输出结果 100000000000000000000 | | // | 取整除 - 返回商的整数部分（**向下取整**） | 9//2 输出结果 4 | 2. 比较运算符：用于比较两个值的大小或相等性。例如：==, !=, >, <, >=, <=。 3. **赋值运算符：用于将一个值赋给变量。例如：=, +=, -=, *=, /=, %=, **=, //=。 赋值运算：将给电脑保存的信息起一个名字（变量）。**格式： ****变量 = 数据 ** 比如：a = “多次使用的数据”。就是将数据为a，后面要使用数据，直接使用ａ代替。 起的名字（变量），格式要求：必须是汉字、大小写英文、数字和`_`的组合，且不能用数字开头。 给电脑保存的信息（数据），分类。分为数字（整数、小数）、字符、列表（元组、字典）。 ```python #　1.数字 var1 = 10　　#整数 var1 = 10.1 #小数 # 2.字符（字符串） # 字符串用引号括起来，单引号、双引号、三引号都可以。 s = "a1a2···an" #双引号 s = 'a1a"2"an' #可以单引号套双引号。这样文本内有引号也可以处理。 str = 'Hello World!' print str # 输出完整字符串 print str[0] # 输出字符串中的第一个字符 print str[2:5] # 输出字符串中第三个至第六个之间的字符串 print str[2:] # 输出从第三个字符开始的字符串 print str * 2 # 输出字符串两次 print str + "TEST" # 输出连接的字符串 # 3.列表 # 用[]括起来。内部元素用逗号隔开。 list = [ 'runoob', 786 , 2.23, 'john', 70.2 ] tinylist = [123, 'john'] print list # 输出完整列表 print list[0] # 输出列表的第一个元素 print list[1:3] # 输出第二个至第三个元素 print list[2:] # 输出从第三个开始至列表末尾的所有元素 print tinylist * 2 # 输出列表两次 print list + tinylist # 打印组合的列表 # 4.元组 # 用 () 标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。用于特定用途。 tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 ) tinytuple = (123, 'john') print tuple # 输出完整元组 print tuple[0] # 输出元组的第一个元素 print tuple[1:3] # 输出第二个至第四个（不包含）的元素 print tuple[2:] # 输出从第三个开始至列表末尾的所有元素 print tinytuple * 2 # 输出元组两次 print tuple + tinytuple # 打印组合的元组 # 5.字典 # 使用键-值（key-value）存储，具有极快的查找速度。 dict = {} #创建一个字典 dict['one'] = "This is one" # 添加一个键-值。 dict[2] = "This is two" # 添加第二个键-值。 tinydict = {'name': 'runoob','code':6734, 'dept': 'sales'} print dict['one'] # 输出键为'one' 的值 print dict[2] # 输出键为 2 的值 print tinydict # 输出完整的字典 print tinydict.keys() # 输出所有键 print tinydict.values() # 输出所有值 ``` 4. 位运算符：用于对整数在二进制层面进行操作。例如：&, |, ^, ~, <<, >>。 基本不用。 ### 内置函数 内置函数，用到的时候再学就可以。没有import就使用的函数就是内置函数。以下作为简单了解。 1. 数学运算函数：如abs(), divmod(), pow(), round(), min(), max(), sum(), range()等。 2. 类型转换函数：如int(), float(), str(), list(), tuple(), dict(), set(), bool()等。 3. 序列操作函数：如len(), sorted(), reversed(), enumerate(), zip(), map(), filter()等。 4. 数据结构相关函数：如list(), tuple(), dict(), set(), frozenset(), bytearray(), memoryview()等。 5. 文件操作函数：如open(), close(), read(), write(), seek(), tell(), flush()等。 6. 操作系统接口函数：如os.name, os.getcwd(), os.chdir(), os.listdir(), os.mkdir(), os.rmdir()等。 7. 时间与日期处理函数：如time.time(), time.sleep(), datetime.date.today(), datetime.datetime.now()等。 8. 其他内置函数：如input(), print(), eval(), exec(), compile(), globals(), locals()等。