Python基础 VS Golang基础

1、语言类型

2、下载地址

3、环境变量

linux环境里可用which python和which go来查看路径

4、程序运行

5、语法结构

• python-1

# 系统默认提供
def  __ init__(self):
    pass

# 自定义构造函数系统将不再提供无参的构造函数

def __init__(self,*s):     #设置不定长参数
        pass

• python-2

class Parent:        # 定义父类
   def myMethod(self):
      print ('调用父类方法')
 
class Child(Parent): # 定义子类
   def myMethod(self):
      print ('调用子类方法')
 
c = Child()          # 子类实例
c.myMethod()         # 子类调用重写方法
super(Child,c).myMethod() #强制调用父类已被覆盖的方法

• python-3

type Book struct{
    author string
    age int
}

• python-4

num = 1
def fun1():
    global num  # 需要使用 global 关键字声明
    num = 123
    print(num)
fun1()     #123
print(num) #123

6、基础语法

7、数学函数

8、随机数

9、字符串

str = “abcd”
sjoin = “-”

10、数组

11、元祖（Python独有）

12、字典（Python独有）

13、集合（Python独有）

14、切片（Golang独有）

15、map集合（Golang独有）

16、条件语句

17、异常

18、正则匹配

19、迭代器与生成器（Python独有）

20、函数

21、数据结构

22、交互模块

23、文件操作

24、序列化和反序列化

25、进程、线程、协程

• python-1

#1、apply（同步），等待函数执行完毕后释放进程
#2、apply_async（异步），不需要等待函数执行完毕，只要函数接收就释放进程
from  multiprocessing import Process,Pool
import time

def Foo(i):
    time.sleep(1)
    return i*2

def Bar(arg):
    print('current number::',arg)

if __name__ == "__main__":
    pool = Pool(3)#定义一个进程池，里面有3个进程
    for i in range(10):
        #callback是回调函数，就是在执行完Foo方法后会自动执行Bar函数，并且自动把Foo函数的返回值作为参数传入Bar函数
        pool.apply_async(func=Foo, args=(i,),callback=Bar)
        #pool.apply(func=Foo, args=(i,))

    pool.close()#关闭进程池
    pool.join()#进程池中进程执行完毕后再关闭,(必须先close在join)

• python-2

import threading
import time

def hello(name):
    print("Hello %s"%name)
    time.sleep(3)
    
def hi(name):
    print("Hello %s"%name)
    time.sleep(3)

if __name__ == "__main__":
    t1=threading.Thread(target=hello,args=("amber",)) #生成线程实例
    t2=threading.Thread(target=hi,args=("paige",))

    t1.setName("aaa")   #设置线程名
    t1.setDaemon(True) #设置为守护线程，当主线程结束后，t1线程也随之终止，要在start前设置

    t1.start()  #启动线程
    t2.start()
    t2.join()   #join主线程阻塞等待t2先执行完
    print(t1.getName()) #获取线程名

• python-3

import gevent
import time

def one():
    print('11')
    time.sleep(3)
    print('22')

def two():
    print('33')
    print('44')

gevent.joinall([
    gevent.spawn(one),
    gevent.spawn(two),
])
#输出结果，并发执行
11
33
44
22

• golang-3
  
  在Go中有一种特殊的类型channle通道，可以通过它来进行goroutine之间的通信，channel的通信保证了同步性。同一时间只有一个协程可以访问数据，所以不会出现数据竞争

//无缓冲
//需要发送方和接收方同时准备好，不然发送方会一直阻塞，直到数据被接收方处理；接收方阻塞直到数据进来，不会保存数据
buffer := make(chan string)

buffer2 := make(chan string, 0)

//带缓冲
//如果缓冲区已满，发送方的主进程或者协程会被阻塞，发送方只能在接收方取走数据后才能从阻塞状态恢复;如果为空，接收方的协程会被阻塞
buffer3 := make(chan string, 4)

//select监听channel
//如果有多个channel接收数据，select会随机选择一个case来处理，没有case需要处理，select会阻塞，可配合超时时间一并处理

package main

import (
	"fmt"
	"time"
)

