Notice: Function _load_textdomain_just_in_time was called incorrectly. Translation loading for the wp-pagenavi domain was triggered too early. This is usually an indicator for some code in the plugin or theme running too early. Translations should be loaded at the init action or later. Please see Debugging in WordPress for more information. (This message was added in version 6.7.0.) in /var/www/blog.zhujinhui.net/wp-includes/functions.php on line 6114

Notice: 函数 _load_textdomain_just_in_time 的调用方法不正确twentyseventeen 域的翻译加载触发过早。这通常表示插件或主题中的某些代码运行过早。翻译应在 init 操作或之后加载。 请查阅调试 WordPress来获取更多信息。 (这个消息是在 6.7.0 版本添加的。) in /var/www/blog.zhujinhui.net/wp-includes/functions.php on line 6114
煅魂-JeffreyChu – 第 2 页 – 煅魂-JeffreyChu的修炼屋

Python工程师不仅仅是会Python!

“语言只是一种工具”

很多人以为Python就只是学习Python语言本身就可以了,其实不然。

想要成为一名真正的Python工程师,除了掌握Python本身知识,还是需要学习和结合其他多种技术,才能开始真正地出活的。本文将简单谈谈Python工程师需要额外掌握的关键技术。

版本控制系统

程序员(不只是Python方向)必备的核心技能之一

  • 常见: Git
  • 用途: 代码管理、团队协作。
  • 学习内容:Git的基本命令(如clonecommitpushpullbranchmerge),GitHubGitLab等平台的使用。

Shell命令

大部分的Python应用都是部署在支持shell命令的环境,所以掌握shell命令也是Python(尤其是运维方向)开发工程师必备技能之一

  • 用途: 控制和管理操作系统,执行脚本和命令行任务。
  • 学习内容: 基本命令(如lscdgrep),脚本编写(条件语句、循环、变量)、权限管理(chmodchown),自动化任务(cron)。

数据库

web后端/运维/爬虫开发工程师必备技能之一

关系型数据库

  • 常见: MySQLPostgreSQLOracle
  • 用途: 结构化数据存储和管理。
  • 学习内容: 增删改查、索引、事务处理。

NoSQL数据库

  • 常见: MongoDBRedis
  • 用途: 非结构化数据存储、高性能缓存。
  • 学习内容: 增删改查操作、数据模型。

进阶

  • 优化慢查询能力
  • 优化存储能力
  • 处理并发能力

前端

如果是往Web开发/爬虫工程师方向发展的话,那么前端技术是必备技能之一

HTML/CSS

  • 用途: 构建网页结构和样式。
  • 学习内容: 基本标签、选择器、布局、样式。

JavaScript

  • 用途: 客户端、服务端交互逻辑。
  • 学习内容: 基本语法、DOM操作、事件处理。

进阶

流行的前端框架是进阶技能之一

  • 常见: ReactVue.js
  • 用途: 构建复杂的单页应用(SPA)。
  • 学习内容: 组件、状态管理、路由。

Web框架

这个是Web开发工程师必备技能之一

  • 常见: DjangoFlaskFastAPI
  • 用途: 快速开发Web网站网页应用。
  • 学习内容: 路由、视图、模板、ORM、认证和授权。

容器编排

web后端/运维开发工程师进阶技能之一

Docker

  • 用途: 应用程序容器化,提供一致的开发和生产环境。
  • 学习内容: 镜像构建、容器管理、Docker Compose

Kubernetes

  • 用途: 容器编排,管理复杂的容器化应用。
  • 学习内容: Pods、服务、部署、卷、网络。

云计算平台

运维开发工程师进阶技能之一,大公司这项技能是标配。

  • 常见: AWSGoogle CloudAzure
  • 用途: 部署和扩展云端应用。
  • 学习内容: 基本服务(EC2S3RDS等)、身份和访问管理(IAM)、服务器部署和监控。

测试框架

优秀的工程师都是会给自己的代码加测试用例,以避免别人或自己修错代码后导致意外发生。

  • 常见: PyTest框架 或 内置Unittest
  • 用途: 自动化测试,提高代码质量。
  • 学习内容: 编写测试用例、测试套件、模拟(Mocking)。

CI/CD

web后端/运维开发工程师进阶技能之一

  • 常见: JenkinsGitHub ActionsGitLab CI
  • 用途: 持续集成和持续交付,自动化部署流程。
  • 学习内容: 管道配置、构建和部署脚本、集成测试。

数据处理和分析

数据分析/大数据/算法开发方向工程师必备技能之一

Pandas

  • 用途: 数据清洗和分析。
  • 学习内容: DataFrame操作、过滤、聚合。

