Python数据类型

1. 整型（int）

• 示例

  # 32位电脑 int长度长度 -2**31~2**32-1
  # 64位电脑 int类型长度 -2**64~2**64
  age = 18
  

• py2/py3的不同之处

  • int长度

    • Py2超出范围python会自动转化成long（长整型）
    • Py3中int不会转化为long类型，int自动兼容数据更长的长度

  • 除法

    • Py2中整型的除法只能保留整数位，需要引用py3的模块 from future import divsion

      print "3 / 2" # 得1
      

• 强制转化可转换类型

  • int(字符串)
  • int(布尔)

• 整型为不可变类型，修改整型变量是对内容重新赋值。

2. 布尔类型（bool）

• 布尔类型只有两个值：True,False
• 强制转换
  • boo(整型)：bool(1)-->True/bool(0)-->False
  • bool(字符串)：bool('aa')-->True/bool('')-->False
  • bool(列表)：bool([1])-->True/bool([])-->False
  • bool(元组)：bool((1)-->True)/bool(())-->False
  • bool(整数)：bool(0)-->True)/bool(1)-->False
• 布尔值为不可变类型，修改整型变量是对内容重新赋值。

3. 字符串（str）

1. 常用独有功能

   1. upper/lower

      • value.upper()

        value = 'aaa'
        new_value = value.upper() # 'AAA'
        

      • value.lower()

        value = 'AAA'
        new_value = value.lower() # 'aaa'
        

   2. isdigit

      判断是否为数字，返回布尔值的真，假

      while True:
      	num = input('请输入服务')
      	flag = num.isdigit()
      	if flag:
      		num = int(num)
      	else:
      		print('请输入数字')
      

   3. strip

      去除字符串左右两侧的空格，及换行符等

      user = input('请输入用户名') # 'alex  '
      # new_user = user.rstrip()
      # new_user = user.lstrip()
      new_user = user.strip()
      
      print('-->',user,'<--')	# 去掉了字符串两侧的空格 
      

   4. replace

      替换

      message = input('请说话')
      print(message) # '我去你大爷的家里玩'
      data = message.repalace('大爷'，'**')
      # data = message.repalace('大爷'，'**',2) # 第三个参数，指定要替换字符串，在整体字符串中的位置。
      
      print(data)
      

   5. split

      切割

      message = 'adsfadsf,afdasdf,adfadsf,'
      result = message.split(',')
      # result = message.split(',',1) # 从左向右第一个
      # result = message.rsplit(',',1) # 从右到左第一个
      print(result)
      

   6. startswith/endswith

      验证字符串是否已目标字符串开头或结尾

       ```python
       name = 'alex'
       flag1 = name.startswith('al')
       name.endswith('ex')
       print(flag1)
       print(flag2)
       ```
      

   7. format

         name = '我叫{0},年龄:{1}'.format('老男孩',73)
         print(name)
      

   8. encode

      Unicode 解码为其他编码

         name = '李杰' # 解释器读取到内存后，按照unicode编码存储：两个字符8个字节
         v1 = name.encode('utf-8')
         print(v1)
         v2 = name.encode('gbk')
         print(v2)
      

   9. join

         name = 'alex'
         result = '_'.join(name) # 循环每个元素，并在元素和元素之间加入连接分隔符
         print(result) # a_l_e_x
      

2. 公共功能

   1. len

      获取数据的长度

      value = 'adfdsfdsf'
      num = len(value)
      

   2. 索引取值

      v = 'oldboy'
      v1 = v[0]
      v2 = v[-1] # 负值，倒序取值
      

   3. 切片

      位置从0开始

      v = 'oldboy'
      v1 = v[2:3] # 位置 2 =< 索引位置 < 3
      v2 = v[3:6] # boy
      v3 = v[3:-1] # 位置3之后取到最后
      v4 = v[3:] # 位置3之后取到最后
      v5 = v[:-1] # oldbo
      v6 = v[-2:] # oy
      

   4. 步长

         name = 'alexalex'
         val = name[0:-1:2]
         print(val) # aeae
         val = name[0::2] # 从字符串的0的位置开始到最后，0之后空2个位置
         val = name[::2] # 从字符串的0的位置开始到最后，0之后空2个位置，正无穷，负无穷
         val = name[-1:0:-1] # 从倒数第一个到，第0个位置，整个字符串反向
         val = name[::-1] # 从倒数第一个到，第0个位置，整个字符串反向，正无穷，负无穷
         print(val) # 反转
      

   5. for循环

      name = 'alex'
      for item in name:
          print(item)
      

3. 强制转换

   可转换类型

   • str(999)
   • str(True)
   • ''.join(列表)
   • ''.join(元组)

