python字典和集合属于符号_python 字典和集合

一、复习(列表)

1.容器，可以同时存放多个数据。可变，有序

2.元素，可以是任何类型的数据，一个列表可以同时存放不同类型的数据

3.元素的增删改查

查 --> 列表[下标]， 列表[:]，列表[::]，遍历

增 --> append(元素), insert(下标,元素), extend(序列)

删除 --> del 列表[下标], remove(元素), pop(),pop(下标), clear()

改 --> 列表[下标] = 新值

4.+, *, ==, is, in, not in, len(), max(), min(), list()

二、元祖

1.什么是元祖

使用()将多个元素括起来，多个元素之间用逗号隔开

a.

容器，可以同时存储多个数据,不可变的，有序的

不可变 ---> 不能增删改

有序 ---> 可以通过下标获取元素

b.

元素，可以是任何类型的数据

tuple1 = (1, 'yue', True, [1, 2], lambda s:s*2)

print(tuple1)

注意：1.如果元祖的元素只有一个的时候，必须在元素的后面加逗号

tuple2 = (100,)

print(type(tuple2))

2.多个数据直接用逗号隔开，表示的也是一个元祖

tuple2 = 10, 20, 'abc'

print(tuple2, type(tuple2))

2.元素的查

元祖的元素不支持增删改

列表获取元素的方式，元祖都支持：元祖[下标],

元祖[:], 元祖[::]

遍历：和列表一样

tuple2 = ('星期一', '星期二', '星期三', '星期四')

print(tuple2[1]) 星期二

print(tuple2[2:]) ('星期三', '星期四')

print(tuple2[::-1]) ('星期四', '星期三', '星期二', '星期一')

遍历

for item in tuple2:

print(item)

index = 0

while index < len(tuple2):

print(tuple2[index])

index += 1

补充：获取部分元素

可以通过相同的变量个数，来一一获取元祖中的元素

x, y = (10, 20)

print(x, y) 10 20

x, y, z = (10, 20, 30)

x, y = 10, 20

1.应用：交换两个数的值

a = 10

b = 20

方法1：

t = a # t = 10

a = b # a = 20

b = t # b = 10

方法2：

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

可以通过在变量前加*来获取部分的元素(适用于列表)

tuple2 = ('小明', 90, 89, 67, 100)

name, *score = tuple2

print(name, score) # 小明 [90, 89, 67, 100]

tuple2 = (90, 89, 67, 100, '小明')

*score, name = tuple2

print(score, name) # [90, 89, 67, 100] 小明

tuple2 = ['boy', 15300022673, 90, 89, 67, 100, '小明']

sex, tel, *score, name = tuple2

print(sex, name, score) # boy 小明 [90, 89, 67, 100]

(了解)

可以通过在列表或者元祖前加*,来展开列表中的元素

tuple3 = (1, 2, 3, 4)

print(*tuple3) # 1 2 3 4

list1 = ['abc', 100, 200]

print(*list1) # abc 100 200

3.元祖的运算

+, *, ==, is, in, not in ---> 和列表一样

print((1, 2, 3) + ('a','b')) #(1, 2, 3, 'a', 'b')

print((1, 2) * 3) # (1, 2, 1, 2, 1, 2)

print((1, 2, 3) == (1, 2, 3)) # True

print((1, 2, 3) is (1, 2, 3)) # False

print(1 in (1, 2, 3)) # True

print(1 not in (1, 2, 3)) # False

4.len(), max(), min()

tuple3 = 10, 230, 100, 78, 34

print(len(tuple3)) # 5

print(max(tuple3)) # 230

print(min(tuple3)) # 10

5.tuple()

所有的序列都可以转换成元祖，注意，字典只能将key值作为元祖元素

print(tuple('abhdnc')) # ('a', 'b', 'h', 'd', 'n', 'c')

print(tuple([1, 23, 90])) # (1, 23, 90)

print(tuple(range(5))) # (0, 1, 2, 3, 4)

print(tuple({'a': 100, 'b': 200})) # ('a', 'b')

