python基本数据类型及其内置方法

1-数字类型

Python 支持三种不同的数值类型：

1. 整型(Int) - 通常被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的，可以当作 Long 类型使用，所以 Python3 没有 Python2 的 Long 类型
2. 浮点型(float) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 10² = 250）
3. 复数( (complex)) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型

Python 数字类型转换

有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。

1. int(x) 将x(纯数字字符串)转换为一个整数。

2. float(x) 将x转换到一个浮点数。

3. complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。

4. complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式

# int() 将纯数字字符串转化成整型
res1 = int('666')
print(res1,type(res1)) # 666 <class 'int'>

res2 = bin(10) # bin十进制转二进制方法
print(res2) # 0b1010
# oct() 十进制转八进制
# hex() 十进制转十六进制

# 二进制转十进制 int('0b1010',2)

# float() 将小数字符串转化成浮点型
res3 = float('2.5')
print(res3,type(res3)) # 2.5 <class 'float'>

# complex(x) # 将x转换到一个复数，实数部分为 x，虚数部分为 0
res4 = complex(10)
print(res4,type(res4)) # (10+0j) <class 'complex'>

2-字符串

1-字符串的定义：是一个有序的字符集合，用于存储和表示基本的文本信息

2-创建

message1 = 'welcome to the world of python !'
message2 = "welcome to the world of python !"
message3 = """welcome to the world of python !"""
# 以上三种都是字符串

3-字符串转化

# str() 函数 次函数可以把任意类型数据类型转换成字符串
res1 = str({'name':'aaa'})
print(res1,type(res1)) # {'name': 'aaa'} <class 'str'>

4-字符串使用及常用内置方法

# 1-按照索引取值(正向取+反向取)
# 正向取
strs = "hello world"
print(strs[0]) # h
print(strs[5]) # 空格
# 反向取
print(strs[-1]) # d
print(strs[-2]) # l
# 字符串是不可变类型，只能取值，不能修改
# strs[0] = 'A' # 报错

# 切片从一个字符串中拷贝出一个子字符串(索引的扩展应用：顾头不顾尾，步长)
print(strs[:6]) # hello
# 指定步长
print(strs[:5:2]) # 0 2 4 --> hlo
# 反向步长
print(strs[7:0:-1]) # ow olle
# 一行代码实现字符串反转(面试题)
new_strs = strs[::-1]
print(new_strs) # dlrow olleh

# 2-统计字符串长度(len()函数)
print(len(strs)) # 11

# 3-成员运算 in 和 not in
# 判断一个子字符串是否存在于大字符串中
print('alex' in 'alex so cool') # True
print('alex' not in 'alex so cool') # False

# lower与upper
# lower 将字符串转化成小写
# upper 将字符串转化成大写
# 使用
msg = 'AAbbdd'
print(msg.lower()) # aabbdd
print(msg.upper()) # AABBDD

# startswith 与 endswith
# startswith(prefix[, start[, end]])
# 检查字符串是否是以指定子字符串 prefix 开头，是则返回 True，否则返回 False。如果start 和 end 指定值，则在指定范围内检查
# endswith(suffix[, start[, end]])
# 检查字符串是否是以指定子字符串 prefix 结尾，是则返回 True，否则返回 False。如果start 和 end 指定值，则在指定范围内检查

name = 'alex'
print(name.startswith('a')) # True
print(name.endswith('x')) # False

# join(seq)
# 以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
print('.'.join(['ab', 'pq', 'rs']))
# ab.pq.rs

# replace(old, new [, count])
# 将字符串中的 str1 替换成 str2,如果 count 指定，则替换不超过 count 次
message = 'welcome to the world of python'
print(message.replace('python','Java'))
# welcome to the world of Java

# isdigit()
# 如果字符串只包含数字则返回 True 否则返回 False..
number = '12212sfs'
print(number.isdigit()) # False

# count(sub[, start[, end]])
# 返回str在string里面出现的次数，如果start或者end指定则返回指定范围内str出现的次数
info = 'abc alex alex alex'
print(info.count('alex')) # 3

