python学习笔记DAY03（数据类型及其内置方法）

这是我个人的学习笔记，都赖于（egon老师）的分享，以下是老师博客的原地址：

https://www.cnblogs.com/xiaoyuanqujing/articles/11640888.html

python基本数据类型及其内置方法

我们之前已经提到过基本数据类型，今天我们就来具体认识下它们。以及如何使用它们。

一、数字类型int and float

1）定义

• 定义整型：age = 22 相当于（age = int（22））

• 定义浮点型：weight = 48.55 相当于（weight = float（48.55））

2）类型转换

• int 和 float互相转换：a= int（16.88）|a = 16 (浮点转成整数只取整数部分)

​ a= float（16）|a = 16.0 (整数转浮点数会在整数后面追加一位小数)

• 纯数字字符串转数字：a = int("16") | a = 16 / a = float("16.88") | a = 16 .88

3）使用

数字类型主要用来做数学运算和比较运算。

二、字符串str

1）定义

• 单引号：name = '任意内容'

• 双引号：name = "任意内容"

• 三引号：name = """这是一个可以换行的字符串"""

• 定义空字符串：name = ""

2）类型转换

str（）可以将任何类型转换成字符串类型。

3）使用

• 字符串取值：name[0] name[1] 正向取值，name[-1] name[-2] 反向取值。注意：字符串的值只能取不能改

• 切片取值：name[0:5] 取0号索引到4号索引的值，

  ​ name[0:5:2]在之前的基础上隔两个位置取一个值，

  ​ name[5:0：-1]反向取值 | name[ : ] 全部取值 | name[ : ：-1] 反向全部取值

• 长度（len）：len（name）获取字符串name的字符长度。

• 成员运算 （in/not in）：判断一段字符是否存在于另外更长的一段字符内。

• 移除字符串首尾指定字符 （.strip ）: " hello,nida ".strip （） 即可去除空白字符，包括回车。

  ​ " **** hello,nida ****** ".strip（*） 即可去除字符串首尾星号。

• 切分（split）：把一个字符串以某种分隔符进行分割，默认已字符串内的空格作为分割点进行分割。"nida is a gril".pllit() | 结果：['nida', 'is', 'a', 'girl']

  指定分割次数："2021:04:21:15:07".split(":",3) | 结果：['2021', '04', '21', '15:07']

• 其余常用：（lstrip）"-----2021:04:21:15:07----".lstrip("-") |结果：2021:04:21:15:07---- 意义：去除左边指定字符

  ​ （rstrip）"-----2021:04:21:15:07----".rstrip("-") |结果：-----2021:04:21:15:07 意义：去除右边指定字符

  ​ （lower）"AGBAERG".lower() |结果：agbaerg 意义：字符全部改为小写

  ​ （upper）"AGBjopRG".upper() |结果：AGBJOPRG 意义：字符全部改为大写

  ​ （startwith）"AGBjopRG".startswith("A") |结果：True 意义：判断是否以指定字符开头

  ​ （endwith）"AGBjopRG".endswith("g") |结果：False 意义：判断是否以指定字符结尾

  ​ （format）"{t}2021:04:21:15:07".format(t = "时间") |结果：时间2021:04:21:15:07 意义：引用数据

  ​ （rsplit）在切分的时候已经说过split，这个rsplit 就是从右往左开始切分。（只有在控制了切分次数才会有用，其它时间直接用split就可以了）

  ​ （join）a= ["nida","yaoyao","lili","ming"]/":".join(a) |结果：nida:yaoyao:lili:ming 意义：用指定字符把不同元素合并为同一个字符串。（适用于所有带有字符元素的数据）

  ​ （replace）"nida".replace("n","w") | 结果：wida 意义：指定字符的某个值替换为指定的值

  ​ （isdigit）"135456467".isdigit() |结果：True 意义：判断一个字符串是不是纯数字组成

  ​ （isnumberic）"四".isnumeric() |结果：True 意义：判断一个字符串是不是其他意义的数字

  其余了解：（find）"nidayaoyao".find("yao") |结果：4 意义：判断一个字符在字符串中第一次出现的起始索引

  ​ （index）意义同上，但是如果找不到指定值，find会返回-1，index会直接报错

  ​ （ceter）"nidayaoyao".center(20,"-") | 结果：-----nidayaoyao----- 意义：格式化打印，打印出20字符，不够用 - 补上，居中对齐。(ljust：左对齐) (rjust：左对齐) (zfill：右对齐，不够用0补充)

  ​ （captalize）"hello nida".capitalize() | 结果：Hello nida 意义：整个字符串首字母大写

  ​ （swapcase）"Hello Nida".swapcase() | 结果：hELLO nIDA 意义：大小写反转

  ​ （title）"hello nida".title() | 结果：Hello Nida 意义：每个单词首字母大写

  ​ （islower）意义：判断字符是不是全小写

  ​ （isupper）意义：判断字符是不是全大写

  ​ （istitle）意义：判断字符每个单词首字母是不是全大写

  ​ （isalnum）意义：判断字符串是不是由字母或者数字或者字母和数字组成

  ​ （isalpha）意义：判断字符串是不是由字母组成

  ​ （isspace）意义：判断字符串是不是全空格

  ​ （isidentfier）意义：判断命名是否符合规范

