一、认识开发语言¶

点击开发语言排行查看2023年开发语言排行

点击开发语言从业者收入查看开发语言从业者收入占比

二、开发语言对比和擅长领域分析¶

开发语言对比说明：

JAVA
优点:跨平台性强,运行稳定,安全性高,生态系统完善。
缺点:代码量较大,开发速度慢,部署复杂,资源消耗大。
Python
优点:易学易用,代码简洁,生态系统丰富,适合快速开发。
缺点:性能较低,不适合处理大型数据和高并发场景。
Go
优点:性能卓越,支持高并发,内存管理自动化,比较适合云原生领域。
缺点:相对年轻,生态系统相对较小。
PHP
优点:易于学习,开发速度快,社区活跃,可应用于Wb开发。
缺点:性能较低,架构设计欠缺,不太适合大型项目。

开发语言应用场景说明：

JAVA
企业级应用开发
分布式系统
大规模Web应用开发
Python
科学计算和数据分析
Web开发和服务器端编程
人工智能和机器学习
自动化测试和脚本编写
Go
网络编程和分布式计算
微服务和云原生应用开发
区块链技术和加密货币开发
后台管理和高并发应用开发
PHP
动态网站和Web应用开发
内容管理系统(CMS)开发
电子商务平台和在线支付系统
社交媒体和论坛网站开发

三、理解编译型和解释型语言¶

3.1 解释型和编译型的区别¶

编译型:将源代码通过编译器转化为一个可以运行的“包”(机器码,二进制),然后在计算机上直接执行。因为机器码是计算机能够直接理解的,所以其运行速度通常比解释型语言快。

解释型:不需要编译成机器码,而是由解释器逐行解释执行程序代码。由于解释器需要动态翻译代码,所以其运行速度通常比编译型语言慢一些,但开发效率较高,更加易于调试和修改。

3.2 解释型和编译型的优缺点¶

编译型:

优点:运行速度快、执行效率高、可移植性强。
缺点:需要编译成机器码,开发和调试时间通常较长;程序在不同的平台上需要重新编译。

解释型:

优点:开发效率高、调试方便。
缺点:执行效率低、运行速度慢、可移植性弱;程序在不同的平台上需要重新安装依赖包。

四、理解变量和常量¶

4.1 变量和常量的含义¶

常量:不会被改变的值称为常量。在程序运行时,常量不会被修改。

变量:变量是可以被更改的值。在程序运行时,可以修改变量以达到不同的运行结果。

4.2 数学中的变量和常量¶

圆的面积公式是：

A=πr*2

其中：

A 表示圆的面积，
π 是圆周率，约等于 3.14159(相当于常量)
r 是圆的半径。(相当于变量)

4.3 Go和Python中的变量和常量¶

4.3.1 Go语言中定义变量和常量¶

使用了 Go 编程语言的语法，声明了一个整数变量 age，并赋予其初始值为 30。在 Go 中，变量的声明和赋值可以同时进行，也可以分开进行。

var age int=30

使用了 Go 语言的常量声明语法，声明了一个名为 pi 的常量，并赋予其值 3.14。常量在程序运行时是不可更改的。

const pi=3.14

4.3.2 Python语言中定义变量和常量¶

age=30

在这里，age 被赋予了整数值 30。在像 Python 这样的动态类型语言中，不需要显式地声明变量的类型。Python 会根据值的类型自动推断变量的类型。

PI=3.14

这里使用了类似常量的命名约定，将 PI 的值设置为 3.14。然而，需要注意的是，在 Python 中，没有真正的常量。通常，使用全大写字母的变量名来表示一个常量，并约定不修改它的值，但实际上，你仍然可以改变它的值。在实践中，程序员通过共同约定来表示不应该修改的变量，使其类似于常量。

4.4 举例说明变量和常量¶

下面进行举例说明：目前在设计一款游戏,这个游戏可以充值游戏币,进行购买装备,已知100元人民币可以兑换200个游戏币,那么此时兑换率为1:2。

其中兑换率1:2为常量，充值的人民币为变量

五、理解数据类型¶

整数(int):-1、0、1

浮点数(float):-1.1、1.1、1.2

字符串(string):zq

布尔值(bool):true、false

5.1 Go中定义不同类型的变量¶

1、定义整型变量

var i int 10

2、定义浮点数变量

var f float64 3.14

3、定义布尔值变量

var b bool true

4、定义字符串变量

var s string "hello world"

5.2 Python中定义不同类型的变量¶

1、定义整型变量

i = 10

2、定义浮点数变量

f = 3.14

