Python基础
#Python 2024-10-14

本文档主要涉及使用Python编写函数时，经常使用的语法，并不是系统性地介绍Python。

数据类型

注意Python在声明变量时并不需要指定数据类型

简单类型

  • 整数(int)
  • 浮点数(float) 【注意Python没有Double类型】
  • 复数(complex)
  • 字符串(str)
  • 布尔值(bool)
  • 空值(None)

容器类型

  • 列表list
  • 元组tuple
  • 字典dict
  • 集合set
1
2
3
4
ls = ['hello!', '333']
tp = ('hello!', '333') 
dc = {'hello!': '333'}
st = {'hello!', '333'}

性质

数据结构 定义符号 元素是否可变 元素是否可重复 元素是否有序
列表（list） [] 可变 可重复 有序
元组（tuple） () 不可变 可重复 有序
字典（dict） {key: value} 可变 key不可重复 value可重复 无序
集合（set） {} 可变 不可重复 无序

输入

单个输入

1
user_input = input("请输入内容: ")

单个数字输入

默认情况下，input() 函数返回的内容是字符串。如果你需要将输入转换为其他数据类型（如整数或浮点数），可以使用类型转换函数。

1
2
age = int(input("请输入你的年龄: "))
# 这里将用户输入的年龄从字符串转换为整数，以便进行数学运算。

多个数字输入

1
a,b,c = list(map(int, input().split))

解释：

input():函数用于获取用户的输入。默认情况下，它返回一个字符串。

input().split():方法用于将输入的字符串分割成多个部分，默认是按空格进行分割。它返回一个字符串列表。例如，如果用户输入 1 2 3，则 input().split() 会返回 ['1', '2', '3']。

map(int, input().split()):

  • map() 函数接受两个参数：一个函数（这里是 int）和一个可迭代对象（这里是 input().split() 的返回值）。它将 int 函数应用于列表中的每个元素，将字符串转换为整数。因此，map(int, input().split()) 将返回一个可迭代对象，其中包含整数。

list(map(...)): 函数用于将 map 对象转换为列表。最终结果是一个包含输入整数的列表。

x a, b, c = list(...):

  • 这个部分是一个解包赋值。它将列表中的值依次赋给变量 x、a、b 和 c。需要注意的是，如果 list(map(...)) 返回的列表中元素的数量与变量的数量不匹配，将会抛出 ValueError。

多个输入

你可以使用 split() 方法来接受多个输入并将其分隔成列表。

1
2
3
fruits = input("请输入你喜欢的水果，用空格分隔: ")
fruit_list = fruits.split()  # 根据空格将输入分隔成列表
print("你喜欢的水果有:", fruit_list)

打印

标准格式：

1
print(objects, sep=' ', end='\n', file=sys.stdout, flush=False)
  • 默认打印完成自动换行 end=’\n’，相当于Java里的System.out.println()。
  • 默认打印对象之间使用一个空格连接sep=’ ‘。
  • 默认在控制台打印file=sys.stdout，亦可写入指定文件。
  • 默认情况下，print() 函数会在遇到换行符时自动刷新输出。如果想要立即刷新输出，可以将 flush 参数设置为 True。

格式化数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 原始数字
number = 1480356.759

# 1. 保留2位小数（直接截断）
truncated = "{:.2f}".format(number)  # 截断后保留两位小数

# 2. 四舍五入保留2位小数
rounded = round(number, 2)  # 四舍五入保留两位小数

# 3. 每三位加上一个逗号
with_commas = "{:,}".format(number)  # 添加千位分隔符

# 4. 百分比形式
percentage = "{:.2%}".format(number)  # 将数字转换为百分比形式

循环控制

在 Python 中，可以使用 for ... in ... 遍历任何可迭代对象（iterable）。可迭代对象是指实现了 __iter__() 或 __getitem__() 方法的对象。以下是常见的一些可以使用 for ... in ... 遍历的类型：

字符串

1
2
for i in 'apple':
    print(i)
  • i依次表示字符串变量中的每一个字符

数组

1
2
3
verb = ["af","hh","afret","eryj"]
for i in verb:
    print(i)

range 对象

1
2
for i in range(5):
    print(i)

字典

1
2
for key, value in d.items():
    print(key, value)

注意，当我们不需要使用遍历对象里的实际值的时候，可用_代替

1
2
for _ in range(5):
    print("ok")

栈

使用列表模拟

1
2
3
4
5
stack = []
# 入栈
stack.append(1)
# 出栈
top_element = stack.pop()

队列

使用列表模拟

1
2
3
4
5
queue = []
# 入队
queue.append(1)
# 出队
front_element = queue.pop(0)
  • 使用 pop(0)的时间复杂度是O(n)，对于大型数据量不适合使用
  • pop() 函数默认参数是-1

字典

创建

1
2
3
4
# 空字典
my_dict = {}
# 带有初始值的字典
my_dict = {"name": "Alice", "age": 25, "city": "Beijing"}

