Python 数据类型

0. 整型(int)

作用： 用于加减乘除计算

print(1 + 1)

类型转换：

# 布尔值转整型
print(int(True))    # 输出：1
print(int(False))   # 输出：0

# 字符串转整型
print(int("666") + 1)   # 输出：667
print(int("0b1010011010",base=2))   # 二进制字符串转换成十进制整数，结果：666
print(int("0o1232",base=8))         # 八进制字符串转换成十进制整数，结果：666
print(int("0x29a",base=16))         # 十六进制字符串转换成十进制整数，结果：666

# 浮点数转换整型，会去掉小数
print(int(6.1))   # 输出：6

小知识：

# 在python2中 9/2 等于 4 不能保留小数，如果想保留小数需要导入 division模块
from __future__ import division
print(9/2)

# 在python3中可以保留小数
print(9/2)  # 结果:4.5

1. 长整型

• 在python2中数据类型有两种，int(整型)，long(长整型)，他们都是整型只是表示的范围不同
  • int,可表示的范围 :- 9223372036854775808~9223372036854775807
  • long,整数值超出int范围之后自动会转换为long类型(无限制)。
• 在python3中去除了long，只剩下int(整型)，并且int长度不在限制。

2. 浮点型(float)

浮点型一般用于小数

# 浮点型转换整型是会去掉小数
print(int(1.1))  # 结果：1

# round()，保留小数点后N位
num = 1.123456
res = round(num,3)  # 保留小数点后三位
print(res)

# 小数相加时会出现错误
num = 0.2
num2 = 0.1
num3 = num2 +num
print(num3) # 结果：0.30000000000000004

# 想要精确计算小数需要导入decimal模块
import decimal
v = decimal.Decimal("0.2")
v2 = decimal.Decimal("0.1")
v3= v + v2
print(v3)   # 结果：0.3

3. 布尔类型(bool)

• 布尔类型只有两个值：真(True) 或 假(False)

布尔类型转换：

• int整数类型： 0转换成布尔类型为False，其它都为True。
• str字符串类型、list列表类型、dict字典类型、tuple元组类型、set集合类型、：这5个类型只有在空的情况为False，其它都为True。

4 字符串(str)

# 判断类字符串,返回True或False
print("hello world".startswith("he"))   # startswith()判断是否以字符串 "he" 开头，返回 True或False
print("hello world".startswith("h",0,4))  #  判断是否以字符串 "h" 开头,并且在下标为0的字符串开始，下标为8的字符串结束
print("hello world".endswith("rld"))           #判断是否以字符串 "old" 结尾，返回 True或False ,在第4个开始，第8个结束
print(' '.isspace())             # 判断是不是空格
print('My Name Is'.istitle())    # 判断首字母是不是大写
print('ab'.islower())            # 判断是不是小写
print('My Name Is'.isupper())    # 判断是不是全是大写
print("aa".isidentifier())       # 判断是不是一个合法的标识符
print("10".isdigit())            # 判断是不是一个整数
print('33'.isnumeric())          # 判断是不是只有数字在里面
print("11".isalnum())            # 判断是不是阿拉伯数字加阿拉伯字符
print("jack".isalpha())          # 判断是不是纯英文字符
print("10".isdecimal())          # 判断是不是十进制


# strip(字符串)去除字符串两边的空格、换行符、制表符，也可以去除指定字符
v = " hello world "
print(v.strip())            # strip去除字符串两边的空格回车
print(v.lstrip())           # lstrip去除字符串左边的空格回车
print(v.rstrip())           # rstrip去除字符串右边的空格回车
print("16661".strip("1"))   # 去除指定字符"1"

# split(字符串) 字符串分割，分割后的字符串为列表，也可以指定字符串分割
print('hello world'.split())     # 按照空格分成列表
print('a,b,c'.split(",",1))  # 找到第一个逗号分割
print('hello,world'.split(","))  # 按照逗号分割
print('1+2\n3+4'.splitlines())   # 按换行来分

# replace(old,new) 字符串替换，形成新的字符串
print('aa bb cc'.replace('a','A')) #把a替换成大写a
print('aa bb cc'.replace('a','A',1)) #把a替换成大写a,只替换一个


# 字符串变大小写,不会修改原字符串
name = 'jaCK'
capitalize_name = name.capitalize() # 首字母大写
print(name,capitalize_name)

