基本数据类型

内容概要

• 八大基本数据类型
  • 数字类型
    • 整数(int)
    • 浮点数(float)
  • 字符串类型(str)
  • 列表类型(list)
  • 字典类型(dict)
    • dictionary
  • 布尔类型(bool)
  • 元组类型(tuple)
  • 集合类型(set)

【一】整型（int）

（1）类型强转

• 可以将由纯整数构成的字符串直接转换成整型
  • 符合int类型格式的字符串可以强转成整数类型

num = '123'
print(num, type(num))  # 123 <class 'str'>
print(int(num), type(int(num)))  # 123 <class 'int'>

• 十进制数转为其他进制

# bin() 十进制转二进制
# oct() 十进制转八进制
# hex() 十进制转十六进制
print(bin(999))

• 其他进制转为十进制
  • 二进制（以'0b'或者'0B'开头）
  • 八进制（以'0o'或者'0O'开头）
  • 十六进制（以'0x'或者'0X'开头）

# int() 其他进制转为十进制
print(int('0b11100',2))
print(int('0o1747',8))
print(int('0x3e7',16))

【二】浮点类型（float）

（1）类型强转

• 符合float类型格式的字符串可以强转成浮点类型

num = '18.0'
print(num, type(num))  # 18.0 <class 'str'>
print(float(num), type(float(num)))  # 18.0 <class 'float'>

（2）取整-round

• 四舍五入---round

print(round(3.5)) # 4
print(round(4.0)) # 4

【三】字符串类型（str）

（1）索引取值

• 只能取值不能修改

name='dhy'
print(name[0]) # d

（2）字符串拼接

• +号拼接

word1 = 'hello'
word2 = 'world'
print(word1 + ',' + word2) # hello,world

• .join给每个字符拼接

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

（3）切片

• 切片也是顾头不顾尾 [起始位置:想要的结束位置+1]

name = 'dhy'
name_one = name[0] + name[1]
print(name_one)  # he
 
name_two = name[2:4 + 1]
print(name_two)  # art

• 切片也可以加步长 [起始位置:想要的结束位置+1:step]

name = 'dhy'
name_three = name[0:5 + 1:2]
print(name_three)  # hat

• 从指定索引切到最后 [起始位置::]

name = 'dhy'
name_four = name[1::]
print(name_four)  # eart

（4）成员运算

• in和not in用于检查一个字符串是否包含另一个字符串

name = 'dhy'
print('h' in name)  # True
print('d' in name)  # False

（5）去除空格 strip()

• strip()方法用于去除字符串里的空格
  • lstrip()用于去除字符左边的空格
  • rstrip()用于去除字符右边的空格

name='  dhy   '
print(name.strip()) # dhy

• 还可以去除指定的字符

name = '&&dhy&&'
print(name.strip('&')) # dhy

（6）切分 split()

• 顾名思义就是将字符串切分成多个子字符串，并返回一个包含切分后字符串的列表

name = 'dhy-425'
print(name.split('-')) # ['dhy', '425']

（7）大小写转换

• 小写转大写upper()
  • isupper()判断是否为纯大写
• 大写转小写lower()
  • islower()判断是否为纯小写

name = 'dhy'
print(name.upper())  # dhy
print(name.lower())  # dhy

（8）首尾字符判断

• startswith()判断当前字符以什么开头，返回bool值
• endswith()判断当前字符以什么结尾，返回bool值

name = 'dhy'
print(name.startswith('h'))  # True
print(name.startswith('e'))  # False
print(name.endswith('t'))  # True
print(name.endswith('r'))  # False

（9）替换replace

• replace可以替换字符串中的词

title = 'my hero is dhy'
print(title.replace('dhy', 'godfather'))

【四】列表类型（list）

（1）类型强转

• 字符串类型强转成列表类型的话就是将每一个元素都拿出，凑成一个列表

