一、三元表达式
语法： [成立1 if condition1 else 成立2 if condition2 else ... if 成立N conditionN else 不成立]
sex = 'man' print('正确' if sex == 'man' else '错误') # 正确 ''' 语句解析： sex = 'man' if sex == 'man': print('正确') else: print('错误') ''' age = 23 res = '猜大了' if age > 23 else '猜小了' if age < 23 else '猜对了' print(res) # '猜对了' ''' 语句解析： age = 23 if age >23: res = '猜大了' elif age <23: res = '猜小了' else: res = '猜对了' '''
二、列表推导式
# 语法 ''' [expression for item1 in iterable1 if condition1 for item2 in iterable2 if condition2 ... for itemN in iterableN if conditionN ] '''
res = ['ege%s'%i for i in range(10) if i%2 ==0] print(res,type(res)) # ['ege0', 'ege2', 'ege4', 'ege6', 'ege8'] <class 'list'> # 类似于 res = [] for i in range(10): if i%2 == 0: res.append('ege%s'%i) print(res)
三、字典生成器
d={i:i for i in range(10) if i > 0}
print(d)
# {1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9}
# 类似于：
dic = {}
for i in range(10):
if i >0:
dic[i] = i
print(dic)
userinfo=[('egon','123'),('alex','456'),('wxx','679')]
dic={k:v for k,v in userinfo}
print(dic)
# {'egon': '123', 'alex': '456', 'wxx': '679'}
四、生成器表达式
# 把 列表推导式中的[] 变成() 就是 生成器表达式 # 生成器表达式 res = (i for i in range(10000000000000000000000000000000000000000000)) print(res) # <generator object <genexpr> at 0x00000000022AD150> # 生成器 def test(): yield 1 test = test() print(test) # <generator object test at 0x00000000021FD200> print(next(test)) # 1
names = ['jmz','qqq','egon'] names = [name.upper() for name in names] print(names)
五、递归与简单二分法
递归
# 递归调用就是函数嵌套调用的一种特殊形式，函数在调用时，直接或间接调用自身，这就是递归调用
def sum(count): if count == 1: return 100 return sum(count-1) + 20 print(sum(5)) # 图解 ''' sum(5) == sum(4) +20 sum(4) == sum(3) + 20 sum(3) == sum(2) + 20 sum(2) == sum(1) + 20 sum(1) == 100 '''
# 递归总结 # 1、 有可以明确地结束条件 # 2、每次进入更深一层递归是，问题规模相比上次递归都应有所减少 # 3、递归效率不高，递归层次过多会导致栈溢出 #python中的递归 # python中的递归效率低，需要在进入下一次递归时保留当前的状态，在其他语言中可以有解决方法：尾递归优化，即在函数的最后一步（而非最后一行)调用自己，尾递归优化 # 但是python又没有尾递归，且对递归层级做了限制
二分法
想从一个按照从小到大排列的数字列表中找到指定的数字，遍历的效率太低，用二分法（算法的一种，算法是解决问题的方法）可以极大低缩小问题规模
nums = [1,2,5,13,16,35,67,87,181,197,200] def search(nums, n): midden_index = len(nums) // 2 if midden_index == 0: print('找到了' if nums[0] == n else '不存在该数据') return num = nums[midden_index] if num == n: print('找到了') return elif num > n: search(nums[:midden_index], n) else: search(nums[midden_index:], n)
# 二分法总结， # 总是取中间值比较，想要找的值比中间值大就想后找 #比中间值小就往前找 #切片一直切到最后就只剩下一个数值，当只剩下一个数值时直接比较即可，无需再比什么中间值了
六、匿名函数
什么是匿名函数
# 匿名函数就是没有名字的函数 def foo(): print('我是有名字的函数，函数名foo') # 匿名函数 lambda x,y,z=1:x+y+z # 与函数有相同的作用域，但是匿名意味着引用计数为0，使用一次就释放，除非让其有名字 func = lambda x,y,z:z+y+z # 将匿名函数 赋值给 func 使其有名，与有名函数一样的调用方式，反而无意义了 print(func(1,2,3)) # 8
匿名函数与有名字的函数对比
# 有名函数：循环使用，保存了名字，通过名字就可以重复引用函数功能 # 匿名函数：一次性使用，随时随时定义 # 应用：max，min，sorted,map,reduce,filter
七、内置函数
#注意：内置函数id()可以返回一个对象的身份，返回值为整数。这个整数通常对应与该对象在内存中的位置，但这与python的具体实现有关，不应该作为对身份的定义，
即不够精准，最精准的还是以内存地址为准。is运算符用于比较两个对象的身份，等号比较两个对象的值，内置函数type()则返回一个对象的类型 #更多内置函数：https://docs.python.org/3/library/functions.html?highlight=built#ascii
#! /usr/bin/env python # -*- coding:utf-8 -*- # Author Jmz # min max 与匿名函数的运用 l = [1,2,3,4,5,6,7,8,9] dic = {'x':11,'y':32,'z':3} print(max(l)) print(min(l)) print(max(dic)) # z 这个取的是key的最大值 print(max(dic,key=lambda k:dic[k])) # y # 这个取的是value最大值的那个key print(min(dic)) # x 这个取的是key的最小值 print(min(dic,key=lambda k:dic[k])) # z # 这个取的是value最小值的那个key print(max([-11,1,21,-31],key=abs)) # -31 # 比较谁的绝对值最大 abs 内置函数取绝对值 # sorted 与 匿名函数的运用 salaries={ 'egon':3000, 'alex':100000000, 'wupeiqi':10000, 'yuanhao':2000 } # 将姓名已工资排序 print(sorted(salaries,key=lambda k:salaries[k])) # 默认升序 # ['yuanhao', 'egon', 'wupeiqi', 'alex'] print(sorted(salaries,key=lambda k:salaries[k],reverse=True)) # 降序了 # ['alex', 'wupeiqi', 'egon', 'yuanhao'] salaries_t = zip(salaries.keys(),salaries.values()) # 迭代器 print(salaries_t) # <zip object at 0x0000000002502E88> #list(salaries_t) == > [('egon', 3000), ('alex', 100000000), ('wupeiqi', 10000), ('yuanhao', 2000)] # zip 用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表或者字典 print(sorted(salaries_t,key=lambda v:v[1])) # 表示已每个元组的第2个数排序 # [('yuanhao', 2000), ('egon', 3000), ('wupeiqi', 10000), ('alex', 100000000)] # map 与匿名函数运用（重要） names = [' jMZ',' jaCk ',' jIm '] # 将名字 转成 首字母 大写，并去除两边空格 names = map(lambda x:x.strip().title(),names) print(list(names)) # ['Jmz', 'Jack', 'Jim'] # filter与匿名函数运用 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。 names=['alex_sb','wupeiqi_sb','egon','yuanhao_sb','liuqingzheng_sb'] res=filter(lambda x:x.endswith('sb'),names) print(list(res)) print((i for i in range(10))) # <generator object <genexpr> at 0x00000000021E00A0> 生成器
# # 数据类型函数 # set() # 集合类型 # list() # 列表类型 # int() # 整型类型 # str() # 字符串类型 # tuple() # 元组类型 # dict() # 字典类型 # float() # 浮动型 # bool() # 布尔类型 # # long() # python 2 中有长整型类型，Python3 统一都是int类型 info = bool('1') print(info,type(info)) info1 = set(['jmz',12,('11',23,1)]) # set([元素]) 每一个元素都必须是不可变类型，即可hash类型 print(info1,type(info1)) info2 = str(123.1) # 集合类型内部必须是可hash 类型，即不可变类型 print(info2,type(info2)) info3 = int("1231") # 内部必须是可以转化成整型的其他类型 print(info3,type(info3)) info4 = list([1,23,34,(1,2,3)]) print(info4,type(info4)) info5 = dict([('name','jmz'),('age',13)]) # info5 = dict(name='jmz',age=12) # info5 = dict([['name','jmz'],['age',12]]) # info5 = dict({'name':'jmz','age':12}) print(info5,type(info5)) info6 = tuple((1,2,3)) # info6 = tuple([1,2,3]) # info6 = tuple({1,2,3}) print(info6,type(info6)) info7 = float(12) # info7 = float('12') print(info7,type(info7))
# # 类有关的方法 # isinstance() # issubclass() # hasattr() # getattr() # setattr() # delattr() class A: def __init__(self): pass class A1(A): def get(self): print('A1') @staticmethod def cat(self): print('我是静态方法') # issubclass() if issubclass(A1,A): print('A1 是 A 的子类') # isinstance() obj = A1() if isinstance(obj,A1): print('obj 是 A1的实例') # hasattr() if hasattr(A1,"get"): print('A1 存在get 方法会属性') if hasattr(obj,"get"): print('obj实例 存在get 方法会属性') # setattr() setattr(A1,"name","jmz") print(A1.__dict__) # {'__module__': '__main__', 'get': <function A1.get at 0x00000000025099D8>, '__doc__': None, 'name': 'jmz'} # getattr() get_func = getattr(obj,"get") get_func() # A1 # delattr delattr(A1,"name") print(A1.__dict__) # {'__module__': '__main__', 'get': <function A1.get at 0x00000000021799D8>, '__doc__': None} # callable() # 函数用于检查一个对象是否是可调用的 if not callable(obj): print('obj 实例不可再调用了') if callable(A1): print('A1 类可以调用')
# # 其他类型 # divmod() # # input() # 输入数据， # open() # 函数用于打开一个文件，创建一个 file 对象，相关的方法才可以调用它进行读写。 # enumerate() # 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。 # pow() # 方法返回 xy（x的y次方） 的值。pow(x,y) # sum() # 求和 sum(iterable) 如：sum([1,2,3]) # print() # 打印 # super() # 用于调用父类(超类)的一个方法 # filter() # 过滤主要与匿名函数配合使用，过滤出符合条件的数据 # len() # 获取数据长度 # range() # 函数可创建一个整数列表，一般用在 for 循环中。 range(start, stop[, step]) # type() # 1 可创建类（元类中介绍），2 可返回数据类型 # format() # 格式化数据 # map() # 主要和内置函数一起使用，map(func,iter) # globals() # 返回所以的全局变量 # locals() # 返回所有的局部变量 # help() # 函数用于查看函数或模块用途的详细说明。如：help('getattr') # iter() # 函数用来生成迭代器 # next() # 返回迭代器的下一个项目。 # id() # 返回数据的内存地址 # 测试一下，未见过的 # bin() #返回一个整数 int 或者长整数 long int 的二进制表示。 # bytearray() # slice() # dir() # hex() # hash() # complex() # __import__() # compile() # memoryview() # round() # zip() # repr() # vars() # 函数返回对象object的属性和属性值的字典对象。 # frozenset() # callable() # divmod() # 函数把除数和余数运算结果结合起来， # bin() #返回一个整数 int 或者长整数 long int 的二进制表示。 print(bin(10)) # 0b1010 print(bin(2)) # 0b10 # bytearray() # 方法返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256。 # class bytearray([source[, encoding[, errors]]]) print(bytearray([1,2,3])) # bytearray(b'x01x02x03') print(bytearray('中国', 'utf-8')) # bytearray(b'xe4xb8xadxe5x9bxbd') # slice() # 切片 arr = range(10) print(arr[0:5:2]) print(arr[slice(None,5,2)]) # range(0, 5, 2) 两个都一样 print(arr[5]) # 5 print(arr[slice(5)]) # ==> slice(5) == slice(None,5) # range(0, 5) # dir() # 获取当前模块的属性列表。 print(dir()) # hex() # 函数用于将10进制整数转换成16进制，以字符串形式表示 print(hex(10)) # 0xa print(hex(1)) # 0x1 print(hex(16)) # 0x10 # hash() # 用于获取取一个对象（字符串或者数值等）的哈希值。 print(hash('test')) # -8237931458019123489 print(hash('dsjaidhadiaidhaishodiahodhaohdo')) # -7824806465354315596 # print(hash([1,1,3])) # 可变类型不可hash # complex() #函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。。 # class complex([real[, imag]]) # real -- int, long, float或字符串； # imag -- int, long, float； # __import__() # 函数用于动态加载类和函数 。 # 如果一个模块经常变化就可以使用 __import__() 来动态载入。 # 和Python import 导入模块用法相同 # import sys <==>sys = __import__('sys')。 # import作用: # 导入/引入一个python标准模块，其中包括.py文件、带有__init__.py文件的目录 # compile() # 函数将一个字符串编译为字节代码。 str = 'for i in range(10):print(i)' c = compile(str,'','exec') exec(c) # 0 # 1 # 2 # 3 # 4 # 5 # 6 # 7 # 8 # 9 # memoryview() # 函数返回给定参数的内存查看对象(Momory view) v = memoryview(bytearray("abcefg", 'utf-8')) print(v[1]) # b # 98 print(v[2]) # c # 99 # round() # 方法返回浮点数x的四舍五入值。 必须是数值 print(round(2.3)) # 2 print(round(3.6)) # # zip() # 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表 data = zip([1,2,3,4],['jmz','fff']) print(data) # <zip object at 0x000000000233E388> 迭代器 print(list(data)) # [(1, 'jmz'), (2, 'fff')] # repr() # 函数将对象转化为供解释器读取的形式。 # vars() # 函数返回对象object的属性和属性值的字典对象。 class test: def __init__(self,name): self.name = name def set(self,name,value): self.name = value print(test.__dict__) print(vars(test)) # 两个一样 ''' {'__module__': '__main__', '__init__': <function test.__init__ at 0x00000000024D99D8>, 'set': <function test.set at 0x00000000024D9A60>, '__dict__': <attribute '__dict__' of 'test' objects>, '__weakref__': <attribute '__weakref__' of 'test' objects>, '__doc__': None} ''' # frozenset() # 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。 a =frozenset(range(10)) print(a) # frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9}) b = frozenset('runoob') print(b) # frozenset({'o', 'u', 'r', 'n', 'b'}) # divmod() # 函数把除数和余数运算结果结合起来， # divmod(a,b) # a: 数字 # b: 数字 print(divmod(2,4)) # (0, 2) print(divmod(5,4)) # (1, 1)