NumPy

  • 用途: 数值计算。
  • 学习内容: 数组操作、矩阵运算。

Matplotlib/R

  • 用途: 数据可视化。
  • 学习内容: 基本绘图、定制化图表。

网络编程

RESTful API

web后端/爬虫开发工程师必备技能之一

  • 用途: 构建和使用API
  • 学习内容: 请求处理、JSON解析、API文档(Swagger)。

WebSockets

  • 用途: 实时通信。
  • 学习内容: 连接管理、消息传递、状态同步。

AI相关

Transformer

机器学习/自然语言处理工程师必备技能之一

  • 用途: 处理序列数据,用于任务如机器翻译、文本生成、语义理解。
  • 学习内容: 架构原理、模型、应用、工具

TensorFlow

深度学习工程师必备技能之一

  • 用途: 构建和训练深度学习模型。
  • 学习内容: 基础知识、模型构建、训练和优化、部署、工具

PyTorch

深度学习工程师必备技能之一

  • 用途: 动态计算图的深度学习框架,用于构建和训练神经网络。
  • 学习内容: 基础知识、模型构建、训练和优化、部署、工具

总结

这些技术不仅能提升Python工程师的能力,还能使他们在项目开发、团队合作、以及职业发展中更具竞争力。

掌握这些技能有助于工程师更有效地构建和维护复杂的软件系统,优化性能,并保证代码质量。

一文搞定Python内建函数类型

Python 内建函数是语言核心功能的一部分,提供了高效的数据处理和简化编程的工具集。它们涵盖了数据类型转换、集合操作、迭代器、函数式编程支持,以及面向对象编程辅助。

本篇主要是介绍内建函数中的内建类型。

内建类型概念

Python 内建函数中的内建类型(built-in types)是指 Python 语言中原生支持的数据类型,像intliststr这种内建函数实际上都是class,不同于普通内建函数absinput。但由于用法比较像函数所以也被称为内建函数,所以称为内建类型更为确切些。

可以通过IDE(如VScode、PyCharm等)跳到int定义的地方看到,它确实是一种类(类型)

或者通过type函数的结果发现,int是一种类,如果是一个函数那么type(int)返回的应该是function

这些类型涵盖了常见的数据表示方法,包括数值序列集合映射文本等。每种内建类型都具有特定的行为、属性和方法,使得数据操作变得简单和直观。

常见用法

object

object 函数返回一个新的空对象。它是所有新风格类的基类。

obj = object()
print(type(obj))  # <class 'object'>

进阶使用:

class MyClass(object):
    pass

instance = MyClass()
print(isinstance(instance, object))  # True

int

int 函数用于将一个数或字符串转换为整数。它可以指定进制来进行转换。

number = int("42")
print(number)  # 42

number = int(3.14)
print(number)  # 3

进阶使用:

binary_number = int("1010", 2)  # 二进制转十进制
print(binary_number)  # 10

hex_number = int("1A", 16)  # 十六进制转十进制
print(hex_number)  # 26

bool

bool 函数用于将一个值转换为布尔值。除了 None0""[](){} 等被认为是 False 之外,其他所有值均为 True

flag = bool(1)
print(flag)  # True

flag = bool(0)
print(flag)  # False

进阶使用:

print(bool([]))  # 空列表为 False
print(bool([1, 2, 3]))  # 非空列表为 True

bytes

bytes 函数用于创建一个不可变的字节序列。可以从整数序列、字符串(需要指定编码)或缓冲区对象创建。

byte_data = bytes("hello", encoding='utf-8')
print(byte_data)  # b'hello'

byte_data = bytes([104, 101, 108, 108, 111])
print(byte_data)  # b'hello'

进阶使用:

byte_data = bytes(5)  # 长度为5的空字节序列
print(byte_data)  # b'\x00\x00\x00\x00\x00'

byte_data = bytes(b'\x01\x02\x03')
print(list(byte_data))  # [1, 2, 3]

bytearray

bytearray 函数用于创建一个可变的字节序列。与 bytes 类似,但它是可变的。

byte_array = bytearray("hello", encoding='utf-8')
print(byte_array)  # bytearray(b'hello')

byte_array = bytearray([104, 101, 108, 108, 111])
print(byte_array)  # bytearray(b'hello')

进阶使用:

byte_array = bytearray(5)  # 长度为5的空字节序列
byte_array[0] = 65
print(byte_array)  # bytearray(b'A\x00\x00\x00\x00')

byte_array.extend(b' world')
print(byte_array)  # bytearray(b'A\x00\x00\x00\x00 world')

complex

complex 函数用于创建复数。可以从两个数字创建复数,或者从字符串表示形式创建复数。