name = 'dhy'
print(list(name))  # ['h', 'e', 'a', 'r', 't']

• 元组类型强转成列表类型，每一个元素就是列表的元素

name_tuple = ('dhy', 'godfather')
print(list(name_tuple))  # ['dhy', 'godfather']

• 集合类型强转成列表类型，每一个元素就是列表的元素

name_set = {'dhy', 'godfather'}
print(list(name_set))  # ['dhy', 'godfather']

• 字典类型强转成列表类型，每一个键就是列表的元素

name_dict = {'dhy': '123456', 'god': '123'}
print(list(name_dict))  # ['dhy', 'god']

• range生成新列表

print(list(range(1, 5)))  # [1, 2, 3, 4]

（2）切片

• 顾头不顾尾

name_list = ['dhy', 'god', 'zeus']
print(name_list[0:3])  # ['dhy', 'god', 'zeus']

• 步长

num_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(num_list[0:8:2])  # [1, 3, 5, 7]

（3）计算长度 len

num_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(len(num_list))  # 9

（4）增加

[1]append()

• 在结尾进行增加，只允许每次加一个元素

num_list = [1, 2, 3, 4, 5, 6]
num_list.append(11)
print(num_list)  # [1, 2, 3, 4, 5, 6, 11]

[2]extend()

• 可以一次性添加多个元素

num_list = [1, 2, 3, 4, 5, 6]
num_list.extend((11, 22, 33))
num_list.extend([99, 88, 77])
num_list.extend({'name': 'dhy', 'age': '18'})
print(num_list)  # [1, 2, 3, 4, 5, 6, 11, 22, 33, 99, 88, 77, 'name', 'age']

[3]insert()

• 按指定位置添加

num_list = [1, 2, 3, 4, 5, 6]
num_list.insert(1, 'a')
print(num_list)  # [1, 'a', 2, 3, 4, 5, 6]

（5）删除

[1]del

• 删除指定索引的元素

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

[2]pop()

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

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

[3]remove()

• 指名道姓删除括号内的元素，没有返回值

• 与pop不同，pop是通过索引值来删除的

num_list = [1, 2, 3, 'dhy']
num_list.remove('dhy')
print(num_list)  # [1, 2, 3]

（6）改

• 按照索引位置改值

num_list = [1, 2, 3]
num_list[0] = 'dhy'
print(num_list)  # ['dhy', 2, 3]

[1]reverse()

• 颠倒列表内元素排列，无返回值，影响的是原来列表

num_list = [1, 2, 3, 4, 5, 6]
num_list.reverse()
print(num_list)  # [6, 5, 4, 3, 2, 1]

[2]sort()

• sort()方法用于对列表进行排序，默认是升序

num_list = [1, 3, 5, 4, 6, 8]
num_list.sort()
print(num_list)  # [1, 3, 4, 5, 6, 8]

• reverse=True降序排序

num_list = [1, 3, 5, 4, 6, 8]
num_list.sort(reverse=True)
print(num_list)  # [8, 6, 5, 4, 3, 1]

[3]sorted

• sorted函数可以保留原来的列表

• 也可以排序，默认正序，返回值就是排好序的新列表

num_list = [1, 3, 5, 4, 6, 8]
a = sorted(num_list)
print(a)  # [1, 3, 4, 5, 6, 8]
print(num_list)  # [1, 3, 5, 4, 6, 8]

【四】字典类型

（1）取值

[1]按[key]

dict_dhy = {'name': 'dhy', 'age': 18, 'height': '180'}
print(dict_dhy['name'])  # dhy

[2]get取值

• 使用get方法可以根据键获取对应的值，如果键不存在，则返回指定的值

dict_dhy = {'name': 'dhy', 'age': 18}
print(dict_dhy.get('name'))  # dhy
print(dict_dhy.get('height', 180))  # 180

（2）计算长度 len

• 使用len函数可以计算字典中键值对的个数

