我的python学习笔记

切片

# 切片
stubs = [1, 2, 3, 4, 5, 6]

# 通过切片来获取指定的元素
# 语法：列表[起始:结束]
#   通过切片获取元素时，会包括起始位置的元素，不会包括结束位置的元素
#   做切片操作时，总会返回一个新列表，不会影响原来的列表
#   起始和结束位置的索引都可以省略不写
#   如果省略结束位置，则会一直截取到最后
#   如果省略起始位置，则会从第一个元素开始截取
#   如果起始位置和结束位置全部省略，则相当于创建了一个列表的副本
#   索引可以是负数，-1表示倒数第一个，-2表示倒数第二个 以此类推

print(stubs[1:])    # [2, 3, 4, 5, 6]
print(stubs[:3])    # [1, 2, 3]
print(stubs[:])     # [1, 2, 3, 4, 5, 6]
print(stubs[-3:])   # [4, 5, 6]
print(stubs[:-2])   # [1, 2, 3, 4]
print(stubs[-5:-1]) # [2, 3, 4, 5]
print(stubs[-1:-5]) # []

# 语法：列表[起始:结束:步长]
# 步长表示，每次获取元素的间隔，默认值是1
# 步长不能是0，但是可以是负数
# 如果是负数，则会从列表的后向前获取元素

print(stubs[::2])       # [1, 3, 5]
# print(stubs[::0])     # ValueError: slice step cannot be zero
print(stubs[::-1])      # [6, 5, 4, 3, 2, 1]

使用print()函数输出文本到文件

f = open("D:/text.txt", "a+")
print("hello word", file=f)
f.close()

赋值

a,b,c = ["aa","bb","cc"]
print(a,b,c)

a,b,c = ("aa","bb","cc")
print(a,b,c)

a, b, c = {"a":"aa", "b":"bb", "c":"cc"}
print(a,b,c)

格式化字符串

%s 在字符串中表示任一字符

name = "超级无敌宇宙霸王"
age = 1000
print("name=%s, age=%s" % (name, age))    # name=超级无敌宇宙霸王, age=1000

在字符串前添加一个f,用来创建一个格式化字符串
在格式化字符串中可以直接嵌入变量

name = "超级无敌宇宙霸王"
age = 1000
print(f"name={name},age={age}") #name=超级无敌宇宙霸王,age=1000

替换 replace()

l = "aabbcc"
print(l.replace('a','b'))   # bbbbcc

分割字符串 split()

# 分割字符串
# 语法 str.split([分割符],[分割次数])
#     默认空格分割,完整分割

s = "csa .dsa/s as/A;"
print(s.split())        # ['csa', '.dsa/s', 'as/A;']
print(s.split("/",1))   # ['csa .dsa', 's as/A;']

列表的通用操作

1. 列表的加法、乘法运算
2. in 和 not in
3. min（） 和 max（）
4. len（）
5. 两个方法:index()和count()

# 列表的方法
# index() 获取列表中指定元素的下标
my_list = ["孙悟空", "猪八戒", "沙和尚"]
print(my_list.index("孙悟空"))

# count() 获取指定元素在列表中出现的次数
my_list = ["孙悟空", "猪八戒", "沙和尚"]
print(my_list.count("孙悟空"))

# append() 向列表的最后添加一个元素
my_list = ["孙悟空", "猪八戒", "沙和尚"]
my_list.append("唐僧")
print(my_list)

# insert() 向列表指定位置插入一个元素
my_list = ["孙悟空", "猪八戒", "沙和尚"]
my_list.insert(1, "唐僧")
print(my_list)

# extend() 使用新的序列来扩展当前序列
my_list = ["孙悟空", "猪八戒", "沙和尚"]
my_list.extend(["张三", "李四"])
print(my_list)

# clear() 清空序列
my_list = ["孙悟空", "猪八戒", "沙和尚"]
my_list.clear()
print(my_list)

# pop() 删除列表中指定下标的元素并返回该元素，如果不指定下标则删除最后一个元素
my_list = ["孙悟空", "猪八戒", "沙和尚"]
s = my_list.pop(0)
print(my_list, s)

# remove() 删除列表中指定的元素，如果有多个一样的元素，则删除第一个元素
my_list = ["孙悟空", "猪八戒", "沙和尚", "猪八戒"]
my_list.remove("猪八戒")
print(my_list)

# reverse() 用来反转列表,会改变原来的对象
my_list = ["孙悟空", "猪八戒", "沙和尚"]
my_list.reverse()
print(my_list)

# sort() 用来排序,会改变原来的对象
my_list = list("hcsalgaXLA")
my_list.sort()
print(my_list)

装饰器

def begin_end(fn):
    def new_fun(*args,**kwargs):
        print("开始执行~~~~~~")
        result = fn(*args, **kwargs)
        print("执行结束~~~~~~")
        return result
    return new_fun

@begin_end
def add_1(*args,**kwargs):
    re = 0
    for i in args:
        re += i
    return re

