1.列表(list)

容器型数据类型(序列),可变(增删改)、有序(支持下表操作)

2.元素

任何类型的数据都可以作为列表元素

3.元素的增删改查

"""
1.查
查单个元素:列表[下标]
查部分元素:列表[开始下标:结束下标:步长]
遍历:直接遍历、遍历下标

2.增

列表.append(元素0)、列表.insert(下标,元素)

list1 = (1, 2, 3, 4, 5, 6, 7)

3.删
del 列表[下标]
列表.remove(元素) #多个重复元素删除第一个
列表.pop() 列表.pop(下标) #将列表最后一个元素取出来

4.改
列表[下标] = 新值
"""

4. +， *， ==，!=，in/not in(判断一个元素是在列表里面存在),len(),list()序列才能转换成列表,序列中的元素单独拿出来作为元素

5.列表常用方法

1) count

"""
列表.count(元素) -- 统计列表中指定元素的个数
"""
nums = [1, 34, 6, 8, 1]
print(nums.count(1))

2.)extend

"""
列表.extend(序列) -- 将序列中元素全部添加到列表中
"""
nums.extend('abc')
print(nums)
nums.extend([100, 'abc', 'name'])
print(nums)
nums.extend({'age': 18})
print(nums)

3.)index

"""
列表.index(元素) -- 获取指定元素对应的下标(如果元素有多个只取第一个)
注意:如果元素不存在会报错
"""
nums = [100, 60, 34, 100]
print(nums.index(34))

4)reverse

"""
列表.reverse() -- 反向列表(直接修改原列表)

reversed(序列) -- 反向序列,不修改原序列而是产生新的序列(迭代器)
"""
nums.reverse()
print(nums)

nums = [100, 60, 34, 100]
new_nums = reversed(nums)
print(nums, list(new_nums))

str1 = 'hello'
new_str = reversed(str1)
print(str1, ''.join(list(new_str)), str1[::-1])

字符串.join(序列)

5)sort

"""
列表.sort() -- 将列表中的元素升序排序(从小到大)
列表.sort(reverse = True) -- 将列表中的元素降序排序(从大到小排序)

sorted(序列) -- 排序的时候不修改原序列，产生新的序列
注意:能够进行排序的列表总要求列表中的元素类型一致并且支持比较运算
"""
nums = [100, 60, 34, 100]

nums1.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) # [100, 60, 34, 101]

new_nums = sorted(nums, reverse=True) # 从大到小排序
print(new_nums) # [101, 100, 60, 34]
str2 = 'helloworld'
new_str = sorted(str2)
print(new_str) # ['d', 'e', 'h', 'l', 'l', 'l', 'o', 'o', 'r', 'w']
print(''.join(new_str)) # adehllloorw

6) clear

"""
列表.clear() -- 删除列表中所有的元素(清空列表)
"""
nums = [101, 100, 60, 34]
print(id(nums))
nums = []
print(id(nums))

nums.clear()

print(nums)

7.copy

"""
列表.copy() -- 相当于列表[:],将列表中的元素拷贝一份产生一个新的列表(浅拷贝)
"""
nums = [101, 100, 60, 34]
new_nums = nums.copy()
print(id(nums), id(new_nums))

new_nums2 = nums # 一个变量给另一个变量赋值，赋的是地址
new_nums2.insert(0, 1000)
print(new_nums2, nums)

1.什么是元祖(tuple)

元祖是python提供的容器型数据类型(序列),不可变(特色)，有序

元祖就是不可变的列表,一般保存一些不让修改的数据

(元素1， 元素2， 元素3...)

2.元素

空的元祖

tuple1 = ()
print(type(tuple1), tuple1)

1) 元素个数是1的元祖: 如果一个元祖中只有一个元素，这个元素后面必须加逗号！

tuple2 = (10,)
print(tuple2, type(tuple2))

2)元祖数据中小括号可以省略。(多个数据直接用逗号隔开，实质表示的是一个元祖)

tuple3 = 10, 23, 89, 10, '小米'
print(tuple3, type(tuple3))

3.获取元素: 和列表一样

tuple2 = ('周一', '周二', '周三', '周四', '周五')
print(tuple2[1])
print(tuple2[2:])
for item in tuple2:
print(item, end= " ")

