python数据类型

数值类型
1.1 整型int

• 类型转换：int("10")
• 10进制转为二进制：bin()
• 10进制转为八进制：oct()
• 10进制转为16进制：hex()
• 二进制转为10进制：int("0b1011",2)
• 八进制转为10进制：int("0o13",8)
• 16进制转为10进制：int('0xb',16)

1.2 浮点型float:使用同int

字符串类型
2.1 用引号（''，""，''' '''，""" """，）包含的一串字符
2.2 类型str
2.3 类型转换：str(xxx)，可以将任意类型转为字符串
2.4 内置方法：

• 按索引取值(正向取+反向取) ：只能取

  msg='hello world'
  # 正向取
  print(msg[0])
  print(msg[5])
  # 反向取
  print(msg[-1])
  

• 切片[start:end:step]:索引的拓展应用，从一个大字符串中拷贝出一个子字符串

  msg='hello world'
  # 步长
  print(msg[0:5:2]) # hlo
  
  # 反向步长
  print(msg[5:0:-2]) # " le"
  

• 默认切片：[:]、[::-1](字符串倒序)

• 长度：len()

• 成员运算in和not in

• 移除字符串左右两侧的符号：strip()，产生新值

  • 默认str.strip()是去掉左右空格
  • str.strip("*")去掉左右*,以此类推
  • lstrip():去掉左侧空格
  • rstrip():去掉右边空格

• 切分：split(xxx,分割次数)按照分隔符xxx切分成列表，默认是空格

  • rsplit():从右开始分割

• lower():大写转小写

• upper():小写转大写

• startswith():以xxx开头

• endswith():以xxx结尾

• format():字符串格式化

• join():xx.join(list),将列表list以分隔符xx连接到一起

• replace(目标元素，替换元素，[次数]):替换

• str.isdigit():判断str是否由纯数字组成

  print('123'.isdigit()) # True
  print('12444.3'.isdigit()) # False
  

• find():返回起始索引，找不到返回-1

  • rfind():从右开始查找

• index():返回起始索引，找不到抛出异常

  • rindex():从右开始查找

• count(xxx):返回xxx出现的个数

• 对齐方式

  • str.center(位数，填充参数)：居中对齐，填充
  • str.ljust(位数，填充参数):左对齐，其余填充
  • str.rjust(位数，填充参数):右对齐，其余填充
  • str.zfill(位数):右对齐,填充0

• str.expandtabs(空格数)：设置制表符代表的空格数

  msg='hello\tworld'
  print(msg.expandtabs(12)) # 设置制表符代表的空格数为12
  

• str.captalize():首字母大写

• str.swapcase():大小写字母切换

• str.title():每个单词首字母大写

• str.isXXX():

  print('abc'.islower())
  print('ABC'.isupper())
  print('Hello World'.istitle())
  print('123123aadsf'.isalnum()) # 字符串由字母或数字组成结果为True
  print('ad'.isalpha()) # 字符串由由字母组成结果为True
  print('     '.isspace()) # 字符串由空格组成结果为True
  print('print'.isidentifier())
  print('age_of_egon'.isidentifier())
  print('1age_of_egon'.isidentifier()) # 字符是否有效
  
  
  num1=b'4' #bytes
  num2=u'4' #unicode,python3中无需加u就是unicode
  num3='四' #中文数字
  num4='Ⅳ' #罗马数字
  
  # isdigit只能识别：num1、num2
  # print(num1.isdigit()) # True
  # print(num2.isdigit()) # True
  # print(num3.isdigit()) # False
  # print(num4.isdigit()) # False
  
  # isnumberic可以识别：num2、num3、num4
  # print(num2.isnumeric()) # True
  # print(num3.isnumeric()) # True
  # print(num4.isnumeric()) # True
  
  # isdecimal只能识别：num2
  # print(num2.isdecimal()) # True
  # print(num3.isdecimal()) # False
  # print(num4.isdecimal()) # False
  

列表类型
3.1 索引对应值，[]中以逗号隔开任意类型的值，每一个值称为一个元素
3.2 索引反映的是顺序、位置，对值没有描述性的功能

nams_list = ['hyf','asd','sdfass',3,{"name":"bbb"}]

3.3 类型转换: 但凡能够被for循环遍历的类型都可以当做参数传给list()转成列表
3.4 内置方法；

• 按索引存取值(正向存取+反向存取)：即可以取也可以改，索引不存在则报错
• 切片(顾头不顾尾，步长)：list[start:end:step]切片等同于拷贝行为，而且相当于浅copy
• len(list):返回列表长度
• in、not in:成员运算符
• 添加值:
  • list.append():追加
  • list.insert(位置，值):插入
  • list2.extend(list1):将list1做了一层扁平化，然后追加到list2列表中
• 删除：
  • del list[0]:只是删除没有返回值
  • list.pop([index]):默认删除最后一个，可以通过传入的下标删除，超出报错
  • list.remove(目标元素)：根据元素删除，返回None
• list.count(目标元素)：返回目标元素的个数
• list.index(目标元素)：返回目标元素的下标，没找到报错
• list.clear():返回一个空列表
• list.reverse():列表倒序
• list.sort([reverse=True]):默认从小到大排序，reverse=True时从大到小排序