# 6.切分split
# 6.1 括号内不指定字符，默认以空格作为切分符号
>>> str3='hello world'
>>> str3.split()
['hello', 'world']
# 6.2 括号内指定分隔字符，则按照括号内指定的字符切割字符串
>>> str4 = '127.0.0.1'
>>> str4.split('.')  
['127', '0', '0', '1']  # 注意:split切割得到的结果是列表数据类型

# 5.strip移除字符串首尾指定的字符(默认移除空格)
# 5.1 括号内不指定字符，默认移除首尾空白字符(空格、\n、\t)
>>> str1 = '  life is short!  '
>>> str1.strip()  
life is short!

# 5.2 括号内指定字符，移除首尾指定的字符
>>> str2 = '**tony**'  
>>> str2.strip('*')  
tony

3-列表list

1-列表的作用

　　序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。

　　Python有6个序列的内置类型，但最常见的是列表和元组。

　　序列都可以进行的操作包括索引，切片，加，乘，检查成员

　　此外，Python已经内置确定序列的长度以及确定最大和最小的元素的方法

　　列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现

　　列表的作用是按位置存放多个值

2-列表的定义

# 创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可
list1 = ['hello','world',12,100]
list2 = [1, 2, 3, 4, 5 ]
list3 = ["a", "b", "c", "d"]

3-列表类型转换 list()

# 但凡能够被for循环遍历的类型都可以 当做参数传给 list() 函数转成列表
res = 'hello' # 字符串
print(list(res)) # ['h', 'e', 'l', 'l', 'o']

dic = {'a':1,'b':2,'c':3} # 字典
print(list(dic)) # ['a', 'b', 'c']

4-列表的内置方法

# 按索引取值(正向存取+反向存取) 即可存也可以改
list1 = ['a','b',1,2]
# 正向
print(list1[0]) # a
# 反向
print(list1[-1]) # 2
# 改
list1[0] = 'AA'
print(list1) # ['AA', 'b', 1, 2]

# 切片 (顾头不顾尾，步长) 就是浅拷贝行为
lis = ['abc','g',122,[123],1,23,66]
print(lis[:3]) # ['abc', 'g', 122]
print(lis[2:]) # [122, [123], 1, 23, 66]
# 指定步长
print(lis[:5:2]) # 0 2 4
# ['abc', 122, 1]

# 反向步长
print(lis[6:0:-2]) # 6 4 2
# [66, 1, 122]

# len() 统计长度
print(len(lis)) # 7

# 反转
print(lis[::-1]) # [66, 23, 1, [123], 122, 'g', 'abc']

# 成员运算 in 和 not in
l = [1,2]
print(1 in l) # True
print(1 not in l) # False

# 追加 append() 函数 在列表末尾添加新的对象
lists = ['abc']
lists.append('bbbb')
print(lists) # ['abc', 'bbbb']

# 插入 insert(index,obj) 函数 将对象插入指定位置
# 参数index:索引位置
# 参数obj:要插入的对象
lis = ['a','b','d']
lis.insert(2,'c')
print(lis) # ['a', 'b', 'c', 'd']

# extend(iterable) 函数 在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)
# 参数：iterable 可迭代对象
l1 = [1,2,3]
l2 = ['a','b','c']

l2.append(l1)
print(l2) # ['a', 'b', 'c', [1, 2, 3]]
# 注意：append方法是把列表作为一个整体追加在另一个列表中

l2.extend(l1)
print(l2) # ['a', 'b', 'c', 1, 2, 3]

# 方式1 del关键字 通用的删除方法，没有返回值
lists = ['hello','world','of','the','python']
del lists[4]
# res = del lists[4] 报错：不支持赋值
print(lists) # ['hello', 'world', 'of', 'the']

# 方式2 pop(index) 函数 按索引删除元素(默认删除最后一个)，并且返回删除的元素
# 参数index：索引
lis1 = ['a','b','c']
res = lis1.pop(2)
print(res) # c
print(lis1) # ['a', 'b']

# 方式2 remove(object) 函数 按照元素对象删除元素，没有返回值
# 参数object:要删除的对象元素
list2 = [1,2,3,4]
res = list2.remove(4)
print(res) # None
print(list2) # [1, 2, 3]

