从零学习python - 02详细整理python中的数据类型

python的数据类型

数字(Number) 字符串(String) 列表(List) 元组(Tuple) 集合(List) 字典(Dictionary)

---

一、数字：

python3支持int整型, float浮点型, bool布尔型

运算使用and or not

二、字符串：

切片：[开始下标:结束下标:步长]取左不取右 下标可省略

str[:]表示全选

str[-1]最后一个字符

str[-3:]倒数第三个到最后一个字符 [-3:-1]不取最后一个字符

切片[开始下标:结束下标:步长] 字符串会根据步长多少在字符串进行跨步 [::-1] 可以反转整个字符串

下标取值：

字符串中每个字符都有一个下标 小标从0开始从左往右依次递增 name[0] - name[name.length-1]

字符串拼接：

字符串之间使用 “+” 进行拼接 name = "张" + "三"

str.join(x,x,x) 被调用方法的字符被插入到每个给定字符串之间

字符串格式化：

string.format() 在字符串需要添加的位置插入大括号 在format()方法小括号内添加所需要插入的内容

插入的内容与需要插入的位置一一对应。也可以在大括号内加入下标(下标指代小括号内容从0开始)进行字符串的格式化。

            # s1 = "大家好，我是{}，我的年龄是{},我的心情十分{}。".format("otto", "28", "开心")

字符串常用方法：

    find("查找元素",x,y)查找元素下标位置返回第一个元素下标 没有返回-1 
    count("统计元素",x,y)统计字符出现次数 没有返回0
    replace("old","new",从前往后替换次数默认替换全部)替换指定的字符串片段
        s1 = "welcome to zoo"
        res = s1.replace("zoo", "WuHu")
    upper()将字符串字母转换为大写
    lower()将字符串字母转换为小写
    len(str)计算统计字符串的长度，返回长度值
        s1 = "python"
        print(len(s1))
    split("分割符","分割次数")指定分割符对字符串进行分割 (默认值)表示根据任何空白进行分割，并丢弃结果中的空字符串。分割次数默认没有限制。
        # ['一条大河', '波浪宽', '']
        print("一条大河啊波浪宽啊".split("啊"))
        # ['一条大河', '波浪宽啊']
        print("一条大河啊波浪宽啊".split("啊", 1))
        # ['一条大河啊', '波浪宽啊']
        print("一条大河啊 波浪宽啊 ".split())
    strip("str")去除字符串首尾str字符，默认为空去除首尾空格
        s1 = "    社会主义好    "
        print(s1.strip()) # 社会主义好
传统格式化输出和F表达式：
    传统格式化输出：%占位符 %s为字符占位，任意类型都可以，%d为数值型占位，%f为浮点数占位 保留小数点后六位
        s1 = "我%s你，我今年%d岁,身高%f厘米" % ('爱', 18, 188.88)
    F表达式：在字符串前加F或f，字符串中可以直接使用{}里加变量名的方式进行格式化输出
        name = "疼痒天下"
        age = 28
        s1 = f"我的名字是{name}，我今年{age}岁了。"
format的进阶用法：
    格式化小数长度(会四舍五入) :.2f 其中冒号前默认为0 也就是format方法内参数的下标 2代表小数后保留两位
        x = 3.6567
        # 今天橘子3.66元一斤
        s1 = "今天橘子{:.2f}元一斤".format(x)
    将小数按百分比形式显示 :.2% 其中2代表小数点后保留几位小数 代表精度
        x = 3.656788
        # 今日房价同比去年增长365.68%
        s1 = "今日房价同比去年增长{:.2%}".format(x)

三、列表：

列表内支持定义任何类型的数据

定义列表：

变量名 = [数值, 字符串, [空列表]] 中间用逗号隔开

列表的下标、列表的取值：

从0开始，变量名[下标]取值，其中的嵌套列表使用[][]双下标进行取值