complex_number = complex(1, 2)
print(complex_number)  # (1+2j)

complex_number = complex("1+2j")
print(complex_number)  # (1+2j)

进阶使用:

real = 1.5
imaginary = 2.5
complex_number = complex(real, imaginary)
print(complex_number)  # (1.5+2.5j)

magnitude = abs(complex_number)
print(magnitude)  # 2.9154759474226504

float

float 函数用于将一个数或字符串转换为浮点数。可以处理科学计数法。

floating_number = float("3.14")
print(floating_number)  # 3.14

floating_number = float(42)
print(floating_number)  # 42.0

进阶使用:

scientific = float("1e-3")
print(scientific)  # 0.001

not_a_number = float('nan')
print(not_a_number)  # nan
print(float('inf'))  # inf

str

str 函数用于将对象转换为字符串。可以指定编码格式。

text = str(42)
print(text)  # '42'

text = str(3.14)
print(text)  # '3.14'

进阶使用:

byte_data = b"hello"
text = str(byte_data, encoding='utf-8')
print(text)  # 'hello'

number = 1234
formatted = str(number).zfill(6)
print(formatted)  # '001234'

list

list 函数用于创建列表,可以从可迭代对象创建。

numbers = list(range(5))
print(numbers)  # [0, 1, 2, 3, 4]

characters = list("hello")
print(characters)  # ['h', 'e', 'l', 'l', 'o']

进阶使用:

tuple_data = (1, 2, 3)
list_from_tuple = list(tuple_data)
print(list_from_tuple)  # [1, 2, 3]

filtered_numbers = list(filter(lambda x: x % 2 == 0, range(10)))
print(filtered_numbers)  # [0, 2, 4, 6, 8]

dict

dict 函数用于创建字典,可以从键值对序列或关键字参数创建。

student = dict(name="Alice", age=21)
print(student)  # {'name': 'Alice', 'age': 21}

pairs = [('name', 'Bob'), ('age', 22)]
student = dict(pairs)
print(student)  # {'name': 'Bob', 'age': 22}

进阶使用:

keys = ["name", "age"]
values = ["Charlie", 23]
student = dict(zip(keys, values))
print(student)  # {'name': 'Charlie', 'age': 23}

default_student = dict.fromkeys(['name', 'age'], 'Unknown')
print(default_student)  # {'name': 'Unknown', 'age': 'Unknown'}

set

set 函数用于创建集合,可以从可迭代对象创建。

unique_numbers = set([1, 2, 2, 3, 4])
print(unique_numbers)  # {1, 2, 3, 4}

characters = set("hello")
print(characters)  # {'h', 'e', 'l', 'o'}

进阶使用:

set1 = set([1, 2, 3])
set2 = set([3, 4, 5])
union_set = set1 | set2
print(union_set)  # {1, 2, 3, 4, 5}

intersection_set = set1 & set2
print(intersection_set)  # {3}

frozenset

frozenset 函数用于创建不可变集合,可以从可迭代对象创建。

frozen = frozenset([1, 2, 2, 3, 4])
print(frozen)  # frozenset({1, 2, 3, 4})

characters = frozenset("hello")
print(characters)  # frozenset({'h', 'e', 'l', 'o'})

进阶使用:

set1 = frozenset([1, 2, 3])
set2 = frozenset([3, 4, 5])
union_frozen = set1 | set2
print(union_frozen)  # frozenset({1, 2, 3, 4, 5})

intersection_frozen = set1 & set2
print(intersection_frozen)  # frozenset({3})

tuple

tuple 函数用于创建元组,可以从可迭代对象创建。

numbers = tuple([1, 2, 3])
print(numbers)  # (1, 2, 3)

characters = tuple("hello")
print(characters)  # ('h', 'e', 'l', 'l', 'o')

进阶使用:

list_data = [1, 2, 3]
tuple_from_list = tuple(list_data)
print(tuple_from_list)  # (1, 2, 3)

single_element = tuple([42])
print(single_element)  # (42,)

filter

filter 函数用于过滤序列,返回一个过滤后的迭代器。

numbers = [1, 2, 3, 4, 5, 6]
even_numbers = filter(lambda x: x % 2 == 0, numbers)
print(list(even_numbers))  # [2, 4, 6]

进阶使用:

def is_positive(n):
    return n > 0

positive_numbers = filter(is_positive, [-2, -1, 0, 1, 2])
print(list(positive_numbers))  # [1, 2]

map

map 函数用于对序列中的每个元素应用指定的函数,返回一个迭代器。

numbers = [1, 2, 3, 4, 5]
squared_numbers = map(lambda x: x ** 2, numbers)
print(list(squared_numbers))  # [1, 4, 9, 16, 25]

