Python基础综合运用速成3

一.字典:

字典类型是“映射”的体现 - 键值对：

键是数据索引的扩展 - 字典是键值对的集合，键值对之间无序 - 采用大括号{}和dict()创建，

键值对用冒号: 表示 {<键1>:<值1>, <键2>:<值2>, … , <键n>:<值n>}

1.字典是以键值对的形式来存储数据的 key:value

dict1 = {}
print(dict1.fromkeys((1, 2, 3), "number"))
dict2 = {}
print(dict2.fromkeys((1, 2, 3), ("one", "two", "three")))

{1: 'number', 2: 'number', 3: 'number'}
{1: ('one', 'two', 'three'), 2: ('one', 'two', 'three'), 3: ('one', 'two', 'three')}

dog = {'name': '小狗', 'age': 8,  'sex': 'male'}
print(dog['sex'])

male

2. 获取字典的所有键, 获取字典的所有值

print(dog.keys(), dog.values())

dict_keys(['name', 'age', 'sex'])
dict_values(['小狗', 8, 'male'])

# 使用用户输入填充字典
phones = {}
polling_active = True
while polling_active:
    phone_name = input("请输入手机的品牌：")
    price = input("请输入手机的价格：")

    # 将手机的品牌及价格存入字典中
    phones[phone_name] = price

    # 判断是否继续输入
    repeat = input("是否继续输入?(yes/no)")
    if repeat == 'no':
        polling_active = False

print(phones)

请输入手机的品牌：小米
请输入手机的价格：1000
是否继续输入?(yes/no)yes
请输入手机的品牌：华为
请输入手机的价格：2000
是否继续输入?(yes/no)no
{'小米': '1000', '华为': '2000'}

3.函数或方法 描述
del d[k] 删除字典d中键k对应的数据值
k in d 判断键k是否在字典d中，如果在返回True，否则False
d.keys() 返回字典d中所有的键信息
d.values() 返回字典d中所有的值信息
d.items() 返回字典d中所有的键值对信息
d.get(k, <default>) 键k存在，则返回相应值，不在则返回<default>值
d.pop(k, <default>) 键k存在，则取出相应值，不在则返回<default>值
d.popitem() 随机从字典d中取出一个键值对，以元组形式返回
d.clear() 删除所有的键值对
len(d) 返回字典d中元素的个数

字典创建DataFrame

import pandas as pd
# 根据字典创建dataframe

data = {
    'ID': [1, 2, 3, 4],
    'name': ['小猫', '臭卷宝', '小坨', '小包'],
    'score': [42, 105, 100, 72]
}
df = pd.DataFrame(data)
print(df)

dtype: object
   ID name  score
0   1   小猫     42
1   2  臭卷宝    105
2   3   小坨    100
3   4   小包     72

二.集合:set {}

set1 = {1, 2, 2, 3}  # 集合元素唯一(不可重复,无序)
# 查找元素下标会报错 'set' object is not subscriptable 对象不可下标
print(set1)
# 集合的交集
set2 = {3, 2, 5.6}
print(set1 & set2)
# 集合的并集  |
print(set1 | set2)

1, 2, 3}
{2, 3}
{1, 2, 3, 5.6}

三.for循环/遍历  for 变量 in 列表:

import numpy as np
import random as r
import time as t
# 用法一:需要列表中的数字进行计算
list1 = [1, 2, 3, 4, 5]
for i in list1:
    if i % 2 == 1:
        print(i)
# 用法二:通过列表元素个数决定循环次数
for j in list1:
    print('Oooooo')
a_0 = np.array([1, 2, 3, 4])  # 数组
for j in a_0:
    print('array')
# range():生成一个有序的整数列表
# range(1, 5)  -->[1,2,3,4]
a0 = np.arange(1, 3)  # 1,2
for i in a0:
    print('arange')
for i in range(1, 3):
    print('range(1,3)')
print(len(a_0))
for i in range(r.randint(1, 4), 5):
    print('random')

1
3
5
Oooooo
Oooooo
Oooooo
Oooooo
Oooooo
array
array
array
array
arange
arange
range(1,3)
range(1,3)
4
random
random

