一、三元表达式
语法：[成立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 = 23res = '猜大了' if age > 23 else '猜小了' if age < 23 else '猜对了'print(res)# '猜对了''''语句解析：age = 23if age >23:res = '猜大了'elif age <23:res = '猜小了'else:res = '猜对了''''
二、列表推导式
# 语法'''[expression for item1 in iterable1 if condition1for 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] = iprint(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 1test = 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 100return sum(count-1) + 20print(sum(5))# 图解'''sum(5) == sum(4) +20sum(4) == sum(3) + 20sum(3) == sum(2) + 20sum(2) == sum(1) + 20sum(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) // 2if midden_index == 0:print('找到了' if nums[0] == n else '不存在该数据')returnnum = nums[midden_index]if num == n:print('找到了')returnelif 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()则返回一个对象的类型#更多内置函数：/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最大值的那个keyprint(min(dic)) # x 这个取的是key的最小值print(min(dic,key=lambda k:dic[k])) # z # 这个取的是value最小值的那个keyprint(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> 生成器
min,max,sorted,map,filter与匿名函数的运用
# # 数据类型函数# 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):passclass A1(A):def get(self):print('A1')@staticmethoddef 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# delattrdelattr(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))# 0b1010print(bin(2))# 0b10# bytearray() # 方法返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256。# class bytearray([source[, encoding[, errors]]])print(bytearray([1,2,3]))# bytearray(b'\x01\x02\x03')print(bytearray('中国', 'utf-8'))# bytearray(b'\xe4\xb8\xad\xe5\x9b\xbd')# slice() # 切片arr = range(10)print(arr[0:5:2])print(arr[slice(None,5,2)])# range(0, 5, 2) 两个都一样print(arr[5])# 5print(arr[slice(5)]) # ==> slice(5) == slice(None,5)# range(0, 5)# dir() # 获取当前模块的属性列表。print(dir())# hex() # 函数用于将10进制整数转换成16进制，以字符串形式表示print(hex(10))# 0xaprint(hex(1))# 0x1print(hex(16))# 0x10# hash() # 用于获取取一个对象（字符串或者数值等）的哈希值。print(hash('test'))# -8237931458019123489print(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# 98print(v[2]) # c# 99# round() # 方法返回浮点数x的四舍五入值。 必须是数值print(round(2.3))# 2print(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 = namedef set(self,name,value):self.name = valueprint(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)
其他内置函数
