#Container#
# --------------------------------------------------list--------------------------------------------------
mylist = [1, 1, 1, 1, 4, 5, "第五人格", "start"]
# index : list.index(element)
inquire = mylist.index(1)
print(f"1在列表中的index为:{inquire}")
# insert : list.insert(index, element) 在指定下标插入元素
mylist.insert(6, 'out')
print(f"在下标第六位insert的元素为:{mylist[6]}")
# append : list.append(element) 在列表尾部插入元素
mylist.append('man')
print(f"在列表尾部append的元素为:{mylist[-1]}")
# extend : list.extend(otherList) 在列表尾部依次追加元素
Kobe = ["what", "can", "i", "say"]
mylist.extend(Kobe)
print(f"extend过后的列表内容为:{mylist}")
# del(关键字) : del list[index] 删除
del mylist[8]
print(f"del过后的列表内容为:{mylist}")
# pop : list.pop(index) 删除
element = mylist.pop(0)
print(f"pop过后的列表内容为:{mylist},取出的元素是:{element}")
# remove : list.remove(元素) 若有重复则删除第一个
mylist.remove(1)
print(f"remove过后的列表内容为:{mylist}")
# clear : list.clear() 清空
mylist2 = [1, 2, 3]
mylist2.clear()
print(f"clear后的列表内容为:{mylist2}")
# count : list.count(element) 计算元素数量
num = mylist.count(1)
print(f"count后得出的结果为:{num}")
# len(函数) : len(list) 计算列表总共元素数量
length = len(mylist)
print(f"计算得列表长度为:{length}")
# sort(函数) : list.sort(key=选择排序依据的函数, reverse=T/F)
# 依据函数就是用来决定key中的元素是按照什么规则排序的, T表降序/F表升序
mylist = [["a", 33], ["b", 55], ["c", 22]]
mylist.sort(key=lambda element: element[1], reverse=True)
print(mylist)
# --------------------------------------------------tuple--------------------------------------------------
# list可修改 而tuple不可修改 可认为只读的list
# def : name = tuple(element, element, element, ... )
t1 = ("mamba", "out", 24, True)
t2 = ()
t3 = tuple() # 定义空元组
# index() count() len() 的用法和list一样
# --------------------------------------------------str--------------------------------------------------
# 下标索引
my_str = "Man wan wan what can i say"
print(f"{my_str[4]}")
# index() count() len() 用法相同
# replace : str.replace(element1, element2) 功能:将str中的element1替换成element2
# 且这个操作是产生一个新的字符串而不是修改原来的字符串,也就是说有返回值
new_str = my_str.replace("w", "m")
print(f"replace后产生的字符串为{new_str}")
# split : str.split(分隔符字符串) 返回的是list
split_str = my_str.split(" ")
print(f"split后产生的列表为{split_str}")
# strip : str.strip(element) 可用于去前后空格和前后字符串
my_str = " mamba out "
new_str = my_str.strip() # 去空格
print(f"strip后产生的字符串为{new_str}")
my_str = "24 kobe 24 42"
new_str = my_str.strip("24") # 去前后数字,实际传入的是"2"和"4"
print(f"strip后产生的字符串为{new_str}")
# 以上为序列:list tuple str
# character : list 可修改, tuple str 不可修改; 三者都是可重复且有序
# 切片: sequence[startIndex:endIndex:step]
# 含头不含尾;step表示间隔(步长),可取-1
# --------------------------------------------------set--------------------------------------------------
# character: 不重复, 乱序, 不支持下标索引, 可修改
# def : name = {element, element, element, ... }, name = set()
my_set = {3, 2, 1, "时代", "少年团", "我们喜欢你", "我们喜欢", "马嘉祺", "马嘉祺", "马家骑"}
print(f"展示set的两个特点:{my_set}")
# add : set.add(element)
my_set.add("丁真珍珠")
my_set.add("策马")
print(f"add后的set内容为:{my_set}")
# remove : set.remove(element)
my_set.remove("少年团")
my_set.remove("马嘉祺")
print(f"remove后的set内容为:{my_set}") # 与 上面的 add和 remove很像
# pop : set.pop(element) 随机取出一个元素, 同时把他删掉
be_pop = my_set.pop()
print(f"pop后的set内容为:{my_set}, pop的元素为{be_pop}")
# --------------------------------------------------dict--------------------------------------------------
# character : 不重复, 不支持下标索引
# def : name = {key : value, key : value, ... }
my_dict = {"xyx": "芝士雪豹", "wsy": "彩笔killer", "wsy": "留一手", "why": "芙蓉王源", "ly": "理塘丁真", "lxs": "YUKI"}
my_dick = {}
my_derk = dict() # 定义空字典
print(f"my_dicy的内容为:{my_dict}")
# 基于key获取value
print(f"key取xyx时,value为:{my_dict["xyx"]}")
# 嵌套
my_dict = {
"xyx": {
"ID": "芝士雪豹",
"Rank": "Diamond"
}, "wsy": {
"ID": "留一手",
"Rank": "Platinum"
}, "why": {
"ID": "芙蓉王源",
"Rank": "Platinum"
}, "ly": {
"ID": "理塘丁真",
"Rank": "Platinum"
}, "lxs": {
"ID": "YUKI",
"Rank": "Gold"
}
}
print(f"检查嵌套结果,xyx-Rank:{my_dict["xyx"]["Rank"]}")
# 增加,修改
my_dict = {"xyx": "芝士雪豹", "wsy": "彩笔killer", "why": "芙蓉王源", "ly": "理塘丁真", "lxs": "YUKI"}
my_dict["ljc"] = "hisoka"
my_dict["wsy"] = "留一手"
# pop : dict.pop(key) 取出并删除
delete = my_dict.pop("ljc")
print(f"删除的元素为:{delete}")
# clear : dict.clear() 清空
# keys : dict.keys() 获取全部key
keys = my_dict.keys()
print(f"key为:{keys},keys的类型为:{type(keys)}")
# 遍历字典
# 方式一 通过提前获取的key来遍历
for i in keys:
print(f"{my_dict[i]}")
# 方式二 直接遍历字典,每次遍历得到的是key
for i in my_dict:
print(f"{my_dict[i]}")
# len : len(dict) 统计元素数量(函数)
num = len(my_dict)
print(f"my_dict的元素数量为:{num}")
# --------------------------------------------------Container--------------------------------------------------
# list 可修改
# tuple 不可修改
# str 不可修改
# set 不重复 乱序 不支持下标索引 可修改
# dict 不重复 不支持下标索引 可修改
# 数据容器通用操作
# for 循环遍历
# len(name), max(name), min(name) (函数)
my_list = [1, 2, 3, 4, 5]
my_tuple = (1, 2, 3, 4, 5)
my_str = "abcdefg"
my_set = {1, 2, 3, 4, 5}
my_dict = {"key1": 1, "key2": 2, "key3": 3, "key4": 2, "key5": 1}
print(f"list 中最大的元素是:{max(my_list)}")
print(f"tuple 中最大的元素是:{max(my_tuple)}")
print(f"str 中最大的元素是:{max(my_str)}")
print(f"set 中最大的元素是:{max(my_set)}")
print(f"dict 中最大的元素是:{max(my_dict)}") # 以key来判断大小
# list,tuple,str,set 可互相转换: 转换类型(name)
# dict 可转换成其他类型,转换成str会保留value,但其他的会丢失value
# sorted : sorted(container, [reverse=True])
# reverse 默认False->从小到大排序;若想反转则赋值True->从大到小排序
my_list = [3, 1, 4, 2, 5]
small = sorted(my_list)
print(f"从小到大排序:{small}")
big = sorted(my_list, reverse=True)
print(f"从大到小排序:{big}")
#Function#
def test_return():
return '第', 5, True
x, y, z = test_return()
print(f"x={x},y={y},z={z}")
# 传参
def user_info(name, age, sex):
print(f"name:{name},age:{age},sex:{sex}")
# 位置传参
user_info("丁真", 23, "man")
# 关键字传参,可以不按顺序
user_info(age=23, sex="man", name="丁真")
# 混合,位置在前且得匹配顺序,关键字在后
user_info("丁真", sex="man", age=23)
# 缺省参数,若设置默认值必须在最后
def user_info(name, age, sex="沃尔玛购物袋"):
print(f"name:{name},age:{age},sex:{sex}")
user_info("Trump", 23)
user_info("丁真", 23, "男")
# 位置不定长
def user_info(*args):
print(f"args:{args}") # 所有参数都会被args收集并合并成一个元组(args是元组类型)
user_info("丁真", 23)
# 关键字不定长
def user_info(**kwargs):
print(f"kwargs:{kwargs}") # 所有键值对形式参数都会被kwargs收集并合并成一个字典(kwargs是字典类型),若不是键值对则会报错
user_info(name="丁真", age=18, sex="man")
# lambda 匿名函数
# character : 只可临时使用一次
# lambda 传入参数: 函数体(一行代码)
def test_func(compute):
result = compute(1, 2)
print(result)
test_func(lambda a, b: a + b)
# 等价于
# def test_func(compute):
# result = compute(1, 2)
# print(result)
#
# def compute(x, y):
# return x + y
#FileOperation#
# open : open(name, mode, encoding) (函数)
# name : 要打开的目标文件名
# mode : 设置访问模式(r:只读, w:写入(原内容被删除), a:追加)
# 若打开不存在的文件r报错,w和a会创建该文件
# encoding : 编码格式(UTF-8), 实际上encoding的顺序并不是第三位, 所以传入参数的时候要用关键字指定传入
# 打开文件
f = open("D:/pytest.txt", "r", encoding="UTF-8")
print(f"f类型为:{type(f)}")
# 读取文件-read(num) num:需要读取的字节长度,若不传入则表示读取全部数据
print(f"读取五个字节:{f.read(5)}")
print(f"全部读取:{f.read()}") # 从上次读取的地方继续读取,不论什么方法都是
print("---------------------------------------------------------------------")
# readLines() 读取全部行,并且返回的是列表,每一行的数据为一个元素
lines = f.readlines()
print(f"lines的type为:{type(lines)}")
print(f"lines:{lines}")
# readline() 一次读取一行
line = f.readline()
print(f"line的type为:{type(line)}")
print(f"line:{line}")
# for 循环读取
for line in f: # 每次读取一行
print("line")
# 文件的关闭
f.close()
# with open 运行过后自动关闭
with open("D:/pytest.txt", "r", encoding="UTF-8") as f:
for line in f:
print(f"每一行:{line}")
# ----------------------------------------文件的写入----------------------------------------
# 1. f=open("path", "operation", encoding=" ") 打开文件
f = open("D:/pytest.txt", "w", encoding="UTF-8")
# 2. f.write("content") 文件写入
f.write("oh yeah")
# 3. f.flush() 内容刷新
# 直接调用write,内容并未真正写入文件,而是积攒在程序的内存中,称之为缓冲区
# # 调用flush的时候内容才会真正写入文件,这样可以避免频繁的操作硬盘,导致效率下降
f.flush()
# 4. close()
f.close() # 其实close内置了flush功能
# ----------------------------------------文件的追加写入----------------------------------------
# 1. f=open("path", "operation", encoding=" ") 打开文件
f = open("D:/pytest.txt", "a", encoding="UTF-8")
# 2. f.write("content") 文件写入
f.write("oh yeah")
# 3. f.flush() 内容刷新
f.flush()
# 4. close()
f.close() # 其实close内置了flush功能
1929
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
