python-07-元组、字典、集合

目录

01-练习

02-冒泡排序优化

03-求列表中最大数

04-删除空字符串

05-列表的嵌套

06-列表的推导式

07-深复制和浅复制

08-元组的使用

09-字典的使用

10-字典使用的注意事项

11-字典的查询

12-字典的增删改

13-update方法的使用

14-字典的遍历

15-字典练习

16-字典的练习1

17-字典的练习2

---

01-练习

# 有一个列表names，保存了一组姓名names=['zhangsan','lisi','chris','jerry','henry']
# 再让用户输入一个姓名，如果这个姓名在列表里存在，提示用户姓名已存在；
# 如果这个姓名在列表里不存在，就将这个姓名添加到列表里。

names = ['zhangsan', 'lisi', 'chris', 'jerry', 'henry']
username = input('请输入一个用户名:')
# if username in names:
#     print('用户名已经存在')
# else:
#     names.append(username)

for name in names:
    if username == name:
        print('用户名已经存在')
        break
else:
    names.append(username)

print(names)

# 冒泡完善
# 统计列表里出现次数最多的元素
# 求列表里的最大数
# 删除列表里的空字符串

02-冒泡排序优化

nums = [1, 2, 3, 4, 5, 6, 7, 9, 8]

count = 0
j = 0
# 第一趟比较时, j=0,多比价了0次
# 第二趟比较时, j=1,多比较了1次
# 第三趟比较时, j=2,多比价了2次
while j < len(nums) - 1:

    # 在每一趟里都定义一个flag
    flag = True  # 假设每一趟都没有换行
    i = 0
    while i < len(nums) - 1 - j:
        count += 1
        if nums[i] > nums[i + 1]:
            # 只要交换了,假设就不成立
            flag = False
            nums[i], nums[i + 1] = nums[i + 1], nums[i]
        i += 1
    if flag:
        # 这一趟走完以后，flag依然是True,说明这一趟没有进行过数据交换
        break
    j += 1

print(nums)
print('比较了%d次' % count)

加了个exchange，判断第二步是否改变

03-求列表中最大数

nums = [3, 1, 9, 8, 4, 2, 0, 7, 5]
# nums.sort()
# print(nums[-1])

# nums.sort(reverse=True)
# print(nums[0])

x = nums[0]  # 假设第0个是最大数
index = 0  # 假设最大数的下标是 0
# for num in nums:
#     if num > x:  # 如果发现列表里存在比假设还要大的数字
#         # 说明假设不成立，把假设的值设置为发现的数字
#         x = num
i = 0
while i < len(nums):
    if nums[i] > x:
        x = nums[i]
        index = i
    i += 1

print('发现的最大数是%d,它的下标是%d' % (x, index))

04-删除空字符串

# 删除列表里的空字符串
words = ['hello', 'good', '', '', 'yes', 'ok', '']
# words = ['hello', 'good', 'yes', 'ok']

# 在使用for...in循环遍历列表时，最好不要对元素进行增删操作
# for word in words:
#     if word == '':
#         words.remove(word)
# print(words)

# i = 0
# while i < len(words):
#     if words[i] == "":
#         words.remove(words[i])
#         i -= 1
#     i += 1
# print(words)

words2 = []
for word in words:
    if word != '':
        words2.append(word)

words = words2
print(words)

三种方式：for in，while ==kong，创 新列表

05-列表的嵌套

import random

# 一个学校，有3个办公室，现在有10位老师等待工位的分配，请编写程序，完成随机的分配
teachers = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J']
rooms = [[], [], []]

for teacher in teachers:
    room = random.choice(rooms)  # choice 从列表里随机选择一个数据
    room.append(teacher)

print(rooms)
# 第0个房间有3个人，分别是...


# 带下标我们一般都使用while
# for循环也可以带下标
for i, room in enumerate(rooms):
    print('房间%d里一共有%d个老师,分别是:' % (i, len(room)),end='')
    for teacher in room:
        print(teacher, end=' ')
    print()

room = random.choice(rooms)  # choice 从列表里随机选择一个数据

for i, room in enumerate(rooms):#枚举，输出为list

random扩展

#!/usr/bin/python
# -*- coding: UTF-8 -*-