func main() {
	buffer := make(chan string, 1)
	go func() {
		time.Sleep(time.Second * 3)
		chan1 <- "res"
	}()

	select {
	case res := <-chan1:   //3秒之后才会有数据进入槽chan1
		fmt.Println(res)
	case <-time.After(time.Second * 1)://定义超时情况，1秒后超时.这个超时时间比上面的case短，所以先运行这个case
		fmt.Println("timeout 1 second")
	}
}

// channel关闭
//close()掉了，你继续往里面写数据，会出现panic
buf := make(chan int, 10)
close(buf)
buf <- "res"  //panic

//channel状态
buf := make(chan int, 10)
buf <- "res"
close(buf)
i, ok := <-buf
fmt.Printf("%d, %t", i, ok) //0, false

26、OS模块

27、连接mysql

28、网络编程

• python服务端

from socket import *
import time

COD = 'utf-8'
HOST = '192.168.1.1' # 主机ip
PORT = 8080 # 软件端口号
BUFSIZ = 1024
ADDR = (HOST, PORT)
SIZE = 10 
tcpS = socket(AF_INET, SOCK_STREAM) # 创建socket对象
tcpS.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #加入socket配置，重用ip和端口
tcpS.bind(ADDR) # 绑定ip端口号
tcpS.listen(SIZE)  # 设置最大链接数
while True:
    print("服务器启动，监听客户端链接")
    conn, addr = tcpS.accept() 
    print("链接的客户端", addr)
    while True:
        try:
            data = conn.recv(BUFSIZ) # 读取已链接客户的发送的消息
        except Exception:
            print("断开的客户端", addr)
            break
        print("客户端发送的内容:",data.decode(COD))
        if not data:
            break
        msg = time.strftime("%Y-%m-%d %X") #获取结构化事件戳
        msg1 = '[%s]:%s' % (msg, data.decode(COD))
        conn.send(msg1.encode(COD)) #发送消息给已链接客户端
    conn.close() #关闭客户端链接
tcpS.closel()

• python客户端

from socket import *

HOST = '192.168.1.1' #服务端ip
PORT = 8080 #服务端端口号
BUFSIZ = 1024
ADDR = (HOST, PORT)
tcpCliSock = socket(AF_INET, SOCK_STREAM) #创建socket对象
tcpCliSock.connect(ADDR) #连接服务器
while True:
    data = input('>>').strip()
    if not data:
        break
    tcpCliSock.send(data.encode('utf-8')) #发送消息
    data = tcpCliSock.recv(BUFSIZ) #读取消息
    if not data:
        break
    print(data.decode('utf-8'))
tcpCliSock.close() #关闭客户端

• golang服务端

func main() {
    listen, err := net.Listen("tcp","127.0.0.1:2000") //监听2000端口
    if err != nil {
        fmt.Println("listen failed, err:", err)
        return
    }
    for {
        conn, err := listen.Accept() // 建立连接
        if err != nil {
            fmt.Println("accept failed, err:", err)
            continue
        }
        go process(conn) // 启动一个goroutine处理连接
    }
}

// 读取数据
func process(conn net.Conn) {
    defer conn.Close() // 关闭连接
    for {
        reader := bufio.NewReader(conn)
        var buf [128]byte
        n, err := reader.Read(buf[:]) // 读取conn链接中数据
        if err != nil {
            fmt.Println("read from client failed, err:", err)
            break
        }
        recvStr := string(buf[:n])
        fmt.Println("收到client端发来的数据：", recvStr)
        conn.Write([]byte(recvStr)) // 发送数据
    }
}

• golang客户端

func main() {
    conn, err := net.Dial("tcp", "127.0.0.1:2000") //连接服务端2000端口
    if err != nil {
        fmt.Println("err :", err)
        return
    }
    defer conn.Close() // 关闭连接
    inputReader := bufio.NewReader(os.Stdin)
    for {
        input, _ := inputReader.ReadString('\n') // 读取用户输入
        inputInfo := strings.Trim(input, "\r\n")
        if strings.ToUpper(inputInfo) == "QUIT" { // 如果输入q就退出
            return
        }
        _, err = conn.Write([]byte(inputInfo)) // 发送数据
        if err != nil {
            return
        }
        buf := [512]byte{}
        n, err := conn.Read(buf[:])
        if err != nil {
            fmt.Println("recv failed, err:", err)
            return
        }
        fmt.Println(string(buf[:n]))
    }
}

29、时间和日期

30、总结

转载：https://blog.csdn.net/ambzheng/article/details/114484837