01-列表

增、删、改、查
1、修改列表元素
- 通过下标获取元素，然后重新赋值：列表名[下标] = 新的值
- 这的下标不能越界

names = ['周星驰', '张家辉','刘德华', '黄渤', '杨洋']
names[4] = '陈奕迅'
# names[-1]
print(names)

输出结果：
['周星驰', '张家辉', '刘德华', '黄渤', '陈奕迅']

2、列表的其他操作
- 1.len(列表)：获取列表长度（元素的个数）
- 2.列表1 + 列表2：让列表1和列表2的元素组合在一起产生一个新的列表
- 3.列表 * 数字：让列表里面的元素重复N次，产生一个新的列表

print(len([1, 2, 3, 4, 5]))
print(len(names))

输出结果：
5

- 1. in, not in操作
    元素 in 列表：判断指定的元素是否在指定的列表中

result = '高以翔' not in names
print(result)

输出结果：
True

3、获取列表中的最大的元素和最小的元素
- max(列表)
- min(列表)
获取一个数字列表中的最大值

numbers = [1, 2, 32, 54, 56, 799, 23]
i = 0
a = numbers[0]
for x in numbers:
    if x > a:
        a = x
print(a)

输出结果：
799
1
799

其他方法
- 1.count ：获取指定元素在列表中出现的次数

print(numbers.count(2))

输出结果：
1

2.extend(序列)：将序列中的每一个元素，添加到列表中

names.extend(['王祖贤'])
print(names)

输出结果：
['周星驰', '张家辉', '刘德华', '黄渤', '陈奕迅', '王祖贤']

3.列表.index（元素）：获取指定元素在指定列表中的索引（如果有多个元素，则取第一个）

print(names.index('张家辉'))

输出结果：
1

4.列表.reverse()：反向列表中的元素(直接操作的原列表，不会产生新的列表)

numbers = [1, 25, 13, 4]
numbers.reverse()
print(numbers)

输出结果：[4, 13, 25, 1]

5.列表.sort():对列表元素进行排序（默认是从小到大排序 - 升序）

numbers.sort()  # 升序
print(numbers)
numbers.sort(reversed=True)  # 降序
print(numbers)

输出结果：
[1, 4, 13, 25]
[25, 13, 4, 1]

6.列表.clear():清空列表中的元素

numbers.clear()
# numbers = []  (效果同上)
print(numbers)

输出结果：
[]

7.列表.copy():将列表中的元素全部拷贝一份，创建一个新的列表

names = ['张三', '李四']
new_names1 = names.copy()
# new_names = names[:]
print(new_names1)

输出结果：
['张三', '李四']

注意：通过一个列表变量给另一个列表变量赋值的时候，赋得是地址。两个列表对元素进行操作时都会相互影响，想要避免这个问题就使用copy或者切片

02-元组

什么是元组
- 元组就是不可变的列表，列表中除了可变的操作以外，其他的操作都是用于元组
- 元组值：
  a.使用（）将元素包含起来，多个元素之间用逗号隔开，比如：（1， 2，3）
  b.元素的类型可以是任何类型
- 2.增、删、改相关操作不能作用于元组。查可以

colors = ('red', 'green', 'yellow', 'purple')

1.查(和列表的查一模一样，没有任何区别)

print(colors[1])
print(colors[0:3])
print(colors[0::2])
for item in colors:
    print(item)

输出结果：
green
('red', 'green', 'yellow')
('red', 'yellow')
red
green
yellow
purple

2.len()

print(len(colors))

输出结果：
4

3.in, not in

print('red' in colors)

输出结果：
True

4.+和*

print((1, 2) + (3, 4))
print((1, 2) * 2)

输出结果：
(1, 2, 3, 4)
(1, 2, 1, 2)

5.元组补充：

获取元组的元素

names = ('aaa', 'bbb', 'ccc')
x, y, z = names  # 通过多个变量分别获取元组的元素（变量个数与元组个数一样）

names = ('aaa', 'bbb', 'ccc', 'ddd')
first, *midel, last = names  # 通过变量名前加*可以把变量变成列表，获取多个元素
print(first, midel, last)

输出结果：
aaa ['bbb', 'ccc'] ddd

03-字典

字典也是一种容器类型的数据类型（序列），存的数据是以键值对的形式出现的，字典中的元素，全部都是键值对
字典是可变的（可以增删改），但是是无序的（不能使用下标）
键是唯一的
- 键值对：键:值（key:value）；键值对中key是形式，value才是真正要存的内容
- 键：理论上可以是任何不可变的数据类型，但是实际开发的时候一般使用字符串作为key
- 值：任何数据类型都能作为值
1.声明一个字典
- a.创建一个字典变量