print(add_1(1,2))

属性和方法

# 类属性：直接在类里定义的属性
#    程序中一般不常用，除非是一些公共属性
#    只能通过类对象来修改，无法通过实例对象修改

# 实例属性：通过实例定义的属性
#     只属于某一个实例
#     只能通过实例对象访问和修改

# 实例方法：直接在类里定义的方法
#     实例方法默认参数为self
#     可以通过实例对象和类对象调用
#         通过实例对象调用时，解析器会自动传递self参数
#         通过类对象调用时，解析器不会自动传递参数，需要手动传递默认参数（当前调用的对象）

# 类方法：在类中定义，使用@classmethed装饰的方法
#     类方法的默认参数为cls
#     可以通过实例对象和类对象调用
#         调用时均无需传递默认参数

# 静态方法：在类中定义，使用@staticmethod装饰的方法
#     静态方法无默认参数
#     可以通过实例对象和类对象调用，无需传递任何默认参数
#     静态方法基本和当前类无关，可以理解为保存在当前类里的一个函数
#     静态方法和函数的区别就是，静态方法需要通过类或者实例来调用

class A:
    # 类属性：
    #   可以通过类和实例访问到，但是只能通过类来修改
    count = "类属性被访问"

    # 实例方法：
    #   可以通过类对象和实例对象来调用
    def test_1(self):
        print("我是test_1，我是一个实例方法", self)

    # 类方法
    #   可以通过类对象和实例对象调用
    #   和实例方法的区别就是默认参数为cls,cls表示当前的类
    @classmethod
    def test_2(cls):
        print("我是test_2，我是一个类方法", cls)

    # 静态方法：
    #   基本上和当前类没有关系，可以理解为保存在当前类里面的一个函数
    #   和函数的区别就是静态方法不能直接调用，需要通过类或者实例调用
    @staticmethod
    def test_3():
        print("我是test_3，我是一个静态方法")


# 创建实例对象
a = A()

# 实例属性：
#   只属于实例，且只能通过实例对象访问
a.name = "小黑"

# 通过实例对象访问实例属性
print(a.name)
# print(A.name)     报错：type object 'A' has no attribute 'name'

# 通过类对象和实例对象来访问类属性
print(A.count)
print(a.count)

# 通过类对象和实例对象访问实例方法
#   使用类对象调用时，解释器不会自动传递self参数，需要手动传递
#   使用实例对象调用时，解释器会自动传递self参数
A.test_1(A)
A.test_1(a)  # 需要手动传递A或者A的实例
a.test_1()  # 解释器自动传递self，无需手动传递默认参数

# 通过类对象和实例对象调用类方法
#   使用类对象调用类方法时，无需传递默认参数
A.test_2()
a.test_2()

# 通过类对象和实例对象调用静态方法，无需传递任何默认参数
A.test_3()
a.test_3()

join() 和os.path.join()

. join()：将序列中的元素以指定的字符连接生成一个新的字符串。
os.path.join()：将多个路径进行拼接

a = list("hcsjdhckds")
print(a)
print("".join(a))


import os
a = "hh"
b = "ss"
print(os.path.join(a,b))

== 和 is

# == 和 != 比较的两个对象的值否相等
# is 和 is not 比较是两个对象否是同一个对象
a = [1, 2 ,3]
b = a.copy()

print(a == b)   # True
print(a is b)   # False

列表推导式

lis = [i for i in range(5)]     # [0, 1, 2, 3, 4]

lis = [i ** 2 for i in range(4)]       # [0, 1, 4, 9]

lis = [i for i in range(9) if i % 2 == 0]   # [0, 2, 4, 6, 8]

lis = [i*i for i in range(9) if i % 2 == 0]   # [0, 4, 16, 36, 64]

lis = [(i, j) for i in range(1,3) for j in range(3,5)]  # [(1, 3), (1, 4), (2, 3), (2, 4)]

lis = [[i for i in range(4)] for i in range(4)]     # [[0, 1, 2, 3], [0, 1, 2, 3], [0, 1, 2, 3], [0, 1, 2, 3]]

lis = [[0 for j in range(4)] for i in range(4)]     # [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]

print(lis)

lambda

# lambda函数语法
# lambda [参数1,参数2,...]:[返回值]

# 1、将lambda作为参数传递给其他函数
# filter()
lis = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(list(filter(lambda x: x % 3 == 0, lis)))  # [3, 6, 9] 过滤出lis中能被3整除的数

# sorted()
name = ["123", "12", "1234"]
print(sorted(name, key=lambda x: len(x)))   # ['12', '123', '1234'] 按照列表中元素字符个数进行排序

# map()
num = [1, 2, 3]
print(list(map(lambda x: x+1, num)))     # [2, 3, 4] 将列表中每个元素+1


# 2、将lambda赋值给一个变量
f = lambda a, b: a**2 + b**2
print(f(2, 3))   # 返回任意两个数平方和