元组：一个不可变的列表

1. 作用：按照索引/位置存放多个值，只用于读不用于改

2. 定义：(value1,value2,....)小括号内用逗号隔开,单独一个括号代表包含的意思,如果元组中只有一个元素，必须加逗号

3. 类型转换：tuple()

   print(tuple('hello')) # ('h', 'e', 'l', 'l', 'o')
   print(tuple([1,2,3])) # (1, 2, 3)
   print(tuple({'a1':111,'a2':333})) # ('a1', 'a2')
   

4. 内置方法：

   • 按索引取值(正向取+反向取)：只能取
   • 切片(顾头不顾尾，步长)
   • len()
   • in、not in:成员运算
   • index():查找元素下标
   • count():获取目标元素在元组中的个数

字典类型

1. 键值对，key对值有描述性的功能
2. {key:value,...}key必须是不可变类型
3. 定义：

   1. d = {'k1'=11,'k2'=33}

   2. d = dict(x=1,y=2,z=3)

   3. d = dict([["name",'hyf'],["age",22]])

   4. 快速初始化

      keys = ['name','age','gender']
      
      d = {}.fromkeys(keys,None)
      

4. 内置方法：

   • 按key存取值：可存可取

   • len(dict):长度

   • 成员运算in和not in:根据key

   • 删除：

     • del dict[key]
     • dict.pop(key)
     • dict.popitem():随机删除，返回元组(删除的key,删除的value)

   • dict.keys():在python3中返回的是dict_keys,需要使用for循环取值

     d = {"k1":22,"k2":44}
     my_dict_list = d.keys() # dict_keys(['k1', 'k2'])
     for k in my_dict_list:
        print(k) # k1,k2
     # 可以使用 list函数将dict_keys转化为列表
     my_dict_list2 = list(d.keys()) # ['k1', 'k2']
     

   • dict.values():获取value值dict_values,同上

   • dict.items():获取键值对，同上

   • dict.clear():清空

   • dict.update():更新字典，

   • dict.get(key):取值，key不存在时返回None

   • dict.setdefault(key):如果key存在则不添加，否则添加。返回字典中key对应的值

     info_dict = {"k1":22}
     info_dict.setdefault("k1",555)
     print(info_dict) # {"k1":22} 因为k1存在
     info_dict.setdefault("k2",555)
     print(info_dict) # {"k1":22,"k2":555} 因为k2不存在
     

布尔类型:真假状态True 和 False

集合

1. 作用：

   1. 关系运算
   2. 去重
      1. 只能针对不可变类型
      2. 无法保证原有顺序

2. 定义：在{key1,key2}中用逗号隔开多个元素，

   # 1. 集合内元素必须为不可变类型
   # 2. 集合内元素无序
   # 3. 集合内元素没有重复
   s = {1,2,1} # s = set({1,2,1})
   print(s,type(s)) # {1, 2} <class 'set'>
   
   # s = {1,[2,3]} # 报错
   # s = {1,'a','z','b',4,7} 
   # print(s,type(s)) # {1, 'z', 4, 7, 'a', 'b'}  <class 'set'>
   # 默认是空字典
   # s={} 
   # 空集合
   # s = set() # print(s,type(s))-->set() <class 'set'>
   

3. 类型转换：set(可迭代类型)

   print(set('hello world')) # {'r', 'o', 'e', 'w', 'd', 'l', ' ', 'h'}
   print(set({'key1':2,"key2":3})) # {'key2', 'key1'}
   print(set([1,1,1,1,1,1])) # {1}
   

4. 内置方法

   1. 取交集：两者共同部分

   2. 取并集：两者全部

   3. 取差集：某一方独有

   4. 对称差集：两方独有

   5. 父子集：包含关系

      set1 = {"zero","kevin","jason","egon"}
      set2 = {"Jy","ricky","jason","egon"}
      # 交集
      res_1 = set1 & set2
      res_2 = set1.intersection(set2)
      print(res_1) # {'egon', 'jason'} {'egon', 'jason'}
      
      # 并集
      res_3 = set1|set2
      res_4 = set1.union(set2)
      print(res_4) # {'zero', 'egon', 'kevin', 'ricky', 'Jy', 'jason'}
      
      # 取差集
      res_5 = set1 - set2 # 取set1独有
      res_6 = set2 - set1 # 取set2独有
      res_7 = set1.difference(set2) # 取set1独有
      res_7 = set2.difference(set1) # 取set2独有
      
      # 对称差集
      res_8 = set1 ^ set2 
      res_9 = set1.symmetric_difference(set2)
      
      # 父子集:issuperset 大于，issubset小于
      set3 = {1,2,3}
      set4 = {1,2}
      set5 = {1,2,4}
      res_10 = set3 > set4 
      res_11 = set3 > set5
      res_12 = set5 > set4
      print(res_10,res_11,res_12) # True false True
      

   6. set.discard(目标元素)：删除目标元素，不存在时do nothing

   7. set.pop():删除最后一个，可以理解为随机删除

   8. set.remove(目标元素)：删除目标元素，不存在时报错

   9. set.update(set1):更新元集合数据

   10. set.add():添加

   11. set.isdisjoint(set1):两个集合是否完全独立