Python基础___Part1

1、Python基础

1.1 数据类型

字符串

s.strip() #去除首未的空格

s.replace("赛利亚", "周杰伦") #替换
a.replace(" ", "")  # 去掉所有的空格

a = "python_java_c_c#_javascript"
lst = a.split("_")  # 切割之后的结果会放在列表当中

s.find("")  # 返回如果是-1就是没有该字符串出现

print(len(s))  # length  长度

lst = ['赵本山', '王大拿', '大张伟', '马大哈']
# 用_把上面的人的名字连起来
s = "_".join(lst)

• 1. upper() 在需要忽略大小写的时候
  2. strip() 可以去掉字符串左右两端的空白(空格, \t, \n)
  3. replace() 字符串替换
  4. split() 对字符串进行切割
  5. join() 拼接一个列表中的内容成为新字符串
  6. startswith() 判断字符串是否以xxx开头
  7. len() 字符串长度(内置函数)

列表

lst.append("张绍刚")
lst.insert(1,"张绍刚")
lst.pop(3)  # 给出被删除的索引. 返回被删除的元素
lst.remove("马超")  # 删除某个元素(*)

# for item in lst:  # 此时, 我们看不到元素的索引位置
for i in range(len(lst)):  # len(lst)列表的长度 ->  可以直接拿到列表索引的for循环
    item = lst[i]  # item依然是列表中的每一项
    if item.startswith("张"):
        # 张绍刚
        new_name = "王"+item[1:]
        print(new_name)
        # 把新名字丢回列表(需要索引了?)
        lst[i] = new_name  # 修改
        
lst.sort()  # 对列表进行升序排序
lst.sort(reverse=True)   # reverse: 翻转

lst = ['赵敏', '张绍刚', '张涛', '武则天', '嬴政', '马超']
temp = []  # 准备一个临时列表, 负责存储要删除的内容
for item in lst:
    if item.startswith("张"):
        temp.append(item)  # 把要删除的内容记录下来
        print(item)
        # lst.remove(item)  # 有bug 直接会跳到后两个位置 因为当前位置被删除了
print(temp)
for item in temp:
    lst.remove(item)  # 去原列表中进行删除操作
print(lst)

元组

#特点: 不可变的列表
# 元组如果只有1个元素(*), 需要在元素的末尾添加一个逗号
# t = ("哈哈",)  # ()默认是优先级

# 关于元组的不可变(坑), 内存地址不能变.
t = (1, 2, 3, ["呵呵哒", "么么哒"])  # (张三, 李四, 王二麻子)
t[3].append("哒哒哒")

集合

# set集合, set集合是无序的 可以删除列表中重复元素
print(list(set(lst)))   # 去除重复之后的数据是无序的.

字典

dic.pop("jay")  # 根据key去删除
dic.setdefault("jay", "胡辣汤")  # 设置默认值. 如果以前已经有了tom了. setdefault就不起作用了

# 1. 可以用for循环, 直接拿到key
for key in dic:
    print(key, dic[key])

# 2. 希望把所有的key全都保存在一个列表中
print(list(dic.keys()))  # 拿到所有的key了

# 3. 希望吧所有的value都放在一个列表中
print(list(dic.values()))

# 4. 直接拿到字典中的key和value
print(list(dic.items()))
for key, value in dic.items(): 
  print(item)  # 确定, item中只有两项元素
  print(key, value)

1.2 函数

全局与局部变量

def func():
    a = 10
    def inner():
        nonlocal a
        a += 1
        return a
    return inner
#nonlocal为函数外部的a

装饰器

通用装饰器的写法:
        def wrapper(fn):   wrapper: 装饰器, fn: 目标函数
            def inner(*args, **kwargs):
                # 在目标函数执行之前.....
                ret = fn(*args, **kwargs)   #   执行目标函数
                # 在目标函数执行之后.....
                return ret
            return inner     #千万别加()

def wrapper1(fn):  # fn: wrapper2.inner
    def inner(*args, **kwargs):
        print("这里是wrapper1 进入")  # 1
        ret = fn(*args, **kwargs)  # wrapper2.inner
        print("这里是wrapper1 出去")  # 5
        return ret
    return inner

def wrapper2(fn):  # fn: target
    def inner(*args, **kwargs):
        print("这里是wrapper2 进入")  # 2
        ret = fn(*args, **kwargs)  # taget
        print("这里是wrapper2 出去")  # 4
        return ret
    return inner


@wrapper1  # target = wrapper1(wrapper2.inner)   =>  target: wrapp1.inner
@wrapper2  # target = wrapper2(target)   => target: wrapper2.inner
def target():
    print('我是目标')  # 3

target()

"""
这里是wrapper1 进入
这里是wrapper2 进入
我是目标
这里是wrapper2 出去
这里是wrapper1 出去
"""

迭代器

• str list tuple dict set open()
• 只能向前不能反复
• 本身也可以迭代
• 省内存
• 惰性机制

it = iter("你叫什么名字啊")

print(next(it))
print(next(it))
print(next(it))
print(next(it))
print(next(it))
print(next(it))
print(next(it))

print(next(it))  
# StopIteration: 迭代已经停止了. 不可以再次从迭代器中拿数据了

统一了不同数据类型的遍历方式

生成器

• 创建方式

生成器函数
    生成器函数中有一个关键字yield
    生成器函数执行的时候, 并不会执行函数, 得到的是生成器.

    yield: 只要函数中出现了yield. 它就是一个生成器函数
        作用:
            1. 可以返回数据
            2. 可以分段的执行函数中的内容, 通过__next__()可以执行到下一个yield位置
    优势:
        用好了, 特别的节省内存


生成器表达式 -> 一次性的
    语法: (数据 for循环 if)

生成函数

def order():
    lst = []
    for i in range(10000):
        lst.append(f"衣服{i}")
        if len(lst) == 50:
            yield lst
            # 下一次拿数据
            lst = []

生成表达式

gen = (i**2 for i in range(10))

for item in gen:
    print(item)

lst = list(gen)
print(lst)

def func():
    print(123)
    yield 666
    print(456)
    yield 999

ret = func()
print(ret.__next__())
print(ret.__next__())

推导式

# 4. 请将下列的列表修改成字典, 要求 索引做为key, 数据作为value
lst = ['赵本山', "潘长江", "高达", "奥特曼"]

dic = {i: lst[i] for i in range(len(lst))}
print(dic)

匿名函数

fn = lambda a,b : a+b

lst = [16,22,68,1,147,256,49]
s = sorted(lst, reverse=True)  # reverse翻转
print(s)

组合表达式

lambda和sorted组合
lst = ["秋", "张二嘎", "比克", "卡卡罗特", "超级宇宙无敌大帅B"]
s = sorted(lst, key = lambda x:len(x),reverse= True)
print(s)

lst = [
    {"id": 1, "name": "周润发", "age": 18, "salary": 5200},
    {"id": 2, "name": "周星驰", "age": 28, "salary": 511100},
    {"id": 3, "name": "周海媚", "age": 78, "salary": 561230},
]
s = sorted(lst, key=lambda x:x['age'],reverse=True)
print(s)

lst = ["张无忌", "张三丰", "张翠山", "灭绝小师太", "小狐仙"]
f = filter(lambda x: x.startswith("张"), lst)
print(list(f))