3、定义布尔值变量

b = True

4、定义字符串变量

s = "hello world"

六、理解数据结构¶

6.1 数组¶

6.1.1 定义¶

数组(array):数组是一组数据元素的集合,每个元素都可以使用索引进行访问。数组的长度是固定的,一旦创建不可修改其大小。

6.1.2 使用场景¶

假如我在写一个关于饭店的程序,首先需要定义这家饭店的桌子数量和每个桌子能够容纳的人数,此时就可以定义一个数组用来表示桌子的数量和对应的容纳人数:

table cap=[2,2,4,4,8,10,10,8,4,4,2,2]

// table_cap的长度表示桌子的数量
// 每个元素的索引表示桌子的号码
// 每个元素表示该桌子可容纳的人数
// 比如table_cap[5]=10,表示第6个桌子可容纳10人

注意:计算机语言中,索引都是以0开始的!!!

6.2 切片/列表¶

6.2.1 定义¶

列表(Iist)和数组的区别是列表可以通过添加、删除或修改元素来动态地调整大小

6.2.2 使用场景¶

假如我在写一个关于饭店的程序,首先需要定义这家饭店的桌子数量和每个桌子能够容纳的人数,此时就可以定义一个数组用来表示桌子的数量和对应的容纳人数，添加一些桌子:

table cap=[2,2,4,4,8,10,10,8,4,4,2,2]
// table_cap的长度表示桌子的数量
// 每个元素的索引表示桌子的号码
// 每个元素表示该桌子可容纳的人数
// 比如table_cap[5]=10,表示第6个桌子可容纳10人
// 添加元素(添加到末尾)：table_caps.append(8)
// 删除元素(不同语言不同写法，这里展示的是python语法)：table_caps.remove(8)

注意:计算机语言中,索引都是以0开始的!!!

6.3 对象/字典¶

6.3.1 定义¶

对象(object):对象是一种复合的数据类型,可以表示为键值对。每个键值对包含一个键(key)和一个相应的值(value),用于表示某种属性或特性

6.3.2 使用场景¶

假如我在写一个关于饭店的程序,首先需要定义这家饭店的桌子数量和每个桌子能够容纳的人数,此时就可以定义一个数组用来表示桌子的数量和对应的容纳人数，需要记录每个桌子点了什么菜,以及定义菜单(这些有对应关系的，可以使用对象):

menu_items = {
  “清蒸鱼”:39,
  “糖醋鱼”:44,
  “松鼠鱼”:65
}

//查看清蒸鱼的价格
menu_items["清蒸鱼"]
//输出结果
39

6.4 数据嵌套¶

6.4.1 定义¶

数据嵌套指的是在一个数据结构中包含另一个数据结构，可以是嵌套的列表、字典、集合、对象等。具体实现方式会依赖于所使用的编程语言。

6.4.2 使用场景¶

1、嵌套列表（List）

nested_list = [1, [2, 3, [4, 5]], 6]

2、嵌套字典（Dictionary）

nested_dict = {'name': 'John', 'age': 25, 'address': {'city': 'New York', 'zip': '10001'}}

3、嵌套对象

在面向对象的语言中，可以定义一个类，并在类的属性中包含其他类的对象。

class Address:
    def __init__(self, city, zip_code):
        self.city = city
        self.zip_code = zip_code

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

john_address = Address(city='New York', zip_code='10001')
john = Person(name='John', age=25, address=john_address)

七、理解强类型语言和弱类型语言¶

编程语言分为强类型语言和弱类型语言。

强类型:编译或运行时会更严格地检查变量的类型一致性
弱类型:编译器会自动进行类型转换。

下面进行实例说明：

//强一致性(不能相加，会发生报错):
var a int = 10
var s string = “zq'
c=a+s

//弱一致性(能相加，不会发生报错)
var a = 10
Vars = “zq”
c = a + s
c = 10zq

八、理解运算符¶

8.1 算术运算符¶

8.1.1 定义¶

用来执行基本的数学计算,包括加、减、乘、除和取余操作。

8.1.2 用法¶

Go语言中的用法：

a := 10
b := 5

//相加
sum := a + b
//相减
difference := a - b
//相乘
product := a * b
//相除
quotient := a / b
//取余
remainder := a % b

Python语言中的用法：

a = 10
b = 5

#相加
sum = a + b
#相减
difference = a - b
#相乘
product = a * b
#相除
quotient = a / b
#取余
remainder = a % b

8.2 比较运算符¶

8.2.1 定义¶

