python-元组、列表、字典

一、元组

"""
python元组 tuple 不可变，不支持删除，添加，修改值：
    1、创建空元组，创建一个元素的元组（一个元素后加英文逗号）。
    2、通过索引获取使用元素。
    3、通过切片slice（分片或切片）获取元组元素[start:end:step],start和end两个索引值可以使用正负值，负数表示从倒数开始，step步长使用负数无意义
    4、加法，列表和元组都支持加法运算，加法的和就是两个列表或元组所包含的元素的总和，注意：列表只能跟列表相加，元组只能跟元组相加，列表不能和元组相加。
    5、乘法，列表和元组乘法的意义就是把它们包含的元素重复。
    6、in运算符，in运算符用于判断元素是否存在于列表或元组中。
    7、长度、最大值和最小值。
    8、序列封包和序列解包。
"""

# 1、创建一个空元组,一个元素的元组
tup=()
print(tup,type(tup))  # () <class 'tuple'>
tup0=(1,)
print(tup0,type(tup0))  # (1,) <class 'tuple'>

# 2、通过索引获取使用元素。
tup1=(1,4,8,1,"元组")
print(tup1)
# 获取元组tup1第1个元素
print(tup1[0])  # 1
# 获取元组tup1第2个元素
print(tup1[1])  # 4
# 获取元组tup1倒数第1个元素
print(tup1[-1])  # 元组
# 获取元组tup1倒数第2个元素
print(tup1[-2])  # 1

# 3、通过切片slice（分片或切片）获取元组元素[start:end:step]
# [start:end:step] start和end可以是正负数，负数表示从倒数开始。step不能是负数。
# 左闭右开（左边包含，右边不包含）
tup2=(2,3,0,"hello",21,7)
# 访问从第2个到第4个（不包含）的所有元素
print(tup2[1:3])  # (3, 0)
# 访问倒数第4到倒数第1个（不包含）元素
print(tup2[-4:-1])  # (0, 'hello', 21)
# 访问第2个到倒数第2个（不包含）元素
print(tup2[1:-2])  # (3, 0, 'hello')
# 访问倒数第3个到第5个（不包含）元素
print(tup2[-3:5])  # ('hello', 21)
# 如果指定step参数，则可间隔step个元素再取元素
tup3=(1,2,3,4,5,6,7,8,9,10)
# 访问从第3个到第9个（不包含），间隔为2的所有元素
print(tup3[2:8:2])  # (3, 5, 7)
# 访问从第3个到第9个（不包含），间隔为3的所有元素
print(tup3[2:8:3])  # (3,6)
# 访问从第3个到倒数第2个（不包含），间隔为2的所有元素
print(tup3[2:-2:2])  # (3,5,7)

# 4、加法，元组和列表支持加法运算，加法的就是两个列表或元组所包含的元素的总和。
# 注意：列表只能和列表相加，元组只能和元组相加，两者不能互加.
tup4,tup5=(1,2,3),(4,5,6)
print(tup4+tup5,type(tup4+tup5))  # (1, 2, 3, 4, 5, 6) <class 'tuple'>

# 5、乘法，列表和元组可以和整数执行乘法运算
tup6=(1,2,3)
print(tup6*3)  # (1, 2, 3, 1, 2, 3, 1, 2, 3)

"""
轻松一练：把用户输入的日期翻译成英文表示形式。
分析：日期格式：English:day/month/year。American：month/day/year
日的缩写表示法：
1st 2nd 3rd 4th 5th 6th 7th 8th 9th 10th
11th 12th 13th 14th 15th 16th 17th 18th 19th 20th
21st 22nd 23rd 24th 26th 27th 28th 29th 30th 
31st
"""
# riqi=('st','nd','rd')\
# +('th',)*17+('st','nd','rd')\
# +('th',)*6+('st',)   # \连接符，元组中只有一个元素时要在其后面添加逗号
# shuru=int(input("输入日期(1-31)："))
# print(shuru,riqi[shuru-1])

# 6、in运算符,用于判断元素是否存在于列表或者元组中。
tup7=(1,2,3,4,6)
print(1 in tup7)  # true

# 7、长度、最大值和最小值,比较最大/小值时，元组和列表的元素都必须是相同类型的才可以进行比较。
tup8=(1,2,3,4,5,6,7,21)
print(len(tup8))  # 8
print(min(tup8))  # 1
print(max(tup8))  # 21