4. 补充

   1. 常用字符串格式化

      # %s在字符串中占一个位置可以替换为对应的变量，%d对应整型，'%'用%%表示，变量所在的元组后加一个逗号，防止被误判为其他数据类型。
      name = '小瘪三'
      age = 18
      percent = '20'
      print('我是%s，我今年%d，我每天用%s%%的时间学习' % (name,age,percent,))
      

   2. 字符串为不可变类型，修改整型变量是对内容重新赋值。

4. 列表（list）

1. 常用独有功能

   • append

     列表追加元素

     users = []
     users.append('alex')
     print(users)
     

   • insert

     指定列表中的索引位置，插入元素

     users = ['aaa','bbb','ccc']
     users.insert(1,'jjj')
     print(users) # ['aaa','jjj',bbb','ccc']
     

   • remove

     users = ['aaa','bbb','ccc']
     users.remove('bbb')
     print(users)
     

   • 4. pop

     删除加索引位置

     users = ['aaa','bbb','ccc']
     # users.pop(2)
     users.pop() # 删除最后一个
     print(users)
     

   • clear

     users = ['aaa','bbb','ccc']
     users.clear()
     print(users)
     

   • extend

     循环列表中的每一个元素加入到另一个列表中

     users = ['aaa','bbb']
     people = ['ccc','ddd']
     users.extend(people)
     people.extend(users)
     
     something = ('eee','fff')
     users.extend(something) # 不可执行，元组中没有extend功能
     
     
     

   • pop

     a = li.pop # 删除元素后，赋值给另一个变量
     

2. 常用公共功能

   • len

     users = ['aaa','bbb',999]
     val = len(users)
     print(val) # 3
     

   • 索引

     users = ['aaa','bbb',99]
     val = users[0]
     

   • 切片

     users = ['aaa','bbb',99]
     val = users[0:2]
     

   • 步长

     users = ['aaa','bbb',99]
     val = users[0:2:2]
     

   • for循环

     users = ['aaa','bbb','ccc']
     for i in users:
         for ele in i:
             print(ele)
             
     users = ['alex','admin','egon']
     count = 0
     for i in users:
         print(count,i)
     
     users = ['alex','admin','egon']
     users_len = len(users)
     for i in range(0,users_len):
         print(i,users[i])
         
     

   • 删除

     列表是可变类型，del支持列表

     字符串是不可变不支持修改或删除

     users = ['aaa','bbb',99,88,77,66,55,44,33,22,11,22,33,44]
     del users[1]
     del users[1:8]
     

   • 修改

     字符串，布尔值不支持

     由于列表是课表类型，可替换列表中的元素

     users = ['aaa','bbb',99]
     users[2] = 66
     users[0] = 'ccc'
     

3. 强制转换

   可转换类型

   • list(字符串)
   • list(元组)

4. 补充

   1. 列表为可变类型，可在不改变内存地址指向的内存空间内对内容做修改

   2. join

      列表也可以使用join

      users = ['aa','bb','cc']
      value = '_'.join(li) # 'aa','bb','cc'
      

   3. 列表嵌套

      users = ['alex',0,True,[11,22,33,'老男孩'],[1,['alex','oldboy'],2,3]]
      users[0]
      users[2]
      users[0][2]
      users[3] # [11,22,33,'老男孩']
      users[3][-1][1] # '男'
      users[3] = 666
      

5. 元组（tuple）

1. 常用独有功能

2. 常用公共功能

   • 索引

     users = (11,22,33,'aaa')
     print(users[0])
     print(users[-1])
     

   • 切片

     users = (11,22,33,'aaa')
     print(users[0:2])
     

   • 步长

     users = (11,22,33,'aaa')
     print(users[0:2:2])
     

   • for循环

     users = (11,22,33,'aaa')
     for item users:
         print(item)
     

   • len

     users = (11,22,33,'aaa')
     users_len = len(users)
     print(users_len)
     

3. 强制转换

   可转换类型

   • tuple(字符串)
   • tuple(列表)

4. 补充

   1. 元组为不可变类型，元组中的元素不可被修改/删除

      v1 = (11,22,33)
      v1[2] = 9 # ×
      v1 = 999 # √
      
      # 元组可嵌套，可嵌套元组，也可嵌套列表
      v2 = [11,22,33,(11,22,33)]
      v2[-1][1] = 99 # ×
      v2[-1] 123 # √
      
      v3 = (11,22,33,[11,22])
      v3[1] = 666 # ×
      v3[1][2] = 123 # √
      

   2. 元组容易产生歧义的情况

      v1 = 1			# int类型
      v2 = (1)		# int类型
      v3 = (1,)		# 元组类型
      data = [(1),(2),(3)]  # 等价于[1,2,3]
      

6. 字典（dict）

帮助用户表示一个事务的信息(事务有多个属性，或多个值)

• 示例1