dict1 = {}  # 创建一个空的字典
print(type(dict1))
dict2 = {'a': 1, 'b': 'abc', 10: [1, 2, 3], ('a', 'b'): 'abc'}
print(dict2)

输出结果：

{'a': 1, 'b': 'abc', 10: [1, 2, 3], ('a', 'b'): 'abc'}

b.将其他数据类型转换成字典

dict3 = dict([(1, 2), (2, 3)])
print(dict3)

输出结果：
{1: 2, 2: 3}

2.字典的增删改查

a.查
获取字典的元素的值
字典获取元素的值，是通过key来获取的
字典[key]

person = {'name': '路飞', 'age': 17, 'face': 90, 'bbb': None}
print(person['name'])
# print(person['aaa'])  (如果key不存在，会报KeyError的错误)
print(person['bbb'])

输出结果：
路飞
None

字典.get(key)

print(person.get('name'))
print(person.get('aaa'))  # 如果Key不存在，返回None

输出结果：
路飞
None

注意：如果Key值确定存在，使用[]语法去获取值。不确定key值是否存在时，才使用get方法去获取值
b.增加元素、修改元素
通过key获取字典元素，然后赋值。当key本身就存在的时候，就是修改元素的值；不存在的时候，就是给字典添加键值对。

person['height'] = 1.8
print(person)
person['age'] = 18
print(person)

输出结果：
{'name': '路飞', 'age': 17, 'face': 90, 'bbb': None, 'height': 1.8}
{'name': '路飞', 'age': 18, 'face': 90, 'bbb': None, 'height': 1.8}

c.删除：删除的是键值对 (如果key不存在，会报KeyError的错误)
del 字典[key]

del person['bbb']
print(person)

输出结果：
{'name': '路飞', 'age': 18, 'face': 90, 'height': 1.8}

字典.pop(key) (会返回被删除的键值对的值)

a = person.pop('age')
print(a, person)

输出结果：
18 {'name': '路飞', 'face': 90, 'height': 1.8}

3.相关的数组属性
- 字典.keys():获取字典所有的key,返回值的类型是dict_keys,但是可以把它当成列表来使用
- 字典.values():获取字典所有的值(value)
- 字典.items():将字典中所有的键值对，转换成一个一个的元组，key作为元组的第一个元素，value作为元组的第二个元素

student_dict = {'name': '张三', 'study_id': 'py1805001', 'scores': {'english': 60, 'math': 100}}
keys = student_dict.keys()
print(type(keys), keys)
# 遍历获取每一个key
for key in keys:
    print(key)

print(student_dict.values())

print(student_dict.items())

输出结果：
name
study_id
scores
dict_values(['张三', 'py1805001', {'english': 60, 'math': 100}])
dict_items([('name', '张三'), ('study_id', 'py1805001'), ('scores', {'english': 60, 'math': 100})])

4.遍历字典（常用★）
- a.直接遍历字典。获取到的是所有的key（推荐使用）

print('★★★★★★★★★★★')
for key in student_dict:
    print(key, student_dict[key])

b.遍历直接获取到key和value（不推荐使用）

输出结果：
★★★★★★★★★★★
name 张三
study_id py1805001
scores {'english': 60, 'math': 100}

print('★★★★★★★★★★★')
for key, value in student_dict.items():
    print(key, value)

输出结果：
★★★★★★★★★★★
name 张三
study_id py1805001
scores {'english': 60, 'math': 100}

列表中有字典、字典中有字典、字典中有列表
声明一个变量，作用是用来存储一个班级的学生的信息。其中学生的信息包括姓名、性别，至少存三个学生的信息

class1 = [{'name': 'K', 'sex': '男'},
          {'name': 'J', 'sex': '女'},
          {'name': 'X', 'sex': '男'}]

6.其他操作
- 1.fromkeys()
  dict.fromkeys(序列，value)：创建一个新的字典，序列中的元素作为key，value作为值

new_dict = dict.fromkeys(['a', 'b', 'c'], 100)
print(new_dict)

输出结果：
{'a': 100, 'b': 100, 'c': 100}

2.in
key in 字典: 判断字典中是否存在指定的key

dog_dict = {'color': 'white', 'age': 3,  'type': '土狗'}
print('color' in dog_dict)  # 判断的是键是否存在
print('white' in dog_dict)