# 8、序列封包，序列解包
# 序列封包：程序将多个值赋给一个变量时，python会自动将多个值封装成元组，这个功能叫做序列封包。
# 序列解包：程序将序列（元组或列表）直接赋值给多个变量时，此时序列的各个元素会被依次赋值给每个变量。
# 序列封包：将10,20,30封装成元组赋值给tup9
tup9=10,20,30
print(tup9)  # (10, 20, 30)
# 序列解包：将tup9元组的各元素依次赋值给a,b,c,d变量
a,b,c=tup9
print(a)
# 封包和解包同时运用
a,b,c=1,2,3
print(a)  # 1
print(b)  # 2
print(c)  # 3

二、列表

"""
python列表 list，列表和元组最大的区别就是列表支持修改元素，而元组不能支持。
注意：大部分时候都可使用列表来代替元组，但如果程序不需要修改列表所包含的元素，那么使用元组代替列表会更安全。
    1、创建列表list()，空列，将其他序列转换为列表。
    2、增加列表元素：
        列表名.append('元素'/序列)，在列表末尾添加元素，添加的元素或序列默认为一个值；
        列表名.extend('元素'/序列)，添加的元素值由个数决定；
        列表名.insert(位置,'元素'/序列)，可以指定位置添加元素。
    3、删除列表元素：
        del 列表名[下标]，即可删除单个元素，也可以删除列表的中间一段，del也可以删除普通变量；
        列表名.remove('元素')，该方法只删除第一个找到的元素；
        列表名.pop(下标)，根据下标删除元素；
        列表名.clear()，清楚列表中所有的元素。
    4、修改列表元素，列表的元素就相当于变量，因此程序可以对列表的元素赋值，这样即可修改列表的元素
        列表名[下标索引]='新元素'，索引可以是正负数。
    5、输出显示列表的其他常用方法dir(list)。
    6、统计列表中某个元素出现的次数，列表名.count('元素')。
    7、判断某个元素在列表中出现的位置，列表名.index('元素')。
    8、将列表反向存放，列表名.reverse()。
    9、用于对列表元素排序，列表名.sort()
"""

# 1、创建列表，空列表，一个列表
list1=[]
print(list1,type(list1))  # [] <class 'list'>
list2=[1]
print(list2,type(list2))  # [1] <class 'list'>
# 将元组转换为列表
tup1=(1,2,3,'元组')
list3=list(tup1)
print(list3,type(list3))  # [1, 2, 3, '元组'] <class 'list'>

# 2、增加列表元素
# 列表名.append()
list4=[1,2,3]
list4.append(1)  # 列表名.append('元素'/列表),默认添加的元素在列表末尾
list4.append(('12',2,4,5))  # 在列表中添加元组序列，整个添加的元组是一个元素
print(list4, list4[4], len(list4))  # [1, 2, 3, 1, ('12', 2, 4, 5)] ('12', 2, 4, 5) 5
# 列表名.extend()
list5=[1,2]
list5.extend((-1,2))  # 列表个数由extend()添加的元素个数决定
print(list5,len(list5))  # [1, 2, -1, 2] 4
# 列表名.insert(位置,'元素'/序列),指定列表位置添加元素
list6=[2,3]
list6.insert(1,1)
print(list6,len(list6))  # [2, 1, 3] 3

# 3、删除列表元素
# del 列表名[下标]，即可删除单个元素，也可以删除列表的中间一段，del也可以删除普通变量；
list7=[1,2,3,4,5]
del list7[0]  # 删除列表list7中第1个元素
print(list7)  # [2, 3, 4, 5]
del list7[0:2]  # 删除列表list7中第1个到第3个（不包含）元素
print(list7)  # [4, 5]
# 列表名.remove('元素')，该方法只删除第一个找到的元素；
list8=[1,2,1,2,3]
list8.remove(1)
print(list8)  # [2, 1, 2, 3]
# 列表名.pop(下标)，根据下标删除元素；
list9=[1,2,3,4]
list9.pop(0)
print(list9)  # [2, 3, 4]
# 列表名.clear()，清楚列表中所有的元素。
list10=[1,2,3,4]
list10.clear()
print(list10)  # []