lower_name = name.lower()           # 把大写变成小写
print(name,lower_name)

upper_name = name.upper()             # upper()把小写变大写
print(name,upper_name)

swapcase_name = name.swapcase()       # 大写换小写，小写换大写
print(name,swapcase_name)

print('my name is jack'.title())  # 每个单词的首字母大写，输出:My Name Is Jack

# 字符串拼接，生成一个新字符串
print('+'.join(['1','2','3']))   # 根据join前面字符串拼接，输出：1+2+3

# 格式化字符串
print("my name is %s"%("jack"))
print("{v1} name is {v2}".format(v1="my",v2="jack1"))
f_name = "jack2"
print(f"my name is {f_name}")


# 字符串转字节
data = "张三"
print(data.encode("utf-8")) # 字符串转utf-8字节类型
print(data.encode("gbk")) # 字符串转gbk字节类型

print(b'\xe5\xbc\xa0\xe4\xb8\x89'.decode("utf-8"))  # utf-8字节类型转字符串
print(b'\xd5\xc5\xc8\xfd'.decode("gbk"))            # gbk字节类型转字符串



# 字符串居中，居左，居右显示。
aa = "aaaa"
print(aa.center(20,"-")) # 打印50个字符如果不够用-补齐把列表放中间
print("aa\taa".expandtabs(tabsize=30))  # 把tab键换成30个空格
print(aa.ljust(50,'*'))  # 保证长度50，不够的用*在后面补齐
print(aa.rjust(50,'-'))  # 证长度50，不够的用-在前面面补齐
print(aa.zfill(50))        # 不够的用0填充,用于处理二进制数据

# 字符串切片，字符串[start,end] ：start 开始下标，从0开始，end 结束下标，最后一个下标不会输出
aaa = "abcdefghij"
print(aaa[4:8])     # 结果：efgh
print(aaa[-1])     # 最后一个，结果：j
print(aaa[:])     # 全部，结果：abcdefghij
print(aaa[3:])     # 从下标第3个开始到最后一个，结果：defghij
print(aaa[:3])     # 从下标0开始，到下标3结束，结果：abc

# [start:end:整数]步长，跳着取值，间隔几个整数取值
num = "123456789"
print(num[::])     # 结果：123456789
print(num[1::2])   # 在下标1开始取值，每间隔2个下标取一次，结果：2468
print(num[1::3])   # 在下标1开始取值，每间隔3个下标取一次，结果：258


# 查找下标，统计字符串
print("hello world".find("o"))       # 查找o的下标数，输出：4
print('hello world'.rfind('o'))      # 从左往走找到最右边的值返回下标 ，输出：7
print("hello world".count("l"))      # 统计有几个l，输出：3

print('My Name Is'.isprintable())#检查字符串中的所有字符是可打印字符还是空字符串。如果所有字符都是可打印的或为空字符串，则函数返回真，否则返回假。
# 字符串中可打印的字符包括字母和符号、数字、标点符号和空白。不可打印字符是指那些在打印时不可见且不占用空间的字符(转义字符，如' \n '，' \t '，' \r '，' \x16 '，' \xlf '等)。




# string.maketrans(x[, y[, z]])：
# maketrans方法用于创建字符映射转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。,常与translate方法配合使用实现字符串的替换、删除或重排
  # 两个字符串的长度必须相同，为一一对应的关系。
  # 参数：
  #   x -- 必需，字符串中要替代的字符组成的字符串。
  #   y -- 可选，相应的映射字符的字符串。
  #   z -- 可选，要删除的字符。
p = str.maketrans('abcdef','123456') # 把a替换成1，b替换2，c替换3，以此类推
print('alex li'.translate(p))  # 在p中找到对应的字符替换>>> 115 li

String1 = "abc"
String2 = "ghi"
String3 = "ab"
string = "abcdef"
print("Before Translation:", string)
mapping= string.maketrans(String1, String2, String3)
print(mapping)
# translate(table,/)  对字符串进行交换或过滤
print("After Translation:", string.translate(mapping))  #


intab = "aeiou"
outab = "12345"
trantab = str.maketrans(intab,outab)
s = "this is string example....wow!!!"
print(s)
print(s.translate(trantab))
#
# string.maketrans(from, to)   # -> from映射到to，所以要求两个字符串一样长, 两个都为空，则为全部字符，那么不会出现替换

