Python：入门：列表推导式、函数、“问号表达式”

1、列表推导式

例子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)]

总结：多层循环是从内到外循环的

2、函数

一般函数

def fun(*args,**kwargs):
    return 1,2
#返回列表（1，2）
a,b = fun()  #拆包a=1,b=2

相关阅读：Python：函数：参数列表 — 1位置参数，2默认参数，3可变参数，4关键字参数，可变关键字参数（前后次序严格，不可存在交集）

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

3、“问号表达式”

第一种方式

LogicalExp = True
result = "正确的结果" if LogicalExp else "错误的结果"
print(result)
LogicalExp = False
result = "正确的结果" if LogicalExp else "错误的结果"
print(result)
# 结果为：------
# 正确的结果
# 错误的结果

第二种方式

flag = ["错误的结果", "正确的结果"][False]
print(flag)
flag = ["错误的结果", "正确的结果"][True]
print(flag)
# 结果为：------
# 错误的结果
# 正确的结果

4、异常

异常处理 — try后必须有except或者finally，如果有else必有except

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 / assert

raise Exception('Error')
a = 3
assert a == 4

assert 如果不成立，抛出AssertionError异常

5、逻辑表达式>、<、==

有序序列可以内部比较，依次比较直到返回真假值

不同类型之间不能进行比较范例，在进行第一个元素可以必出大小的时候，不会报错，否则就报错。

print((1, 2) > (2, 'a'))
# 结果-----False
print("1a" > "21")
# 结果-----False
print("2a" > "21")
# 结果-----True
print((2, 2) > (2, 'a'))
# 报错

6、内置函数

eval()----将字符串string对象转化为有效的表达式参与求值运算返回计算结果

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)

zip()----函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。

如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

a, b = [1, 2, 3], 'abcdef'
print(zip(a, b))
# 结果：可迭代的zip对象----<zip object at 0x11bc12ec8>
print(*zip(a, b))
# 结果：(1, 'a') (2, 'b') (3, 'c')
bList = [j for i, j in zip(a, b)]
print(bList)
# 结果：['a', 'b', 'c']

map(function, iterable, …)----第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表

map1 = map(lambda x:abs(x),[1,-1,2,-2]);print(map1,’–>’,list(map1))

==> <map object at 0x000001DF708A8128> --> [1, 1, 2, 2]

filter(function, iterable, …) #通过生成 True 和 False 组成的迭代器将可迭代对象中不符合条件的元素过滤掉

filter1 = filter(lambda x:x>2,[0,1,2,3]);print(filter1,’–>’,list(filter1))
#==> <filter object at 0x0000028B3C0ADC18> --> [3]

def aaa(x):
if x>2:
return False
return True
print(list(filter(aaa,[0,1,2,3])))
#==> [0, 1, 2]

#abs() #求绝对值

#float() #返回浮点数

bool()

list()

set()

frozenset([iterable]) #产生一个不可变的set

dict() 参数为二维，每个元素必须为两个元素

print(dict([{1,2},(3,4)]))
#==>{1: 2, 3: 4}

#round(1.45,2) #四舍五入
print(round(111.45,2))
print(round(111.45,-1))

==>110.0

111.45

max(iterable[, args…][key]) 返回集合中的最大值

min(iterable[, args…][key]) 返回集合中的最小值

#sum() #对可迭代对象的求和 eg:序列，集合，字典的键求和,
print(sum((1,2)))

oct(x) 将一个数字转化为8进制

hex(x) 将整数x转换为16进制字符串

ord(ch) 输出字符在ASCII码中对应的整数

chr(i) 返回整数i对应的ASCII字符

format() 格式化输出字符串

#参考：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])])

==>[(0, 1), (1, 2), (2, 3), (3, 4)]

sorted(iterable[, cmp[, key[, reverse]]]) #返回一个列表

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

[1, 2, 3, 4, 5] –

[1, 2, 3, 4, 5]

[1, 2, 3, 4, 5] –

None

[5, 4, 3, 2, 1] –

<list_reverseiterator object at 0x0000020C7C9EBEF0>

[1, 2, 3, 4, 5] –

all(iterable) 1、集合中的元素都为真的时候为真 2、特别的，若为空串返回为True

any(iterable) 1、集合中的元素有一个为真的时候为真 2、特别的，若为空串返回为False

#dir([object]) 1、不带参数时，返回当前范围内的变量、方法和定义的类型列表；
# 2、带参数时，返回参数的属性、方法列表。
# 3、如果参数包含方法__dir__()，该方法将被调用。当参数为实例时。
# 4、如果参数不包含__dir__()，该方法将最大限度地收集参数信息
print(dir(dir))

id(object) 返回对象的唯一标识

isinstance(object, classinfo) 判断object是否是class的实例

issubclass(class, classinfo) 判断是否是子类

len(s) 返回集合，字典，序列的长度

next(iterator[, default]) 类似于iterator.next()

#open(name[, mode[, buffering]]) #打开文件

help() 帮助信息

print(help())

#7、序列方法：==================

1、索引访问对象

a = [1,2,3,4,5,6]
b = tuple(a)
c = set(a)
d = dict(zip(a,b))
print(a[0])

2、切片操作

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

9、tuple

#序列方法
#内置函数len(),max(),min(),tuple(),enumerate()

10、list

#序列方法
#内置函数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) #无参数，默认删除最后一个元素

list1.clear();print(list1) #清空列表

list11 = list1.copy();print(id(list11)==id(list1)) #复制列表,浅复制
import copy;list2 = copy.deepcopy(list1) #深复制

11、set

#无重复，可变–>元素的去重

无序、唯一、可变。集合中的元素需要可哈希的，元素不可以是可变对象。

#内置函数len(),max(),min(),tuple(),enumerate()
#set方法
set1 = set((‘a’,1,‘b’,‘c’,‘d’))

set1.add(‘a’);print(set1)

set1.clear()

set1.pop();print(set1) #随机移除元素

set1.remove(‘a’);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的数据
#-----------------------------------

运算：

#没有相加

| union(A,B) #返回两个集合的并集

& intersection() #返回集合的交集

A-B difference() #返回多个集合的差集

A^B symmetric_difference()#取两个集合各自独有的元素。

11、dict

#内置函数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)