三、列表list

可以存多个值，索引对应多个值。元素之间用 , 逗号分隔。（list中的元素可以取也可以改）

注意：无论要对列表进行 取值，添加，修改 如果指定索引不存在，就会报错

1）定义

list1 = ["nida",5,6] | 空列表 list2 = []

2）类型转换

只要能被for循环遍历的就可以转换成列表。list会和for循环一样，遍历所有数据，然后把每一个元素放到列表中。

list('wdad') # 结果：['w', 'd', 'a', 'd'] 字符串
list({"name":"jason","age":18}) #结果：['name', 'age']  字典
list((1,2,3)) # 结果：[1, 2, 3] 元组
list({1,2,3,4}) # 结果：[1, 2, 3, 4] 集合

3）使用

list1 = ["nida","yaoyao",1,2]
list2 = ["meyo",3]
list1.append("echo")    # 结果:['nida', 'yaoyao', 1, 2, 'echo']  追加值
list1.insert(1,"ming")  # 结果：['nida', 'ming', 'yaoyao', 1, 2]  指定位置插入值
list1.extend(list2)     # 结果：['nida', 'yaoyao', 1, 2, 'meyo', 3]  合并两个列表
name = list1.pop(1)     # 结果：yaoyao  删除指定索引值，并且返回被删除的值
list1.remove(1)         # 结果：['nida', 1, 2]  删除指定索引值，没有返回值
------------------------------------------------------------------------------
list3 = [10,2,52,63,7]
a = list1.count("nida")    #结果： 1  统计指定元素在列表中出现次数
list1.reverse()            #结果： [2, 1, 'yaoyao', 'nida']  整个列表倒过来
list3.sort(reverse=True)   #结果：[63, 52, 10, 7, 2]  列表按降序排序
list3.sort(reverse=False) 就是 list3.sort()  #结果：[2, 7, 10, 52, 63] 列表按升序排序（默认）
关于.sort 的底层逻辑，就是把列表的所有元素拿出来，两两比较后确定是否更换位置，然后达到排序的效果。
注意：只有所有元素同属一个类型才可以排序

• 切片：与字符串切片用法一样。（切片就相当于浅拷贝，在python中所有默认copy都是浅拷贝）

四、元组tuple

​ 元组就是一个不可变列表，只用于读取操作。（元组不可变指的是元素的内存地址不可变，但是本身这个元素是个可变类型，那么可变元素内的元素更改并不会影响元组元素的内存地址）。

如果有多个值需要存储，但是后续只需要读取，那么最好使用元组。

1）定义

t = (10,12,15) 定义一个新元组 t 。（注意如果要定义元组，但是只有一个值需要在末尾加上，逗号。不然会被认为就是个包含意义）

2）类型转换

类型转换与列表一致

3）使用

常用方法与列表一致

五、字典dict

字典存储数据是{key：value}格式，字典又被称为映射类型。（注意，key必须唯一，value随意）

1）定义

d= {"name":"nida"} 定义一个字典。 | d={} 定义一个空字典 |d =dict(a=1,b=2) 也可以定义一个字典

2）类型转换

list1 = [['name','tony'],('age',18)])
dict1 = dict（list1） 列表转换为字典
d = {}.fromkeys(('name','age','sex'),None) 结果： {'name': None, 'age': None, 'sex': None}元组转为字典，元组元素为key,value设默认值为None。 

经常会使用{}.fromkeys初始化一个字典。

3）使用

d = {'age': 18, 'sex': "女", 'name': "nida"}
len(d)               # 统计key的数量
in  not in           # 判断的是key是否存在
v = d.popitem()      # 结果：('name', 'nida')  随机删除一个元素，并以元组的格式返回被删除的key,value
r = d.setdefault("name","lili")  # nida 对字典添加元素，如果key已存在，不会更改元素并且返回 对应key的value
r = d.setdefault("class",5)      # 5 对字典添加元素，如果key不存在，向字典追加并且返回 对应key的value
d.update({"name":"lili","sex":"男"}) # {'age': 18, 'sex': '男', 'name': 'lili'} 用新字典更新老字典，有则修改，无则添加
d.keys()    # dict_keys(['age', 'sex', 'name'])     获取全部key 列表形式
d.values()  # dict_values([18, '女', 'nida'])       获取全部value  列表形式
d.items()   # dict_items([('age', 18), ('sex', '女'), ('name', 'nida')]) 获取全部key，value  列表形式
r = d.get("nn") # None  按照key取值，如果存在就获取key对应的value值，如果key不存在 就返回None (不会报错)
# 备注：在字典取值时，一般都是用get，容错性好

六、集合set

集合和其它容器类型一样可以存多个值，但是集合有它自己的独到之处：

