切片
# 切片
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;']
列表的通用操作
- 列表的加法、乘法运算
- in 和 not in
- min() 和 max()
- len()
- 两个方法: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)) # 返回任意两个数平方和