【Android】Kotlin 核心语法详解(快速入门)

前言

在Google I/O 2017中,Google 宣布 Kotlin 成为 Android 官方开发语言。Kotlin 是一种在 Java 虚拟机上运行的静态类型编程语言,Kotlin 可以编译成Java字节码,也可以编译成 JavaScript,可以完美运行在 Java 环境。

Kotlin 语言主要是具有以下特性:

1.语法简洁、高级
2.空指针安全
3.完全兼容Java:可Kotlin 和 Java 两种语言混合开发
4.函数式编程:扩展函数、支持Lambda表达式
5.类型推断:无需指明类型
6.强大的协程:处理线程问题
7.委托:延迟加载,提高加载速度
8.不可变数据
9.无需 findViewById获取控件:有些地方不推荐使用

Kotlin 可谓集大家之所长,极大提升了Android原生代码的开发效率,备受欢迎。


1. Kotlin 环境搭建

在创建项目工程的时候直接勾选 Include Kotlin support 选项,选择 Kotlin 语言即可。
如果是Java老项目,Android Studio 需要安装Kotlin插件,同时手动配置 gradle,配置如下:

在 app 模块的 gradle 下加入如下代码:

apply plugin: 'kotlin-android'
apply plugin: 'kotlin-android-extensions'

在 project 模块的 gradle 下加入如下代码:

ext.kotlin_version = '1.4.21'
dependencies {
	classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
}

后文是 Kotlin 语言的具体介绍和使用,同时与 Java 语言进行对比,方便理解。

2. 对象

Java 的写法

MainActivity.this

Kotlin 的写法

this@MainActivity

3. 类

Java 的写法

MainActivity.class

Kotlin 的写法

MainActivity::class.java

4. 继承

Java 的写法

public class MainActivity extends AppCompatActivity {
    
}

Kotlin 的写法(在 Kotlin 中被继承类必须被 open 关键字修饰)

class MainActivity : AppCompatActivity() {
    
}

5. 变量

Java 的写法

Intent intent = new Intent();

Kotlin 的写法

var intent = Intent()

6. 常量

Java 的写法

final String text = "";

Kotlin 的写法

val text = ""

7. 静态常量

Java 的写法

public class MainActivity extends AppCompatActivity {

    static final String text = "";
}

Kotlin 的写法(需要注意的是要把静态变量定义在类上方)

const val text = ""

class MainActivity : AppCompatActivity() {

}

8. 定义方法

Java 的写法

public void test(String message) {

}

Kotlin 的写法(Unit 跟 void 一样效果)

fun test(message : String) : Unit {

}
// 在 Kotlin 可以省略 Unit 这种返回值
fun test(message : String) {

}

9. 重载方法

Java 的写法

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
    }
}

Kotlin 的写法

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
    }
}

10. 基本数据类型

Java 的写法

int i = 1;
long l = 2;
boolean b = true;
float f = 0;
double d = 0;
char c = 'A';
String s = "text";

Kotlin 的写法

var i : Int = 1
var l : Long = 2
var b : Boolean = true
var f : Float = 0F
var d : Double = 0.0
var c : Char = 'A'
var s : String = "text"
// 更简洁点可以这样,自动推倒类型
var i = 1
var l = 2
var b = true
var f = 0F
var d = 0.0
var c = 'A'
var s = "text"

11. 比较类型

Java 的写法

if ("" instanceof String) {

}

Kotlin 的写法

if ("" is String) {

}

12. 转换符

Java 的写法

int number = 100;
System.out.println(String.format("数量有%d", number));

Kotlin 的写法

var number = 100
println("数量有${number}")
// 换种简洁的写法
var number = 100
println("数量有$number")
// 如果不想字符串被转义可以使用\$
var number = 100
println("数量有\$number")

13. 字符串比较

Java 的写法

String s1 = "text";
String s2 = "text";
if (s1.equals(s2)) {
    
}

Kotlin 的写法(Kotlin 对字符串比较的写法进行优化了,其他类型对象对比还是要用 equals 方法)

var s1 = "text"
var s2 = "text"
if (s1 == s2) {

}

14. 数组

Java 的写法

int[] array1 = {1, 2, 3};
float[] array2 = {1f, 2f, 3f};
String[] array3 = {"1", "2", "3"};

