Python学习路程——Day15

重要内置函数

zip()

'''
zip()函数的作用
	zip() 函数可以将多个序列（列表、元组、字典、集合、字符串以及ranger()区间构成的列表压缩成一个zip对象，所谓压缩，其实就是将这些序列中对应位置的元素重新组合，生成一个个新的元素）他们之间的关系是一一对应的。
	语法结构：
		zip(iterable,...)  itearable 可迭代的、可重复的
		
'''
# 列表
list_one = [1, 2, 3]
list_two = ['name', 'age', 'sex']
res = zip(list_one, list_two)
print(res)  # <zip object at 0x000001C3A3037BC0>
print(list(res))    # [(1, 'name'), (2, 'age'), (3, 'sex')]
print(dict(res))  # {1: 'name', 2: 'age', 3: 'sex'} 如果两个同时输出的话，第二个为空

# 集合
set_one = {1, 2, 3}
set_two = {'name', 'age', 'sex'}
res = zip(set_one, set_two)
print(res)  # <zip object at 0x000001FD04A87BC0>
print(list(res))    # [(1, 'name'), (2, 'age'), (3, 'sex')]

# 元组
tuple_one = (1, 2, 3)
tuple_two = ('name', 'age', 'sex')
res = zip(tuple_one, tuple_two)
print(res)  # <zip object at 0x0000018BB78C7C00>
print(list(res))    # [(1, 'name'), (2, 'age'), (3, 'sex')]

# 字符串
str_one = '123'
str_two = 'abc'
res = zip(str_one, str_two)
print(res)  #   <zip object at 0x0000013C569B44C0>
print(list(res)) # [('1', 'a'), ('2', 'b'), ('3', 'c')]

# 字典
dict_one = {'name': 'Jason',
            'age': 18,
            'sex': '女'
            }
dict_two = {'Tony': 'name',
            '18': 'age',
            '女': 'sex'
            }
res = zip(dict_one, dict_two)
print(res)  # <zip object at 0x000001AF2DC37E40>
print(list(res))  # [('name', 'Tony'), ('age', '18'), ('sex', '女')]

# range()
ran = range(1, 5)
ran1 = range(2, 6)
res = zip(ran, ran1)
print(res)  # <zip object at 0x00000250FD394540>
print(list(res))    # [(1, 2), (2, 3), (3, 4), (4, 5)]`	

filter()

'''
	filter，顾名思义，就是一个过滤器。其作用是从列表（或其他序列类型）中筛选出满足条件的子列表，filter是python的内置函数，无须import即可直接使用。
	
filter的基础用法:
	对于列表（或其他序列类型），如果希望从中筛选出满足某个约束条件的子列表，我们一般的做法是使用一个for循环遍历每个元素然后执行相同约束条件判断，将满足条件的放入新的子列表中。例如，从列表中找出所有偶数子列表，并按对应的先后顺序放入子列表中:
	
	语法结构：
	filter(function or None, iterable)

	function：函数，作用是对iterable中的每个元素判断是否符合特定条件。

	None：不调用任何函数，只对可迭代对象中的元素本身判断真假，保留为真的元素。

	iterables：可迭代对象(序列、字典等)。
'''
# 求一个序列中大于零的元素组成的新序列
c = [-10, 28, 9, -5, 30, 5]
filter(lambda a:a>0, c) # <filter at 0x27950dbb9d0>
list(filter(lambda a:a>0, c)) # [28, 9, 30, 5]

# 求序列中非零数组成的新序列
'''
	在filter函数定义中提到，filter函数中参数None表示不调用任何函数，只对可迭代对象中的元素本身判断真假，保留为真的元素。
'''
#找出序列中的非0数
c2 = [4, 9, 0, -5, -8, 7, 0]
list(filter(None, c2)) # [4, 9, -5, -8, 7]

# 求字典中大于2的键组成的新序列
'''
	在filter函数定义中提到，它对可迭代对象进行处理，所以包括了列表和字典等对象。前两个例题都是对列表进行处理，本例看下对字典的处理。代码如下：
'''
# 找出字典中大于2的键
list(filter(lambda x:x>2, {1:'杨紫', 2:'刘诗雯', 3:'张继科', 4:'王明', 5:'刘明'})) # [3, 4, 5]

sorted()

'''
	sorted() 作为 Python 内置函数之一，其功能是对序列（列表、元组、字典、集合、还包括字符串）进行排序。
	
	sorted() 函数的基本语法格式如下：
	list = sorted(iterable, key=None, reverse=False)
   
    其中，iterable 表示指定的序列，key 参数可以自定义排序规则；reverse 参数指定以升序（False，默认）还是降序（True）进行排序。sorted() 函数会返回一个排好序的列表。 
    
    注意，key 参数和 reverse 参数是可选参数，即可以使用，也可以忽略。
'''

#对列表进行排序
a = [5,3,4,2,1]
print(sorted(a))
#对元组进行排序
a = (5,4,3,1,2)
print(sorted(a))
#字典默认按照key进行排序
a = { 4:1,
    5:2,
    3:3,
    2:6,
    1:8}
print(sorted(a.items()))
#对集合进行排序
a = {1,5,3,2,4}
print(sorted(a))
#对字符串进行排序
a = "51423"
print(sorted(a))

'''
[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5]
[(1, 8), (2, 6), (3, 3), (4, 1), (5, 2)]
[1, 2, 3, 4, 5]
['1', '2', '3', '4', '5']
'''
'''
	再次强调，使用 sorted() 函数对序列进行排序， 并不会在原序列的基础进行修改，而是会重新生成一个排好序的列表。例如： 
'''
#对列表进行排序
a = [5,3,4,2,1]
print(sorted(a))
#再次输出原来的列表 a
print(a)

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

