Python第二天-基本数据类型

整体介绍

python有以下几种基本类型，int，float，str，range，slice，bool，list，tuple，dict，set

详细介绍

int

int表示整型数字，不管多大的数字都可以用int表示，整合了java中的byte，short，int，long。

将其他类型转换成int类型

a = '123'
b = int(a, base=10)

可以将字符串，布尔值，字节数组转换成int值，第二个参数为进制，默认10进制，如果为非字符串，不能设置进制。类似java的Integer.parseInt方法。

获取二进制长度

a = 5
print(a.bit_length())

类似java的Integer.toBinaryString().length()

运算符

print(1 + 1)  # 加
print(1 - 1)  # 减
print(1 * 1)  # 乘
print(1 / 1)  # 除 结果为 float
print(1 // 1) # 整除 结果为 int
print(1 % 1)  # 取余
print(1 ** 1) # 次方 类似java的Math.power()

float

float表示浮点数

price = 12.5
print(type(price))
print(float(12))
print(float("12.45"))

bool

bool 表示布尔值，python中bool是继承int类型的，True表示1，False表示0

print(bool(0))
print(bool(1))
print(bool(2))
print(bool(""))
print(bool(" "))
print(bool("ad"))

可以将int或str转换成bool类型，0或空字符串为false，其他都是True。

str

str表示字符串类型，字符串都是比可变的，每次操作都会创建一个新的字符串对象。

各种方法

print("this is".capitalize())  # Abc 首字符大写 其余小写 类似java中apache commons StringUtils.capitalize()
print("ABC".center(7, "*"))  # **ABC** 左右填充数据 内容居中 填充内容只能是一个字符 类似java中StringUtils.center()
print("AABBCC".count("ABC"))  # 子字符串包含的数量 类似java中StringUtils.countMatches()
print("ABC".startswith("AB"))  # 是否以某前缀开始 类似java的String.startsWith()
print("ABC".endswith("AB"))  # 是否以某后缀结束 类似java的String.endsWith()
print("A\tB\tC".expandtabs(3))  # 将tab字符使用空格扩展，默认8个空格
print("ABC".find("BC"))  # 找到的第一个索引 找不到为-1 类似java的String.indexOf()
print("ABC".rfind("C"))  # 找到的最后一个索引 找不到为-1 类似java的String.lastIndexOf()
print("ABC".index("A"))  # 找到的第一个索引 找不到抛出错误
print("I am %s,age is %d" % ("lisi", 23))  # 格式化 根据名字 类似java的String.format()
print("I am {name},age is {age}".format(age=23, name="lisi"))  # 格式化 根据名字 类似java的String.format()
print("I am {0},age is {1}".format("lisi", 24))  # 格式化 根据索引
print("I am {name},age is {age}".format_map({"name": "lisi", "age": 21}))  # 格式化 根据字典
print("abc123".isalnum())  # 是否只包含字符和数字 不能包含特殊字符 空白字符 类似java中StringUtils.isAlphanumeric()
print("abc".isalpha())  # 是否只包含字符 不能包含特殊字符 空白字符 数字 类似java中StringUtils.isAlpha()
print("234".isdecimal())  # 是否只包含十进制数字
print("234".isdigit())  # 是否只包含数字
print("dict".isidentifier())  # 是否是python标识符
print("abc".lower())  # 转换成小写  类似java中StringUtils.toLowerCase()
print("abc".islower())  # 是否是小写字符串 类似java中StringUtils.isAllLowerCase()
print("ABC".upper())  # 转换成大写 类似java中StringUtils.toUpperCase()
print("ABC".isupper())  # 是否是大写字符串 类似java中StringUtils.isAllUpperCase()
print("12.4".isnumeric())  # 是否只包含数字 类似java中StringUtils.isNumeric()
print("abc".isprintable())  # 是否为可打印字符串 \t \n 都是不可打印字符
print(" \t".isspace())  # 是否为空白字符串 空格 制表符 换行符 类似java中StringUtils.isBlank()
print("Abc".istitle())  # 是否每个单词为首字母大写 其余小写
print("*".join(["a", "b", "c"]))  # 以某字符串分隔符合并成新的字符串 类似java的String.join()
print("abc".ljust(5, "*"))  # 右边填充数据 类似java中StringUtils.leftPad()
print("abc".rjust(5, "*"))  # 左边填充数据 类似java中StringUtils.rightPad()
print(" abc abc ".lstrip().__len__())  # 去除左边空白字符 类似java中StringUtils.stripStart()
print(" abc abc ".rstrip().__len__())  # 去除右边空白字符 类似java中StringUtils.stripEnd()
print(str.maketrans("abc", "123"))  # 创建一个映射关系 dict类型
print("a*b*c".partition("*"))  # 从左边开始 以一个分隔符分割成3部分
print("a*b*c".rpartition("*"))  # 从右边开始 以一个分隔符分割成3部分
print("aaa".replace("a", "A", 1))  # 字符替换 默认替换所有
print("a*b*c".split("*", 1))  # 从前往后分割 分割出指定数量
print("a*b*c".rsplit("*", 1))  # 从后往前分割 分割出指定数量
print("a\nb\nc".splitlines())  # 按行分割
print("Abc".swapcase())  # 大写转小写 小写转大写
print("this is".title())  # 间将每个单词首字符大写 其余小写
print("abc".translate(str.maketrans("abc", "123"))) # 将字符串根据映射关系转换成新字符串
print("abc".zfill(5)) # 用0填充左边
print(len("abc"))  # 字符串长度 类似java中String.length()
print("a" in "abc") # 是否包含 类似java中String.contains()
print("abc".encode(encoding="utf-8")) # 将字符串编码为字节数组 默认编码utf-8

单引号 双引号 三引号

print("i'am lisi")
print('i"am lisi')
abc = """
hello 
 world
 lisi
"""
print(abc)

单引号和双引号都可以声明字符串，在单引号中包含双引号不需要转义，反之亦然。三引号（包括单引号和双引号）可以让字符串原样输出。

迭代

print("abc"[1])  # 根据索引获取子字符串
print("abcdefghijklmnopqrst"[0:-1:3])  # 根据切片获取子字符串
for x in "abcd":
    print(x)

range

range表示一个不可变的数字序列

a = range(0, 10, 2)
for i in a:
    print(i)
print(a.index(2))
print(a.count(2))

创建一个range对象，包含3个属性
start：开始位置，默认0，
stop：结束位置，不包括结束
step：步长，默认1
range不会存储实际的数据，每次使用到才会计算，只会占用很少的内存，这也是对比list，tuple类型的优势。

slice

slice可以看做一个切片，表示字符串str，集合list，元组tuple的索引的不可变集合

s = slice(0, 10, 2)
print("abcdefghijklmn"[s])  # 字符串截取
print("abcdefghijklmn"[0:10:2])  # 字符串截取
print([1, 2, 3, 4, 5, 6, 7, 8, 9][s])  # list截取
print((1, 2, 3, 4, 5, 6, 7, 8, 9)[s])  # tuple截取
print(s.indices(5))  # 返回一个包含start，stop，step的tuple 参数比stop大，取之前的，小的话取参数

创建一个slice也是需要start，stop，step3个参数

list

list表示一个可变的列表，类似java中的List。可以存放任意类型的元素。

names = ["lisi", "wangwu", 12, 24, ["a", "b"]]
li = list("abcd")
names.append("c")  # 追加元素
names.insert(-1, "d")  # 指定索引元素之前插入元素
names[-1] = "e"  # 指定索引元素修改
del names[-1]  # 指定索引元素删除
names[0:2] = ["x", "y"]  # 指定切片元素修改
del names[0:2]  # 指定切片元素删除
print(names, li)
print(names.count(12))  # 统计元素数量
print(names.index(12))  # 查找元素索引 找不到抛出错误
print(names.pop())  # 删除最后一个元素并返回
names.remove(12)  # 删除元素
print(names.copy())  # 列表拷贝 返回一个新的列表
names.reverse()  # 列表数据翻转
names.clear()  # 清空
names = [23, 12, 56]
names.sort(key=lambda x: x, reverse=True)  # 列表排序 key指定排序字段，reverse表示是否翻转
names.extend(["d", "e"])  # 批量追加元素
print("d" in names) # 元素是否在列表中
print(names)

tuple

tuple在python中称做元组，表示一个不可变的列表，内容包括添加，修改，删除，类似java中的ImmutableList。

tu = (2)  # 不加,表示int
print(type(tu))  # int 类型
tu = (2,)  # 定义元组
print(type(tu))  # tuple类型 
tu = tuple([1, 2, 3])  # 根据迭代器对象创建元组
print(type(tu))
print(tu.count(1))  # 元素数量
print(tu.index(1))  # 元素索引

dict

dict表示一个字典，键值对的集合，类似java中的Map。

person = {
    "name": "lisi",
    3: 5,
    True: True,
    (1, 2,): [1, 2],
}  # 定义字典
person["age"] = 34  # 添加或修改键值对
del person["age"]  # 删除键值对
print("name" in person)  # key是否存在
person["age"] = 4
print(person.get("age"))  # 获取key对应的值 key不存在返回None
print(person["age"])  # 获取key对应的值 key不存在报错
print(person.pop("age"))  # 删除key并返回value
print(person.popitem())  # 按后进先出的顺序删除一个键值对 字典为空，报错
print(person.copy())  # 字典拷贝
print(person.update({"name": "li"}))  # 将新字典的值更新到原字典中
print(person)
for key in person.keys():  # 遍历key
    print(key)
for val in person.values():  # 遍历value
    print(val)
for key, val in person.items():  # 遍历key，value
    print(key, val)
person.clear()  # 字典清空
print(person)

set

set表示无序的不重复的集合，只能存储不可变类型，如int,float,str,tuple

name_set = {"lisi", "Tom", "Mary", "xioaming"}  # 定义集合
age_set = set([4, 6, 8, 2])  # 定义集合
print(name_set)
name_set.add("xioali")  # 添加元素
print(name_set)
print(name_set.copy())  # 集合复制
print(name_set.difference({"lisi", "Tom"}))  # 集合求差集
name_set.difference_update({"lisi", "Tom"})  # s1=s1.difference(s2) 集合求差集并更新原集合
print(name_set)
name_set.discard("lisi")
print(name_set)
print(name_set.intersection({"Mary"}))  # 集合求交集
name_set.intersection_update({"Mary"})  # 集合求交集并更新原集合
print(name_set.isdisjoint({"Mary"}))  # 是否没有交集
print(name_set.issubset({"Mary"}))  # 是否为子集
print(name_set.issuperset({"Mary"}))  # 是否为父集
print(name_set.pop())  # 随机删除并返回
name_set.add("Mary")
name_set.remove("Mary")  # 删除元素 不存在抛出错误
print(name_set.symmetric_difference({"Mary"}))  # 集合求交叉补集
name_set.symmetric_difference_update({"Mary"})  # 集合求交叉补集并更新原集合
print(name_set.union({"Mary"}))  # 集合求并集
name_set.update({"Mary"})  # 集合求并集并更新原集合
print(name_set)
name_set.clear()  # 集合清空
print(name_set)
age_set = frozenset([1, 2, 3, 4, 4]) # 定义不可变集合
print(age_set)