Kotlin 的写法

val array1 = intArrayOf(1, 2, 3)
val array2 = floatArrayOf(1f, 2f, 3f)
val array3 = arrayListOf("1", "2", "3")

15. 循环

Java 的写法

String[] array = {"1", "2", "3"};

for (int i = 0; i < array.length; i++) {
    System.out.println(array[i]);
}

Kotlin 的写法

val array = arrayListOf("1", "2", "3")

for (i in array.indices) {
    println(array[i])
}

16. 下标循环

Java 的写法

String[] array = {"1", "2", "3"};

for (int i = 1; i < array.length; i++) {
    System.out.println(array[i]);
}

Kotlin 的写法(这种写法在 Kotlin 中称之为区间)

val array = arrayListOf("1", "2", "3")

for (i in IntRange(1, array.size - 1)) {
    println(array[i])
}
// 换种更简洁的写法
val array = arrayListOf("1", "2", "3")

for (i in 1..array.size - 1) {
    println(array[i])
}
// 编译器提示要我们换种写法
val array = arrayListOf("1", "2", "3")

for (i in 1 until array.size) {
    println(array[i])
}

17. 高级循环

Java 的写法

String[] array = {"1", "2", "3"};

for (String text : array) {
    System.out.println(text);
}

Kotlin 的写法

val array = arrayListOf("1", "2", "3")

for (text in array) {
    println(text)
}

18. 判断器

Java 的写法

int count = 1;

switch (count) {
    case 0:
        System.out.println(count);
        break;
    case 1:
    case 2:
        System.out.println(count);
        break;
    default:
        System.out.println(count);
        break;
}
在这里插入代码片

Kotlin 的写法

var count = 1

when (count) {
    0 -> {
        println(count)
    }
    in 1..2 -> {
        println(count)
    }
    else -> {
        println(count)
    }
}
var count = 1

// 换种更简洁的写法
when (count) {
    0 -> println(count)
    in 1..2 -> println(count)
    else -> println(count)
}

19. 构造函数

Java 的写法

public class MyView extends View {

    public MyView(Context context) {
        this(context, null);
    }

    public MyView(Context context, @Nullable AttributeSet attrs) {
        this(context, attrs, 0);
    }

    public MyView(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
    }
}

Kotlin 的写法

class MyView : View {

    constructor(context : Context) : this(context, null) {

    }

    constructor(context : Context, attrs : AttributeSet?) : this(context, attrs, 0) {

    }

    constructor(context : Context, attrs : AttributeSet?, defStyleAttr : Int) : super(context, attrs, defStyleAttr) {

    }
}
// 换种更简洁的写法
class MyView : View {

    constructor(context : Context) : this(context, null)

    constructor(context : Context, attrs : AttributeSet?) : this(context, attrs, 0)

    constructor(context : Context, attrs : AttributeSet?, defStyleAttr : Int) : super(context, attrs, defStyleAttr)
}
// 只有一种构造函数的还可以这样写
class MyView(context: Context?) : View(context) {

}

20. 类创建

Java 的写法

public class Person {

    String name;
    int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
Person person = new Person("Zhangsan", 100);
person.setName("ZS");
person.setAge(18);
System.out.println("name: " + person.getName() + ", age: " + person.getAge());

Kotlin 的写法(如果不想暴露成员变量的set方法,可以将 var 改成 val )

class Person {

    var name : String? = null
    get() = field
    set(value) {field = value}

    var age : Int = 0
    get() = field
    set(value) {field = value}
}
// 换种更简洁的写法
class Person(var name : String, var age : Int)
var person = Person("Zhangsan", 100)
person.name = "ZS"
person.age = 18
println("name: {$person.name}, age: {$person.age}")

21. 私有化 set 方法

Java 的写法

public class Person {

    String name;
    int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    private void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    private void setAge(int age) {
        this.age = age;
    }
}

Kotlin 的写法

class Person {

    var name : String? = null
    private set

    var age : Int = 0
    private set
}

22. 私有化 get 方法

Java 的写法

public class Person {

    String name;
    int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    private String getName() {
        return name;
    }

    private void setName(String name) {
        this.name = name;
    }

    private int getAge() {
        return age;
    }

