go build

go install

go run

// wincmd SET, macos export
export CGO_ENABLED=0	//禁用CGO
export GOOS=linux	//设置目标平台linux,windows,darwin
export GOARCH=amd64//目标处理器架构是amd64
go build

export CGO_ENABLED=0 GOOS=linux GOARCH=amd64
go build

var 变量名 类型 = 表达式
var name string = "Q1mi"
var age int = 18
var name, age = "Q1mi", 20	//会根据值推导类型
var (
    a string
    b int
    c bool
    d float32
)

	n := 10
	m := 200
	fmt.Println(m, n)

fmt.Print()
fmt.Printf()
fmt.Println() //换行

var studentName string

x, _ = foo()
_, y = foo()

const pi = 3.14

const (
  n1 = iota //0
  n2	//1
  n3	//2
  n4	//3
)

const (
  n1 = iota //0
  n2	//1
  _	//2 但是被丢弃
  n3	//3
)

const (
  _ = iota
  KB = 1 << (10 * iota)
  MB = 1 << (10 * iota)
  GB = 1 << (10 * iota)
  TB = 1 << (10 * iota)
  PB = 1 << (10 * iota)
)

	// 十进制
	var a int = 10
	fmt.Printf("%d \n", a)  // 10
	fmt.Printf("%b \n", a)  // 1010  占位符%b表示二进制
 
	// 八进制  以0开头
	var b int = 077
	fmt.Printf("%o \n", b)  // 77
 
	// 十六进制  以0x开头
	var c int = 0xff
	fmt.Printf("%x \n", c)  // ff
	fmt.Printf("%X \n", c)  // FF
	fmt.Printf("%T \n", c)  // 输出类型
	fmt.Printf("%v \n", c)  // 输出变量值，任意类型

math.MaxFloat64 // float64最大值

// 在win中路径转义
s := "D:\\Documents\\A"

// 反引号原样输出, 多行字符串
s := `
asda
		asd
`
s := "D:\Documents\A"

len(str)
ss := s1 + s2
ret := strings.Split(s3, "\\")
ret = strings.Contains(s3, "abcd")
ret = strings.HasPrefix(s3, "abcd")
ret = strings.HasSufix(s3, "abcd")
ret = strings.Index(s3, "c")
ret = strings.LastIndex(s3, "c")
ret = strings.Join(a, b)

for _, char := range str {
  fmt.Printf("%c", char)
}

s3 := []rune(s2)	//切片
s3[0] = 'e'	//修改
s4 := string(s3)

if 表达式1 {
    分支1
} else if 表达式2 {
    分支2
} else{
    分支3
}

// 局部变量score只在if中生效，减少内存占用
	if score := 65; score >= 90 {
		fmt.Println("A")
	} else if score > 75 {
		fmt.Println("B")
	} else {
		fmt.Println("C")
	}

for 初始语句;条件表达式;结束语句{
    循环体语句
}

for i := 0; i < 10; i++ {
		fmt.Println(i)
}

i := 0
	for i < 10 {
		fmt.Println(i)
		i++
	}

for {
    循环体语句
}

for i,v := range s{
  fmt.Println(i, v)
}

finger := 3
	switch finger {
	case 1:
		fmt.Println("大拇指")
    fallthrough
	case 2:
		fmt.Println("食指")
	case 3:
		fmt.Println("中指")
	case 4:
		fmt.Println("无名指")
	case 5:
		fmt.Println("小拇指")
	default:
		fmt.Println("无效的输入！")
	}

switch n := 7; n {
	case 1, 3, 5, 7, 9:
		fmt.Println("奇数")
	case 2, 4, 6, 8:
		fmt.Println("偶数")
	default:
		fmt.Println(n)
	}

var breakFlag bool
	for i := 0; i < 10; i++ {
		for j := 0; j < 10; j++ {
			if j == 2 {
				// 设置退出标签
				breakFlag = true
				break
			}
			fmt.Printf("%v-%v\n", i, j)
		}
		// 外层for循环判断
		if breakFlag {
			break
		}
	}

for i := 0; i < 10; i++ {
		for j := 0; j < 10; j++ {
			if j == 2 {
				// 设置退出标签
				goto breakTag
			}
			fmt.Printf("%v-%v\n", i, j)
		}
	}
	return
	// 标签
breakTag:
	fmt.Println("结束for循环")

// 逻辑运算
&&
||
!

// 位运算
&
|
^
<<
>>

// 赋值
+=
-=
<<=

var a [3]int

