python基本数据类型操作

赋值：a="张三"

拼接：a  = "张三"
b = a+"李四"

截取：name = "ZhangSan"
print(name[0:-1])  # 输出第一个至倒数第二个的字符，截取时顾头不顾尾，输出：ZhangSa
print(name[0])     # 输出第一个字符，输出：Z
print(name[-1])    # 输出最后一个字符，输出：n
print(name[2:])    # 输出从第三个开始之后的所有字符，输出：angSan
print(name[0:-1:2])# 输出第一个至倒数第二个的字符，步长为2，输出：Zaga
print(name[8])     # 若字符不存在，则会抛出IndexError: string index out of range

概念：不带小数点的数字

操作

概念：带小数点的数字

操作

概念：带数字表达式

操作

概念：判断真和假，True = 1  False = 0

操作

创建
d0 = {}  # 创建空字典
d1 = {"张珊":100,"李思":120,"王武":110} # 使用花括号创建字典
d2 = dict(name="李尔",weight=116)  # 调用内置函数dict()创建，通常用于转换为字典时使用

获取
print(d1["李思"])   # 使用中括号根据Key获取Value值，输出：120
print(d1["张三"])   # 若Key不存在，则抛出KeyError: '张三'

# ↓还可以使用get()方法取值，此方式若Key不存在则返回None，不会抛出KeyError异常，还可以设置默认Value
print(d1.get("张珊")) # 使用get()方法取值，输出：100
print(d1.get("王武",98)) # 若对应Key不存在则输出默认值，否则输出对应的Value值，此处输出：110

# ↓使用keys()方法获取所有Key
print(d1.keys())   # 获取字典中所有的Key，输出：dict_keys(['张珊', '李思', '王武'])
print(list(d1.keys()))  # 获取字典中所有的Key并转为列表，输出：['张珊', '李思', '王武']
print(tuple(d1.keys()))  # 获取字典中所有的Key并转为元组，输出：('张珊', '李思', '王武')

# ↓使用values()方法获取所有Value值
print(d1.values())   # 获取字典中所有的Value值，输出：dict_values([100, 120, 110])
print(list(d1.values()))    # 获取字典中所有的Value值并转为列表，输出：[100, 120, 110]
print(tuple(d1.values()))   # 获取字典中所有的Value值并转为元组，输出：(100, 120, 110)

# ↓使用items()方法获取所有的键值对
print(d1.items())   # 获取字典中所有的Key:Value，输出：dict_items([('张珊', 100), ('李思', 120), ('王武', 110)])
print(list(d1.items()))  # 获取字典中所有的Key:Value并转为列表，输出：[('张珊', 100), ('李思', 120), ('王武', 110)]
print(tuple(d1.items()))    # 获取字典中所有的Key:Value并转为元组，输出：(('张珊', 100), ('李思', 120), ('王武', 110))

for item in d1:  # 使用for循环遍历字典中的元素
    print(item)  # 返回字典中所有的Key

判断是否存在
print("李思" in d1) # 判断d1字典中存在Key"李思"，输出：True
print("王武" not in d1) # 判断d1字典中不存在Key"王武"，输出：False

增删改
d1["李思"] = 118  # 若Key存在，则修改对应的Value值，原李思对应的value值变为118
d1["张三"] = 106  # 若Key不存在，则新增键值对，字典中新增'张三': 106
d1.pop("张三")  # 删除Key为“张三”的键值对
d1.pop("张凤")  # 必须传入一个Key，若Key不存在，则抛出KeyError: '张凤'
del d1["张三"]  # 同样也是删除Key为“张三”的键值对
d1.clear()   # 清空字典
del d1   # 删除字典

创建
l0 = [] # 创建空列表
l1 = ["张三",'lisi',12,["22","lisi","王武"],"赵柳"]  # 直接使用中括号创建列表
l2 = list(['lisi',12,("22","王武"),"赵柳"])    # 或者调用内置函数list()，通常用于转换为列表时使用

