前端进阶（内卷）- python自由之路第一篇：数据类型

前言

笔者为前端已八年有余。见证了前端的繁荣发展，亦见证了前端残暴内卷。这是时代的悲哀，更是行业的无奈。每个人似乎都不能从这场内卷的浩劫中独善其身。

既然无力反抗？何不尽情享受？

所以，我决定毅然而然的加入内卷大军中，享受内卷的酣畅淋漓。于是，我把眼光瞄向了python。

python学习曲线平滑，使用范围极广，未来前景广阔......

这些理由已经足以使我迫不及待地卷起来！

话不多说，今天第一课，我们来讲讲python的数据类型。

请注意，本系列文章不做细致谈论，不照本宣科，仅从前端角度切入，如何快速掌握python语法技巧。

---

数据类型 - 概括

作为前端，最经常使用和熟悉的语言莫过于js。所以，我们学习的时候，亦可以通过两者概念语法的对比来学习。一来，温故而知新；二来，对比出奇迹。

js中谈及数据类型，大致可以分为基础数据和引用数据。前者包含字符、数字、布尔等，后者包含函数、对象、数组等。

那么在python中，大体也可以这么区分，只是要注意具体内容细节上的变化。我个人认为数字和布尔值相对没有那么多主要点和不同，反而是字符、列表、对象、集合值得一说。下面我们就分别讨论下上边提及的四种数据类型。任何一种类型，都会从他们的定义、方法等方面去比较学习。

数据类型 - 字符

js字符：

// 首先是js的字符串

// 1. 字符定义

let str = 'hello, world';

// 2. 字符截取方法比较丰富，比如substr, substring, slice(开始索引， 结束索引)
str.slice(0, 1) // h ,含义是从第0个截取到第1个结束，但是不包括1,

// 3. 包含是否某个字符
str.includes('a') // true

// 4.字符索引
let index = str.indexOf('h') // 0

// 5.字符格式化 - 模板字符串或者正则
`${str}`
str.replace(/h/g, '')


// 实际开发中上边这些内容用到最多

然后在python中：

# 这里是python的字符

# 1. 字符定义
s = 'hello world'

# 2. 字符的截取
# 字符的截取就不用具体的方法了，而是引入极具python特色的切片
# 切片的使用和js的slice使用极其相似，同样通过索引传入
# 可以通过[开始索引:结束索引]的形式去截取
ss = s[1:2] # e

# 3. 字符串是否包含指定字符 in
'h' in ss # True

# 4. 找到字符索引 fnd
ss.find('f') 

# 5. 字符格式化
# 高能预警！！！
# python的字符格式化极其丰富！

# 单词首字母大写 title
s.title() # 'Hello World'

# 字符首字母大写
s.capitalize() # 'Hello world'

# 填充字符到指定长度
s.center(20, '*') # ****hello world*****

# 字符重复
s * 3 # 'hello world hello world hello world'

# 模板字符串
print(f'你好啊 {ss}') # '你好啊 hello world'

# more 还有很多很多  用到时候 可以具体查阅

感受：
python在字符串的处理上，方法极为丰富，切片和格式化完胜！

数据类型 - 列表

js列表（通常叫数组）:

// js 数组

// 1. 数组的定义

// 字面量 
let a = [1,2,3,4,5]
// 构造器
let b = new Array(1,2,3,4,5)
// 当然还有其他不常用的方式

// 2. 数组的截取 slice
a.slice(0, 1) // 1

// 3. 数组的增删改查

// 遍历 常用
for (let i = 0; i< a.length; i++) {}
a.forEach((item, index, ary) => {})

// 增加
a.unshift(1000)
a.push(1000)

// 删除
a.shift()
a.pop()

// 改
a[0] = 999

// 查 1这个元素在数组中的位置
a.findIndex(item => item == 1)

// 排序
a.sort()

// 倒序 
a.reverse()



// 4. 数组的高阶函数

// 筛选数据 筛选出被2整除的项
const b = a.filter(item => item % 2 == 0)

// 数组计算 数组每一项加1
const c = a.map(item => item + 1)

// 数组累加 每一项累加
const d = a.reduce((prev, next) => prev + next)

python中的列表：

# python 列表

# 1. 数组的定义

# 字面量 
a = [1,2,3,4,5]
# 构造器
b = list(range(1,6))
# 推导式
c = [x**2 for x in range(20)] # 意思是创建一个序列，从1到20，然后每一项都平方，输出数组
# more