var a [3]int
var b [4]int
a = b //不可以这样做，因为此时a和b是不同的类型

	var testArray [3]int	//数组会初始化为int类型的零值
	var numArray = [3]int{1, 2}	//使用指定的初始值完成初始化
	var cityArray = [3]string{"北京", "上海", "深圳"} //使用指定的初始值完成初始化
	var numArray = [...]int{1, 2} //根据值推断数组长度
	var cityArray = [...]string{"北京", "上海", "深圳"}

	a := [...]int{1: 1, 3: 5}	//指定索引初始化
	fmt.Println(a)                  // [0 1 0 5]

for index, value := range a {
		fmt.Println(index, value)
	}

a := [3][2]string{
		{"北京", "上海"},
		{"广州", "深圳"},
		{"成都", "重庆"},
	}

	var a = []string              //声明一个字符串切片
	var b = []int{}             //声明一个整型切片并初始化
	var c = []bool{false, true} //声明一个布尔切片并初始化
	var d = []bool{false, true} //声明一个布尔切片并初始化

a1 := [...]int{1, 3, 5, 7, 9, 11, 13}
s3 := a1[0:4] //左包右不包，索引为0-3切片

len(s3) // 4 切片长度
cap(s3)	// 7 容量=原数组切片点到末尾的长度

a[2:]  // 等同于 a[2:len(a)]
a[:3]  // 等同于 a[0:3]
a[:]   // 等同于 a[0:len(a)]

a[low : high : max]
a := [5]int{1, 2, 3, 4, 5}
t := a[1:3:5] //t:[2 3] len(t):2 cap(t):4

make([]T, size, cap)

a := make([]int, 2, 10) // 初始化值为0

	s1 := make([]int, 3) //[0 0 0]
	s2 := s1             //将s1直接赋值给s2，s1和s2共用一个底层数组
	s2[0] = 100
	fmt.Println(s1) //[100 0 0]
	fmt.Println(s2) //[100 0 0]

	var s []int
	s = append(s, 1)        // [1]
	s = append(s, 2, 3, 4)  // [1 2 3 4
	s2 := []int{5, 6, 7}  
	s = append(s, s2...)    // [1 2 3 4 5 6 7]

var s []int
s = append(s, 1, 2, 3)

func main() {
	//append()添加元素和切片扩容
	var numSlice []int
	for i := 0; i < 10; i++ {
		numSlice = append(numSlice, i)
		fmt.Printf("%v  len:%d  cap:%d  ptr:%p\n", numSlice, len(numSlice), cap(numSlice), numSlice)
	}
}

newcap := old.cap
doublecap := newcap + newcap
if cap > doublecap {
	newcap = cap
} else {
	if old.len < 1024 {
		newcap = doublecap
	} else {
		// Check 0 < newcap to detect overflow
		// and prevent an infinite loop.
		for 0 < newcap && newcap < cap {
			newcap += newcap / 4
		}
		// Set newcap to the requested cap when
		// the newcap calculation overflowed.
		if newcap <= 0 {
			newcap = cap
		}
	}
}

	a := []int{1, 2, 3, 4, 5}
	c := make([]int, 5, 5)
	copy(c, a)     //使用copy()函数将切片a中的元素复制到切片c
	fmt.Println(a) //[1 2 3 4 5]
	fmt.Println(c) //[1 2 3 4 5]
	c[0] = 1000
	fmt.Println(a) //[1 2 3 4 5]
	fmt.Println(c) //[1000 2 3 4 5]

	a = append(a[:index], a[index+1:]...)
	a := []int{30, 31, 32, 33, 34, 35, 36, 37}
	// 要删除索引为2的元素
	a = append(a[:2], a[3:]...)
	fmt.Println(a) //[30 31 33 34 35 36 37]

	//底层数组长度不变，元素左移，右边的由最右元素补全

sort.Ints(a[:])

ptr := &v // v的类型为T 输出指针类型*T 如 *string *int

	a := 10
	b := &a
	fmt.Printf("a:%d ptr:%p\n", a, &a) // a:10 ptr:0xc00001a078
	fmt.Printf("b:%p type:%T\n", b, b) // b:0xc00001a078 type:*int
	fmt.Println(&b)                    // 0xc00000e018

	c := *b // 指针取值（根据指针去内存取值）
	fmt.Printf("type of c:%T\n", c)
	fmt.Printf("value of c:%v\n", c)

func modify1(x int) {
	x = 100
}

func modify2(x *int) {
	*x = 100
}