# 求1~200的所有偶数和
Sum = 0
for i in range(1, 201):
    if i % 2 == 0:
        Sum = Sum + i
print(Sum)
print(sum(range(0, 202, 2)))  # 10100
print(sum(range(0, 201, 2)))  # 10100
print(sum(range(-1, 200, 2)))  # 9999
print(sum(range(-1, 201, 2)))  # 9999

10100

4.break,continue

n = 0
for i in range(0, 202, 2):
    n = 0 + i
    print(n)
a = 0
while a <= 10:
    a = a+1
    print(a)
# break 终止整个循环 continue 跳过本次循环
for i in range(1, 11):
    if i % 2 == 0:
        continue
    print('跳过5次, 执行了5次')

第一个循环n为0-200间的所有偶数

第二个循环(while):1-11的所有整数

第三个循环:

跳过5次, 执行了5次
跳过5次, 执行了5次
跳过5次, 执行了5次
跳过5次, 执行了5次
跳过5次, 执行了5次

t.sleep(0.5)
print('0.5s到了')

表示休眠0.5秒

倒计时3s

time = 3
while time >= 0:
    print(time)
    time = time -1
    t.sleep(1)
    if time == 0:
        print('boom!!!')

5.类的简单使用:

class用来创造类:

class Calc(object):

    @staticmethod
    def c_sum(start, self, step):
        self = self+1
        return sum(range(start, self, step))


    @staticmethod
    def c_multiply(start, self, step):    # 求乘积和,# 步长范围值必须能够被self整除
        for each in range(start, self, step):
            if each % step == 0:
                self = self * each
            else:
                continue
        return self

以上为我写的对序列累加或累成的两个方法

调用方 类名.方法():

i = 30
print(Calc.c_sum(3, i, 4))   # 105
print(Calc.c_sum(4, i, 4))   # 112
print(Calc.c_sum(5, i, 7))   # 62
print(Calc.c_sum(3, i, 7))   # 54
print(Calc.c_sum(1, i, 1))   # 465
print(Calc.c_multiply(28, i, 1))  # 24360
print(Calc.c_multiply(28, i, 2))  # 24360
print(Calc.c_multiply(21, i, 3))  # 408240

Calc.c_sum(1, i, 1)表示从1开始累加到i停止,每次累加的步长为1

Calc.c_multiply(21,i,3)表示从21开始乘积,到i结束,每次长为3即21*24*27*30=408240

运用的小测试

w = [1, 2, [3, 4]]
print(len(w) == 3)
q = {'q': 'w', 'o': 'r'} 
print(len(q))
list1 = [1, 2, 3, 4, 5, 0]
list1.remove(0)
list1.pop()
print(list1)
# 递归最大深度为998

# 字符串替换
# replace()把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次。
NAME = 'Z, 3, 6'
n = NAME.replace("3", "6")
print(NAME.replace("3", "6"))
print(n)

True
2
[1, 2, 3, 4]
Z, 6, 6
Z, 6, 6

# 实现一个栈stack,后进先出
# Stack() 创建一个新的空栈
# push(item) 添加一个新的元素item到栈顶
# pop() 弹出栈顶元素
# peek() 返回栈顶元素
# is_empty() 判断栈是否为空
# size() 返回栈的元素个数
class Stack:
    def __init__(self):
        self.items = []

    def push(self, item):
        # 加入元素
        self.items.append(item)

    def pop(self):
        # 弹出元素
        return self.items.pop()

    def peek(self):
        # 返回栈顶元素
        return self.items[len(self.items) - 1]

    def is_empty(self):
        # 判断是否为空
        return self.items == []

    def size(self):
        # 返回栈的大小
        return len(self.items)


if __name__ == "__main__":
    stack = Stack()
    stack.push("A")
    stack.push("B")
    stack.push("C")
    print(stack.size())  # 3
    print(stack.peek())  # C
    print(stack.pop())  # C
    print(stack.pop())  # B
    print(stack.pop())  # A