5 列表(list)

列表(list),是一个有序可变的容器，可以存放多种不同元素类型的值。

5.1 创建列表

name = ["a",1,"c",True,"a","f"]
或
name = list(["a","b","c","d","a","f"])
name2 = ["1","2","3","4"]

5.2 添加

v = ["a","b","c","d","d"]
# appeng()：列表结尾追加
v.append("end") # 在列表末尾添加
print(v)
# insert(位置下标，数据)：指定位置添加
v.insert(1,"在a和b中间") # 在下标1的位置插入 "在a和b中间"
print(v)
# extend(数据)：列表结尾追加数据，如何数据是一个列表，则将列表的数据逐一添加的列表
v.extend([1,2,3,4]) # 在v列表添加[1,2,3,4]列表
print(v)

5.3 删除

v = [1,2,3,4,5,6,7,8,9,10]
# pop()：删除指定下标的数据，默认删除最后一个，
v.pop()     # 删除最后一个元素  删除，10
v.pop(3)    # 删除下标为3的字符 删除，4
print(v)    # 结果：[1, 2, 3, 5, 6, 7, 8, 9]
# remove()：移除列表中某个数据的第一个匹配项
v.remove(3)   # 删除 3
print(v)    # 结果：[1, 2, 5, 6, 7, 8, 9]
# del：删除第一个或连续几个元素
del v[1]    # 删除下标为1的字符   删除，2
del v[1:3]  # 删除下标1到3的元素，不包含下标3的字符  删除，5, 6
print(v)    # 结果：[1, 7, 8, 9]
# clear()：清空数据
v.clear()
print(v)    # 结果：[]

5.4 修改

# 修改指定下标的数据
v = ["a","b","c"]
v[0] = '1'  # 修改，把下标为0的字符串 改成 i
print(v)    # 结果：['1', 'b', 'c']

5.5 查询

v = [1,2,3,4,5,1,1,]
# 列表[下标]：查询列表下的元素
print(v[1]) # 查询下标为1的元素，输出：2
# index(元素)：查询元素的下标
print(v.index(5)) # 查询5的下标，输出：4
print(v[v.index(5)]) # 根据5的下标查找5，输出：5
# count("元素")：查询元素的个数
print(v.count(1)) #统计有多少个1，输出：3

# 从后往前查询
list1= [1,2,3,4,5]
# 从前往后数下标是：0，1，2，3，4，最后一个值不取所有下标是5
print(list1[0:5])
# 从后往前数下标是：-1，-2，-3，-4，-5，最后一个值不取所有下标是-6
# 步长：整数从前往后步长，负数从后往前步长
print(list1[-1:-6:-1])

5.6 其他操作

v = ["a","b","c","d","e","f"]
# 切片
print(v[1])     # 输出列表下标为1的字符，结果：b
print(v[0:2])   # 切片,把小标0到2的字符都取出来，不包含2，结果:a,b
print(v[-1])    # -1 代表最后一个,结果：f
print(v[:2])    # name[:2]=name[0:2]  如果前面是0可以省略，结果：a,b
print(v[::2])   # [:]取全部，[::2]，从第一个开始没两个取一次。
print("a" in v) # 判断 "a" 是否在列表里，存在返回 true 否则返回 false

v = ["a","b","c","d","e","f"]

# len()列表长度
print(len(v))

# reverse()：反转
v.reverse()    # 反转列表
print(v)

# sort()：排序，特殊符号 --> 数字 --> 大写字母 --> 小写字母
v.sort()
print(v)

# copy()：复制模块
v1 = ["a","b",[1,2]]
v2 = v1.copy() # 浅复制 只复制列表的第一层
v1[2][1] = 0
print(v2,v1)

import copy # 引入模块
v3 = ["a","b",[1,2]]
v4 = copy.deepcopy(v3) # 深复制 完全复制一份
v3[2][1] = 0
print(v4,v3)

# 列表可以相加，相乘
list1 = [1,2,3] + [ 4,5,6]
print(list1)    # 结果：[1, 2, 3, 4, 5, 6]

list1 = [1,2,3] * 2
print(list1)    # 结果：[1, 2, 3, 1, 2, 3]

6.元组(tuple)

元组是一个有序且不可变的容器，可以存放多种不同类型的元素。

name = ("a",True,"c")
print(name[0])  # 结果：a