# 4、修改列表元素，列表的元素就相当于变量，因此程序可以对列表的元素赋值，这样即可修改列表的元素
# 列表名[下标索引]='新元素'，索引可以是正负数。
list11=[1,2,3,4,5]
list11[0]=2  # 修改列表第1个元素为2
print(list11)  # [2, 2, 3, 4, 5]
list11[2:4]=2,3  # 修改列表中第3位到第4位（不包含）的元素
print(list11)  # [2, 2, 2, 3, 5]

# 5、输出显示列表的其他常用方法dir(list)。
print(dir(list))
# ['__add__', '__class__', '__contains__', '__delattr__',
# '__delitem__', '__dir__', '__doc__', '__eq__', '__format__',
# '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__',
# '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__',
# '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__',
# '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__',
# '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count',
# 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

# 6、统计列表中某个元素出现的次数，列表名.count('元素')。
list12=[1,2,3,4,5,6,1,2,3,41,2]
print(list12.count(1))  # 2
# 7、判断某个元素在列表中出现的位置，列表名.index('元素')。
list13=[1,23,4,5,1,2,3]  # 判断在列表list13中，元素1出现的位置，如果元素重复则只显示第一个。
print(list13.index(1))  # 0
# 判断列表list13中从下标1开始（包含），元素1的位置
print(list13.index(1,1))  # 4
# 判断列表list13中从下标2开始（包含）到下标5结束（不包含），元素4的位置，如果没有这个元素则会报错
print(list13.index(4,2,5))  # 2

# 8、将列表反向存放，列表名.reverse()。
list14=[1,3,5,6,8,0]
list14.reverse()
print(list14)  # [0, 8, 6, 5, 3, 1]

# 9、用于对列表元素排序，列表名.sort()，只能相同类型的元素进行比较
list15=[8,9,7,6,1,2,3,4,5,6,]
list15.sort()  # 默认从小到大进行排序
print(list15)  # [1, 2, 3, 4, 5, 6, 6, 7, 8, 9]
list16=['11','111','1111','gg']
list16.sort()  # 对字符串进行排序，默认按字符串包含的字符的编码来计较大小
print(list16)  # ['11', '111', '1111', 'gg']
# sort()方法除了默认排序之外，还可以传入key和reverse两个参数，而且这两个参数必须通过参数名指定（这种参数叫关键字参数）
list17=['what','your','wo','are','home']
# 指定key为len，指定使用len函数对集合元素生成比较大小的键
list17.sort(key=len)  # 表示安装字符串的长度比较大小
print(list17)  # ['wo', 'are', 'what', 'your', 'home']
list17.sort(key=len,reverse=True)  # reverse=True反向排序，reverse=False正向排序
print(list17)  # ['what', 'your', 'home', 'are', 'wo']

三、字典

"""
python字典dict：是一种常见的数据结构，用来从存放具有映射关系的数据；语法：{key:value}，key可以是任意不可变类型。
    1、创建字典，dict()和{key:value}都可以用来创建空列表，多个ksy-value对之间用英文,隔开。
    2、增，只需要为不存在的key赋值即可。
    3、删，del 字典名['key']，字典名.pop('key')。
    4、改，对已经存在的key重新赋值。
    5、查，字典名['key']。
    6、字典的常用方法：
        1、字典名.clear()，清空字典的所有key-value对。
        2、字典名.get('key')，根据key来获取value，他相当于方括号语法的增强版。
        3、字典名.update({'key':'value'})，如果字典有key-value则更新，没有则表示添加。
        4、字典名.item()获取字典中所有的key-value对，字典名.keys()获取字典中所有的key，字典名.values()获取所有的value值。
    7、字典名.popitem()，随机弹出字典中的一个key-value对。
    8、dict.fromkeys()，使用给定的多个key创建字典，这些字典对应的value默认都是None，该对象一般不会使用对象调用，通常直接使用dict类直接调用。
    9、使用字典格式化字符串。
"""

# 1、创建字典，创建一个空字典，既可以使用花括号{}，也可以使用dict()创建
dict1={}  # 创建一个空字典{}
dict2=dict()  # 创建一个空字典dict()
print(dict1,dict2,type(dict1),type(dict2))  # {} {} <class 'dict'> <class 'dict'>
dict3={"语文":99,11:1}  # 创建多个key-value对的字典
print(dict3,type(dict3),dict3[11])  # {'语文': 99, 11: 1} <class 'dict'> 1

