甜橘子，专注成都网站制作网站设计与营销型网站建设与优化
QQ :532337155
电话：028-86922220
1、get() 返回指定键的值，如果值不在字典中返回default值。
创新互联从2013年成立，是专业互联网技术服务公司，拥有项目成都网站设计、成都网站制作网站策划，项目实施与项目整合能力。我们以让每一个梦想脱颖而出为使命，1280元嘉鱼做网站,已为上家服务,为嘉鱼各地企业和个人服务,联系电话:028-86922220
语法：dict.get(key,default=None)
参数：
key 字典中要查找的键。
default 如果指定键的值不存在时，返回该默认值值。
例：
dict={'Name':'alex','Age':21}
print("Name is:%s"% dict.get('Name')+"\n"+ "Age is:%d"% dict.get('Age'))
显示结果为：
Name is:alex
Age is:21
2、update() 将一个字典中的值更新到另一个字典中。
语法：dict.update(dict2)
参数：
dict2 添加到指定字典dict里的字典。
例：
dict={'Name':'alex','Age':21}
dict2={'Sex':'female'}
dict.update(dict2)
print("Value is %s" % dict)
显示结果为：
Value is {'Name': 'alex', 'Age': 21, 'Sex': 'female'}
1.集合类型概述
Python语言中的集合类型与数学中的集合概念一致，即包含0个或多个数据项的无序组合。
集合是无序组合，用大括号{}表示，它没有索引和位置的概念，集合中元素可以动态增加或删除。
由于集合元素独一无二，使用集合类型能够过滤掉重复元素。
集合类型有4个操作符，交集、并集|、差集-、补集^，操作逻辑与数学定义相同
集合类型有一些常用的操作函数或方法
set()函数将其他的组合数据类型变成集合类型，返回结果是一个无重复且排序任意的集合。set()函数也可以生成空集合变量。
列表类型用中括号[]表示，也可以通过list(x)函数将集合或字符串类型转换成列表类型。
列表属于序列类型，所以列表类型支持序列类型对应的操作
1.序列类型有一些通用的操作符和函数
2.列表的索引
索引是列表的基本操作，用于获得列表的一个元素。使用中括号作为索引操作符。
可以使用遍历循环对列表类型的元素进行遍历操作，
基本使用方式如下
3.列表的切片
切片是列表的基本操作，用于获得列表的一个片段，即获得一个或多个元素。切片后的结果也是列表类型。
切片的使用方式：
切片获取列表类型从N到M（不包含M）的元素组成新的列表。当K存在时，切片获取列表类型从N到M（不包含M）以K为步长所对应元素组成的列表。
1.列表的操作方法
ls.append(x)仅用于在列表中增加一个元素，如果希望增加多个元素，可以使用加号+，将两个列表合并。
可以使用Python保留字del对列表元素或片段进行删除。
如下：
或
使用索引配合等号（=）可以对列表元素进行修改。
补：元组
Python的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号()，列表使用方括号。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
Python语言中的字典使用大括号{}建立，每个元素是一个键值对。
使用方式：
键和值通过冒号连接，不同键值对通过逗号隔开。大括号可以表示集合，字典类型也具有和集合类似的性质，即键值对之间没有顺序且不能重复。
•字典的索引
列表类型采用元素顺序的位置进行索引。由于字典元素“键值对”中键是值的索引，因此，可以直接利用键值对关系索引元素。
利用索引和赋值 = 配合，可以对字典中每个元素进行修改。
使用大括号可以创建字典。通过索引和赋值配合，可以向字典中增加元素。
字典类型有一些通用的操作函数
字典类型存在一些操作方法
d.keys()返回字典中的所有键信息，返回结果是Python的一种内部数据类型dict_keys，专用于表示字典的键。如果希望更好的使用返回结果，可以将其转换为列表类型。
d.values()返回字典中的所有值信息，返回结果是Python的一种内部数据类型dict_values。如果希望更好的使用返回结果，可以将其转换为列表类型。
d.items()返回字典中的所有键值对信息，返回结果是Python的一种内部数据类型dict_items。
d.get(key, default)根据键信息查找并返回值信息，如果key存在则返回相应值，否则返回默认值，第二个元素default可以省略，如果省略则默认值为空。
d.pop(key, default)根据键信息查找并取出值信息，如果key存在则返回相应值，否则返回默认值，第二个元素default可以省略，如果省略则默认值为空。相比d.get()方法，d.pop()在取出相应值后，将从字典中删除对应的键值对。
d.popitem()随机从字典中取出一个键值对，以元组(key,value)形式返回。取出后从字典中删除这个键值对。
d.clear()删除字典中所有键值对。
此外，如果希望删除字典中某一个元素， 可以使用Python保留字del。
字典类型也支持保留字in，用来判断一个键是否在字典中。如果在则返回True，否则返回False。
字典可以遍历循环对其元素进行遍历
for循环返回的变量名是字典的索引值。如果需要获得键对应的值，可以在语句块中通过get()方法获得。
def exchange(d):
res = dict((v,k) for k,v in d.items())
print(res)
print(d)
一行代码完成交换的，按你的需求定义了一个函数
一,python整数类型所表示的数据。
1,一般用以表示一类数值:所有正整数,0和负整数;
2,整型作为最常用的,频繁参与计算的数据类型，在python3.5中解释器会自动在内存中创建-5-3000之间的（包含5，不包含3000）整型对象，也就是说在该范围内,相等都是同一个已经创建好的整型对象。范围之外的即使相等也表示不同对象，该特性随python版本而改变，不要过于依赖。
3,bool型继承了int型，他是int的子类。
4,Python2中有长整型long，数值范围更大，在python3中已取消，所有整型统一由int表示。
5,参与所有数值计算，数学运算，科学计算。这也是所有编程语言都有的数据类型，因为编程语言生而需要模拟人的思维，借助数学方式，自动计算、更好的解决大量重复性的事务，因此数值类型、整数类型在编程语言中不可或缺。
6,支持二进制(0b\0B开头),十进制,八进制(0o\0O),十六进制(0x\0X)
二，python整数和浮点型支持常规的数值运算
整数和浮点数都可参与的运算：+ - * / %（取余） //（整除） **（幂）
Python字符型：
python字符型表示的数据：
python3支持Unicode编码，由字母、数字和符号组成的形式就叫字符串，更接近或者相同与人们文字符号表示，因此在信息表示和传递时它也是最受认可的形式。在程序编写中也是非常常用，对应的可操作的方法也很多，很有意思。
字符串不可被修改，可以拼接等方法创建新字符串对象；
支持分片和下标操作；a[2:]
支持+拼接，*重复操作和成员关系in/not in；
表示形式：用单引号双引号包含起来的符号；a = str(‘sdfsdfsdf’) 或 r’\t\nabcd’ 原始字符，Bytes：b’abcd’；
6,字符串属于不可变数据类型，内部机制为了节省空间，相同的两个字符串表示相同的一个对象。a = ‘python’ b = ‘python’ a is b :True
二, 字符串支持的运算方法
1,capitalize() :首字母大写后边的字母小写 a = ‘abcd’ b = a.capitalize() b:Abcd
2,casefold() lower():字母转换为全小写
3,center(width,fillchar) :居中，width填补的长度；fillchar添加的字符
a = a.center(10,’_’) //’____abcd____’ 默认无fillchar填充空格
4,count(sub,star,end) :字母计数：sub要查询的字符
5,encode(encoding=’utf-8’,errors=’strict’) 设置编码
Errors :设置错误类型
6,endswith(suffix,star,end) : 若以suffix结尾返回True
7，expandtabs(8) :设置字符串中tab按键符的空格长度：’\tabcde’
8,find(sub,star,end) : 返回指定范围内的字符串下标，未找到返回-1
9，index(sub,star,end) :返回指定范围字符串下标未找到抛出异常
10，isalnum() :判断字符串是否是字母或数字，或字母和数字组合
11，isalpha() :判断是否全是字母
12，isdecimal() :判断字符串是否是十进制数值
13，isdigit() :判断字符串是否是数字
14，isidentifier() :判断字符串中是否包含关键字
15，islower() :判断是否全小写
16，isnumeric() :判断全是数字
17，isspace() :判断是否是空格
18，isupper() 判断是否大写
19，istitle() :判断是否首字母大写
20，join(iterable) :把可迭代对象用字符串进行分割：a.join(‘123’)
21,ljust(width,fillchar);rjust() :左对齐右对齐
22, upper() :将字符串改为大写
23，split(sep=None,maxsplit=-1) :分割一个字符串，被选中字符在字符串中删除
‘ab1cd1efg’.split(‘1’) :[‘ab’,’cd’,’efg’]
三，字符串格式化：按照规格输出字符串
format(*args,**kwargs) :args位置参数，kwargs关键字参数
‘{0:.1f}’.format(123.468) :格式化参数，小数点后保留1位四舍五入
四，字符串操作符%
1，%s :格式化字符串 ‘abcd%sdef’%’dddd’
2，%d:格式化整数
3，%o格式化无符号八进制
4，%x格式化无符号十六进制
5，%f格式化定点数
6, %e: 科学计数法格式化定点数
7，%g 根据值大小自动选%f,%e
8, %G E X :大写形式
五，格式化辅助命令：
m.n :m最小总宽度，n小数点后位数：’%12.4f’%23456.789
六，转义字符：字符串前r避免转义：r’\nhello\thi’
\n:换行符
\t:横向制表符
\':'
\":"
\b:退格符
\r:回车
\v:纵向制表符
\f:换页符
\o,\x:八进制和十六进制
\0:空字符串
Python列表list
一，Python的列表list类型表示的数据：
Python列表在cpython中被解释为长度可变的数组，用其他对象组成的连续数组。
列表中元素可以是相同或不同的数据类型；
当列表元素增加或删除时，列表对象自动进行扩展或收缩内存，保证元素之间没有缝隙，总是连续的。
Python中的列表是一个序列，也是一个容器类型
创建列表：a = []; b = [1,’python’]; c = list(); d = list((1,3,4,5))
支持切片操作list[start,stop,step]
python列表常用方法
1,append添加单个元素：list.append(object); //a.append(‘python’)
2,extend添加可迭代对象: list.extend(iterable); //a.extend(‘abcde’/[1,2,3])
3,insert 插入元素：list.insert(index,object): 在index下标前插入元素//a.insert(2,’python’)
4,clear 清空所有元素：list.clear() //a.clear()
5,pop 删除并返回一个元素：list.pop(index) //默认删除默认一个元素
remove 删除指定元素：list.remove(v) ,v元素不存在报错 //a.remove(‘c’)
7，count 返回这个值在列表中数量：list.count(value)
8,copy 浅拷贝一个新列表：list.copy()
9,sort:排序list.sort(reverse=False/True) :默认升序
排序函数：sorted(list)
10，reverse: 原地翻转：list.reverse()
11，index(value,star,stop) :指定范围内该值下标：list.index(2,0,5)
列表元素访问：
下标访问：list[1]
For循环遍历
通过下标修改元素：list[2 ] = ‘hello’
列表常用运算符：
1,比较运算符：从第一个元素开始对比
2，+ 拼接一个新列表：l1+ l2
3, 重复操作符：* ,多个列表拼接
成员关系操作符：in/ not in
逻辑运算符：and not or
列表常用的排序方法：
冒泡排序；选择排序；快速排序；归并排序
Python元组tuple
一，Python元组tuple数据类型表示的数据：
元组是受到限制的、不可改变的列表；
可以是同构也可以是异构；
元组是序列类型、是可迭代对象，是容器类型。
元组的创建: a = (1,2,3)或a=1,2,3; b = tuple(); c = tuple(iterable)
支持切片操作tuple[start,stop,step]
二，python元组常用方法
1,index(value,star,stop) :指定范围内该值下标：tuple.index(2,0,5)
2,count(value) ：值出现次数
三，支持运算：
1,比较运算符：从第一个元素开始对比
2，+ 拼接一个新元组：l1+ l2
3, 重复操作符：* ,多个元组拼接
4成员关系操作符：in/ not in
逻辑运算符：and not or
四，元组的访问
下标操作；
For循环遍历访问。
Python字典类型
一,Python字典dict表示的数据：{key:value}
可根据关键字：键快速索引到对应的值；
字典是映射类型，键值对一一对应关系，不是序列；
字典元素是无序的；
字典是可迭代对象，是容器类型；
字典的创建：k = {}; k1={‘keyword’:object}; k2 = dict();
K3 = dict(mapping); dict=(iterable)
二，字典的访问：
通过key：k[‘key’]
修改key对应的值：K[‘key’] = value
For循环遍历出来的是key；
For循环键值对：for I in d.items():
For 循环enumerate: for k,v in enumerate(k1):
In/not in 成员关系查询键不支持查值
三，字典常用方法
get(key,de):获取值：k.get(key,de) //若不存在则默认输出de
pop(k,de):删除一个键值对，不存在输出de，未设置报错；
keys() :返回字典所有key组成的序列：list(k.keys()) [1,2,3];
values():返回字典所有value组成的序列：list(k.values())
items():返回键值对组成的元组为元素的序列：（类set）list(k.items())
update(e):更新字典：e可是字典或两元素组成的单位元素序列：e=[(5,6),(7,8)];
k.update(e)
clear():清空字典；
popitem()删除某个键值对，若字典为空则报错
copy() :浅拷贝
10, fromkeys(iterable,value=None):从可迭代对象创建字典
{}.fromkeys([1,2,3]) -----{1:None,2:None,3:None}
11,setdefault(k,d=None) :若key不存在则生成一个键值对
k.setdefault(‘keyword’)
Python 集合set
集合表示的数据：
多个元素的无序组合，集合是无序的，集合元素是唯一的；
字典的键是由集合实现的；
集合是可迭代对象
集合创建：s = {1,2}; s1 = set(); s2 = set(iterable)
集合元素的访问：
For 循环将集合所有元素全部访问一遍，不重复
常用方法：
add(object):s.add(‘hi’) 向集合添加一个元素
pop() :弹栈，集合为空则报错：删除任意一个元素；
clear():清空集合，返回一个空集合对象；
remove(object):删除一个元素，不存在和报错：s.remove(‘hi’)
update(集合)：更新另一个集合，元素不存在则不更新；
copy() :浅拷贝
集合的运算：
交集：s1s2;
差集,补集：s1-s2;
并集：s1|s2;
Issubset():判断是否是子集：s1.issubset(s2) s1是否s2的集合子集
Issuperset():判断是否是父集：s1.issuperset()
不可变集合：
Frozenset():返回一个空的不可变集合对象
Frozenset(iterable):
S = frozenset(iterable)
Python序列类型共同特性
一,序列类型共同特性
python序列类型有:str字符串,list列表,tuple元组
都支持下标索引，切片操作；
下标都是从0开始，都可通过下标进行访问；
拥有相同的操作符
二，支持的函数：
len(obj):返回对象长度；
list(iterable):将可迭代对象转为列表；
tuple(iterable):将可迭代对象转为元组；
str(ojb):将任何对象转为字符串形式；
max(iterable): python3中元素要是同类型，python2中元素可异构：max([‘a’,1])
min(iterable):和max类似；
sum(iterable,star=0),求可迭代对象和，默认star为0，元素不能为字符串
sorted(iterable,key=None,reverse=False)
s=[(‘a’,3),(‘b’,2),(‘c’,9)]
sorted(s,key=lambda s:s[1]) //按照数字排序
reversed(sequence):翻转序列，返回迭代器
enumerate(iterable):返回enumerate对象,其元素都是一个元组（下标，值）
zip（iter1,iter2）: zip([1,2],[3,4]) ----[(1,3),(2,4)]
序列类型的切片操作：
Slice:
L[index]; 访问某个元素；
L[1:4]; 区间
L[star:stop:step]; 设置步长取区间元素
点击上方 "Python人工智能技术" 关注，星标或者置顶
22点24分准时推送，第一时间送达
后台回复“大礼包”，送你特别福利
编辑：乐乐 | 来自：pypypypy
上一篇：
正文
大家好，我是Pythn人工智能技术。
内置函数就是Python给你提供的，拿来直接用的函数，比如print.，input等。
截止到python版本3.6.2 ，python一共提供了68个内置函数，具体如下
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()
本文将这68个内置函数综合整理为12大类，正在学习Python基础的读者一定不要错过，建议收藏学习！
和数字相关 1. 数据类型
bool : 布尔型(True,False)
int : 整型(整数)
float : 浮点型(小数)
complex : 复数
2. 进制转换
bin() 将给的参数转换成二进制
otc() 将给的参数转换成八进制
hex() 将给的参数转换成十六进制
print(bin(10)) # 二进制:0b1010
print(hex(10)) # 十六进制:0xa
print(oct(10)) # 八进制:0o12
3. 数学运算
abs() 返回绝对值
divmode() 返回商和余数
round() 四舍五入
pow(a, b) 求a的b次幂, 如果有三个参数. 则求完次幂后对第三个数取余
sum() 求和
min() 求最小值
max() 求最大值
print(abs(-2)) # 绝对值:2
print(divmod(20,3)) # 求商和余数:(6,2)
print(round(4.50)) # 五舍六入:4
print(round(4.51)) #5
print(pow(10,2,3)) # 如果给了第三个参数. 表示最后取余:1
print(sum([1,2,3,4,5,6,7,8,9,10])) # 求和:55
print(min(5,3,9,12,7,2)) #求最小值:2
print(max(7,3,15,9,4,13)) #求最大值:15
和数据结构相关 1. 序列
（1）列表和元组
list() 将一个可迭代对象转换成列表
tuple() 将一个可迭代对象转换成元组
print(list((1,2,3,4,5,6))) #[1, 2, 3, 4, 5, 6]
print(tuple([1,2,3,4,5,6])) #(1, 2, 3, 4, 5, 6)
（2）相关内置函数
reversed() 将一个序列翻转, 返回翻转序列的迭代器
slice() 列表的切片
lst = "你好啊"
it = reversed(lst) # 不会改变原列表. 返回一个迭代器, 设计上的一个规则
print(list(it)) #['啊', '好', '你']
lst = [1, 2, 3, 4, 5, 6, 7]
print(lst[1:3:1]) #[2,3]
s = slice(1, 3, 1) # 切片用的
print(lst[s]) #[2,3]
（3）字符串
str() 将数据转化成字符串
print(str(123)+'456') #123456
format() 与具体数据相关, 用于计算各种小数, 精算等.
s = "hello world!"
print(format(s, "^20")) #剧中
print(format(s, "20")) #左对齐
print(format(s, "20")) #右对齐
# hello world!
# hello world!
# hello world!
print(format(3, 'b' )) # 二进制:11
print(format(97, 'c' )) # 转换成unicode字符:a
print(format(11, 'd' )) # ⼗进制:11
print(format(11, 'o' )) # 八进制:13
print(format(11, 'x' )) # 十六进制(⼩写字母):b
print(format(11, 'X' )) # 十六进制(大写字母):B
print(format(11, 'n' )) # 和d⼀样:11
print(format(11)) # 和d⼀样:11
print(format(123456789, 'e' )) # 科学计数法. 默认保留6位小数:1.234568e+08
print(format(123456789, '0.2e' )) # 科学计数法. 保留2位小数(小写):1.23e+08
print(format(123456789, '0.2E' )) # 科学计数法. 保留2位小数(大写):1.23E+08
print(format(1.23456789, 'f' )) # 小数点计数法. 保留6位小数:1.234568
print(format(1.23456789, '0.2f' )) # 小数点计数法. 保留2位小数:1.23
print(format(1.23456789, '0.10f')) # 小数点计数法. 保留10位小数:1.2345678900
print(format(1.23456789e+3, 'F')) # 小数点计数法. 很大的时候输出INF:1234.567890
bytes() 把字符串转化成bytes类型
bs = bytes("今天吃饭了吗", encoding="utf-8")
print(bs) #b'\xe4\xbb\x8a\xe5\xa4\xa9\xe5\x90\x83\xe9\xa5\xad\xe4\xba\x86\xe5\x90\x97'
bytearray() 返回一个新字节数组. 这个数字的元素是可变的, 并且每个元素的值得范围是[0,256)
ret = bytearray("alex" ,encoding ='utf-8')
print(ret[0]) #97
print(ret) #bytearray(b'alex')
ret[0] = 65 #把65的位置A赋值给ret[0]
print(str(ret)) #bytearray(b'Alex')
ord() 输入字符找带字符编码的位置
chr() 输入位置数字找出对应的字符
ascii() 是ascii码中的返回该值 不是就返回u
print(ord('a')) # 字母a在编码表中的码位:97
print(ord('中')) # '中'字在编码表中的位置:20013
print(chr(65)) # 已知码位,求字符是什么:A
print(chr(19999)) #丢
for i in range(65536): #打印出0到65535的字符
print(chr(i), end=" ")
print(ascii("@")) #'@'
repr() 返回一个对象的string形式
s = "今天\n吃了%s顿\t饭" % 3
print(s)#今天# 吃了3顿 饭
print(repr(s)) # 原样输出,过滤掉转义字符 \n \t \r 不管百分号%
#'今天\n吃了3顿\t饭'
2. 数据集合
字典：dict 创建一个字典
集合：set 创建一个集合
frozenset() 创建一个冻结的集合，冻结的集合不能进行添加和删除操作。
3. 相关内置函数
len() 返回一个对象中的元素的个数
sorted() 对可迭代对象进行排序操作 (lamda)
语法：sorted(Iterable, key=函数(排序规则), reverse=False)
Iterable: 可迭代对象
key: 排序规则(排序函数), 在sorted内部会将可迭代对象中的每一个元素传递给这个函数的参数. 根据函数运算的结果进行排序
reverse: 是否是倒叙. True: 倒叙, False: 正序
lst = [5,7,6,12,1,13,9,18,5]
lst.sort() # sort是list里面的一个方法
print(lst) #[1, 5, 5, 6, 7, 9, 12, 13, 18]
ll = sorted(lst) # 内置函数. 返回给你一个新列表 新列表是被排序的
print(ll) #[1, 5, 5, 6, 7, 9, 12, 13, 18]
l2 = sorted(lst,reverse=True) #倒序
print(l2) #[18, 13, 12, 9, 7, 6, 5, 5, 1]
#根据字符串长度给列表排序
lst = ['one', 'two', 'three', 'four', 'five', 'six']
def f(s):
return len(s)
l1 = sorted(lst, key=f, )
print(l1) #['one', 'two', 'six', 'four', 'five', 'three']
enumerate() 获取集合的枚举对象
lst = ['one','two','three','four','five']
for index, el in enumerate(lst,1): # 把索引和元素一起获取,索引默认从0开始. 可以更改
print(index)
print(el)
# 1
# one
# 2
# two
# 3
# three
# 4
# four
# 5
# five
all() 可迭代对象中全部是True, 结果才是True
any() 可迭代对象中有一个是True, 结果就是True
print(all([1,'hello',True,9])) #True
print(any([0,0,0,False,1,'good'])) #True
zip() 函数用于将可迭代的对象作为参数, 将对象中对应的元素打包成一个元组, 然后返回由这些元组组成的列表. 如果各个迭代器的元素个数不一致, 则返回列表长度与最短的对象相同
lst1 = [1, 2, 3, 4, 5, 6]
lst2 = ['醉乡民谣', '驴得水', '放牛班的春天', '美丽人生', '辩护人', '被嫌弃的松子的一生']
lst3 = ['美国', '中国', '法国', '意大利', '韩国', '日本']
print(zip(lst1, lst1, lst3)) #
for el in zip(lst1, lst2, lst3):
print(el)
# (1, '醉乡民谣', '美国')
# (2, '驴得水', '中国')
# (3, '放牛班的春天', '法国')
# (4, '美丽人生', '意大利')
# (5, '辩护人', '韩国')
# (6, '被嫌弃的松子的一生', '日本')
fiter() 过滤 (lamda)
语法：fiter(function. Iterable)
function: 用来筛选的函数. 在filter中会自动的把iterable中的元素传递给function. 然后根据function返回的True或者False来判断是否保留留此项数据 , Iterable: 可迭代对象
搜索公众号顶级架构师后台回复“面试”，送你一份惊喜礼包。
def func(i): # 判断奇数
return i % 2 == 1
lst = [1,2,3,4,5,6,7,8,9]
l1 = filter(func, lst) #l1是迭代器
print(l1) #
print(list(l1)) #[1, 3, 5, 7, 9]
map() 会根据提供的函数对指定序列列做映射(lamda)
语法 : map(function, iterable)
可以对可迭代对象中的每一个元素进行映射. 分别去执行 function
def f(i): return i
lst = [1,2,3,4,5,6,7,]
it = map(f, lst) # 把可迭代对象中的每一个元素传递给前面的函数进行处理. 处理的结果会返回成迭代器print(list(it)) #[1, 2, 3, 4, 5, 6, 7]
和作用域相关
locals() 返回当前作用域中的名字
globals() 返回全局作用域中的名字
def func():
a = 10
print(locals()) # 当前作用域中的内容
print(globals()) # 全局作用域中的内容
print("今天内容很多")
func()
# {'a': 10}
# {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__':
# _frozen_importlib_external.SourceFileLoader object at 0x0000026F8D566080,
# '__spec__': None, '__annotations__': {}, '__builtins__':
# (built-in), '__file__': 'D:/pycharm/练习/week03/new14.py', '__cached__': None,
# 'func': }
# 今天内容很多
和迭代器生成器相关
range() 生成数据
next() 迭代器向下执行一次, 内部实际使⽤用了__ next__()⽅方法返回迭代器的下一个项目
iter() 获取迭代器, 内部实际使用的是__ iter__()⽅方法来获取迭代器
for i in range(15,-1,-5):
print(i)
# 15
# 10
# 5
# 0
lst = [1,2,3,4,5]
it = iter(lst) # __iter__()获得迭代器
print(it.__next__()) #1
print(next(it)) #2 __next__()
print(next(it)) #3
print(next(it)) #4
字符串类型代码的执行
eval() 执行字符串类型的代码. 并返回最终结果
exec() 执行字符串类型的代码
compile() 将字符串类型的代码编码. 代码对象能够通过exec语句来执行或者eval()进行求值
s1 = input("请输入a+b:") #输入:8+9
print(eval(s1)) # 17 可以动态的执行代码. 代码必须有返回值
s2 = "for i in range(5): print(i)"
a = exec(s2) # exec 执行代码不返回任何内容
# 0
# 1
# 2
# 3
# 4
print(a) #None
# 动态执行代码
exec("""
def func():
print(" 我是周杰伦")
""" )
func() #我是周杰伦
code1 = "for i in range(3): print(i)"
com = compile(code1, "", mode="exec") # compile并不会执行你的代码.只是编译
exec(com) # 执行编译的结果
# 0
# 1
# 2
code2 = "5+6+7"
com2 = compile(code2, "", mode="eval")
print(eval(com2)) # 18
code3 = "name = input('请输入你的名字:')" #输入:hello
com3 = compile(code3, "", mode="single")
exec(com3)
print(name) #hello
输入输出
print() : 打印输出
input() : 获取用户输出的内容
print("hello", "world", sep="*", end="@") # sep:打印出的内容用什么连接,end:以什么为结尾
#hello*world@
内存相关
hash() : 获取到对象的哈希值(int, str, bool, tuple). hash算法:(1) 目的是唯一性 (2) dict 查找效率非常高, hash表.用空间换的时间 比较耗费内存
s = 'alex'print(hash(s)) #-168324845050430382lst = [1, 2, 3, 4, 5]print(hash(lst)) #报错,列表是不可哈希的 id() : 获取到对象的内存地址s = 'alex'print(id(s)) #2278345368944
文件操作相关
open() : 用于打开一个文件, 创建一个文件句柄
f = open('file',mode='r',encoding='utf-8')
f.read()
f.close()
模块相关
__ import__() : 用于动态加载类和函数
# 让用户输入一个要导入的模块
import os
name = input("请输入你要导入的模块:")
__import__(name) # 可以动态导入模块
帮 助
help() : 函数用于查看函数或模块用途的详细说明
print(help(str)) #查看字符串的用途
调用相关
callable() : 用于检查一个对象是否是可调用的. 如果返回True, object有可能调用失败, 但如果返回False. 那调用绝对不会成功
a = 10
print(callable(a)) #False 变量a不能被调用
def f():
print("hello")
print(callable(f)) # True 函数是可以被调用的
查看内置属性
dir() : 查看对象的内置属性, 访问的是对象中的__dir__()方法
print(dir(tuple)) #查看元组的方法
你还有什么想要补充的吗？
免责声明：本文内容来源于网络，文章版权归原作者所有，意在传播相关技术知识行业趋势，供大家学习交流，若涉及作品版权问题，请联系删除或授权事宜。
技术君个人微信
添加技术君个人微信即送一份惊喜大礼包
→ 技术资料共享
→ 技术交流社群
--END--
往日热文：
Python程序员深度学习的“四大名著”：
这四本书着实很不错！我们都知道现在机器学习、深度学习的资料太多了，面对海量资源，往往陷入到“无从下手”的困惑出境。而且并非所有的书籍都是优质资源，浪费大量的时间是得不偿失的。给大家推荐这几本好书并做简单介绍。
获得方式：
2.后台回复关键词：名著
Python 字典(Dictionary) get() 函数返回指定键的值，如果值不在字典中返回默认值。