Python 基本数据类型

使用字符串

- 

def main():

    str1 = "hello, world!"
    # 通过len函数计算字符串的长度
    print(len(str1))
    # 字符串首字母大写
    print(str1.capitalize())
    # 字符串全部转换大写
    print(str1.upper())
    # 从字符串中查找子串所在位置
    print(str1.find("or"))
    print(str1.find("shit"))
    # index与find类似，但是找不到子串会抛出异常
    print(str1.index("or"))
    # print(str1.index("shit"))
    # 检查字符串是否以指定的字符串开头
    print(str1.startswith("He"))
    print(str1.startswith("hell"))
    # 检查字符串是否以指定的字符串结尾
    print(str1.endswith("!"))
    # 将字符串以指定的宽度居中并在两侧填充指定的字符
    print(str1.center(50,"*"))
    # 将字符串以指定的宽度靠右放置左侧填充指定的字符
    print(str1.rjust(50,"*"))

    str2 = "abc123456"
    # 从字符串中取出指定位置的字符（下标运算）
    print(str2[2]) #c
    # 字符串切片（从指定的开始索引到指定的结束索引）
    print(str2[2:5]) #c12
    print(str2[2:]) #c123456
    print(str2[2::2])#c246
    print(str2[::2])#ac246
    print(str2[::-1])#654321cba
    print(str2[-3:-1])#45
    # 检查字符串是否由数字组成
    print(str2.isdigit())
    # 检查字符串是否由字符组成
    print(str2.isalpha())
    # 检查字符串是否以数字和字母构成
    print(str2.isalnum())

    str3 = "    jackfrued@126.com"
    print(str3)
    # 去除字符串左右两侧空白
    print(str2.strip())

if __name__ == '__main__':
    main()

 

使用列表

切片：

def main():
    fruits = ["grape","apple","strawberry","waxberry"]
    for fruit in fruits:
        print(fruit.title(),end="")
    print(fruit)

    # 列表切片
    fruit2 = fruits[1:4]
    print(fruit2)
    #fruit3 = fruits # 没有复制列表只创建了新的索引
    # 可以通过完整切片操作来复制列表
    fruit3 = fruits[:]
    print(fruit3)
    fruit4 = fruits[-3:-1]
    print(fruit4)
    # 可以通过反向切片操作来获得倒转后的列表的拷贝
    fruit5 = fruits[::-1]
    print(fruit5)

if __name__ == '__main__':
    main()

# 对列表的排序操作

def main():

    list1 = ["orange","apple","zoo","internationalization","blueberry"]
    list2 = sorted(list1)
    # sorted 函数返回列表排序后的拷贝，不会修改传入的列表
    list3 = sorted(list1,reverse=True)
    # 通过key关键字参数指定根据字符串长度进行排序而不是默认的字母表顺序
    list4 = sorted(list1,key=len)
    print(list1)
    print(list2)
    print(list3)
    print(list4)
    # 给对象列表发出排序消息直接在列表对象上进行排序
    list1.sort(reverse=True)
    print(list1)

if __name__ == '__main__':
    main()

 

# 使用列表生成式创建列表

import sys

def main():
    f = [x for x in range(1,10)]
    print(f)
    f = [x + y for x in "ABCD" for y in "1234567"]
    print(f)
    # 用列表的生成表达式语法创建容器
    # 用这种语法创建列表之后元素已经准备就绪，所以需要耗费较多的内存空间
    f = [x ** 2 for x in range(1,1000)]
    print(sys.getsizeof(f)) # 查看对象占用内存的字节数
    print(f)
    # 请注意下面的代码创建的不是一个列表而是一个生成器对象
    # 通过生成器可以获取到数据，但它不占用额外的空间存储数据
    # 每次需要数据的时候就通过内部的运算得到数据（需要花费额外的时间）
    f = (x ** 2 for x in range(1,1000))
    print(sys.getsizeof(f)) # 相比生成式，生成器不占用存储数据的空间
    print(f)
    for val in f:
        print(val)

if __name__ == '__main__':
    main()

 

使用元祖

# python的元组与列表类似，不同之处在于元组的元素不能修改