info = {'name':'刘伟达','age':18,'gender':'男','hobby':'同桌'}
name = info['name']
age = info['age']

• 示例2

userinfo = {'username':'alex','password':'123'}
user = input('请输入密码')
pwd = input('请输入密码')
if userinfo['username'] == user and userinfo['password'] == pwd:
    print('登录成功')
else:
    print('用户名或密码错误')
  

1. 独有功能

   info = {'name':'刘伟达','age':18,'gender':'男','hobby':'同桌'}
   info.keys() # 获取字典中的所有键
   info.values() # 获取自动中所有的值
   info.items() # 获取字典中所有键值对
   

   • keys，获取字典中所有的键

     for item in info.keys():
         print(item)
     

   • values，获取字典中所有的值

     for item in info.values():
         print(item)
     

   • items，获取字典中的所有的键值对

     for k,v in info.items():
         print(k,v)
     

   • get

     取不存在的索引不会报错

     info = {'k1':'v1','k2':'v2'}
     print(info['k111']) # 报错
     print(info['k111']) # 没有该键，但是不报错，返回None
     print(info['k111'],666) # 如果没有该键，返回666
     

   • pop

     删除

     info = {'k1':'v1','k2':'v2'}
     result = info.pop('k2')
     print(info,result) # 删除，并可赋值给另一个变量
     

   • update

     info = {'k1':'v1','k2':'v2'}
     info.update({'k3':'v3'})
     print(info) # 不存在即添加，存在即更新
     

2. 公共功能

   • len

   • 索引

     info['name']
     

   • for 默认循环value

   • 修改

     存在修改，不存在增加

     # 改值
     info['age'] = 22
     

   • 删除

     del info['name']
     

   • 新增

     info['xxx'] = 'xxx' # 用没有的键赋值的方式新增
     

3. 补充

   • 字典大概在3.7版本之前是无序的，3.7版本之后改为有序
   • 字典是可变类型，不改变内存地址的情况下，可改变内容

7. 集合（set）

. 集合set

1. 集合特性
   • 无序
   • 不重复

v = {1,2,3,4,6,99,100}

1. 空集合

   v1 = set()
   print(type(v1)) # <class 'set'>
   """
   对比其他数据类型的空
   None
   int
       v1 = 123
       v1 = int() --> 0
   bool
       v2 = True/False
       v2 = bool() -> False
   str
       v3 = ""
       v3 = str()
   list
       v4 = []
       v4 = list()
   tuple
       v5 = ()
       v5 = tuple()
   dict
       v6 = {}
       v6 = dict()
   set
       v7 = set()
   """
   

   2. 独有功能

   • add

     v = {1,2}
     v.add('lishao')
     v.add('lishao')
     print(v) # {1,2,'lishaoqi'}
     

   • discard

     删除

     v = {1,2,'lishao'}
     v.discard('lishao')
     print(v) # {1,2}
     
     

   • update

     批量添加

     v = {1,2,'lishao'}
     v.update({11,22,33})
     print(v) # {1,22,33,22,11,'lishao'}
     

   • 交集 intersection

     v = {1,2,'lishao'}
     result = v.intersection(1,'lishao','xiaohei')
     print(result) # {1,'lishao'}
     

   • 并集 union

     v = {1,2,'lishao'}
     result = v.union({1,'lishao','xiaohei'})
     

   • 差集 difference

     v = {1,2,'lishao'}
     result = v.difference({1,'lishao','xiaohei'}) # v集合中元素在新集中没有的
     print(result) # {2}
     

   • 对称差集 symmetric_difference

     v = {1,2,'lishao'}
     result = v.symmetric_difference({1,'lishao','xiaohei'}) # B集合中没有A集合中的元素 和 A集合中没有B集合的元素
     print(result) # {2, 'xiaohei'}
     

   • 注意

     intersection交集中，中也可以使用列表和元组

   3. 公共功能

   • len

   • for循环

     v = {1,2,3}
     for i in v:
         print(i)
     

   4. 集合的嵌套

   5. 列表/字典/结合 可变类型，不可hash，不能放在集合中

      info = {1,2,3,4,True,"guofeng",None,(1,2,3)}
      print(info) # {1,2,3,4,'国风',None,(1,2,3)} 没有True
      
      

   6. hash

      因为在内部会将值进行哈希算法并得到一个值(对应内存地址)，用于以后快速查找。

   7. 特殊情况

      # 关于字典和集1，0/Ture，False
      info = {0, 2, 3, 4, False, "国风", None, (1, 2, 3)}
      print(info)
      
      info = {
          1:'alex',
          True:'oldboy'
      }
      print(info)
      

8. 空类型

• None

  None数据类型，比其他数据类型的空，更节省内存。没有任何功能，仅表示空，布尔值中表示False

9. 补充