kotlin 基础

文章目录

      • 1、安装 Java 和 Kotlin 环境
      • 2、程序代码基本结构
      • 3、变量的声明与使用
      • 4、数据类型
      • 5、数字类型的运算
        • 1）布尔类型
        • 2）字符类型
        • 3）字符串类型
      • 6、 选择结构
        • 1)（if - else）
        • 2） 选择结构（when）——适用于多分支结构
      • 7、循环结构
        • 1）for
        • 2）循环结构——while
      • 8、函数的定义及使用
        • 1）用 fun 关键字声明
        • 2）函数的调用
        • 3）有参数的函数
        • 4）有返回值的函数
        • 5）全局变量
        • 6）函数类型变量
          • 1 变量可以接收函数
          • 2 函数也可以接收函数
          • 3 总结
      • 9、类与对象
        • 1） 类的定义与对象的创建
        • 2) 对象的创建
        • 3）对象的初始化
        • 4）类的成员函数
        • 5) 再谈基本类型
          • a、空值和空类型
        • 6）修饰符
        • 7）封装
        • 8）继承
        • 9）属性的覆盖——多态
        • 10）接口
      • 10、数组的创建与使用
      • 11、集合类
        • 1）数组局限性
        • 2）集合的分类
        • 3）集合简介

1、安装 Java 和 Kotlin 环境

2、程序代码基本结构

fun main(args: Array<String>) {println("Hello World!")
}
  • 注意点：Kotlin 严格区分大小写

3、变量的声明与使用

fun main(args: Array<String>) {var x = 30println(x)
}// 自动判断变量类型
fun main(args: Array<String>) {var x = 30println(x)
}// 变量值赋值给变量
fun main(args: Array<String>) {var x = 30var y = xprintln(y)
}fun main(args: Array<String>) {var x = 30var y = x / 30println(y)
}fun main(args: Array<String>) {var x = 30var y = 70println(x + y)
}fun main(args: Array<String>) {var x = 30x = 20println(x)
}// 定义常量
fun main(args: Array<String>) {val x = 30  // 常量println(x)
}

4、数据类型

  • Byte、Short、Int、Long
  • Float、Double
val pi = 3.1415 // 默认推断为 Double 类型
val one : Double = 1  // 这种写法错误，无法编译通过
val one : Double = 1.0 // 这种写法是对的
val a : Float = 1.0f
  • 与其他语言不同，Kotlin 中的数字类型没有隐式转换的操作
var a:Int = 1;
var b:Double = a;  // 报错，不能隐式转换

5、数字类型的运算

1）布尔类型
var a: Boolean = false
2）字符类型
var c: Char = 'D'
3）字符串类型
    // 字符串中的字符一旦确定是无法进行修改的var str: String = "Hello World"str = "Helle World"  // 整体修改val text = "Hello\nWorld"  // 字符串中换行，需要用到转义字符

6、 选择结构