    private void setAge(int age) {
        this.age = age;
    }
}

Kotlin 的写法

class Person {

    private var name : String? = null

    private var age : Int = 0
}

23. 枚举

Java 的写法

enum Sex {

    MAN(true), WOMAN(false);

    Sex(boolean isMan) {}
}

Kotlin 的写法

enum class Sex (var isMan: Boolean) {

    MAN(true), WOMAN(false)
}

24. 接口

Java 的写法

public interface Callback {
    void onSuccess();
    void onFail();
}

Kotlin 的写法(Kotlin接口方法里面是可以自己实现,这里就不再演示了)

interface Callback {
    fun onSuccess()
    fun onFail()
}

25. 匿名内部类

Java 的写法

new Callback() {

    @Override
    public void onSuccess() {
        
    }

    @Override
    public void onFail() {

    }
};

Kotlin 的写法

object:Callback {

    override fun onSuccess() {
        
    }

    override fun onFail() {
        
    }
}

26. 内部类

Java 的写法

public class MainActivity extends AppCompatActivity {

    public class MyTask {

    }
}

Kotlin 的写法

class MainActivity : AppCompatActivity() {

    inner class MyTask {
        
    }
}

27. 内部类访问外部类同名变量

Java 的写法

String name = "Zhangsan";

public class MyTask {

    String name = "ZS";

    public void show() {
        System.out.println(name + "---" + MainActivity.this.name);
    }
}

Kotlin 的写法

var name = "Zhangsan"

inner class MyTask {

    var name = "ZS"

    fun show() {
        println(name + "---" + this@MainActivity.name)
    }
}

28. 抽象类

Java 的写法

public abstract class BaseActivity extends AppCompatActivity implements Runnable {

    abstract void init();
}

Kotlin 的写法

abstract class BaseActivity : AppCompatActivity(), Runnable {

    abstract fun init()
}

29. 静态变量和方法

Java 的写法

public class ToastUtils {

    public static Toast sToast;

    public static void show() {
        sToast.show();
    }
}

Kotlin 的写法(在 Kotlin 将这种方式称之为伴生对象)

companion object ToastUtils {

    var sToast : Toast? = null

    fun show() {
        sToast!!.show()
    }
}

30. 可变参数

Java 的写法

public int add(int... array) {
    int count = 0;
    for (int i : array) {
        count += i;
    }
    return count;
}

Kotlin 的写法

fun add(vararg array: Int) : Int {
    var count = 0
    //for (i in array) {
    //    count += i
    //}
    array.forEach {
        count += it
    }
    return count
}

31. 泛型

Java 的写法

public class Bean<T extends String> {

    T data;
    public Bean(T t) {
        this.data = t;
    }
}
Bean<String> bean = new Bean<>("666666");

Kotlin 的写法

class Bean<T : Comparable<String>>(t: T) {
    var data = t
}
var bean = Bean<String>("666666")
// 换种更简洁的写法
var bean = Bean("666666")

32. 构造代码块

Java 的写法

public class MainActivity extends AppCompatActivity {

    int number;

    {
        number = 1;
    }
}

Kotlin 的写法

class MainActivity : AppCompatActivity() {

    var number = 0

    init {
        number = 1
    }
}

33. 静态代码块

Java 的写法

public class MainActivity extends AppCompatActivity {

    static int number;

    static {
        number = 1;
    }
}

Kotlin 的写法

class MainActivity : AppCompatActivity() {