6.sorted()

可以通过sorted()方法，对元祖进行排序，产生一个新的列表

tuple3 = 10, 230, 100, 78, 34

new = sorted(tuple3)

print(new, tuple3) # [10, 34, 78, 100, 230] (10, 230, 100, 78, 34)

tuple1 = (1, 'yue', True, [1, 2], lambda s:s*2)

print(tuple1) #(1, 'yue', True, [1, 2], at 0x0000000001E83F28>)

三、认识字典

什么时候用容器类型的数据？ ---> 需要同时保存多个数据的时候

什么时候用列表？ ---> 保存的多个数据是同一类的数据(不需要区分)

什么时候用字典？ ---> 保存的多个数据是不同类的数据 (需要区分)

1.什么是字典(dict)

字典是一个容器类的数据类型，可以用来存储多个数据(以键值对的形式存储)。可变的，无序的

{key1:value1, key2:value2...}

可变 ---> 可以增删改

无序 ---> 不能通过下标获取值

键(key): 用来定位值的。要求只能是不可变的数据类 型(数字，字符串，元祖...)。是唯一的

值(value): 存储的数据。可以是任何类型的数据

person1 = ['yuting', 18, 90, 100, '1547262889']

person2 = {'name': 'yuting', 'age': 18, 'face': 90,

'score': 100, 'tel': '1547262889', 'name':'小花'}

dict1 = {10: 893, 'abc': 100, (1, 23): 'abc'}

print(person2) # {'name': '小花', 'age': 18, 'face': 90,

# 'score': 100, 'tel': '1547262889'}

dict1 = {}

print(dict1) # {}

四、字典的增删改查

1.查(获取键值对的value)

获取字典的值，必须通过key来获取

a.字典[key] ---> 获取key对应的值

注意：key值必须是存在的，否则会报KeyError

student = {'name': '小明', 'age': 30, 'study_id': 'py001',

'sex': 'boy'}

print(student['name']) # 小明

print(student['sex']) # boy

b.字典.get(key) ---> 通过key获取值

注意：key值不存在的时候不会报错，结果是None

print(student.get('age'), student.get('study_id')) #30 py001

print(student.get('score')) # None

确定key一定存在就是使用[]语法，key可能不存在的时候使用get语法

c.直接遍历字典(推荐使用)

通过for-in遍历字典拿到的是key值

for x in student:

print(x, student[x])

d.其他遍历方式(了解)

直接遍历拿到值

for value in student.values():

print(value)

直接拿到key和value

print(student.items())

for key, value in student.items():

print(key, value)

2.增(添加键值对)

字典[key] = 值(key不存在)

car = {}

car['color'] = 'yellow'

print(car) # {'color': 'yellow'}

car['price'] = 300000

print(car) # {'color': 'yellow', 'price': 300000}

3.修改(修改值)

字典[key] = 新值 (key存在)

car['color'] = 'red'

print(car) # {'color': 'red', 'price': 300000}

4.删 (删除键值对)

a. del 字典[key] ---> 通过key删除键值对

student = {'name': '小明', 'age': 30, 'study_id': 'py001',

'sex': 'boy'}

del student['age']

print(student)

# {'name': '小明', 'study_id': 'py001', 'sex': 'boy'}

b. 字典.pop(key) ---> 取出key对应的值(实质还是删除key对应的键值对)

name = student.pop('name')

print(student, name)

# {'study_id': 'py001', 'sex': 'boy'} 小明

五、字典的相关操作

1.字典相关运算

==: 判断两个字典的值是否相等

is: 判断两个字典的地址是否相等

in 和 not in: key in 字典 / key not in 字典 ---> 判断key是否存在

dic1 = {'a': 1, 'b': 2}

aa = dic1

print(dic1 is aa) T

print({'a': 100, 'b': 200} == {'b': 200, 'a': 100}) T

print({'a': 100, 'b': 200} is {'b': 200, 'a': 100}) F

print('abc' in {'abc': 100, 'a': 200}) T

