Python学习【第2篇】：Python_数据类型

Python：数据类型

1. 整形

age = 18

• py2

  • int

    • 32位电脑：-2^31~231-1；
    • 64位电脑：-2^63~263-1

  • 整形除法只能保留整数位。

    for __future__ import division
    
    v = 9 / 2
    print(v) #4
    

• py3

  • 理论上长度是无限的（只要内存足够大）

2. 布尔值（bool/boolen）

• 只有两个值True/False
• 转换
  • 数字转布尔：0是False，其他都是True
  • 字符串转布尔：”“是False，其实都是True

3. 字符串（str/string）

• 字符串常用操作

  value = "  alex sb  "
  

  • upper() / lower()

    value.upper() # "  ALEX SB  "   字符串变大写
    value.lower() # "  alex sb  "   字符串变小写
    

  • isdigit()

    value.isdigit() # false   判断字符串 是否可以转换成数字
    

  • .strip() / .lstrip() / rstrip()

    value.rstrip() # "  alex sb"   去除字符串右边的空格
    value.lstrip() # "alex sb  "   去除字符串左边的空格
    value.strip() # "alex sb"   去除字符串两边的空格
    

  • replace()

    value.replace('a',“*”) # "  *lex sb  "   用‘*’替换字符串中含有‘a’的字符
    

  • split()

    value.split(' ') # ['', '', 'alex', 'sb', '', '']  切割含有' '的字符串
    value.split(' ',1) # ['', ' alex sb  ']  从左到右切割第1个含有' '的字符串
    value.rsplit(' ',1) # ['  alex sb ','']  从右到左切割第1个含有' '的字符串
    

• 公共

  • len，计算长度。（字符串 -> 计算字符串中的字符个数）

  • 索引取值

    	v = "oldboy"
    	v1 = v[0] # 'o'
        v2 = v[-1] # 'y'
    

  • 切片

    	v = "oldboy"
        
        v[2:4] # 'db'
        v[3:6] # 'boy'
        v[3:-1] # 'bo'
        v[3:] # 'boy'
        v[:-1] # 'oldbo'
    

4. 列表

#列表格式：
users = ["222","333",99]

• 公共功能

  • len

    users = ["222","333",99]
    val = len(users)
    print(val) # 3
    

  • 索引

    users = ["222","333",99]
    val = users[0]
    print(val) # "222"
    

  • 切片

    users = ["222","333",99]
    val = users[0:2]
    print(val) # ["222","333"]
    

  • 步长

    users = ["222","333",99]
    val = users[0::2]
    print(val) # ['222', 99]
    

  • 删除（数字、布尔、字符串除外）

    users = ["222","333",99]
    #方式一
    users.pop(1)
    print(val) # ['222', 99]
    
    #方式二
    del users[1]
    print(val) # ['222', 99]
    

    注意：

    • 字符串本身不能修改或删除【不可变类型】
    • 列表是可变类型

  • 修改（字符串、数字、布尔除外）

    users = ["222","333",99]
    users[2] = 66 
    users[0] = "liss"
    
    

  • for循环

    #1.for循环
    users = ['小米','小白','小黑','小红']
    """
    for i in users:
        print(i)
    # 小米
    # 小白
    # 小黑
    # 小红
    """
    #2.将列表中每一个字符打印
    """
    for i in users:
        for ele in i:
            print(ele)
    #打印所有的字符
    """
    #3.将列表 i users[i] 格式打印
    """
    #方式一：
    count = 0
    for i in users:
        print(count,i)
        count+=1
    # 0 小米
    # 1 小白
    # 2 小黑
    # 3 小红
    #方式二：
    users_len = len(users)
    for index in range(0,users_len):
        print(index,users[index])
    """
    

• 特有功能

• append

  #1. append 列表的最后追加一个元素
  users = []
  while True:
      name = input('请输入姓名：')
      users.append(name)
      print(users)
  

• insert

  #2. insert 在指定索引位置进行插入元素
  users = ['小米','小白','小黑','小红']
  users.insert(1,'小夏')
  print(users)  #['小米','小夏','小白','小黑','小红']
  