1.让变量的个数和元祖中元素的个数保持一致,来一一获取元祖中每个元素的值

point = (100, 50)
x, y = point
print('x:', x, 'y', y)

a, b, c = 10, 20, 30 # a, b, c = (10, 20, 30)

2) 让多个变量同时获取元祖中的元素的时候，可以在一个变量前加*号

将这个变量变成一个列表，来获取不带号的变量获取后剩下的数据。(注意:带号的半两只能有一个)

student = ('小米', 18, 89, 68, 89, 90)
name, age, *scores =student
print(name, age, scores)

name, *scores, age = student
print(name, age, scores)

*items, a, b = student
print(item, a, b)

tuple4 = (10, 20)
print(*tuple4) # print(10, 20)

new_tuple4 = tuple4
print(new_tuple4)

1.什么是字典(dict)

字典(哈希)是python提供的容器型数据类型(序列),可变,无序

2.字典中的元素

{键值对1， 键值对2， 键值对3,....} - 字典的元素就是键值对

键值对 - '键：值'的形式成对出现，

键(key) - 要求不可变,唯一 (建议用字符串作为key，用来对值进行说明和区分的)

值(value) - 任何类型的数据都可以作为值

dict1 = {10: 100, 'name': 100, (1, 2): 100, 'a': 'abc', 'b': True, 'c': [1, 2], 'd': {'a': 2}}
print(dict1)

dict2 = {10: 100, 'name': 100, [1, 2]: 100} #TypeError: unhashable type: 'list'

dict1 = {10: 100, 'name': 100, {'a': 1}: 100} #TypeError: unhashable type: 'dict'

3.元素的操作

1)查 - 获取值

"""
1.字典[key] - 获取字典中key对应的value,如果key不存在会报错.
2.字典.get(key) - 获取字典中key对应的value，如果key不存在不报错，结果是None
字典.get(key, 默认值)- 获取字典中key对应的value，如果key不存在不报错，结果是默认值
"""
dog = {'name': '旺财', 'color': '黄色', 'age': 3, 'type': '土狗'}
print(dog['type'])

print(dog['gender']) # KeyError: 'gender'

print(dog.get('name'))
print(dog.get('gender')) # None
print(dog.get('age', 100))
print(dog.get('gender', '公狗'))

key = 'age'

print(dog.get(key))

print(dog[key]) # 3

"""
3.遍历字典
直接通过for循环遍历字典的时候，获取到的是所有的key
"""

1.直接遍历(只用这个)

print('-----------------')
for item in dog:
print(item, dog[key])

2.间接遍历

print('------------')
for value in dog.values():
print(value)

print('--------------')
for key, value in dog.items():
print(key, value)

2)增/改

"""
字典[key] = value - 如果key存在,修改key对应的值;如果key不存在，添加键值对
"""
class1 = {'name': 'py1902', 'address': '19楼5教室'}
print(class1)

增

class1['number'] = 50
print(class1) # {'name': 'py1902', 'address': '19楼5教室', 'number': 50}

改

class1['name'] = 'python1902'
print(class1)

3) 删

"""
1.del 字典[key] - 删除字典中指定key对应的键值对。如果key不存在会报错
2.字典.pop(key) - 取出字典中key对应的值。如果key不存在会报错
"""
class2 = {'name': 'python1902', 'address': '19楼5教室', 'num': 50}
del class2['num']
print(class2) # {'name': 'python1902', 'address': '19楼5教室'}

class2.pop('name')
print(class2)

4.字典相关操作

1)运算符:不支持数学运算,比较运算符只支持比较相等,不支持比较大小

print({'a': 100, 'b': 10} == {'b': 100, 'a': 10}) # 支持比较运算符

2) in / not in

key in/ not in 字典 - 判断字典中是否存在指定的key

print('-----------')
class2 = {'name': 'python1902', 'address': '19楼5教室', 'num': 50}

print('name' in class1) - True

print(50 not in class1) - True

3) len

print(len(class2))

4) dict

"""
能转换成字典的数据要求:数据本身是序列，序列中的每个元素也是长度2的序列，并且小序列中第一个元素是不可变的
"""
data = [(1, 2), ['a', 23]]
print(dict(data))