用来比较两个值之间的关系,并返回一个布尔值。包括大于、小于、大于等于、小于等于、不等于、等于等等。

8.2.2 用法¶

Go语言中的用法：

a := 10
b := 5

fmt.Println(a > b)  //输出true
fmt.Println(a < b)  //输出false
fmt.Println(a >= b) //输出true
fmt.Println(a <= b) //输出false
fmt.Println(a == b) //输出false
fmt.Println(a != b) //输出true

Python语言中的用法：

a = 10
b = 5

print(a > b)  #输出True
print(a < b)  #输出False
print(a >= b) #输出True
print(a <= b) #输出False
print(a == b) #输出False
print(a != b) #输出True

8.3 逻辑运算符¶

8.3.1 定义¶

用来执行布尔逻辑运算,包括与、或和非操作。例如,与运算符会检查多个条件是否同时为真,或运算符会检查多个条件中是否有至少一个为真,而非运算符则会反转给定条件的值。

8.3.2 用法¶

Go语言中的用法：

a := true
b := false

//且
fmt.Println(a && b) //输出false
//或
fmt.Println(a || b) //输出true
//取反
fmt.Println(!a) //输出false
fmt.Println(!b) //输出true

Python语言中的用法：

a = true
b = false

#且
print(a and b) #输出False
#或
print(a or b) #输出True
#取反
print(not a) #输出False
print(not b) #输出True

九、理解逻辑控制¶

逻辑控制(Logic control)是一种编程思想,它使用条件语句、循环语句和函数等流程,以达到实现特定功能的目的。

简单来说,逻辑控制就是通过不同的条件来控制程序的运行流程,并做出不同的结果。

举个例子:设计一个身份信息,根据身份证的年龄表达该用户有没有成年。

//中文
如果小明的年龄大于18;
   小明已经成年了
否则
   小明还没有成年

//开发语言-Go
package main

import "fmt"

func main() {
    // 假设小明的年龄是一个变量，比如 age
    age := 20

    if age > 18 {
        fmt.Println("小明已经成年了")
    } else {
        fmt.Println("小明还没有成年")
    }
}

#开发语言-Python
# 假设小明的年龄是一个变量，比如 age
age = 20

if age > 18:
    print("小明已经成年了")
else:
    print("小明还没有成年")

9.1 if-else/switch(条件语句)¶

9.1.1 定义¶

if-else语句：

在许多编程语言中，if-else语句用于根据某个条件选择性地执行不同的代码块。

switch语句：

switch语句是一种多分支条件语句，它允许根据某个表达式的值选择性地执行不同的代码块。不同的编程语言对switch语句的支持和语法可能有所不同。

9.1.2 使用场景¶

1、if-else语句：

用途：

在某个条件为真时执行一组语句，否则执行另一组语句。
处理简单的条件分支逻辑。

# 示例1：根据用户输入的数字判断奇偶性
num = int(input("Enter a number: "))
if num % 2 == 0:
    print("The number is even.")
else:
    print("The number is odd.")

2、switch语句（在某些编程语言中）

用途：

处理多个可能的情况，根据表达式的值选择执行相应的代码块。
提高代码的可读性，尤其是在有多个固定的选项时。

def switch_case(case):
    switch_dict = {
        'case1': 'This is case 1',
        'case2': 'This is case 2',
        'case3': 'This is case 3',
    }
    return switch_dict.get(case, 'This is the default case')

# 示例2：使用字典实现类似switch的功能
print(switch_case('case2'))
print(switch_case('case4'))  # 使用默认值

9.2 for/while(循环语句)¶

9.2.1 定义¶

for循环：

for循环是一种重复执行一段代码块的结构，通常用于处理迭代操作。

while循环：

while循环也是用于重复执行代码块的结构，但它的执行条件是在循环开始之前进行检查。

9.2.2 使用场景¶

1、for循环

用途：

用于循环执行特定次数的代码块。
遍历集合元素。

# 示例3：使用for循环打印列表中的元素
fruits = ["apple", "banana", "orange"]
for fruit in fruits:
    print(fruit)

2、while循环

用途：

在条件为真时重复执行代码块。
适用于不确定循环次数的情况。

# 示例4：使用while循环计算数字之和，直到输入的数字为0
sum_of_numbers = 0
num = int(input("Enter a number (enter 0 to stop): "))

while num != 0:
    sum_of_numbers += num
    num = int(input("Enter another number (enter 0 to stop): "))

print(f"The sum of the numbers is: {sum_of_numbers}")

十、理解函数¶

在编程中,函数是一种可重用的代码块,它封装了一系列相同的操作成为了一个独立的一部分,这个部分可以被其他地方调用。

