📔 Python基本数据类型 学习笔记

1. 可变和不可变类型

• 可变类型：值改变，id不变。

  • 证明改的是原值。证明原值可以被改变。

• 不可变类型：值改变，id也会改变。

  • 证明产生新的值，原值不会被改变（不可被改变）。

• int是不可变类型

  x=10
  print(id(x))
  
  x=11 # 此时已经产生新的值
  print(id(x))
  

• 浮点型(float)也是不可变类型

  x=3.1
  print(id(x))
  
  x=3.2 
  print(id(x))
  

• str是不可变类型

  x='abc'
  print(id(x))
  
  x='def'
  print(id(x))
  

• bool 是不可变类型

总结：在python中，int、float、str被设计成一个整体，不可以被改变。

• list是可变类型

  list00 = [1,2,3,4]
  
  print(id(list00))
  list00[0] = 10
  print(id(list00))
  

• dict是可变类型

  dict = {"name":"Bob","Age":18}
  print(id(dict))
  dict["name"] = "SolerHO"
  print(id(dict))
  

2. 字符串类型

• str可以将任意其他类型都转成字符串类型。

• 在Python中，有很多字符串的内置方法。

2.1 按索引取值（正向和反向）

• 只能进行取值，不能进行修改。
• 正向取值：直接从0开始取值。
• 反向取值：从-1开始取值。

 str_msg = "Hello World"
 # 正向取值
print(str_msg[0])
print(str_msg[3])
# 反向取值
print(str_msg[-1])

2.2 字符串的切片

是索引的扩展，从一个大的字符串中拷贝出一个子字符串。

msg = "Hello world"

# 直接指定范围，类似for循环取值
print(msg[0:5]) # 注意，取值过程中，和for循环中的range类似，包括起点，不包括终点。

# 步长

# 增加步长，起点+2步长的方式索引，取一个字符出来。（正向步长）
print(msg[0:5:2]) # 步长为2，所以输出结果为：Hlo

# 反向步长
print(msg([5:0:-1])) # 从终点开始，然后到起点（注意此时不包括起点），逆向来处理字符串

# 如果不写任何值
print(msg[:]) # 表示从起点开始到终点结束，等价于 print(msg[0:len(msg)])

# 反向取值
print(msg[::-1]) #表示从反向取值，表示字符串的反转

2.3 字符串的长度len

msg = "hello world"

print(len(msg))

2.4 字符串成员运算in和 not in

判断一个子字符串是否存在于一个字符串中。

2.5 移除 strip、lstrip、rstrip

msg = "   Hello    "

# ---- 移除字符串中的空白
print(msg.strip()) # 如果在strip中不设置任何值，则直接去除空格。

# ----- 去除制定的字符
msg11 = "-------Hello-------"
print(msg11.strip('-')) #移除-字符

# strip只取两边，但是不会去移除中间部分
msg22 = "-------Hello------World-------"
print(msg22.strip('-')) # 具体输出为：Hello------World （类似直接两头堵）

# 如果要移除多种情况
msg33 = "***/===??Hello===()"
print(msg33.strip('*/=?()')) # 此时输出信息为：Hello ，所有的符号或者指定相关的字符会被移除

• 三个区别

  msg = "-----Hello-----"
  print(msg.strip('-')) # 去除左右两边
  print(msg.lstrip('-')) # 去除左边
  print(msg.rstrip('-')) # 去除右边
  

2.6 切分 split 和 rsplit

把一个字符串按照某种分隔符进行切分，得到一个列表。

infor00 = "Soler 22  male"

# 默认不设置，则此时的分隔符是空格
print(infor00.split()) #此时生成列表为：["Soler","22","male"]

# 指定分隔符
infor11 = "SolerHO:22:Male"
pint(infor11.split(':')) # 指定 : 号进行移除

# 指定分隔次数
infor22 = "SolerHO:22:Male"
print(infor22.split(':',1)) # 只移除第一次的:符号，其他的不受影响。设定次数为1.

• split 和 rsplit 的区别

  infor22 = "SolerHO:22:Male"
  # 如果未指定次数，则两个切分的意义一样，但是设置次数之后，会有所差异。
  print(infor22.split(':',1)) # 指定次数后，从左往右切分
  print(infor22.rsplit(':',1)) # 指定次数后，从右往左切分
  

2.7 upper、lower ----- 大小写转换