func main() {
	a := 10
	modify1(a)
	fmt.Println(a) // 10
	modify2(&a)
	fmt.Println(a) // 100
}

	a := new(int)
	b := new(bool)
	fmt.Printf("%T\n", a) // *int
	fmt.Printf("%T\n", b) // *bool
	fmt.Println(*a)       // 0
	fmt.Println(*b)       // false

	var b map[string]int
	b = make(map[string]int, 10)
	b["沙河娜扎"] = 100
	fmt.Println(b)

	map[KeyType]ValueType

	scoreMap := make(map[string]int, 8) // 初始化才能用，避免动态扩容！
	scoreMap["张三"] = 90
	scoreMap["小明"] = 100
	fmt.Println(scoreMap)
	fmt.Println(scoreMap["小明"])
	fmt.Printf("type of a:%T\n", scoreMap)

	userInfo := map[string]string{
		"username": "沙河小王子",
		"password": "123456",
	}

value, ok := map[key] // ok返回key是否存在的bool值

	v, ok := scoreMap["张三"]
	if ok {
		fmt.Println(v)
	} else {
		fmt.Println("查无此人")
	}

for k, v := range scoreMap {
		fmt.Println(k, v)
}

for k := range scoreMap {
		fmt.Println(k)
}

for _, v := range scoreMap {
		fmt.Println(v)
}

delete(map, key)

func main() {
	rand.Seed(time.Now().UnixNano()) //初始化随机数种子

	var scoreMap = make(map[string]int, 200)

	for i := 0; i < 100; i++ {
		key := fmt.Sprintf("stu%02d", i) //生成stu开头的字符串
		value := rand.Intn(100)          //生成0~99的随机整数
		scoreMap[key] = value
	}
	//取出map中的所有key存入切片keys
	var keys = make([]string, 0, 200)
	for key := range scoreMap {
		keys = append(keys, key)
	}
	//对切片进行排序
	sort.Strings(keys)
	//按照排序后的key遍历map
	for _, key := range keys {
		fmt.Println(key, scoreMap[key])
	}
}

	var mapSlice = make([]map[string]string, 3) // 切片初始化，每个元素都是一个map
	for index, value := range mapSlice {
		fmt.Printf("index:%d value:%v\n", index, value)
	}
	fmt.Println("after init")
	// 对切片中的map元素进行初始化
	mapSlice[0] = make(map[string]string, 10)
	mapSlice[0]["name"] = "小王子"
	mapSlice[0]["password"] = "123456"
	mapSlice[0]["address"] = "沙河"
	for index, value := range mapSlice {
		fmt.Printf("index:%d value:%v\n", index, value)
	}

func main() {
	var sliceMap = make(map[string][]string, 3)
	fmt.Println(sliceMap)
	fmt.Println("after init")
	key := "中国"
	value, ok := sliceMap[key]
	if !ok {
		value = make([]string, 0, 2)
	}
	value = append(value, "北京", "上海")
	sliceMap[key] = value
	fmt.Println(sliceMap)
}

func 函数名(参数 类型) 返回值类型 {
    函数体
}

func intSum(x int, y int) int {
	return x + y
}

func intSum(x, y int) int {
	return x + y
}

func intSum2(x ...int) int {
	fmt.Println(x) //x是一个切片
	sum := 0
	for _, v := range x {
		sum = sum + v
	}
	return sum
}

//有命名的返回
func calc(x, y int) (sum, sub int) {
	sum = x + y
	sub = x - y
	return
}
//切片
func someFunc(x string) []int {
	if x == "" {
		return nil // 没必要返回[]int{}
	}
	...
}

type calculation func(int, int) int

func main() {
	var c calculation               // 声明一个calculation类型的变量c
	c = add                         // 把add赋值给c
	fmt.Printf("type of c:%T\n", c) // type of c:main.calculation
	fmt.Println(c(1, 2))            // 像调用add一样调用c

	f := add                        // 将函数add赋值给变量f1
	fmt.Printf("type of f:%T\n", f) // type of f:func(int, int) int
	fmt.Println(f(10, 20))          // 像调用add一样调用f
}

func add(x, y int) int {
	return x + y
}
func calc(x, y int, op func(int, int) int) int {
	return op(x, y)
}
func main() {
	ret2 := calc(10, 20, add)
	fmt.Println(ret2) //30
}

func do(s string) (func(int, int) int, error) {
	switch s {
	case "+":
		return add, nil
	case "-":
		return sub, nil
	default:
		err := errors.New("无法识别的操作符")
		return nil, err
	}
}

