【Python】基础篇之数据类型
写在前面的一些内容：
相较于其他的编程语言，既有相同点也有不同点。
在python中，对缩进的要求很严格，哪怕是运算符之间的空格，也会给你提醒。
它不用 ;作为语句结束的标志，也不使用{}作为函数范围的一个确定。
对于其他不同的地方，举个例子：pass语句是python不同与C/C++的。
数据类型
关于如何定义数据类型：
在使用的时候不用像C/C++一样提前声明类型，直接定义即可
# python
a = 10 # int型
b = 1.2 # float型
c = 'abcd' # string 型
关于其之间的类型转换，可以使用int()，float()，str()来完成。
如果想要查看数据的类型，可以使用type()函数，想要查看经过某一个操作过后，数据是新生成的还是在原有的基础上进行修改的，可以使用id()，来进行一个简单的判断。
列表：
使用的符号是 []，属于可变序列结构
关于其创建方式：
# 创建
# 方式1：直接使用[]
lst1 = [4, 5, 6]
# 方式2：使用list()
lst2 = list([1, 2, 3])
# 创建空列表
lst3 = []
列表有一些特点：
从左向右，其下标为0，1，2，3…
从右向左，其下标为-1，-2，-3…
列表生成式：
# 生成1-10的列表
lst = [it for it in range(1, 10)]
经常使用的一些方法：
| 函数名称 | 介绍 |
|---|---|
| insert(index,val) | 在第index个位置前面插入val |
| append() | 在列表的末尾插入 |
| extend() | 在列表的末尾一次性追加多个元素 |
| copy() | 创建副本 |
| count() | 给定一元素，返回其在列表内的数量 |
| index() | 获取所寻元素的下标 |
| len() | 返回列表的长度 |
| pop() | 默认删除列表末尾的元素；但若给出需要删除元素的所在下标，可定向删除 |
| remove() | 删除所给定的数字，若有多个，则默认删除从左向右的第一个 |
| reverse() | 逆置列表 |
| sort() | 排序，默认为升序，当reverse=True时，为降序排列 |
| sorted() | python内置排序函数，有返回值 |
| clear() | 清空列表 |
关于append()和extend()之间的区别：
# extend()和append()之间的区别
lst1 = [4, 5, 6]
lst2 = list([1, 2, 3])
print('lst1=', lst1)
print('lst2=', lst2)
temp1 = lst1.copy() # 为了防止数据被影响，这里使用副本测试
temp1.append(lst2) # append()
lst1.extend(lst2) # extend()
temp2 = lst1.copy()
print('使用append()得到的新列表temp1：', temp1)
print('使用extend()得到的列表temp2：', temp2)
# 运行结果如下：
lst1= [4, 5, 6]
lst2= [1, 2, 3]
使用append()得到的新列表temp1： [4, 5, 6, [1, 2, 3]]
使用extend()得到的列表temp2： [4, 5, 6, 1, 2, 3]
所以可得，对于单个元素的插入，append()和extend()并无明显差别，但对于类似列表这样的多个元素的插入，二者所产生的结果是不相同的。
字典：
使用的符号是{}，属于可变序列结构。关于字典，其每个Key对应一个val，key值不重复，val可以重复，类似C++中的map，但却和map有所区别。
关于其创建方式：
# 创建
# 方式1：直接使用{}
dir1 = {'jack': 10, 'li bai': 20}
# 方式2：使用dict()
dir2 = dict({'wang': 25, 'liu': 23})
关于获取某个键其所对应的值，其中一种操作类似map，可以用dir[‘jack’]来获得
关于添加和修改，可以直接使用dir1[‘chen’] = 24，这样的操作来实现
经常使用的一些方法：
| 函数名称 | 说明 |
|---|---|
| get() | 获取键所对应的值 |
| pop() | 删除指定键 |
| clear() | 清空字典 |
| copy() | 复制副本 |
| keys() | 以列表的形式返回字典内的所有键 |
| values() | 以列表的形式返回字典内的所有值 |
| items() | 返回字典内的所有项目 |
| fromkeys(key[,val) | 以key为键，val为值，返回一个新字典，若不为val赋值，则默认val为None |
| popitem() | 删除最后插入的键值对 |
| setdefault(key,deVal) | 返回指定key的值，若不存在则插入改键，值为deVal，若不为deVal赋值，默认为None |
| update() | dir1.update(dir2)，对指定键值对进行更新，若不存在则添加进当前字典 |
元组：
使用的符号是()，属于不可变序列结构。但元组内的列表、字典等可变序列结构还是可以改变的。
如果想要改变元组内容的话，需要先将其转变为列表，列表是可以修改的，待修改完成后在转换成元组。
具体方法类似：
# 在元组tup1内添加一个元素 30
tup1 = ('a', 10, 20)
print('未添加前：', tup1, id(tup1))
lst1 = list(tup1)
lst1.append(30)
tup1 = tuple(lst1)
print('添加后：', tup1, id(tup1))
运行结果：
未添加前： ('a', 10, 20) 2425795893760
添加后： ('a', 10, 20, 30) 2425795932304
通过上述例子，我们不难发现，tup1已经不是以前的tup1了。
此外，在方法上，元组和列表也有很多相同之处：索引、截取
关于其创建方式：
# 创建
# 方法1：直接使用()
tup1 = ('a', 10, 20)
# 方法2：使用tuple()
tup2 = tuple((1, 'acd', 'b'))
# 关于创建空元组
tup3 = ()
经常使用的一些方法：
| 函数名称 | 介绍 |
|---|---|
| index() | 获取所寻元素的下标 |
| count() | 获取所寻元素的个数 |
这里对上面我所说的元组内的列表、字典等可变序列结构还是可以改变的做一个测试用例，方便理解。
tup3 = ('a', [10, 20], 50) # 元组
print('未改变前：', tup3, id(tup3))
tup3[1].append(30) # 对元组内的列表进行扩展
print('改变后：', tup3, id(tup3))
运行结果：
未改变前： ('a', [10, 20], 50) 2317033487296
改变后： ('a', [10, 20, 30], 50) 2317033487296
通过id，我们可以得知，元组还是那个元组。
集合：
使用的符号是{}，属于可变序列结构，集合是没有val的字典。但集合的特性是，其内不含有重复的元素。
因为其不可以使用索引，查找可以使用 in 或者 not in
关于其创建方式：
# 一、直接使用 {}
s = {'a','b','c'}
# 二、使用set()
s1 = set({'a','b'})
# 如何定义一个空集合
s2 = set()
经常使用的一些方法：
| 函数名称 | 介绍 |
|---|---|
| update() | 一次至少添加一个元素，参数可以是列表[]，也可以是元组（） |
| add() | 一次添加一个元素 |
| union() | 集合的合并，合并后会去除掉重复的元素，其效果与“|”相同 |
| copy() | 集合的拷贝，返回该集合的一个副本 |
| renove() | 一次删除一个指定元素，如果不存在就抛出异常keyError，程序终止 |
| discard() | 一次删除一个指定元素，如果元素不存在也不会抛出异常，程序可以正常执行完毕 |
| pop() | 一次删除一个元素，一般是从左边删除，字符串除外 |
| clear() | 清空集合 |
| difference() | s3 = s1.difference(s2)，返回给s3的是s1中不包含s2内元素的序列，即求差集，与“-”的效果相同 |
| difference_upatde() | 同上，但不返回，直接对s1进行修改 |
| intersection() | 返回两个集合之间的交集，其效果也与“&”相同 |
| intersection_update() | 同上。但不返回，直接对s1进行修改 |
| isdisjoint() | 判断两个集合是否有交集，有就返回False |
| issubset() | s1.issubset(s2)，判断s1是否为s2的子集，是返回True |
| issupperset() | s1.issuperset(s2)，判断s1是否为s2的超集，是返回True |
| symmetric_difference（） | s1.symmetric_difference(s2)，返回集合s1和集合s2的对称差集，其效果与“^”相同 |
| symmetric_difference_update（） | 同上，但并不返回，直接对s1进行修改 |
字符串
Ⅰ、在python中，字符串是基本数据类型，是一个不可变序列。到此为止，我们学到的两种不可变序列为元组 和 字符串。
Ⅱ、需要注意的是，字符串有驻留机制。
什么叫做驻留机制呢？
进保存一份相同且不可变字符串的方法，不同的值被存放在字符串的驻留池中 ，对相同的字符串只保留一份拷贝，后续如果创建相同的字符串，并不会开辟新的空间，而是把该字符串的地址赋给这个新创建的变量。
一、驻留机制的几种情况(交互模式)（cmd）
- 字符串的驻留机制
- 符合标识符的字符串
- 字符串只在编译时进行驻留，而非运行时
- [-5,256]之间的整数数字
二、sys中的intern方法强制2个字符串指向同一个对象（cmd）
三、PyCharm对字符串进行了优化处理
Ⅲ、对于字符串的拼接，可以使用”+“，也可以使用join()，推荐使用join()，其可以计算出所有字符串的长度，然后再拷贝，只需要new一次，效率更高
Ⅳ、关于索引，其与列表相同，有正向的索引，也有负向的索引
创建方式：
# 创建
# 1、使用 ''
st1 = 'abc'
# 2、使用""
st2 = "def"
# 3、使用''''''
st3 = '''gh'''
方法：
| 函数名称 | 介绍 |
|---|---|
| index() | 查找子串substr第一次出现的位置，如果子串不存在时，抛出异常 |
| rindex() | 查找子串substr最后一次出现的位置，如果子串不存再，抛出异常 |
| find() | 查找子串substr第一次出现的位置，如果不存在返回-1 |
| rfind() | 查找子串substr最后一次出现的位置，如果不存在返回-1 |
| upper() | 将小写转换为大写，需要返回 |
| lower() | 将大写转换为小写，需要返回 |
| swapcase() | 将字符串中的大写换为小写，小写换为大写，需要返回 |
| capitalize() | 将第一个字符转换为大写，其余字符转为小写，需要返回 |
| title() | 把每个单词的第一个字符转换为大写，剩余字符转换为小写，需要返回 |
| center(width,str) | 居中对齐，width指定宽度，str指定填充字符，若width小于字符串长度，则返回原串 |
| ljust() | 左对齐，同上 |
| rjust() | 右对齐，同上 |
| zfill() | 右对齐，左边用0填充，与上面右对齐不同的是，其只接收一个参数：width |
| split(sep, ms) | 从左边开始分割字符串，默认以空格作为分割的标志，返回值为列表，也可以通过指定符号来分割，sep=''，sp为maxsplit，即最大分割次数 |
| rsplit() | 同上，但是从字符串的右侧开始分割 |
| isidentifier() | 判断字符串是否为合法的标识符（字母，数字，下划线） |
| isspace() | 判断字符是否全为空格组成 |
| isalpha() | 判断字符串是否全部由字母组成 |
| isdecimal() | 判断字符串是否全部由十进制组成 |
| isnumeric() | 判断字符串是否全部由数字组成 |
| isalnum() | 判断字符串是个否全部由字母和数字组成 |
| replace() | 字符串的替换，第一个参数指定操作子串，第二参数为替换的的内容，第三个参数为最大替换次数 |
| join() | 将列表或者元组中的字符串合并成一个字符串 |
字符串之间的比较：
类似C/C++，需要注意的是“==”和 “is” 之间的区别：
== ：比较的是value
is：比较的是id
字符串的切片操作：
因为字符串是不可变类型，不具备增删改等操作，所以切片必定会产生新的对象。
# 操作1
st6 = 'abcdefg'
temp7 = st6[:3]
print('st6[:3]=', temp7)
temp8 = st6[5:]
print('st6[5:]=', temp8)
# 操作2
# st6[start:end:step]
# 因为字符串可以使用负的下标，同理，切片也可以使用
temp9 = st6[1:6:2]
print('st6[1:6:2]=', temp9)
运行结果：
st6[:3]= abc
st6[:5]= fg
st6[1:2:2]= bdf
格式化字符串：
格式化字符串有两种方式：
1、%作占位符
格式：print('name=%s,age=%d' % (name,age))
其格式化输出（宽度、精度与C语言相似，在此不做过多介绍）
2、{}作占位符
格式：print('name={0},age={1}'.format(name,age))
其格式化输出：
print('Pi = {0:.3f}'.format(3.1415962))
其运行结果为：Pi = 3.142
起始也与%作占位符的操作类似。
3、f-string
print(f'name={name},age={age}')
具体例子：
name = 'li bai'
age = 24
temp = (name, age)
# %
print("1、使用%作占位符：")
print('name=%s,age=%d' % temp)
# {}
print("2、使用{}作占位符：")
print('name={0},age={1}'.format(name, age))
# f-string
print("3、使用f-string")
print(f'name={name},age={age}')
运行结果：
1、使用%作占位符：
name=li bai,age=24
2、使用{}作占位符：
name=li bai,age=24
3、使用f-string
name=li bai,age=24
字符串的编码和解码：
编码：将字符串转换为二进制数据
GBK：每个中文字符占两个字节
UTF-8：每个中文字符占三个字节
解码：将二进制数据转换为字符串
tips：用什么编码，就要相对用的用什么解码
具体的使用方法：
st1 = '梅花'
# 编码
print(st1.encode(encoding='utf-8'))
print(st1.encode(encoding='GBK'))
# 解码
st2 = st1.encode(encoding='GBK')
print(st2.decode(encoding='GBK'))
运行结果：（前面的 b 表示为二进制）
b'\xe6\xa2\x85\xe8\x8a\xb1'
b'\xc3\xb7\xbb\xa8'
梅花
（后续在学习过程中会补充一些相关内容…）