infor = "SolerHO"
print(infor.lower()) # 全部直接转化为小写
print(infor.upper()) # 全部直接转换为大写

2.8 startswitch、endswitch

infor = "This is Hello world"
print(infor.startswitch("This")) # 以 This开头
print(infor.endswitch("world")) # 以 world结尾的

• 返回结果的形式为True，而不是字符串。

2.9 join ---- 拼接操作

把字符串或者列表进行拼接。对于 + 号也可以进行拼接，但是 + 号的效率极低。

l = ["SolerHO","22","Male"]
print(":".join(l)) # 按照某个分隔符，将全为字符串的列表拼接成一个新的字符串。

2.2 替换 replace

替换，如果不指定次数，则默认全部替换。

infor = "This is Solerho note home,welcome to solerho home"
print(infor.replace('solerho','SolerHO'))   # 未指定次数，所以直接全部替换
print(infor.replace('solerho','SolerHO',1)) # 指定次数，则替换从左往右的第一次

2.11 判断是否是数字：isdigit

判断字符串中是否有纯数字组成

print("123".isdigit())

• 返回的是True或者False。

2.12 查找（索引）：find、rfind、index、rindex

infor = "Hello World Solerho,welcome"
# find和index，如果可以找到，返回值是要查找的字符或字符串在大字符串中的起始索引，如果找不到，则直接抛出异常 -1
print(infor.find('e'))
print(infor.index('e'))

2.13 count ---- 统计个数

主要是统计某个字符或者字符串出现的次数。

infor = "This is is is is"
print(infor.count('is')) # 输出次数为4

2.14 显示位置：center、ljust、rjust、zfill

• center --- 居中显示，如果不够，则使用特定字符串来填充

  print("SolerHO",center(50,'*')) # 50是总的宽度，如果字符不够，则使用 * 来填充
  

• ljust ---- 左对齐

• rjust ---- 右对齐
• zfill ---- 默认右对齐，不够的则使用0来填充

2.15 指定宽度：expandtabs

指定制表符的宽度

infor = "Hello\tworld"
print(infor.expandtabs(2)) # 指定制表符的宽度为2

2.16 capitalize、swapcase、title

• capitalize ---- 表示首字母大写，不传任何参数

• swapcase ----- 表示大小写反转，大写变成小写，小写变成大写。不传任何参数

• title ---- 每个单词的首字母大写，不传任何参数

2.17 数字识别：isnumberic

• 可识别数字、纯中文数字和罗马数字

3. 列表类型

列表：按照位置来存储多个值。

定义：list = [] 在 [] 内可存储各种类型，数字、字符、字符串等。

• 按索引取值（正向存取+反向存取）：既可以取也可以改。

  list = ["Solerho",22,"Male"]
  
  # 正向取
  print（list[0]）
  # 反向取
  print(list[-1])
  # 可取可改（索引存在则修改对应的值，而索引不存在时，则会直接报错----超出范围）
  list[1]= 25
  print(list)
  

• 切片（顾头不顾尾，步长）。

  • 与字符串的切片类似

• 长度len

  • 直接使用len()即可

• 成员运算in 和 not in

• 追加append()

  list = ["Solerho",22,"Male"]
  list.append(55)
  print(list) # 直接追加到原列表中的末尾
  

• 指定位插入值

  list = ["Solerho",22,"Male"]
  list.insert(2,54) # 在索引2中插入值
  print(list)
  

• extend方法

  list = ["Solerho",22,"Male"]
  new_list = [1,2,3]
  
  # 直接将new_list添加
  list.append(new_list) 
  
  # 另外需求：将每个元素添加到list中，使用for的方式
  for item in new_list
      list.append(item)
  print(list)
  
  # 直接使用extend方法
  list.extend(new_list)
  print(list)
  

• 删除

  # 方式1 ： 通用的删除方法，只是单纯的删除、没有返回值
  list00 = ["SolerHO",22,54,"Male"]
  del l[1]
  print(list00)
  
  # 方式2；使用pop() ---- 根据索引进行删除
  list00.pop(1) # 不设定位置，则默认删除最后一个，如果设定索引，则删除对应索引位置的值
  
  # 方式3:使用remove ---- 根据元素进行删除
  list00.remove("Male")
  