lis = [1,2,3]
for i in lis:
    print(i)

"""
1
2
3
"""

其他常用方法

# count(object) 函数 统计某个元素在列表中出现的次数
# 参数object：要统计的元素对象
lis1 = [1,1,1,2,'s','a']
print(lis1.count(1)) # 3

# index(object,start,stop) 函数 从列表中找出某个值第一个匹配项的索引位置,找不到则报错
# 参数object：要查找的元素对象
# 参数start：设置范围开始查找的位置
# 参数stop：查找结束的位置
lis2 = ['a','b','b','c',1,1,2,3]
print(lis2.index('b',1,3)) # 1
print(lis2.index(3)) # 7

# clear() 函数 清空列表
lis3 = [1,2,3]
lis3.clear()
print(lis3) # []

# reverse() 函数 反向列表中元素
lis4 = [3,2,1]
print(lis4[::-1]) # [1, 2, 3]
lis4.reverse()
print(lis4) # [1, 2, 3]

# sort(key,reverse) 函数 对原列表进行排序 必须是同种类型才可以排序
# 参数key=：配合lambda使用
# 参数reverse：reverse=True 降序   reverse=False 升序
lis5 = [9,8,7,6,5,4,3,2,1]
lis5.sort(reverse=False)
print(lis5) # [1, 2, 3, 4, 5, 6, 7, 8, 9]

4-两种数据类型模拟：队列和堆栈

# 队列
# 队列：FIFO即先进先出
l = []
# 入队
l.append(1)
l.append(2)
l.append(3)
print(l)
# 出队
l.pop(0)
l.pop(0)
l.pop(0)

# 堆栈
# 堆栈：FOLI即先进后出
lis = []
# 入栈
lis.append(1)
lis.append(2)
lis.append(3)
# 出栈
lis.pop()
lis.pop()
lis.pop()

5-元组

1-元组：元组与列表类似，也是可以存多个任意类型的元素，不同之处在于元组的元素不能修改，即元组相当于不可变的列表，用于记录多个固定不允许修改的值，单纯用于取

2-作用：按照索引/位置存放多个值，只用于取，不可改

3-定义

# 在()内用逗号分隔开多个任意类型的值
hero = ("李白","韩信","张飞")  # 本质:hero = ("李白","韩信","张飞")
# 强调：如果元组内只有一个值，则必须加一个逗号，否则()就只是包含的意思而非定义元组
new_hero = ("关羽",)  # 本质:new_hero = ("关羽",)

print(hero,type(hero))
# ('李白', '韩信', '张飞') <class 'tuple'>
print(new_hero,type(new_hero))
# ('关羽',) <class 'tuple'>

补充：x = (10) <--> x = 1 单独一个括号代表包含的意思

4-元组数据类型在内存中的本质

hero = ("李白","韩信","张飞")  # hero = (0-->值'李白'的内存地址,1-->值'韩信'的内存地址,2-->值'张飞'的内存地址)
# hero[0] = '貂蝉' 报错：元组是不可变类型
t = (1,['a','b'],) # t = (0-->值1的内存地址,1-->值['a','b']的内存地址,)
# t[0] = 1111 不可改:指的是不可改变元组的内存地址

print(id(t[0]),id(t[1]))
# 140704856716112 1787481317960
t[1][0] = 'A'
print(id(t[0]),id(t[1]))
# 140704856716112 1787481317960
print(t)
# (1, ['A', 'b'])

5-元组类型转换

tuples = tuple('可迭代类型')
# 注意：tuple函数的参数只要是可迭代类型都可以被转换

# 可迭代类型先可理解为但凡能被for循环的遍历的数据类型都可以传给tuple()转换成元组类型
tuple('wdad') # 结果：('w', 'd', 'a', 'd') 
tuple([1,2,3]) # 结果：(1, 2, 3)
tuple({"name":"jason","age":18}) # 结果：('name', 'age')
tuple((1,2,3)) # 结果：(1, 2, 3)
tuple({1,2,3,4}) # 结果：(1, 2, 3, 4)
# tuple()会跟for循环一样遍历出数据类型中包含的每一个元素然后放到元组中

