Python基础之列表函数、元组、字典

Python从入门到精通Day7

1.列表函数

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

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

# 不推荐
# nums = [10, 2, 4, 5]
# nums = []
# 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内存地址相同

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

nums2 = nums.copy()
print(nums2)    # [10, 2, 4, 5]
print('nums2:', id(nums2))    # 与nums地址不同

del nums[-1]
print(nums3)    # [10, 2, 4]      赋值运算的数据改变
print(nums2)    # [10, 2, 4, 5]   copy运算的数据不变

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)

.

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

结构1： - 变换
[表达式 for 变量 in 序列]

功能：创建一个列表；让变量去序列中取值，每取一个值产生一个元素(元素就是对应表达式的值)
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)

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

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

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

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

结构3
[表达式1 if 条件语句 else 表达式2 for 变量 in 序列]

2.元组（tuple）

1）什么是元组（tuple）

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

# 空元组(无意义，不可增删改)
t1 = ()
print(t1, type(t1))

t2 = (10, 23.8, 'abc', 10)
print(t2)

2）元组就是不可变的列表 - 列表中除了增删改以外的操作都适用于元组

2.1 获取元素

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, 90)

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

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

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

t1 = (100,)
print(t1, type(t1), len(t1))    # (100,) <class 'tuple'> 1

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 男

4) 元组相关方法

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

3.字典（dict）

1）什么是字典（dict）

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

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

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

# 定义一个变量同时保存一个学生的信息：姓名、年龄、性别、身高、体重、成绩
student = ['小明', 30, '男', 175, 73, 65]
print(student[-1])    # 65

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

# 空字典
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）增删改查

2.1 查 - 获取字典中某个元素的值

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

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

遍历

for 变量 in 字典:
循环体

注意：变量依次取到的时候字典的键

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

2.2 增、改