def main():
    # 定义元组
    t = ("陈掌柜","38",True,"四川成都")
    print(t)
    # 获取元组中的元素
    print(t[0])
    print(t[3])
    # 遍历元祖中的值
    for member in t:
        print(member)
    # 重新给元祖赋值
    # t[0] = "王大锤"  TypeError: 'tuple' object does not support item assignment
    # 变量t重新引用了新的元祖，原来的元祖将被垃圾回收
    t = ("王大锤","20",True,"云南昆明")
    print(t)
    # 将元祖转换成列表
    person = list(t)
    print(person)
    # 列表时候可以修改它的元素的
    person[0] = "王麻子"
    person[1] = 25
    print(person)
    # 将列表转换成元组
    fruits_list = ["apple","banana","orange"]
    fruits_tuple = tuple(fruits_list)
    print(fruits_tuple)

if __name__ == '__main__':
    main()

 

使用集合

# 集合不允许有重复元素，可以进行交集、并集、差集等运算

def main():

    set1 = {1,2,3,3,3,2}
    print(set1)
    print("length =",len(set1))
    set2 = set(range(1,10))
    print(set2)
    set1.add(4)
    set1.add(5)
    set2.update([11,12])
    print(set1)
    print(set2)
    set2.discard(5)
    print(set2)
    # remove 的元素如果不存在会引发KeyError
    if 4 in set2:
        set2.remove(4)
    print(set2)
    # 遍历集合容器
    for elem in set2:
        print(elem ** 2 ,end=" ")
    print()
    # 将元组转换成集合
    set3 = set((1,2,3,3,2,1))
    print(set3.pop())
    print(set3)
    # 集合的交集、并集、差集、对称差运算
    print(set1 & set2)
    print(set1 | set2)
    print(set1 - set2)
    print(set1 ^ set2)
    # 判断子集和超集
    print(set2 <= set1)
    print(set3 <= set1)
    print(set1 >= set2)
    print(set1 >= set3)

if __name__ == '__main__':
    main()

 

使用字典

# 可以存储任意类型的对象，与列表、集合不同的是：字典的没个元素都是由一个键和一个值组成的"键值对"，键和值通过冒号分开

def main():

    scores = {"陈掌柜":70,"jay":80,"kobe":95}
    #通过键可以获取字典中对应的值
    print(scores["kobe"])
    print(scores["jay"])
    # 对字典进行遍历(遍历的其实是键，再通过键取对应的值)
    for elem in scores:
        print("%s\t--->\t%d" %(elem,scores[elem]))
    # 更新字典中的元素
    scores["kobe"] = 65
    scores["rose"] = 100
    print(scores)
    # 使用update方法: 将dict2添加到指定字典dict字典里
    dict = {"name":"alex","age":90}
    dic2 = {"sex":"man"}
    dict.update(dic2)
    print("value : %s" % dict)
    if "kobe" in scores:
        print(scores["kobe"])
    print(scores.get("kobe"))
    # get方法也是通过键获取对应的值，但是可以设置默认值
    print(scores.get("kobe",60))
    # 删除字典中的元素
    print(scores.popitem()) # 默认从末尾开始弹出
    print(scores.popitem())
    print(scores.pop("陈掌柜"))
    print(scores)
    # 清空字典
    scores.clear()
    print(scores)
    
if __name__ == '__main__':
    main()

 

小结：

按存储空间的占用分（从低到高）:
数字
字符串
集合：无序，即无序存索引相关信息
元组：有序，需要存索引相关信息，不可变
列表：有序，需要存索引相关信息，可变，需要处理数据的增删改
字典：无序，需要存key与value映射的相关信息，可变，需要处理数据的增删改

按可变不可变区分：
1、可变类型：在id不变的情况下，value可以变，则称为可变类型，如列表，字典
2、不可变类型：value一旦改变，id也改变，则称为不可变类型（id变，意味着创建了新的内存空间）

进制：
1个二进制位是计算机里的最小表示单元
1个字节是计算机里最小的存储单位
二进制位=bit = 8bits
8bits = 1Byte = 1字节
1024Bytes = 1KB = 1KB
1024KB = 1MB = 100万字节 = 100万字符 = 1兆
1024MB = 1GB = 一部高清电影短片， 1080p 20分钟，
1024GB= 1TB
1024TB = 1PB