2021-03-09

3月9日 学习内容

1.列表.clear() - 清空列表(删除列表中所有的元素)

nums = [10, 2, 4, 5]
nums.clear()
print(nums)   # []

2.列表.copy() - 复制原列表产生一个一模一样的新列表，将新列表返回

列表[:]、列表+[]、列表*1的功能和列表.copy()的功能一模一样
id(变量) - 获取变量中保存的数据的地址

nums = [10, 2, 4, 5]    # 变量保存数据其实是保存的数据在内存中的地址
print('nums:', id(nums))

将nums中保存的数据的地址赋给nums

nums3 = nums
print(nums3)     # [10, 2, 4, 5]
print('num3:', id(nums3))

复制nums中地址对应的数据，在新的内存中保存，然后将新的地址返回

nums2 = nums.copy()
print(nums2)    # [10, 2, 4, 5]
print('nums2:', id(nums2))

del nums[-1]
print(nums3)    # [10, 2, 4]
print(nums2)    # [10, 2, 4, 5]

3.列表.count(元素) - 统计列表中指定元素的个数

nums = [29, 78, 67, 29, 78, 78, 100]
print(nums.count(78))   # 3
print(nums.count(888))  # 0

4.列表.extend(序列) - 将指定序列中所有的元素全面添加到列表的后面

nums = [1, 2]
nums.append('abc')
print(nums)   # [1, 2, 'abc']

nums = [1, 2]
nums.extend('abc')
print(nums)   # [1, 2, 'a', 'b', 'c']

nums = [1, 2]
nums.extend([100, 200])
print(nums)     # [1, 2, 100, 200]

5.列表.index(元素) - 获取指定元素在列表中的下标(下标是0开始增加的下标)

如果元素有多个，只返回最前面那一个的下标
如果元素不存会报错

movies = ['怦然心动', '阿甘正传', '绿皮书', '肖生克的救赎', '触不可及', '阿甘正传', '当幸福来敲门']
print(movies.index('触不可及'))   # 4
print(movies.index('阿甘正传'))   # 1
print(movies.index('沉默的羔羊'))     # ValueError: '沉默的羔羊' is not in list

6.列表.reverse() - 将列表倒序

movies.reverse()
print(movies)   # ['当幸福来敲门', '阿甘正传', '触不可及', '肖生克的救赎', '绿皮书', '阿甘正传', '怦然心动']

7.

列表.sort() - 将列表中的元素从小到大排序（不会产生新的列表）
列表.sort(reverse=True)

nums = [23, 89, 90, 23, 45, 28, 78]
result = nums.sort()
print(result)    # None
print(nums)     # [23, 23, 28, 45, 78, 89, 90]

nums = [23, 89, 90, 23, 45, 28, 78]
nums.sort(reverse=True)
print(nums)

1.什么是元组（tuple）

元组是容器型数据类型（序列）；将()作为容器的标志，里面多个元素用逗号隔开：(元素1, 元素2, 元素3,...)
元组是不可变(不支持增删改);元组是有序的(支持下标操作)
元素：任何类型的数据都可以作为元组的元素

t1 = ()
print(t1, type(t1))

t2 = (10, 23.8, 'abc', 10)
print(t2) ```
### 2.元组就是不可变的列表   -  列表中除了增删改以外的操作都适用于元组
2.1获取元素

```python
t3 = ('绿色', '黄色', '粉色', '红色', '白色')

print(t3[1], t3[-4])    # 黄色 黄色

print(t3[1:3])      # ('黄色', '粉色')
print(t3[::-2])     # ('白色', '粉色', '绿色')

for x in t3:
    print('x:', x)

for index in range(len(t3)):
    print(index, t3[index])

2.2相关操作

t3 = ('绿色', '黄色', '粉色', '红色', '白色')
print('黑色' in t3)    # False
print('白色' in t3)    # True

t4 = (10, 20)
t5 = (100, 200, 300)
print(t4 + t5)      # (10, 20, 100, 200, 300)
print(t4 * 3)       # (10, 20, 10, 20, 10, 20)

print(t4 == (10, 20))       # True
print(t4 == (20, 10))       # False

print(t4 > (1, 100, 200, 300))      # True

print(max(t5))    # 300
print(min(t5))    # 100
print(sum(t5))    # 600
new_nums = sorted((23, 78, 90, 45))
print(new_nums)     # [23, 45, 78, 90]

print(tuple(new_nums))      # (23, 45, 78, 9

3.元组特有和更常用的相关操作

3.1 只有一个元素的元组: 必须在唯一的元素的后面添加逗号

l1 = [100]
print(l1, type(l1))    # [100] <class 'list'>

t1 = (100,)
print(t1, type(t1), len(t1))

3.2 在没有歧义的情况下元组的小括号可以省略

直接将多个数据用逗号隔开表示的也是一个元组

t2 = 23, 56, 78
print(t2, type(t2))     # (23, 56, 78) <class 'tuple'>

3.3 直接使用多个变量获取元组中的元素