访问字典元素

可以通过键来访问字典中的值：

1
2
name = my_dict["name"]
print(name)  # 输出: Alice

添加或更新元素

可以通过赋值的方式添加或更新键值对：

1
2
3
my_dict["age"] = 26  # 更新age键的值
my_dict["country"] = "China"  # 添加新的键值对
print(my_dict)  # 输出: {'name': 'Alice', 'age': 26, 'city': 'Beijing', 'country': 'China'}

删除元素

使用 pop() 方法删除指定键，并返回该键对应的值：

1
2
3
age = my_dict.pop("age")
print(age)  # 输出: 26
print(my_dict)  # 输出: {'name': 'Alice', 'city': 'Beijing', 'country': 'China'}

使用 del 关键字删除键值对：

1
2
del my_dict["city"]
print(my_dict)  # 输出: {'name': 'Alice', 'country': 'China'}

遍历

可以使用 items() 方法遍历键值对：

1
2
for key, value in my_dict.items():
    print(key, value)

使用 keys() 和 values() 方法遍历键或值：

1
2
3
4
5
6
# 遍历键
for key in my_dict.keys():
    print(key)
# 遍历值
for value in my_dict.values():
    print(value)

检查键是否存在

使用 in 关键字检查字典中是否包含某个键：

1
2
if "name" in my_dict:
    print("Name exists")

列表

创建/初始化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
lst = []
# 或者
lst = list()

# 创建一个包含5个元素的列表，每个元素为0
lst = [0] * 5  # [0, 0, 0, 0, 0]

# 创建包含偶数的列表
lst_even = [x for x in range(10) if x % 2 == 0]

#使用 list() 函数将其他可迭代对象转换为列表
lst = list("hello")  # ['h', 'e', 'l', 'l', 'o']
lst = list((1, 2, 3))  # [1, 2, 3]
lst = list({1, 2, 3})  # [1, 2, 3]，顺序可能不同

# 创建包含0到9的列表
lst = list(range(10))  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# m*n二维列表并初始化为1
matrix = [[1 for _ in range(n)] for _ in range(m)]

添加元素

append(x)：在列表末尾添加一个元素 x。

1
2
lst = [1, 2, 3]
lst.append(4)  # [1, 2, 3, 4]

删除元素

pop([i])：删除并返回指定索引 i 处的元素。不指定索引时，默认删除并返回最后一个元素。

1
2
lst.pop()     # [1, 2, 3, 4, 6]
lst.pop(1)    # [1, 3, 4, 6]

排序

sort(key=None, reverse=False)：对列表进行原地排序。key 是一个函数，用来指定排序规则；reverse=True 表示降序排序。

1
2
3
lst = [3, 1, 4, 2]
lst.sort()          # [1, 2, 3, 4]
lst.sort(reverse=True)  # [4, 3, 2, 1]

sorted(list, key=None, reverse=False)：返回一个排序后的新列表，不改变原列表。

1
sorted_lst = sorted(lst)  # 原列表 lst 保持不变

长度

len(list)：返回列表中元素的数量。

1
length = len(lst)  # 4

切片

Python 的列表切片（slicing）是一种从列表中提取子列表的简便方法，语法如下：

1
list[start:stop:step]

其中：

  • start：切片开始的索引位置，包含该位置（默认是 0）。
  • stop：切片结束的索引位置，不包含该位置（默认是列表长度）。
  • step：步长，表示每隔几个元素取一个（默认是 1）。

示例

假设我们有一个列表：

1
numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

  1. 基本切片：

    1
    numbers[2:5]  # [2, 3, 4]

  2. **省略 start 和 stop**：

    1
    2
    numbers[:5]    # [0, 1, 2, 3, 4]
    numbers[5:]    # [5, 6, 7, 8, 9]

  3. 使用负索引：

    1
    numbers[-3:]   # [7, 8, 9]

  4. **步长 step**：

    1
    2
    numbers[::2]   # [0, 2, 4, 6, 8]
    numbers[1::2]  # [1, 3, 5, 7, 9]

  5. 反向切片：

    1
    numbers[::-1]  # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

切片可以用于生成列表的子列表，非常灵活。

切片操作：可以通过切片获取列表的子列表，支持步长。

1
2
sub_lst = lst[1:3]       # [4, 2]
sub_lst_with_step = lst[::2]  # [1, 2]

注意

在 Python 列表切片中，如果省略了 start 或 stop，即使给定的 start 或 stop 超出了列表的合法索引范围，Python 也不会报错，而是自动将其调整到列表的有效范围内。

假设一个列表：