print('abc' in {'100': 'abc', 'a': 200}) F

2.字典相关的函数和方法

len(字典) --> 获取键值对的个数

dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4}

print(len(dict1)) # 4

2.字典.clear() --> 清空字典

dict1.clear()

print(dict1) # {}

3.字典.copy() --> 将字典中的键值对复制一份产生一个新的字典

dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4}

dict2 = dict1.copy()

print(dict2, dict1 is dict2)

# {'a': 1, 'b': 2, 'c': 3, 'd': 4} False

4.dict.fromkeys(序列, 值) --> 创建一个字典，将序列中的每个元素作为key，值作为value

dict3 = dict.fromkeys('xyz', 100)

print(dict3) # {'x': 100, 'y': 100, 'z': 100}

dict3 = dict.fromkeys(['aa', 'bb', 'cc'], (1, 2))

print(dict3) # {'aa': (1, 2), 'bb': (1, 2), 'cc': (1, 2)}

字典.get(key) --> key不存在取None

字典.get(key,默认值) --> key不存在取默认值

student = {}

print(student.get('name')) # None

print(student.get('name', '无名')) # 无名

字典.values() --> 返回所有值对应的序列

字典.keys() --> 返回所有键对应的序列

字典.items() --> 将键值对转换成元祖，作为一个序列的元素

注意：返回的都不是列表，是其他类型的序列

dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4}

items = list(dict1.items())

print(items, type(items))

# [('a', 1), ('b', 2), ('c', 3), ('d', 4)]

print(dict1.items(), type(dict1.items()))

# dict_items([('a', 1), ('b', 2), ('c', 3), ('d', 4)])

字典.setdefault(key) --> 添加键值对，键是key，值是None

字典.setdefault(key,value) --> 添加键值对，键是key，值是value

注意：key存在的时候，对字典不会有任何操作(不会修改key对应的值)

dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4}

dict1.setdefault('aa')

print(dict1)

# {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'aa': None}

8.字典1.update(字典2) --> 使用字典2中键值对去更新字典1。(已经存在的key就更新，不存在就添加)

dict1 = {'a': 1, 'b': 2}

dict2 = {'b': 200, 'c': 100}

dict1.update(dict2)

print(dict1) # {'a': 1, 'b': 200, 'c': 100}

六、集合

1.什么是集合(set)

容器，可以同时存储多个数据,可变的，无序的,元素是唯一的

可变 --> 增删改

无序 --> 不能通过下标获取元素

唯一 --> 自带去重的功能

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

元素：只能是不可变的数据

set1 = {10, 20, 'abc', (10, 200), 10}

print(set1) # {(10, 200), 10, 20, 'abc'}

# set2 = {} # 这个是空的字典

2.集合的增删改查

a.查(获取元素)

集合不能单独的获取一个元素，也不能切片，只能通过for-in来遍历

for x in set1:

print(x)

b.增(添加元素)

集合.add(元素) --> 在集合中添加一个元素

set1 = {1, 2, 3}

set1.add(4)

print(set1) # {1, 2, 3, 4}

集合1.update(序列) --> 将序列中的元素添加到集合1中

set1.update({'a', 'b'})

print(set1) # {'a', (10, 200), 20, 10, 'b', 'abc'}

set1.update('0987')

print(set1)

# {10, 'b', 'abc', 20, '8', '7', (10, 200), 'a', '9', '0'}

set1.update(['abc', 'aaa'])

print(set1)

# {10, 'b', 'abc', 20, '8', '7', (10, 200), 'aaa',

# 'a', '9', '0'}

set1.update({'name': 1, 'age': 18}) # 字典只添加key

print(set1)

# {10, 'b', 'abc', 20, 'name', '8', 'age', '7',

# (10, 200), 'aaa', 'a', '9', '0'}

3.删(删除元素)

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

set1.remove(1)

print(set1) # {2, 3, 4}

4.改(集合不能改)

七、集合相关的数学运算

