5.数据类型内置方法

【一】数据类型内置方法

1）整数类型（int）

1.类型强转

可将符合整数格式的字符串转换成整数类型

print(int('5'))

2.进制转换

• 十进制转二进制 0b

  print(bin(999))  # 0b1111100111
  

• 十进制转八进制 0o

  print(oct(999))  # 0o1747
  

• 十进制转十六进制 0x

  print(hex(999))  # 0x3e7
  

• 其他转十进制

  print(int(0b1111100111))
  print(int(0o1747))
  print(int(0x3e7))
  #999
  

2）浮点数类型（float）

1.类型强转

print(float(12))	#12.0
print(float('12.5'))	#12.5

2.判断当前类型是否是整数或浮点数

num1 = b'4'	# bytes
num2 = '4'	# unicode
num3 = '四'	# 中文数字
num4 = 'Ⅳ'	# 罗马数字

• 判断是否为数字类型(.isdigit)

  print(b'4'.isdigit())  # True
  print('4'.isdigit())  # True
  print('四'.isdigit())  # False
  print('Ⅳ'.isdigit())  # False
  

• 判断是否为小数点类型(.isdecimal)

  print('4'.isdecimal())  # True
  print('四'.isdecimal())  # False
  print('Ⅳ'.isdecimal())  # False
  

• 判断是否为小数点类型(.isnumeric)

  print('4'.isnumeric())  # True
  print('四'.isnumeric())  # True
  print('Ⅳ'.isnumeric())  # True
  

均无法判断浮点数

3）字符串类型（str）

1.字符串拼接（+和.join）

• + 拼接

  a = 'hello'
  b = 'world'
  print(a+b)	#helloworld
  

• .join()拼接

  print('-'.join('hello'))	#h-e-l-l-o
  

2.索引取值（ [ ] ）

• 正索引，负索引，只能取值不能修改

3.切片（[起始:结尾:步长]）

• 切片顾头不顾尾

• 步长

  print('0123456789'[2:7:2])	#246
  

• 负索引切片（左小右大）

  print('0123456789'[-7:-2:2])	#357
  

4.计算长度（len()）

print(len('0123456789'))	#10

5.成员运算

• in 和 not in

  print('e' in 'hello')	True
  

6.去除空格（.strip）

• 去除两边空格（.strip()）

  word='   hello   '
  print(word.strip())	#hello
  

• 左去除（.lstrip()）

• 右去除（.rstrip()）

• 去除两边指定字符（.strip('指定符号')）

7.切分（.split()）

默认空格，括号内可指定字符，切分字符消失

user = 'v_123'
print((user).split('_'))	#['v', '123']

8.替换（.replace('旧','新')）

print(name_a.replacea('a','b'))	#name_b

9.遍历（for _ in _)

将每一个元素看一遍

for i in 'hello':
    print(i)
#h
#e
#l
#l
#o

10.重复当前元素

print("v" * 5)	#vvvvv

11.大小写转换

• 小写转大写（.upper()）

  # print('Name'.upper())	#NAME
  

• 大写转小写（.lower()）

  # print('Name'.lower())	#name
  

• 判断是否是全大写或小写

  print('name'.islower())	#True
  print('name'.isupper())	#False
  

12.判断字符开头结尾

• 判断开头（.startswith()）
• 判断结尾（.endswith()）

13.格式化输出

• s%，d%
• .formate
• f{}

——————

14.查找

• .find()

  • 从左向右查找位置，只找一次，找不到返回-1
  • 可指定区间（.find(查找内容，区间)）

• .rfind()

  • 从右向左查找位置

• .index()

  • 同find，找不到会报错

• .rindex()

  • 从右向左查找位置

• .count()

  • 统计出现次数

15.填充

• .center()

  • 填充两侧

  • 填充长度要高于给定字符长度

  • 若为奇数左少右多

    print(name.center(len(name) + 3, '*'))
    

• .ljust()

  • 右填充

• .rjust()

  • 左填充

• .zfill

  • 左侧填充0

16.制表符

• \t
  • 默认代表一个空格

17.字母大小写

• .capitalize()
  • 句子首字母大写
• .title()
  • 每个单词首字母大写
• .swapcase()
  • 字母大小写颠倒

name = 'Dream123'
print(name.islower())    # 字符串是否是纯小写，True
print(name.isupper())    # 字符串是否是纯大写，False
print(name.isalnum())    # 字符串中既可以包含数字也可以包含字母，True
print(name.isalpha())    # 字符串中只包含字母，False
print(name.isidentifier())  # 字符串是否是合法标识符，True
print(name.isspace())    # 字符串是否全是空格，False
print(name.istitle())    # 字符串中的单词首字母是否都是大写，False

4）列表类型（list）

1.类型强转（list()）

# 字符串
print(list('hello'))	#['h', 'e', 'l', 'l', 'o']
# 元组
print(list((1，2，'a')))	#[1, 2, 3, 'a']
# 字典
print(list({'a':1,'b':'c'}))	#['a', 'b']
# 集合
print(list({1,2,3,3}))	#[1, 2, 3]
# range关键字
print(list(range(0, 5)))	#[0, 1, 2, 3, 4]