1)（if - else）
if 
if {}if {
} else {
}if
else if 
else if 
else if {if }// if-else 还可以用作结果判断
var score = 2
var res = if (score > 60) "Yes" else "NO"
2） 选择结构（when）——适用于多分支结构
//代码结构
when (目标) {匹配值1 -> 代码匹配值2 -> 代码匹配值3 -> 代码else -> {  // 可以没有else语句，类似于之前的 if-else if-else代码  // 如果以上条件都不满足，就进入else中}
}

val c = 'A'
when (c) {'A' -> println("尖子班")'B' -> println("中等班")'C' -> println("普通班")
}val c = 'A'
var value = when (c) {'A' -> 1'B' -> 2'C' -> 3else -> 0  // 要把所有能表示的情况都写完才不会报错（必加）
}val c : Boolean = true
var value = when (c) {true -> 1false -> 2  // 所有情况中只有这两种情况所以不用加else 
}// 某些值属于同一种情况，可以使用逗号将其条件组成一行
var x = 0;
when (x) {0, 1 -> print("x == 0 or x == 1")else -> print("otherwise")
}// in 表示区间
var score = 10;
var grade= when (score) {// 使用 in 判断目标标量值是否在指定范围in 100 .. 90 -> {println();"优秀"}in 89 .. 80 -> "良好"in 79 .. 70 -> "及格"else -> "不及格"
}

7、循环结构

1）for
// 结构
for (遍历出来的单个目标 in 可遍历目标) 循环体
  • 可遍历目标
    • 数组
    • 区间
    • 任何实现了运算符重载函数iterator的类
// 可遍历目标为区间
for (i in 1..3)println(i)val range: IntRange = 1..3
for (i in range)println(i)val range: IntRange = 1..3
var x = 0
for (i in range) {  // i 的作用范围只在括号中println(i)x = i
}

// for 循环的嵌套
for (i in 0..2) {for (j in 0..2) {println("外层 $i，内层$j")}
}
2）循环结构——while
while (循环条件) 循环体

8、函数的定义及使用

1）用 fun 关键字声明
fun 函数名称([函数参数...]): 返回类型 {// 函数体
}

// 无返回值的两种写法
fun test(): Unit {  // 返回值类型为Unit类比于其他语言中的void}fun text() {}
2）函数的调用
fun main() {test()
}
3）有参数的函数
fun text(m: String) {  // m为参数名字，String为参数类型println(m)
}
4）有返回值的函数
fun text(a: Int, b: Int) : Int{  // a,b为参数，Int 为返回值类型return a + b
}// return 关键字在执行之后，后面的内容就不能继续执行了
fun text(a: Int, b: Int) : Int{  // a,b为参数，Int 为返回值类型if (a + b > 10) return 10println("后面的函数")return a + b
}fun main(args: Array<String>) {test()  // 参数有默认值之后可以不传入实参
}   
fun test(m: String = "HelloWorld") {println(m)
}fun main(args: Array<String>) {test("Hi")  // 传入值则形参为传入的值
}
fun test(m: String = "HelloWorld") {println(m)
}fun sum(a: Int, b: Int): Int = a + b
fun sum(a: Int, b: Int) = a + b
5）全局变量
var a: Int = 10fun main(args: Array<String>) {println(a)
}fun test() {a = 20println(a)
}

var a: Int = 5get() = field + 10  // field代表变量a本身fun main(args: Array<String>) {println(a)  // 此时打印出来的是15
}fun test() {a = 20println(a)
}

// 变脸中get和set属性
// get 和 set 函数操作的就是本身变量的值
var a: Int = 5get() = field + 10  // field代表变量a本身set(value) {  // value是赋值过来的参数println("我被赋值了")field = value}fun main(args: Array<String>) {a = 90println(a)  // 此时打印出来的是15
}
6）函数类型变量
1 变量可以接收函数
// 接收String作为参数返回值为Int的函数类型var func: (String) -> Int   // (String) -> Int：String作为参数，返回值为Int的函数给变量func存储
2 函数也可以接收函数
fun test(func: (String) -> Int) {  // 形参可以为函数类型的参数}fun test(other: (Int) -> String) {println(other(1))  // 
}
3 总结
  • 函数类型的变量可以当作函数使用
  • 函数类型的变量也可以作为函数参数进行传递

9、类与对象

  • 类是一个抽象的概念，对象指具体的
1） 类的定义与对象的创建
  • 类的声明使用关键字 class 声明
class Student {
}
  • kotlin 中的类可以添加一个主构造函数和一个或多个次要构造函数，主构造函数是类定义的一部分
class Student constructor(name: String, age: Int) {  // 主构造函数的形参}// 主构造函数中的constructor也可以省去
class Student (name: String, age: Int) {}// 将构造函数的 参数变成类的属性，在变量前面添加 var或者 val
class Student (var name: String, var age: Int) {}// 属性写在类里面的时候，必须要求有初始值
class Student () {var name: String = ""val age: Int = 8
}class Student (name: String, age: Int) {  // 将传进来的参数赋值给属性var name: String = nameval age: Int = age
}
2) 对象的创建
  • 对象的创建就是通过构造函数，调用构造函数
