列表、元组、字典、集合
列表
- 列表(list)
容器型数据类型(序列), 可变、有序 - 元素
任何类型的数据都可以作为列表元素 - 元素的增删改查（*）
1).查
查单个元素：列表[下标]
查部分元素(切片)：列表[开始下标:结束下标:步长], 列表[:], 列表[::-1]
遍历：直接遍历、遍历下标
2).增
列表.append(元素)、 列表.insert(下标, 元素)
3).删
del 列表[下标]
列表.remove(元素)
列表.pop() 列表.pop(下标)
4.改
列表[下标] = 新值
+, *, ==, !=, in/not in, len(), list()
5.列表常用方法
- count
列表.count(元素) -- 统计列表中指定元素的个数,返回一个整数
nums = [1, 34, 1, 6, 8, 1]
print(nums.count(1))
- extend
列表.extend(序列) -- 将序列中的元素全部添加到列表中
nums.extend('abc')
print(nums)
nums.extend([100, 'abc', 'name'])
print(nums)
- index
列表.index(元素) -- 获取指定元素对应的下标（如果元素有多个只取第一个）
注意：如果元素不存在会报错！
nums = [100, 60, 34, 100]
print(nums.index(34))
4)reverse
列表.reverse() -- 反向列表(直接修改原列表)
reversed(序列) -- 反向序列，不修改原序列而是产生新的序列(迭代器)
nums = [100, 60, 34, 101]
nums.reverse()
print(nums)
nums = [100, 60, 34, 101]
new_nums = reversed(nums)
print(nums, list(new_nums))
str1 = 'hello'
new_str = reversed(str1)
print(str1, ''.join(list(new_str)), str1[::-1])
字符串.join(序列)
join()： 连接字符串数组。将字符串、元组、列表中的元素以指定的字符(分隔符)连接生成一个新的字符串
'sep'.john(seq)
- sort
"""
列表.sort() -- 将列表中的元素升序排序(从小到大)
列表.sort(reverse=True) -- 将列表中的元素降序排序(从大到小)
sorted(序列) -- 排序的时候不修改原序列，产生新的序列
注意: 能够进行排序的列表要求列表中的元素类型一致，并且支持比较运算
# sort
nums = [100, 60, 34, 101]
# nums.sort()
nums.sort(reverse=True)
print(nums)
sorted
nums = [100, 60, 34, 101]
new_nums = sorted(nums) # 从小到大排序
print(nums) # [100, 60, 34, 101]
print(new_nums) # [34, 60, 100, 101]
new_nums = sorted(nums, reverse=True) # 从大到小排序
print(new_nums) # [101, 100, 60, 34]
str2 = 'helloworlda'
new_str = sorted(str2)
print(new_str) # ['a', 'd', 'e', 'h', 'l', 'l', 'l', 'o', 'o', 'r', 'w']
print(''.join(new_str)) # adehllloorw
- clear
列表.clear() -- 删除列表中所有的元素(清空列表)
nums = [100, 60, 34, 101]
print(id(nums))
nums = []
nums.clear()
print(nums, id(nums))
7.copy
列表.copy() -- 相当于列表[:], 将列表中的元素拷贝一份产生一个新的列表（浅拷贝）
nums = [100, 60, 34, 101]
new_nums = nums.copy()
print(nums, new_nums)
print(id(nums), id(new_nums))
new_nums2 = nums # 一个变量给另一个变量赋值，赋的是地址
new_nums2.insert(0, 1000)
print(new_nums2, nums)
元组
1.什么是元组（tuple)
元组是python提供的容器型数据类型，不可变(特色），有序
元组就是不可变的列表，一般保存一些不让修改的数据
2.获取元素和列表一样
（元素1,元素2,元素3....) 元组是小括号括起来，里面用逗号隔开
#空的元组
tuple1=()
print(tuple1,type(tuple1))
元素个数是1的元组:如果一个元组里面只有1个元素，这个元组里面必须要加逗号
tuple2=(19,)
print(tuple2,type(tuple2))
3.获取元素：和列表一样
tuple2=('周一','周二','周三','周四','周五')
print(tuple2[1:])
print(tuple2[2])
for item in tuple2:
print(item)
1)让变量的个数和元组中元素的个数保持一致，来一一获取元组中每一个元素的值
point =(100,50)
x,y=point
print('x',x,'y:',y)
a,b,c,=10,3,3
2)元组数据中小括号可以省略（多个数据直接用逗号隔开，实际表示的是一个元组）
tuple3=10,23,23,32
3)让多个变量同时获取元组中的元素的时候，可以在一个变量前加将这个变量变成一个列表，
来获取不带的变量获取后剩下的数据，带*号的变量只能有一个
student = ('小明',18,3,23,45)
print(student[1])
name,age,*scores=student # 带*号的只有一个
print(name,age,scores)
name,*scores,age=student
print(name,scores,age)
字典
1.什么是字典（dict）
字典是python提供的容器型数据类型(序列），可变，无序
2.字典中的元素
{键值对1，键值对2，键值对3...}--字典的元素就是键值对
键值对--以'键':'值'的形式成对出现
键(key)--必须是不可变的数据才可以为键，要求不可变，唯一,建议用字符串作为key，用来对值进行说明和区分）
值(value)--任何类型的数据都可以做为值
dict1 = {10:100,'b':True,'name':100,(1,2):100,'d':{'a':2}}
print(dict1)
3.元素的操作
1)查--获取值
字典[key]--获取字典中key对应的值 （如果key不存在会报错!程序崩溃）
字典.get(key) -获取字典中key对应的值,(如果没有会None,否则默认值)
dog = {'name':'周天子','color':'黄色','age':3}
print(dog['color']) #key 不存在会报错
print(dog.get('name'))
print(dog.get('genden')) #这种get方式不存在的话会报"None"
print(dog.get('geng','公狗')) #公狗
2)遍历字典
直接通过for循环遍历字典的时候，获取到的是所有的key (直接遍历)
for key in dog: # 直接遍历，实际开发用
print(key,dog[key])
for value in dog.values(): # 间接遍历
print(value)
3)字典的增加，修改
字典[key] = value -如果key 存在，修改key对应的值；如果key不存在，添加键值对
class1 = {'name':'py1902','address':'19楼'}
class1['num']=50 #增加
print(class1) #{'name': 'py1902', 'address': '19楼', 'num': 50}
class1['name']='java1209' #修改
print(class1)
4)删除
1.del 字典[key] --删除字典中指定key对应的键值对，如果key不存在会报错
2.字典.pop(key) --取出字典中key对应的值，如果key不存在会报错
class2 = {'name':'py1902','address':'19楼'}
del class2['name']
print(class2) #{'address': '19楼'}
class2.pop('address')
print(class2)
4.字典的相关操作
1)运算符不支持数学运算,比较运算符只支持比较相等不支持比较大小
print({'a':100,'b':23} == {'b':24,'a':100})
2)in/not in
key in 字典 --判断字典中是否存在指定的key
class2 = {'name':'py1902','address':'19楼'}
print('name' in class2) #True
3)len
print(len(class2)) #判断键值对对数
4)dict 转化
能转换成字典的数据要求数据本身是序列，序列中的每个元素也是长度是2的序列，并且小序列中第一个元素是不可变的
data = [(1,2),['a',23]]
print(dict(data))
dict2 = {'a':10,'b':13}
print(list(dict2))
5.相关方法
1)clear
字典.clear()--清空字典
dict2 = {'a':10,'b':13}
dict2.clear()
print(dict2)
2)copy
字典.copy --拷贝字典中的键值对产生一个新的字典
dict2 = {'a':10,'b':13}
dict3=dict2.copy()
dict3['a']=100
print(dict2) #{'a': 10, 'b': 13} ,字典中的值并没有变
print(dict3)
3）fromkeys(序列，值） --创建一个新的字典，字典的key是序列的元素，key对应的value是值
dict.fromkeys
new_dict=dict.fromkeys('hello',100)
print(new_dict) #{'h': 100, 'e': 100, 'l': 100, 'o': 100}
4)keys,values,items
字典.keys()--获取字典中所有的key,结果是一个序列
字典.values()--获取字典中所有的value,结果是一个序列
字典.items() --获取字典中的key和value,key 和value以元组的形式返回
5)setdefault --添加键值对（不能修改）
字典.setdefault(key,value)
6)update(字典2） -使用字典2中的键值对去更新字典1（不存在添加，存在修改）
dict1={'a':1,'b':1,'c':3}
dict2={'b':100,'c':23,'e':23}
dict1.update(dict2)
print(dict1)
集合
1.什么是集合
容器型数据类型（序列），可变、无序（不支持下标操作）
2.集合中的元素
{元素1，元素2，元素3....}
元素：不可变，唯一（自带去重的功能）
注意：{}大括号不能表示空的集合，set()-空集合
set1 =set()
print(set1)
set2 = {1,'abc',(1,3),False,} #TypeError: unhashable type: 'list'
print(set2) #{False, 1, (1, 3), 'abc'}
集合可以去重
str1='adsdasdjksagifh'
print(''.join(set(str1)))
3.元素的操作
1）查
集合不但单独的获取指定的某一个元素，只支持遍历
set3={1,2,3,4,42,30,23}
for x in set3:
print(x)
2)增加
1.集合.add(元素) --往集合中添加一个元素
2.集合.update(序列） -将序列的元素添加到集合中（自带去重）
set1={1}
set1.add(100)
print(set1)
set1.update('abc')# {1, 100, 'a', 'c', 'b'}
print(set1)
set1.update({'name':'张三'})
print(set1)
3)删除
集合.remove(元素) --删除集合中指定的元素 {元素不存在会报错}
"""
4.数学集合运算
set1={1,2,3,4,5,6}
set2={4,5,6,7,8}
#1)并集：两个集合合并在一起，产生一个新的集合
#print(set1 | set2)
#2)交集：&--求两个集合公共的部分
#print(set2 & set1)
3)差集：集合1-集合2 --获取集合1中除了集合2以外的部分，
print(set1-set2)
4）补集：集合1^集合2 ，求两个集合中除了公共部分以外的部分
print(set1^set2)
5)包含关系
集合1>=集合2 --集合1中是否包含集合2
集合1<=集合2 --集合2中是否包含集合1
print({5,6,4,2}>={3.2}) #False