2.索引取值

• 只能取不能改，无则报错

3.切片

• 顾头不顾尾

4.计算长度（len()）

5.成员运算

• in 和 not in

6.增加

• 追加（.append()）

  • 默认追加到末尾

  number = [1, 2, 3]
  number.append(4)
  print(number)	#[1, 2, 3, 4]
  

• 一次添加多个（.extend()）

  • 一次性在列表尾巴添加多个元素，合并列表

  number = [1, 2]
  num = [3, (4, 'a')]
  number.extend(num)
  print(number)  # [1, 2, 3, (4,'a')]
  

• 指定位置添加（.insert(位置，内容)）

  number = [1, 2, 3]
  number.insert(1, 'a')
  print(number)  # [1, 'a', 2, 3]
  

7.删除

• 删除指定位置元素（del）

  number = [1, 2, 3]
  del number[1]
  print(number)  # [1, 3]
  

• 弹出（.pop()）

  • 默认删除最后一个元素，并将删除的值返回

  number = [1, 2, 3]
  a = number.pop(1)
  print(number,a)		#[1, 3] 2
  

• 删除指定元素（.remove()）

  • 括号内指定元素，无返回值，只删除一次，没有会报错

  number = [1, 2, 3, 2]
  number.remove(2)
  print(number)  # [1, 3, 2]
  

8.颠倒元素（.reverse()）

number = [1, 2, 3]
number.reverse()
print(number)	#[3, 2, 1]

9.元素排列（.sort()）

• 默认升序排列

  • 无返回值

  number = [1, 5, 9, 3, 4]
  number.sort()
  print(number)  #[1, 3, 4, 5, 9]
  

• 降序

  number = [1, 5, 9, 3, 4]
  number.sort(reverse=True)
  print(number)  #[9, 5, 4, 3, 1]
  

• 只反转

  • 有返回值

  num_list = [1, 5, 9, 3, 4]
  num_new = sorted(num_list, reverse=True)
  print(num_new)	#[9, 5, 4, 3, 1]
  print(num_list)	#[1, 5, 9, 3, 4]
  

10.遍历循环

name = ['tom', 'v', 'lihua']
for i in name:
    print(i)
# tom
# v
# lihua

name = ['tom', 'v', 'lihua']
index = 0
while index < len(name):
    print(name[index])
    index += 1
# tom
# v
# lihua

11.步长

number = [1, 2, 3, 4, 5, 6]
# 正向步长
print(number[::2])  # [1, 3, 5]
# 反向步长
print(number[::-2])  # [6, 4, 2]
# 列表反转
print(number[::-1])  # [6, 5, 4, 3, 2, 1]

5）字典类型（dict）

1.取值

• [key]

  • 不存在会报错

  user = {'name':'v','age':30}
  print(user['name'])	#v
  

• .get()取值

  • 不存在返回None

  user = {'name':'v','age':30}
  print(user.get('name'))	#v
  

2.计算元素个数（len()）

user = {'name': 'v', 'age': 30}
print(len(user))	# 2

3.成员运算

• in 和 not in

4.增加

• 字典[键]=值

  • 存在对应值会覆盖，不存在会添加

  user = {'name': 'v', 'age': 30}
  user['sex'] = 'man'
  user['name'] = 'dive'
  print(user)  # {'name': 'dive', 'age': 30, 'sex': 'man'}
  

• 增加值并返回值（.setdefault()）

  • 有返回值

  user = {'name': 'v', 'age': 30}
  new_user = user.setdefault('sex','man')
  print(new_user)	# man
  print(user)  # {'name': 'dive', 'age': 30, 'sex': 'man'}
  

• 批量增加（.update()）

  • 存在对应值会添加

  user = {'name': 'v', 'age': 30}
  new_user = {'sex': 'man', 'hobby': 'music'}
  user.update(new_user)
  user.update(hobby='run')
  print(new_user)  # {'sex': 'man', 'hobby': 'music'}
  print(user)  # {'name': 'v', 'age': 30, 'sex': 'man', 'hobby': 'run'}
  

5.删除

• 删除键（del）

  user = {'name': 'v', 'age': 30}
  del user['age']
  print(user)  # {'name': 'v'}
  

• 弹出键值对（.pop()）

  • 有返回值

  user = {'name': 'v', 'age': 30}
  age = user.pop('age')
  print(age)  # 30
  print(user)  # {'name': 'v'}
  

• 清空字典（.clear()）

  user = {'name': 'v', 'age': 30}
  user.clear()
  print(user)  # {}
  

• 弹出最后一个键值对（.popitem()）

  user = {'name': 'dive', 'age': 30, 'sex': 'man'}
  a = user.popitem()
  print(a)  # ('sex', 'man')
  print(user)  # {'name': 'dive', 'age': 30}
  

6.取字典的对值

