print("Hello Mojo!")
变量:
使用’ var ‘创建一个可变的值,或者用’ let '创建一个不可变的值。
方法:
方法可以使用python中的def 方法声明,也引入了fn 关键字声明方法,这两者使用方式会有一些区别。
fn声明强制执行强类型和内存安全行为,而def提供python风格的动态行为。
fn main():
var x: Int = 1
x += 1
print(x)
fn声明的方法中,可以不用声明变量类型,可以自动推断变量的类型,如下图case
fn do_math():
let x: Int = 1
let y = 2
print(x + y)
do_math()
虽然在函数体中声明的变量不需要类型,但fn函数的参数和返回值需要类型。
例如,下面是如何声明Int作为函数参数和返回值的类型:
fn add(x: Int, y: Int) -> Int:
return x + y
z = add(1, 2)
print(z)
可选参数和关键字参数
还可以指定参数默认值(也称为可选参数),并通过关键字参数名称传递值。例如:
fn pow(base: Int, exp: Int = 2) -> Int:
return base ** exp
# Uses default value for `exp`
z = pow(3)
print(z)
# Uses keyword argument names (with order reversed)
z = pow(exp=3, base=2)
print(z)
输出:
9
8
fn方法中参数的值是不可变的。如果希望参数是可变的,则需要将每个参数约定声明为inout。这意味着对函数内部参数所做的更改在函数外部是可见的。
例如,这个函数可以修改原来的变量:
fn add_inout(inout x: Int, inout y: Int) -> Int:
x += 1
y += 1
return x + y
var a = 1
var b = 2
c = add_inout(a, b)
print(a)
print(b)
print(c)
2
3
5
另一种选择是将参数声明为owned,这为函数提供了值的完全所有权(它是可变的并且保证唯一的)。这样,函数可以修改值,而不必担心影响函数外部的变量。例如:
fn set_fire(owned text: String) -> String:
text += ""
return text
fn mojo():
let a: String = "mojo"
let b = set_fire(a)
print(a)
print(b)
mojo()
可以为结构中的类型(或“对象”)构建高级抽象。Mojo中的结构体类似于Python中的类:它们都支持方法、字段、操作符重载、元编程的装饰器等。然而,Mojo结构是完全静态的——它们是在编译时绑定的,因此它们不允许动态分派或对结构进行任何运行时更改。(Mojo将来也会支持类。)
例如,这是一个基本结构:
struct MyPair:
var first: Int
var second: Int
fn __init__(inout self, first: Int, second: Int):
self.first = first
self.second = second
fn dump(self):
print(self.first, self.second)
调用方法
let mine = MyPair(2, 4)
mine.dump()
尽管Mojo仍在开发中,还不是Python的完整超集,但我们已经构建了一种机制,可以按原样导入Python模块,因此您可以立即利用现有的Python代码。在底层,该机制使用CPython解释器来运行Python代码,因此它可以与当今所有Python模块无缝协作。
例如,下面是你如何导入和使用NumPy(你必须安装Python NumPy):
from python import Python
let np = Python.import_module("numpy")
ar = np.arange(15).reshape(3, 5)
print(ar)
print(ar.shape)
[[ 0 1 2 3 4]
[ 5 6 7 8 9]
[10 11 12 13 14]]
(3, 5)