函数的作用在于将复杂的程序逻辑拆分成多个小块,使得程序结构更加清晰明了,易于维护和扩展。

函数封装原则:

单一职责:每个函数应该只负责一块功能,不应该做太多的事情:
可读性强:函数应该清晰易懂,遵循良好的命名规范,让其他开发人员容易理解;
可重用性强:函数应该尽可能地通用,让其可以在不同的上下文中使用。

比如想要实现一个程序,这个程序是计算长方形的面积,并打印结果。现在想要计算如下长方形的面积: 长8宽8.长4宽6,长5宽7

//封装前:
s1 = 8*8
print(面积为:s1)
s2 = 4*6
print(面积为:s2)
s3 = 5*7
print(面积为:s3)

//函数封装后:
function area(length,width){
  return length * width
}
print(面积为: area(8,8)
print(面积为: area(4,6)
print(面积为: area(5,7)

十一、理解代码风格规范¶

11.1 代码开发规范的重要性¶

代码开发规范是指遵循一定的编码风格、命名约定、注释规范等的一系列行为准则

提高代码质量:遵循代码开发规范可以使代码易于阅读、维护和共享,多人协作开发更加容易
降低维护成本:遵循代码开发规范可以让整个团队共享相同的代码写作习惯,从而减少代码维护成本
提高团队协作效率:代码开发规范可以统一团队开发标准,减少因为不同习惯带来的不必要的沟通和误解,提高团队的协作效率。

11.2 变量命名规范¶

变量命名规范:

使用有意义的名称,避免使用无意义或缩写形式进行命名,要见名知义。
变量名应该以小写字母开头,多个单词可以用下划线分隔(例如:first_name)或者使用驼峰命名法(例如:firstName),推荐使用驼峰式。
避免使用保留关键字或已经定义的函数名作为变量名。

11.3 函数命名规范¶

函数命名规范:

函数名应该描述函数的功能,使用有意义的名称,也需要是见名知义。
函数名同样应该以小写字母开头(如果需要引用，得用大写字母开头),并且使用驼峰命名法
如果函数返回布尔值,通常在函数名前加上is、has、can等前缀,例如:isValid()、hasPermission().
如果函数是一个事件处理程序,通常需要以on开头,例如:onClick()、onSubmit()。

11.4 代码注释规范¶

单行注释

package main
import "fmt"
func main(){
  //打印Hello,World!"
  fmt.Println("Hello,World!")
}

多行注释

/*
greet函数返回问候语
参数name: 用户名
参数age: 年龄
返回值: 字符串类型的问候语
*/
func greet(name string,age int)string {
  return fmt.Sprintf("你好,%s,你今年已经%d岁了吗?",name,age)
}

一、认识开发语言¶

二、开发语言对比和擅长领域分析¶

三、理解编译型和解释型语言¶

3.1 解释型和编译型的区别¶

3.2 解释型和编译型的优缺点¶

四、理解变量和常量¶

4.1 变量和常量的含义¶

4.2 数学中的变量和常量¶

4.3 Go和Python中的变量和常量¶

4.3.1 Go语言中定义变量和常量¶

4.3.2 Python语言中定义变量和常量¶

4.4 举例说明变量和常量¶

五、理解数据类型¶

5.1 Go中定义不同类型的变量¶

5.2 Python中定义不同类型的变量¶

六、理解数据结构¶

6.1 数组¶

6.1.1 定义¶

6.1.2 使用场景¶

6.2 切片/列表¶

6.2.1 定义¶

6.2.2 使用场景¶

6.3 对象/字典¶

6.3.1 定义¶

6.3.2 使用场景¶

6.4 数据嵌套¶

6.4.1 定义¶

6.4.2 使用场景¶

七、理解强类型语言和弱类型语言¶

八、理解运算符¶

8.1 算术运算符¶

8.1.1 定义¶

8.1.2 用法¶

8.2 比较运算符¶

8.2.1 定义¶

8.2.2 用法¶

8.3 逻辑运算符¶

8.3.1 定义¶

8.3.2 用法¶

九、理解逻辑控制¶

9.1 if-else/switch(条件语句)¶

9.1.1 定义¶

9.1.2 使用场景¶

9.2 for/while(循环语句)¶

9.2.1 定义¶

9.2.2 使用场景¶

十、理解函数¶

十一、理解代码风格规范¶

11.1 代码开发规范的重要性¶

11.2 变量命名规范¶

11.3 函数命名规范¶

11.4 代码注释规范¶

评论区