1，python是一种解释型语言，在开发过程中没有编译的环节。
使用pycharm开发环境编辑器进行python开发，新建一个工程pyPro，之后再新建一个main.py文件，在代码编辑页面输入如下代码：
# print hello world
"""
hellow
world
"""
# 在 Python 里，使用 # 表示单行注释，使用6个双引号将内容包裹起来就形成多行注释。
# 在 Python 里，Python 的变量名支持字母、下划线、数字。但不能在变量名里加入空格，不能以数字开头。
# 创建一个变量的语法是：变量名 = 值
hello = "hello world"
print(hello)
# 在Python中，id函数用于获取一个对象的标识符，它是一个唯一的整数，用于标识对象在内存中的位置。
# id函数可以用来比较两个对象是否为同一个对象。如果两个对象的id值相同，那么它们一定是同一个对象。
print(id(hello))
hello = "hello"
world = "world"
# print输出后默认换行，可以通过设置end="\t"来避免换行。
print(hello, end="\t")
print(world, end="\n")
2，python中的数据类型
主要类型包括：int, bool, float,complex(由实数部分和虚数部分构成，虚数部分必须有后缀j或J), string(是不可变类型，在引号包括单引号或双引号内包含字符即可)，None类型等。
对于复数，示例如下：
z1 = complex(1, 2)
print(z1)
z2 = complex(2.5, -1.5)
print(z2)
# 只提供实部，虚部默认为0
z3 = complex(7)
print(z3)
# 使用字符串表示复数（注意格式，加号或减号两边不能有空格）
z4 = complex('1+2j')
print(z4)
获取复数的实部与虚部
# 获取复数的实部
real_part_z1 = z1.real
print(real_part_z1)
# 获取复数的虚部
imag_part_z1 = z1.imag
print(imag_part_z1)
对于上面代码的输出如下：
(1+2j)
(2.5-1.5j)
(7+0j)
(1+2j)
1.0
2.0
另外，在Python中，None 是一个特殊的值，用来表示空值或“无值”。它的类型是 NoneType，这是 None 的唯一实例。None 常用于初始化变量、表示函数没有返回值或作为函数的默认返回值。示例代码如下：
# 初始化一个变量为 None
my_variable = None
print(my_variable) # 输出: None
print(type(my_variable)) # 输出: <class 'NoneType'>
# 函数没有返回值
def my_function():
# 这个函数没有返回值，因此隐式返回 None
print("Hello, World!")
print(my_function()) # 输出: None
# 作为函数的默认返回值
def find_item_in_list(item_list, target):
for item in item_list:
if item == target:
return item
return None
my_list = [1, 2, 3, 4, 5]
result = find_item_in_list(my_list, 10)
print(result) # 输出: None，因为10不在列表中
# 检查变量是否为 None
def process_value(value):
if value is None:
print("The value is None.")
else:
print(f"The value is {value}.")
process_value(None) # 输出: The value is None.
process_value(42) # 输出: The value is 42.
3, python中的数学运算
基础算术运算
加法：使用加号（+）进行，例如：a + b。
减法：使用减号（-）进行，例如：a - b。
乘法：使用乘号（*）进行，例如：a * b。
除法：使用除号（/）进行，返回浮点数结果，例如：a / b。
整除：使用双斜杠（//）进行，返回商的整数部分，忽略小数部分，例如：a // b。
取余：使用百分号（%）进行，返回除法运算的余数，例如：a % b。
幂运算：使用双星号（**）进行，例如：a ** b表示a的b次方。
高级数学运算
三角函数：通过math库提供，包括sin、cos、tan等。
对数函数：通过math库提供，包括log（自然对数）、log10（以10为底的对数）等。
开方函数：通过math库的sqrt函数提供，用于计算一个数的平方根。
微积分运算：通过SymPy库进行符号计算，包括求导（diff函数）和积分（integrate函数）等。
对于微积分，示例如下：
# 使用as关键字为模块或属性指定别名
import sympy as sp
# 定义符号变量
x = sp.symbols('x')
# 定义多项式函数
function = x ** 3 + 2 * x ** 2 + 2 * x + 1
# 求导
fun_prime = sp.diff(function, x)
print(f"f'(x) = {fun_prime}") # 输出f'(x) = 3*x**2 + 4*x + 2
# 求二阶导
fun_prime2 = sp.diff(function, x, 2)
print(f"f''(x)= {fun_prime2}") # 输出f''(x)= 2*(3*x + 2)
# 在特定点求导数值
x_value = 2
fun_prime_value = fun_prime.subs(x, x_value)
print(f"f'({x_value}) = {fun_prime_value}") # 输出f'(2) = 22
# 不定积分
indefinite_integral = sp.integrate(function, x)
print(f"∫f(x)dx = {indefinite_integral}") # 输出∫f(x)dx = x**4/4 + 2*x**3/3 + x**2 + x
# 定积分
a, b = 0, 1
definite_integral = sp.integrate(function, (x, a, b))
print(f"∫_{a}^{b} f(x)dx = {definite_integral}") # 输出∫_0^1 f(x)dx = 35/12
对于上面的代码，首先导入了SymPy库并将其重命名为 sp 以便在代码中更方便地引用，并定义了符号变量x，之后定义了一个多项式函数f(x)。
使用sp.diff函数计算了该函数的一阶导数和二阶导数。
使用sp.integrate函数计算该函数的不定积分和定积分。
对于代码print(f"f'(x) = {f_prime}")分析如下：
f"f'(x) = {f_prime}" 是一个f-string，它是Python 3.6及以上版本引入的一种字符串格式化方法。
在f-string中，大括号 {} 内的表达式会被求值，并将其结果转换为字符串，然后插入到f-string中。
与f-string相关的函数print()输出格式化有如下用法：
hello = "hello world"
print("first code:%s" % hello)
hello = "hello"
world = "world"
print("first code:%s %s" % (hello, world))
money = 9999
money1 = 999999
print("the money is:%6d" % money)
print("the money is:%6d" % money1)
# 上面的代码将对齐输出：
the money is: 9999
the money is:999999
num = 12.345
print("num is %.2f" % num)
num1 = Decimal(num)
print("num is %.2f" % Decimal(str(num1)).quantize(Decimal('0.00'), 'ROUND_HALF_UP'))
# 上面的代码将输出：
num is 12.35
num is 12.35
对于幂运算有如下示例：
# 使用pow对数据求立方根
print(pow(27, 1/3))
# 使用幂运算对数据求立方根
print(27**(1/3))
# 以上输出结果均为3.0
4，条件判断
在 Python 里，用 if...else... 表示这个句式，按照缩进来划分代码块。
# 获取用户输入的年龄
# input 是Python的内置函数，用于从用户那里获取输入。输入完成后，用户按下回车键，此时 input 函数会捕获输入的文本。
# int 也是Python的内置函数，用于将一个数或合法的字符串转换成整数。如果字符串不能转换为整数（例如，包含非数字字符或为空），int 函数将抛出一个 ValueError 异常。
age = int(input("please input age: "))
# 使用if-else语句判断年龄
if age < 18:
print("Young")
else:
print("Adult")
# 上面的代码在输入15后输出如下内容：
please input age: 15
Young
对于多重条件判断使用elif，示例如下：
grade = 99
if grade >= 90:
print("优")
elif 80 <= grade < 90:
print("良")
elif 60 <= grade < 80:
print("中")
else:
print("差")
# 输出：优
5，逻辑运算
and、or 和 not 是Python中的逻辑运算符，用于构建逻辑表达式。
# and 运算符用于当两个表达式都为真时返回真，否则返回假。
# 示例 1: 两个表达式都为真
a = True
b = True
result = a and b
print(result) # 输出: True
# 示例 2: 一个表达式为假
a = True
b = False
result = a and b
print(result) # 输出: False
# or 运算符用于当至少一个表达式为真时返回真，否则返回假。
# 示例 1: 至少一个表达式为真
a = True
b = False
result = a or b
print(result) # 输出: True
# 示例 2: 两个表达式都为假
a = False
b = False
result = a or b
print(result) # 输出: False
# not 运算符用于反转表达式的布尔值。如果表达式为真，则返回假；如果表达式为假，则返回真。
# 示例 1: 反转真值
a = True
result = not a
print(result) # 输出: False
# 示例 2: 反转假值
a = False
result = not a
print(result) # 输出: True
# 综合示例
# 定义变量
age = 20
has_ticket = True
is_rainy = False
# 使用逻辑运算符构建表达式
can_go_out = (age >= 18 and has_ticket) or (is_rainy and age < 18 and not has_ticket)
print(can_go_out) # 输出: True
6，循环函数
Python提供了多种循环结构，包括for循环和while循环。
for循环通常用于遍历可迭代对象（如列表、元组、字符串、字典、集合或范围）。
msg = "Hello"
for txt in msg:
print(txt)
# 输出是
# h
# e
# l
# l
# o
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
print(fruit)
for i in range(5): # 相当于从0到4
print(i)
# python根据缩进划分代码块，所以上面的代码和下面的代码输出是不同的。
for fruit in fruits:
print(fruit)
for i in range(5): # 相当于从0到4
print(i)
while循环在给定条件为真时重复执行代码块。
count = 0
while count < 5:
print(count)
count += 1
使用break语句提前退出循环
while True:
user_input = input("Enter 'exit' to quit: ")
if user_input == "exit":
break
print(f"You entered: {user_input}")
使用continue语句跳过当前迭代
for i in range(1, 6):
if i % 2 == 0: # 如果i是偶数
continue # 跳过当前迭代，continue语句导致偶数被跳过，只有奇数被打印出来。
print(i) # 输出 1 3 5
7，列表
Python中的列表（list）是一种非常灵活且强大的数据结构，能够存储一系列有序的项目。
列表的创建与基本操作示例：
# 创建一个包含几个水果名称的列表
fruits = ["apple", "banana", "cherry"]
# 访问列表中的元素（索引从0开始）
print(fruits[0]) # 输出: apple
print(fruits[1]) # 输出: banana
# 修改列表中的元素
fruits[2] = "cranberry"
print(fruits) # 输出: ['apple', 'banana', 'cranberry']
# 添加新元素到列表末尾
fruits.append("date")
print(fruits) # 输出: ['apple', 'banana', 'cranberry', 'date']
# 删除列表中的元素（通过值删除，首次出现的元素）
fruits.remove("banana")
print(fruits) # 输出: ['apple', 'cranberry', 'date']
# 删除列表中的元素（通过索引删除）
del fruits[1]
print(fruits) # 输出: ['apple', 'date']
# 使用for循环遍历列表
for fruit in fruits:
print(fruit)
# 输出:
# apple
# date
# 列表切片（获取列表的一部分）
fruits_slice = fruits[0:1] # 获取第一个元素（切片是左闭右开的）
print(f"fruits_slice:{fruits_slice}") # 输出: ['apple']
# 合并列表
fruits_extended = fruits + ["elderberry", "fig"]
print(fruits_extended) # 输出: ['apple', 'date', 'elderberry', 'fig']
# 使用列表推导式创建一个包含1到10的平方的列表
squares = [x**2 for x in range(1, 11)]
print(squares) # 输出: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
# 创建一个嵌套列表（二维列表）
matrix = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]
# 访问嵌套列表中的元素
print(matrix[1][2]) # 输出: 6
# insert: 在列表指定位置插入元素
fruits.insert(len(fruits), "hello")
print(fruits) # 输出：['apple', 'date', 'hello']
# pop: 删除指定索引的元素
fruits.pop(1)
print(fruits) # 输出：['apple', 'hello']
8，字典
Python中的字典（dictionary）是一种内置的数据结构，它存储的是键值对（key-value pairs）的集合。字典中的每个元素都是一个键值对，其中键（key）是唯一的，而值（value）则可以是任意数据类型。字典使用花括号 {} 来表示，并且键和值之间使用冒号 : 分隔。键必须是不可变的类型，比如字符串、数字或元组，而值则可以是任意类型。字典是Python中非常强大且灵活的数据结构，适用于需要快速查找、插入和删除操作的场景。
# 创建一个空字典
my_dict = {}
# 创建一个包含一些键值对的字典
person = {
"name": "Alice",
"age": 30,
"city": "New York"
}
# 访问字典中的值
print(person["name"]) # 输出: Alice
# 修改字典中的值
person["age"] = 31
print(person["age"]) # 输出: 31
# 添加新的键值对
person["email"] = "alice@example.com"
print(person) # 输出: {'name': 'Alice', 'age': 31, 'city': 'New York', 'email': 'alice@example.com'}
# 删除字典中的键值对（通过键删除）
del person["city"]
print(person) # 输出: {'name': 'Alice', 'age': 31, 'email': 'alice@example.com'}
# 检查键是否在字典中
if "name" in person:
print("Name is in the dictionary.")
# 获取字典的键和值
keys = person.keys()
values = person.values()
items = person.items()
print(keys) # 输出: dict_keys(['name', 'age', 'email'])
print(values) # 输出: dict_values(['Alice', 31, 'alice@example.com'])
print(items) # 输出: dict_items([('name', 'Alice'), ('age', 31), ('email', 'alice@example.com')])
# 将字典转换为其他数据结构
person_list = list(person.items())
print(person_list) # 输出: [('name', 'Alice'), ('age', 31), ('email', 'alice@example.com')]
# 与列表推导式类似，Python也支持字典推导式，用于从一个可迭代对象创建字典。
# 使用字典推导式创建一部字典，其中键是0到4的数字，值是这些数字的平方
squares_dict = {x: x ** 2 for x in range(5)}
print(squares_dict) # 输出: {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
# 在Python 3.9及更高版本中，你可以使用 | 运算符来合并字典。
dict1 = {"a": 1, "b": 2}
dict2 = {"b": 3, "c": 4}
merged_dict = dict1 | dict2 # 注意：如果有重复的键，后面的字典的值会覆盖前面的
print(merged_dict) # 输出: {'a': 1, 'b': 3, 'c': 4}
# 在Python 3.5及以上版本中，你还可以使用 ** 运算符来解包字典，并在创建新字典时合并它们。
merged_dict = {**dict1, **dict2} # 注意：同样地，如果有重复的键，后面的字典的值会覆盖前面的
print(merged_dict) # 输出: {'a': 1, 'b': 3, 'c': 4}
9，函数
Python中的函数是通过def关键字来定义的。函数允许你将代码封装成可重用的块，通过传递参数，函数可以接受输入，并通过return语句返回输出。
# 定义一个简单的函数，打印一条消息
def greet():
print("Hello, world!")
# 调用函数
greet() # 输出: Hello, world!
# 定义一个带参数的函数，用于计算两个数的和
def add(a, b):
return a + b
# 调用函数并传递参数
result = add(3, 5)
print(result) # 输出: 8
# 定义一个带默认参数的函数，用于打印问候语
def greet_with_name(name="Guest"):
print(f"Hello, {name}!")
# 调用函数，使用默认参数
greet_with_name() # 输出: Hello, Guest!
# 调用函数，传递自定义参数
greet_with_name("Alice") # 输出: Hello, Alice!
# 可变参数（*args 和 **kwargs）
# 定义一个接受可变数量位置参数的函数
def sum_all(*args):
return sum(args)
# 调用函数，传递任意数量的位置参数
print(sum_all(1, 2, 3, 4)) # 输出: 10
# 定义一个接受可变数量关键字参数的函数
def print_info(**kwargs):
for key, value in kwargs.items():
print(f"{key}: {value}")
# 调用函数，传递任意数量的关键字参数
print_info(name="Alice", age=30, city="New York")
# 输出:
# name: Alice
# age: 30
# city: New York
# 定义一个返回多个值的函数
def get_person_info():
name1 = "Alice"
age1 = 30
return name1, age1
# 调用函数并接收返回值
name, age = get_person_info()
print(name) # 输出: Alice
print(age) # 输出: 30
# 定义一个lambda函数，用于计算两个数的和
add1 = lambda x, y: x + y
# 调用lambda函数
print(add1(5, 3)) # 输出: 8
# 定义一个递归函数，用于计算阶乘
def factorial(n):
if n == 0:
return 1
else:
return n * factorial(n - 1)
# 调用递归函数
print(factorial(5)) # 输出: 120
