内置函数

 python中总共有68个内置函数，这68个内置函数又可分为反射相关、基础数据类型相关、作用域相关、面向对象相关、迭代器/生成器相关，以及其他6大类。

		Built-in Functions
abs()	dict()	help()	min()	setattr()
all()	dir()	hex()	next()	slice()
any()	divmod()	id()	object()	sorted()
ascii()	enumerate()	input()	oct()	staticmethod()
bin()	eval()	int()	open()	str()
bool()	exec()	isinstance()	ord()	sum()
bytearray()	filter()	issubclass()	pow()	super()
bytes()	float()	iter()	print()	tuple()
callable()	format()	len()	property()	type()
chr()	frozenset()	list()	range()	vars()
classmethod()	getattr()	locals()	repr()	zip()
compile()	globals()	map()	reversed()	__import__()
complex()	hasattr()	max()	round()
delattr()	hash()	memoryview()	set()

 作用域相关

globals()是获取全局变量的字典
loclas()获取执行本方法所在命名空间内的局部变量的字典

注意要和global和nonlocal等区分：

global+变量：定义了一个全局变量

nonlocal+变量：定义了一个局部变量

还有带下划线的方法：

__next__就等价于，next()方法；与此类似iter

iter（）：可迭代的就是可迭代对象
迭代器=iter(可迭代的）=可迭代的.__iter__

dir：查看一个变量拥有的方法,只是显示方法的名字
callable:检查一个名字是不是函数，只要能够调用的，返回值就为ture。
比如print(callable(print))
def func():pass
print(callable(func))

hlep:
help():打印出有关该函数的所有方法，于dir相比，不仅仅是函数名，还有其他的解释

import等价于__import__()
某个方法属于某个数据类型的变量，就用.调用比如list.append
如果某个方法不依赖任何数据类型，就直接调用，内置函数和自定义函数,比如print（），import

f=open('1.复习')
print(f.writable())#表示能不能写，返回ture或者false
print(f.readable())#表示能不能读，返回ture或者false

hash:

print(hash(12345))
print(hash('dskjkl'))
print(hash(('dskjkl','123')))
print(hash([]))


D:\anoconda\python.exe F:/python/python学习/人工智能/第一阶段day2/2.作业.py
12345
Traceback (most recent call last):
-7564731404730763680
  File "F:/python/python学习/人工智能/第一阶段day2/2.作业.py", line 4, in <module>
1915581128307838963
    print(hash([]))
TypeError: unhashable type: 'list'

Process finished with exit code 1

如以上结果所示：数字、字符串、元组都是可哈希的，但是列表不可哈希

hash值对于可以hash的数据的hash值在一次程序的执行过程中总是不变
应用：字典中的一个key对应一个hash值，这个key对应的value值也放在这个hash值上，那么利用key可以很快找到value值。

print

print(‘sklj’end='')#指定输出的结果
print(1,2,3,4,step='')#指定输出多个值之间的分隔符

f=open('演示','w')
print('aaa',file=f)
f.close()
#一般print的结果都是显示在当前页面，但是在指定了文件地址后，能够打印到指定的文件内

利用print方法来打印进度条

import time
for i in range(0,101,2):
     time.sleep(0.1)
     char_num = i//2      #打印多少个'*'
     per_str = '\r%s%% : %s\n' % (i, '*' * char_num) if i == 100 else '\r%s%% : %s'%(i,'*'*char_num)
     print(per_str,end='', flush=True)
#小越越  ： \r 可以把光标移动到行首但不换行

 eval和exec

exec和eval都可以执行字符串类型的代码
eval有返回值，只能用在你明确直到你要执行的代码是什么，但是容易被黑客利用不安全，适合简单的计算
exec没有返回值，适合简单的流程控制

代码示例如下：

exec('print(123)')
eval('print(123)')
print(exec('1+2+3+4'))
print(eval('1+2+3+4'))


D:\anoconda\python.exe F:/python/python学习/人工智能/第一阶段day2/2.作业.py
123
123
None
10

Process finished with exit code 0

能够执行结果

code='''
for i in range(10):
     print(i*'*')
'''
exec(code)#代码运行结果是※的堆积，是一个流程，如果使用eval则会直接报错

compile
将字符串类型的代码进行编译，代码对象能够通过exec语句来执行或者eval来进行求值

1. 参数source：字符串或者AST（Abstract Syntax Trees）对象。即需要动态执行的代码段。　　

2. 参数 filename：代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。当传入了source参数时，filename参数传入空字符即可。　　

3. 参数model：指定编译代码的种类，可以指定为 ‘exec’,’eval’,’single’。当source中包含流程语句时，model应指定为‘exec’；当source中只包含一个简单的求值表达式，model应指定为‘eval’；当source中包含了交互式命令语句，model应指定为'single'。

code1='for i in range(0,10):print(i)'
compile1=compile(code1,'','exec')#这里的空双引号表示省略了文件名，
exec(compile1)

code1='1+2+3+4'
compile1=compile(code1,'','eval')#这里的空双引号表示省略了文件名，
print(eval(compile1))#注意看结果时候，需要打印出来

 

#交互语句用single
code3 = 'name = input("please input your name:")'
compile3 = compile(code3,'','single')
# name #执行前name变量不存在
exec(compile3)
name

 浮点数：有限循环小数和无限循环小数称为浮点数

bin、oct、hex分别能够转成2进制、8进制和16进制

abs:求绝对值
divmod:除余方法，

print(divmod(9,4))

D:\anoconda\python.exe F:/python/python学习/人工智能/第一阶段day2/2.作业.py
(2, 1)

Process finished with exit code 0
#表示结果是2，余数是1

round:小数位数设置

pow:幂运算。
pow(2,3)#2的3次方
pow(2,3,3)#2的3次方除以3的余数

print(min(1,2,3,-4,key=abs))#注意这里如果没有key这个参数，那么最小值是-4，但是加上了取绝对值这个参数，结果就是1.
print(max(1,2,3,-4,key=abs))#注意这里如果没有key这个参数，那么最大值是3，但是加上了取绝对值这个参数，结果就是-4.

 

 数据结构：

dict list  tuple set  str.注意dict和tuple只存在于python中，其他编程语言中不存在。

reverse和reversed()：

reverse只是表示反转，会生成新的反转后的对象

reversed()不改变原来的列表，会生成一个新反向的迭代器

l=[1,2,3,4]
l1=reversed(l)
print(l1)#这里生成一个迭代器，
for i in l1:
    print(i)

D:\anoconda\python.exe F:/python/python学习/人工智能/第一阶段day2/2.作业.py
<list_reverseiterator object at 0x000001BEBADC6048>
4
3
2
1

Process finished with exit code 0

slice切片

l=[1,2,3,4,5,6,7,8,9]
sli=slice(1,5)
print(l[sli])
#实际上就等价于
print(l[1:5])

format:

可参考：http://www.cnblogs.com/Eva-J/articles/7266245.html

print(format('text','<20'))#左对齐
print(format('text','>20'))#左对齐
print(format('text','^20'))#居中

D:\anoconda\python.exe F:/python/python学习/人工智能/第一阶段day2/2.作业.py
text                
                text
        text        

Process finished with exit code 0

bytes
网络编程：只能使用二进制
照片和视频也是二进制存储
html网页爬取到的也是二进制编码

print(bytes('你好',encoding='utf-8').decode('utf-8'))#unicode转换成utf-8的bytes类型
print(bytes('你好',encoding='utf-8').decode('utf-8'))#unicode转换成utf-8的bytes类型，然后再转换成utf-8格式
print(bytes('你好',encoding='gbk'))

ord:将字符串按照unicode转成数字

chr:将unicode编码的数字转成字符

repr:

print(repr(1))
print(repr('1'))

D:\anoconda\python.exe F:/python/python学习/人工智能/第一阶段day2/2.作业.py
1
'1'

Process finished with exit code 0

 all():括号中的参数必须是可迭代的，有一个值为空就表示false

print(all(['a','','123']))#有一个空值
print(all(['a','123']))
print(all([0,'123']))#有一个0


D:\anoconda\python.exe F:/python/python学习/人工智能/第一阶段day2/2.作业.py
False
True
False

Process finished with exit code 0

print(any(['a','','123']))#有一个为真就为true

zip:有拉链的意思，其在代码中的作用也类似于拉链

l=[1,2,3]
l1=['a','b','c']
print(zip(l,l1))#运行结果是一个内存地址，猜想他是一个迭代器
#使用for循环
for i in zip(l,l1):
    print(i)

D:\anoconda\python.exe F:/python/python学习/人工智能/第一阶段day2/2.作业.py
<zip object at 0x000001FCFFA9CFC8>
(1, 'a')
(2, 'b')
(3, 'c')

Process finished with exit code 0

 

l=[1,2,3]
l1=['a','b','c']
l2=('*','**',[1,2])
l3={'k1':1,'k2':5}
print(zip(l,l1))#运行结果是一个内存地址，猜想他是一个迭代器
#使用for循环
for i in zip(l,l1,l2,l3):
    print(i)

D:\anoconda\python.exe F:/python/python学习/人工智能/第一阶段day2/2.作业.py
<zip object at 0x000001A72C821088>
(1, 'a', '*', 'k1')
(2, 'b', '**', 'k2')

Process finished with exit code 0

filter

def func(x):
    return x%2==1

ret=filter(func,[1,2,3,4,5,6,7,8,9])#将后面可迭代列表中的元素逐个传递到前面的函数名中，如果为true,则显示结果
#等价于下面的列表推导式[i for i in [1,2,3,4,5,6,7,8,9] if i%2==1]
print(ret)#说明ret是一个迭代器
for i in ret:
    print(i)

def func(x):
    return type(x)==str

ret=filter(func,[1,2,3,'HI',4,5,6,7,'DKHK',8,9])#将后面可迭代列表中的元素逐个传递到前面的函数名中，如果为true,则显示结果,筛选出字符
#等价于下面的列表推导式[i for i in [1,2,3,4,5,6,7,8,9] if i%2==1]
print(ret)#说明ret是一个迭代器
for i in ret:
    print(i)

#去掉none和空值
def func(x):
    return x and str(x).strip()

ret=filter(func,[1,2,3,'HI','',None,[],4,5,6,7,'DKHK',8,9])#将后面可迭代列表中的元素逐个传递到前面的函数名中，如果为true,则显示结果,筛选出字符
#等价于下面的列表推导式[i for i in [1,2,3,4,5,6,7,8,9] if i%2==1]
print(ret)#说明ret是一个迭代器
for i in ret:
    print(i)

#找出100以内平方根为整数的数字
from math import sqrt

def func(x):
    return sqrt(x)%1==0

ret=filter(func,range(1,101))#将后面可迭代列表中的元素逐个传递到前面的函数名中，如果为true,则显示结果,筛选出字符
#等价于下面的列表推导式[i for i in [1,2,3,4,5,6,7,8,9] if i%2==1]
print(ret)#说明ret是一个迭代器
for i in ret:
    print(i)

filter:执行了filter之后的结果集合<=执行前的数字
map:执行前后个数不变，值可能改变

ret=map(abs,[-1,-5,4,8,9,-6])#将后面可迭代列表中的元素逐个传递到前面的函数名中，如果为true,则显示结果,筛选出字符
#等价于下面的列表推导式[i for i in [1,2,3,4,5,6,7,8,9]]
print(ret)#说明ret是一个迭代器
for i in ret:
    print(i)

sort

l=[1,-10,5,-8]
l.sort()
print(l)
#在原列表的基础上进行排序

sorted：不改变原来的列表

l=[1,-10,5,-8]
print(sorted(l))
print(l)#原来的列表l依然存在，缺点是占内存

#列表按照每一个元素的len排序
l = [[1,2],[3,4,5,6],(7,),'123']
print(sorted(l,key=len))

 作业

用map来处理字符串列表，把列表中所有人都变成sb,比方alex_sb

#首先定义这样一个能够在字符串后面加上_sb的函数，且该函数有返回值
def func(item):
    return item+'_sb'
name=['alex','wupeiqi','yuanhao','nezha']
ret=map(func,name)#这里直接调用func函数
for i in ret:
    print(i)
print(list(ret))#注意ret是一个迭代器，所以当使用for循环取完值以后，这里打印出的结果就为空

进一步改进

name=['alex','wupeiqi','yuanhao','nezha']
ret=map(lambda item:item+'_sb',name)
print(list(ret))

用filter函数处理数字列表，将列表中所有的偶数筛选出来

def func(x):
    return x%2==0
num=[1,3,5,6,7,8]
ret=filter(func,num)
print(list(ret))
print(list(ret))#因为ret是一个迭代器，所以上面的list已经取完了ret中所有的值，这里print的结果就是空列表

使用匿名函数

num=[1,3,5,6,7,8]
ret=filter(lambda x:x%2==0,num)
print(list(ret))

匿名函数的另一种方式

num=[1,3,5,6,7,8]
ret=filter(lambda x:True if x%2==0 else False,num)#在匿名函数中加上简单的条件语句
print(list(ret))

5、随意写一个20行以上的文件：
运行程序，先将内容读取到内存中，用列表存储；
接收用户输入的页码，每页五条，仅输出当页的内容

 这是自己写的代码

with open('file',encoding='utf-8') as f:
    l=f.readlines()
page_num=int(input('请输入您的页码：'))
pages,mod=divmod(len(l),5)
# print(pages,mod)
for i in range(1,6):
    print(l[page_num*5-i].strip())

这是老师写的代码

with open('file',encoding='utf-8') as f:
    l=f.readlines()
page_num=int(input('请输入您的页码：'))
pages,mod=divmod(len(l),5)
# print(pages,mod)
# print(len(l))


if mod:
    pages+=1
if page_num>pages:
    print('输入有误')

elif page_num==pages and mod !=0:
    for i in rang(mod):
        # print(l[(page_num-1)*5+i].strip())
        print(l[i].strip())
else:
    for i in range(5):
        print(l[i].strip())

 6.如下，每个小字典的name对应股票名字，shares对应多少股，price对应股票的价格

portfolio = [
    {'name': 'IBM', 'shares': 100, 'price': 91.1},
    {'name': 'AAPL', 'shares': 50, 'price': 543.22},
    {'name': 'FB', 'shares': 200, 'price': 21.09},
    {'name': 'HPQ', 'shares': 35, 'price': 31.75},
    {'name': 'YHOO', 'shares': 45, 'price': 16.35},
    {'name': 'ACME', 'shares': 75, 'price': 115.65}
]

6.1.计算购买每支股票的总价

ret=map(lambda dic:{dic['name']:round(dic['shares']*dic['price'],2)},portfolio)#自己这里尝试使用for循环但是没有做出来，这是老师的方法
print(list(ret))

D:\anoconda\python.exe F:/python/python学习/人工智能/第一阶段day2/练习.py
[{'IBM': 9110.0}, {'AAPL': 27161.0}, {'FB': 4218.0}, {'HPQ': 1111.25}, {'YHOO': 735.75}, {'ACME': 8673.75}]

根据老师的方法求出的结果是一个列表，但是进一步，需要求出购买这些股票需要多少资金

ret=map(lambda dic:round(dic['shares']*dic['price'],2),portfolio)
l=list(ret)
print(l)
sum=0
for i in range(len(l)):
    sum=l[i]+sum
print(sum)#这是自己写的代码，能够实现对列表中的所有元素进行求和

 6.2.用filter过滤出，单价大于100的股票有哪些

ret=filter(lambda dic: dic['price']>100,portfolio)
print(list(ret))