// 引用赋值
fun main(args: Array<String>) {var p1 = Student("小明", 18)var p2 = p1  // 引用赋值，指向的是同一个对象println(p2.name)  // p2也就可以操控对象
}fun main(args: Array<String>) {var p1 = Student("小明", 18)  // 通过构造函数创建对象var p2 = p1  // 引用赋值println(p2 == p1)  // 判断p1和p2是否指向的是同一个对象，输出结果为true
}fun main(args: Array<String>) {var p1 = Student("小明", 18)var p2 = Student("小红", 19)println(p2 == p1)  // p1和p2指向的是两个不同的对象，输出结果为false
}fun main(args: Array<String>) {var p1 = Student("小明", 18)var p2 = Student("小明", 18)println(p2 == p1)  // 输出为false，通过构造函数创建出来的就是一个独立的对象
}class Student (name: String, a	ge: Int) {  // 将传进来的参数赋值给属性var name: String = nameval age: Int = age
}
3）对象的初始化
  • 在对象创建时，我们可能需要做一些初始化工作，可以使用初始化代码块来完成，初始化代码块使用init关键字来完成，Init 函数在创建对象的时候会自动执行；
  • 例如，我们希望对象在创建时，如果年龄不足18岁，那么就设定为18岁
  • 这样在创建对象的时候，就会在创建的时候自动执行初始化代码块里面的代码了
fun main(args: Array<String>) {var stu = Student("小明", 9)}class Student (var name: String, var age: Int) {// 可以定义多个init，执行顺序为从上往下依次执行init {println("我是初始化操作")if (age < 18) age = 18println(age)println("初始化操作结束")}init {}
}
4）类的成员函数
  • 如果函数中的变量存在歧义，那么优先使用作用于最近的一个，比如函数形参的 name 作用域更近，那么这里的 name 拿到的一个是形参 name，而不是类的成员属性 name
  • 如果我们要获取的是类中的成员属性，需要使用 this 关键字来表示当前类
  • 默认情况下，如果作用域不冲突，使用类中属性 this 可以省略
fun main(args: Array<String>) {var stu = Student("小明", 19)stu.hello()
}class Student (var name: String, var age: Int) {fun hello() {println("大家好啊")}
}// 默认变量指代的就是离它最近的
class Student (var name: String, var age: Int) {fun hello(name: String) {println("大家好啊，我叫$name")  // 指代的是hello中的参数name// 使用 this 关键字表示当前对象，这样就可以指定这里是类中this中的name 属性了println("大家好啊，我叫${this.name}") // 指代的是类中属性name}
}

在类中，同样可以定义多个同名但是不同参数的函数实现重载

class Student(var name: String, var age: Int) {fun hello() = println("大家好，我叫 ${this.name}，今年${age}岁")fun hello(gender: String) = println("大家好，我叫 ${this.name}，今年 ${age} 岁，性别 ${gender}")
}
5) 再谈基本类型
  • Kotlin 中万物皆对象，所有变量存储的都是对象的引用
fun main(args: Array<String>) {val a: Int = 10  // Int类型的对象，值为10，而a持有的是对这个Int对象的引用val b: Double = a.toDouble()
}

fun main(args: Array<String>) {val a: Int = 10  // Int类型的对象，值为10，而a持有的是对这个Int对象的引用val b: Int = 5val c: Double = b / a.toDouble()  // 结果为0.5
}fun main(args: Array<String>) {val str: String = "10"str.length()str.toInt()
}
a、空值和空类型
  • 所有的变量除了引用一个具体的值以外，还有一种特殊的值可以使用，就是 null，它代表空值，即不引用任何对象
  • 所有的类型默认都是非空类型，非空类型的变量是不允许被赋值为 null，这直接在编译阶段就避免了其他语言中经常存在的空指针问题
fun main(args: Array<String>) {val stu: Student = null //报错
}
  • 希望某个变量在初始化情况下使用 null，而不是去引用某个具体的对象，将变量的类型修改为可空类型，只需要再类型名的后面添加一个 ? 即可