# 2、增，通过key增加
dict4={}
dict4["数学"]=100  # 添加不存在的key
print(dict4,type(dict4))

# 3、删，del 字典名['key']，字典名.pop('key')，字典名.clear()
dict5={"英语":89,"政治":90}
del dict5["英语"]
print(dict5)  # {'政治':90}
dict5.pop('政治')
print(dict5)  # {}
print(dict5.clear())  # 清空所有key-value对

# 4、改，通过对key重新赋值达到修改目的
dict6={"历史":90,"生物":80}
dict6["历史"]=70  #  通过key重新赋值
print(dict6)  # {'历史': 70, '生物': 80}
dict6.update({"历史":91,"化学":100})  # 通过已存在的key修改，不存在的添加
print(dict6)  # {'历史': 91, '生物': 80, '化学': 100}

# 5、查，通过[key]，get('key')查看字典
dict7={"科学":100,"地理":20}  # 通过key查看字典value
print(dict7["科学"])  # 100  # 通过get(key)方法查看字典value
print(dict7.get("科学"))  # 100
# 字典名.setdefault()，根据key来获取value的值，如果key不存在则会自动添加。
print(dict7.setdefault("科学"))  # 100
print(dict7.setdefault("人文"))  # None
print(dict7.setdefault("人文",100))
print(dict7)  # {'科学': 100, '地理': 20, '人文': None}
# 6、字典的常用方法：
# dir()，查看字典的方法有哪些
print(dir(dict))
# ['__class__', '__contains__', '__delattr__', '__delitem__',
# '__dir__', '__doc__', '__eq__', '__format__', '__ge__',
# '__getattribute__', '__getitem__', '__gt__', '__hash__',
# '__init__', '__init_subclass__', '__iter__', '__le__',
# '__len__', '__lt__', '__ne__', '__new__', '__reduce__',
# '__reduce_ex__', '__repr__', '__setattr__', '__setitem__',
# '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy',
# 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem',
# 'setdefault', 'update', 'values']

# 字典名.item(),获取字典中所有的key - value对，返回一个dict_items对象
dict8={"亚洲":2000,"非洲":100}
time1=dict8.items()
print(time1,type(time1))  # dict_items([('亚洲', 2000), ('非洲', 100)]) <class 'dict_items'>
# 将time1转化为列表
print(list(time1),type(list(time1)))  # [('亚洲', 2000), ('非洲', 100)] <class 'list'>
# 访问第二个key-value对
print(list(time1)[1])  # ('非洲', 100)
# 字典名.keys(),获取字典中所有的key，返回一个dict_keys对象
dict9={"欧洲":1999,"美洲":2001}
kys=dict9.keys()
print(kys,type(kys))  # dict_keys(['欧洲', '美洲']) <class 'dict_keys'>
# 字典名.values(),获取所有的value值，返回一个dict_values对象。
dict10={"太平洋":20,"大西洋":30,"北冰洋":15}
val=dict10.values()
print(val,type(val))  # dict_values([20, 30, 15]) <class 'dict_values'>

# 7、字典名.popitem()，随机弹出字典中最后的一个key - value对。
dict11={"地球人":"地","火星人":"火","水星人":"水","金星人":"金"}
print(dict11.popitem())  # ('金星人', '金')

# 8、dict.fromkeys()，使用给定的多个key创建字典，这些字典对应的value默认都是None，该对象一般不会使用对象调用，通常直接使用dict类直接调用。
# 使用列表创建包含两个key的子集
dic12=dict.fromkeys(["a","b"])
print(dic12,type(dic12))  # {'a': None, 'b': None} <class 'dict'>
# 使用元组创建
dic13=dict.fromkeys((1,2,3))
print(dic13,type(dic13))  # {1: None, 2: None, 3: None} <class 'dict'>
# 使用元组创建字典，并默认指定的value
dic14=dict.fromkeys(('a','b'),100)
print(dic14,type(dic14))  # {'a': 100, 'b': 100} <class 'dict'>

# 10、使用字典格式化字符串。
temp='书名是：%(name)s,价格是：%(price)0.12f,出版社是:%(publish)s'
book={"name":"python疯狂讲义","price":"100","publish":"电子社"}
print(temp) # {'a': 100, 'b': 100} <class 'dict'>
# 书名是：%(name)s,价格是：%(price)0.12f,出版社是:%(publish)s