1)让变量的个数和元组中元素个数保持一致

subjects = ('Python', 'Java', 'H5', 'UI')
x1, x2, x3, x4 = subjects
print(x1, x2, x3, x4)

p1 = (100, 200)
x, y = p1
print(x, y)

m, n, p = 10, 20, 30

2) 让变量的个数小于元组中元素的个数，并且在其中某一个变量前加*。

获取的时候先让不带*的变量按位置获取对应的元素，剩下的元素全部由带*的变量获取（列表）

student = ('小明', 18, 89, 78, 23, 8, '男')
name, *others, sex = student
print(name, sex, others)    # 小明 男 [18, 89, 78, 23, 8]

name, age, *s, sex = student
print(s, name, age, sex)    # [89, 78, 23, 8] 小明 18 男

*x, y, z = student
print(x, y, z)      # ['小明', 18, 89, 78, 23] 8 男

1）元组.count(元素)    -   统计元组中指定元素的个数
2）元组.index(元素)    -   获取元素在元组的下标```



```定义一个变量同时保存一个学生的信息：姓名、年龄、性别、身高、体重、成绩```

```python
student = ['小明', 30, '男', 175, 73, 65]
print(student[-1])

student = {'姓名': '小明', 'age': 30, 'gender': '男', 'height': 175, 'weight': 73, 'grade': 65}
print(student['grade'])

1.什么是字典（dict）

将{}作为容器的标志， 里面多个元素用逗号隔开，每一个元素都是一个键值对：{键1: 值1, 键2: 值2, 键3: 值3, ...}
字典是可变的(支持增删改); 字典是无序(不支持下标操作)

字典保存数据其实真正想要保存的是值，键是用来对值进行区分和说明。

元素：字典的一个元素是一个键值对
     键  -   必须是不可变的类型的数据(数字、字符串和元组)，但是一般使用字符串；键是唯一的
     值  -   可以是任何类型的数据```

###### 空字典

```python
d1 = {}

键是不可变的数据
d2 = {'a': 10, 10: 20, (10, 20): 30}
print(d2)    # {'a': 10, 10: 20, (10, 20): 30}

d3 = {'a': 10, 10: 20, [10, 20]: 30}     # 报错！列表不能作为键


键是唯一的
d4 = {'a': 10, 'b': 20, 'a': 30}
print(d4)       # {'a': 30, 'b': 20}

字典是无序的

print({'a': 10, 'b': 20} == {'b': 20, 'a': 10})    # True

2.1 查 -  获取字典中某个元素的值
1）查单个
字典[key]   -   获取字典中指定key对应的值, 如果key不存在会报错
字典.get(key)   -   获取字典中指定key对应的值，如果key不存在返回None
字典.get(key, 默认值)  -   获取字典中指定key对应的值，如果key不存在返回默认值```

```python
student = {'姓名': '小明', 'age': 30, 'gender': '男', 'height': 175, 'weight': 73, 'grade': 65}
print(student['gender'])   # 男
print(student['weight'])    # 73
print(student['score'])   # KeyError: 'score'

print(student.get('height'))    # 175
print(student.get('score'))     # None
print(student.get('score', 0))  # 0

2）遍历
"""
for 变量 in 字典:
    循环体

注意：变量依次取到的时候字典的键
"""
student = {'姓名': '小明', 'age': 30, 'gender': '男', 'height': 175, 'weight': 73, 'grade': 65}
for x in student:
   print('x:', x, student[x])

1.列表推导式 - 通过序列创建列表的一种特殊的表达式

[表达式 for 变量 in 序列]

功能：创建一个列表；让变量去序列中取值，每取一个值产生一个元素(元素就是对应表达式的值)```

```python
list1 = []
for 变量 in 序列:
    list1.append(表达式)
"""
result = [x for x in range(3)]
print(result)    # [0, 1, 2]

result = [x*2 for x in range(3)]
print(result)      # [0, 2, 4]

result = [100 for x in range(4)]
print(result)   # [100, 100, 100, 100]

练习：提取数字序列中所有元素的个位，创建一个新的列表（推导式）

nums = [239, 78, 27, 90, 23, 112]  -> [9, 8, 7, 0, 3, 2]
nums = [239, 78, 27, 90, 23, 112]
result = [x % 10 for x in nums]
print(result)

nums = [239, 78, '27', 90, 23, '112']
result = [int(x) % 10 for x in nums]
print(result)

[表达式 for 变量 in 序列 if 条件语句]

功能：
list1 = []
for 变量 in 序列:
    if 条件语句:
        list1.append(表达式)

练习：

nums = [23, 23.4, True, 'abc', 230, 100, '23', 2.12]
[23, 230, 100]
result = [x for x in nums if type(x) == int]
print(result)    # [23, 230, 100]


nums = [12, 21, 30, 8, 9, 33, 2]
[6, 42, 15, 4, 18, 66, 1]

三目运算符： 表达式1 if 条件语句 else 表达式2 - 如果条件语句为True，整个运算表达式的结果是表达式1的值否则是表达式2的值