获取元素（查）
print(l1[1])        # 获取列表l1中第二个元素，输出：lisi
print(l1[0:2])      # 获取列表l1中第一个和第二个元素，输出：['张三', 'lisi']
print(l1[-5:-2])    # 获取列表l1中第一个至倒数第三个数据，反向索引，输出：['张三', 'lisi', 12]
print(l1[2:-1])     # 获取列表l1中第三个至倒数第二个元素，输出：[12, ['22', 'lisi', '王武']]
print(l1[1::2])     # 获取列表l1中第二个至最后一个元素，步长为2，输出：['lisi', ['22', 'lisi', '王武']]
print(l1[:1:-2])    # 反向获取列表l1中元素，步长为-2，输出：['赵柳', 12]
print(l1[::-1])     # 步长为-1时表示倒序排列元素，输出：['赵柳', ['22', 'lisi', '王武'], 12, 'lisi', '张三']
print(l1[3][0])     # 获取l1嵌套列表(即第四个元素)中的第一个元素，输出：22
print(l1[3][-1])    # 获取l1嵌套列表(即第四个元素)中的最后一个元素，输出：王武
print(l1[5])  # 若元素不存在，则会抛出IndexError: list index out of range

判断是否存在某个元素
print("lisi" in l1)     # 判断l1列表中包含“lisi”，输出：True
print("赵柳" not in l1)  # 判断l1列表中不包含“赵柳”，输出：False
print("22" in l1[3])    # 判断l1嵌套列表中包含“22”，输出：True
print("王武" not in l1)  # 判断l1列表中不包含“王武”，输出：True

修改
l1[1]="李思"       # 将l1列表中第二个元素改为李思
l1[3][0] = 22       # l1嵌套列表中的第一个元素改为22
l1[1:3]= ["张珊","李思"]  # 将l1列表中第二个和第三个值改为张珊和李思

增加

删除
l1.remove("张珊")  # 删除指定元素，一次只能删除一个元素，若出现重复元素则只删除第一个
l1.remove("菡菡")  # 若元素不存在，则抛出ValueError: list.remove(x): x not in list
l1.pop(1)   # 删除指定索引位置上的元素，若不指定索引则默认删除最后一个元素
l1.pop(8)   # 若索引不存在，则抛出IndexError: pop index out of range
l1.clear()   # 清空l1列表
del l1   # 删除l1列表

初始化
t0 = ()  # 创建空元组
t1 = ("张珊","lisi",["李思",12,"Python"],("王武","22"))# 直接使用小括号创建元组
t2 = (1,)         # 当元组只有一个元素时需要在后面加上逗号
t3 = tuple(("依儿",22,"Java"))   # 或者调用内置函数tuple()，通常用于转换为元组时使用

获取元素（查）
print(t1[1])        # 获取元组t1中第二个元素，输出：lisi
print(t1[0:2])      # 获取元组t1中第一个和第二个元素，输出：('张珊', 'lisi')
print(t1[2:-1])     # 获取元组t1中第三个至倒数第二个元素，输出：(['李思', 12, 'Python'],)
print(t1[1::2])     # 获取元组t1中第二个至最后一个元素，步长为2，输出：('lisi', ('王武', '22'))
print(t1[::-1])     # 步长为-1时表示倒序排列，输出：(('王武', '22'), ['李思', 12, 'Python'], 'lisi', '张珊')
print(t1[2][0:-1])  # 获取元组t1中第三个元素中的第一个至倒数第二个元素，输出：['李思', 12]

for i in t1:  # 使用for循环遍历元组中的元素
    print(i)  # 遍历元素后的操作，比如输出结果

修改可变对象的值
# 修改元组t1中列表中的元素
t1[2][1] = "十"      # 将12改为10
t1[2].remove("Python")  # 删除Python元素
t1[2].pop()             # 删除最后一个元素
t1[2].clear()      # 清空列表
t1[2].append("啊哈")    # 添加一个元素
# 拼接元组
print(t2+t3)      # 输出：('1', '依儿', 22, 'Java')