dict_dhy = {'name': 'dhy', 'age': 18, 'height': 180}
print(len(dict_one))  # 3

（3）成员运算

• 使用in和not in可以判断键是否存在字典中

dict_dhy = {'name': 'dhy', 'age': 18, 'height': 180}
print('name' in dict_one)  # True

（4）增加

• 如果没有这个键，那就将键添加进字典里
• 如果存在这个键，就直接替换成新内容

dict_one = {'name': 'dhy', 'age': 18, 'height': 180}
dict_one['sex'] = '男'
dict_one['name'] = 'dhy1'
print(dict_one)  # {'name': 'dhy1', 'age': 18, 'height': 180, 'sex': '男'}

[1] update(key=value)

• 使用update()方法可以批量增加键值对，如果键已经存在，则更新字典

dict_one = {'name': 'dhy'}
dict_one.update(sex='男', hobby=['music'])
print(dict_one)  # {'name': 'dhy', 'sex': '男', 'hobby': ['music']}

[2]setdefault(key,value)

• 用于获取指定键的值，如果键不存在，则返回默认值，有返回值，并且返回值就是你添加到字典中的值，只能单个增加元素

dict_one = {'name': 'dhy'}
res = dict_one.setdefault('sex', '男')
print(dict_one)  # {'name': 'dhy', 'sex': '男'}
print(res)  # 男

（5）删除

[1]del

• 根据字典中的键删除指定的键值

dict_one = {'name': 'dhy', 'age': 18}
del dict_one['name']
print(dict_one)  # {'age': 18}

[2]pop()

• 使用pop方法可以根据键弹出字典中的键值对，同时返回被弹出的值

dict_one = {'name': 'dhy', 'age': 18, 'height': 180}
print(dict_one.pop('age'))  # 18
print(dict_one)  # {'name': 'dhy', 'height': 180} 

[3]clear()

• 使用clear方法可以清空字典中的所有键值对

dict_one = {'name': 'dhy', 'age': 18, 'height': 180}
dict_one.clear()
print(dict_one)  # {}

[4]popitem

• 删除字典中结尾的一个键值对，并以元组的形式返回被删除的键值

dict_one = {'name': 'dhy', 'age': 18, 'height': 180}
print(dict_one.popitem())  # ('height', 180)
print(dict_one)  # {'name': 'dhy', 'age': 18}

（6）keys()键对

• 使用keys方法可以获取字典里所有的键

dict_one = {'name': 'dhy', 'age': 18, 'height': 180}
print(dict_one.keys())  # dict_keys(['name', 'age', 'height'])

（7）values()值对

• 使用values方法可以获取字典中所有的值

dict_one = {'name': 'dhy', 'age': 18, 'height': 180}
print(dict_one.values())  # dict_values(['dhy', 18, 180])

（8）items()键值对

• 使用item方法可以获取字典中所有的键值对

dict_one = {'name': 'dhy', 'age': 18, 'height': 180}
print(dict_one.items())  # dict_items([('name', 'dhy'), ('age', 18), ('height', 180)])

（9）遍历循环

• 可以遍历字典，但是遍历字典出来的是键

dict_one = {'name': 'dhy', 'age': 18, 'height': 180}
for i in dict_one:
    print(i)

• 可以遍历字典的键值对，根据解压赋值

dict_one = {'name': 'dhy', 'age': 18, 'height': 180}
for k,v in dict_one.items():
    print(k,v)

（10）sorted()字典排序

• 字典的排序是通过字典的键来进行的

dict_one = {'name': 'dhy', 'age': 18, 'height': 180}
print(sorted(dict_one))  # ['age', 'height', 'name']

【五】布尔类型（bool）

（1）类型强转

• 代表真的情况：
  • 数字类型 （有值的数字类型都是真）、有值的字符串/列表/字典/元组/集合

num = 1
print(bool(num), type(bool(num)))  # True <class 'bool'>