1.集合内元素为不可变类型 / 2.集合内元素不能重复 / 3.集合内元素无序

所以，在编写代码的过程中，主要是用集合来进行两组数据的整体运算。

1）定义

s = {"neme","age",18} 定义一个集合 因为s = {} 是一个空字典，所以定义空集合必须是s = set{}

2）类型转换

s = set((8,9,3,"nida"))     # 元组转集合
s1 = set([1,2,3,4])         # 列表转集合
s2 = set({'name':'jason'})  # 字典转集合(只取value)
s3 = set('nidaisgril')      # 字符串转集合(分隔每个字符)

如上代码，虽然所有容器类型都可以转为元组，但是请记住集合的特性。如果被转换内容有重复值，会被消除；如果内容有可变类型，就会报错；而且，转换完成之后，元素顺序被打乱。

备注：凡是可以被for循环遍历的数据类型，都可以转换为集合。

3）使用

• 运算符号+集合 的使用

n = s1 & s2    # {'d', 'c'}  交集：& 取的是两组数据重复的部分
n1 = s1 | s2   # {'d', 'f', 'b', 'e', 'c', 'a'}  合集： |  取的是两组数据合并之后，去重
n2 = s1 - s2   # {'a', 'b'} 差集： 取的是第一组数据去除与第二组数据重复后，剩下的部分
n3 = s2 - s1   # {'e', 'f'} 差集：同上，（注意每组数据的位置）
n4 = s1 ^ s2   # {'e', 'a', 'b', 'f'} 对称差集：取的是两组数据合并之后，删除掉交集的数据
s1 > s2 # (True/False)  父子集：判断一组数据是否包含或等于另一组数据
s1 < s2 # (True/False)  父子集：判断一组数据是否包含或等于另一组数据

• 内置方法的使用

n = s1.intersection(s2)  # {'d', 'c'}  交集：& 取的是两组数据重复的部分
n1 = s1.union(s2) # {'d', 'f', 'b', 'e', 'c', 'a'}  合集： |  取的是两组数据合并之后，去重
n2 = s1.difference(s2) # {'a', 'b'} 差集： 取的是第一组数据去除与第二组数据重复后，剩下的部分
n3 = s2.difference(s1) # {'e', 'f'} 差集：同上，（注意每组数据的位置）
n4 = s1.symmetric_difference(s2) # {'e', 'a', 'b', 'f'} 对称差集：取的是两组数据合并之后，删除掉交集的数据
s1.issubset(s2)  # 就是 s1 > s2  父子集：判断一组数据是否包含或等于另一组数据
s2.issubset(s1)  # 就是 s1 < s2 父子集：判断一组数据是否包含或等于另一组数据
s = {"nida",25}
s1 = {"nida",25}
s.remove("nnnnnn")  #删除不存在元素会报错
s.discard("nnnnn")  #删除不存在元素不会报错
s.update({"linlin","100"})  #就是表示把新列表与旧列表合并
v = s.pop("nida")    #删除指定元素，并返回
s.add("lin")         #对集合进行元素的添加
t = s.isdisjoint(s1)   #判断两个是否是独立的

总结：在具体使用的过程中，运算符号一目了然，一般不用内置方法进行两组数据对比。

六、可变不可变数据类型

可变数据类型：值发生改变时，内存地址不变，就是说ID不变。证明改变的是原值

不可变数据类型：值在生改变时，内存地址也发生改变，就是说ID也变，证明原值没有改，是产生了新的值

• 数字类型数据

数字类型数据，值改变的时候，ID也已经变化了。

i = 10   #ID:2440034216528
i = 20   #ID:2502124596112

• 字符串类型数据

字符串类型数据，值改变的时候，ID也已经变化了。

r = "nida"   #ID:2918924565552
r = "yaoyao"   #ID:1527711352368

• 列表类型数据

列表类型数据，值改变的时候，ID不会发生变化。

l = ["nida","yaoyao"]
print(id(l))     #ID:2905255844480
l.append("ming")
print(id(l))     #ID:2905255844480
l[0] = "fan"
print(id(l))     #ID:2905255844480

• 字典类型数据

字典类型数据，值改变的时候，ID不会发生变化。

d = {"name":"nida","age":20}
print(id(d))     #ID:1154069448128
d["name"] = "yaoyao"
print(id(d))     #ID:1154069448128

• 元组类型数据

元组类型数据，如果元素本身发生变化，系统会报错。但是元组在创建之初如果有可变类型在内，而之后这个可变类型内的元素发生变化时，对元组元素的内存地址是不会用影响的。所以ID不会发生改变

t = ("nida","yaoyao",[18,30])
print(id(t))     #ID:1879731385984
t[2][0] = 15
print(id(t))     #ID:1879731385984
t[0] = "ming"
print(id(t))     #报错

• 集合类型数据

集合类型数据，在最初创建时就不允许有可变类型存在。如果想对集合里的元素进行修改，就会报错

s = {"nida",25}
print(id(s))     #ID:1313377259296
s[2] = 5         #报错