Python速查表

---

---

这份Python速查表对学生和开发者快速学习Python编程很有帮助。

打印Hello World

打印“Hello, World!”是一个基本程序。要打印“Hello, World”，请使用print()函数。这是一个基本的Python程序：

print("Hello, World!")  # Output: Hello, World!

打印输出

**print()函数**也可以用来打印输出，即变量的值到屏幕上。

name = "Kelly Hu"
print("Hi my name is: ", name)

要打印多个变量，可以使用以下print()函数的级联形式：

name = "Kelly Hu"
age = 27
city = "Brentwood"
print("I am", name, ". I'm", age, "years old and lives in", city)

不换行打印

print()方法在打印结果后会插入一个换行符。要实现不换行打印，请在print()方法中使用end=' '参数作为最后一个参数。

print("Hello", end=" ")
print("World")

您可以为**end**参数指定任何值；新分配的值将在结果之后打印。

print("Hello", end="####")
print("World")

注释

Python提供了三种类型的注释：

• 单行注释
• 多行注释
• 文档字符串注释

1. 单行注释

单行注释后面跟着井号(#)。

# This is single-line comment

2. 多行注释

多行注释写在三个单引号(''' )之间。在'''和'''之间编写的任何内容都表示多行注释。

'''
name = "Kelly Hu"
age = 30
city = "Brentwood"
'''

print("Hello, World!")

变量

Python变量是在您为其赋值时创建的。Python中没有用于声明变量的关键字。

name = "Kelly Hu"
age = 27
print(name)
print(age)

指定变量的数据类型

可以使用类型转换（借助于str()、int()、float()等内置函数）来指定变量的数据类型。

a = str(123)
b = int(123)
c = float(123)
# Printing type
print(type(a))
print(type(b))
print(type(c))

打印变量/对象的类型

type()函数可用于打印变量或对象的数据类型（对象类型）。

name = "Kelly Hu"
print(name, "is the type of", type(name))

变量名

变量名（或标识符）必须以字母或下划线字符开头，并且仅允许字母数字字符和下划线作为变量名。

一些有效的变量名：**name**、**_name**、**my_name**、**name2**、**MY_NAME**

为变量赋值多个值

可以通过逗号分隔变量名和值来为变量赋值多个值。

name, age, city = "Kelly Hu", 27, "Brentwood"
print(name)
print(age)
print(city)

数据类型

以下是Python数据类型：

1. 文本类型：字符串 (str)

text = "Hello, World!"

2. 数值类型

int

num_int = 10

float

num_float = 10.5

complex

num_complex = 2 + 3j

3. 序列类型

list

my_list = [1, 2, 3]

tuple

my_tuple = (1, 2, 3)

range

my_range = range(1, 10)

4. 映射类型：字典 (dict)

my_dict = {"name": "Kelly Hu", "age": 27}

5. 集合类型

set

my_set = {1, 2, 3}

frozenset

my_frozenset = frozenset([1, 2, 3])

6. 布尔类型：bool

my_bool = True

7. 二进制类型

bytes

my_bytes = b"Hello"

bytearray

my_bytearray = bytearray(5)

memoryview

my_memoryview = memoryview(b"Hello")

8. None类型：NoneType

my_none = None

运算符

Python运算符用于对操作数执行各种运算，例如算术运算、逻辑运算等。

算术运算符

Python算术运算符包括+（加法）、-（减法）、*（乘法）、/（除法）、//（地板除）、%（取模）和**（指数） 。

赋值运算符

Python赋值运算符用于将值赋给变量，包括=、+=、-=、*=、/=、%=、**=、//=、&=、|=、^=、>>=和<<=。

比较运算符

Python比较运算符用于比较两个值，包括==（等于）、!=（不等于）、>（大于）、<（小于）、>=（大于等于）和<=（小于等于）。

逻辑运算符

Python逻辑运算符为**and**、**or**和**not**。

身份运算符

Python身份运算符为**is**和**is not**，用于检查两个变量是否引用内存中的同一个对象。

成员运算符

Python 成员运算符是 **in** 和 **not in**。这些运算符用于测试某个值是否在一个序列中。

位运算符

Python 位运算符对二进制值执行运算；这些运算符包括 AND (&)、OR (|)、NOT (~)、XOR (^)、左移 (<<) 和右移 (>>)。

用户输入

Python 允许你从用户那里获取不同类型的 输入。input() 函数用于从用户获取字符串类型的输入。你可以使用以下基本方法将输入转换为特定类型：

• int() − 将输入转换为整数。
• float() − 将输入转换为浮点数。
• bool() − 将输入转换为布尔值。

基本用户输入

name = input("Enter your name: ")
print("Hello", name)

整数输入

age = int(input("Enter your age: "))
print(f"You are {age} years old.")

浮点数输入

x = float(input("Enter any float value: "))
print(x)

处理无效输入

你可以使用 try 和 except 来处理无效输入。

try:
   x = int(input("Input an integer value: "))
   print(x)
except ValueError:
   print("Please enter a valid number.")

条件语句

Python 条件语句 使用 **if**、**elif** 和 **else** 关键字编写。

a = 10
b = 20
if a > b:
   print("a is greater than b")
elif b > a:
   print("b is greater than a")
else:
   print("a is greater than b")

循环

有两种类型的 Python 循环 − for 循环 和 while 循环。

for 循环

students = ["Kelly Hu", "Akanksha", "Peter"]
for s in students:
   print(s)

while 循环

i = 1
while i <= 10:
   print(i)
   i += 1

字符串

Python 字符串 是用单引号或双引号括起来的字符序列。

打印字符串

print("I'm Kelly Hu I live in Brentwood")
name, city = "Kelly Hu", "Brentwood"
# Printing string variables
print("I'm", name, "I live in", city)

引号嵌套

你可以使用 print() 函数打印引号作为字符串。

print("I'm Kelly Hu")
print("I am 'Kelly Hu'")
print("I am \"Kelly Hu\"")

多行字符串

Python 允许将多行字符串赋值给变量。只需使用三个单引号或双引号来表示多行字符串即可。

a = """I am Kelly Hu
I lives in Brentwood.
I am 27 years old"""

b = '''I am Kelly Hu
I lives in Brentwood.
I am 27 years old'''

print(a)
print(b)

字符串切片

字符串切片可以通过使用起始索引和结束索引来完成，这两个索引之间用冒号分隔，并用方括号括起来。

test = "Hello, World!"
print(test[2:5])
print(test[0:])
print(test[:13])
print(test[:5])

字符串连接

你可以使用加号 (+) 运算符连接两个或多个字符串。

name = "Kelly Hu"
city = "Brentwood"

person = name + " " + city
print(person)

字符串格式化

字符串格式化使用 Python f-string 完成。

name = "Kelly Hu"
age = 27
person = f"My name is {name}, I am {age} years old"
print(person)

字符串方法

以下是常用的 字符串方法：

转义字符

Python 转义字符 是转义符 (\) 和字符的组合，用于执行特定任务。以下是转义字符及其含义：

列表

Python 列表用于存储以逗号分隔的值。

创建列表

# Empty list
my_list = []
# List with elements
my_list = [1, 2, 3, 4, 5]

访问元素

可以使用索引和列表切片来访问列表的元素。

my_list = [1, 2, 3, 4, 5]
print(my_list[0])
print(my_list[2])
print(my_list[-1])
print(my_list[2:4])

追加和插入元素

可以使用 list.append() 和 list.insert() 方法分别追加和插入列表中的元素。

my_list = [1, 2, 3, 4, 5]
print(my_list)
my_list.append(6)
my_list.insert(0, 0)
print(my_list)

删除列表元素

remove() 方法用于删除列表中的元素。

my_list = [1, 2, 3, 4, 5]
print(my_list)
my_list.remove(3)
print(my_list)

复制列表

list.copy() 方法用于将一个列表复制到另一个列表。

my_list = [1, 2, 3, 4, 5]
new_list = my_list.copy()
print(my_list)
print(new_list)

清空列表

list.clear() 方法用于清空列表元素。

my_list.clear()

嵌套列表

Python 嵌套列表指的是列表中的列表。

nested_list = [[1, 2], [3, 4], [5, 6]]
print(nested_list)

元组

Python 元组 用于在一个变量中存储多个以逗号分隔的值。元组值放在圆括号内。

创建元组

my_tuple = (1, 2, 3)
print(my_tuple)

创建空元组

my_tuple = ()
print(my_tuple)

无括号的元组（隐式元组）

my_tuple = 1, 2, 3
print(my_tuple)

单元素元组

my_tuple = (1,)
print(my_tuple)

访问元组元素

可以使用索引和元组切片来访问元组的元素。

my_tuple = (10, 20, 30)
print(my_tuple[0])
print(my_tuple[1])
print(my_tuple[0:])
print(my_tuple[-1])
print(my_tuple[0:2])

元组连接

要连接元组，请使用加号 (+) 运算符。

tuple1 = (10, 20, 30)
tuple2 = (40, 50)
print(tuple1 + tuple2)

元组解包

tuple1 = (10, 20, 30)
a, b, c = tuple1
print(a)
print(b)
print(c)

嵌套元组

nested_tuple = ((10, 20), (30, 40), (50, 60))
print(nested_tuple)

集合

Python 集合 是多个项目的集合，这些项目是无序的、不可更改*的和无索引的。集合值以逗号分隔，并用花括号括起来。

创建集合

set1 = {10, 20, 30, 40, 50}
# Set from a list
set2 = set([10, 20, 30, 40, 50])
print(set1)
print(set2)

添加和删除元素

以下函数用于向集合中添加和删除元素：

• add() − 添加单个元素。
• update() − 添加多个元素。
• remove() − 删除元素。
• discard() − 安全地删除元素。
• pop() − 删除并返回任意元素。
• set.clear() − 清空集合。

集合运算示例

set1 = {10, 20, 30, 40, 50}
set1.add(60)
print(set1)
set1.update([70, 80])
print(set1)
set1.remove(30)
print(set1)
set1.discard(10)
print(set1)
print(set1.pop(),"is removed!")
set1.clear()
print(set1)

字典

Python 字典 是键值对的集合，并用花括号编写。

创建字典

my_dict = {'name': 'Kelly Hu', 'age': 27}
print(my_dict)

创建空字典

my_dict = {}
print(my_dict)

创建具有混合键的字典

my_dict = {1: 'Kelly', 'hair_color': 'Brown', (36, 24): 'lucky_numbers'}
print(my_dict)

访问值

你可以通过在方括号内提供用引号括起来的键名来直接访问指定键的值，还可以使用 dict.get() 方法 获取指定键的值。

person = {'name': 'Kelly', 'age': 27, 'city': 'Brentwood'}
# Direct access
print(person['name'])
print(person['age'])
print(person['city'])
# Using method
print(person.get('name'))
print(person.get('age'))
print(person.get('city'))

修改字典

你可以直接更新现有键的值，也可以使用 dict.update() 方法 更新多个值。

person = {'name': 'Kelly', 'age': 27, 'city': 'Brentwood'}
print(person)
# Updating single value
person['age'] = 18
print(person)
# Updating multiple values
person.update({'age': 21, 'city': 'New York'})
print(person)

删除元素

以下方法可用于从字典中删除元素：

• pop() − 删除键值对并返回值。removed_value = person.pop('age')
• popitem(): 删除最后添加的项并返回键值对。
  removed_value = person.popitem()
• dict.clear(): 删除所有项并清空字典。person.clear()

遍历字典

person = {'name': 'Kelly', 'age': 27, 'city': 'Brentwood'}
# Iterate through keys
for key in person:
   print(key)

# Iterate through values
for value in person.values():
   print(value)

# Iterate through key-value pairs
for key, value in person.items():
   print(f"{key}: {value}")

字典推导式

dict1 = {x: x**2 for x in range(5)}
print(dict1)

Lambda 函数

**Python lambda 函数** 只能有一个表达式。它们是小的匿名函数，可以接受任意数量的参数。

value = lambda x : x * 3
print(value(5))

类和对象

Python 是一种面向对象的编程语言，允许创建类和对象。你可以使用“class”关键字在 Python 中创建类。

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

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

# Create objects
per1 = Person("Kelly Hu", 27)
per2 = Person("Adele", 25)

# Access object attributes
print(per1.name)
print(per1.age)

# Printing using method
per2.display_info()

继承

Python 继承 允许你将父类的属性继承给子类。

基本继承示例

# Base class
class Student:
   def __init__(self, name, grade):
      self.name = name
      self.grade = grade

   def get_details(self):
      return f"Student: {self.name}, Grade: {self.grade}"

# Derived class
class Graduate(Student):
   def get_details(self):
      return f"Graduate: {self.name}, Grade: {self.grade}, Status: Graduated"

# Create an instance of the child class
grad = Graduate("Kelly Hu", "B+")

# Access inherited and overridden methods
print(grad.get_details())

使用 super() 方法覆盖方法

super() 方法 用于调用父类（或基类）中的方法。

# Base class
class Student:
   def __init__(self, name, grade):
      self.name = name
      self.grade = grade

   def get_details(self):
      return f"Student: {self.name}, Grade: {self.grade}"

# Derived class
class Graduate(Student):
   def __init__(self, name, grade, graduation_year):
      # Call the parent class's constructor using super()
      super().__init__(name, grade)
      self.graduation_year = graduation_year

   def get_details(self):
      # Call the parent class's get_details() method using super()
      student_details = super().get_details()
      return f"{student_details}, Graduation Year: {self.graduation_year}"

# Create an instance of the child class (Graduate)
grad = Graduate("Kelly Hu", "B+", 2011)

# Access inherited and overridden methods
print(grad.get_details())

异常处理

Python 异常处理允许在程序执行期间处理异常。以下关键字（块）用于异常处理：

• **try** − 在要测试异常的主代码中编写。
• **except** − 编写处理异常的代码。
• **else** − 当没有错误时编写要执行的代码。
• **finally** − 无论是否有错误，都要编写最终执行的代码。

# Create function to divide two numbers
def divide_numbers(a, b):
   try:
      result = a / b
   except ZeroDivisionError:
      print("Error: Cannot divide by zero!")
   else:
      print(f"The divide result is : {result}")
   finally:
      print("Execution complete.")

# Calling function
print("Test Case 1:")
divide_numbers(10, 2)

print("\nTest Case 2:")
divide_numbers(10, 0)