• 代表假的情况：
  • 数字类型0或者空的字符串/列表/元组/字典

num = 0
num_one = ''
print(bool(num), type(bool(num)))  # False <class 'bool'>
print(bool(num_one), type(bool(num_one)))  # False <class 'bool'>

【六】元组类型（tuple）

（1）类型强转

• 但凡能被for循环遍历的数据类型都可以传给tuple()转换成元组类型

name_list = ['dhy', 18]
print(tuple(name_list), type(tuple(name_list)))

（2）索引取值

• 元组也支持索引取值，只能取不改

name_tuple = ('dhy', 'lqq')
print(name_tuple[0])  # dhy

（3）切片

• 顾头不顾尾[起始索引:结束索引:step]

name_tuple = ('dhy', 'god', 'father', 'tom')
print(name_tuple[0:2])  # ('dhy', 'god')

（4）计算长度 len

name_tuple = ('dhy', 'lqq', 'jerry', 'tom')
print(len(name_tuple))  # 4

（5）成员运算

num_tuple = (1, 2, 3, 4)
print(3 in num_tuple)  # True

（6）循环取值

num_tuple = (1, 2, 3, 4)
num_tuple_two = ('a', 'b', 'c')
print(num_tuple + num_tuple_two)  # (1, 2, 3, 4, 'a', 'b', 'c')

【八】集合类型（set）

• 集合类型的定义使用大括号（），元素之间使用,分隔

（1）类型强转

• 集合的特点就是无序性

print(set('dhy'))  # {'h', 'd', 'y'}

• 集合的另一大特性就是去重，去除重复的元素

print(set('dhyy'))  # {'y', 'h', 'd'}

• 字符串类型可以强转成集合类型
• 字典也可以去重，一般我们只对字典的值去重

print(set({'name': 'dhy', 'age': 18, 'sex': '男', 'height': 18}.values()))  # {18, '男', 'dhy'}

• 列表类型可以强转成集合类型

num_list = [1, 2, 3, 4, 5, 6, 6, 6, 6, 6, 6]
print(set(num_list))  # {1, 2, 3, 4, 5, 6}

（2）添加元素

[1]add()

• 添加单个元素

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

[2]update()

• 添加多个元素（字符串/列表/字典/元组）
• 重复的元素会按照集合的特性进行去重

num_set = {1, 2, 3, 4}
num_set.update((1, 2, 5, 6))
print(num_set)  # {1, 2, 3, 4, 5, 6}

（3）删除元素

[1]remove()

• 只能按照集合中的值删除掉指定元素

num_set = {1, 2, 3, 4, 5, 6}
num_set.remove(1)
print(num_set)  # {2, 3, 4, 5, 6}

（4）集合操作

[1]union()并集

num_set = {1, 2, 3, 4, 5, 6}
num_set_two = {2, 3, 7, 8}
union_set = set.union(num_set, num_set_two)
print(union_set)  # {1, 2, 3, 4, 5, 6, 7, 8}

[2]intersection()交集

num_set = {1, 2, 3, 4}
num_set_two = {2, 3, 7, 8}
union_set = set.intersection(num_set, num_set_two)
print(union_set)  # {2, 3}

[3]difference()差集

• 方法返回当前集合和其他集合的差集

num_set = {1, 2, 3, 4}
num_set_two = {2, 3, 7, 8}
union_set = set.difference(num_set, num_set_two)
print(union_set)  # {1, 4}

（5）成员运算

• 虽然集合是无序的，但是不影响判断元素在不在集合里面，在就是True，不在就是False

num_set = {1, 2, 3}
print(1 in num_set)  # True

（6）循环

num_set = {1, 2, 3, 'dhy'}
for i in num_set:
    print(i)
# 1
# 2
# 3
# dhy

（7）计算长度 len()

num_set = {1, 2, 3, 'dhy'}
print(len(num_set))  # 4