例子1
import random
lists = [(i,j,m) for i in range(1) for j in range(2) for m in range(3)]
print(lists)
结果
[(0, 0, 0), (0, 0, 1), (0, 0, 2), (0, 1, 0), (0, 1, 1), (0, 1, 2)]
例子2
lists1 = [(index,content) for index,content in enumerate([1,'a',3,4,5])]
print(lists1)
结果
[(0, 1), (1, 'a'), (2, 3), (3, 4), (4, 5)]
例子3
lists2 = [(key,value) for key,value in {1:2,2:3}.items()]
print(lists2)
结果
[(1, 2), (2, 3)]
def fun(*args,**kwargs):
return 1,2
#返回列表(1,2)
a,b = fun() #拆包a=1,b=2
https://blog.csdn.net/weixin_43473435/article/details/83413724
shaddow = lambda x, y: (x + y, x)
a, b = shaddow(1, 2)
print(a, b)
# 结果为:------
# 3 1
第一种方式
LogicalExp = True
result = "正确的结果" if LogicalExp else "错误的结果"
print(result)
LogicalExp = False
result = "正确的结果" if LogicalExp else "错误的结果"
print(result)
# 结果为:------
# 正确的结果
# 错误的结果
第二种方式
flag = ["错误的结果", "正确的结果"][False]
print(flag)
flag = ["错误的结果", "正确的结果"][True]
print(flag)
# 结果为:------
# 错误的结果
# 正确的结果
try:
print(c)
raise Exception('Error')
except IndexError as e:
print('处理异常1:\n',e)
except Exception as e:
print('处理异常2:\n',e)
else:
print('execute else')
finally:
print('execute finally')
raise Exception('Error')
a = 3
assert a == 4
assert 如果不成立,抛出AssertionError异常
有序序列可以内部比较,依次比较直到返回真假值
不同类型之间不能进行比较范例,在进行第一个元素可以必出大小的时候,不会报错,否则就报错。
print((1, 2) > (2, 'a'))
# 结果-----False
print("1a" > "21")
# 结果-----False
print("2a" > "21")
# 结果-----True
print((2, 2) > (2, 'a'))
# 报错
print(eval('2 * 3 + (3 - 1) / 2'))
# 结果-----7.0
a, b = 1, 3;
print(eval('a + b'))
# 结果-----4
print(eval('(1, 2, "t", a)'))
# 结果-----(1, 2, 't', 1)
如果各个迭代器的元素个数不一致,则返回列表长度与最短的对象相同,利用 * 号操作符,可以将元组解压为列表。
a, b = [1, 2, 3], 'abcdef'
print(zip(a, b))
# 结果:可迭代的zip对象----
print(*zip(a, b))
# 结果:(1, 'a') (2, 'b') (3, 'c')
bList = [j for i, j in zip(a, b)]
print(bList)
# 结果:['a', 'b', 'c']
map1 = map(lambda x:abs(x),[1,-1,2,-2]);print(map1,’–>’,list(map1))
filter1 = filter(lambda x:x>2,[0,1,2,3]);print(filter1,’–>’,list(filter1))
#==>
def aaa(x):
if x>2:
return False
return True
print(list(filter(aaa,[0,1,2,3])))
#==> [0, 1, 2]
#abs() #求绝对值
#float() #返回浮点数
print(dict([{1,2},(3,4)]))
#==>{1: 2, 3: 4}
#round(1.45,2) #四舍五入
print(round(111.45,2))
print(round(111.45,-1))
#sum() #对可迭代对象的求和 eg:序列,集合,字典的键求和,
print(sum((1,2)))
#参考:https://blog.csdn.net/i_chaoren/article/details/77922939
print('I{0:*>10.3f}Love You '.format(5.23333))
#> I*****5.233Love You
print(’{0:&^15,.2f}’.format(1000000))
#> &1,000,000.00&&
#enumerate(sequence [, start = 0]) #返回一个可枚举的对象,该对象的next()方法将返回一个tuple
print([i for i in enumerate([1,2,3,4])])
print(list(sorted([1,2,3,4],reverse=False))) #默认False为升序,如果为True为降序
print(’---------------------------’)
a = [1,2,3,4,5];print(a.sort());print(a,’–’) #a.sort没有返回值,作用于调用者,参数reverse默认False,升序
a = [1,2,3,4,5];print(sorted(a));print(a,’–’) #sorted(a)返回可迭代对象,参数reverse默认False,升序
a = [1,2,3,4,5];print(a.reverse());print(a,’–’) #列表.reverse() 没有返回值,作用于调用者
a = [1,2,3,4,5];print(reversed(a));print(a,’–’) #reversed() 返回可迭代对象
#==> None
#dir([object]) 1、不带参数时,返回当前范围内的变量、方法和定义的类型列表;
# 2、带参数时,返回参数的属性、方法列表。
# 3、如果参数包含方法__dir__(),该方法将被调用。当参数为实例时。
# 4、如果参数不包含__dir__(),该方法将最大限度地收集参数信息
print(dir(dir))
#open(name[, mode[, buffering]]) #打开文件
#7、序列方法:==================
a = [1,2,3,4,5,6]
b = tuple(a)
c = set(a)
d = dict(zip(a,b))
print(a[0])
print(a[0],’–>’,a[len(a)-1]) #1 --> 3
print(a[0::1],’–>’,a[-1::-1]) #[1, 2, 3] --> [3, 2, 1] #不指定方向,默认为右,如果第三个参数为负数,方向向左
print(a[0:4:-1]) #[] #方向不同为空
#8、字符串方法
import string
str1 = string.ascii_lowercase
str2 = string.ascii_uppercase
str = string.ascii_letters
str3 = str1[0:3]
str4 = ’ ’ + str3 + ’ ’
str5 = ‘abc,cde,fgh,ssss’
str6 = ‘’’
abc
def
ghh
‘’’
print(str6.title()) #返回"标题化"的字符串,就是说所有单词都是以大写开始,其余字母均为小写
print(str1.istitle()) #是否是title格式
print(str1.upper())
print(str1.isupper())
print(str1.swapcase()) # 将字符串中大写转换为小写,小写转换为大写
print(’-’.join([‘1’,‘2’])) #参数序列元素必须为字符串
print(len(str))
print(str.lower())
print(max(str))
print(min(str))
print(str.replace(‘a’,’–’))
print(str.find(‘a’)) #找不到不报错,返回-1
print(str.rfind(‘a’))
print(str.index(‘c’)) #找不到报错,最好用find
print(str.rindex(‘c’))
print(str3.zfill(5)) # 返回长度为 width 的字符串,原字符串右对齐,前面填充0
print(str3.rjust(5,’’)) #返回右对齐字符串,填充
print(str3.ljust(5,’*’))
print(str4.strip()) #删除字符串首尾的空格
print(str4.strip(‘abc’)) #删除字符串首尾包含的字符’a’,‘b’,‘c’
print(str4.rstrip()) #删除字符串字符串末尾的空格
print(str4.lstrip())
print(str5.split(’,’,2)) #按照2个,分割成数组,不能用正则字符串
print(str6.splitlines(False)) # 按照行(’\r’, ‘\r\n’, ‘\n’)分隔,返回一个包含各行作为元素的列表
print(str6.splitlines(True)) # True保留换行符,False不保留换行符
print(str1.startswith(‘a’))
print(str1.endswith(‘z’))
print(‘2225’.isdecimal()) #检查字符串是否只包含十进制字符,如果是返回 true,否则返回 false
#运算
print(str1 + str2)
print(str1 * 2)
print(str1[0]) #切片
print(‘abc’ in str1)
print(‘defa’ not in str1)
print(r’\sfasf\’) #原始字符串,大小写r都可以
print(R’\sfasf\’)
print(‘i love you %s’%(5)) #格式化字符串
print(‘i love you %.2f’%(5))
#自动补三种方法
str.zfill(5) #字符串长度为5,不足补0
str.rjust(5,‘0’) #字符串长度为5,不足补0
str = ‘%0nd’ #字符串长度为5,不足补0
#序列方法
#内置函数len(),max(),min(),tuple(),enumerate()
#序列方法
#内置函数len(),max(),min(),list(),enumerate()
#list方法
list1 = [1,2,3,4]
list1.append(‘a’);print(list1) #在列表末尾添加新的对象
list1.append([2,2,2]);print(list1)
list1.count(‘a’) #统计某个元素在列表中出现的次数
list1.extend([1,2,3]) #将序列中的每一个元素追加到列表中,注意与append的区别
print(list1.index(1)) #从列表中找出某个值第一个匹配项的索引位置
list1.insert(0,2) #将对象插入列表,插入到0下标前
list1.remove(1);print(list1) #移除列表中某个值的第一个匹配项,没有报错
del list1[0];print(list1)
list1.pop(0);print(list1) #无参数,默认删除最后一个元素
list11 = list1.copy();print(id(list11)==id(list1)) #复制列表,浅复制
import copy;list2 = copy.deepcopy(list1) #深复制
#无重复,可变–>元素的去重
#内置函数len(),max(),min(),tuple(),enumerate()
#set方法
set1 = set((‘a’,1,‘b’,‘c’,‘d’))
set1.add(‘a’);print(set1)
set1.pop();print(set1) #随机移除元素
set1.update([‘a’,1,2,3]);print(set1)
print(set1)
set11 = set1.copy();print(id(set11)id(set1))
#浅复制和深复制(适用所有)----------------
print(’=浅复制’)
set1 = [10000,2,3,[1,2]]
set2 = set1.copy()
print(id(set1),id(set2))
print(id(set1[0]),id(set2[0]))
#说明:浅复制只是复制了一层
print(’=深复制==’)
import copy
set3 = copy.deepcopy(set1)
print(id(set1),id(set3))
print(id(set1[0]),id(set3[0]))
#深复制:复制了所有的层,除了最底层使用了一样9的数据
#-----------------------------------
#没有相加
#内置函数len(),max(),min()都是比较的键值,所以键值必须是相同类型,dict(二维元素),enumerate()
dict1 = {5:2,2:3,3:‘b’,True:False};print(min(dict1))
dict2 = {‘ac’:1,‘b’:2};print(min(dict2))
print(dict1.keys()) #返回字典键的可迭代对象
print(dict1.values()) #返回字典值的可迭代对象
print(dict1.items()) #以列表返回可遍历的(键, 值) 元组数组的可迭代对象
print(dict.fromkeys((1,2,3),5)) #创建一个新字典,以序列seq中元素做字典的键,val为字典所有键对应的初始值
print(dict1.get(1,0)) #返回指定键的值,如果值不在字典中返回default值
print(dict1.setdefault(1,6)) #但如果键不存在于字典中,将会添加键并将值设为default
print([key for key in dict1]) #遍历key
print(1 in dict1) #如果键在字典dict里返回true,否则返回false
print(dict1.update(dict2));print(dict1) #把字典dict2的键/值对更新到dict1里
print(dict1.pop(1)) #删除字典给定键 key 所对应的值,返回值为被删除的值。key值必须给出。 否则,返回default值。
print(dict1.popitem()) #随机返回并删除字典中的一对键和值(一般删除末尾对)。
print(dict1.clear()) #删除字典内的所有元素
#==对字典的排序方法:(按照value排序)
dict3 = {3:1,5:3,2:5,‘a’:2,‘z’:99}
l = sorted(dict3.items(), key=lambda x: x[1], reverse=True)
print(l)
#方法二:不稳定,如果第一个值相同,第二个值是不同类型就会报错
f = zip(dict3.values(),dict3.keys())
sorted(f)
#方法三:
import operator
l1 = sorted(dict3.items(), key=operator.itemgetter)
print(l1)