进阶使用:

def double(n):
    return n * 2

doubled_numbers = map(double, [1, 2, 3, 4])
print(list(doubled_numbers))  # [2, 4, 6, 8]

property

property 函数用于创建属性访问器,通常用于封装对象的私有属性。

class Person:
    def __init__(self, name):
        self._name = name

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, value):
        self._name = value

person = Person("Alice")
print(person.name)  # Alice
person.name = "Bob"
print(person.name)  # Bob

进阶使用:

class Rectangle:
    def __init__(self, width, height):
        self._width = width
        self._height = height

    @property
    def area(self):
        return self._width * self._height

rect = Rectangle(4, 5)
print(rect.area)  # 20

classmethod

classmethod 函数用于将方法定义为类方法,可以访问类本身而不是实例。

class MyClass:
    counter = 0

    @classmethod
    def increment_counter(cls):
        cls.counter += 1

MyClass.increment_counter()
print(MyClass.counter)  # 1

进阶使用:

class Person:
    population = 0

    def __init__(self, name):
        self.name = name
        Person.increase_population()

    @classmethod
    def increase_population(cls):
        cls.population += 1

print(Person.population)  # 0
p1 = Person("Alice")
p2 = Person("Bob")
print(Person.population)  # 2

staticmethod

staticmethod 函数用于将方法定义为静态方法,无法访问类或实例。

class MyClass:
    @staticmethod
    def greet(name):
        return f"Hello, {name}!"

print(MyClass.greet("Alice"))  # Hello, Alice!

进阶使用:

class Math:
    @staticmethod
    def add(a, b):
        return a + b

print(Math.add(3, 4))  # 7

super

super 函数用于调用父类的方法,可以支持多继承。

class Animal:
    def sound(self):
        return "Some sound"

class Dog(Animal):
    def sound(self):
        return super().sound() + " (Dog)"

dog = Dog()
print(dog.sound())  # Some sound (Dog)

进阶使用:

class A:
    def __init__(self):
        print("A")

class B(A):
    def __init__(self):
        super().__init__()
        print("B")

b = B()  # A B

slice

slice 函数用于创建一个切片对象,可以用在序列的切片操作中。

s = "hello"
slice_obj = slice(1, 3)
print(s[slice_obj])  # 'el'

进阶使用:

numbers = [0, 1, 2, 3, 4]
slice_obj = slice(1, 4, 2)
print(numbers[slice_obj])  # [1, 3]

zip

zip 函数用于将多个可迭代对象打包成一个迭代器,按元素并行处理。

names = ["Alice", "Bob", "Charlie"]
ages = [24, 30, 22]
combined = zip(names, ages)
print(list(combined))  # [('Alice', 24), ('Bob', 30), ('Charlie', 22)]

进阶使用:

keys = ["name", "age"]
values = ["Alice", 24]
combined = dict(zip(keys, values))
print(combined)  # {'name': 'Alice', 'age': 24}

reversed

reversed 函数用于返回序列的反向迭代器。

numbers = [1, 2, 3, 4, 5]
rev_numbers = reversed(numbers)
print(list(rev_numbers))  # [5, 4, 3, 2, 1]

进阶使用:

text = "hello"
rev_text = reversed(text)
print(''.join(rev_text))  # 'olleh'

range

range 函数用于生成数字序列,常用于循环中。

for i in range(5):
    print(i)  # 0 1 2 3 4

进阶使用:

numbers = list(range(1, 10, 2))
print(numbers)  # [1, 3, 5, 7, 9]

reverse_range = list(range(10, 0, -2))
print(reverse_range)  # [10, 8, 6, 4, 2]

memoryview

memoryview 函数用于创建一个视图对象,可以直接访问原始数据的内存。

byte_array = bytearray(b'hello')
view = memoryview(byte_array)
print(view[0])  # 104
view[0] = 72
print(byte_array)  # bytearray(b'Hello')

进阶使用:

buffer = memoryview(b'abcdefgh')
print(buffer[1:4].tobytes())  # b'bcd'

numbers = bytearray([1, 2, 3, 4, 5])
view = memoryview(numbers)
view[1:3] = b'\x00\x01'
print(numbers)  # bytearray(b'\x01\x00\x01\x04\x05')

总结

本文详细介绍了 Python 内建函数的多种用法及其实际代码示例。内建函数是 Python 强大的语言特性之一,它们不仅提供了基本的数据操作能力,还能简化日常编程任务,使代码更加简洁、高效。掌握这些函数的用法,能有效提升编程技巧和代码质量。

希望这些示例能帮助你更好地理解和使用 Python 内建函数,提升编程效率