• 需要掌握的操作

  • l.count() ------- 统计元素的个数
  • l.index() ------- 查找索引到元素的第一个值所在的位置。如果找不到就直接抛出异常
  • l.clear() ------- 清除整个列表中的元素，不进行传值。
  • l.reverse() ------- 直接反转列表，不是排序

  • l.sort() ------- 默认是升序（从小到大，此时reverse=False），如果要设置为降序，则修改reverse=True即可。

    • 对于字符串的排序，则是根据ASCII码表的先后顺序区别字符的大小。

4. 元组（tuple）类型

• 元组是不可变的列表类型。

  • 直接按照索引/位置来存放多个值，只能用于读，而不能修改。

• 定义

  • 用 () 来定义，() 内用逗号分隔开多个任意类型的元素。

  t = (1,3,5,'aa') # t = tuple((1,3,5,'aa'))
  print(t,type(t))
  
  x = (10) # 单独1个括号表示包含的意思。
  
  t = (10,) #如果在元组中只有一个元素，则必须使用逗号
  
  #对于元组而言，不能修改，只能读取使用，而在元组内嵌套的列表则可以修改，但是元组内的地址不会被修改。
  

• 按索引取值（正向取和反向取）

• 常见的内置方法：

  • index
  • count

5. 字典（dict）类型

• {} 内使用 逗号分隔 开多个 key:value。
  • value可以是任意类型，但key必须是不可变的类型，且key值不能重复，否则只保留一个。

5.1 定义方式

# 字典对应的类型： dict
dict_01 = {"Key01":111,(1,2,3):222} # 说明：字符串和元组tuple是不可变类型。
print(d[key01]) # 打印key01对应的值
print(d[(1,2,3)]) # 打印元组对应的value值

• 定义空字典的方式

  d1 = {} # 默认定义为空字典
  print(d1,type(d1))
  
  d2 = dict()
  print(d2,type(d2))
  
  d3 = dict(x = 1, y = 2, z = 3)
  print(d3,type(d3))
  

• 快速初始化字典的方式

  keys = {'name', 'age', 'gender'}
  # 方式1 ： 不简洁
  d1 = {}
  for k in keys:
      d1[k] = None
  print(d1)
  
  # 方式2 
  d2 = {}.fromkeys(keys,None)
  print(d2)
  

5.2 内置方法

• 按key存取值：可存可取

  # 主要针对赋值操作
  
  # 当key存在时，则进行修改操作。
  d1 = {'k1':111}
  d1['k1'] = 222
  print(d1)
  # 当key不存在时，则会创建新key值
  d1['k2'] = 333
  print(d1)
  
  # 如果打印某个不存在的值时，会直接报错
  print(d['k3'])
  

• 长度len

  • 统计key的个数，如果出现重复的key，则统计最后重名的key值

  d1 = {'k1':1, 'k2':2, 'k3':3,'k4':4}
  print(len(d1)) # 统计key的个数，如果出现重复的key，则统计最后重名的key值
  

• 成员运算 in 和 not in

  • 只能根据key来进行判断，不能使用value来进行判断成员。

  infor = {'name':'solerho','age':22,'sex':'male'}
  if 'name' in infor:
      PASS # 也可以使用 ... 和PASS等同
  # 目前可以通过使用setdefault来简化上述code
  print(infor.setdefault('name':'solerho')) # 返回字典中key对应的值
  

• 删除

  # 通用方式删除
  d1 = {'k1':1, 'k2':2, 'k3':3,'k4':4}
  del d1[k1]
  print(d1)
  # 使用pop删除：根据key删除元素，返回删除key对应的那个value值
  res = d1.pop('k4')
  print(d1)
  print(res) # 返回的是删除的value值
  
  # 使用popitem删除：随机删除，且返回的值是一个元组 (已删除key,已删除value)
  res = d.popitem()
  print(d)
  print(res) #打印删除的值
  

• 键keys()、值values()、键值对items()

  # 在python2中，目前暂不使用，可不关注，但需要了解
  d1 = {'k1':1, 'k2':2, 'k3':3,'k4':4}
  print(d1.keys()) # 打印key的列表 ['k1','k2','k3','k4']
  print(d1.values()) # 打印value的列表 [1,2,3,4]
  print(d1.items()) #打印一个键值对的元组 ('k1':1, 'k2':2, 'k3':3,'k4':4)
  
  # 在python中，得到的显示情况会和python2有所区别
  print(d1.keys()) # 打印key的列表 dict_keys(['k1','k2','k3','k4'])
  print(d1.values()) # 打印value的列表 dict_values([1,2,3,4])
  print(d1.items()) #打印一个键值对的元组 dict_items('k1':1, 'k2':2, 'k3':3,'k4':4)
  

  如果使用for循环的方式

  # 取出对应的key值
  for k in d1.keys():
      print(k)
  #取出对应的value
  for v in d1.values():
      print(v)
  #取出对应的元组值
  for k,v in d.items():
      print(k,v)
  