dict2 = {'a': 10, 'b': 20}
print(list(dict2)) # ['a', 'b']

5.相关方法

1)clear

"""
字典.clear() - 清空字典
"""
dict2 = {'a': 10, 'b': 20}
dict2.clear()
print(dict2)

2)copy

"""
字典.copy() - 拷贝字典中的键值对产生一个新的字典
"""
dict2 = {'a': 10, 'b': 20}
dict3 = dict2
dict3['a'] = 100
print(dict2) # {'a': 10, 'b': 20}

dict2 = {'a': 10, 'b': 20}
dict3 = dict2.copy()
dict3['a'] = 100
print(dict2) # {'a': 10, 'b': 20}

3)formkeys

"""
dict.fromkeys(序列，值) - 创建一个新的字典,字典的key是序列的元素,key对应的value是值
"""
new_dict = dict.fromkeys('hello', 100)
print(new_dict)

4)keys, values, items

"""
字典.key() - 获取字典中所有的key,结果是一个序列
字典.values() - 获取字典中所有的value,结果是一个序列
字典.items() - 获取字典中的key和value.key和value以元祖的形式返回
"""
students ={'name': '张三', 'age': 18, 'stu_id': "stu001", 'gender': "男"}
print(students.keys())
print(students.values())
print(students.items())

5)setdefault

"""
字典.setdefault(key, value) - 添加键值对
"""
students.setdefault('tel', '18803091680')
print(students)

6)update

"""
字典1.update(字典2) - 使用字典2中的键值对去更新字典1(不存在添加、存在修改)
"""
dict1 = {'a': 1, 'b': 2, 'c': 3}
dict2 = {'b': 200, 'd': 300, 'e': 400}
dict1.update(dict2) # 结果: {'a': 1, 'b': 200, 'c': 3, 'd': 300, 'e': 400}
print(dict1)

1.什么是集合(set)

容器型数据类型(序列),可变、无序

2.集合中的元素

{元素1, 元素2. 元素3,....}

元素: 不可变、唯一(自带去重功能)

注意: {}不能表示空的集合,set() - 空集合

set1 = set()
set2 = {1, 'abc', (1, 3), False, 1, 1, 1}

set2 = {1, 'abc', (1, 3), False, [1, 2]}

print(set2) # TypeError: unhashable type: 'list'

print(set2) # {(1, 3), 1, 'abc', False}

str1 = 'ssadjkasdkajkjkjsa'
print(''.join(set(str1)))

list1 = [1, 34, 43, 2, 2]
print(list(set(list1)))

3.元素相关的操作

1)查

集合不能单独获取指定的某一个元素，只支持遍历

print("-----------")
set3 = (1, 2, 3, 44, 5, 21)
for x in set3:
print(x)

2)增

"""
集合.add(元素) - 往集合中农添加一个元素
集合.upade(序列) - 将系列中的元素添加到集合中(自带去重)
"""

set1 = {1}
print(set1)
set1.add(100)
print(set1)
print('---------')
set1.update({'name': '张三', 'age':20})
print(set1) # {'age', 1, 'name', 100}

3)删

"""
集合.remove(元素) - 删除元素中指定的元素
"""

set4 = {'age', 1, 'name',100}
set4.remove(100)
print(set4)

(*)4.数学集合运算

set1 = {1, 2, 3, 4, 5, 6}
set2 = {2, 3, 4, 5, 6, 7}

两门课:class1, class2

1)并集: |

"""
集合1 | 集合2 - 将两个集合中的元素合并产生新的集合
"""
print(set1 | set2)

2）交集: & - 求两个集合公共的部分

print(set1 & set2)

3)差集: 集合1 - 集合2 --- 获取集合1中除了集合2以外的部分

print(set1 - set2) # {1}
print(set2 - set1) # {7}

4)补集:集合1^集合2 --- 两个集合除了公共部分以外的部分

print(set1 ^ set2)

5)包含关系

"""
集合1 >= 集合2 - 集合1中是否包含集合2
集合1 <= 集合2 - 集合2中是否包含集合1
"""
print({5, 6, 7, 8, 9} >= {1,2, 3}) # False
print({5, 6, 7, 8, 9} >= {5, 9}) # True