1
numbers = [0, 1, 2, 3, 4, 5]

  1. start 超过最大索引：

    1
    numbers[10:]  # 返回空列表 []

    尝试从索引 10 开始切片，但由于超出范围，返回空列表。

  2. stop 超过最大索引：

    1
    numbers[:10]  # 返回整个列表 [0, 1, 2, 3, 4, 5]

    stop 超出范围，Python 自动调整为列表末尾。

  3. 负索引超出范围：

    1
    numbers[-10:]  # 返回整个列表 [0, 1, 2, 3, 4, 5]

    如果负索引超出范围，Python 会自动调整为 0，即从列表开始位置切片。

当 start 或 stop 超出范围时，Python 切片操作会自动调整到有效范围，而不会报错。

是否存在

in 和 not in：检查元素是否在列表中。

1
2
exists = 3 in lst        # True
not_exists = 5 not in lst  # True

逆置

1
2
3
4
5
6
# 原地反转
my_list = [1, 2, 3, 4, 5]
my_list.reverse()

# 不修改原列表
new_list = my_list[::-1]

去重

1
a = list(set(a))

字符串函数

在 Python 中，字符串是一个重要的数据类型，提供了多种内置方法来处理和操作字符串。以下是一些常用的字符串方法及其功能：

大小写

str.lower(): 将字符串中的所有字符转换为小写。

1
2
s = "Hello World"
print(s.lower())  # 输出: hello world

str.upper(): 将字符串中的所有字符转换为大写。

1
2
s = "Hello World"
print(s.upper())  # 输出: HELLO WORLD

查找和替换

str.find(sub): 查找子字符串 sub 在字符串中的第一个位置，如果未找到则返回 -1。

1
2
s = "Hello World"
print(s.find("World"))  # 输出: 6

str.replace(old, new): 将字符串中的 old 子串替换为 new 子串。

1
2
s = "Hello World"
print(s.replace("World", "Python"))  # 输出: Hello Python

切割和连接

str.split(sep): 根据指定的分隔符 sep 将字符串切割为列表。

1
2
s = "Hello World"
print(s.split())  # 输出: ['Hello', 'World']

str.join(iterable): 将可迭代对象中的字符串连接成一个新的字符串。

1
2
words = ["Hello", "World"]
print(" ".join(words))  # 输出: Hello World

去除空白

str.strip(): 去除字符串开头和结尾的空白字符。

1
2
3
4
5
6
7
8
9
10
s = "   Hello World   "
print(s.strip())  # 输出: Hello World

# str.lstrip(): 去除字符串开头的空白字符。
s = "   Hello World   "
print(s.lstrip())  # 输出: Hello World   

#str.rstrip(): 去除字符串结尾的空白字符。
s = "   Hello World   "
print(s.rstrip())  # 输出:    Hello World

格式化字符串

str.format(): 用于格式化字符串，插入变量值。

1
2
3
4
name = "Alice"
age = 30
s = "My name is {} and I am {} years old.".format(name, age)
print(s)  # 输出: My name is Alice and I am 30 years old.

检查字符串

str.startswith(prefix): 检查字符串是否以指定的前缀开头。

1
2
s = "Hello World"
print(s.startswith("Hello"))  # 输出: True

str.endswith(suffix): 检查字符串是否以指定的后缀结尾。

1
2
s = "Hello World"
print(s.endswith("World"))  # 输出: True

其他

str.count(sub): 计算子字符串在字符串中出现的次数。

1
2
s = "Hello World"
print(s.count("o"))  # 输出: 2

str.isdigit(): 检查字符串是否只包含数字。

1
2
s = "12345"
print(s.isdigit())  # 输出: True

str.isalpha(): 检查字符串是否只包含字母。

1
2
s = "Hello"
print(s.isalpha())  # 输出: True

数学函数

1
2
3
4
5
# 四舍五入（format格式化输出亦可） 第二个参数是精度
rounded_number = round(number, 1)
# 假设 a>b
a = max(a,b)
b = min(a,b)

注意：对于max,min函数

如果只有一个参数，必须是一个可迭代对象（例如列表、元组、字符串等）也即实现了 __iter__()__方法的类的实例

查看数据类型

1
print(type("6"))

范围函数range

1
2
3
range(a,b)

# 常用于if条件判断和for循环中
  • range里只有一个数(a)，则从0开始，步长为1，到a-1结束
  • range里有两个数(a,b)，则从a开始，到b-1结束.步长为1
  • range里有三个数(a,b,c)，则从a开始，到b-c结束.步长为c
  • 区间是左闭右开 即 $[a,b)$

随机数

1
2
import random
number = random.randint(lower_bound, upper_bound)
  • 需要引入random包
  • 需要给定上下限。
  • 仅满足统计学上的均匀分布，并不具备不可预测性。

其它

三元表达式

Python实际上没有三元表达式，，，这只是一种代替写法

1
2
condition_is_true if condition else condition_is_false
1 if a>b else 2

交换数组两个元素

元素直接交换

1
2
3
a = 5
b = 8
a,b = b,a

数组元素交换

1
2
num =[456,3,5,8,78,54,94,12,63]
num[5],num[3] = num[3],num[5]