python语法学习
函数参数
参数顺序：必选参数、默认参数、可变参数和关键字参数
可变参数：不确定参数个数
这些可变参数在函数调用时自动组装为一个tuple。*args表示的是可变参数，*args接收的是一个元组
# 参数numbers是可变参数，表示输入的参数个数可以为任意值 def plus(*numbers): add = 0 for i in numbers: add += i return(add) # 调用3次plus函数，每次的参数个数都不相同 print(plus(1,2,3)) #6 print(plus(1,3,5,7,9)) #25 print(plus()) #0向函数中可以传递任意参数，包括0个参数
关键字参数
**kw表示的是关键字参数，**kw接收的是一个字典。
''' 而关键字参数允许我们传入任意个含参数名的参数，这些关键字参数在函数调用时自动组装为一个dict。 也就是说，关键字参数将长度任意的键-值对，作为参数传递给函数。例如： ''' def plus(**kw): #定义一个包含关键字参数的函数，返回值为参数值 return kw print(plus())#{}调用plus函数，参数值为空 print(plus(x=1))#{'x': 1}调用plus函数，参数值为x=1 print(plus(x=1, y=2))#{'x': 1, 'y': 2}调用plus函数，参数值为x=1,y=2
def plus(x,y,z): return x+y+z dict = {'x':1, 'y':2, 'z':3} # 用关键字参数的方法将dict列表中的3个值传入plus函数中，得到返回值d print(plus(**dict))# 相当于plus(dict['x'],dict['y'],dict['z'])
for循环的写法
#遍历从2到n-1 for i in range(2,n-1): if(n%i == 0): flag = False break
0.读取带权重的边列表文件（txt），并创建一个图
import networkx as nx # 读取带权重的边列表文件，并创建一个图 original_grapic_path = 'Cooperation_net/test.txt' with open(original_grapic_path, 'r', encoding='utf-8') as file: original_G = nx.read_weighted_edgelist(file, delimiter=",") print("Nodes:", original_G.nodes()) print("Edges:", original_G.edges())
1.图graph的方法
import networkx as nx G = nx.Graph() G.add_node(1) G.add_nodes_from([2, 3]) G.add_nodes_from([(4, {"color": "red"}), (5, {"color": "green"})]) G.add_node("spam") # adds node "spam" G.add_nodes_from("spam") # adds 4 nodes: 's', 'p', 'a', 'm' G.add_edge(1, 2) e = (2, 3) G.add_edge(*e) # unpack edge tuple* #添加边 G.add_edges_from([(1, 2), (1, 3)]) G.add_edge(3, 'm') print("图1-------------------------------------") print("节点:", G.nodes())#list(G.nodes) print("边:", G.edges())#list(G.edges) print('节点1的邻居',list(G.adj[1])) # or list(G.neighbors(1)) print('节点1的度',G.degree[1]) # edges() 方法用于返回图中与指定节点相关的边。 #G.edges([2, 'm']) 将返回一个列表，包含与节点 2 和节点 'm' 相关的所有边 G.edges([2, 'm']) print('节点数',G.number_of_nodes()) print('边数',G.number_of_edges()) G.clear() # 创建一个具有 10 个节点的路径图的函数调用。 # 路径图是一种特殊的图，其中节点按照线性序列连接，每个节点最多只有两个邻居，除了第一个和最后一个节点之外。 H = nx.path_graph(10) G.add_nodes_from(H) # 打印图的节点和边 print("图2-------------------------------------") print("Nodes:", G.nodes()) print("Edges:", G.edges()) G.clear() ''' nx.DiGraph() 是 NetworkX 库中的一个函数，用于创建一个有向图（Directed Graph）。在 NetworkX 中，图可以是无向的（即图中的边没有方向）或有向的（即图中的边有特定的方向）。DiGraph 是 "Directed Graph" 的缩写。 ''' DG = nx.DiGraph() DG.add_edge(2, 1) # adds the nodes in order 2, 1 DG.add_edge(1, 3) DG.add_edge(2, 4) DG.add_edge(1, 2) # DG.successors(2) 是 DiGraph 类的一个方法，它返回一个迭代器，包含节点 2 的所有后继节点（即有向边指向节点 2 的节点）。 # list(DG.successors(2)) 将这个迭代器转换成列表，这样就可以对它进行列表比较。== [1, 4] 检查这个列表是否等于 [1, 4]。 assert list(DG.successors(2)) == [1, 4] assert list(DG.edges) == [(2, 1), (2, 4), (1, 3), (1, 2)]
2.列表list
例：元组列表 [[1,2],[3,4]]删除1
lst = [[1,2],[3,4]] lst = [[element for element in sublst if element != 1] for sublst in lst] print('111=',lst) # 输出: [[2], [3, 4]]
例：过滤边，只保留与节点2，3有关的边
# 原始边列表 edges = [('1', '2'), ('1', '3'), ('2', '3')] # 特定的节点集合 specific_nodes = ['2','3']#{'2', '3'} # 过滤列表，如果边的两个节点都在 specific_nodes 集合中，则保留 edges = [edge for edge in edges if set(edge).issubset(specific_nodes)] print(edges)
语法
# 列表list fruit = ["苹果","梨子","菠萝","黄瓜","香蕉"] fruit2 = ["苹果2","梨子2","菠萝2","黄瓜2","香蕉2"] fruit3 = ["1","2","3","4","5"] ls = [1, 2, 3] a = "abcd" x = '瓜子' #添加 ls.append([4, 5, 6]) # [1, 2, 3, [4, 5, 6]] append 函数是把参数直接原封不动地添加到 ls 对象的尾部 ls.extend([4, 5, 6]) # [1, 2, 3, [4, 5, 6], 4, 5, 6] 而 extend 函数是把参数中的元素提取出来，然后再添加到 ls 对象的尾部 ls = [1, 2, 3] + [4, 5, 6] #[1, 2, 3, 4, 5, 6] # 删除 fruit.pop() print('fruit',fruit) fruit.pop(0) print('fruit',fruit) del(fruit[0]) fruit.remove('菠萝') fruit[0] = "Baidu" print(len(fruit)) #计算列表元素个数 print(fruit+fruit2) print(['Hi!',] * 4) #复制 print(x in fruit) print(max(fruit3)) print(min(fruit3)) print(list(a)) #将字符串转换为列表。 print(fruit2) #不需要循环，直接打印输出 ''' 切片访问[start:end:det] start 表示起点， end 表示终点， det 表示访问时下标每次的增量，即步长。 如果 det 值为 1 ，那么实际上就是获取 list 对象中，下标在 [start, end) 之间的所有元素(注意，这是数学上的左闭右开区间)。 对于 det 属于任意非 0 整数的情况，实际上就是获取 list 对象中，下标分别是start start+det start+det*2 …… start+det*i的元素，构成的新列表。其中 |start+det*i| < |end| ，且 i∈N ，注意双竖线 || 表示取里面的绝对值，因为考虑到负数下标的问题。 ''' ls = [1, 2, 3] print(ls[-3], ls[-2], ls[-1]) # 1 2 3 print(ls[0:]) # [1, 2, 3] 通过切片的方式，将下标从0开始到最后一个元素的切片输出，当然如果是输出整个ls的话‘0’可以省略 print(ls[-1::-1])# [3, 2, 1]通过切片的方式，将下标从-1开始到第一个元素的切片输出，当然如果是逆序输出整个ls的话，第一个‘-1’可以省略
3.集合
# 集合 s = set() #创建空集合不可以{}， { } 是用来创建一个空字典。 s = set([1, 1, 2, 2, 3, 3]) #对列表去重，重复元素在 set 中自动被过滤，即去重功能：s = {1, 2, 3} len(s) s.add(3) #可以重复添加，但不会有效果：s = {1, 2, 3} s.remove(3) #删除元素 4，而不是索引位置 4 fruit = {"苹果","梨子","菠萝","黄瓜","香蕉"} x = '瓜子' fruit.add(x) print(x in fruit) a = {1,2,3,4} b = {4,5,6,7} a - b #{1,2,3} a | b #并{1,2,3,4,5,6,7} 集合a或b中包含的所有元素 a & b #{4} 集合a和b中都包含了的元素 a ^ b #{1,2,3,5,6,7}不同时包含于a和b的元素
4元组
#元组 元组的元素不能修改 tup1 = () tup1 = (50,) tup2 = (1,2,3,"abc",(1,2,3,"abc"),[1,2,3,"abc"]) tuple = (1,2,3,4) x = [1,2,3,4] tup3 = tup1 + tuple print(tup3) print(len((1, 2, 3))) print(('Hi!',) * 4) print(3 in (1, 2, 3)) print(len(tuple)) #计算元组元素个数。 print(max(tuple)) print(min(tuple)) # print(tuple((1,2,3,4))) #将列表转换为元组。(1,2,3) # del(tup2[1])
5.字典
# 字典 dict = {'Alice': '2341', 'Beth': '9102'} print(dict) menu = {'鱼':40, '猪肉':30, '番茄':15, '拉面':10} menu['果汁'] = 12 #添加元素 menu['鱼'] = 50 #修改字典中的值 del menu['拉面'] #删除
6.字符串
# 字符串 first_name = "John" last_name = "Doe" full_name = first_name + " " + last_name full_name = "{} {}".format(first_name, last_name) full_name = f"{first_name} {last_name}" print(full_name) # 输出：John Doe print(first_name, last_name) # 输出：John Doe len(first_name) #长度 source_string = 'abc' source_string.upper()#将源字符串转换为大写 source_string.lower() source_string.title() #将源字符串每个词首字母转换为大写 source_string.strip() #可以去除字符串两侧（不包含内部）全部的空格,。 hello_world = ' **The world ** is big!* ' hello_world.strip() hello_world.strip('TH *')# he world ** is big! 使用该方法，也可以通过指定参数，去除两侧指定的特定字符。 # 字符串查找 # 如果该字符串中，有一个或者多个子字符串，则该方法返回第一个子串所在位置的最左端索引，若没有找到符合条件的子串，则返回-1。 source_string.find('ab') source_string.replace('a', 'b') # 用以替换给定字符串中的子串 #实现字符串分割,将一个字符串分割为字符列表 source_string = '1+2+3+4+5' print(source_string.split('+')) #['1', '2', '3', '4', '5'] print(source_string.split('/')) #['1+2+3+4+5'] # print print("Hello", "World", sep="-", end="!\n") # 输出：Hello-World!
7.栈
# 栈 class Student(): def __init__(self, name, age): #构造函数，Python 中类的方法的第一个参数始终是 self self.name = name #赋值给成员变量，且成员变量是通过将 self. 作为前缀引出 self.age = age def __repr__(self): # 当实例作为 print 函数的参数时，就会输出实例的 __repr__ 的返回值 return f'Name: {self.name}\nAge: {self.age}' stu = Student('Zhang', 15) print(stu)# Name: Zhang Age: 15 class Stack(): def __init__(self, size=5): self.size = size self.stack = [] self.top = -1 def is_full(self): #判满 true return self.top+1 == self.size def is_empty(self): #判空 true return self.top == -1 def push(self, x): #请在此添加代码，实现将元素x入栈，并在栈满时不进行操作 #********** Begin *********# if not self.is_full(): self.stack.append(x) self.top += 1 #********** End *********# def pop(self): #请在此添加代码，实现将栈顶元素出栈，并栈顶元素作为返回值返回，栈空时不进行操作 #********** Begin *********# if not self.is_empty(): self.top -= 1 return self.stack.pop() #********** End *********# def __repr__(self): return str(self.stack)
9.datetime
import datetime print(datetime.date(2020,2,29)) #2020-02-29 print(datetime.date.today()) #2024-10-16 print(datetime.date.fromtimestamp(9999999.99)) #1970-04-27 print(datetime.datetime.today()) #2024-10-16 16:29:35.829056 print(datetime.datetime.today().strftime('%Y-%m-%d %H:%M:%S')) #2024-10-16 16:29:35 print(datetime.datetime.now())#2024-10-16 16:29:35.829195 print(datetime.datetime.now().time()) #16:29:35.829327 # print(datetime.fromtimestamp(999999999.99)) #16:29:35.829327返回与 UNIX 时间戳对应的本地日期和时间。 print(datetime.time(23,14,15,1999)) #23:14:15.001999 print(datetime.timedelta(10)) #10 days, 0:00:00 print(datetime.datetime.today()+datetime.timedelta(10)) #2024-10-26 16:45:02.182753 10天后 print(datetime.timedelta(weeks=5)) #35 days, 0:00:00 print(datetime.date(2020,1,29)-datetime.timedelta(weeks=5)) #2019-12-25 5周前 print(datetime.date(2020,1,29)+datetime.timedelta(weeks=-5)) #2019-12-25 5周前 print("-------------------------------------------")
10 os （未测试）
# import os # fd = os.open('example.txt', os.O_RDWR | os.O_CREAT) # #os.O_RDWR 是一个标志，表示以读写模式打开文件。这意味着你可以从文件中读取数据，也可以向文件中写入数据。 # #os.O_CREAT 是另一个标志，表示如果文件不存在，则创建它。 # print("写入前",os.read(fd,100)) # os.close(fd) # print("-------------------------------------------") # with open('example.txt', 'r+', encoding='utf-8') as file: # print('写入前',file.read()) # ## 文件会自动关闭，无需调用 f.close() # file.write('123') # print("-------------------------------------------") # dirname, basename = os.path.split('/community_results/peeledTheory of Computer Science.txt') # print('Directory:',dirname) # 输出：/home/user # print('File:',basename) # 输出：file.txt # # 检查路径名是否存在 # print(os.path.exists('/HonorStoreDownload/WebCache')) # 输出：False # # 检查路径名是否是一个文件 # print(os.path.isfile('/community_results/peeledTheory of Computer Science.txt')) # False # # 检查路径名是否是一个目录 # print(os.path.isdir('/community_results')) # 输出：False # print("-------------------------------------------") # # 检查当前用户是否有权访问指定的文件 # print(os.access("test.py", os.R_OK)) # # 更改指定文件的权限模式 # os.chmod("test.py", os.R_OK) # # 输出结果 # print(os.access("test.txt", os.R_OK)) # print("-------------------------------------------") # # 列出指定目录的所有文件和子目录 # print(os.listdir('/')) # os.mkdir('new_directory') # print("Directory 'new_directory' created") # # 递归创建目录 # os.makedirs('new_directory/sub_directory') # # 输出结果 # print("Directory 'new_directory/sub_directory' created") # #创建空目录 # os.makedirs('empty_directory/sub_directory') # #删除空目录 # os.removedirs('empty_directory/sub_directory') # #输出结果 # print("Empty directories removed") # with open('original_file.txt', 'w') as f: # f.write('This is a test file.') # #重命名文件 # os.rename('original_file.txt','renamed_file.txt') # #输出结果 # print("File 'original_file.txt' renamed to 'renamed_file.txt'") #内置模块的内置函数
12globals().和locals()
''' globals()和locals()函数可被用来返回全局和局部命名空间里的名字 如果在函数内部调用的是globals()函数，那么返回的是所有在该函数里能够访问的全局名字。 如果在函数内部调用的locals()函数，返回的是能够在该函数里访问的局部命名。 globals()函数和locals()函数的返回类型都是字典，所以名字们能用keys()函数摘取 '''
13reload()函数
''' reload()函数 当一个模块被导入到一个脚本中后，程序只会将模块顶层部分的代码执行一次。 因此，如果我们想再次执行模块顶层部分的代码，可以用reload()函数。 该函数便会重新将之前导入过的模块导入。 格式如下reload(module_name),module_name要直接放模块名，而不能是一个字符串形式 '''
14引入其他文件
# 引入其他文件的方法 from pyyuan import plus print(plus(1,2))
pyyuan.python中
def plus(a,b): return a+b
15lambda函数
''' lambda函数又称匿名函数 匿名函数不需要return来返回值，lambda函数表达式本身的计算结果就是返回值 ''' f = lambda x,y:x+y print(f(1,2)) list1 = [2,3,-5,0,-4,-8,-1] # def f(x): # return abs(x) # list2=sorted(list1, key=f) list2=sorted(list1, key=lambda x: abs(x)) print(list2) MAXIMUM = lambda x, y: x if x > y else y MINIMUM = lambda x, y: x if x < y else y print(MAXIMUM(1,2)) print(MINIMUM(1,2))
16map()
''' map()用于映射，reduce()用于归并 map()函数会根据传入的函数对指定的序列做映射。 map()函数接收两个参数，一个是function函数，另一个参数是一个或多个序列。 map()函数会将传入的函数依次作用到传入序列的每个元素，并把结果作为新的序列返回。 map()函数的定义为：map(function, sequence[, sequence, ...]) -> list 当map()函数传入的序列有多个时，我们要注意function函数的参数数量，应和map()函数传入的序列数量相匹配 简单来说：function并行的作用于传入序列的每一个元素，返回列表[] ''' r = map(lambda x: x ** 2, [1, 2, 3, 4,]) print(list(r)) #[1, 4, 9, 16] r = map(lambda x, y: x + y, [1, 2, 3, 4, 5], [6, 7, 8, 9, 10]) print(list(r)) print(list(map(str,'python'))) #['p', 'y', 't', 'h', 'o', 'n'] print(list(map(str,[2, 2, 2, 2, 5]))) #['2', '2', '2', '2', '5'] print('*'.join(map(str,result))) #2*2*2*2*5
17reduce()
''' reduce()函数把传入的函数作用在一个序列[x1, x2, x3, ...]上，且这个函数必须要接收两个参数。 reduce()函数把第一次计算的结果继续和序列中的下一个元素做累积计算。 reduce()函数的定义为：reduce(function, sequence[, initial]) -> value function参数是有两个参数的函数， reduce()函数依次在序列中取元素，并和上一次调用function函数的结果做参数，然后再次调用function函数。 ''' from functools import reduce r = reduce(lambda x, y: x + y, [1, 2, 3, 4, 5],6) print(r) #((((((1+6)+2)+3)+4)+5))
18sys
import sys print(sys.argv[0]) #d:/ljj/大/detteam/team/puthon_study.py print(sys.argv[1:]) #[] print(sys.platform) #win32 print(sys.version) # 3.13.0 (tags/v3.13.0:60403a5, Oct 7 2024, 09:38:07) [MSC v.1941 64 bit (AMD64)] # print(sys.modules) print(sys.path) # ['d:\\ljj\\大\\detteam\\team', 'D:\\soft\\python313\\python313.zip', 'D:\\soft\\python313\\DLLs', 'D:\\soft\\python313\\Lib', 'D:\\soft\\python313', 'D:\\soft\\python313\\Lib\\site-packages']
19异常相关
''' 异常相关 ''' # print(sys.exc_info())#返回当前异常的相关信息，包括异常类型、异常值和异常追踪信息。 # print(sys.exc_clear()) #清除当前异常。 # print(sys.exc_type) #是一个变量，保存了当前异常的类型。 # print(sys.exc_value) #是一个变量，保存了当前异常的值。 # print(sys.traceback) #是一个变量，保存了当前异常的追踪信息。 # sys.exit(0)
20正则表达式
''' 正则表达式 [a] 示匹配单个小写字符 a [abcde] 匹配abcde之中的任意一个字符 [a-d］ 表示匹配 a 、 b 、 c 、 d 中的任意一个字符， . 匹配除\n以外的任何字符（注意元字符是小数点） [^fgh] 不与fgh之中的任意一个字符匹配 \w 匹配大小写英文字符及数字0~9中的任意一个及下画线，相当于[a-zA-Z0-9」 \W 不匹配大小写英文字符及数字0~9中的任意一个，相当于[^a-zA-Z0-9] \s 匹配任何空白字符，包括空格、制表符、换页符等。等价于[\f\n\r\t\v]。 注意：Unicode正则表达式会匹配全角空格符 \S 匹配任何非空白字符。等价于[^\f\n\r\t\v] \d 匹配任何0~9中的单个数字，相当于[0-9] \D 不匹配任何0~9中的单个数字，相当于[^0-9] \b 匹配一个单词边界，也就是指单词和空格间的位置。 例如，er\b可以匹配 never中的er,但不能匹配verb中的er \B 匹配非单词边界，er\B能匹配verb中的er,但不能匹配never中的er \t 匹配一个制表符。 \v 匹配一个垂直制表符。 \f 匹配一个换页符。 \n 匹配一个换行符。 \r 匹配一个回车符。 \cx匹配由x指明的控制字符。例如，cM匹配一个Ctr+M或回车符。x的值必须为A~Z或a~z之一。 举例 abc5def 12345 5 ttt \b 匹配一个单词边界，也就是指单词和空格间的位置。 8 never和ever er\b er 无匹配 abc12345B CD \a或a或[a] 匹配字母a abc babc12345B CD b b 匹配字母b \b[b]\b（独立的b） abc12345B CD [B]匹配大写字母B aac、abc、acc、adc、a1c、a2c、ac、a#c \a.c 匹配以a开头，以c结尾，中间有一个字符的词 filename.txt hello.py hi.exe filename.txt 匹配文件：filename.txt 正则表达式限定符 ^ 匹配输入字符串的开始位置。[^]除非在方括号表达式中使用，此时它表示不接受该字符集合。 $ 匹配输入字符串的结束位置。如果设置了RegExp对象的Multiline属性，则'$'也匹配'\n'或'\r'。（有示例）要匹配'$'字符本身，使用'\$'。 () 将位于()内的内容当作一个整体。 []匹配括号中的任何一个字符。例如，“b[an]g” 可以匹配“bag”“bng” 但是不能匹配“big”“bang”。 []中还可以使用“”来表示某一范围，例如，“[0-9]”表示从 “0”到“9”的所有数字，等价于“a[0123456789]c”，所以“a[0-9]c” 就可以匹配“a0c”“alc”…“a9c”等多个字符串。 []还可以指定多个区间，例如，[a-zA-Z0-9] 表示任意的字母和数字。 {} 按{}中的次数进行匹配。 例如：正则表达式 A[0-9]{3}能够匹配字符"A"后面跟着正好3个数字字符的串，例如A1234 结果A123。 {n} n是一个非负整数。匹配确定的n次。 {n,} n是一个非负整数。至少匹配n次。 {n,m} ：m和n均为非负整数，其中，n≤m。最少匹配n次且最多匹配m次。正则表达式[0-9]{4,6}匹配连续的任意4个、5个或者6个数字 * 匹配位于*之前的0个或多个字符。 ? 匹配位于?之前的0个或一个字符。 + 匹配位于+之前的一个或多个字符。正则表达式9+ 99 99 \ 表示位于\之后的为转义字符。如'\m'匹配字符'm'，'\n'匹配换行符。 | 匹配位于|之前或者之后的字符。 逻辑“或”运算（Or）。 x|y 匹配x或者y ''' # 1.字符串匹配re.match() import re print(re.match('[a]','abc')) #<re.Match object; span=(0, 1), match='a'> print(re.match(r"\d+", '我叫pp，我今年21岁啦，id是200，班级为3年2班')) # 2.字符串查找re.search()、re.findall() print(re.findall("a", '这是一个sfdfaadv'),len(re.findall("a", '这是一个sfdfaadv'))) # ['a', 'a'] print(re.findall(r"\d+", '这是一个1234567890')) # ['1234567890'] print(re.search(r"\d+", '我叫pp，我今年21岁啦，id是200，班级为3年2班').group()) # 3.字符串替换re.sub() # 4.字符串分割re.split() # compile obj = re.compile(r"\d+") # 直接使用已经加载好的正则表达式 print(obj.findall('我叫pp，我今年21岁啦，id是200，班级为3年2班')) # !!! print(re.findall("a", '这是一个sfdfaadv'),len(re.findall("a", '这是一个sfdfaadv'))) # ['a', 'a'] # 1. 提取邮箱地址： # 给定一个字符串，编写一个正则表达式来提取其中的所有电子邮件地址。 str = re.findall(r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b', '请联系我们通过email@example.com或者support@example.co.uk获取更多信息') print(str,len(str)) # 2. 验证电话号码： # 编写一个正则表达式来验证字符串是否为有效的电话号码格式，例如： (123) 456-7890 。 # str = re.findall("a", '这是一个sfdfaadv') # print(str,len(str)) # 3. 替换字符串中的日期格式： # 将字符串中的日期从 dd/mm/yyyy 格式替换为 yyyy-mm-dd 格式。 # str = re.findall("a", '这是一个sfdfaadv') # print(str,len(str)) # 4. 查找重复的单词： # 编写一个正则表达式来查找字符串中连续出现两次的单词。 # str = re.findall("a", '这是一个sfdfaadv') # print(str,len(str)) # 5. 删除字符串中的HTML标签： # 给定一个包含HTML标签的字符串，编写一个正则表达式来删除所有的HTML标签。 # str = re.findall("a", '这是一个sfdfaadv') # print(str,len(str)) # 6. 提取URL中的协议和域名： # 编写一个正则表达式来提取URL中的协议（例如http或https）和域名。 # str = re.findall("a", '这是一个sfdfaadv') # print(str,len(str)) # 7. 检查字符串是否为有效的IPv4地址： # 编写一个正则表达式来验证一个字符串是否为有效的IPv4地址。 # 8. 提取字符串中的数字： # 编写一个正则表达式来提取字符串中的所有数字。 # str = re.findall("a", '这是一个sfdfaadv') # print(str,len(str)) # 9. 检查字符串是否只包含字母和数字： # 编写一个正则表达式来验证一个字符串是否只包含字母和数字。 # str = re.findall("a", '这是一个sfdfaadv') # print(str,len(str)) # 10. 分割字符串： # 编写一个正则表达式来分割字符串，以非字母数字字符作为分隔符。 # str = re.findall("a", '这是一个sfdfaadv') # print(str,len(str))
str()
把列表/元组/字符串的每个元素变成了str类型，然后以列表的形式返回
print(list(map(str,'python'))) #['p', 'y', 't', 'h', 'o', 'n'] print(list(map(str,[2, 2, 2, 2, 5]))) #['2', '2', '2', '2', '5'] print('*'.join(map(str,result))) #2*2*2*2*5
数学运算
abs()
返回数值的绝对值
print(abs(-4)) #4
divmod()
返回两个数值的商和余数
print(divmod(7,2)) #(3, 1)
max()
返回元素中的最大值
min()
返回元素中的最小值
sum()
返回传入元素之和
bool()
print(bool()) #False print(bool(1)) #True print(bool(0)) #False print(bool('st4')) #True
int()
print(int('3')) #3 print(int(3.7)) #3
float()
print(float()) #0.0 不提供参数的时候，返回0.0 print(float(3)) #3.0 print(float('3')) #3.0
complex()
根据传入的参数创建一个新的复数
print(complex() ) #0j 当两个参数都不提供时，返回复数0j print(complex('2+4j')) #(2+4j) print(complex(1,2)) #(1+2j)
math
#math vvvvv import math
from math import pi as PI
c=1.22222 print(math.ceil(2.4)) #向上取整 print(math.floor(2.4)) #向下取整 print(math.ceil(-2.4)) print(math.floor(-2.4)) print(math.pow(5,3)) #x的y次幂 print(math.sqrt(3.6)) #平方根 print(math.log(125,5)) print(math.degrees(0.5*math.pi)) #弧度转化为角度 print(math.radians(180/math.pi))#角度转化为弧度 print(math.sin(0.3)) #sinx print("{:.3f}".format(c)) #保留三位小数
序列操作
all()
判断可迭代对象的每个元素是否都为True值
print(all([1,2,3]) ) #True 列表中每个元素逻辑值均为True，返回True print(all([0,1,2])) #False print(all(()) ) #True空元组
any()
判断可迭代对象的元素是否有为True值的元素
print(any([1,2,3]) ) #True print(any([0,1,2])) #True print(any([]) ) #False空列表
sorted()
对可迭代对象进行从小到大排序，返回一个新的列表
print(sorted(['a','b','d','c','B','A']) ) #['A', 'B', 'a', 'b', 'c', 'd']默认按字符ascii码排序
对象操作
help()
返回对象的帮助信息
dir()
返回对象或者当前作用域内的属性列表
''' dir()函数是一个排好序的字符串列表， 其内容是一个模块里定义过的名字，包含在一个模块里定义的所有模块、变量和函数。例如： ''' print(dir(math)) #输出了math模块中所有模块、函数和变量的名字 # ['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs','factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'pi', 'pow', 'radians', 'sin','sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc']
交互操作
print()
input()
文件操作
open()
使用指定的模式和编码打开文件，返回文件读写对象
import os print(os.getcwd()) #D:\ljj\my a = open('test.txt','rt') #文件要放在D:\ljj\my下 print(a.read()) a.close()