6-元组使用(内置方法有 index 和 count 和列表是一样的)

>>> tuple1 = (1, 'hhaha', 15000.00, 11, 22, 33) 
# 1、按索引取值(正向取+反向取)：只能取，不能改否则报错！  
>>> tuple1[0]
1
>>> tuple1[-2]
22
>>> tuple1[0] = 'hehe'  # 报错：TypeError:

# 2、切片(顾头不顾尾，步长)
>>> tuple1[0:6:2] 
(1, 15000.0, 22)

# 3、长度
>>> len(tuple1)  
6

# 4、成员运算 in 和 not in
>>> 'hhaha' in tuple1 
True
>>> 'hhaha' not in tuple1  
False 

# 5、循环
>>> for line in tuple1:
...     print(line)
1
hhaha
15000.0
11
22
33

6-字典dict

1-字典：在{}内用逗号分隔开多元素，每一个元素都是key:value的形式，其中value可以是任意类型，而key则必须是不可变类型，通常key应该是str类型，因为str类型会对value有描述性的功能

2-作用：Python语言中唯一的映射类型

3-定义：

# 1-定义：{key1:value1,key2:value2}
# 键与值用冒号 : 分开
# 元素之间用 , 分开
d1 = {'name':'张飞','age':22} # d1 = dict(name='张飞',age=22)  # d1 = dict(["name":"张飞","age":22])
print(d1['name'])
print(d1['age'])
print(type(d1)) # <class 'dict'>

dic = {}.fromkeys(["k1","k2"],[])
print(dic) # {'k1': [], 'k2': []}
dic['k1'].append(1)
print(dic) # {'k1': [1], 'k2': [1]}

d = {} # 默认定义出空字典

# 2-特性
# key-value结构   key必须可hash，且必须为不可变类型，必须唯一
# 可以存放任意多个值，可修改，可以不唯一
# 无序

4-类型转换

# 数据类型的转换
info = [['name','李白'],['age',22],['gender','male'],['位置','打野']]
info_dict = {}
for i in info:
    info_dict[i[0]] = i[1]
print(info_dict) # {'name': '李白', 'age': 22, 'gender': 'male', '位置': '打野'}

res = dict(info) # 一行代码搞定
print(res) # {'name': '李白', 'age': 22, 'gender': 'male', '位置': '打野'}

# 快速初始化一个字典
# {}.fromkeys(key,'')
lis = ['a','b','c']
d= {}.fromkeys(lis,'王者荣耀')
print(d) # {'a': '王者荣耀', 'b': '王者荣耀', 'c': '王者荣耀'}

5-常用内置方法

# 1-按 key 存取值，可存可取.
# 针对赋值操作：key存在，则修改。  key不存在，则新增
d1 = {'name':'李白'}
d1['name'],d1['age'] = '韩信',22
print(d1) # {'name': '韩信', 'age': 22}

# 2-长度 len() 函数
d2 = {'a':1,'b':2,'c':3,'c':45,'c':520} # 这里需要注意一下，字典中的 key 必须唯一
print(d2) # {'a': 1, 'b': 2, 'c': 520}
print(len(d2)) # 3

# 3-成员运算 in 和 not in
d3 = {'name': '李白', 'age': 22, 'gender': 'male', '位置': '打野'}
print('name' in d3) # True
print(22 in d3) # False

# 4-删除
del d3['name'] # 通用的删除方法
res1 = d3.pop('age') # 根据key删除元素，返回key对应的删除值
print(res1) # 22
print(d3)
# 字典独有的删除方法 popitem() 随机删除元素并返回由删除元素组成的元组(key,value)
res2 = d3.popitem()
print(res2) # ('位置', '打野')
# 注意这里是随机删除

# 5-键keys() 值values() 键值items() python3中为了节省内存，都返回生成器
d4 = {'a':1,'b':2}
s = d4.keys()
print(s,type(s)) # dict_keys(['a', 'b']) <class 'dict_keys'>
print(d4.values()) # dict_values([1, 2])
print(d4.items()) # dict_items([('a', 1), ('b', 2)])

# 6-清空 clear() 函数
d5 = {'a':1,'b':2}
d5.clear()
print(d5) # {}

