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

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

  • 1、列表推导式
    • 总结:多层循环是从内到外循环的
  • 2、函数
    • 一般函数
      • 相关阅读:Python:函数:参数列表 --- 1位置参数,2默认参数,3可变参数,4关键字参数,可变关键字参数(前后次序严格,不可存在交集)
    • 匿名函数
  • 3、“问号表达式”
  • 4、异常
    • 异常处理 --- try后必须有except或者finally,如果有else必有except
    • 抛异常 --- raise / assert
  • 5、逻辑表达式>、<、==
  • 6、内置函数
    • eval()----将字符串string对象转化为有效的表达式参与求值运算返回计算结果
    • zip()----函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元组组成的列表。
    • map(function, iterable, ...)----第一个参数 function 以参数序列中的每一个元素调用 function 函数,返回包含每次 function 函数返回值的新列表
  • ==> --> [1, 1, 2, 2]
  • filter(function, iterable, ...) #通过生成 True 和 False 组成的迭代器将可迭代对象中不符合条件的元素过滤掉
  • bool()
  • list()
  • set()
  • frozenset([iterable]) #产生一个不可变的set
  • dict() 参数为二维,每个元素必须为两个元素
  • ==>110.0
  • 111.45
  • max(iterable[, args...][key]) 返回集合中的最大值
  • min(iterable[, args...][key]) 返回集合中的最小值
  • oct(x) 将一个数字转化为8进制
  • hex(x) 将整数x转换为16进制字符串
  • ord(ch) 输出字符在ASCII码中对应的整数
  • chr(i) 返回整数i对应的ASCII字符
  • format() 格式化输出字符串
  • ==>[(0, 1), (1, 2), (2, 3), (3, 4)]
  • sorted(iterable[, cmp[, key[, reverse]]]) #返回一个列表
  • [1, 2, 3, 4, 5] --
  • [1, 2, 3, 4, 5]
  • [1, 2, 3, 4, 5] --
  • None
  • [5, 4, 3, 2, 1] --
  • [1, 2, 3, 4, 5] --
  • all(iterable) 1、集合中的元素都为真的时候为真 2、特别的,若为空串返回为True
  • any(iterable) 1、集合中的元素有一个为真的时候为真 2、特别的,若为空串返回为False
  • id(object) 返回对象的唯一标识
  • isinstance(object, classinfo) 判断object是否是class的实例
  • issubclass(class, classinfo) 判断是否是子类
  • len(s) 返回集合,字典,序列的长度
  • next(iterator[, default]) 类似于iterator.next()
  • help() 帮助信息
  • print(help())
  • 1、索引访问对象
  • 2、切片操作
  • 9、tuple
  • 10、list
  • list1.clear();print(list1) #清空列表
  • 11、set
  • 无序、唯一、可变。集合中的元素需要可哈希的,元素不可以是可变对象。
  • set1.clear()
  • set1.remove('a');print(set1) #移除指定元素
  • 运算:
  • | union(A,B) #返回两个集合的并集
  • & intersection() #返回集合的交集
  • A-B difference() #返回多个集合的差集
  • A^B symmetric_difference()#取两个集合各自独有的元素。
  • 11、dict
  • 方法一:

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对象----
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))

==> --> [1, 1, 2, 2]

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

filter1 = filter(lambda x:x>2,[0,1,2,3]);print(filter1,’–>’,list(filter1))
#==> --> [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] –

[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)

你可能感兴趣的:(python,python)