字典[key] = 值    -   当key存在的时候就是修改指定key对应的值，当key不存在的时候添加键值对
"""
dog = {'name': '财财', 'age': 2, 'breed': '哈士奇'}
print(dog)     # {'name': '财财', 'age': 2, 'breed': '哈士奇'}

dog['gender'] = '母狗'
print(dog)      # {'name': '财财', 'age': 2, 'breed': '哈士奇', 'gender': '母狗'}

dog['breed'] = '中华田园犬'
print(dog)      # {'name': '财财', 'age': 2, 'breed': '中华田园犬', 'gender': '母狗'}

2.3 删

del 字典[key] - 删除字典中指定key对应的键值对

dog = {'name': '财财', 'age': 2, 'breed': '中华田园犬', 'gender': '母狗'}
del dog['gender']
print(dog)      # {'name': '财财', 'age': 2, 'breed': '中华田园犬'}

字典.pop(key) - 取出字典中指定key对应的值

dog = {'name': '财财', 'age': 2, 'breed': '中华田园犬', 'gender': '母狗'}
result = dog.pop('age')
print(dog, result)      # {'name': '财财', 'breed': '中华田园犬', 'gender': '母狗'} 2

3) 字典相关操作

字典不支持+、* 和 比较大小，只支持比较是否相等的运算
in 和 not in - 判断字典中是否存在指定的key

print('a' in {'name': 'a', 'age': 18})   # False
print('name' in {'name': 'a', 'age': 18})       # True

dict、len

dict(数据) - 将数据转换成字典
a. 数据必须是序列
b. 序列中元素必须是小序列, 而且小序列有且只有两个元素，第一个元素必须是不可变的

list1 = [(10, 20), 'ab', range(2)]
print(dict(list1))   # {10: 20, 'a': 'b', 0: 1}

dog = {'name': '财财', 'age': 2, 'breed': '中华田园犬', 'gender': '母狗'}
result = list(dog)
print(result)   # ['name', 'age', 'breed', 'gender']

print(len(dog))     # 4

4) 字典推导式

{表达式1:表达式2 for 变量 in 序列}
{表达式1:表达式2 for 变量 in 序列 if 条件语句}

dict(表达式 for x in 序列) - 表达式必须是有且只有两个元素的序列，第一个元素必须是不可变的

result = {x: x**2 for x in range(3)}
print(result)       # {0:0, 1:1, 2:4}

result = {x: None for x in ['name', 'age', 'gender']}
print(result)       # {'name': None, 'age': None, 'gender': None}

result = {x: x//2 for x in range(11, 20) if x % 2 == 0}
print(result)       # {12:6, 14:7, 16:8, 18:9}

dog = {'name': '财财', 'age': 2, 'breed': '中华田园犬', 'gender': '母狗'}
result = {dog[x]: x for x in dog}
print(result)       # {'财财': 'name', 2: 'age', '中华田园犬': 'breed', '母狗': 'gender'}

result = dict((dog[x], x) for x in dog)
print(result)       # {'财财': 'name', 2: 'age', '中华田园犬': 'breed', '母狗': 'gender'}

5) 字典相关方法

5.1 字典.clear() - 清空字典

dog = {'name': '财财', 'age': 2, 'breed': '中华田园犬', 'gender': '母狗'}
dog.clear()
print(dog)      # {}

5.2 字典.copy() - 复制字典产生一个一模一样的新字典

dog = {'name': '财财', 'age': 2, 'breed': '中华田园犬', 'gender': '母狗'}
dog1 = dog
dog2 = dog.copy()
print(dog1)     # {'name': '财财', 'age': 2, 'breed': '中华田园犬', 'gender': '母狗'}
print(dog2)     # {'name': '财财', 'age': 2, 'breed': '中华田园犬', 'gender': '母狗'}

dog.clear()
print(dog, dog1, dog2)        # {} {} {'name': '财财', 'age': 2, 'breed': '中华田园犬', 'gender': '母狗'}

5.3 dict.fromkeys(序列) - 创建一个字典，将序列中所有的元素作为字典key，值默认都是None

result = dict.fromkeys('abcd')
print(result)   # {'a': None, 'b': None, 'c': None, 'd': None}

result = dict.fromkeys(['name', 'age', 'gender'], 100)
print(result)       # {'name': 100, 'age': 100, 'gender': 100}

5.4 values、keys、items

字典.values() - 获取字典中所有的值；返回的不是列表另是一种序列
字典.keys() - 获取字典中所有的键；返回的不是列表另是一种序列
字典.items() - 获取字典中键值对；返回的时候序列，序列中的元素是每个键值对对应的元组

dog = {'name': '财财', 'age': 2, 'breed': '中华田园犬', 'gender': '母狗'}
result = dog.values()
print(result)       # dict_values(['财财', 2, '中华田园犬', '母狗'])
print(list(result)) # ['财财', 2, '中华田园犬', '母狗']

print(dog.keys())       # dict_keys(['name', 'age', 'breed', 'gender'])

print(dog.items())      # dict_items([('name', '财财'), ('age', 2), ('breed', '中华田园犬'), ('gender', '母狗')])
print('===========================================================')
for x in dog.items():
    print(x)            # ('name', '财财') ('age', 2) ('breed', '中华田园犬') ('gender', '母狗')

print('===========================================================')
for x, y in dog.items():
    print('x:', x, 'y:', y)    # x: name y: 财财  x: age y: 2  x: breed y: 中华田园犬  x: gender y: 母狗

5.5 字典.setdefault(key, value) - 在字典中添加键值对(不会在key存在的时候进行修改操作)

dog = {'name': '财财', 'age': 2, 'breed': '中华田园犬', 'gender': '母狗'}
dog.setdefault('weight', 20)
print(dog)      # {'name': '财财', 'age': 2, 'breed': '中华田园犬', 'gender': '母狗', 'weight': 20}

dog.setdefault('name', '小黑')
print(dog)      # {'name': '财财', 'age': 2, 'breed': '中华田园犬', 'gender': '母狗', 'weight': 20}

5.6 字典.update(序列) - 将序列中所有的元素作为键值对添加到字典中。序列必须是可以转换成字典的序列

字典1.update(字典2) - 将字典2中的键值对全部添加到字典1中

dict1 = {'a': 10}
dict1.update({'b': 20, 'c': 30})
print(dict1)        # {'a': 10, 'b': 20, 'c': 30}

dict1.update(['ab', ('name', '张三'), ['age', 100]])
print(dict1)        # dict1.update(['ab', ('name', '张三'), ['age', 100]])