• remove

  #3. remove 重左到右找到第一个匹配的目标，进行删除
  users = ['小米','小白','小黑','小红']
  users.remove('小米')
  print(users)  #['小白','小黑','小红']
  

• pop

  #4. pop 进行删除
  users = ['小米','小白','小黑','小红']
  users.pop(1)
  print(users)  #['小米','小黑','小红']
  
  users = ['小米','小白','小黑','小红']
  users.pop()  #默认删除最后一个
  print(users)  #['小米','小白','小黑']
  

• clear

  #5. clear 清空列表
  users = ['小米','小白','小黑','小红']
  users.clear()
  print(users)  #[]
  

• 总结：

  • 增

    • append / insert

  • 删

    • remove / pop / clear / del users[2]

  • 改

    • users[2] = 66

  • 查

    • 索引 / 切片

  • 列表嵌套

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

  • 强制转换

    v1 = list((11,22,33,44))
    print(v1) #[11,22,33,44]
    

5. 元组

• 元组书写规范

  users = [11,22,33,"老男孩"] #列表（可变）
  
  users = (11,22,33,"老男孩") #元组（不可变）
  

• 公共功能

  • 索引

    users = (11,22,33,"老男孩")
    
    print(users[0])
    print(users[-1])
    

  • 切片

    users = (11,22,33,"老男孩")
    print(users[0:2])
    

  • 步长

    users = (11,22,33,"老男孩")
    print(users[0:2:2])
    

  • 删除（排除：tuple、str、int、bool）

  • 修改（排除：tuple、str、int、bool）

  • for循环

    users = (11,22,33,"老男孩")
    for item in users:
        print(item)
    

  • len

    users = (11,22,33,"老男孩")
    print(len(users))
    

• 独有功能（无）

• 特殊：元组中的元素不可被修改 / 删除

  #示例一：
  v1 = (11,22,33)
  v1[2] = 0 #false
  v1 = 999 #right
  
  #示例二：元组可以嵌套
  v1 = (11,22,33,(44,55))
  
  #示例三：嵌套
  v2 = [11,22,33,(11,22,33)]
  v2[-1][-1] = 99 #false
  v2[-1] = 123 #right
  
  #示例四：嵌套
  v3 = (11,22,33,[11,22,33],44)
  v3[3] = 666 #false
  v3[3][2] = 123 #right
  

• 面试题 ：元组记得加 “,” 号

  v1 = 1  
  v2 = (1)
  v3 = (1,) 
  v5 = () 
  print(type(v1),type(v2),type(v3),type(v4)) #<class 'int'> <class 'int'> <class 'tuple'> <class 'tuple'>
  data = [(1),(2),(3)] #== [1,2,3]
  

• 强制转换

  v1 = tuple([11,22,33,44])
  print(v1) #(11,22,33,44)
  

6. 常见类型转换

# 字符串转数字
	v1 = int("666")
    print(v1) # 666
# 数字转字符串
	v1 = str(666)
    print(v1) # "666"
# 列表转元组
	v1 = list((11,22,33,44))
	print(v1) # [11,22,33,44]
# 元组转列表
	v1 = tuple([11,22,33,44])
	print(v1) # (11,22,33,44)
# 其他转bool时，只有0 '' [] ()

• .join 字符串拼接 .join([元素必须是字符串，元素必须是字符串])

  nums = ['11','22','33','44']
  v = '_'.join(nums)
  print(v)  # 11_22_33_44
  

7. 字典

​ 请表示：刘伟达的信息，年龄：18 性别：男，爱好：同桌

name = "刘伟达"
age = 18
gender = "男"
hobby = "同桌"

#用字典表示
info = {"name" : "刘伟达", "age" : 18, "gender" : "男", "hobby" : "同桌"} #键值
print(info("hobby")) # 同桌

• 独有功能

  info = {"name" : "刘伟达", "age" : 18, "gender" : "男", "hobby" : "同桌"} #键值
  

  • keys / values / items

    for item in info.keys():
        print(item)   #name age gender hobby
    
    for item in info.values():
        print(item)   #刘伟达 18 男 同桌
    
    for v1,v2 in info.items():
        print(v1,v2)
    # name 刘伟达
    # age 18
    # gender 男
    # hobby 同桌
    