初始化
s0 = set()        # 创建空集合，不能直接使用花括号，花括号默认是创建字典
s1 = {"李思","张珊","李思","王武"} # 花括号中元素非键值对时，创建的是集合
s2 = set("李尔")   # 调用内部函数set()创建，通常用于转换为集合时使用

获取（查）
# ↓若集合中存在相同的元素，只会出现输出一个，因为集合是无序的，所以每次输出结果顺序可能不一致
print(s1)          # 获取集合s1中所有的元素，输出：{'李思', '王武', '张珊'} 
for i in s1: # 通过for循环获取集合中的元素
    print(i) # 同样重复元素只返回一个
# ↓集合中的某一个元素是不能直接获取的，可以先转换为列表，然后使用列表方式获取元素
ls = list(s1) # 将集合s1转换为列表
print(ls[1])       # 获取列表l1中第二个元素，输出：李思
print(ls[0:2])     # 获取列表l1中第一个和第二个元素，输出：['王武', '李思']
……

判断是否存在
print("李思" in s1) # 判断s1集合中存在"李思"，输出：True
print("王武" not in s1) # 判断s1集合中不存在"王武"，输出：False

添加和更新
s1.add("赵柳")  # 添加一个元素，因为集合是无序的，所以元素位置随机
# update也可以理解为新增，当存在相同元素时，相同元素会被覆盖，不同元素会新增到集合中
s1.update("张三")          # 集合中会添加两个元素，‘张’、‘三’
s1.update("张三丰")        # 集合中会更新两个元素，‘张’和‘三’，新增一个元素‘丰’

删除
s1.remove("李思")  # 删除s1集合中的元素“李思”，若元素不存在，则抛出KeyError: '李思'
s1.discard("张三")  # 删除s1集合中的元素“张三”，若元素不存在，不会抛出任何异常
s1.pop()  # 随机删除任意一个元素
s1.clear()  # 清空集合中的元素
del s1  # 删除集合

判断是否相等
print(s1 == s2) # 输出：False
print(s1 != s2) # 输出：True

判断两个集合的关系
s3 = {"李思","张珊","李思","王武","Andy"}
s4 = {"李四","张珊","张三","王武"}
s5 = {"Andy"}

# ↓当s5中所有的元素s3里都有，但s5中的元素s3中未必有，则s3就是s5的超级，反之s5就是s3子集
print(s3.issuperset(s5)) # 判断s3是否是s5的超集，输出：True，因为s3中有s5所有的元素
print(s5.issubset(s3)) # 判断s5是否是s3的子集，输出：True，因为s5中的所有元素s3中都有
print(s3.isdisjoint(s4)) # 判断s3和s4两个集合是否没有交集，输出：False，因为两个集合中都有"张珊"和"王武"，存在交集

print(s3.intersection(s4)) # 输出s3和s4交集(即二者都有)的元素，输出：{'张珊', '王武'}
print(s3 & s4)  # 与intersection()等价，交集的一种符号表示法

print(s3.union(s4)) # 输出s3和s4并集(即去掉二者都有)的元素，输出：{'李思', '张三', '王武', '李四', '张珊', 'Andy'}
print(s3 | s4)  # 与union()等价，并集的一种符号表示法

print(s3.difference(s4)) # 输出s3和s4差集(即所有属于s3但不属于s4)的元素，输出：{'Andy', '李思'}
print(s3 - s4)  # 与union()等价，差集的一种符号表示法

print(s3.symmetric_difference(s4)) # 输出s3和s4对称差集(即s3中不属于s4和s4中不属于s3)的元素，输出：{'Andy', '李思', '李四', '张三'}
print(s3 ^ s4)   # 与symmetric_difference()等价，对称差集的一种符号表示法