val stu: Student? = null // 正确，加了?号之后就可以为空了，不代表任何对象
6）修饰符
  • private、internal、public
7）封装
class Student(private var name: String, private var age: Int) {fun getName(): String = namefun getAge(): Int = agefun setName(name: String) {if (name.contains("刚")) returnthis.name = name}
}
8）继承
  • Kotlin 中类是 终态的（不能被任何类继承），要使类可继承，需要用关键字 open 标记需要被继承的类
open class Student { // 可以被继承，可作为父类}class ArtStudent: Student() {  // 以调用主构造函数的形式进行声明，这个类就是Student的子类}
  • 当一个类继承另一个类时，属性会被继承，可以直接访问父类中定义的属性，除非父类中将属性的访问权限修改为 private，那么子类将无法访问
open class Student { // 可以被继承，可作为父类var name: String = "小明"fun hello() = println("大家好，我叫 $name")
}class ArtStudent: Student() {  // 以调用主构造函数的形式进行声明，这个类就是Student的子类fun test() {name  // 可以直接访问父类中的属性hello()  // 可以直接访问父类中的方法}
}
9）属性的覆盖——多态
  • 子类重写父类定义的内容
  • 有些时候，我们可以子类继承父类的某些属性，，但是我们可能希望去修改这些属性的默认实现，可以使用 override 关键字来表示对一个属性的重写（覆盖）
fun main() {var student = ArtStudent()student.hello()}open class Student { // 可以被继承，可作为父类open fun hello() = println("我会打招呼")
}class ArtStudent: Student() {  // 以调用主构造函数的形式进行声明，这个类就是Student的子类fun draw() = println("我会画画")override fun hello() {// 在子类中编写一个同名函数，并添加override关键字，就可以在子类中进行覆盖了，然后编写自己的实现println("我会画画")super.hello()  // 可以执行父类的}
}class MusicStudent: Student() {override fun hello() = println("我会唱歌")
}
10）接口
  • 定义一些所具备的功能
interface A {val x: String // 接口中所有属性默认都是abstract的（所以可省略abstract关键字）fun sleep()  // 接口中所有函数默认都是abstract的（所以可省略abstract关键字）
}interface B {fun game()
}// 用类去实现接口中的功能
// Student 实现了A和B接口，证明同时具有了A和B中的功能
class Student: A, B {  // 接口的实现和类的继承一样，直接写到后面，多个接口用逗号隔开override val x: String = "测试"  // 跟抽象类一样，接口中的内容是必须要实现的override fun game() = println("玩游戏")override fun sleep()  = println("睡觉")
}

10、数组的创建与使用

  • 存放一组相同类型的数据
  • 在kotlin中，数组是Array类型的对象
  • 在 Kotlin 中创建数组有两种创建方式：1）官方预设工具函数：arrayOf()、arrayOfNulls() 以及 emptyArray()
  • 使用类 Array 构造函数创建
val array: Array<Int> = arrayOf(7, 3, 9, 1, 6)  // 直接在arrayOf函数中添加每个元素

  • 注意：数组在创建完成后，数组容量和元素类型是固定不变的，后续无法进行修改

