python基本数据类型

一.数字

int（整型）

　　在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647
　　在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807

float（浮点实际值）：代表实数，小数除以整数部分和小数部分的书面。

complex(复数)

二.字符串

迭代
索引
切片
长度(len())

字符串方法

capitalize   首字母大写
casefold   所有变小写,casefold()对于非中英文的其他语言小写有效
宽度设置
    center(20,'*')   设置宽度，内容居中 
    ljust(20,'*')   设置宽度，内容居左 
    rjust(20,'*')   设置宽度，内容居右
    zfill(20)   内容在右，其余0填充

count('子序列'[, start[, end]]  -->计算出现次数

编码及解码
    encode(encoding='utf-8', errors='strict')：编码
    decode(encoding='utf-8',errors='strict')：解码
    -> 先编码，再解码，编码解码一致，否则会乱码

结尾、开始
    endswith(suffix[, start[, end]])
    tartswith

expandtabs(tabsize=8)
    断句,配合制表符	使用

寻找
    find(sub[, start[, end]])    未找到返回 -1
    index(sub[, start[, end]])    未找到报错

format    格式化输出

判断
    isalnum()    是否只包含 字母和数字
    isalpha()    是否是字母，汉字
    是否为数字
        v1 = test.isdecimal()   # 123                   ---》十进制
        v2 = test.isdigit()        # 123①②③          ---》数字
        v3 = test.isnumeric()  # 123①②③一二三  ---》数字的
    isprintable()    是否存在不可显示的字符 	 

    isspace()    是否全部是空格
    istitle()    是否是标题(所有单词首字母大写)
    isidentifier()    是否全是字母，数字，下划线

'_'.join(test)    拼接

大小写
    islower()    是否为小写
    lower()    转为小写
    isupper()    是否是大写
    upper()    转为大写
    swapcase()    大小写相互转换

移除制定字符串
    lstrip('xa')
    rstrip()
    strip()
    有限最多匹配,无参数时去除空格

对应关系替换
    print(v.translate(str.maketrans('123','asd')))
        ①先用str.maketrans 创建关系，数量需要一致
        ②调用translate 替换
    replace(old, new[, count])

分割
    partition(sep) -> (head, sep, tail)
    rpartition()
    split('j',2)    不包括自己，默认全部分割，后面可以制定分割次数
    splitlines(False)    根据换行分割，True表示保留
,默认不保留

字符串方法

重点方法：join,split,find,strip,upper,lower,replace

字符串官方文档

注意：字符串一旦创建，不可修改，一旦修改或者拼接，都会造成重新生成字符串。

三.列表

索引
切片
追加
删除
长度
切片
循环

包含

 1 def append(self, *args, **kwargs):  # real signature unknown
 2     """ Append object to the end of the list. 尾部添加一个对象"""
 3     pass
 4 
 5 
 6 def clear(self, *args, **kwargs):  # real signature unknown
 7     """ Remove all items from list. 清空列表"""
 8     pass
 9 
10 
11 def copy(self, *args, **kwargs):  # real signature unknown
12     """ Return a shallow copy of the list.复制列表，浅复制 """
13     pass
14 
15 
16 def count(self, *args, **kwargs):  # real signature unknown
17     """ Return number of occurrences of value. 计算元素出现的次数"""
18     pass
19 
20 
21 def extend(self, *args, **kwargs):  # real signature unknown
22     """ Extend list by appending elements from the iterable. 追加可迭代对象，一个个增加"""
23     pass
24 
25 
26 def index(self, *args, **kwargs):  # real signature unknown
27     """
28     Return first index of value.根据值获取索引位置，返回第一个值位置
29     Raises ValueError if the value is not present.超出范围报错
30     """
31     pass
32 
33 
34 def insert(self, *args, **kwargs):  # real signature unknown
35     """ Insert object before index.根据索引位置插入值，在inde之前 """
36     pass
37 
38 
39 def pop(self, *args, **kwargs):  # real signature unknown
40     """
41     尾部删除
42     Remove and return item at index (default last).
43     Raises IndexError if list is empty or index is out of range.
44     """
45     pass
46 
47 
48 def remove(self, *args, **kwargs):  # real signature unknown
49     """
50     删除第一个出现的值，不存在就报错
51     Remove first occurrence of value.
52     Raises ValueError if the value is not present.
53     """
54     pass
55 
56 
57 def reverse(self, *args, **kwargs):  # real signature unknown
58     """ Reverse *IN PLACE*. 反转"""
59     pass
60 
61 
62 def sort(self, *args, **kwargs):  # real signature unknown
63     """ Stable sort *IN PLACE*. 排序"""
64     pass

列表官方文档

四.元祖

索引
切片
循环
长度
包含

1 # 创建元祖
2 t = (1,2,3,)
3 t = tuple((1,2,3,))
4 
5 # 元组的一级元素不可修改/删除/增加,  例如如果二级是列表，可以修改
6 # 写元组的时候，推荐在最后加','
7 # 支持索引，切片，迭代，可以for循环，支持join方法
8 # 方法：count();   index()

元祖官方文档

五.字典

索引
新增
删除
键、值、键值对
循环
长度

 1 def clear(self):  # real signature unknown; restored from __doc__
 2     """ 清除内容 """
 3     """ D.clear() -> None.  Remove all items from D. """
 4     pass
 5 
 6 
 7 def copy(self):  # real signature unknown; restored from __doc__
 8     """ 浅拷贝 """
 9     """ D.copy() -> a shallow copy of D """
10     pass
11 
12 
13 @staticmethod  # known case
14 def fromkeys(S, v=None):  # real signature unknown; restored from __doc__
15     """
16     dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v.
17     v defaults to None.
18     """
19     pass
20 
21 
22 def get(self, k, d=None):  # real signature unknown; restored from __doc__
23     """ 根据key获取值，d是默认值 """
24     """ D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None. """
25     pass
26 
27 
28 def items(self):  # real signature unknown; restored from __doc__
29     """ 所有项的列表形式 """
30     """ D.items() -> list of D's (key, value) pairs, as 2-tuples """
31     return []
32 
33 
34 def keys(self):  # real signature unknown; restored from __doc__
35     """ 所有的key列表 """
36     """ D.keys() -> list of D's keys """
37     return []
38 
39 
40 def pop(self, k, d=None):  # real signature unknown; restored from __doc__
41     """ 获取并在字典中移除 """
42     """
43     D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
44     If key is not found, d is returned if given, otherwise KeyError is raised
45     """
46     pass
47 
48 
49 def popitem(self):  # real signature unknown; restored from __doc__
50     """ 获取并在字典中移除 """
51     """
52     D.popitem() -> (k, v), remove and return some (key, value) pair as a
53     2-tuple; but raise KeyError if D is empty.
54     """
55     pass
56 
57 
58 def setdefault(self, k, d=None):  # real signature unknown; restored from __doc__
59     """ 如果key不存在，则创建，如果存在，则返回已存在的值且不修改 """
60     """ D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D """
61     pass
62 
63 
64 def update(self, E=None, **F):  # known special case of dict.update
65     """ 更新
66         {'name':'root', 'age': 18}
67         [('name','admin'),]
68     """
69     """
70     D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.
71     If E present and has a .keys() method, does:     for k in E: D[k] = E[k]
72     If E present and lacks .keys() method, does:     for (k, v) in E: D[k] = v
73     In either case, this is followed by: for k in F: D[k] = F[k]
74     """
75     pass
76 
77 
78 def values(self):  # real signature unknown; restored from __doc__
79     """ 所有的值 """
80     """ D.values() -> list of D's values """
81     return []

字典官方文档

六.集合

定义：由{}括起来，

　　---由不同元素组成；

　　---无序；

　　---元素必须为不可变类型

方法

add()  # 添加，没有不会报错
clear()  #清空
copy()  # 复制
pop()  # 删除，无序，所以随机删除
remove()  # 指定删除，没有会报错
discard()  # 指定删除，没有不会报错

集合运算

 1 交集    &    集合a.intersection(集合b) 
 2 
 3 并集    |    集合a.union(集合b)
 4 
 5 差集    -    集合a.difference(集合b)
 6 
 7 交叉补集    ^    集合a.symmetric_difference(集合b)
 8 
 9 difference_update    求差集并更新原集合，返回值为None ，相当于p_s = p_s - l_s
10 
11 isdisjoint    是否有交集,包含返回False，不包含返回True
12 
13 issubset    是否是另一个集合的子集
14 
15 issuperset    是否是另一个集合的父集
16 
17 update    求并集，并且更新

补充：s = frozenset() --->表示不可变集合

集合官方文档

七.布尔值(bool)

　　记住：0, None, '', (), [], {} 为False，其余为True