    companion object {
        
        var number = 0
        
        init {
            number = 1
        }
    }
}

34. 方法代码块

Java 的写法

void test(){
    {
        int a = 1;
    }
}

Kotlin 的写法

fun test() {
    run {
        var a =1
    }
}

35. 可见修饰符

Java 的写法(默认为 default)

修饰符作用
public所有类可见
protected子类可见
default同一包下的类可见
private仅对自己类可见

Kotlin 的写法(默认为 public)

修饰符作用
public所有类可见
internal同 Module 下的类可见
protected子类可见
private仅对自己类可见

36. 无需 findViewById

在布局中定义

<TextView
    android:id="@+id/tv_content"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="Hello World!" />

直接设置 TextView 的文本

tv_content.text = "改变文本"

37. Lambda

Lambda 表达式虽然在 Java JDK 已经加上了,但是没有普及开来,现在搭配 Kotlin 是一个不错的选择

tv_content.setOnClickListener(View.OnClickListener(

    fun(v : View) {
        v.visibility = View.GONE
    }
))

现在可以用 Lambda 表达式进行简化

tv_content.setOnClickListener { v -> v.visibility = View.GONE }

38. 函数变量

在 Kotlin 语法中函数是可以作为变量进行传递的

var result = fun(number1 : Int, number2 : Int) : Int {
    return number1 + number2
}

使用这个函数变量

println(result(1, 2))

39. 空安全

在 Java 不强制我们处理空对象,所以常常会导致 NullPointerException 空指针出现,现在 Kotlin 对空对象进行了限定,必须在编译时处理对象是否为空的情况,不然会编译不通过

在对象不可空的情况下,可以直接使用这个对象

fun getText() : String {
    return "text"
}
val text = getText()
print(text.length)

在对象可空的情况下,必须要判断对象是否为空

fun getText() : String? {
    return null
}
val text = getText()
if (text != null) {
    print(text.length)
}
// 如果不想判断是否为空,可以直接这样,如果 text 对象为空,则会报空指针异常,一般情况下不推荐这样使用
val text = getText()
print(text!!.length)
// 还有一种更好的处理方式,如果 text 对象为空则不会报错,但是 text.length 的结果会等于 null
val text = getText()
print(text?.length)

40. 方法支持添加默认参数

在 Java 上,我们可能会为了扩展某个方法而进行多次重载

public void toast(String text) {
    toast(this, text, Toast.LENGTH_SHORT);
}

public void toast(Context context, String text) {
    toast(context, text, Toast.LENGTH_SHORT);
}

public void toast(Context context, String text, int time) {
    Toast.makeText(context, text, time).show();
}
toast("弹个窗");
toast(this, "弹个窗");
toast(this, "弹个窗", Toast.LENGTH_LONG);

但是在 Kotlin 上面,我们无需进行重载,可以直接在方法上面直接定义参数的默认值

fun toast(context : Context = this, text : String, time : Int = Toast.LENGTH_SHORT) {
    Toast.makeText(context, text, time).show()
}
toast(text = "弹个窗")
toast(this, "弹个窗")
toast(this, "弹个窗", Toast.LENGTH_LONG)

41. 类方法扩展

可以在不用继承的情况下对扩展原有类的方法,这种方式可以为很多基本数据类型添加新方法,例如对 String 类进行扩展方法

fun String.handle() : String {
    return this + "Zhangsan"
}
// 需要注意,handle 方法在哪个类中被定义,这种扩展只能在那个类里面才能使用
print("ZS = ".handle())
ZS = ZhangSan

43. 运算符重载

在 Kotlin 中使用运算符最终也会调用对象对应的方法,我们可以通过重写这些方法使得这个对象支持运算符

运算符调用方法
+aa.unaryPlus()
-aa.unaryMinus()
!aa.not()
运算符调用方法
a++a.inc()
a–a.dec()
运算符调用方法
a + ba.plus(b)
a - ba.minus(b)
a * ba.times(b)
a / ba.div(b)
a % ba.rem(b), a.mod(b) (deprecated)
a…ba.rangeTo(b)
运算符调用方法
a in bb.contains(a)
a !in b!b.contains(a)
运算符调用方法
a[i]a.get(i)
a[i, j]a.get(i, j)
a[i_1, …, i_n]a.get(i_1, …, i_n)
a[i] = ba.set(i, b)
a[i, j] = ba.set(i, j, b)
a[i_1, …, i_n] = ba.set(i_1, …, i_n, b)
运算符调用方法
a()a.invoke()
a(i)a.invoke(i)
a(i, j)a.invoke(i, j)
a(i_1, …, i_n)a.invoke(i_1, …, i_n)
运算符调用方法
a += ba.plusAssign(b)
a -= ba.minusAssign(b)
a *= ba.timesAssign(b)
a /= ba.divAssign(b)
a %= ba.remAssign(b), a.modAssign(b) (deprecated)
运算符调用方法
a == ba?.equals(b) ?: (b === null)
a != b!(a?.equals(b) ?: (b === null))
运算符调用方法
a > ba.compareTo(b) > 0
a < ba.compareTo(b) < 0
a >= ba.compareTo(b) >= 0
a <= ba.compareTo(b) <= 0

44. 扩展函数

扩展函数是 Kotlin 用于简化一些代码的书写产生的,其中有 let、with、run、apply、also 五个函数

(1) let 函数

在函数块内可以通过 it 指代该对象。返回值为函数块的最后一行或指定return表达式

一般写法

fun main() {
    val text = "CurvedBowZhang"
    println(text.length)
    val result = 1000
    println(result)
}

let 写法

fun main() {
    val result = "CurvedBowZhang".let {
        println(it.length)
        1000
    }
    println(result)
}

最常用的场景就是使用let函数处理需要针对一个可null的对象统一做判空处理

mVideoPlayer?.setVideoView(activity.course_video_view)
mVideoPlayer?.setControllerView(activity.course_video_controller_view)
mVideoPlayer?.setCurtainView(activity.course_video_curtain_view)
mVideoPlayer?.let {
   it.setVideoView(activity.course_video_view)
   it.setControllerView(activity.course_video_controller_view)
   it.setCurtainView(activity.course_video_curtain_view)
}

又或者是需要去明确一个变量所处特定的作用域范围内可以使用

(2) with 函数

前面的几个函数使用方式略有不同,因为它不是以扩展的形式存在的。它是将某对象作为函数的参数,在函数块内可以通过 this 指代该对象。返回值为函数块的最后一行或指定return表达式

定义 Person 类

class Person(var name : String, var age : Int)

一般写法

fun main() {
    var person = Person("CurvedBowZhang", 100)
    println(person.name + person.age)
    var result = 1000
    println(result)
}

with 写法

fun main() {
    var result = with(Person("CurvedBowZhang", 100)) {
        println(name + age)
        1000
    }
    println(result)
}

适用于调用同一个类的多个方法时,可以省去类名重复,直接调用类的方法即可,经常用于 Android 中RecyclerView中onBinderViewHolder中,数据 model 的属性映射到 UI 上

override fun onBindViewHolder(holder: ViewHolder, position: Int){
    val item = getItem(position)?: return
    holder.nameView.text = "姓名:${item.name}"
    holder.ageView.text = "年龄:${item.age}"
}
override fun onBindViewHolder(holder: ViewHolder, position: Int){
    val item = getItem(position)?: return
    with(item){
        holder.nameView.text = "姓名:$name"
        holder.ageView.text = "年龄:$age"
    }
}

(3) run 函数

实际上可以说是let和with两个函数的结合体,run函数只接收一个lambda函数为参数,以闭包形式返回,返回值为最后一行的值或者指定的return的表达式

一般写法

var person = Person("CurvedBowZhang", 100)
println(person.name + "+" + person.age)
var result = 1000
println(result)

run 写法

var person = Person("CurvedBowZhang", 100)
var result = person.run {
    println("$name + $age")
    1000
}
println(result)

适用于let,with函数任何场景。
因为run函数是let,with两个函数结合体,准确来说它弥补了let函数在函数体内必须使用it参数替代对象,在run函数中可以像with函数一样可以省略,直接访问实例的公有属性和方法;
另一方面它弥补了with函数传入对象判空问题,在run函数中可以像let函数一样做判空处理,这里还是借助 onBindViewHolder 案例进行简化

override fun onBindViewHolder(holder: ViewHolder, position: Int){
    val item = getItem(position)?: return
    holder.nameView.text = "姓名:${item.name}"
    holder.ageView.text = "年龄:${item.age}"
}
override fun onBindViewHolder(holder: ViewHolder, position: Int){
    val item = getItem(position)?: return
    item?.run {
        holder.nameView.text = "姓名:$name"
        holder.ageView.text = "年龄:$age"
    }
}

(4) apply 函数

从结构上来看apply函数和run函数很像,唯一不同点就是它们各自返回的值不一样,run函数是以闭包形式返回最后一行代码的值,而apply函数的返回的是传入对象的本身

一般写法

val person = Person("CurvedBowZhang", 100)
person.name = "ZJX"
person.age = 50

apply 写法

val person = Person("CurvedBowZhang", 100).apply {
    name = "ZJX"
    age = 50
}

整体作用功能和run函数很像,唯一不同点就是它返回的值是对象本身,而run函数是一个闭包形式返回,返回的是最后一行的值。正是基于这一点差异它的适用场景稍微与run函数有点不一样。
apply一般用于一个对象实例初始化的时候,需要对对象中的属性进行赋值。或者动态inflate出一个XML的View的时候需要给View绑定数据也会用到,这种情景非常常见。特别是在我们开发中会有一些数据model向View model转化实例化的过程中需要用到

mRootView = View.inflate(activity, R.layout.example_view, null)
mRootView.tv_cancel.paint.isFakeBoldText = true
mRootView.tv_confirm.paint.isFakeBoldText = true
mRootView.seek_bar.max = 10
mRootView.seek_bar.progress = 0

使用 apply 函数后的代码是这样的

mRootView = View.inflate(activity, R.layout.example_view, null).apply {
   tv_cancel.paint.isFakeBoldText = true
   tv_confirm.paint.isFakeBoldText = true
   seek_bar.max = 10
   seek_bar.progress = 0
}

多层级判空问题

if (mSectionMetaData == null || mSectionMetaData.questionnaire == null || mSectionMetaData.section == null) {
    return;
}
if (mSectionMetaData.questionnaire.userProject != null) {
    renderAnalysis();
    return;
}
if (mSectionMetaData.section != null && !mSectionMetaData.section.sectionArticles.isEmpty()) {
    fetchQuestionData();
    return;
}

kotlin的apply函数优化

mSectionMetaData?.apply {

    //mSectionMetaData不为空的时候操作mSectionMetaData

}?.questionnaire?.apply {

    //questionnaire不为空的时候操作questionnaire

}?.section?.apply {

    //section不为空的时候操作section

}?.sectionArticle?.apply {

    //sectionArticle不为空的时候操作sectionArticle

}

(5) also 函数

also函数的结构实际上和let很像唯一的区别就是返回值的不一样,let是以闭包的形式返回,返回函数体内最后一行的值,如果最后一行为空就返回一个Unit类型的默认值。而also函数返回的则是传入对象的本身

fun main() {
    val result = "CurvedBowZhang".let {
        println(it.length)
        1000
    }
    println(result) // 打印:1000
}
fun main() {
    val result = "CurvedBowZhang".also {
        println(it.length)
    }
    println(result) // 打印:CurvedBowZhang
}

适用于let函数的任何场景,also函数和let很像,只是唯一的不同点就是let函数最后的返回值是最后一行的返回值而also函数的返回值是返回当前的这个对象。一般可用于多个扩展函数链式调用

(6) 小结

通过以上几种函数的介绍,可以很方便优化 Kotlin 中代码编写,整体看起来几个函数的作用很相似,但是各自又存在着不同。使用的场景也有相同的地方,比如:run函数就是let和with的结合体。

一张图说明:
在这里插入图片描述

总结

以上这些仅仅只是 Kotlin 的一些基本使用,还有很多神奇之处和高级用法,帮助我们更加优雅地实现功能,后续我会继续补充在后面,也方便自己开发查阅。

  • 8
    点赞
  • 37
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
Python基本语法是指在Python编程语言中使用的语法规则和结构。这些语法规则包括但不限于变量声明、数据类型、运算符、条件语句、循环语句以及函数定义等。在Python中,可以使用关键字和特殊符号来实现这些语法规则。 举个例子,变量声明可以使用等号将变量名与值进行绑定,如a = 10。数据类型包括整数、浮点数、字符串、列表、元组、字典等。运算符包括算术运算符、比较运算符、逻辑运算符等。 条件语句可以使用if、elif和else关键字来进行条件判断,根据条件的不同执行相应的代码块。循环语句可以使用for和while关键字进行循环迭代,重复执行一段代码块。函数定义可以使用def关键字来定义函数,函数可以接受参数并返回结果。 总之,Python基本语法是编写Python程序所必需的语法规则和结构。通过正确使用这些语法规则,可以实现各种功能和逻辑。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* [Python基础语法合集.pdf](https://download.csdn.net/download/m0_62089210/85566584)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] - *2* *3* [Python基本语法快速入门)](https://blog.csdn.net/weixin_45867159/article/details/119205252)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

full courage

你的鼓励是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值