func main() {
	// 将匿名函数保存到变量
	add := func(x, y int) {
		fmt.Println(x + y)
	}
	add(10, 20) // 通过变量调用匿名函数

	//自执行函数：匿名函数定义完加()直接执行
	func(x, y int) {
		fmt.Println(x + y)
	}(10, 20)
}

func adder() func(int) int {
	var x int
	return func(y int) int {
		x += y
		return x
	}
}
func main() {
	var f = adder()
	fmt.Println(f(10)) //10
	fmt.Println(f(20)) //30
	fmt.Println(f(30)) //60

	f1 := adder()
	fmt.Println(f1(40)) //40
	fmt.Println(f1(50)) //90
}

func main() {
	fmt.Println("start")
	defer fmt.Println(1)
	defer fmt.Println(2)
	defer fmt.Println(3)
	fmt.Println("end")
}

/*
start
end
3
2
1
*/

//面试题 defer注册要延迟执行的函数时,该函数所有的参数都需要确定其值
func calc(index string, a, b int) int {
	ret := a + b
	fmt.Println(index, a, b, ret)
	return ret
}

func main() {
	x := 1
	y := 2
	defer calc("AA", x, calc("A", x, y))
	x = 10
	defer calc("BB", x, calc("B", x, y))
	y = 20
}

/*
A 1 2 3 //defer calc("AA", 1, 3)
B 10 2 12 //defer calc("BB", 10, 12)
BB 10 12 22
AA 1 3 4
*/

func funcA() {
	fmt.Println("func A")
}

func funcB() {
	defer func() {
		err := recover()
		//如果程序出出现了panic错误,可以通过recover恢复过来
		if err != nil {
			fmt.Println("recover in B")
		}
	}()
	panic("panic in B")
}

func funcC() {
	fmt.Println("func C")
}
func main() {
	funcA()
	funcB()
	funcC()
}

func main() {
	fmt.Print("在终端打印该信息。") //不换行
	name := "沙河小王子"
	fmt.Printf("我是：%s\n", name)
	fmt.Println("在终端打印单独一行显示")
}