• 公共功能

  • len

    info = {"name" : "刘伟达", "age" : 18, "gender" : "男", "hobby" : "同桌"} #键值
    print(len(info))  # 4
    

  • 索引

    info = {"name" : "刘伟达", "age" : 18, "gender" : "男", "hobby" : "同桌"} #键值
    print(info("hobby")) # 同桌
    

  • 切片【无】

  • 步长【无】

  • for【见上：独有功能】

  • 修改

    # 改值
    info = {"name" : "刘伟达", "age" : 18, "gender" : "男", "hobby" : "同桌"} #键值
    info['age'] = 19
    print(info['age'])  # 19
    
    # 改建
    # 删除后再增加
    info = {"name" : "刘伟达", "age" : 18, "gender" : "男", "hobby" : "同桌"} #键值
    del info['age']
    info['xxxx'] = 'x1'
    

  • 删除

    info = {"name" : "刘伟达", "age" : 18, "gender" : "男", "hobby" : "同桌"} #键值
    del info['age']
    print(info)  # {'name': '刘伟达', 'gender': '男', 'hobby': '同桌'}
    

• 注意：

  • dict中可变的数据类型不能当key（例如list、tuple）
  • dict中值可以是任意数据类型

*. 重点

• int
• bool
• str
• list
• tuple
• dict

*. 补充

1. 列表

• reverse

  v1 = [1,2,33,32,31] 
  print(v1) # [1, 2, 33, 32, 31]
  v1.reverse()
  print(v1) # [31, 32, 33, 2, 1]
  

• sort

  v1 = [1,2,33,32,31]
  v1.sort(reverse=False) # 从小到大 （默认）
  print(v1)   # [1, 2, 31, 32, 33]
  v1.sort(reverse=True) # 从小到大 （默认）
  print(v1)   # [33, 32, 31, 2, 1]
  

2. 字典

• keys / values / items

• get

  info = {'k1':'v1','k2':'v2'}
  v1 = info['k111111']    # flase
  v2 = info.get('k111111',666)    #666
  v2 = info.get('k111111')    #None
  
  None数据类型，该类型表示空（无任何功能，专门用于提供空值）
  

• pop

  info = {'k1':'v1','k2':'v2'}
  
  result = info.pop('k2')
  print(info,result)  # {'k1': 'v1'} v2
  
  del info['k1'] #无返回 值
  

• update

  #键 存在则替换，不存在则添加
  info = {'k1':'v1','k2':'v2'}
  
  info.update({'k3':'v3','k4':'v4','k2':666})
  print(info) # {'k1': 'v1', 'k2': 666, 'k3': 'v3', 'k4': 'v4'}
  

3. 判断一个字符串中是否右敏感字符？

• str

  v = "python全栈"
  
  if "全栈" in v:
      print('含敏感字符')
  

• list / tuple

  v = ['alex','oldboy','xiaocilao']
  
  if 'oldboy' in v:
      print('含敏感字符')
  

• dict

  info = {'k1':'v1','k2':'v2'}
  
  # 默认按照key判断，即：判断x是否是字典的key
  	if 'x' in v:
          pass
  
  
  # 请判断：k1是否在其中？
  	if 'k1' in v:
          pass
      
  # 请判断：v2是否在其中？
  # 方式一：循环判断
  	flag = '不存在'
  	if value in info.values():
          if value = 'v2':
              flag = '存在'
       print(flag)
      
  # 方式二：将values强制转换成列表
  	if 'v2' in list(info.values()):
          pass
      
  # 请判断：k2:v2 是否在其中？
      info = {'k1':'v1','k2':'v2'}
      value = info.get('k2')
      if value == 'v2':
          print('存在')
      else:
          print('不存在')
      
  	
  

8. 集合

• 无序
• 无重复

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

# 疑问：v = {}
# 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()