  • 数组元素的访问和修改

val array: Array<Int> = arrayOf(7, 3, 9, 1, 6)  // 直接在arrayOf函数中添加每个元素
println(array[0])
array[0] = 2val array: Array<Int> = arrayOf(7, 3, 9, 1, 6)  // 直接在arrayOf函数中添加每个元素
for (i in 0 until array.size) {  // 方式1println(array[i])
}for (element in array) {  // 方式2println(element)
}
  • 数组中的操作
val array1: Array<Int> = arrayOf(1, 2, 3, 4, 5)
val array2: Array<Int> = arrayOf(1, 2, 3, 4, 5)
val array3 = array1println(array1 == array2)  // 结果为false，比较是否是两个同一个对象
println(array1 == array3)  // 结果为true，因为比较的是两个相同的对象// 比较两个数组中的内容是否相同
println(array1.contentEquals(array2))  // 结果为true，两者内容相同

11、集合类

1）数组局限性
  • 长度是固定的，无法扩展 ；
  • 无法做到在数组中像列表那样进行插入和删除元素；
2）集合的分类
  • List：有序的集合，通过索引访问元素，可以包含重复元素
  • Set：不包含重复元素的集合，一般情况下不维护元素顺序
  • Map：是一组键值对，其中每个键不可重复存在，每个键都映射到恰好一个值（值可以重复存在）
  • 所有集合类都是继承自 Collection 接口（Map 除外）
3）集合简介
  • List：可以自由地在某个位置插入或删除一个元素，列表的长度也会动态发生变化
// 创建一个 listval list: MutableList<Int> = mutableListOf(1, 2, 3, 4, 5)  // 创建可变集合// 支持所有数组的操作list[0] = 10println(list)  // 格式化地打印println(list.get(1))  // 取数据list.add(9)  // 在末尾添加一个新元素list.add(1, 10)  // 在下标为1处，添加元素10，可插入范围只能是[0, size]这个闭区间内
  • Set 集合
// 创建一个Set集合
val set: Set<String> = mutableSetOf("AA", "BB", "BB", "CC")
println(set)  // 因为set中不允许出现重复元素，结果为 [AA, BB, CC]
  • Map
// 创建一个 Map
val map: MutableMap<Int, Student> = mutableMapOf(10001 to Student("小明", 18),10002 to Student("小红", 17),10003 ti Student("小刚", 16)
)

val student: Student? = map[10001]  // 使用[]运算符通过Key查找value
val student1: Student? = map[10001]  // 得到小明这个对象
val student2: Student? = map[10005]  // Map 中根本没有键为10005的键值对，所以得到结果为null

map.contains(1)  // 判断是否包含指定Key
map.containKey(1)  // 同上
10001 in map  // 同上map.containsValue(Student("小明", 18))  // 判断是否包含Value

val keys: MutableSet<Int> = map.keys   //以Set形式存储的[10001, 10002, 10003]
val value: Collection<Student> = map.values

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/diannao/42400.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

useImperativeHandle浅谈

useImperativeHandle浅谈

useImperativeHandle 是 React Hooks 提供的一个高级功能&#xff0c;它允许你在函数式组件中自定义并暴露特定的实例值或方法给父组件。主要的作用是&#xff1a; 自定义对外暴露的实例值或方法: 通常情况下&#xff0c;函数式组件内部的实例值或方法对外是不可见的&#xff0…
阅读更多...
如何有效管理你的Facebook时间线？

如何有效管理你的Facebook时间线？

Facebook作为全球最大的社交平台之一&#xff0c;每天都有大量的信息和内容在用户的时间线上展示。有效管理你的Facebook时间线&#xff0c;不仅可以提升用户体验&#xff0c;还能够帮助你更好地控制信息流和社交互动。本文将探讨多种方法和技巧&#xff0c;帮助你有效管理个人…
阅读更多...
分班结果老师怎么发给家长？

分班结果老师怎么发给家长？

分班结果老师怎么发给家长&#xff1f; 随着新学期的脚步渐近&#xff0c;老师们的工作也变得愈发繁忙。从准备教学计划到整理课程材料&#xff0c;每一项任务都不容小觑。而其中&#xff0c;分班结果的告知工作&#xff0c;更是让不少老师头疼不已。传统的分班通知方式&#…
阅读更多...
7、Redis主从复制过程

7、Redis主从复制过程

Redis主从复制过程 ​ 当一个Redis节点&#xff08;Slave节点&#xff09;接受到类似slaveof 127.0.0.1 6380的指令直到其可以从master持续复制数据&#xff0c;大致经历如下过程&#xff1a; 1、保存master地址 ​ 当slave接收到slaveof命令后&#xff0c;slave会立即将新的…
阅读更多...
Python爬虫与数据可视化：构建完整的数据采集与分析流程

Python爬虫与数据可视化：构建完整的数据采集与分析流程

Python爬虫技术概述 Python爬虫是一种自动化的数据采集工具&#xff0c;它可以模拟浏览器行为&#xff0c;访问网页并提取所需信息。Python爬虫的实现通常涉及以下几个步骤&#xff1a; 发送网页请求&#xff1a;使用requests库向目标网站发送HTTP请求。获取网页内容&#xf…
阅读更多...
.gitignore 的奥秘：前端开发者必须了解的文件忽略规则（二）.gitignore 匹配规则

.gitignore 的奥秘：前端开发者必须了解的文件忽略规则（二）.gitignore 匹配规则

.gitignore 匹配规则 Git 版本管理在开发中场景&#xff0c;其中.gitignore也是Git中必不可少的配置文件&#xff0c;.gitignore 文件用于告诉 Git 哪些文件或目录应该被忽略&#xff0c;即不被版本控制系统跟踪和提交。 系列文章&#xff0c;上一篇介绍了&#xff1a;.gitigno…
阅读更多...
Python 如何批量压缩PDF文件或减小PDF文件大小

Python 如何批量压缩PDF文件或减小PDF文件大小

目录 安装Python PDF库 Python通过压缩图片来减小PDF文件大小 Python通过压缩字体或取消嵌入字体来减小PDF文件大小 Python通过删除不必要的内容如附件、注释或表单来减小PDF文件大小 总结 PDF文件凭借其平台无关性和便携性&#xff0c;已经成为日常办公和信息共享的首选格…
阅读更多...
15集终于编译成功了-了个球！编译TFLite Micro语音识别工程-《MCU嵌入式AI开发笔记》

15集终于编译成功了-了个球！编译TFLite Micro语音识别工程-《MCU嵌入式AI开发笔记》

15集终于编译成功了-个球&#xff01;编译TFLite Micro语音识别工程-《MCU嵌入式AI开发笔记》 还是参考这个官方文档&#xff1a; https://codelabs.developers.google.cn/codelabs/sparkfun-tensorflow#2 全是干货&#xff01; 这里面提到的这个Micro工程已经移开了&#xff1…
阅读更多...
【微服务】springboot对接Prometheus指标监控使用详解

【微服务】springboot对接Prometheus指标监控使用详解

目录 一、前言 二、微服务监控概述 2.1 微服务常用监控指标 2.2 微服务常用指标监控工具 2.3 微服务使用Prometheus监控优势 三、环境准备 3.1 部署Prometheus服务 3.2 部署Grafana 服务 3.3 提前搭建springboot工程 3.3.1 引入基础依赖 3.3.2 配置Actuator 端点 3.…
阅读更多...
【Linux】信号的处理

【Linux】信号的处理

你很自由 充满了无限可能 这是很棒的事 我衷心祈祷你可以相信自己 无悔地燃烧自己的人生 -- 东野圭吾 《解忧杂货店》 信号的处理 1 信号的处理2 内核态 VS 用户态3 键盘输入数据的过程4 如何理解OS如何正常的运行5 如何进行信号捕捉信号处理的总结6 可重入函数volatile关…
阅读更多...
C# 如何获取属性的displayName的3种方式

C# 如何获取属性的displayName的3种方式

文章目录 1. 使用特性直接访问2. 使用GetCustomAttribute()方法通过反射获取3. 使用LINQ查询总结和比较 在C#中&#xff0c;获取属性的displayName可以通过多种方式实现&#xff0c;包括使用特性、反射和LINQ。下面我将分别展示每种方法&#xff0c;并提供具体的示例代码。 1.…
阅读更多...
数据库逆向工程工具reverse_sql

数据库逆向工程工具reverse_sql

reverse_sql 是一个用于解析和转换 MySQL 二进制日志&#xff08;binlog&#xff09;的工具。它可以将二进制日志文件中记录的数据库更改操作&#xff08;如插入、更新、删除&#xff09;转换为反向的 SQL 语句&#xff0c;以便对系统或人为产生的误操作进行数据回滚和恢复。 *…
阅读更多...
JVM专题之垃圾收集器

JVM专题之垃圾收集器

JVM参数 3.1.1 标准参数 -version -help -server -cp 3.1.2 -X参数 非标准参数，也就是在JDK各个版本中可能会变动 ``` -Xint 解释执行 -Xcomp 第一次使用就编译成本地代码 -Xmixed 混合模式，JVM自己来决定 3.1.3 -XX参数 > 使用得最多的参数类型 > > 非…
阅读更多...
RedHat运维-Linux文本操作基础-牛客AWK

RedHat运维-Linux文本操作基础-牛客AWK

1. 查看static这个连接文件是否自动连接的命令是____________________________________&#xff1b; 2. 查看default这个连接文件是否自动连接的命令是_____________________________________&#xff1b; 3. 查看con0这个连接文件是否自动连接的命令是_______________________…
阅读更多...
【Python】已解决：（paddleocr导包报错）ModuleNotFoundError: No module named ‘paddle’

【Python】已解决：（paddleocr导包报错）ModuleNotFoundError: No module named ‘paddle’

文章目录 一、分析问题背景二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项 已解决&#xff1a;&#xff08;paddleocr导包报错&#xff09;ModuleNotFoundError: No module named ‘paddle’ 一、分析问题背景 近日&#xff0c;一些使用PaddleOCR库进行文字…
阅读更多...
Python数据分析案例49——基于机器学习的垃圾邮件分类系统构建(朴素贝叶斯，支持向量机)

Python数据分析案例49——基于机器学习的垃圾邮件分类系统构建(朴素贝叶斯，支持向量机)

案例背景 trec06c是非常经典的邮件分类的数据&#xff0c;还是难能可贵的中文数据集。 这个数据集从一堆txt压缩包里面提取出来整理为excel文件还真不容不易&#xff0c;肯定要做一下文本分类。 虽然现在文本分类基本都是深度学习了&#xff0c;但是传统的机器学习也能做。本案…
阅读更多...
C#架构师的成长之路

C#架构师的成长之路

成为一名C#架构师不仅需要深厚的技术功底&#xff0c;还需要广泛的行业知识、优秀的团队协作能力和领导力。以下是C#架构师成长之路上的关键步骤和技能要求&#xff1a; 1. 扎实的技术基础 精通C#语言&#xff1a;深入理解C#的语法、特性&#xff0c;包括但不限于泛型、多线程…
阅读更多...
Xilinx FPGA:vivado关于真双端口的串口传输数据的实验

Xilinx FPGA:vivado关于真双端口的串口传输数据的实验

一、实验内容 用一个真双端RAM&#xff0c;端口A和端口B同时向RAM里写入数据0-99&#xff0c;A端口读出单数并存入单端口RAM1中&#xff0c;B端口读出双数并存入但端口RAM2中&#xff0c;当检测到按键1到来时将RAM1中的单数读出显示到PC端&#xff0c;当检测到按键2到来时&…
阅读更多...
Vim编辑器与Shell命令脚本

Vim编辑器与Shell命令脚本

前言&#xff1a;本博客仅作记录学习使用&#xff0c;部分图片出自网络&#xff0c;如有侵犯您的权益&#xff0c;请联系删除 目录 一、Vim文本编辑器 二、编写Shell脚本 三、流程控制语句 四、计划任务服务程序 致谢 一、Vim文本编辑器 “在Linux系统中一切都是文件&am…
阅读更多...
Rust 程序设计语言学习——函数式语言功能：迭代器和闭包

Rust 程序设计语言学习——函数式语言功能：迭代器和闭包

Rust 的闭包&#xff08;closures&#xff09;是可以保存在一个变量中或作为参数传递给其他函数的匿名函数。可以在一个地方创建闭包&#xff0c;然后在不同的上下文中执行闭包运算。不同于函数&#xff0c;闭包允许捕获被定义时所在作用域中的值。 迭代器&#xff08;iterato…
阅读更多...
最新文章

Copyright @ 2022~2023