系列
目录
四大数据类型
整数 int
表示整数值,例如:42, -10。
int() 转型
可以指定进制类型的。
print(int('100')) # 默认就是 10进制
print(int('100', 2)) # 按照2进制读取,就是4
print(int('100', 8)) # 按照8进制读取,就是64
print(int('100', 9)) # 按照9进制读取,就是81
print(int('100', 10)) # 按照10进制读取,就是100
format() 进制互转
支持常见的进制转换。包括2、8、10、16进制。
举一个例子,
# 十进制转换为2进制、8进制、10进制、16进制
num = 255
# 转换为二进制
binary = format(num, 'b') # 输出: '11111111'
print(f"二进制: {binary}")
# 转换为八进制
octal = format(num, 'o') # 输出: '377'
print(f"八进制: {octal}")
# 转换为十进制(实际上是重复了,因为num已经是十进制的)
decimal = format(num, 'd') # 输出: '255'
print(f"十进制: {decimal}")
# 转换为十六进制
hexadecimal = format(num, 'x') # 输出: 'ff'
print(f"十六进制: {hexadecimal}")
再举个例子,
num = 100
print("二进制", format(num, 'b'))
print("八进制", format(num, 'o'))
print("十进制", format(num, 'd'))
print("十六进制", format(num, 'x'))
# 二进制 1100100
# 八进制 144
# 十进制 100
# 十六进制 64
浮点数 float
表示带有小数部分的数值,例如:3.14, -0.5。
float() 转型
num = 100
print(type(num), num) # 原始数据
num_float = float(num) # int 转 float
print(type(num_float), num_float)
字符串 str
表示字符或文本序列,用引号(单引号或双引号)括起来,例如:“Hello, World!”。
str() str转型
num = 100
print(type(num), num) # 原始数据
num_str = str(num) # int 转 str
print(type(num_str), num_str)
num_int = int(num) # str 转 int
print(type(num_int), num_int)
布尔值 bool
表示真(True)或假(False)的值。
四大数据结构
列表 list
又称一维数组。表示有序、可变的集合,可以包含不同类型的元素。
创建、遍历、更新、删除
创建一维数组
numbers = [1, 2, 3, 4, 5]
创建二维数组,赋值0
matrix = [[0 for col in range(cols)] for row in range(rows)]
创建二维数组,空
matrix = [[] for row in range(rows)]
遍历一维数组
first_number = numbers[0] # 访问第一个元素
last_number = numbers[-1] # 访问最后一个元素
遍历二维数组
for row in range(rows):
for col in range(cols):
print(matrix[row][col])
更新一维数组
numbers[1] = 10 # 将索引为1的元素更新为10
更新二维数组
matrix[row][col] = value
添加元素
numbers.append(6) # 在数组末尾添加一个元素
numbers.insert(2, 7) # 在索引为2的位置插入元素7
删除元素
del numbers[3] # 删除索引为3的元素
numbers.remove(4) # 删除值为4的第一个元素
求长度、切片
length = len(numbers) # 获取数组的长度
一维数组切片
sliced_numbers = numbers[1:4] # 获取索引1到3的元素切片
二维数组切片,取原矩阵的[2:5][2:5]
new_matrix = [row[2:5] for row in maxtrix[2:5]]
计数、查询下标
index()是在序列中检索参数并返回第一次出现的索引位置,Python下标默认从0计数。
A = [123, 'xyz', 'zara', 'abc']
print(A.index('xyz')) # 输出1
元组 tuple
表示有序、不可变的集合,可以包含不同类型的元素。
创建、不可修改
元组中的元素值是不允许修改的,但我们可以对元组进行连接组合。
t = (1, 2, 3)
t = t + (4, 5, 6)
print(t) # (1, 2, 3, 4, 5, 6)
字典 dict
表示无序、键值对的集合,用大括号括起来。
获取、添加/更新、删除
使用字典的键来获取对应的值,可以使用方括号或get()方法。
my_dict = {'name': 'Alice', 'age': 25, 'gender': 'female'}
print(my_dict['name']) # 输出:Alice
print(my_dict.get('age')) # 输出:25
使用字典的键来添加或修改对应的值,可以使用方括号或update()方法。
my_dict = {'name': 'Alice', 'age': 25, 'gender': 'female'}
my_dict['email'] = 'alice@example.com'
my_dict.update({'age': 26, 'gender': 'unknown'})
print(my_dict) # 输出:{'name': 'Alice', 'age': 26, 'gender': 'unknown', 'email': 'alice@example.com'}
删除。使用del语句或pop()方法来删除字典中的键值对。
my_dict = {'name': 'Alice', 'age': 25, 'gender': 'female'}
del my_dict['age']
my_dict.pop('gender')
print(my_dict) # 输出:{'name': 'Alice'}
获取所有键值
使用keys()方法获取所有键,使用values()方法获取所有值。
my_dict = {'name': 'Alice', 'age': 25, 'gender': 'female'}
print(my_dict.keys()) # 输出:dict_keys(['name', 'age', 'gender'])
print(my_dict.values()) # 输出:dict_values(['Alice', 25, 'female'])
判断键是否存在
使用in判断键是否存在于字典中。
my_dict = {'name': 'Alice', 'age': 25, 'gender': 'female'}
print('name' in my_dict) # 输出:True
集合 set
表示无序、唯一的元素集合,用大括号括起来。
交集 &
返回两个集合中都存在的元素。
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
intersection = set1.intersection(set2)
print(intersection) # {4, 5}
intersection = set1 & set2
print(intersection) # {4, 5}
并集 |
返回两个集合中所有的元素,去重后组成的新集合。
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
union = set1.union(set2)
print(union) # {1, 2, 3, 4, 5, 6, 7, 8}
union = set1 | set2
print(union) # {1, 2, 3, 4, 5, 6, 7, 8}
差集/补集 -
返回属于第一个集合但不属于第二个集合的元素。
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
difference = set1.difference(set2)
print(difference) # {1, 2, 3}
difference = set1 - set2
print(difference) # {1, 2, 3}
对称差集 ^
返回只属于一个集合而不属于另一个集合的元素。
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
symmetric_difference = set1.symmetric_difference(set2)
print(symmetric_difference) # {1, 2, 3, 6, 7, 8}
symmetric_difference = set1 ^ set2
print(symmetric_difference) # {1, 2, 3, 6, 7, 8}
函数式编程
在函数式编程中,函数是第一类对象,这意味着函数可以作为参数传递给其他函数,也可以作为返回值从一个函数返回。
即,函数也可以像常见的bool、int、str一样,作为一个参数进行传递。
高阶函数
map() 映射
将一个列表映射成另一个列表。
def square(x):
return x ** 2
nums = [1, 2, 3, 4, 5]
squared_nums = map(square, nums)
print(list(squared_nums)) # 输出:[1, 4, 9, 16, 25]
filter() 过滤
bool函数,将一个列表进行过滤,返回为True的值,生成新列表。
def is_even(x):
return x % 2 == 0
nums = [1, 2, 3, 4, 5]
even_nums = filter(is_even, nums)
print(list(even_nums)) # 输出:[2, 4]
reduce() 缩减
列表元素从左往右,逐个缩减,缩减方法为函数的操作方法。
from functools import reduce
def add(x, y):
return x + y
nums = [1, 2, 3, 4, 5]
sum_nums = reduce(add, nums)
print(sum_nums) # 输出:15
嵌套函数
嵌套函数是一种函数作为返回值的情况。
def my_sum(x):
def my_add(y, z):
return x + y * z
return my_add
f = my_sum(10) # my_add(y, z)
print(f(5, 2)) # 输出 20
但嵌套函数不会立马计算值,只是保存了一个引用。
注意到返回的函数在其定义内部引用了局部变量args,所以,当一个函数返回了一个函数后,其内部的局部变量还被新函数引用。
def my_sum(x):
result_f = []
for x in range(3):
def my_add(y, z):
return x + y * z
result_f.append(my_add)
return result_f
f1, f2, f3 = my_sum(10) # my_add(y, z)
print(f1(5, 2), f2(5, 2), f3(5, 2)) # 输出 12
匿名函数
单个参数
print(list(map(lambda x: x * x, [1, 2, 3])))
# 输出 [1, 4, 9]
多个参数
# 定义一个lambda函数,接受两个参数x和y,返回它们的和
add = lambda x, y: x + y
# 调用lambda函数,将3和5作为参数传递
result = add(3, 5)
print(result) # 输出:8
装饰器
Python装饰器是一种特殊类型的函数,它可以接受一个函数作为参数,并返回一个新的函数。装饰器可以在不修改原始函数代码的情况下,为函数添加额外的功能。
无参数
下面是一个简单的Python装饰器示例,不涉及一个参数:
def my_decorator(func):
def wrapper():
print("Something is happening before the function is called.")
func()
print("Something is happening after the function is called.")
return wrapper
@my_decorator
def say_hello():
print("Hello!")
# 调用装饰后的函数
say_hello()
有参数
下面实现一个在原始函数前后添加额外功能的装饰效果,用于计算函数的执行时间:
import time
def timer_decorator(func):
def wrapper(*args, **kwargs):
start_time = time.time()
result = func(*args, **kwargs)
end_time = time.time()
print(f"Function {func.__name__} took {end_time - start_time} seconds to execute.")
return result
return wrapper
@timer_decorator
def compute_fibonacci(n):
if n <= 1:
return n
else:
return compute_fibonacci(n-1) + compute_fibonacci(n-2)
# 调用装饰后的函数并传入参数10,计算斐波那契数列的第10个数
result = compute_fibonacci(10)