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

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)

金色牛神

关注

7
点赞
踩
10

收藏

觉得还不错? 一键收藏
0
评论
Python常用技能手册 - 基础语法

使用字典的键来添加或修改对应的值，可以使用方括号或update()方法。使用keys()方法获取所有键，使用values()方法获取所有值。表示有序、可变的集合，可以包含不同类型的元素。元组中的元素值是不允许修改的，但我们可以对元组进行连接组合。使用字典的键来获取对应的值，可以使用方括号或get()方法。表示有序、不可变的集合，可以包含不同类型的元素。返回两个集合中所有的元素，去重后组成的新集合。表示无序、唯一的元素集合，用大括号括起来。表示无序、键值对的集合，用大括号括起来。返回两个集合中都存在的元素。
复制链接

扫一扫

专栏目录