// 向标准输出写入内容
fmt.Fprintln(os.Stdout, "向标准输出写入内容")
fileObj, err := os.OpenFile("./xx.txt", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
if err != nil {
	fmt.Println("打开文件出错，err:", err)
	return
}
name := "沙河小王子"
// 向打开的文件句柄中写入内容
fmt.Fprintf(fileObj, "往文件中写如信息：%s", name)

s3 := fmt.Sprintln("沙河小王子")

e := errors.New("原始错误e")
w := fmt.Errorf("Wrap了一个错误%w", e)

fmt.Scan(&name, &age, &married)
fmt.Scanf("1:%s 2:%d 3:%t", &name, &age, &married)
fmt.Scanln(&name, &age, &married)

func bufioDemo() {
	reader := bufio.NewReader(os.Stdin) // 从标准输入生成读对象
	fmt.Print("请输入内容：")
	text, _ := reader.ReadString('\n') // 读到换行终止 空格也读入
	text = strings.TrimSpace(text)
	fmt.Printf("%#v\n", text)
}

//将MyInt定义为int类型
type MyInt int

type TypeAlias = Type

type byte = uint8
type rune = int32

type 类型名 struct {
    字段名 字段类型
    字段名 字段类型
    …
}

type person struct {
	name string
	city string
	age  int8
}

type person1 struct {
	name, city string
	age        int8
}

var 结构体实例 结构体类型

type person struct {
	name string
	city string
	age  int8
}

func main() {
	var p1 person
	p1.name = "沙河娜扎"
	p1.city = "北京"
	p1.age = 18
	fmt.Printf("p1=%v\n", p1)  //p1={沙河娜扎 北京 18}
	fmt.Printf("p1=%#v\n", p1) //p1=main.person{name:"沙河娜扎", city:"北京", age:18}
}

func main() {
    var user struct{Name string; Age int}
    user.Name = "小王子"
    user.Age = 18
    fmt.Printf("%#v\n", user)
}

var p2 = new(person)
//使用&对结构体进行取地址操作相当于对该结构体类型进行了一次new实例化操作
p3 := &person{}


fmt.Printf("%T\n", p2)     //*main.person
fmt.Printf("p2=%#v\n", p2) //p2=&main.person{name:"", city:"", age:0}

//支持对结构体指针直接使用.来访问结构体的成员
p2.name = "小王子"
p2.age = 28
p2.city = "上海"
fmt.Printf("p2=%#v\n", p2) //p2=&main.person{name:"小王子", city:"上海", age:28}

p5 := person{
  name: "小王子",
	city: "北京",
	age:  18,
}

p6 := &person{
	name: "小王子",
	city: "北京",
	age:  18,
}

p8 := &person{
	"沙河娜扎",
	"北京",
	28,
}

cols = ['col1', 'col2']
pd.read_table(path, sep='|', headers=None, names=cols)
pd.head()	# first five rows

df.describe()	#show mean, std, max, min...

df.rename(columns = {'old_col_name':'new_col_name'}, inplace=True)

cols = new_col_list
df.columns = cols
df.columns = df.columns.str.replace(' ', '_')

df.drop('col', axis=1, inplace=True)

df.drop([rows], axis=0, inplace=True)

df['col'].sort_values(ascending=False)	# series

df.sort_values('col')	# return dataframe
df.sort_values(['col1', 'col2'])	

pd.Series([])

df[df['col'] >= 200]

#	df[df['col'] >= 200]['col2']
df.loc[df['col'] >= 200, 'col2']	#	loc select cols or rows with labels

df[(df['col'] >= 200) | (df['col1'] == 'a')]

df['col'].isin(['a', 'b', 'c'])

pd.read_csv(path, usecols=['a', 'b'])

pd.read_csv(path, nrows=3)

for c in df['col']:
	print(c)

for index, row in df.iterrows():
  print(index, row['a'], row['b'])

import numpy as np
df.select_dtypes(include=[np.number]).dtypes

df.describe(include=['object', 'float64'])

df.mean()	# mean value for serires
df.mean(axis=1)	# row mean

df['col'].str.upper()	# uppercase 
df['col'].str.contains('str')	#	return series of t/f
df[df['col'].str.contains('str')]
df['col'].str.replace('a', 'b').str.replace('c', 'd')	# support regex

df.dtypes
serires.dtype
df['col'] = df['col'].astype('float64')

df = pd.read_csv(path, dtype=('col1':float))
df['col'].str.replace('$', '').astype(float).mean()

df.groupby('col1').mean()
df.groupby('col1')['col2'].mean()
df.groupby('col1')['col2'].agg(['count', 'min', 'max', 'mean'])

%matplotlib inline
df.groupby('col1')['col2'].mean().plot(kind='bar')

df['col'].describe()
df['col'].value_counts()
df['col'].value_counts(normalize=True)
df['col'].unique()
df['col'].nunique()	# number of unique values
pd.crosstab(df['col1'], df['col2'])
df['col1'].plot(kind='hist')

df.tail()
df.isnull().head()
df.isnull().sum()
df.dropna(how='any', inplace=True)	# drop a row if it contains null
df.dropna(subset=['col1', 'col2'], how='any')	# drop a row if col1 or col2 is null
df['col'].value_counts(dropna=False)
df['col'].fillna(value='A', inplace=True)

df.index
df.columns
df.shape

df.loc[23, 'a']	#	fetch value
df.decribe().loc['25%', 'col']

df.set_index(Series, inplace-True)

df['col'].value_counts()['value1']
df['col'].value_counts().sort_values()
df['col'].value_counts().sort_index()

pd.Series(value array, index=[indices])
pd.concat([df1, df2], axis=1)

df.loc[index, col_name]	# by label
df.iloc[:, [0, 3]]	# by indices

df= pd.read_csv(path, index_col='col1')
df.ix['row_label', 0]	# mix labels and indices (not recommend)
df.ix[1, 'col_label']
df.ix['col1':'col3', 0:2]

df.memory_usage(deep=True)
df['col'].astype('category')
df['col'] = df['col'].astype('category', categories=['good', 'veray good', 'excellent', ordered=True])

pd.DataFrame({'id':array1, 'col':array2}).set_index('id').to_csv('1.csv')
df.to_pickle('1.pkl')
df.read_pickle('1.pkl')

df.loc[0:4, :]	#	inclusive-label
df.iloc[0:4, :]	# exclusive-index

df.sample(n=3, random_state=42)
df.sample(frac=0.75)
train = df.sample()
test = df.loc[~df.index.isin(train.index), :]

df['sex_male'] = df['sex'].map({'female':0, 'male':1})
pd.get_dummies(df['sex'], prefix='sex')

df['time'] = pd.to_datetime(df['time'])
df['time'].dt.weekday_name
df['time'].dt.dayofyear
df.loc[df['time'] > pd.to_datetime('1/1/1999'), :]
(df['time'].max() - df['time'].min()).days

df['col'].duplicated().sum()
df.loc[df.duplicated(keep='first'), :]	#	'last' False
df.duplicated(subset=['col1', 'col2'])

pd.set_option('display.max_rows', None)
pd.reset_option('display.max_rows', None)
pd.set_option('display.max_colwidth, None)
pd.set_option('display.precision, 2)
df['new_col'] = df['col'] * 1000
pd.set_option('display.float_format', '{:,}'.format)

pd.DataFrame(dict, columns=['a', 'b'])
s = pd.Series([1, 2], index=['c', 'd'], name=shape)

df['col1'] = df['col2'].apply(function)
df['col1'] = df['col2'].apply(np.ceil)
df['col'].apply(lambda x: x[0])
df['col1'] = df['col2'].apply(np.argmax, axis=1)

ser = df.groupby(['col1', 'col2']).col3.mean()	# series with multiindex
ser.unstack()	# dataframe
df.pivot_table(values='col1', index='col2', columns='col3')

df.set_index(['col1', 'col2'], inplace=True)
df.sort_index(inplace=True)

pd.concat([df1, df2])
pd.merge([df1, df2])

pd.merge(df1, df2, left_on='col1', right_on='col2')
pd.merge(df1, df2, how='inner')	#	outer left right

变量名 赋值符号 变量名

id()

type()

print('-' * 10)
# -----------

list2 = list1.copy()

import copy
list3 = copy.deepcopy(list1)

a = {
  "key":"value"
	"1":1,
  "2":"qwe"
}

del x	# 解除变量与值的绑定

input() # 存为str

# python2
raw_input()	# 存为str
input()	# 要求用户输入明确数据类型，输入的是什么类型就为什么类型

print("name: %(name)s, age:%(age)d" % {"name": "a", "age": 10})
# %s可以接受任何类型

print("name: {name}, age:{age}".format(name = "a", age = 10))

print(f"name: {name}, age:{age}")

10 // 3	#只保留整数部分，即整除
3 ** 10	#指数
10 % 3 #取余数

1 != 2
1 < x < 3

a = 1

 a += 1
 b *= 1

z = y = x = 10 

m, n = n, m

list = [1, 2, 3, 4]
a, b, c, d = list
x, y, *_ = list	#取前两个
*_ , x, y = list	#取后两个
# 字典解压取值的是key

"a" in "abc"
1 in [1, 2, 3]

if 16 < a < 20:

while True:
	...
else:
	...

for variable in Iterable object:
	...
  

for i in range(1, 100):
	...
  

# py2
>>> range(0, 5)
[0, 1, 2, 3, 4]
#py3 优化
>>> range(0,5)
range(0,5)

print("hello", end="*")	# 自定义结束，默认为换行

# 不可变，是一个整体，不可单独改某个字符
str(10)
msg = "hello"

# 切片
msg[0] # h
msg[-1] # o
msg[0:5] # hello 顾头不顾尾
msg[0:5:2] # hlo
msg[5:0:-1] # olle

"alex" in ”alexxxx"	# true
"alex" not in ”alexxxx"	# false

msg = "    eee   "
res = msg.strip()	# 默认去除两边空格 字符串不可变，故需要新赋值
msg = "***eee***"
res = msg.strip(“*”)  # strip只去两边，不去中间
res = msg.lstrip()
res = msg.rstrip()

# 切分：按某字符分割字符串，返回列表
res = msg.split(":", 1) # 默认按空格为分隔符 分割次数，从左往右算
res = msg.lsplit(":", 1)
res = msg.rsplit(":", 1) #从右往左

res2 = ":".join(res) # 以：为分隔符拼接

res = msg.lower() # 小写
res = msg.upper()
res = msg.startswith("aaa") # True 以什么开头
res = msg.endswith("aaa")
res = msg.replace("you", "me" ,1) #字符串替换，次数

“123”.isdigit() # 纯数字

msg.find("e") # 返回索引，找不到返回-1
msg.index("e") # 返回索引，找不到程序报错
msg.count("e") # 数子串出现次数
"分割线".center(50, "*") #两侧用*填充
"分割线".ljust(50, "*") #右侧填充
"分割线".rjust(50, "*")
"分割线".zfill(50) # 左侧用0填充

# is 判断系列 查文档
isalpha()
isdigit()
isdecimal() # 只识别阿拉伯数字 py3 默认unicode
isnumeric() # 可以识别汉字，阿拉伯数字