列表 元组 字典 集合 推导式

'''列表（list）
Python 支持多种复合数据类型，可将不同值组合在一起。最常用的**列表** ，是用方括号标注，逗号分隔的一组值。列表可以包含不同类型的元素，但一般情况下，各个元素的类型相同

- 列表是一种可以存储任意个各种类型的序列容器
- 列表内的数据有先后顺序关系
- 列表是可变的容器

创建列表的构造函数 list
list()           # 创建一个空的列表，等同于 []
list(可迭代对象)   # 用可迭代对象创建一个列表
例如：
l = []              #输出[]
L = list("ABC")     # L = ['A', 'B', 'C']
L = list(range(5))  # L = [0, 1, 2, 3, 4]
列表的运算  列表list同字符串str都是序列, 他们的运算规则基本相同
+ 用于拼接列表  [1, 2, 3] + [4, 5, 6]   # [1, 2, 3, 4, 5, 6]
* 用于生产重复的列表
==  != 用于比较
in /not in 用于判断一个数据元素是否在列表中
索引 与字符串的索引一样，列表索引从 0 开始，第二个索引是 1，依此类推。
索引也可以从尾部开始，最后一个元素的索引为 -1，往前一位为 -2，以此类推。
切片与字符串一样规则

列表的数据操作(增、删、改、查)
添加 L.append(x)  #向列表的末尾追加单个数据
插入 L.insert(index, obj) #将某个数据obj 插入到 index这个索引位置的数据之前
L.extend(可迭代对象) #等同于: L += 可迭代对象，如列表、元组、字符串、集合等在尾部添加一个可迭代对象
修改数据：用索引赋值可以改变列表内的数据    列表[整数表达式] = 表达式
删除  L.remove(x) 从列表L中删除第一次出现在列表中的数据元素，如果x不存在则报错
L.pop() 根据索引删除元素，并返回该元素。若不提供索引，默认删除最后一个元素，也可以用  del 列表[整数表达式]
L.clear()   清空列表
'''
# #添加数据
# l =[1,2,3]
# l.append(4)
# print(l)
# #插入数据
# l.insert(0,[1,2,3])
# print(l)
# #在尾部添加一个可迭代对象
# l.extend([1,2,3])
# print(l)
#修改数据
# l=[1,2,3.4]
# l[2]=5
# print(l)
#元素删除
# l=[1,2,3,3,3,6,7,8,9]
# l.remove(1)
# print(l)
# l.pop(0)
# print(l)

'''例题
写一个程序, 用列表保存用户输入的数据
1. 让用户输入4个任意的整数，放入列表
2. 在第三个整数前面插入一个100
3. 删除列表中的第4个整数
4. 将之前输入的第二个整数加上1 后放回原处
5. 打印现在的列表
'''
# l= []
# for x in range(4):
#     s = int(input('请输入:'))
#     l.append(s)
# l.insert(2,100)
# l.pop(3)
# l[1]+=1
# print(l)
'''
列表常用API
len(list)列表元素个数
max(list)返回列表元素最大值
min(list)返回列表元素最小值
'''

'''
- 元组是不可改变的列表，所谓元组的不可变指的是元组所指向的内存中的内容不可变。
- 同列表list 一样，元组可以存放任意类型的数据
- 但是，一旦创建将不可修改，包括添加、删除或更改其中的元素
- 元组使用小括号 ( )，列表使用方括号 [ ]
删除：元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组
元组运算：元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，类似于字符串
'''