import random

print( random.randint(1,10) )        # 产生 1 到 10 的一个整数型随机数  
print( random.random() )             # 产生 0 到 1 之间的随机浮点数
print( random.uniform(1.1,5.4) )     # 产生  1.1 到 5.4 之间的随机浮点数，区间可以不是整数
print( random.choice('tomorrow') )   # 从序列中随机选取一个元素
print( random.randrange(1,100,2) )   # 生成从1到100的间隔为2的随机整数

a=[1,3,5,6,7]                # 将序列a中的元素顺序打乱
random.shuffle(a)
print(a)

#!/usr/bin/python
# -*- coding: UTF-8 -*-

import random
import string

# 随机整数：
print random.randint(1,50)

# 随机选取0到100间的偶数：
print random.randrange(0, 101, 2)

# 随机浮点数：
print random.random()
print random.uniform(1, 10)

# 随机字符：
print random.choice('abcdefghijklmnopqrstuvwxyz!@#$%^&*()')

# 多个字符中生成指定数量的随机字符：
print random.sample('zyxwvutsrqponmlkjihgfedcba',5)

# 从a-zA-Z0-9生成指定数量的随机字符：
ran_str = ''.join(random.sample(string.ascii_letters + string.digits, 8))
print ran_str

# 多个字符中选取指定数量的字符组成新字符串：
print ''.join(random.sample(['z','y','x','w','v','u','t','s','r','q','p','o','n','m','l','k','j','i','h','g','f','e','d','c','b','a'], 5))

# 随机选取字符串：
print random.choice(['剪刀', '石头', '布'])

# 打乱排序
items = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
print random.shuffle(items)

06-列表的推导式

# 列表推导式作用是使用简单的语法创建一个列表
nums = [i for i in range(10)]
print(nums)

x = [i for i in range(10) if i % 2]
print(x)

# points 是一个列表。这个列表里的元素都是元组
points = [(x, y) for x in range(5, 9) for y in range(10, 20)]
print(points)


# 了解即可
# 请写出一段 Python 代码实现分组一个 list 里面的元素,比如 [1,2,3,...100]变成 [[1,2,3],[4,5,6]....]
m = [i for i in range(1, 101)]
print(m)
# m[0:3]  j ==> 0
# m[3:6]  j ==> 3
#         j ==> 6

n = [m[j:j + 3] for j in range(0, 100, 3)]
print(n)

# 列表推导式作用是使用简单的语法创建一个列表
nums = [i for i in range(10)]【很常用需要背，使用形式也有很多】

列表推导式

列表推导式格式为：

[表达式 for 变量 in 列表] 
[out_exp_res for out_exp in input_list]

或者 

[表达式 for 变量 in 列表 if 条件]
[out_exp_res for out_exp in input_list if condition]

• out_exp_res：列表生成元素表达式，可以是有返回值的函数。
• for out_exp in input_list：迭代 input_list 将 out_exp 传入到 out_exp_res 表达式中。
• if condition：条件语句，可以过滤列表中不符合条件的值。

• >>> names = ['Bob','Tom','alice','Jerry','Wendy','Smith']
  >>> new_names = [name.upper()for name in names if len(name)>3]
  >>> print(new_names)
  ['ALICE', 'JERRY', 'WENDY', 'SMITH']

  计算 30 以内可以被 3 整除的整数：

  >>> multiples = [i for i in range(30) if i % 3 == 0]
  >>> print(multiples)
  [0, 3, 6, 9, 12, 15, 18, 21, 24, 27]

• 字典推导式

  字典推导基本格式：

  { key_expr: value_expr for value in collection }
  
  或
  
  { key_expr: value_expr for value in collection if condition }

  使用字符串及其长度创建字典：

  listdemo = ['Google','Runoob', 'Taobao']
  # 将列表中各字符串值为键，各字符串的长度为值，组成键值对
  >>> newdict = {key:len(key) for key in listdemo}
  >>> newdict
  {'Google': 6, 'Runoob': 6, 'Taobao': 6}

  提供三个数字，以三个数字为键，三个数字的平方为值来创建字典：
  
  实例
  >>> dic = {x: x**2 for x in (2, 4, 6)}
  >>> dic
  {2: 4, 4: 16, 6: 36}
  >>> type(dic)
  <class 'dict'>

  集合推导式

  集合推导式基本格式：

  { expression for item in Sequence }
  或
  { expression for item in Sequence if conditional }