# (1) 和 (1,) 区别
  (1)  # 不会看成元组，是数字加了括号
  (1,) # 1后面有逗号，所以是元组

# 元组不能修改，但是元组中的列表可以修改。
v = ("a",1,[1,2,3],)
v[2].append(4)
print(v)  # 结果：('a', 1, [1, 2, 3, 4])

# 元组相加，相乘
tuple1 = (1,2,3) + (4,5,6)
print(tuple1)

tuple1 = (1,2,3) * 2
print(tuple1)

7.字典(dict)

字典是无序，键不重复的容器，字典以键值对{key:value}的方式保存。
字典的特性：

• dict 是无序的
• key 必须是唯一的，天生去重

7.1 创建字典

# 创建字典
dict1 = {}
dict2 = dict()
# 打印数据类型
print(type(dict1),type(dict2))

7.2 增加和修改

语法：字典[key] = value ：如果值存在就修改，不存在就增加

dict1 = {}
# 添加数据
dict1["张三"] = ["张三",18]
print(dict1)    # {'张三': ['张三', 18]}

# 修改数据
dict1["张三"] = ["张三",26,13500000000]
print(dict1)    # {'张三': ['张三', 26, 13500000000]}

# update() 更新字典，如果key存在就更新值，不存在就添加
info = {"name":"张三","age":10}
info.update({"age":18,"sex":"男"})
print(info) # {'name': '张三', 'age': 18, 'sex': '男'}

7.3 删除数据

• del：删除典中指定键值对
• pop()：删除典中指定键值对
• popitem()：随机删除
• clear()：清空字典

info = {"sut1":"aaaaa","sut2":"bbbbb","sut3":"ccccc","sut4":"ddddd"}

del info['sut1']       # 删除 sut1
print(info) # {'sut2': 'bbbbb', 'sut3': 'ccccc', 'sut4': 'ddddd'}

info.pop('sut2')       # 删除 sut2
print(info) # {'sut3': 'ccccc', 'sut4': 'ddddd'}

info.popitem()         # python3.6之前随机删除，3.6之后删除最后一个值，并返回
print(info) # {'sut3': 'ccccc'}

info.clear()           # 清空字典
print(info)# {}

7.4 查找

• Key值查找
  • 语法：字典[key]
  • 缺点：如果字典中没有key值，则会报错。

info = { "name":"kaer" , "age":18}
print(info["name"]) # kaer
print(info["name2"]) # 保存

• get()：如果查找的key不存在则返回第二个参数（默认值），如果没写默认值，则返回None。
  • 语法：字典.get(key, 默认值)，key存在返回key的值，不存在返回默认值

info = {"name": "kaer", "age": 18}
print(info.get("name"))  # kaer
print(info.get("name2"))  # None
print(info.get("name2", "name2不存在"))  # name2不存在，输出:"name2不存在"

• keys()：查找字典中所有的key，返回可迭代对象

info = {"name": "kaer", "age": 18}
print(info.keys())

• values()：查找字典中所有的value，返回可迭代对象

info = {"name": "kaer", "age": 18}
print(info.values())

• items()：把字典中每对键值对组成一个元组，并把这些元组放在列表中返回

info = {"name": "kaer", "age": 18}
# 把key赋值给k，把value赋值给v
for k, v in info.items():
    print(k, v)

• fromkeys赋值

# 字典赋值
# [6,7,8] 字典的key，test字典的值
c = info.fromkeys([6, 7, 8], 'test')  # 创建一个字典

• setdefault：setdefault()方法和get()方法类似, 如果键不存在于字典中，将会添加键并将值设为默认值。
  • 语法：dict.setdefault(key, default=None)

info = {}
info.setdefault('北京', {'昌平': ['回龙观', '天通苑']})
print(info['北京'])
print(info['北京']['昌平'])

7.5 字典的遍历

info = {"name":"kaer", "age":18}

# 遍历key值
for k in info.keys():
    print("key值：",k," value值：",info[k])
# 遍历value值
for v in info.values():
    print("value值：",v)
# 遍历value值
for k,v in info.items():
    print("key值：",k,"value值：",v)

8.集合(set)

集合是一个无序，可变，不允许重复的容器。

• 去重，把一个列表变成集合，就自动去重了
• 关系测试，测试两组数据之前的交集、差集、并集等关系

8.1 创建集合