• 需要掌握的内置方法

  • dict.clear()：字典清空
  • dict.update()：如果不存在则新增，如果存在，但是key修改，则对应修改value值
  • dict.get()：如果key不存在，则直接显示None，如果存在，则正常打印信息。
  • dict.setdefault()：如果key存在，则不进行添加，如果key不存在，则进行添加。两种情况都返回字典中key对应的值

6. 集合类型

6.1 掌握点

• 关系运算

• 去重（有局限性）

• 总结与分类

  • 有序 or 无序（有序又称为序列类型）
  • 原子类型（存一个值）
  • 存多个值称为容器类型

6.2 作用

• 主要进行关系运算

  set1 = {3,5,6,8}
  set2 = {4,6,9,7}
  
  # 找到两个共同的元素
  # 方案1
  l =[]
  for x in set1:
      if x in set1:
          l.append(x)
  print(l)
  

• 去重

  • 仅仅针对不可变类型去重。
  • 无法保证原来的顺序。

6.3 定义

在 {} 内用逗号分隔开多个元素，多个元素满足以下条件：

• 集合内元素必须为不可变类型
• 集合内元素无序
• 集合内元素没有重复

set1={} #默认情况下是空字典
print(type(s))
# 定义空集合
s = set()
print(s,type(s))

6.4 类型转换

# set({1,2,4})
res = set('hello')
print(res) # 集合不能有重复，所以l（字母）只会出现一次

print(set([1,1,1,1,1])) # 该方式可行，且保留1
print(set(1,1,1,1,1,1,[11,22])) # list是一个可变的类型，会直接报错

print(set({'k1':1,'k2':2}))

6.5 内置方法

set1 = {3,5,6,8}
set2 = {4,6,9,7}

# 取出共同的部分（交集）
print(set1 & set2)
print(set1.intersection(set2))

# 取两者所有的部分（并集/合集）
print(set1 | set2)
print(set1.union(set2))

# 取独有的（差集）
print(set1 - set2) # 取set1独有的 print(set1.difference(set2))
print(set2 - set1) # 取set2独有的 print(set2.difference(set1))

# 对称差集：求两个集合独有的内容（即去掉共同的元素）
print(set1 ^ set2)
print(set1.symmetric_difference(set2))

# 父子集：包含关系
s1 = {1,2,3}
s2 = {1,2,4}

# 不存在包含关系。直接全部返回False
print(s1 > s2) 
print(s1 < s2)

# 如果如下集合
s3 = {1,2,3}
s4 = {1,2}
print(s3 > s4) # 当s3 大于或等于s4。说明s3是s4的父集
# 等价于 print(s3.issuperset(s4))
# 等价于 print(s4.issubset(s3))

# 删除集合中的一个元素
s3.discard(3) # 元素存在，会直接删除，如果元素不存在，则不进行操作，不会报错
s4.remove(3) # 如果元素不存在，删除操作则会直接报错

# len求长度

# update更新元素
s3.update({2,4,6,7}) # 将元素增加到s3集合中，然后再次进行去重


# 如果两个集合是独立则返回True
s3.isdisjoint({10,11,12}) # 返回为True

7. 几个数据类型的分类总结

• 按存值个数区分

  • 只能存一个值：可称为标量/原子类型：数字、字符串
  • 可以存放多个值：可称为容器类型。列表、元组、字典

• 按照访问方式来区分

  • 直接访问：只能通过变量名访问整个值：数字
  • 顺序访问：可以使用索引来访问指定的值，索引代表顺序，又称为序列类型。字符串、列表、元组
  • Key访问：可以使用Key访问指定的值，又称为映射类型。字典

• 按可变/不可变区分

  • 可变类型：列表、字典
  • 不可变类型：数字、字符串、元组

8. 参考资料

• Python官方文档
• W3CSchool Python教程
• 路飞学城Python开发视频课：B站