• 独有功能

  • add

    # v = {1,2}
    # v.add('Lishaoqi')   # {'Lishaoqi', 1, 2}
    # v.add('Lishaoqi')   # {'Lishaoqi', 1, 2}
    # v.add('23d')        # {1, 2, 'Lishaoqi', '23d'}
    # print(v)
    

  • discard

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

  • update

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

  • intersection （交集）

    # v = {1,2,'Lishaoqi'}
    # result = v.intersection({1,'Lishaoqi','小黑'})
    # print(result)     # {1, 'Lishaoqi'}
    

  • difference （差集）

    v = {1,2,'Lishaoqi'}
    result = v.difference({1,'Lishaoqi','小黑'})  # v中有且{1,'Lishaoqi','小黑'}没有
    print(result)       # {2}
    

  • union （并集）

    v = {1,2,'Lishaoqi'}
    result = v.union({1,'Lishaoqi','小黑'})
    print(result)       # {1, 2, 'Lishaoqi', '小黑'}
    

  • symmetric_difference （对称差集）

    v = {1,2,'Lishaoqi'}
    result = v.symmetric_difference({1,'Lishaoqi','小黑'})
    print(result)       # {2, '小黑'}
    

  • 注意：集合与列表 注意事项

    v = {1,2,'Lishaoqi'}
    result = v.intersection([1,'Lishaoqi','小黑'])  #方法中可以传 列表
    print(result)       # {1, 'Lishaoqi'}
    

• 公共功能

  • len

    v = {1,2,'Lishaoqi'}
    print(len(v))       # 3
    

  • for

    v = {1,2,'Lishaoqi'}
    for item in v:
        print(item)
    

  • 索引【无】

  • 步长【无】

  • 切片【无】

  • 删除【无】

  • 修改【无】

• 嵌套问题：

  1. 列表、字典、集合 --> 不能放在集合中+不能作为字典的key （unhashable）

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

  2. hash --> 哈希是怎么回事

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

  3. 特殊情况

     info = {0,2,3,4,False,"国风",None,(1,2,3)}
     print(info)     # {0, 2, 3, 4, None, (1, 2, 3), '国风'}
     
     
     info = {
         1:'alex',
         True:'oldboy'
     }
     print(info)  # {1: 'oldboy'}
     

9. 内存相关

• Python中内存相关

  #添加值操作
  # v1 = [1,2,3]
  # v2 = v1
  # v1.append(999)
  # print(v1,v2)
  # print(id(v1),id(v2))    # 2214117948736 2214117948736
  
  # # 重新赋值操作
  # v1 = [1,2,3]
  # v2 = v1
  # print(id(v1),id(v2))    # 1543793786048 1543793786048
  # v1 = 999
  # print(id(v1),id(v2))    # 1543793485936 1543793786048
  

• Python中小数据缓冲池

  # #Python缓存机制
  # #小数据池[-5,256] 对于小的整数存在一个缓存池。为了避免因创建相同的值而重复申请内存空间所带来的效率问题，
  # #Python解释器会在启动时创建出小整数池，范围是[-5,256]，该范围内的小整数对象是全局解释器范围内被重复使用，永远不会被垃圾回收机制回收
  # v1 = 1
  # v2 = 1
  # print(id(v1),id(v2))    # 2173432588592 2173432588592
  # v1 = "abc"
  # v2 = "abc"
  # print(id(v1),id(v2))    # 1617579984496 1617579984496
  # #注意：对于在pycharm中，给变量赋值超出这个范围时仍然地址相同，
  # # 是因为pycharm出于对性能的考虑，会扩大小整数池的范围，
  # # 其他的字符串等不可变类型(str)也都包含在内一便采用相同的方式处理了，我们只需要记住这是一种优化机制，至于范围到底多大，无需细究。
  # v1 = 258
  # v2 = 258
  # print(id(v1),id(v2))    # 地址不同
  

• 面试题：Python中 "==" 和 "is" 有什么区别？

  #  == 用于比较值是否相等
  #  is 用于比较内存地址是否相等
  
  v1 = [1,2,3]
  v2 = [1,2,3]
  print(v1 == v2) # True
  print(v1 is v2) # Falsev1
  
  v1 = [1,2,3]
  v2 = v1
  print(v1 == v2) # True
  print(v1 is v2) # True
  

• Python中比较运算优先级关系：or<and<not，同一优先级默认从左往右计算。

__EOF__

本文作者：The1Yu
本文链接：https://www.cnblogs.com/The1Yu/p/14552427.html
关于博主：评论和私信会在第一时间回复。或者直接私信我。
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！