# 创建集合
s1 = {1,4,5,7,3,6,7,9}
s2 = set('abcd')
s3 = set()
# 打印 s1,s2,s3,数据类型
print(type(s1),type(s2),type(s3))
# 创建列表
list_1 = [1,4,5,7,3,6,7,9]
# 列表转换成集合
list_1 = set([list_1])  
list_2 = set([2,6,0,66,22,8,4])
list_3 = set([1,3,7])
list_4 = set([5,6,8])

8.2 增加数据

集合有去重功能，当追击的数据是集合中存在的，则不进行任何操作
存储原理：利用哈希函数(hash)将字符串转成一个数值如：8392831571661386736，再用这个值，做位运算取余，得到的余数是几就放到那个索引下。
只有能被哈希的数据类型，才能存入集合中。

# add()：添加
list_3.add(100)
# update()：追加的数据是序列
list_3.update([22,44,66])

# 查看哈希值
num = hash("张三")
print(num)

8.3 删除数据

# remove()：删除集合中的指定数据，如果数据不存在会报错
list_4.remove(5)    # 删除5，没有会报错
# discard()：删除集合中的指定数据，如果数据不存在,不会报错
list_3.discard(1)   # 删除1，没有不会报错
print(list_3,list_4)
# pop()：随机删除集合中的某个数据，并返回这个数据。
list_3.pop()        #随机删
print(list_3)

8.4 查找数据

判断数据在集合序列中，返回True或False

# in：判断数据在集合序列
list1 = {1,2,3,4}
print(4 in list1)  # True

# not in：判断数据不在集合序列
print(4 not in list1)  # False

8.5 其他操作

list_1 = [1,4,5,7,3,6,7,9]
list_1 = set(list_1)
list_2 = set([2,5,6,0,66,22,8,4])
list_3 = set([1,3,7])
list_4 = set([5,6,8])
 
# 交集：把两个集合中相同的打印出来
print(list_1 & list_2)
print(list_1.intersection(list_2))
#并集：两个集合，合并，重复的只打印一次
print(list_1 | list_2)
print(list_1.union(list_2))
#差集：打印其他集合中不存在的数据
print(list_1 - list_2)
print(list_1.difference(list_2)) #list_1打印第list_2没有的数据
print(list_2.difference(list_1)) #list_2打印第list_1没有的数据
#子集：list_1集合中包含list_3
print(list_3.issubset(list_1))
#父集：list_2集合中包含list_4
print(list_2.issuperset(list_4))
#对称差集：list_1 和 list_2 集合中有相同的数据都不打印
print(list_1 ^ list_2) #合并重复的不打印
print(list_1.symmetric_difference(list_2))
#判断是否是交集：判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False
print(list_3.isdisjoint(list_1))
 
#集合长度
print(len(list_3))

9. None类型

空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值

10. 推导式

作用：用一个表达式创建一个有规律的列表和控制一个有规律列表。列表推导式又叫列表生成式。

10.1 列表推导式

while 循环实现

list0 = []
num = 0
while num < 10:
    list0.append(num)
    num += 1
print(list0)

for 循环实现

# 方法一：
list1 = []
for i in range(10):
    list1.append(i)
print(list1)
# 方法二:推导式
list2 = [i for i in range(10)]
print(list2)

带判断的列表推导式

# 需求：创建0-10的偶数列表
list3 = [i for i in range(10) if i % 2 == 0 and i != 0 ] # 带判断的推导式  
list4 = [i for i in range(0,10,2) if i != 0 ]   # 步长实现
print(list3)
print(list4)

列表推导式中写多个for循环

list5 = [(i,j) for i in range(4) for j in range(i) ]
print(list5)
# 相当于
list6 = []
for i in range(4):
    for j in range(i):
        list6.append((i,j))
print(list6)

10.2 字典推导式

# 字典推导式
dict0 = {i: i**2 for i in range(5)}
print(dict0)

合并两个列表

name = ["kaer","man",18]
title = ["name","gender","age"]
dict1 = {title[i]:name[i] for i in range(len(name))}
print(dict1)

提取字典中目标数据大于200的

counts = {"HP":202,"DELL":201,"MAC":199,"MBP":198}
countNum = {k:v for k,v in counts.items() if v >200}
print(countNum)

10.3 集合推导式

set0 = {i**2 for i in range(5)}
print(set0)