• 计算数字 1,2,3 的平方数：
  
  实例
  >>> setnew = {i**2 for i in (1,2,3)}
  >>> setnew
  {1, 4, 9}
  判断不是 abc 的字母并输出：
  
  实例
  >>> a = {x for x in 'abracadabra' if x not in 'abc'}
  >>> a
  {'d', 'r'}
  >>> type(a)
  <class 'set'>

  元组推导式

  元组推导式可以利用 range 区间、元组、列表、字典和集合等数据类型，快速生成一个满足指定需求的元组。

  元组推导式基本格式：

  (expression for item in Sequence )
  或
  (expression for item in Sequence if conditional )

  元组推导式和列表推导式的用法也完全相同，只是元组推导式是用 () 圆括号将各部分括起来，而列表推导式用的是中括号 []，另外元组推导式返回的结果是一个生成器对象。

• 例如，我们可以使用下面的代码生成一个包含数字 1~9 的元组：
  
  实例
  >>> a = (x for x in range(1,10))
  >>> a
  <generator object <genexpr> at 0x7faf6ee20a50>  # 返回的是生成器对象
  
  >>> tuple(a)       # 使用 tuple() 函数，可以直接将生成器对象转换成元组
  (1, 2, 3, 4, 5, 6, 7, 8, 9)

07-深复制和浅复制

import copy

# 浅复制(拷贝)
nums = [1, 2, 3, 4, 5]
nums1 = nums  # 深拷贝/浅拷贝？都不是，是一个指向，是赋值

nums2 = nums.copy()  # 浅拷贝，两个内容一模一样，但是不是同一个对象

nums3 = copy.copy(nums)  # 和 nums.copy()功能一致，都是浅拷贝

# 深拷贝,只能使用copy模块实现
words = ['hello', 'good', [100, 200, 300], 'yes', 'hi', 'ok']

# words1是words的浅拷贝
# 浅拷贝认为只拷贝了一层
# words1 = words.copy()

# 深拷贝的words2
words2 = copy.deepcopy(words)

words[0] = '你好'
print(words2)

words[2][0] = 1
print(words2)

浅拷贝只复制指向某个对象的指针，而不复制对象本身，新旧对象还是共享同一块内存。但深拷贝会另外创造一个一模一样的对象，新对象跟原对象不共享内存，修改新对象不会改到原对象。

浅拷贝（shallowCopy）只是增加了一个指针指向已存在的内存地址，

深拷贝（deepCopy）是增加了一个指针并且申请了一个新的内存，使这个增加的指针指向这个新的内存

08-元组的使用

# 元组和列表很像，都是用来保存多个数据
# 使用一对小括号 () 来表示一个元组
# 元组和列表的区别在于，列表是可变的，而元组是不可变数据类型
words = ['hello', 'yes', 'good', 'hi']  # 列表，使用 [] 表示
nums = (9, 4, 3, 1, 9, 7, 6, 9, 3, 9)  # 元组，使用 () 来表示

# 和列表一样，也是一个有序的存储数据的容器
# 可以通过下标来获取元素
print(nums[3])
# nums[3] = 40  # 元组是不可变数据类型，不能修改
print(nums.index(7))
print(nums.count(9))

# 特殊情况:如何表示只有一个元素的元组?
# ages = (18)  # 这种书写方式，ages是一个整数，并不是一个元组
ages = (18,)  # 如果元组里只有一个元素，要在最后面加 ,
print(type(ages))  # <class 'int'>

# tuple 内置类
# print(tuple(18))
print(tuple('hello'))  # ('h', 'e', 'l', 'l', 'o')

# 怎样把列表转换成为元组？元组转换成为列表?
print(tuple(words))  # tuple list set 都是这样使用的
print(list(nums))

heights = ("189", "174", "170")
print('*'.join(heights))
print("".join(('h', 'e', 'l', 'l', 'o')))

# 元组也可以遍历
for i in nums:
    print(i)

