2022.12.21-Python100day-day04-review-CSDN博客

本文链接：https://blog.csdn.net/wldcn3/article/details/128392543

1、跑马灯的文字效果

# '+++++拼搏到无能为力，坚持到感动自己！+++++'
# '++++拼搏到无能为力，坚持到感动自己！++++++'
# '+++拼搏到无能为力，坚持到感动自己！+++++++'
# 拿到切片 将第一个索引的字符 添加到字符串的末尾上去

构建思路：总共是26个字符，是将最后的一个字符，添加到第一个字符的索引上去。

import time
import os

content = '+++++拼搏到无能为力，坚持到感动自己！+++++'

while True:
    os.system('clear')
    print(content)
    time.sleep(0.3)     # 暂时睡眠时间
    a = content[1:] + content[0]

2、在字符串的元素寻找的方面有两种方法。一般我们使用find的方法，优势如下：

find方法 找不到 程序不会崩溃  index的方法 找不到 程序会崩溃 所以更倾向于使用 find方法

3、字符串的拆分——用空格拆分字符串可以得到一个列表

 content = 'You go your way, I will go mine.'
 content2 = content.replace(',', '').replace('.', '')

 用空格拆分字符串 得到一个列表
 words = content2.split()
 print(words, len(words))

 for word in words:
     print(word)

 用空格拆分字符串，最多允许拆分3次， maxsplit 默认为 -1 ，可以拆多次 直到全部拆分完毕即可
 words = content2.split(' ', maxsplit=3)
 print(words, len(words))

4、凯撒加密 maketrans 方法实现字符串转义

5、生成随机验证码

import random
import string

两种字符串生成的方法

1、 普通的字符的生成方法  按照 for循环 在 range 范围中进行取值
 nums = [i for i in '0123456789']
 big_letters = [chr(i) for i in range(65, 91)]
 small_letters = [chr(i) for i in range(97, 123)]
 all_chars = nums+big_letters+small_letters
2、string. 里面自带的字符串的包
 digits = '0123456789'
 ascii_lowercase = 'abcdefghijklmnopqrstuvwxyz'
 ascii_uppercase = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

all_chars = string.digits + string.ascii_lowercase + string.ascii_uppercase
生成10个  长度=4 的随机验证码
for _ in range(10):
    select_chars = random.choices(all_chars, k=4)
    print(''.join(select_chars))

6、集合

 一个新的容器 -- 集合 只能存储 不可变的数据类型 hashable
 列表 元组 字符串
 顺序存储 （有小标）
 优点：可以实现随机访问
 缺点：判断一个元素是否在容器中 查找效率十分低下

哈希函数   ---> 会得到一个哈希码   不同的元素 算出来得到同一个哈希码  这个就叫做哈希冲突  在查找数的时候只要看这个哈希码有没有被占用即可
集合
哈希存储
优点：集合在元素查找时 效率远高于列表 不依赖问题的规模   常量级时间复杂度的存储方案
     如果一个对象无法计算哈希码  就不能放到集合中  列表就是无法计算哈希码的对象  列表时不可哈希的类型
     可变容器 均没有办法  计算哈希码  作为集合中的元素
     可变容器（列表、集合、字典） 都无法计算 哈希码  因此都不能放到集合中， 作为集合的元素
     集合中可以放置元组  ，因为元组是不可变化的
     集合自己 本身 也不能  放在 集合 里面   因为 集合 本身  也是一个可变的容器

缺点：哈希存储的关键是设计一个好的哈希函数   尽量保证不同的对象能够计算出不同的 哈希码
     百度云盘的极速秒传功能就是一个很好地例子：计算出哈希码，如果已经在百度云盘服务器上已经有备份了就可以实现极速秒传。

7、字典

字典 ---> 元素由键和值两部分组成，：前面==键， ：后面 == 值 合在一起称为键值对
字典的键 采用了 hash 存储的方式 进行存储的

7.1、字典的构建和使用

 构造方法1：字面量 语法 构建字典
student1 = {
    'id': 1001,
    'name': 'faker',
    'sex': True,
    'birthday': '1908-11'
}
 print(student1)
 print(len(student1))

 重构取值的方法  取到 对应的值
 for key in student1:
     print(key, student1[key])

 遍历字典中  值
 print(student1.values())

 for value in student1.values():
     print(value)

 for key, value in student1.items():
     print(key)
     print(value)

7.2、构造器函数 方法 构造字典
student2 = dict(id=1002, name='bang', sex=True, birthday='1990-1-1')
print(student2)

7.3、生成式语法
列表的生成式
list1 = [i for i in range(1, 10)]
print(list1)

7.4、集合的生成式
set1 = {i for i in range(1, 10)}
print(set1)

7.3、字典的取值方法

字典取值  一般 使用 get（）方法 去取value 值  即使 字典里面 没有所对应的值  程序也不会报错的
get() 方法 是最稳定的方法
student1 = {
    'id': 1001,
    'name': 'faker',
    'sex': True,
    'birthday': '1908-11'
}
给 age 一个值 如果拿到 value 的话  则 给到一个 value=20
print(student1.get('age', 20))

如果使用下标进行 运算的话  一定要保证 键值对的存在 ！！！

字典的其他 相关 操作
key 也是 一个 hash 存储类型 的 值
字典的 setdefault 方法

8、统计一段话中英文字母的数量

results = {letter: 0 for letter in string.ascii_lowercase}
print(results)

content = input('please input:').lower()
print(len(content))

for ch in content:
    if ch in results:
        results[ch] += 1

for key, value in results.items():
    print(f'{key}: {value:>2d} times')

给每个字母建立一个字典，在后面对出现的次数进行统计

9、homework2 -字典保存了股票的信息

1、找出 股票 价格 > 100 元的股票 并 创建 一个新的字典
2、找出价格 最高 和最低 股票 对应 的股票代码
3、按照股票的价格 从高到低 给 股票的 代码 进行排序

 step1：方法1：
new_stocks = {}
for key, value in stocks.items():
    if value > 100:
        new_stocks[key] = value
print(new_stocks)

 step1：方法2：
new_stocks1 = {key: value for key, value in stocks.items() if value > 100}
print(new_stocks1)

max_stocks = {}
max_stocks_key = {}

max_stocks = stocks['AAPL']

for key, value in stocks.items():
    if value > max_stocks:
        max_stocks = value
        max_stocks_key = key

print(max_stocks_key)

补充知识点 zip() 方法   如果 遇到 问题： 将字典中的 key 和 value 的位置进行更换 就 用下面的方法 进行更换即可
dict1 = {'A': 1, 'B': 2, 'C': 3, 'D': 4}
dict2 = dict(zip(dict1.values(), dict1.keys()))
print(dict1)
print(dict2)

step2： 方法1   是 取出 二元组 中的  第一个元素  下标[1] 的 第一个元素  是参照上面的补充方法
第一步
print(dict(zip(stocks.values(), stocks.keys())))
第二步
print(max(zip(stocks.values(), stocks.keys())))
第三步
print(max(zip(stocks.values(), stocks.keys()))[1])
print(min(zip(stocks.values(), stocks.keys()))[1])

step2： 方法2  重新 定义 max 函数的方法

key = ['AAPL', 'GOOG', 'IBM', 'ORCL', 'ACN', 'FB', 'SYMC']
字典 上 是 没有 sort 方法 的  只有 sorted 方法
print(max(stocks, key=stocks.get))
print(min(stocks, key=stocks.get))

print(sorted(stocks, key=stocks.get, reverse=True))