# 7-更新 update() 函数
d6 = {"打野":"韩信","中单":"王昭君"}
d6.update({"上单":"李信","打野":"libai"}) # 老字典有的更新，没有的追加
print(d6) # {'打野': 'libai', '中单': '王昭君', '上单': '李信'}

# 8-获取 get() 函数
d7 = {'a':1,'b':2}
# s = d7['c'] 此时key不存在，报错
s = d7.get('c','没有值') # key不存在，返回第二个参数指定的值，这里是 '没有值'
print(s) # 没有值

# 9-设置默认值 setdefault() 函数
d8 = {"age":22,"sex":"male"}
# if "name" in d8:
#     pass # ... 新语法，等同于pass
# else:
#     d8['name'] = 'howie'
# print(d8)
res = d8.setdefault('name','howie') # 如果key存在则添加，key不存在则添加,并返回key对应的值
print(d8) # {'age': 22, 'sex': 'male', 'name': 'howie'}
print(res) # howie

7-集合

1-集合的定义与类型转换

# 集合：集合、list、tuple、dict一样都可以存放多个值，但是集合主要用于：去重、关系运算
"""
定义：在{}内用逗号分隔开多个元素，集合具备以下三个特点：
     1：每个元素必须是不可变类型
     2：集合内没有重复的元素
     3：集合内元素无序
"""
# 示例
s = {1,2,3} # 本质 s = set({1,2,3})
s1 = set({1,2,3})
print(s,type(s)) # {1, 2, 3} <class 'set'>
print(s1,type(s1)) # {1, 2, 3} <class 'set'>

# s = {1,2,[17,8]} 报错 每个元素必须是不可变类型
s2 = {1,} # 注意：s2 = {} 时 默认是空字典，要定义空集合用 s2 = set()
print(type(s2)) # <class 'set'>

# 类型转换
res = set('helloeell')
# 去重
print(res) # {'h', 'e', 'l', 'o'}
# print(set([1,1,[2,3]])) 报错，每个元素必须是不可变类型

2-内置方法(关系运算符)，也有对应的函数，此处没有列出，因为不好记。

# 内置方法
s1 = set({'a','b','c'})
s2 = set({'a','b','v'})
# 取交集 &
print(s1&s2) # {'a', 'b'}

# 取并集/合集 |
print(s1|s2) # {'c', 'a', 'b', 'v'}

# 取差集 - 注意顺序不同，结果也不同
print(s1-s2) # {'c'}
print(s2-s1) # {'v'}

# 对称差集
print(s1^s2) # {'c', 'v'}

# 父子集(包含关系)
s3 = {1,2,3}
s4 = {1,2} # 注意:如果s4 = {1,2,4} 不存在包含关系，s3>s4 或 s3<s4 均为False
print(s3>s4) # True 说明:当s3大于等于s4的情况下，s4才是s3的子集

3-去重

# 去重的局限性
# 1-只能针对不可变数据类型去重
print(set([1,1,2,2,3])) # {1, 2, 3}
print(set([1,2[2,2]])) # 报错

# 2-无法保证原来的顺序
lis = [1,1,1,2,'a',3,3,3,4,5]
l = list(set(lis))
print(l)
# [1, 2, 3, 4, 5, 'a'] 与原来的顺序不一样了

4-其他内置方法

# 其他内置方法
# 1. discard() 函数 删除指定的元素，如果元素不存在，则不报错，无返回值
s1 = {1,2,3}
s1.discard(4)
print(s1) # {1, 2, 3}
# 对比remove
#s1.remove(4) # 删除元素不存在则报错

# 2.update() 函数 更新集合并去重
s1.update({3,4,5,6})
print(s1) # {1, 2, 3, 4, 5, 6}

# 3. pop() 随机删除 返回删除的元素
res = s1.pop()
print(res)
print(s1)

# 4. add() 增加元素
s1.add(res)
print(s1) # {1, 2, 3, 4, 5, 6}

# 5. isdisjoint() 两个集合完全独立，没有共同部分，返回True
res1 = s1.isdisjoint({8,9,10})
print(res1) # True