j = 0
while j < len(nums):
    print(nums[j])
    j += 1

# 查找数据(字典的数据在保存时，是无序的，不能通过下标来获取)
#定义一个person字典
print(person['name'])  # 使用key获取到对应的value
# print(person['height'])  # 如果要查找的key不存在，会直接报错

# 需求:获取一个不存在的key时，不报错，如果这个key不存在，使用默认值
# 使用字典的get方法,如果key不存在，会默认返回 None,而不报错
# print(person.get('height'))  # None
# 如果根据key获取不到value,使用给定的默认值

09-字典的使用

# 列表可以存储任意数据类型，但是一般情况下，我们都存储单一数据类型
names = ['zhangsan', 'lisi', 'wangwu']
scores = [100, 98, 99, 97]

# 这个列表里的每一个元素到底代表的什么?
# 列表只能存储值，但是无法对值进行描述
# person = ['zhangsan', 18, 98, 97, 95, 93, 180, 150]

# 字典不仅可以保存值，还能对值进行描述
# 使用大括号来表示一个字典，不仅有值value，还有值的描述key
# 字典里的数据都是以键值对key-value的形式保留的
# key和value之间使用冒号 : 来连接
# 多个键值对之间使用逗号 , 来分割
person = {'name': 'zhangsan',
          'age': 18,
          'math': 98,
          'Chinese': 95,
          'English': 95,
          'gym': 93,
          'height': 180,
          'weight': 150
          }

10-字典使用的注意事项

person = {
    'name': 'zhangsan',
    'age': 18,
    'height': 180,
    'age': 20,  # 会替换上一个age的值
    'isPass': True,  # 值可以是布尔值
    'hobbies': ['唱', '跳', '篮球', 'rap'],  # 也可以是列表
    4: 'good',  # key只能是不可变数据类型
    ('yes', 'hello'): 100,
    # ['ok', 'no']: 'hi'  # key只能是不可变数据类型
}

# 1. 字典里的key不允许重复，如果key重复了，后一个key对应的值会覆盖前一个
# 2. 字典里的value可以是任意数据类型，但是key只能使用不可变数据类型，一般使用字符串
print(person)

11-字典的查询

person = {'name': 'zhangsan', 'age': 18, 'x': 'y'}

# 查找数据(字典的数据在保存时，是无序的，不能通过下标来获取)
print(person['name'])  # 使用key获取到对应的value
# print(person['height'])  # 如果要查找的key不存在，会直接报错

# 需求:获取一个不存在的key时，不报错，如果这个key不存在，使用默认值
# 使用字典的get方法,如果key不存在，会默认返回 None,而不报错
# print(person.get('height'))  # None
# 如果根据key获取不到value,使用给定的默认值
print(person.get('gender', 'female'))
print(person.get('name', 'lisi'))  # zhangsan

print(person)

# x = 'age'
# print(person[x])
# print(person['x'])

12-字典的增删改

person = {'name': 'zhangsan', 'age': 18, 'addr': '襄阳'}
print(person['name'])

# 直接使用key可以修改对应的value
person['name'] = 'lisi'

# 如果key存在，是修改key对应的value;
# 如果key在字典里不存在，会往字典里添加一个新的key-value
person['gender'] = 'female'
print(person)

# 把name对应的键值对删除了，执行结果是被删除的value
x = person.pop('name')
print(x)  # lisi
print(person)

# popitem 删除一个元素，结果是被删除的这个元素组成的键值对
result = person.popitem()
print(result)  # ('gender', 'female')
print(person)

del person['addr']
print(person)

person.clear()  # 用来清空一个字典
print(person)  # {}

# 直接使用key可以修改对应的value   改
person['name'] = 'lisi'

# 如果key存在，是修改key对应的value;
# 如果key在字典里不存在，会往字典里添加一个新的key-value
person['gender'] = 'female'
print(person)

# 把name对应的键值对删除了，执行结果是被删除的value
x = person.pop('name')
print(x)  # lisi
print(person)

# popitem 删除一个元素，结果是被删除的这个元素组成的键值对
result = person.popitem()
print(result)  # ('gender', 'female')
print(person)

del person['addr']
print(person)

