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

Python：数据类型

1. 整形

age = 18

  • py2

    • int

      • 32位电脑：-231~231-1；
      • 64位电脑：-263~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，同一优先级默认从左往右计算。

posted @ 2021-03-17 22:39  The1Yu  阅读(36)  评论(0)    收藏  举报