'''
- 字典是一种可变容器模型，且可存储任意类型对象。
- 字典的数据都是以键(key)-值(value)对的形式进行映射存储.
- 字典的每个键值对( key:value )用冒号分割，每个对之间用逗号分割，整个字典包括在花括号 {} 中 
- **d = {key1 : value1, key2 : value2, key3 : value3 }**
- 字典的数据在Python 3.7及更高版本中，字典是有序的；3.6之前的版本中，字典是无序的
- 字典的键不能重复，且只能用不可变类型作为字典的键
- 字典中的数据只能用"键"key 进行索引，不能用整数进行索引
-不可变对象：Number(数字)，String（字符串），tuple（元组）
-可变对象：list（列表），dict（字典），set
**字典值可以是任何的 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行。**
不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住
键必须不可变，所以可以用数字，字符串或元组充当，而用列表等就不行
'''
# dit={} #创建字典
# dit={"id":'zy',"age":18,"sex":'nan',"bir":3}    #初始化key ：value
# #修改
# dit["age"]=19
# print(dit)
# #添加一个不存在的key，给key赋值
# dit["tel"]=123
# print(dit)
# #访问：根据key获取相应的value
# print(dit["sex"])
# #in/not in 判断key是否在字典中
# print("bir" in dit)
#删除
#1.del在字典中可以根据key删除元素
# d={"id":'zy',"age":18,"sex":'nan',"bir":3}
# del d["id"]
# #2.pop(key):删除元素，根据key删除元素，并且返回该元素的value值
# a=d.pop("bir")
# print(a)
# #popitem():删除字典中最后一个元素，并且返回该元素的key和value
# key,value = d.popitem()
# print(key,value)
# print(d)
# # 删除字典中的所有项
# d.clear()
# print(d)
#get（key）通过get方法里的key获取value
#字典遍历
# d={"id":'zs',"age":18,"sex":'nan'}
# for k in d:
#     print(k,d[k])
# #keys():获取字典中key
# l=d.keys()
# for k in l:
#     print(k)
# #values（）：获取字典中的value
# l=d.values()
# print(l)
# for value in l:
#     print(value)
# #items（）：获取字典中的key和value
# l=d.items()
# print(l)
# for k,value in l:
#     print(k,value)
#fromkeys(seq):根据序列生成字典，序列中的元素作为字典的key，如果value未指定则默认为None
# l={"id":'name'}
# dic=dict.fromkeys(l)
# print(dic)
# dic["id"]=1
# dict.setdefault("id1",1)
# print(dic)
#update(dic):将dic更新到原来的字典中
# d1 = {'a': 1, 'b': 2}
# d2 = {'b': 3, 'c': 4}
# d3 = d1.copy()
# d3.update(d2)
# print(d3)

'''
-  集合是可变的容器，固定集合是不可变的集合 
-  集合相当于只有键没有值的字典
-  集合是无序的不重复元素的存储结构
-  集合内的数据都是唯一的，不可变的
创建集合的方式

> 空集合 set()
>
> 非空集合 用 {} 括起来，值用逗号分隔开
创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
'''
# #集合创建
# s=set()
# print(s)
# s={1,2,3,4,5}
# print(s)
# #frozenset:固定集合
# fs=frozenset()
# fs=frozenset({1,2,3,4,5})
# print(fs)
# #add(x):添加元素到集合中
# s={1,2,3,4,5}
# s.add(6)
# print(s)
# #set集合的元素是唯一的，不能重复
# s.add(6)
# print(s)
#
# #update:把序列添加到集合中，可以为列表，元组等
# l={4,5,6,7}
# s.update(l)
# print(s)
#
# #删除
# s={1,2,3,4,5}
# #remove(x)删除指定元素，如果不存在就抛出异常
# s.remove(5)
# print(s)
# #discare:删除指定的元素，如果元素不存在，不会抛异常
# s.discard(2)
# print(s)
# s.discard(6)
# print(s)
# #pop():先对集合进行排序，然后将排序后的序列中最左边的元素删除，返回的集合是排序后的集合
# s={5,1,4,34,7}
# s.pop()
# print(s)
#
# #in/not in:判断元素是否在集合中
# print(3 in s)
#union():做集合的并集
# s1={1,2,3,4,5}
# s2={4,5,6,7}
# s3=s1.union(s2)
# print(s3)
# s4=s1.intersection(s2)
# print(s4)

'''
Python 推导式是一种独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体。

Python 支持各种数据结构的推导式：

- 列表(list)推导式
用简单的表达式方式来创建列表
[ 表达式 for 自定义变量 in 可迭代对象 ]
# 或
[ 表达式 for 自定义变量 in 可迭代对象 if 真值表达式 ]
例子：
# 生成一个列表， 里面有 10 个数是[1, 4, 9 ...]
l=[]
for i in range(1,11):
    n =i **2
    l.append(n)
print(l)
#列表推导式
l1=[i**2 for i in range(1,11)]
print（l1）
'''
#生成一个列表，对列表中偶数元素进行平方，生成一个新列表
l=[]
for i in range(1,11):
    if i % 2 == 0:
        n=i**2
        l.append(n)
print(n)
#列表推导式：
l = [i**2 for i in range(1, 11) if i % 2 == 0]
print(l)

#字典推导式
#格式：{key表达式：value表达式 for 变量 in 迭代对象 if 条件语句}
#将列表中各字符串值为键，各字符串的长度为值，组成键值对
l=["one","two","three","four","five"]
dic={key:len(key) for key in l}
print(dic)
#提供三个数字，以三个数字为键，三个数字的平方值来创建字典
dic={x: x ** 2 for x in {2,4,6}}
print(dic)
#集合推导式
#格式：{ 表达式 for 变量 in 迭代器 if 条件判断}