1.3-python基础数据类型
目录
python基础数据类型
1. 什么是数据类型
Python中常用的数据类型如下：
- int 数字，主要用于运算；
- bool 布尔，判断真假：True，False；
- str 字符串，简单少量的存储数据，并进行相应的操作；
- tuple 元组，只读不能更改；
- list 列表，大量有序数据；
- dict 字典，大量数据，且是关联性比较强的数据；
2. 基础数据类型
2.1 数字 int
主要用于算数运算。
将十进制转化成二进制
print(bin(100))
# 0b1100100
将二进制转化成十进制
print(int("1100100",2))
# 100
2.2 布尔值bool
布尔值就两种：True，False，反应条件的是与否
真 1 True，假 0 False
# int str bool 三者数据类型之间的转换
# int --> book
i = 100
print(bool(i)) # True 非零即为True
l = 0
print(bool(l)) # False 零即为False
# book --> int
x = True
print(int(x)) # 1
y = False
print(int(y)) # 0
# int --> str
i = 100
print(str(i),type(str(i))) # 100 <class 'str'>
# str --> int
l = "100"
print(int(l),type(int(l))) # 100 <class 'int'>
# str --> bool
s = '黑色利穆'
z = ''
print(bool(s)) # True # 非空即为True
print(bool(z)) # False
# bool --> str
t = True
print(bool(t)) # True
2.3 字符串 str
python中引号引起来的都可以称为字符串类型，组成字符串的每个元素称为字符，将这些字符一个个连接起来然后引号引起来就是字符串。
s = '黑色利穆'
对于s这个字符串来说，它由四个字符组成：黑 色 利 穆
2.3.1 字符串的索引与切片
组成字符串的字符从左向右，依次排列（0,1,2,3,.....)
索引即下标，就是字符串组成的元素从第一个开始，初始索引位0，以此类推；
s = "ABCDEFGHIJK"
print(s[0])
print(s[1])
print(s[3])
print(s[5])
print(s[6])
切片就是通过索引（索引:索引:步长）截取字符串的一段，形成新的字符串（顾头不顾尾）：
s = "ABCDEFGHIJK"
print(s[0:3])
print(s[:3]) # 0开始可以默认不写
print(s[3:4])
print(s[:]) # 默认到最后
print(s[:-1]) # -1 列表中最后元素的索引，但是满足顾头不顾尾，所以取不到最后一位元素
print(s[:7:2]) # 设置步长为2
print(s[-1:-5:-2]) # 反向步长
2.3.2 字符串常用方法
# 字符串中元素出现的个数
a = "aaabbbcccabcabcabc"
ret = a.count("a", 0, -1) # 可切片
print(ret)
# startswith 判断是否以...开头
# endswith 判断是否以...结尾
a = 'abcfdef'
ret = a.endswith('f', 1, 4) # 顾头不顾尾
print(ret) # True
ret2 = a.startswith('c', 2, 6)
print(ret2) # True
# split 以...分割，最终形成一个列表，此列表不含有这个分割的元素
s = "heiselimu,heisenaiyou,heiseqiaokeli"
print(s.split('i'))
# ['he', 'sel', 'mu,he', 'sena', 'you,he', 'seq', 'aokel', '']
print(s.split('i', 2))
# ['he', 'sel', 'mu,heisenaiyou,heiseqiaokeli']
# format的三种，格式化输出
msg = '{} {} {}'.format('黑色利穆', 25, 'OPS')
print(msg) # 黑色利穆 25 OPS
msg = '{1} {0} {1}'.format('黑色利穆', 25, 'OPS')
print(msg) # 25 黑色利穆 25
msg = '{name} {age} {job}'.format(name='黑色利穆', age=25, job='OPS')
print(msg) # 黑色利穆 25 OPS
# strip 脱
name = '***黑色利穆***'
print(name.strip('*')) # 黑色利穆
print(name.lstrip('*')) # 黑色利穆***
print(name.rstrip('*')) # ***黑色利穆
# replace 替换
name = '黑色利穆是世界上最帅的男人，世界上'
print(name.replace('世界', '地球', 1))
# 黑色利穆是地球上最帅的男人，世界上
print(name.replace('世界', '地球', 2))
# 黑色利穆是地球上最帅的男人，地球上
# is系列
name = '黑色利穆123a'
print(name.isalnum()) # True 字符串由字母数字组成
print(name.isalpha()) # False 字符串只由字母组成
print(name.isdecimal()) # False 字符串只由十进制组成
# find index 寻找字符串中元素是否存在
s = '我就是黑色的黑色利穆'
print(s.find('黑', 0, 5)) # 找到返回元素索引，找不到返回 -1
print(s.index('黑', 5, 8)) # 找到返回元素索引，找不到报错
# captalize， swapcase， title
name = "heiselimu"
print(name.capitalize()) # Heiselimu 首字母大写
name = "HeiSeLiMu"
print(name.swapcase()) # hEIsElImU 大小写反转
name = "hei se li mu"
print(name.title()) # Hei Se Li Mu 每个单词的首字母大写
# 内同居中，空白处填充
s = "黑色利穆"
print(s.center(20, "-"))
# --------黑色利穆--------
2.4 列表list
列表属于容器类的数据类型，可以承载多种数据类型（字符串，数字，布尔值，列表，集合，元组，字典），可以储存大量数据；
列表是有序的，有索引值，可切片
不管什么类型进行切片的时候获取到的都是源数据类型；
2.4.1 列表的创建
三种方式
# 直接创建
l1 = [1, 2, '黑色利穆']
# 空列表，迭代对象迭代如列表
l1 = list('黑色利穆')
print(l1) # ['黑', '色', '利', '穆']
# 列表推导式
l1 = [i for i in range(1,5)]
print(l1) # [1, 2, 3, 4]
2.4.2 列表的索引切片
l1 = ['黑色利穆', 1, 123, 'abc', 'ccc']
print(l1[0]) # 黑色利穆
print(l1[-1]) # ccc
print(l1[1:3]) # [1, 123]
print(l1[:-1]) # ['黑色利穆', 1, 123, 'abc']
print(l1[::2]) # ['黑色利穆', 123, 'ccc']
print(l1[::-1]) # ['ccc', 'abc', 123, 1, '黑色利穆']
练习
'''
li = [1, 3, 2, "a", 4, "b", 5,"c"]
通过对li列表的切片形成新的列表l1,l1 = [1,3,2]
通过对li列表的切片形成新的列表l2,l2 = ["a",4,"b"]
通过对li列表的切片形成新的列表l3,l3 = [3,"a","b"]
通过对li列表的切片形成新的列表l4,l4 = ["b","a",3]
'''
li = [1, 3, 2, "a", 4, "b", 5,"c"]
l1 = li[:3]
print(l1)
l2 = li[3:6]
print(l2)
l3 = li[1:-1:2]
print(l3)
l4 = li[-3:-8:-2]
print(l4)
2.4.3 增
# append 追加，给列表的最后追加一个元素
l = [1, 2, 'a']
l.append(777)
print(l) # [1, 2, 'a', 777]
# insert 插入，列表的任意位置插入元素
l.insert(1, '黑色利穆')
print(l) # [1, '黑色利穆', 2, 'a', 777]
# extend 迭代着追加，在列表的最后面迭代追加一组数据
l.extend('小明')
print(l) # [1, '黑色利穆', 2, 'a', 777, '小', '明']
2.4.4 删
# pop 通过索引删除列表中对应的元素，返回值位删除的元素
l = [1, '黑色利穆', 2, 'a', 777, '小', '明']
ret = l.pop(1)
print(ret) # 黑色利穆
# remove 通过元素删除列表中该元素
l.remove(777)
print(l) # [1, 2, 'a', '小', '明']
# clear 清空列表
l.clear()
print(l) # []
# del 按照索引删除该元素
l = [1, '黑色利穆', 2, 'a', 777, '小', '明']
del l[2]
print(l) # [1, '黑色利穆', 'a', 777, '小', '明']
# 切片删除该元素
l = [1, '黑色利穆', 2, 'a', 777, '小', '明']
del l[2:]
print(l) # [1, '黑色利穆']
# 切片（步长）删除该元素
l = [1, '黑色利穆', 2, 'a', 777, '小', '明']
del l[::2]
print(l) # ['黑色利穆', 'a', '小']
2.4.5 改
# 按照索引改值
l = [1, '黑色利穆', 2, 'a', 777, '小', '明']
l[0] = 'abcd'
print(l) # ['abcd', '黑色利穆', 2, 'a', 777, '小', '明']
# 按照切片改值（迭代增加）
l = [1, '黑色利穆', 2, 'a', 777, '小', '明']
l[1:3] = 'ab'
print(l) # [1, 'a', 'b', 'a', 777, '小', '明']
# 按照切片（步长）改值，必须一一对应
l = [1, '黑色利穆', 2, 'a', 777, '小', '明']
l[::2] = "一一对应"
print(l) # ['一', '黑色利穆', '一', 'a', '对', '小', '应']
2.4.6 查
切片查，循环查
2.4.7 其他操作
# count （统计元素在列表中出现的次数）
a = ["a", "b", "c", "a", "a", "c", "c"]
print(a.count("a"))
# index （从列表中找出某个值第一个匹配项的索引位置）
print(a.index("c"))
# sort（在原位置对列表进行排序）
# reverse（将列表中元素反向存放）
a = [1, 3, 123, 7, 191, 98, 13]
a.sort()
print(a) # [1, 3, 7, 13, 98, 123, 191]
a.reverse()
print(a) # [191, 123, 98, 13, 7, 3, 1]
# 列表也可以相加与整数相乘
l1 = [1, 2, 3]
l2 = [4, 5, 6]
print(l1 + l2) # [1, 2, 3, 4, 5, 6]
print(l1 * 3) # [1, 2, 3, 1, 2, 3, 1, 2, 3]
2.4.8 列表的嵌套
'''
l1 = [1, 2, 'hello', [3, 4, '黑色利穆']]
1, 将l1中的'hello'变成大写并放回原处。
2，给小列表[3, 4, '黑色利穆']追加一个元素,'nb'。
3，将列表中的'黑色利穆'通过字符串拼接的方式在列表中变成'黑色利穆最厉害'
'''
l1 = [1, 2, 'hello', [3, 4, '黑色利穆']]
l1[2] = l1[2].upper()
print(l1)
# [1, 2, 'HELLO', [3, 4, '黑色利穆']]
l1[-1].append('nb')
print(l1)
# [1, 2, 'HELLO', [3, 4, '黑色利穆', 'nb']]
l1[-1][-2] = l1[-1][-2] + '最厉害'
print(l1)
# [1, 2, 'HELLO', [3, 4, '黑色利穆最厉害', 'nb']]
2.4.9 练习
'''
li = ["xiaoming", "zhangsan", "lisi", "heiselimu", "marry"]
计算列表的长度并输出
列表中追加元素"seven",并输出添加后的列表
请在列表的第1个位置插入元素"Tony",并输出添加后的列表
请修改列表第2个位置的元素为"Kelly",并输出修改后的列表
请将列表l2=[1,"a",3,4,"heart"]的每一个元素添加到列表li中，一行代码实现，不允许循环添加。
请将字符串s = "abcd"的每一个元素添加到列表li中，一行代码实现，不允许循环添加。
请删除列表中的元素"lisi",并输出删除后的列表
请删除列表中的第2个元素，并输出删除的元素和删除元素后的列表
请删除列表中的第2至4个元素，并输出删除元素后的列表
'''
li = ["xiaoming", "zhangsan", "lisi", "heiselimu", "marry"]
print(len(li)) # 5
li.append('seven')
print(li) # ['xiaoming', 'zhangsan', 'lisi', 'heiselimu', 'marry', 'seven']
li.insert(1, "Tony")
print(li) # ['xiaoming', 'Tony', 'zhangsan', 'lisi', 'heiselimu', 'marry', 'seven']
li[2] = 'Kelly'
print(li) # ['xiaoming', 'Tony', 'Kelly', 'lisi', 'heiselimu', 'marry', 'seven']
l2 = [1, "a", 3, 4, "heart"]
print(li + l2)
# ['xiaoming', 'Tony', 'Kelly', 'lisi', 'heiselimu', 'marry', 'seven', 1, 'a', 3, 4, 'heart']
s = "abcd"
print(li + list(s))
# ['xiaoming', 'Tony', 'Kelly', 'lisi', 'heiselimu', 'marry', 'seven', 'a', 'b', 'c', 'd']
li.remove('lisi')
print(li) # ['xiaoming', 'Tony', 'Kelly', 'heiselimu', 'marry', 'seven']
ret = li.pop(2)
print("删除的元素:",ret, "删除后的列表:", li)
# 删除的元素: Kelly 删除后的列表: ['xiaoming', 'Tony', 'heiselimu', 'marry', 'seven']
del li[2:4]
print(li) # ['xiaoming', 'Tony', 'seven']
'''
相应练习题
lis = [2, 3, "k", ["qwe", 20, ["k1", ["tt", 3, "1"]], 89], "ab", "adv"]
将列表lis中的"tt"变成大写（用两种方式）。
将列表中的数字3变成字符串"100"（用两种方式）。
将列表中的字符串"1"变成数字101（用两种方式）。
'''
lis = [2, 3, "k", ["qwe", 20, ["k1", ["tt", 3, "1"]], 89], "ab", "adv"]
# 方法一
lis[-3][-2][-1][0] = lis[-3][-2][-1][0].upper()
print(lis)
# [2, 3, 'k', ['qwe', 20, ['k1', ['TT', 3, '1']], 89], 'ab', 'adv']
# 方法二
lis[3][2][1][0] = lis[3][2][1][0].upper()
print(lis)
# 方法一
lis[1] = "100"
lis[3][2][1][1] = "100"
print(lis)
# [2, '100', 'k', ['qwe', 20, ['k1', ['TT', '100', '1']], 89], 'ab', 'adv']
# 方法二
lis[-5] = "100"
lis[-3][-2][-1][-2] = "100"
print(lis)
# 方法一
lis[3][2][1][2] = 101
print(lis)
# [2, '100', 'k', ['qwe', 20, ['k1', ['TT', '100', 101]], 89], 'ab', 'adv']
# 方法二
lis[-3][-2][-1][-1] = 101
print(lis)
2.4.10 用途
列表用途：
需要存储大量的数据，且需要这些数据有序的时候；
制定一些特殊的数据群体：按顺序，按规则，自定制数据。
2.5 tuple 元组
对于容器型数据类型list，无论谁都可以进行增删改查，重要数据放在list中是不安全的。所以需要一种存放重要数据的容器类数据类型，只能查看而不能增删改，这种数据类型就是元组；
元组：不可变的列表（只读列表），python的基本数据类型之一，小括号括起来。可以存放任何数据类型的数据，可以查询，循环，切片。不可以改；
元组的索引切片
tu1 = ('a', 'b', '黑色利穆', 777)
print(tu1[0]) # a
print(tu1[-1]) # 777
print(tu1[1:3]) # ('b', '黑色利穆')
print(tu1[:-1]) # ('a', 'b', '黑色利穆')
print(tu1[::2]) # ('a', '黑色利穆')
print(tu1[::-1]) # (777, '黑色利穆', 'b', 'a')
index： 通过元素找索引（可切片）
tu1 = ('a', 'b', '黑色利穆', 777)
print(tu1.index('黑色利穆')) # 2
count：获取元素在列表中出现的次数
tu1 = ('a', 777, 'b', 777, '黑色利穆', 777)
print(tu1.count(777)) # 3
len
tu1 = ('a', 777, 'b', 777, '黑色利穆', 777)
print(len(tu1)) # 6
用途：
将一些非常重要的且不可改动的数据放在元组中，只供查看；
常用于元组拆包；
2.6 dict 字典
字典是python语言中的映射类型，是以{}括起来的，里面的内容是以键值对的形式储存的：
key：不可变（可哈希）的数据类型，并且键是唯一的，不重复的；
value：任意数据（int，str，bool，tuple，list，dict，set）包括实例对象等；
python3.5版本之前，字典是无序的；3.6版本开始，字典会按照初建字典的顺序排列。字典的缺点是内存消耗巨大；
2.6.1 创建字典的集中方法
# 方法一：
dic = dict((('one', 1), ('two', 2), ('three', 3)))
# dic = dict([('one', 1), ('two', 2), ('three', 3)])
print(dic)
# {'one': 1, 'two': 2, 'three': 3}
# 方法二：
dic = dict(one=1, two=2, three=3)
print(dic)
# 方法三：
dic = dict({'one': 1, 'two': 2, 'three': 3})
print(dic)
# 方法四：
dic = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
print(dic)
# 方法五：
dic = { k: v for k, v in [('one', 1), ('two', 2), ('three', 3)]}
print(dic)
# 方法六：
dic = dict.fromkeys('abcd', '黑色利穆')
print(dic)
# {'a': '黑色利穆', 'b': '黑色利穆', 'c': '黑色利穆', 'd': '黑色利穆'}
2.6.2 验证字典的合法性
# 合法
dic = {123: 456, True: 777, 'id': 3, 'name': 'hslm', 'stu': ['xm', 'xh', 'xg'], (1, 2, 3): 'xl'}
print(dic[123])
print(dic[True])
print(dic['id'])
print(dic['name'])
print(dic['stu'])
print(dic[(1, 2, 3)])
# 不合法
# dic = {[1, 2, 3]: 456} # list是可变的，不能作为key
# dic = {{1: 2}: 234} # dict是可变的，不能作为key
# dic = {{1, 2, 3}: 234} # set是可变的，不能作为key
2.6.3 字典的常用操作-增
# 通过键值对直接增加
dic = {'name': '黑色利穆', 'age': 25}
dic['sex'] = 'man' # 没有sex键，就增加键值对
print(dic) # {'name': '黑色利穆', 'age': 25, 'sex': 'man'}
dic['name'] = 'xiaoming' # 有name键，改变字典值
print(dic) # {'name': 'xiaoming', 'age': 25, 'sex': 'man'}
# setdefault
dic = {'name': '黑色利穆', 'age': 25}
dic.setdefault('sex', 'man') # 没有sex键，添加
print(dic) # {'name': '黑色利穆', 'age': 25, 'sex': 'man'}
dic.setdefault('name', 'xiaoming') # 有name键，不改变
print(dic) # {'name': '黑色利穆', 'age': 25, 'sex': 'man'}
# 返回值
dic = {'name': '黑色利穆', 'age': 25}
ret = dic.setdefault('name')
print(ret) # 黑色利穆
2.6.4 删
# pop 通过key删除字典的键值对，有返回值，可设置返回值
dic = {'name': '黑色利穆', 'age': 25}
ret = dic.pop('name')
print(ret, dic) # 黑色利穆 {'age': 25}
ret1 = dic.pop('n', None)
print(ret1, dic) # None {'age': 25}
# popitem 3.5之前为随机删除，3.6之后删除最后一个，有返回值
dic = {'name': '黑色利穆', 'age': 25}
ret = dic.popitem()
print(ret, dic) # ('age', 25) {'name': '黑色利穆'}
# clear 清空字典
dic = {'name': '黑色利穆', 'age': 25}
dic.clear()
print(dic) # {}
# del 通过键删除键值对
dic = {'name': '黑色利穆', 'age': 25}
del dic['name']
print(dic) # {'age': 25}
# 删除整个字典
del dic
2.6.5 改
# 通过键值对直接改
dic = {'name': '黑色利穆', 'age': 25}
dic['name'] = 'xm'
print(dic) # {'name': 'xm', 'age': 25}
# update
dic = {'name': '黑色利穆', 'age': 25}
dic.update(sex='man', height=175)
print(dic)
# {'name': '黑色利穆', 'age': 25, 'sex': 'man', 'height': 175}
dic.update([(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')])
print(dic)
# {'name': '黑色利穆', 'age': 25, 'sex': 'man', 'height': 175, 1: 'a', 2: 'b', 3: 'c', 4: 'd'}
dic1 = {'name': 'xm', 'age': 20, 'sex': 'man'}
dic2 = {'name': 'zs', 'weight': 80}
dic1.update(dic2)
print(dic1) # {'name': 'zs', 'age': 20, 'sex': 'man', 'weight': 80}
print(dic2) # {'name': 'zs', 'weight': 80}
2.6.6 查
# 通过键查询，直接dict[key] 没有键会报错
dic = {'name': '黑色利穆', 'age': 25}
print(dic['name']) # 黑色利穆
# get
dic = {'name': '黑色利穆', 'age': 25}
v = dic.get('name')
print(v) # 黑色利穆
v1 = dic.get('name1')
print(v1) # None
v2 = dic.get('name2', '没有此键')
print(v2) # 没有此键
# keys()
dic = {'name': '黑色利穆', 'age': 25}
print(dic.keys()) # dict_keys(['name', 'age'])
# values()
dic = {'name': '黑色利穆', 'age': 25}
print(dic.values()) # dict_values(['黑色利穆', 25])
# items()
dic = {'name': '黑色利穆', 'age': 25}
print(dic.items()) # dict_items([('name', '黑色利穆'), ('age', 25)])
练习
'''
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}
请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
请在修改字典中 "k1" 对应的值为 "alex"，输出修改后的字典
请在k3对应的值中追加一个元素 44，输出修改后的字典
请在k3对应的值的第 1 个位置插入个元素 18，输出修改后的字典
'''
dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}
dic['k4'] = 'v4'
print(dic)
# {'k1': 'v1', 'k2': 'v2', 'k3': [11, 22, 33], 'k4': 'v4'}
dic['k1'] = '黑色利穆'
print(dic)
# {'k1': '黑色利穆', 'k2': 'v2', 'k3': [11, 22, 33], 'k4': 'v4'}
dic['k3'].append(44)
print(dic)
# {'k1': '黑色利穆', 'k2': 'v2', 'k3': [11, 22, 33, 44], 'k4': 'v4'}
dic['k3'].insert(1, 18)
print(dic)
# {'k1': '黑色利穆', 'k2': 'v2', 'k3': [11, 18, 22, 33, 44], 'k4': 'v4'}
2.6.7 其他操作
# fromkeys
dic = dict.fromkeys('abcd', '黑色利穆')
print(dic)
# {'a': '黑色利穆', 'b': '黑色利穆', 'c': '黑色利穆', 'd': '黑色利穆'}
dic = dict.fromkeys([1, 2, 3], '黑色利穆')
print(dic)
# {1: '黑色利穆', 2: '黑色利穆', 3: '黑色利穆'}
# 高仿列表，存放的都是字典的key
dic = dict.fromkeys('abcd', '黑色利穆')
key_list = dic.keys()
print(key_list)
# dict_keys(['a', 'b', 'c', 'd'])
print(list(key_list)) # 高仿列表可以转化成列表
# ['a', 'b', 'c', 'd']
# 可以循环打印
dic = {'小明': 99, '小红': 97, '小刚': 100}
for i in dic:
print(i)
# 小明
# 小红
# 小刚
value_list = dic.values()
print(value_list) # dict_values([99, 97, 100])
# 一个高仿里诶包，存放的都是字典中的value，并且这个高仿列表可以转化成字典
print(list(value_list)) # [99, 97, 100]
# 可以循环打印
for i in dic.values():
print(i)
# 99
# 97
# 100
key_value_list = dic.items()
print(key_value_list)
# dict_items([('小明', 99), ('小红', 97), ('小刚', 100)])
# 一个高仿列表，存放多个元组，元组中第一个是字典的键，第二个是字典的值
# 也可以转化成列表
print(list(key_value_list))
# [('小明', 99), ('小红', 97), ('小刚', 100)]
# 也可以循环打印
for i in dic.items():
print(i)
# ('小明', 99)
# ('小红', 97)
# ('小刚', 100)
分别赋值，拆包
a, b = 1, 2
print(a, b) # 1 2
a, b = ('你好', '世界')
print(a, b) # 你好 世界
a, b = ['黑色', '利穆']
print(a, b) # 黑色 利穆
a, b = {'黑色': 'heise', '利穆': 'limu'}
print(a, b) # 黑色 利穆
利用拆包，循环字典时可以获取字典的键，值
dic = {'昨天': 20201127, '今天': 20201128, '明天': 20201129, '今年': 2020
}
for k, v in dic.items():
print('dic的键是：', k)
print('dic的值是：', v)
# dic的键是： 昨天
# dic的值是： 20201127
# dic的键是： 今天
# dic的值是： 20201128
# dic的键是： 明天
# dic的值是： 20201129
# dic的键是： 今年
# dic的值是： 2020
2.6.8 字典的嵌套
'''
dic = {
'name':'汪峰',
'age':48,
'wife':[{'name':'国际章','age':38}],
'children':{'girl_first':'小苹果', 'girl_second':'小怡', 'girl_three':'顶顶'}
}
1. 获取汪峰的名字。
2.获取这个字典：{'name':'国际章','age':38}。
3. 获取汪峰妻子的名字。
4. 获取汪峰的第三个孩子名字。
'''
dic = {
'name':'汪峰',
'age':48,
'wife':[{'name':'国际章','age':38}],
'children':{'girl_first':'小苹果', 'girl_second':'小怡', 'girl_three':'顶顶'}
}
print(dic['name']) # 汪峰
print(dic['wife'][0]) # {'name': '国际章', 'age': 38}
print(dic['wife'][0]['name']) # 国际章
print(dic['children']['girl_three']) # 顶顶
'''
dic1 = {
'name': ['heiselimu', 2, 3, 5],
'job': 'OPS',
'trait': {'heiselimu': ['善良', '温柔', 666]}
}
1，将name对应的列表追加⼀个元素’xiaoming’。
2，将name对应的列表中的alex⾸字⺟⼤写。
3，trait对应的字典加⼀个键值对’sex’,’man’。
4，将trait对应的字典中的heiselimu对应的列表中的‘温柔’删除
'''
dic1 = {
'name': ['heiselimu', 2, 3, 5],
'job': 'OPS',
'trait': {'heiselimu': ['善良', '温柔', 666]}
}
dic1['name'].append('xiaoming')
print(dic1)
# {'name': ['heiselimu', 2, 3, 5, 'xiaoming'], 'job': 'OPS', 'trait': {'heiselimu': ['善良', '温柔', 666]}}
dic1['name'][0] = dic1['name'][0].capitalize()
print(dic1)
# {'name': ['Heiselimu', 2, 3, 5, 'xiaoming'], 'job': 'OPS', 'trait': {'heiselimu': ['善良', '温柔', 666]}}
dic1['trait']['sex'] = 'man'
print(dic1)
# {'name': ['Heiselimu', 2, 3, 5, 'xiaoming'], 'job': 'OPS', 'trait': {'heiselimu': ['善良', '温柔', 666], 'sex': 'man'}}
del dic1['trait']['heiselimu'][1]
print(dic1)
# {'name': ['Heiselimu', 2, 3, 5, 'xiaoming'], 'job': 'OPS', 'trait': {'heiselimu': ['善良', 666], 'sex': 'man'}}
2.7 set 集合
集合是无序的，不重复的数据集合，它里边的元素是可哈希（不可变类型），但是集合本身不可哈希。
天然去重；测试交集，差集，并集等关系；
2.7.1 集合的创建
set1 = set({1, 2, 'heiselimu'})
set2 = {1, 2, 'heselimu'}
print(set1, set2)
# {'heiselimu', 1, 2} {1, 2, 'heselimu'}
2.7.2 集合的增
set1 = {'张三', '李四', '王五', '小明'}
set1.add('小红')
print(set1)
# {'张三', '李四', '王五', '小红', '小明'}
# update 迭代增加
set1.update('A')
print(set1) # {'李四', 'A', '张三', '王五', '小明', '小红'}
set1.update('abc')
print(set1) # {'b', 'A', '李四', 'a', '小红', '小明', '王五', 'c', '张三'}
set1.update([1, 2, 3])
print(set1) # {1, 2, '小红', '王五', 3, 'A', '张三', '小明', 'a', 'c', 'b', '李四'}
2.7.3 集合的删
set1 = {'张三', '李四', '王五', '小明'}
set1.remove('王五') # 删除一个元素
print(set1) # {'张三', '小明', '李四'}
set1.pop() # 随机删除一个元素
print(set1) # {'小明', '李四'}
set1.clear() # 清空集合
print(set1) # set()
del set1 #删除集合
2.7.4 集合的其他操作
# 交集 & 或者 intersection
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
print(set1 & set2) # {4, 5}
print(set1.intersection(set2))
# 并集 | 或者 union
print(set1 | set2) # {1, 2, 3, 4, 5, 6, 7, 8}
print(set1.union(set2))
# 差集 - 或者 difference
print(set1 - set2) # {1, 2, 3}
print(set1.difference(set2))
# 反交集 ^ 或者 symmetric_difference
print(set1 ^ set2) # {1, 2, 3, 6, 7, 8}
print(set1.symmetric_difference(set2))
# 子集 与 超集
set1 = {1, 2, 3}
set2 = {1, 2, 3, 4, 5}
print(set1 < set2) # True 说明set1是set2的子集
print(set1.issubset(set2))
print(set2> set1)
print(set2.issuperset(set2)) # True 说明set2 是set1 的超集
3 其他 for， enumerate， range
for循环，用户按照顺序循环可迭代对象的内容；
msg = '黑色利穆是最帅的男人'
for i in msg:
print(i)
# 黑
# 色
# 利
# 穆
# 是
# 最
# 帅
# 的
# 男
# 人
li = ['黑色', '利穆', '是最帅', '的男人']
for i in li:
print(i)
# 黑色
# 利穆
# 是最帅
# 的男人
dic = {'name': 'heiselimu', 'age': 25, 'job': 'OPS'}
for k, v in dic.items():
print(k, v)
# name heiselimu
# age 25
# job OPS
enumerate：枚举，对一个可迭代对象（iterable）或者可遍历的对象（列表，字符串）,将其组成一个索引序列，利用它可以同时获得索引和值：
li = ['黑色', '利穆', '是最帅', '的男人']
for i in enumerate(li):
print(i)
# (0, '黑色')
# (1, '利穆')
# (2, '是最帅')
# (3, '的男人')
for index, name in enumerate(li, 1):
print(index, name)
# 1 黑色
# 2 利穆
# 3 是最帅
# 4 的男人
for index, name in enumerate(li, 100): # 起始位默认是0，可改变
print(index, name)
# 100 黑色
# 101 利穆
# 102 是最帅
# 103 的男人
range：指定范围，生成指定数字：
for i in range(1, 10):
print(i)
for i in range(1, 10, 2): # 步长
print(i)
for i in range(10, 1, -2): # 反向步长
print(i)
利用len和range打印列表索引：
li = ['黑色', '利穆', '是最帅', '的男人']
for i in range(len(li)):
print(i)