• 键对（.keys()）

  • 取所有的键，返回一个可迭代的值

  user = {'name': 'dive', 'age': 30, 'sex': 'man'}
  key = user.keys()
  print(key)  # dict_keys(['name', 'age', 'sex'])
  

• 值对（.values()）

  • 取所有的值，返回一个可迭代的值

  user = {'name': 'dive', 'age': 30, 'sex': 'man'}
  key = user.values()
  print(key)  # dict_values(['dive', 30, 'man'])
  

• 键值对（.items()）

  • 取所有的键值，返回一个可迭代的值

  user = {'name': 'dive', 'age': 30, 'sex': 'man'}
  key = user.items()
  print(key)  # dict_items([('name', 'dive'), ('age', 30), ('sex', 'man')])
  

7.遍历循环

user = {'name': 'dive', 'age': 30, 'sex': 'man'}
# 遍历key
for key in user:
    print(key)
# name
# age
# sex
# 遍历 value
for value in user.values():
    print(value)
# dive
# 30
# man

6）元组类型（tuple）

1.类型强转

# 字符串
print(tuple('hello'))  # ('h', 'e', 'l', 'l', 'o')
# 列表
print(tuple([1, 2, 'a']))  # (1, 2, 'a')
# 字典
print(tuple({'a': 1, 'b': 'c'}))  # ('a', 'b')
# 集合
print(tuple({1, 2, 3, 3}))  # (1, 2, 3)
# range关键字
print(tuple(range(0, 5)))  # (0, 1, 2, 3, 4)

2.索引取值

• 可存可取，无则报错

3.切片

• 顾头不顾尾

4.计算长度（len()）

5.成员运算

• in 和 not in

6.遍历循环

fruit_tuple = ('apple', 'banana', 'cherry')
for i in fruit_tuple:
    print(i)
# apple
# banana
# cherry

7.元组拼接

print((1, 2, 3) + (2, 3, 4))
# (1, 2, 3, 2, 3, 4)

8.元组拼接

print((1, 2, 3) + (2, 3, 4))
# (1, 2, 3, 1, 2, 3, 1, 2, 3)

7）布尔类型（bool）

1.强转类型

• 只会转成True和False

假：False，数字0，空值

8）集合类型（set）

• 无序性，去重性

1.类型强转

# 字符串
print(set('hello'))	#{'l', 'o', 'h', 'e'}

2.计算长度len()）

3.成员运算

• in 和 not in

4.遍历循环

5.添加元素

• 添加单个元素（.add()）

  num = {1,2,3}
  num.add(4)
  print(num)	#{1, 2, 3, 4}
  

• 添加多个元素（.update()）

  num = {1, 2, 3}
  num.update([3, 4, 5])
  print(num)  # {1, 2, 3, 4, 5}
  

6.删除元素

• 删除指定元素（.remove()）

  • 没有会报错

  num = {1, 2, 3}
  num.remove(2)
  print(num)  # {1, 3}
  

• 删除指定元素（.discard()）

  • 没有不会报错

  num = {1, 2, 3}
  num.discard(2)
  print(num)  # {1, 3}
  

• 删除随机元素（.pop()）

  • 仅集合类型不能指定
  • 纯数字会删除最小

  num = {'a','b','c'}
  num.pop()
  print(num)
  

7.集合运算

num_1 = {1, 2, 3}
num_2 = {3, 4, 5}
# 并集(.union())
print(num_1.union(num_2))  # {1, 2, 3, 4, 5}
# 交集(.intersection())
print(num_1.intersection(num_2))  # {3}
# 差集(.difference())
print(num_1.difference(num_2))  # {1, 2}
# 对称差集(.symmetric_difference())
print(num_1.symmetric_difference(num_2)) #{1, 2, 4, 5}

num_1 = {1, 2, 3, 4}
num_2 = {2, 3}
# 父集(.issuperset())
print(num_1.issuperset(num_2))
# 子集(.issubset())
print(num_1.issubset(num_2))

8.去重

• 只能针对不可变类型
• 去重后无法保留原来顺序

# 针对不可变类型，且要保证顺序
user= [
    {'name': 'lili', 'age': 18, 'sex': 'male'},
    {'name': 'jack', 'age': 73, 'sex': 'male'},
    {'name': 'lili', 'age': 18, 'sex': 'male'},
    {'name': 'lili', 'age': 20, 'sex': 'male'},
]
new_user = []
for dic in user:
    if dic not in new_user:
        new_user.append(dic)
print(new_user)
# [{'name': 'lili', 'age': 18, 'sex': 'male'},
#  {'name': 'jack', 'age': 73, 'sex': 'male'},
#  {'name': 'lili', 'age': 20, 'sex': 'male'}]

总结）

按存储值的个数
存一个值	数字、字符串
存多个值	列表、元祖、字典

按访问方式分
直接访问	数字、布尔
索引访问	列表、集合、元组
关键字访问	字典、映射类型

按是否可变区分
不可变	字符串、数字、布尔、元组、集合
可变	列表、字典

可迭代与不可迭代
不可迭代	数字、布尔
可迭代（可被for遍历）	元组，集合 、列表，字典，字符串、