# 2. 数组的截取 
# 我们上边说了 字符串的截取用切片 那么 同样的
# 数组的截取也是切片 yyds
a[1:2]
a[2:3]
a[-3:-1]
a[1:]
a[:]

# 3. 数组的增删改查

# 遍历
for item in a:
    print(item)

# 增加
a.insert(0, 10000) # 向第o个位置插入一项 10000
a.append(1000) # 末尾追加 相当于 js push

# 删除
a.pop() # 这个和js是一样的
a.pop(i) # 删除某一项 i 是索引
a.remove(1) # 删除数组中数值为1的这一项
del(a[1]) # 删除索引为1的这一项

# 改
a[0] = 999 # 相同

// 查 1这个元素在数组中的位置
a.index(1)

# 排序
a.sort()

# 倒序 
a.reverse()

# 4. 数组的高阶函数

# 筛选数据 筛选出被2整除的项
const b = list(filter(lambda x: x%2==0, a)

# 数组计算 数组每一项加1
const c = list(filter(lambda x: x+1, a)

# 数组累加 每一项累加
# 需要引入reduce函数
from functools import reduce

const d = reduce(lambda x,y: x+y, a)

# 这里需要注意函数简易生成推导式 lambda；  后续函数中会讲到

感受：

js和python之间真的是简直了，孪生兄弟啊！

数据类型 - 字典

js中也称之为对象。不过就是换了个马甲，还是老样子。

js中对象：

// js 对象 

// 1. 定义对象

// 字面量
const obj = {name: 'Will'}

// 构造器
const obj = new Object()
obj.name = 'Will'

// 还有很多 比如 继承，Object.create() 等等

// 2. 遍历对象
for key in obj {
    const element = obj[key]
}

// 3.对象的增删改查

// 增加属性
obj.age = 20

// 删除属性
del obj.age;

// 改
obj.age = 1000

// 查
obj.name obj['name']

// 清空 
obj = null

python中的字典：

# 1. 创建字典

# 字面量创建

d1 = {'name': 'Will', 'age': 30}

# 构造器创建

d1 = dict(a='hehe', b=2, c=3)

# 推导式创建

d1 = {x: x*10 for x in range(1, 10)}

# 使用zip函数（一个内置解压函数）创建

d1 = dict(zip(['a', 'b', 'c'], '123'))

# 最后两种方法 可能用处不太广泛  了解一下即可

# 2. 字典的操作

# 增加

d1['word'] = 'this is a word'

# 增加多个属性
d1.update(d=100, e="hello")

# 删除一个属性 并返回属性值
d1.pop('a')

# 修改
d1['a'] = 10000

# 查询 
d1['a']


# 遍历

for key, value in d1.items():
    print('属性', key)
    print('属性值', value)

# 清空

d1.clear()

感受：

注意方法差异和遍历的不同。

数据类型 - 集合

无论是js还是python，集合都是和数学上的集合概念高度一致的。都可以从交集、并集、差集去理解。

js中的set：

// js中的集合用法

// 1. 创建

let s = new Set([1,2,3,4,1,2,3])

// 2. 操作

// 增加元素
set.add(5)

// 删除元素
s1.delete(1)

// 是否包含
s1.has(2) // true

// 清空
s1.clear()

// 查看长度
s1.size

// 3. 遍历

s.forEach(item => {
    console.log(item);
})


// 4. 交集 并集

// 交集 
let a = new Set([1,2,3])

let b = new Set([3,4,5])

let c = new Set([...a, ...b])


// 并集
let d = new Set([...b].filter(item => a.has(item)))


// 差集
let e = new Set([...b].filter(item => !a.has(item)))

python中的集合：

# python 中的集合

# 1. 创建

s = set([1,2,3])

# 字面量创建

s = {1,2,3}

# 推导式创建

s = {num for num in range(1,10) if num %2 == 0}

# 2. 操作

# 新增

s.add(4)

# 删除 
s.delete(1)
s.discard(2)

# 有啥区别呢？remove和discard方法都是删除某个元素，区别是 remove -> 删除不存在的元素 会报错；

# 批量更新

s.update([5,6])

# 3. 遍历
for value in s:
    print(value)

# for in 在python中真的是无敌了  

至此，python和js四种主要的数据类型 —— 字符、数组、对象、集合，就对比完毕了。对比学习，一方面复习下js，另一方面可以对比和js的不同，加深记忆，方便学习！

好了，第一节课到此结束。