list1 = [1, 2, 3, "列表字符串", ["列表的嵌套", 1, 2]]

    # ['列表的嵌套', 1, 2]
    print(list1[4])
    # 1
    print(list1[4][1])

列表的长度与更新列表：

计算列表的长度使用len()方法

    list1 = [1, 2, 3, 4, 5, 6]
    print(len(list1))

列表的更新采用重新赋值方法 list1[0] = newNum

列表的加法与乘法操作：

两个列表相加会将其组合为一个列表返回

    list1 = [6, 5, 4]
    list2 = [1, 2, 3]
    # [6, 5, 4, 1, 2, 3]
    print(list1 + list2)

两个列表相乘会复制原列表所乘倍数添加到原列表后

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

列表的切片取值：

列表的切片取值与字符串切片取值大致相同 list[firstNum:listNum:stepNum] 取左不取右

列表的操作方法：

    del关键字：删除
        del list 删除list列表  del list[下标] 删除列表指定下标的元素
    append(newNum):向列表末尾添加元素
    insert(插入位置，插入对象):向列表内插入元素，可以插入任何数据
    clear():将列表清空
    remove(value):从列表中移除元素，如果有重复元素只移除匹配到的第一个
        list1 = ["我", "爱", "你"]
        list1.remove("爱")
        # ['我', '你']
        print(list1)
    pop(index):移除列表中指定位置的元素并返回，默认情况下移除最后一个元素
        list1 = ["我", "爱", "你"]
        # 爱
        print(list1.pop(1))
        # ['我', '你']
        print(list1)
    index(value,start,end):返回所匹配元素的索引
    reverse():用于将列表反向排序
    extend():在原列表的末尾追加另一个列表数据，与append()的区别在于可以一次性添加多个元素
        list1 = [1, 2, 3]
        list1.extend([10, 20, 30])
        # [1, 2, 3, 10, 20, 30]
        print(list1)
    copy():复制列表 list2 = list1.copy()
    sort():用于列表将同类型数据进行默认升序排序 list.sort()
        通过ascii码:0-9<A-Z<a-z 降序排序可写为list.sort(reverse=True)
    count(value):用于统计某个元素在列表中出现的次数并返回

四、元组：

元组与列表类似，不同之处在于元组的元素不能修改。元组写在小括号里并且用逗号隔开。

元组的创建：

    t = (66, -66, "六十六", 6.66, [1, 2, 3])
    # (66, -66, '六十六', 6.66, [1, 2, 3])
    print(t)

元组的拼接：

两个元组相加，t2会跟在t1后。元组中的列表内的数据是可以更改的。

    t1 = (10, 20, 30)
    t2 = ([1, 2], [3, 4], [5, 6])
    # (10, 20, 30, [1, 2], [3, 4], [5, 6])
    print(t1 + t2)
    -------------------------------------------
    t3 = t1 + t2
    t3[3][1] = "更改元组内列表内数据s"
    # (10, 20, 30, [1, '更改元组内列表内数据s'], [3, 4], [5, 6])
    print(t3)

关于元组、列表、字符串的一些共同操作：

len()长度 max()最大值 min()最小值

使用方法：
a = (1, 2, 3, 4)
print(len(a)) # 4
print(max(a)) # 4
print(min(a)) # 1

b = [1, 2, 3, 4]
print(len(b)) # 4
print(max(b)) # 4
print(min(b)) # 1

c = "123456789abc"
print(len(c)) #12
print(max(c)) #c
print(min(c)) #1

元组注意事项：

如果元组内只有一条数据，则要在这个数据后面加逗号，否则这唯一的数据并不是以元组形式存储。

5、集合：

集合是无序的，集合中的元素是唯一的。一般用于元组或者列表中的元素去重。

集合的创建：

变量名 = set(元素) 字符串、列表、元组、字典 - 但是元素类型唯一

s = set("123")
# {'3', '2', '1'} 运行结果无序
print(s)