'''
	除此之外，sorted(）函数默认对序列中元素进行升序排序，通过手动将其 reverse 参数值改为 True，可实现降序排序。例如： 
'''
#对列表进行排序
a = [5,3,4,2,1]
print(sorted(a,reverse=True)) # [5, 4, 3, 2, 1]

'''
	另外在调用 sorted() 函数时，还可传入一个 key 参数，它可以接受一个函数，该函数的功能是指定 sorted() 函数按照什么标准进行排序。例如：
'''
chars=['http://c.biancheng.net',
       'http://c.biancheng.net/python/',
       'http://c.biancheng.net/shell/',
       'http://c.biancheng.net/java/',
       'http://c.biancheng.net/golang/']
#默认排序
print(sorted(chars))
#自定义按照字符串长度排序
print(sorted(chars,key=lambda x:len(x)))
'''
['http://c.biancheng.net',
 'http://c.biancheng.net/golang/',
 'http://c.biancheng.net/java/',
 'http://c.biancheng.net/python/',
 'http://c.biancheng.net/shell/']
 
['http://c.biancheng.net',
 'http://c.biancheng.net/java/',
 'http://c.biancheng.net/shell/',
 'http://c.biancheng.net/python/',
 'http://c.biancheng.net/golang/']
'''

常见的内置函数

abs（）绝对值

print(abs(-888)) # 888
print(abs(888))	# 888

all() 返回布尔值

'''
所有数据值对应的布尔值为True结果才是True 否则返回False
'''
print(all([0, 1, 6, 8]))	# False
print(all([1, 6, 8, True]))	# True

any() 返回布尔值

'''
所有数据值对应的布尔值有一个为True结果就是True 否则返回False
'''
print(any([0, None, '', 1])) # True
print(any([0, None, '']))	# False

bin() oct() hex() int()

'''
进制转换
'''

7.chr() ord()  #基于ASCII码表做数字与字母的转换
print(chr(65))  # A
print(ord('A'))  # 65
8.dir()  返回括号内对象能够调用的名字
print(dir('hello'))
9.divmod()  元组 第一个数据为整除数 第二个是余数
res = divmod(100, 2)
print(res)  # (50, 0)
res = divmod(100, 3)
print(res)
page_num, more = divmod(9999, 20)
print(divmod(99, 10))  # (9, 9)
if more:
    page_num += 1
print('总页码为:', page_num)  # 总页码为: 500
10.enumerate()  枚举
11.eval() exec()  能够识别字符串中的python并执行
s1 = 'print("哈哈哈")'
eval(s1)
exec(s1)
s2 = 'for i in range(100):print(i)'
eval(s2)  # 只能识别简单的python代码 具有逻辑性的都不行
exec(s2)  # 可以识别具有一定逻辑性的python代码
12.hash()  哈希加密
print(hash('jason'))
13.id() input() isinstance()
14.map() max() min()
15.open()
16.pow()  幂指数(次方)
print(pow(2, 2))
print(pow(2, 3))
print(pow(2, 4))
17.range()
18.round() 四舍五入
print(round(98.3))
print(round(98.6))
19.sum()
print(sum([11, 22, 33, 44, 55, 66]))
20.zip()

可迭代对象

1.可迭代对象
	对象内置有__iter__方法的都称为可迭代对象
	"""
	1.内置方法  通过点的方式能够调用的方法
	2.__iter__  双下iter方法
	"""
2.可迭代对象的范围
	不是可迭代对象
    	int float bool 函数对象
	是可迭代对象
    	str list dict tuple set 文件对象
3.可迭代的含义
	"""
	迭代:更新换代(每次更新都必须依赖上一次的结果)
		eg:手机app更新
	"""
	可迭代在python中可以理解为是否支持for循环

迭代器对象

1.迭代器对象
	是由可迭代对象调用__iter__方法产生的
	迭代器对象判断的本质是看是否内置有__iter__和__next__
2.迭代器对象的作用
	提供了一种不依赖于索引取值的方式
 	正因为有迭代器的存在 我们的字典 集合才能够被for循环
3.迭代器对象实操
	 s1 = 'hello'  # 可迭代对象
    res = s1.__iter__()  # 迭代器对象
    print(res.__next__())  # 迭代取值 for循环的本质
	 一旦__next__取不到值 会直接报错
4.注意事项
	可迭代对象调用__iter__会成为迭代器对象 迭代器对象如果还调用__iter__不会有任何变化 还是迭代器对象本身

for循环的本质

for 变量名 in 可迭代对象:
    循环体代码
"""
1.先将in后面的数据调用__iter__转变成迭代器对象
2.依次让迭代器对象调用__next__取值
3.一旦__next__取不到值报错 for循环会自动捕获并处理
"""

异常捕获/处理

1.异常
	异常就是代码运行报错 行业俗语叫bug
	代码运行中一旦遇到异常会直接结束整个程序的运行 我们在编写代码的过程中药尽可能避免
2.异常分类
	语法错误
    	不允许出现 一旦出现立刻改正 否则提桶跑路
	逻辑错误
    	允许出现的 因为它一眼发现不了 代码运行之后才可能会出现
3.异常结构
	错误位置
 	错误类型
 	错误详情

原文地址：http://www.cnblogs.com/HaiMan/p/16792843.html