person.clear()  # 用来清空一个字典
print(person)  # {}

13-update方法的使用

s1 = 'hello'
s2 = 'world'
print(s1 + s2)
# 列表可以使用extend方法将两个列表合并成为一个列表
nums1 = [1, 2, 3, 4, 5]
nums2 = [6, 7, 8, 9]
nums1.extend(nums2)
print(nums1)
print(nums1 + nums2)

words1 = ('hello', 'good')
words2 = ('yes', 'ok')
print(words1 + words2)  # ('hello', 'good', 'yes', 'ok')

person1 = {'name': 'zhangsan', 'age': 18}
person2 = {'addr': '襄阳', 'height': 180}
person1.update(person2)
'''描述
Python 字典 update() 函数把字典参数 dict2 的 key/value(键/值) 对更新到字典 dict 里。

语法
update() 方法语法：

dict.update(dict2)'''
print(person1)

# 字典之间不支持加法运算
# print(person1 + person2)

描述

Python 字典 update() 函数把字典参数 dict2 的 key/value(键/值) 对更新到字典 dict 里。

update() 方法用于修改当前集合，可以添加新的元素或集合到当前集合中，如果添加的元素在集合中已存在，则该元素只会出现一次，重复的会忽略。

语法

update() 方法语法：

dict.update(dict2)

14-字典的遍历

person = {'name': 'zhangsan', 'age': 18, 'height': '180cm'}

# 特殊在列表和元组是一个单一的数据，但是字典是键值对的形式

# 第一种遍历方式: 直接for...in循环字典
# for x in person:  # for...in循环获取的是key
#     print(x, '=', person[x])

# 第二种方式:获取到所有的key,然后再遍历key,根据key获取value
# print(person.keys())  # dict_keys(['name', 'age', 'height'])
# for k in person.keys():
#     print(k, '=', person[k])

# 第三种方式:获取到所有的value.
# 只能拿到值，不能拿到key
# for v in person.values():
#     print(v)

# 第四种遍历方式:
# print(person.items())  # dict_item([('name', 'zhangsan'), ('age', 18), ('height', '180cm')])

# for item in person.items():  # 列表里的元素是元组，把元组当做整体进行遍历
#     print(item[0], '=', item[1])

for k, v in person.items():
    print(k, '=', v)

仔细看，最好自己写一遍

15-字典练习

chars = ['a', 'c', 'x', 'd', 'p', 'a', 'c', 'a', 'c', 'a']

char_count = {}

for char in chars:
    # if char in char_count:
    #     char_count[char] += 1
    # else:
    #     char_count[char] = 1
    if char not in char_count:
        char_count[char] = chars.count(char)

# print(char_count)  # {'a': 4, 'c': 3, 'x': 1, 'd': 1, 'p': 1}
vs = char_count.values()
# 可以使用内置函数 max 取最大数
max_count = max(vs)  # 4

for k, v in char_count.items():
    if v == max_count:
        print(k)

16-字典的练习1

persons = [
    {'name': 'zhangsan', 'age': 18},
    {'name': 'lisi', 'age': 20},
    {'name': 'wangwu', 'age': 19},
    {'name': 'jerry', 'age': 21}
]

# 让用户输入姓名，如果姓名已经存在，提示用户;如果姓名不存在，继续输入年龄，并存入列表里
x = input('请输入您的姓名:')

for person in persons:
    # if name in person:  # in 运算符，如果直接用在字典上，是用来判断key是否存在，而不是value
    if person['name'] == x:
        print('您输入的名字存在')
        break
else:
    # print('您输入的名字不存在')
    # 创建一个新的字典  new_person
    new_person = {'name': x}
    y = int(input('请输入您的年龄:'))
    new_person['age'] = y

    # 把这个新的数据存储到 persons 列表里
    persons.append(new_person)
    print('用户添加成功')

print(persons)

17-字典的练习2

dict1 = {"a": 100, "b": 200, "c": 300}

# dict2 = {}
# for k, v in dict1.items():
#     dict2[v] = k
#
# dict1 = dict2

dict1 = {v: k for k, v in dict1.items()}  # 字典推导式
print(dict1)  # {100:"a",200:"b",300:"c"}