输出结果：
True
False

3.updata
字典1.updata(字典2)

new_dict.update({'a': 50, 'b': 150})
print(new_dict)

输出结果：
{'a': 50, 'b': 150, 'c': 100}

04-集合

集合也是一种容器类型的数据类型（序列），数据放在{}中，多个之间只用逗号隔开：{1, 2, 'a'}
集合是无序的（不能通过索引去取值），可变（可以增删改），元素不能重复
集合可以进行数学中集合相关的操作：判断是否包含，求交集、并集、差集、补集
1.怎么声明集合
- a.声明一个变量，赋一个集合值

set0 = set()  # 声明一个空的列表
set1 = {1, 2, 3, 2, 1}
print(set1, type(set1))

输出结果:
{1, 2, 3}

b.将其他的数据转换成集合

set2 = set('abc123')  # 将其他数据转换成集合，自带一个去重功能
print(set2)
set3 = set([13, 'abc', 'hh', 12, 'hh'])
print(set3)
print(list(set3))

输出结果：
{'b', 'c', '2', 'a', '3', '1'}
{'abc', 'hh', 12, 13}
['abc', 'hh', 12, 13]

2.增删改查
- a.查：遍历
  注意：集合没有办法单独获取某一个元素

for item in set3:
    print(item)

输出结果：
abc
hh
12
13

b.增
集合.add(元素)：在指定的集合中添加指定的元素

set1 = {1, 2, 3}
set1.add(100)
print(set1)

输出结果：
{1, 2, 3, 100}

集合1.update(集合2)：将集合2中的元素添加到集合一中，自动去重

set1.update({'abc', 'zzz'})
print(set1)

输出结果：
{1, 2, 3, 100, 'abc', 'zzz'}

c.删

集合.remove(元素)：在指定的集合中，删除指定的元素

set1.remove('zzz')
print(set1)
print('★★★★★★★★★★★')
# pop删除是随机删除一个
set1.pop()
print(set1)

输出结果：
{1, 2, 3, 100, 'abc'}
★★★★★★★★★★★
{2, 3, 100, 'abc'}

3.判断是否包含
- 集合1 >= 集合2 --判断集合1中是否包含集合2(判断集合2中的元素是否都在集合1里面)
- 集合1 <= 集合2 --判断集合2中是否包含集合1


print({1, 2, 3, 4} >= {1, 4})
print({1, 2, 3, 4} <= {1, 2})

输出结果：
True
False

4.数学的集合运算
- 求并集：|

print({1, 2, 3} | {2, 3, 4, 5})

输出结果：
{1, 2, 3, 4, 5}

求交集：&

print({1, 2, 3} & {2, 3, 4, 5})

输出结果：
{2, 3}

求差集：-

print({1, 2, 3} - {2, 3, 4, 5})

输出结果：
{1}

求补集：^

print({1, 2, 3} ^ {2, 3, 4, 5})

输出结果：
{1, 4, 5}

5.其他方法
- clear:清空集合

set1.clear()
print(set1, type(set1))

输出结果：
set()

len:获取集合中元素的个数

print(len(set1))

输出结果：
0

day6字典

01-列表

增、删、改、查

1、修改列表元素

2、列表的其他操作

3、获取列表中的最大的元素和最小的元素

获取一个数字列表中的最大值

其他方法

注意：通过一个列表变量给另一个列表变量赋值的时候，赋得是地址。两个列表对元素进行操作时都会相互影响，想要避免这个问题就使用copy或者切片

02-元组

什么是元组

1.查(和列表的查一模一样，没有任何区别)

2.len()

3.in, not in

4.+和*

5.元组补充：

03-字典

字典也是一种容器类型的数据类型（序列），存的数据是以键值对的形式出现的，字典中的元素，全部都是键值对

字典是可变的（可以增删改），但是是无序的（不能使用下标）

键是唯一的

1.声明一个字典

2.字典的增删改查

3.相关的数组属性

4.遍历字典（常用★）

6.其他操作

04-集合

集合也是一种容器类型的数据类型（序列），数据放在{}中，多个之间只用逗号隔开：{1, 2, 'a'}

集合是无序的（不能通过索引去取值），可变（可以增删改），元素不能重复

集合可以进行数学中集合相关的操作：判断是否包含，求交集、并集、差集、补集

1.怎么声明集合

2.增删改查

3.判断是否包含

4.数学的集合运算

5.其他方法

你可能感兴趣的:(day6字典)