Python常用技能手册 - 基础语法

?系列

Python常用技能手册 - 基础语法

Python常用技能手册 - 模块module

Python常用技能手册 - 包package

目录

四大数据类型

整数 int

int() 转型

format() 进制互转

浮点数 float

float() 转型

字符串 str

str() str转型

布尔值 bool

四大数据结构

列表 list

创建、遍历、更新、删除

求长度、切片

计数、查询下标

元组 tuple

创建、不可修改

字典 dict

获取、添加/更新、删除

获取所有键值

判断键是否存在

集合 set

交集 &

并集 |

差集/补集 -

对称差集 ^

函数式编程

高阶函数

map() 映射

filter() 过滤

reduce() 缩减

嵌套函数

匿名函数

单个参数

多个参数

装饰器

无参数

有参数

---

四大数据类型

整数 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)