Python 考试应急笔记（X）,（更新中。。。

目录

Python

第二章：数据类型

python内置类型中不可变类型有str, int, float, boolean, tuple；可变类型有list, dict, set。

相应的方法

  1. 查看数据类型：type(变量名)
a = 1
print(type(a))
>> <class 'int'>

  1. 地板：\\

    返回整数部分（向上取整）

    注意：如果要返回值为小数时，必须除数与被除数之中至少有一个为小数

print(5/2)
print(5//2)
print(5.0//2)
>> 2.5
>> 2
>> 2.0

字符串

  1. 字符串：这里约定下面的str皆代表String变量名

    先在开头指出，不要试图使用形如s[0] = "a" 的方式修改原有字符串，因为字符串本身不支持修改。

    如果你尝试这么做，将会得到TypeError: 'str' object does not support item assignment

    • 自然字符串：指出不需要如转义字符特殊处理，通常可在字符串前面添加r

      a = r'new are in by \n'#自然字符串
aa = 'new are in by \n'
print("~~~"+a+"~~~")
print("----"+aa+"----")
>> ~~~new are in by \n~~~
>> ----new are in by 
>> ----

    • 字符串的拼接操作：

    print("Hellow"+" world"+"\n")#将三个字符串(包含最后的一个转义字符)连接在一起
print("Hellow "*5)			#重复五次将一个字符串拼接在一起
>> Hellow world
>> 
>> Hellow Hellow Hellow Hellow Hellow

    • 字符串的索引：

      1）index下标索引规则与Java一致，都是 [0,length-1] 的

      2）可通过[index]的方式来访问字符串的对应元素

      3）切片访问方式，从末尾倒着来减即从右到左 表现形式为：str[-1] 则表示为末尾最后一个

      a = "Hellow world"
print(a[0])
print(a[a.__len__() - 1])#str.__len__()->返回str中的元素个数 也可替换为 len(a)
print(a[-2])
>> H
>> d
>> l

    • 字符串的切片：

      1）从字符串取出指定部分，其表现形式为：str[所需取出目标头下标:所需去取出目标为下标+1]

      值得注意的是：这里的下标也是从0开始的，且区间为左闭右开:[j:k)

      a = "Hellow world"
print(a[0:6])#所取下标范围：[0,5]
>> Hellow
print(a[-5:a.__len__() - 1])#用的是下标索引方式自然可以倒着取：从倒数第五个 取到最后一个，		
>> worl

      2.1）变形扩展，其中切片里面的下标可以省略但是：不能省略：即str[:] 其中哪块部分省略了表示默认

      从头开始/取到末尾，上面的就表示：从头开始取到字符串末尾。

      print(a[:])
>> Hellow world
print(a[1:])	#省略第二下标，则表示从1开始取到末尾
>> ellow world
print(a[:-1])	#省略第一下标，表示从头取到倒数第二个元素,因为左闭右开，所以取不到倒数第一位，取前面那位
>> Hellow worl

      2.2) 变形扩展，添加第三参数，设置切片步长，其表现形式为：

      str[所需取出目标头下标:所需去取出目标为下标+1:每个多少个元素索引一次]

      这里的步长还可以为负数，与正数表示从头分组相反，这表示从末尾开始分组

      a = "123456789"	#为了方便理解，这里的字符串使用数字形式
print(a[::3])	#每三元素为一组[1,2,3][4,5,6][7,8,9]索引一次
print(a[::9])	#每九元素为一组[1,2,3,4,5,6,7,8,9]索引一次
print(a[::10])	#每十元素为一组[1,2,3,4,5,6,7,8,9]索引一次，但实际上现有元素凑不到，将就9个
print(a[::4])	#每四个元素为一组[1,2,3,4][5,6,7,8][9]
>> 147
>> 1
>> 1
>> 159
#相信聪明的你一定发现了都是取分组里面的第一个元素 :)

a = "123456789"
print(a[::-1]) 	#表示从末尾开始取，每一位分成一组，每组索引一次，放在开头位置
print(a[::-9])	#表示从末尾开始取，每九位分成一组，每组索引一次，与正数相同，都是取分组中的头一位
print(a[::-10])
print(a[::-4])	#每四个元素为一组[9,8,7,6][5,4,3,2][1],每组索引一次，都是取分组中的头一位
>> 987654321
>> 9
>> 9
>> 951

    • 其他的一些操作

    ​ 1）字符串包含判断in not in

    "a" in "bac" #True
"a" not in "bac" #False

    ​ 2）char 与 对应的ASCII 码之间的转换

    print(ord('a'))	#char  转	ASCII
print(chr(97))	#ASCII 转	char
>> 97
>>  a

    ​ 3）查找目标子串第一次出现的下标，其表现形式为：str.find(目标字串,查找范围的起始下标,查找范围的结束下标)

    a= "Hellow lowworld"
print(a.find('low' , 0,a.__len__()))
>> 3

    ​ 4）rfind 表示反着找

    a= "Hellow lowworld"
print(a.rfind('low' , 0,a.__len__())) #由于是方向查找，故会找到第二个low，即下标为7的'low'
>> 7

    ​ 5）字符串分割：str.split() 将字符串分割成list形式， 默认以空格分割，如需指定分割符号需要在括号内填写

    ​ 分割之后，指定的分割符号将不存在分割结果里面

    a= "Hellow world"
print(a.split())			#默认以空格' '作为分隔符
print(a.split("w"))			#自定义    'w'作为分隔符
>> ['Hellow', 'world']
>> ['Hello', ' ', 'orld']	#结果里面将不存在分割符号'w'
#其中split(指定分割符,分割次数)，可以指定其从左往右的分割次数

    ​ 6）字符串的修改：

    ​ 可利用str.replace() 方法，注意，这不会改变原字符串

    ​ 也可利用slice切片技术

    a= "Hellow world"
print(a.replace('H','h'))
print(a)
>> hellow world
>> Hellow world				#并未修改原字符串

#slice方法
index= 5		    		#定义修改的下标为5
newStr= "W"					#定义修的修改元素为'W'
a = a[:5]+newStr+a[index+1:]  #原理：取出[0:4]+ newStr +[6:] => Hello + W +  world
print(a)
>> HelloW world

    7）去除字符串中的空格 下面的三个方法都可以传入参数，作为指定的去除在字符串中的（首尾）元素。

    且，以下三个方法都不会修改原字符串

    #str.strip()	去除字符串两边的空格
a = "abc a yes or a no abc"
print("去除首末位的'abc'元素：{0}".format(a.strip("abc")))
>> 去除首末位的'abc'元素： a yes or a no 
# 该方法从左往右扫描时发现原字符串的头"abc"部含有'a' 'b' 'c'
# 刚好都是在{'a','b','c'}中的，故全删除，当遇到空格时停止从左往右扫描，哪怕后面的a也是符合要求的
#从右往左也同理

print("去除首末位的'ab'元素：{0}".format(a.strip("ab")))
>> 去除首末位的'ab'元素：c a yes or a no abc
# 该方法从左往右扫描时发现原字符串的头"abc部含有'a' 'b'
# 刚好都是在{'a','b'}中的，故全删除，当遇到'第三个字符'c' 时发现不符合要求，不在{'a','b'}，停止从左往右扫描
#从右往左也同理,右边第一个'c'就不符号要求，就直接停止扫描了

print("去除首末位的'bc'元素：{0}".format(a.strip("bc")))
>> 去除首末位的'bc'元素：abc a yes or a no a
#与上述原理相同

#str.lstrip()	去除字符串左边的空格
只不过相对于 str.strip() 少了从右往左的扫描

#str.rstrip()	去除字符串右边的空格
只不过相对于 str.strip() 少了从左往右的扫描

    8）join() 连接方法，其表现形式为："指定分隔符".join(需要拼接的例表或元组变量名)

    注意：这里的拼接元素只允许是str类型

    可视为，join() 与 split() 互为相逆过程

    #以指定分隔符将列表或元组所拥有的元素连接起来
# 连接列表
list1 = ["114","*","514"]
print("~".join(list1))
>> 114~*~514

#连接元组
tuple1 = (114,514)#非str类型
print("~".join(tuple1))
>> TypeError: sequence item 0: expected str instance, int found

tuple2 = ("114","#","514")
print("~".join(tuple2))
>> 114~#~514

    9）判断是相关数字与字母

    str.isalnum()

    如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False

    str.isalpha()

    如果字符串至少有一个字符并且所有字符都是字母或文字则返回 True，否则返回 False。

    str.isascii()

    如果字符串为空或字符串中的所有字符都是 ASCII，则返回 True，否则返回 False。

    str.isdigit()

    如果字符串只包含数字则返回 True 否则返回 False。

输入与输出

  • 输入与输出

    输出 print()

    a= "Hellow lowworld"
print(a[0],a[2],a[3])                   #将多行打印在一行
print(a[0],a[2],a[3],end="^*^")     #并以"*"结尾
>> H l l
>> H l l^*^
#也可以类似于java中 用字符串中format方法
print("这是第一个：{0}\t这是第二个：{1}".format(a[0],a[1]))
>> 这是第一个：H   这是第二个：e

    输入 input() 值得注意的一点是，input 所接受的只会转换成str，也就是说，就是你用键盘输入的int 的123，

    input 接受转换之后的也是str 的“123”，若想正确抓换成int类型，前面得加类型转换int()

    a = input("这是要打印在屏幕上的内容\n")
print("a type is: {0} and conten is: {1}".format(type(a),a))
>> 这是要打印在屏幕上的内容
>> 123										输入int类型123
>> a type is: <class 'str'> and conten is: 123  输出的还是str类型
        
aa= int(input("这是要打印在屏幕上的内容2\n"))	  进行类型的转换
print("int(a) type is: {0} and conten is: {1}".format(type(aa),aa))
>> 这是要打印在屏幕上的内容2
>> 123
>> int(a) type is: <class 'int'> and conten is: 123

  • range(n)函数

    用于生成 0 ~ n-1 的长度为 n 的序列；我们也可以自定起始点和终点和步长

    #list() 方法用于将序列转化为列表
print(list(range(5)))		#默认从0开始到n-1
print(list(range(2,5)))		#从2开始到4 ：左闭右开
print(list(range(0,5,2)))	#从0开始到4，步长为2
>> [0, 1, 2, 3, 4]
>> [2, 3, 4] 
>> [0, 2, 4]

元组

  • 元组 tuple 圆括号表示：()

    类似的，与str一样，自身并不支持修改元组内的元素tuple[0] = 11其中就包括添加与删除,但是它可以包含一个可变对象，例如list；以及可以进行下标从0开始的切片操作tuple[0:]，返回的是元组，注意区别tuple[0]返回的是元素而非元组

    1）元组创建

    tuple1 = ()		#空元组
tuple2 = (20,)	#创建只有一个元素的元组，注意不能写成 tuple2 = (20) 这是一个int类型
tuple3 = (20)
print(type(tuple1),type(tuple2),type(tuple3))
>> <class 'tuple'> <class 'tuple'> <class 'int'>

    其中内嵌方法有：len(tuple)->计算元组中元素个数

    ​ max(tuple)->返回元组中元素的最大值

    ​ min(tuple)->返回元组中元素的最小值

    2）元组解包

tuple2 = (20,30)
a,b = tuple2		#其中等式左边元素个数要等与元组里面的对象个数
print(a,b)
>> 20 30

列表

  • 列表 list 中括号表示： []

    类似于元组，字符串，下标都是从0开始，支持切片(同样为左闭右开)和索引，支持从右往左查找 list(-1)代表最右边的第一个元素，list(-2)代表最右边第二个元素，以此类推。list(-len(list))为最左边的第一个元素。

    但不同于前两者的是：列表支持修改操作

    1）列表创建

    list1 = [] 								#空列表
list2 = [1]								#有一个参数的列表
list3 = list(range(4))					#利用range生成0~3序列的列表
print(type(list1),type(list2),type(list3))
>> <class 'list'> <class 'list'> <class 'list'>
>> [] [1] [0, 1, 2, 3]

    2）切片

    list3 = list(range(4))
print(type(list3[0:1]),type(list3[3:3]))
>> <class 'list'> <class 'list'>			#切片返回的是一个列表，哪怕没有切到任何元素
>> [0] []

    3）列表的添加操作

    # 1）使用+串联方法添加两个
list1 = ["I","can","love","you"]
list1 =  list1+["also","you","can"]		#+串联操作
print(list1)
>> ['I', 'can', 'love', 'you', 'also', 'you', 'can']

# 2）使用slice方法在指定位置添加 可迭代对象
list1[len(list1):len(list1)] = "?"		#使用切片技术 在list1的位置len(list)插入"?"
# list1[len(list1):len(list1)] = 1  	Error : 当使用切片修改元素时，所赋的值必须为迭代对象，如list，或者 tuple				
# list1[len(list1):len(list1)] = [1]	True
print(list1) 
>> ['I', 'can', 'love', 'you', 'also', 'you', 'can', '?']

# 3）使用list自带方法list.append()	其可添加：list，数，字符串等
list1 = ["I","love"]
list1.append("python")
list1.append(3.5)
print(list1)
>> ['I', 'love', 'python', 3.5]

# 4）使用list自带方法list1.extend(list1)	将两个列表合并 类似于 list = list + list1
list1 = ["I","love"]
list2=["you"]
list1.extend(list2)
print(list1)
>> ['I', 'love', 'you']
# extend()于append()的区别为：前者不能添加单个元素，后者可以
list2.extend("you") 
#结果为 ['you', 'y', 'o', 'u'] 不难看出，自动对"you" 用了list("you") 方法 转换成了['a','b','c']
list2.extend(3.5)	#不能添加单个元素值，必须为可迭代类型
#TypeError: 'float' object is not iterable

# 5）使用list自带方法list1.insert(index,var) index=插入下标，var=插入元素
list1 = ["can","love","me","?"]
list1.insert(1,"you")			#在下标为1的地方插入"you" 元素
print(list1)
>> ['can', 'you', 'love', 'me', '?']

    可以使用list(str)的方法，将str转换为list 如：list("abc") = ['a','b','c']

    4）列表的删除操作

    # 1）使用list自带的list.pop()方法删除
list1 = ['can', 'you', 'love', 'me', '?']
list1.pop(0)							#删除下标为0的元素 "can"
print(list1)							
>> ['you', 'love', 'me', '?']
list1.pop()								#默认删除最后一个元素 "?"
print(list1)
>> ['you', 'love', 'me']

# 2）使用del list方法删除
#	1.1)del list[index] 删除下标为index位置的元素
#	1.2)del list[m:n]   删除指定范围的元素
list1 = ["you","love","me","?"]
del list1[len(list1)-1]			#删除下标位置为len(list1)-1的元素
print(list1)
>> ['you', 'love', 'me']
del list1[1:3]				   #删除下标位置为[1,2]的元素，注意给定区间为左闭右开
print(list1)
>> ['you']

# 3)也可以使用切片
list1 = ["you","love","me","?"]
list1 = list1[:-3]
print(list1)
>> ['you']

    5）排序

    import copy

listx = [];
for  i in range(1,5):
    listx.append(i*5);

print("原列表：{0}".format(listx))
>> 原列表：[5, 10, 15, 20]

#在这里说一下如何区别该方法是否改变原列表：如果该方法是系统方法则一般不会修改；若是列表自带的，则一般会修改

#方法一：
# 利用list自身带的方法sort()
list1 = copy.deepcopy(listx)     #深层拷贝
conList1 = list1                 #复制原列表的引用
list1.sort(reverse=True);		#list1.sort()会修改list1 本身位置
print("方法一：排序后的原列表：{0}\tsorted返回排序好的列表：{1}".format(conList1,list1))
>> 方法一：排序后的原列表：[20, 15, 10, 5] sorted返回排序好的列表：[20, 15, 10, 5]

#方法二：
# 利用系统方法，reversed()  不改变原列表
#注意：reversed 函数返回的是一个迭代器，需要人为进行类型转换
list2 = copy.deepcopy(listx)
print("方法二：排序后的原列表：{0}\tsorted返回排序好的列表：{1}".format(list2,(list(reversed(list2)))))
>> 方法二：排序后的原列表：[5, 10, 15, 20] sorted返回排序好的列表：[20, 15, 10, 5]

#方法三：
#sorted(list) 不会修改list1 原本的排列位置，只会产生一个新的副本，不改变原列表
list3 = copy.deepcopy(listx)
print("方法三：排序后的原列表：{0}\tsorted返回排序好的列表：{1}".format(list3,sorted(list3,reverse=True)))
>> 方法三：排序后的原列表：[5, 10, 15, 20] sorted返回排序好的列表：[20, 15, 10, 5]

#方法四：
#步长为-的表示倒着取分组，具体可看上面的字符串切片部分，不改变原列表
list4 = copy.deepcopy(listx)
print("方法四：排序后的原列表：{0}\tsorted返回排序好的列表：{1}".format(list4,list4[::-1]))
>> 方法四：排序后的原列表：[5, 10, 15, 20] sorted返回排序好的列表：[20, 15, 10, 5]

#方法五：
#借助list自带的reverse()方法实现，这会改变调用的列表本身
list5 = copy.deepcopy(listx)
conList5 = list5
list5.reverse()
print("方法五：排序后的原列表：{0}\tsorted返回排序好的列表：{1}".format(conList5,list5))
>> 方法五：排序后的原列表：[20, 15, 10, 5] sorted返回排序好的列表：[20, 15, 10, 5]

字典

  • 字典 dict 花括号表示：{}

    dict{key : value}

    其中key必须为不可变类型，因此常用字符串str，tuple，int作为key

    ​ value为任意类型。

    1）字典的创建：

    dic = {}    #创建空字典
print(dic)
>> {}

dic1= {"A":1,"B":2} #用str作为key int作为value
print(dic1)
>> {'A': 1, 'B': 2}

dic2= {(3,4,5):"10",789:"12"} #用tuple ，int 作为key 。str作为ivalue
print(dic2)
>> {(3, 4, 5): '10', 789: '12'}	#用list作为key，由于list是可变量，所以会报错

a = [2]
dic3 = {a:3}				#用可变量作为key，报错
print(dic3)
>> TypeError: unhashable type: 'list'
        
#利用循环将两个list合并成一个字典
num = [4,3,2,1]				#作为字典的value
ap = ["a","b","c","d"]		#作为字典的key
blend = {}
for i in range(len(num)):
    blend[ap[i]] = num[i]	#取出ap[i]中的值赋到blend中当key，取出num[i]中的值做对应的value
print(blend)
>> {'a': 4, 'b': 3, 'c': 2, 'd': 1}

# 使用dict构造函数，注意，参数里面是一个列表，列表里面括着几对元组
dict4 = dict([('a',10),('b',30)])
print(dict4)
>> {'a': 10, 'b': 30}

# 使用eval将str转换成字符串，需要注意字符串的格式
str1 = '{"a":20,"b":30}'
#str2 = "{'a':20,'b':30}"	或者这个，注意双引号里面只能套单引号；单引号里面只能套双引号
dict5 = eval(str1)
print(dict5)
>> {'a': 20, 'b': 30}

    3）获取字典相关信息

    dic1 = {'a': 40, 'b': 30,'c':20,'d':-1}
listKey = list(dic1.keys())				#获取对应的键名列表
listValues = list(dic1.values())		#获取对应的值列表
print(listKey)
>> ['a', 'b', 'c', 'd']
print(listValues)
>> [40, 30, 20, -1] 
print(tuple(dic1.items()))  #转换为元组
>> (('a', 40), ('b', 30), ('c', 20), ('d', -1))

    2）字典的增删改查

    #增
# 1）直接使用键值赋值
dic = {'a': 20, 'b': 30}
dic["c"] = 40                   #若不存在键值"c"则自动添加该键，并绑定对应的值40
print(dic)
>> {'a': 20, 'b': 30, 'c': 40}
# 2）使用update()添加新字典
dicAdd = {'e':50,'f':60}    #创建一个需要添加合并的add字典
dic.update(dicAdd)         #将add加到dic中
print(dic)
>> {'a': 20, 'b': 30, 'c': 40, 'e': 50, 'f': 60}

#删
del dic['b']		#删除对应的键值对，若不存在该键则报错
print(dic)
>> {'a': 20, 'c': 40}
dic.pop('a')		#删除对应的键值对，若不存在该键则报错
>> {'c': 40}

#改
dic["c"] =  50      #若已存在该键值"c"则自动将其的值替换成50
print(dic)
>> {'a': 20, 'c': 50}

#查
dic1 = {'a': 20, 'b': 30}	#直接根据键来索引
print(dic1['a'])
>> 20
print(dic1.get('a')) #也可以使用自带的get()方法，其好处是，可以自定义处理找不到指定值的情况，默认返回Noe
>> 20
print(dic1.get('c'))
>> None
print(dic1.get('c',-1))		#指定当找不到对应索引时返回-1，这里不只局限于int 也可以指定str
>> -1

    3）字典的排序

    dic1 = {'d': 40, 'c': 30,'b':20,'a':-1}
print(sorted(dic1.items(),key=lambda e:e[1],reverse=False))		#对值排序    从小到大
>> [('a', -1), ('b', 20), ('c', 30), ('d', 40)]
#其中 e表示的时items()中的一个元素，e[1] 表示按值排序 reverse表示是否降序，True为真，False为假
print(sorted(dic1.items(),key=lambda e:e[0],reverse=False))		#对键排序    从小到大
>> [('a', -1), ('b', 20), ('c', 30), ('d', 40)]

集合

  • 集合 set 花括号表示：{}，是一个无序不重复元素的集，换句话说，具有去重的功能。

    1）集合的创建

    set1 = set()    #注意，创建空集合不能 set1 = {} 因为这是空字典的写法
print(set1)
>> set()
ll = ["a","a","b","d"]
set2 = set(ll)  #去重   写法相当于 set2 = {"a","a","b","d"}
print(set2)
>> {'a', 'b', 'd'}
print(set("aaaaa"))	#同样可直接对字符串去重
>> {'a'}

    2）集合的运算

    set1 - set2 #从集合set1 除去 集合set2的元素
set1 | set2 #集合set1 与 集合set2 的并集
set1 & set2 #集合set1 与 集合set2 的交集
set1 ^ set2 #集合set1 与 集合set2 的补集

第三章流程控制

分支判断

  • if 单分支

    if 满足条件：
	执行语句#记得缩进 4个空格或者一个tab键

  • if-else 单分支

    if 满足条件：
	执行语句#记得缩进 4个空格或者一个tab键
else:
	#当不满足if条件时自动执行else的语句
	执行语句#记得缩进 4个空格或者一个tab键

  • if-elif 多分支

    if 满足条件1：
	执行语句
elif 满足条件2：
	执行语句
elif 满足条件3：
.
.
.
else:
	执行语句#当上述条件没有一个满足时执行该语句

    循环

  • for循环(记得for后面的引号)

    1）遍历列表

    for i in [2,3,4]:
	print(i,end=",")#end=","表示将结果输出在同一行，每个结果以(,)号隔开
>> 2,3,4,

    2）遍历字符串

    for c in "abc":
	print(c)
>> a
>> b
>> c

    3）配合内置函数range()使用，作用有：1）控制循环次数。2）辅助生成列表

    #控制循环次数
for i in range(2,5):#范围左闭右开 即：[2,4]
    print(i)
>> 2
>> 3
>> 4

for i in range(5):#range(n) 范围默认从0开始到n-1
    print(i)
>> 0
>> 1
>> 2
>> 3
>> 4

#因此 列表也可以这么遍历
list1 = ["a","b","c"]
for i in range(len(list1)):
    print(list1[i])

#range()函数还可以设置步长，其格式为：range(start,stop,step)
print(list(range(2,6)))	#从0开始到5
>> [2, 3, 4, 5]
print(list(range(2,6,2)))	#从0开始到5 步长为2
>> [2, 4]
#range()函数也可以倒序，需要注意的是 ：start > stop
for i in range(6,2,-1):
    print(i,end=",")
>> 6,5,4,3,    

print(list(range(6,2,-2)))	#选[6,5][4,3]分组中的第一位
>> [6, 4]


#辅助生成列表
#生成[0,9]范围的列表并将每个数平方然后放入列表中
print([ x**2 for x in range(10)])
>> [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

#生成[0,9]范围的列表并将每个数平方，然后将结果可以被整除的数放入列表中放入列表中
print([ x**2 for x in range(10) if x %2 == 0])
>> [0, 4, 16, 36, 64]

    4）多维数组的遍历

    list1 = [[1,2],[3,4,5],[6,7,8,9]]
for i in range(len(list1)):
    for j in range(len(list1[i])):
        print('['+str(i)+']','['+str(j)+']'+'=',list1[i][j])
>> [0] [0]= 1
>> [0] [1]= 2
>> [1] [0]= 3
>> [1] [1]= 4
>> [1] [2]= 5
>> [2] [0]= 6
>> [2] [1]= 7
>> [2] [2]= 8
>> [2] [3]= 9

函数

1）位置参数

#1
def printf(a = "Hellow",b="World"):
    print(a,b)
    
printf()
>> Hellow World

printf("Your")
>> Your World

printf("New","Py")
>> >> New Py

printf(b = "Py",a = "New")
>> New Py

printf(b = "Hellow")
>> Hellow Hellow

#2
def printf(a,b):
    print(a,b)
    
printf(b = "Py",a = "New")
>> New Py

2）任意个数的参数

声明：在参数前加上* 或者是**

def printf(st,*end):
    print("start is :",st)
    print("remin is :")
    for c in end:
        print(c,end=",")

printf(0,1,2,3,4,'end')
>> start is : 0
>> remin is :
>> 1,2,3,4,end,

3）函数返回值，一个函数可以有多个返回值，其全部都将包含在一个元组或是列表中返回

4）函数式编程 lambda

posted @   Mercurows  阅读(218)  评论(0)  编辑  收藏  举报
编辑推荐：
· 基于Microsoft.Extensions.AI核心库实现RAG应用
· Linux系列：如何用heaptrack跟踪.NET程序的非托管内存泄露
· 开发者必知的日志记录最佳实践
· SQL Server 2025 AI相关能力初探
· Linux系列：如何用 C#调用 C方法造成内存泄露
阅读排行：
· 震惊！C++程序真的从main开始吗？99%的程序员都答错了
· 【硬核科普】Trae如何「偷看」你的代码？零基础破解AI编程运行原理
· 单元测试从入门到精通
· 上周热点回顾（3.3-3.9）
· Vue3状态管理终极指南：Pinia保姆级教程
点击右上角即可分享
微信分享提示
AI IDE Trae