集合相关的运算: 是否包含，交集、并集、差集、补集

1.包含

集合1 >= 集合2 ---> 判断集合1之中是否包含集合2

集合2 <= 集合2 ---> 判断集合2之中是否包含集合1

set1 = {1, 2, 3, 4, 5, 10}

set2 = {3, 4, 1}

print(set1 >= set2) # T

2.交集 -> &

& --> 求两个集合公共的部分

set1 = {1, 2, 3, 4, 5}

set2 = {1, 2, 3, 10, 20}

print(set1 & set2) # {1, 2, 3}

3.求并集

| --> 求两个集合的和

print(set1 | set2) # {1, 2, 3, 4, 5, 10, 20}

4.求差集

集合1-集合2 --> 求集合1中除了集合2以外的部分

print(set1 - set2) # {4, 5}

5.求补集

^ --> 求两个集合除了公共部分以外的部分

print(set1 ^ set2) # {20, 4, 5, 10}

八、类型转换

1.整型

int()

浮点数、布尔、部分字符串可以转换成整型。

只有去掉引号后本身就是一个整数的字符串才能转换成整型

print(int('34')) 34

print(int('+45')) 45

print(int('-90')) -90

# print(int('34.5')) # ValueError

2.浮点数

整数，布尔，部分字符串可以转换成浮点数

去掉的引号，本身就是一个数字的字符串才能转换成浮点数

print(float(100)) # 100.0

print(float(True)) # 1.0

print(float('34.90')) # 34.90

print(float('100')) # 100.00

3.布尔

所有的数据都可以抓换成布尔值

为空为0的值转换成False, 其他的数据都转换成True

print(bool('abchd')) # True

print(bool('False')) # True

print(bool('')) # False

print(bool([1, 2, 3])) # True

print(bool([])) # False

print(bool({'a': 1})) # True

print(bool({})) # False

print(bool(())) # F

print(bool(0.00)) # F

print(bool(None)) # F

num = 100

if num == 0:

print('是0')

if not num:

print('是0')

names = [23]

if names:

print('不是空')

else:

print('是空')

num = 230

if num % 2:

print('是奇数') # 不是空

else:

print('是偶数') # 是偶数

4.字符串

str()

所有的数据都可以转换成字符串

数据转换成字符串，就是在数据的最外面加引号

print([str(100)])

print([str(True)])

print([str([1, 2, 3])])

print([str({'a': 1, 'b': 2})])

print([str(lambda x: x*2)])

list_str = str([1, 2, 3])

print(len(list_str))

5.列表

list()

序列才能转换成列表。

将序列中的元素作为列表的元素。字典转换成列表，将字典的key作为列表的元素

print(list('styui'))

print(list((23, 45, 'ac')))

print(list({'a': 100, 'b': 89}))

print(list({'a': 100, 'b': 89}.items()))

6.元祖(和列表一样)

tuple()

只能将序列转换成元祖

print(tuple('ancbd'))

print(tuple({'a': 100, 'b': 89}))

7.字典

dict()

序列的每个元素有两个元素的数据才能转换成字典

list1 = [(1, 2)]

print(dict(list1))

tuple1 = ((1, 8), {'a', 'b'})

print(dict(tuple1))

8.集合

set()

序列可以转换成集合，有去重的功能

print(set([1, 1, 90, 3, 10, 10]))

九、作业

用一个变量来保存一个班级的学生信息，学生信息包括:姓名、学号、成绩(英语、体育、美术、数学)、年龄

b.给这个班级添加学生

c.根据姓名查看班级里的某个学生的信息

d.根据姓名删除一个指定的学生信息

e.查看班级的所有的学生信息

f.求指定的学生平均成绩

x = []

score = {}

name = input('请输入你的姓名')

age = input('请输入你的年龄')

number = input('请输入你的学号')

scores['math'] = input('请输入你的数学成绩')

scores['English'] = input('请输入你的英语成绩')

scores['art'] = input('请输入你的美术成绩')

scores['sport'] = input('请输入你的体育成绩')