整体介绍

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)