变量名 = {元素, ..., 元素} 元组、字符串、字典 - 元素类型可不唯一

b = {123, "123"}
# {'123', 123}  运行结果无序
print(b)

元素是唯一的，用于列表的去重。用大括号存储。

列表的去重：

list1 = [1, 1, 2, 2, 3, 3, 4, 4, 5, 5]
s = set(list1)
# {1, 2, 3, 4, 5}
print(s)

元组的去重：

t1 = (1, 1, 2, 2, 3, 3, 4, 4, 5, 5)
s = set(t1)
# {1, 2, 3, 4, 5}
print(s)

字符串也可以进行去重，这里就不演示了。

字典也可以针对key进行去重，这里就不演示了。

集合常用的方法：

    add():集合添加元素 -> 数字、字符串、元组
        格式：set.add(value)
    update():可以将集合进行合并
        a = {1, 2, 3}
        b = {'a', 'b', 'c'}
        a.update(b)
        # {1, 2, 3, 'c', 'a', 'b'} 这里b不会发生变化
        print(a)
    remove(value):如果有要删除的元素则直接删除，如果没有则报错
    pop():随机删除集合中的元素，如果集合为空则报错
    discard(value):如果元素存在则直接删除，如果没有则不做操作
集合的交集和并集：
        a = {1, 2, 3}
        b = {'a', 'b', 'c'}
    交集∩：使用&符号连接多个集合，得到相同的元素
        c = a & b
        # set()
        print(c)
    并集∪：使用|符号连接多个集合，得到集合中全部元素
        d = a | b
        # {1, 2, 3, 'a', 'b', 'c'}
        print(d)

6、字典：

key-value键值对，是一种映射类型，关键字必须为不可变类型（元组、字符串、数字）且不能重复

创建字典：

直接创建：

d1 = {
    "令狐冲": "令狐冲",
    123: 123,
    (4, 5, 6): 456
}
# {'令狐冲': '令狐冲', 123: 123, (4, 5, 6): 456}
print(d1)

dict创建：dict(元组(中存列表[的形式存储],[存储...]))

d2 = dict((["摸着天", "杜迁"], ["小李广", "花荣"], [123, 123], [(4, 5, 6), 456]))
# {'摸着天': '杜迁', '小李广': '花荣', 123: 123, (4, 5, 6): 456}
print(d2)

空字典：

d = {} 这里直接写大括号代表空字典

s = set() 这样写代表空集合

字典的常用操作：

增加：d[key] = value
删除：del d[key]
修改：d[key] = new value
查找：print(d[key])
get(key,默认值):从字典中获取指定key的value并返回。可设置默认值，如果没有找到对应key便返回默认值。
keys():返回字典中所有key。
items():以列表的形式返回字典中所有键值对
values():以列表的形式返回字典中所有值
clear():清空字典 d.clear()
copy():复制字典创建副本 d2 = d1.copy()
fromkeys(序列,数据):调用后返回一个新的字典
    第一个参数：序列为列表、元组、集合 作为key使用
    第二个参数：数据可以为任意类型，作为每个key的value
        d2 = d1.fromkeys(["name", "age"], ["otto", 18])
        # {'name': ['otto', 18], 'age': ['otto', 18]}
        print(d2)
pop():从字典中移除指定key，并返回对应key的value
popitem():从字典中删除最后一项，以元组形式返回该项对应的键值对
    r = d.popitem()
setdefault():用于设置key的默认值，若该key已存在则忽略设置，不存在则添加该键值对
    d.setdefault(key,value)
update():将字典dy的值更新到字典x，如果y中的值已存在则对dx进行覆盖，不存在则添加
    dx.update(dy)

---

python的数据格式与java有很多相似的地方，比如字典和hashmap。各数据类型的常用方法都总结到上方了，慢慢理解融会贯通就好了，没必要去死记硬背。