一层内置函数 >>>>二层基础数据类型>>>>三层和数字相关14个
四层数据类型4个
1 布尔值 ***bool
只有True 和False，并且首字母必须是大写。
True: 1 int（非0）， 2 str(非'') 非空： True
False: 1 int（0）, 2 str('') 空： 0，“”，{}，[],（），set（）
2 数字 ***int
int 应用于 ：+ ，- ，* ，/ ，** ，% ，
例：int1 = 2 int2 = 12
int3 = int1 + int2
int3 = int1 - int2
int3 = int1 * int2
int3 = int1 / int2
3 浮点数（小数）***float
特点： 在取值中 会取值一定的位数
print(float (1.343))
a= 3.141592653123456789
print(a)
3.141592653123457
保留15，16位小数 且最后一位是四舍五入 不太理解
4 复数 complex
复数由 a + bj : 实部和虚部组成
实数 ：1
虚部：j -1的平方
3+ 4j < 5 +2j 错误 复数不能比较
四层 进制转换3个
print(bin(20))
print(oct(20))
print(hex(20))
0b10100
0o24
0x14
1 二进制 bin()
0b10100
2 八进制 oct()
0o24
3 十六进制 hex()
0x14
四层 数学运算 7个
1 计算绝对值 **abs()
l1 = [1,3,5,-2,-4,-6]
l2 = sorted(l1,key=abs)
print(l1)
print(l2)
2 返回取（商，余） **divmod()
ret = divmod(8,3)
ret1 =divmod (8,2)
print(ret)
print(ret1)
(2,2)
(4,0)
3 小数精确 **round(x,n)n为保留小数 具有四舍五入的应用
print(round(2.12133112,2))
2.12
print(round(2.12733112,2))
2.13
4 幂运算 **pow()
(x,n) x**n
(x,n,y) x**n\y 取商余数 和divmod 比较直接输出余数
>>> 分2种情况
print(pow(2,3))
print(pow(2,3,4))
print(pow(2,3,3))
8
0
2
1 pow(x,y) x**y
2pow(x,y,z) x**y%z
5 求和 sum(iterable,start) ***
iterable参数必须是一个可迭代数字集
start指出求和的初始值。start+iterable中的值为最终的和
print(sum([1,2,3]))
print(sum([1,2,3],2)) 2 为初始值
print(sum([1,2,3],[3,4])) 打印报错 因为([1,2,3],[3,4])不是可迭代对象
print(sum(range(100)))
6
8
4950
6 计算最小值min（）
>>>>分2种情况
字母比较也是一样的 a<b<c
1 min(iterable,key,default)
a min({1,2,3,4,-5})
print(min({1,2,3,4,-5}))
1-5
b min({},1) 不理解
print({},1) {}
c min({1,2,3,4,5},key=lambda n:abs(n))
print( min({1,2,3,4,5},key=lambda n:abs(n)))
1
print(min({1, 2, 3, 4, -5}, key=abs))
1
插入小知识 lambda 是匿名函数的关键字相当于def
固定格式 函数名 = lambda 参数（n）：返回值n**n(n的条件)
print(函数名（参数的值n）)
a和b 是一样的
a def add(x,y):
return x +y
print(add(1,2))
b add=lambda x,y: x+y
print(add(1,2))
2 min(*args,key,defult)
6 计算最大值max（）
字母比较也是一样的 a<b<c
>>>>分2种情况
1 max(iterable,key,defult)
dic = {'k1':10,'k2':100,'k3':30}
print(max(dic))
k3 因为此时比较的是ascii 码的大小
lis = [1,3,6,-22]
print(max(lis ,key=lambda k :k))
print(max(lis ,key=abs))
6
-22
2 max(*args,key,defult)
dic = {'k1': 10, 'k2': 100, 'k3': 30}
print(max(dic, key=lambda k: dic[k]))
k2
条件是dic[k]
值最大的键
一层内置函数 >>>>二层基础数据类型>>>>三层和数据结构相关24个
四层序列13个>>>列表和元祖2个
1 列表 ***list
增加
1append
增加到最后一个列表
li = [1, 3, 4, 'wang', ]
li.append('wangyan')
print(li)
[1, 3, 4, 'wang', 'wangyan']
2insert
插入， xx.insert(3)表示列表里第2位插入，此处是内容)
li = [1, 3, 4, 'wang', ]
li.insert(3, 'wangyan')
print(li)
[1, 3, 4, 'wang',‘wangyan’]
li = [1, 3, 4, 'wang', ]
3 # extend 迭代的添加 添加的元素分开了叠加，也就是extend后如果是字符串（‘ABC’）后边则是'A', 'B', 'C',如果后边是[]
li = [1, 3, 4, 'wang', ]
li.extend([1, 2, 3, 'www'])
print(li)
[1, 3, 4, 'wang', 1, 2, 3, 'www']
li.extend([1, 2, 3, 'www'])
则变成[1, 2, 3, 'www']
li = [1, 3, 4, 'wang', ]
li.extend('luodan')
print(li)
[1, 3, 4, 'wang', 'l', 'u', 'o', 'd', 'a', 'n']
二删除 #
1pop
按照索引去删除，有返回值，
此时注意压栈思想
和insert用法类似
。pop(索引对应的值，数字是多少就是列表的数字的N - 1)删除那个
li = [1, 3, 4, 'wang', ]
li.pop(3)
print(li)[1, 3, 4]
li = [1, 3, 4, 'wang',]
li.pop()
print(li)
[1, 3, 4 ] 2remove 按照元素去删除说白了就是删除名字就行
例如1'wang'
li = [1, 3, 4, 'wang', ]
li.remove('wang')
print(li)[1, 3, 4]
3clear
列空列表结果[]
li = [1, 3, 4, 'wang', ]
li.clear()
print(li)
4del 用法和正常的键盘删除基本几样
区别.pop.remove.clear
直接del[] 删除列里面切片 取值在删除
li = [1, 3, 4, 'wang', 'True', 33, 'yy']
del li[3:6:2]
print(li)
[1, 3, 4, 'True', 'yy']
三改
先切片 在删除 在改正
1
字符串的
li = [1, 3, 4, 'wang', 'True', 33, 'yy']
li[1:4] = '宝宝'
print(li)
[1, '宝', '宝', 'True', 33, 'yy']
切片后先删除
4 ‘wang’ 变为2位 ‘宝’宝 ‘宝’ 并且迭加
2，后边的是列表[]
取片删除后进行在删除的位置合并
li = [1, 3, 4, 'wang', 'True', 33, 'yy']
li[1:3] = ['ad', 'efe', 'eded', 'wian']
print(li)
[1, 'ad', 'efe', 'eded', 'wian', 'wang', 'True', 33, 'yy']
四查 切片 查看
li = [1, 3, 4, 'wang', 'True', 33, 'yy']
print(li[3:6])
['wang', 'True', 33]
li = [1, 3, 4, 'wang', 'True', 33, 'yy']
del li
print(li)
结果为空的
打印长度
li = [1, 'dfs', 23, 87]
print(len(li))
2 元祖*** tuple
元组被称为只读列表，即数据可以被查询，但不能被修改，所以，字符串的切片操作同样适用于元组。
例：（1，2，3）（"a","b","c"）
一层内置函数 >>>>二层基础数据类型>>>>三层和数据结构相关24个
四层序列13个>>>相关内置函数2个
1 反转 **reversed() 迭代器的
recersed() 迭代器 1 新生成一个列表不改变原列表 2 有返回值还是一个迭代器
2还有个是就是强转的list(ret)
reserse() 反转 1 不会生成一个列表改变原来的列表 2 返回值是Npne
l = [1, 3, 5, 4, 2, 7]
ret = reversed(l)
print(ret)
print(list(ret))
<list_reverseiterator object at 0x02B6A370> 迭代器
[7, 2, 4, 5, 3, 1]
l = [1, 3, 5, 4, 2, 7]
l.reverse()
print(l)
[7, 2, 4, 5, 3, 1]
拓展 sort（） 是从小到大排序
sort() reversed()
li = [1,3,5,6,4,2]
li.sort()
print(li)
li.reverse()
print(li)
[2, 4, 6, 5, 3, 1] 列表反转
li = [2, 4, 6, 5, 3, 1]
li .sort(reverse = True)
print(li)
[6, 5, 4, 3, 2, 1] 列表倒序
2 slice 切片 转成元祖
l = (1,2,23,213,5612,342,43)
sli = slice(1,5,2)
print(l[sli]）
(2, 213)
一层内置函数 >>>>二层基础数据类型>>>>三层和数据结构相关24个
四层序列13个>>>字符串9个
1 字符串***str
a 带引号的都是字符串 三引号 可以跨行
name = '郭鹏达'name2 = "王岩"
例： msg = '''
字符串
''
b 字符串拼接。 字符串加法和乘法。 S1 = ‘abc’ s2 = ‘123’ print(s1 + s2) ‘abc123’
2 .format()
大括号内是改变输出前的内容 大括号内空 和。format() 一一对应
li = ['alex','eric','rain']
# # 利用下划线将列表的每一个元素拼接成字符串"alex_eric_rain"
info = "{}_{}_{}".format(li[0],li[1],li[2])
print(info)
#第一种： 大括号内是改变输出前的内容 大括号内空 和。format() 一一对应
ret18 = 'name :{},sex:{},hig:{}'.format("王岩","男",174)
print(ret18)
name :王岩,sex:男,hig:174
3 字节 *** bytes
1 acsic码 基本不用 不同编码之间互用会产生乱码，
2 unicode A 字母 4个字节 00000000 00000000 00100100 01000000
中 文 4个字节 00000000 00000000 00100100 00000000
3utf-8 中文 A 字母 1个字节 00000001
欧 洲 2个字节 00000000 00000000 00100100 00000000
亚洲 中文 3个字节 00000000 00000000 00000000 00100100 0000000
4 gbk A 字母 2个字节 00000000 00001000
中文 亚洲 2个字节 00100100 00000000
bytes ：表现形式： s = ‘Q’ b1 = s.encode ('utf-8') print (b1) b1 = b'Q'
内部存储是（utf-8 ，gbk ，gb232等）
s1 = '晓梅' b11 = s1.encode('utf-8')
表现形式： s = b'\xe6\x99\x93\xe6\xa2\x85' （utf-8,gbk，gb2312.....）010101
0000 1000 0000 0000 0000 0001 0000 1001 0000 0000 0000 0001
注意：在utf-8 的情况下b 后边有6个 （e6 99 等） 说名 晓梅 是中文 utf-8 是两个字6个字节
4 bytearray
5 memoryview
6 ord 字符按照unicode转数字
7 chr 数字按照unicode转字符
8 ascii 只要是ascii码中的内容，就打印出来，不是就转换成\u
9 **rep 用于%r格式化输出
区别就是 输出什么就是什么 注意引号
print('name,%r'%'金老板')
name,'金老板'
print('name,%s'%'金老板')
name ，金老板
一层内置函数 >>>>二层基础数据类型>>>>三层和数据结构相关24个
四层序列13个>>>数据集合3个
1 **字典
字典相关的代码
1、字典的特性：a 字典的无序性； b 数据关联性强 C 键键值对 唯一一个映射数据类型
字典的键必修二是可哈希的（不可变的数据类型：,字符串，数字的，布尔值，元祖）
并且是唯一的
不可哈希的（可变的数据：列表，字典，set 集合）
例子 ,
dic = {'name':'aima','age':43}
2 增加
a、 增加 dic ['k'] = v 直接可覆盖 dic['name'] = 'wangyan'
b 、dic.sedefault ('k') 有键值对不做任何改变，没有键值对才添加
dic = {'name':'aima','age':43,'sex':'men'}
dic['name'] = 'wangyan'
print(dic)
dic.setdefault('goodmen','wangyan')
print(dic)
有键值 不做任何反应还是原来的字典 ，没有的就添加新的
3 、删除
a .pop() 删除一个键 就删除一个组
dic.pop('name')
print(dic)
压栈思想 .pop() 默认返回最后一个值
li=[]
l = [1,2,3,4,5]
l1 = l.pop()
print(l1)
5
b 、del 直接删除k 键
del dic['age']
print(dic)
dic = {'name':'aima','age':43,'sex':'men'}
4 改
a 和第一种增加一样 覆盖
dic['name'] = 'luodan'
print(dic)
b .update()
dic1 = {'boy':'wangmutian'}
dic .update(dic1)
print(dic)
{'name': 'aima', 'age': 43, 'sex': 'men', 'boy': 'wangmutian'}
5 查 直接打印k 就能得到V的值 但是如果没有k键 就会报错 提示None
a 直接打印k
for key in dic:
print(key)
name
age
sex
b for i in dic.keys():
for i in dic.keys():
print(i)
for i in iterms
打印出来的是键值对
6重要的格式 一定要记住!!!!!!!!! 低级尽量不用
dic = {'name':'aima','age':43,'sex':'men'}
for key,value in dic.items():
print(key,value)
name aima
age 43
sex men
for key in dic:
print(key,dic[key])
dic = {'name':'aima','age':43,'sex':'men'}
7列表变成字典 如果后边有1 ，就是值 否则[]里面都是k 值
分别给键对值
dic = dict.fromkeys(['22',(1,2),'wangyan','zhang'],'kk')
print(dic
{'22': 'kk', (1, 2): 'kk', 'wangyan': 'kk', 'zhang': 'kk'}
固定格式 一定的是
dic = dict.fromkeys() 针对于多个键 对应一个值的方法 ）
---------------
2 **集合
集合是无序的 元素是可哈希的（不可变的数据类型：int str tuple bool ）
但是集合本身是不可哈希的（可变的数据类型） 所以做不了字典的键
主要是用于去重
a 每次打印都是无序的 都不一样的
set = {1,'wag',4 ,'Tru',3}
print(set)
set = {1,'wag',4 ,'Tru',3，3}
print(set)
直接打印去重
b 集合的增删改查
增加 。add() .update
删 。pop
改
查 for i in set1
c 集合的交集 并集 反交集
交集&（and） 取公共部分
差集(-) 取set1 交集以外的set1
并集 取所有的 但是重复部分取一次 用|表示
set(lis)&set1(lis2)
set(lis)-et1(lis2)
set1 ={1,2,3,4}
set2 ={2,3,4,5,6,7,8}
交集
print(set1&set2)
{2, 3, 4}
去重 并集 | 表示
print(set1|set2)
{1, 2, 3, 4, 5, 6, 7, 8}
差集
print(set1-set2)
{1}
3 **冷冻集合 暂无资料
set1^set 非集合
一层内置函数 >>>>二层基础数据类型>>>>三层和数据结构相关24个
四层序列13个>>>相关内置函数8个
1 **len() 长度 字符串 列表 包含空
lis = [1,4,3,2]
print(len(lis))
s = 'wangyanluodanwangmutian '
s1 = 'wangyanluodanwangmutian'
print(len(s))
print(len(s1))
4
25
23
2 **枚举，对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），
enumerate将其组成一个索引序列，利用它可以同时获得索引和值。
就是打印列表的索引和值
li = ['alex','银角','女神','egon','太白']
for i in enumerate(li):
print(i)
(0, 'alex')
(1, '银角')
(2, '女神')
(3, 'egon')
(4, '太白')
for index,name in enumerate(li,1):
print(index,name)
1 alex
2 银角
3 女神
4 egon
5 太白
3 all 判断是否有bool值为False 的值
4 any 判断是否有bool值为True 的值
5 **zip 返回一个迭代器必须有个list 转化 拉链 以最短的为基准 将两个列表整合成两个列表 分别取值
print( list(zip([1,2,3,4,5],[2,3,4])))
[(1, 2), (2, 3), (3, 4)]
6 filter 过滤 通过函数的定义过滤
# 题目 用filter过滤方法 处理里面的偶数
# 三元运算 注意了没有 标点 True if n %2 ==0 else False
# li =[1,2,3,4,5,6,7,8]
# def func(n):
# if n %2==0:
# return n
# print(list(filter(func,li)))
# ret = filter(lambda n:True if n %2 ==0 else False,li)
# print(list(ret))
# for i in ret :
# print(i)
def small(x):
if x < 10:
return True
ret = filter(small,[1,4,3,22,55,33])
print(list(ret))
[1,4,3]
def small(x):
return x % 2 == 1
ret = filter(small,[1,4,3,22,55,33])
print(list(ret))
7 map 返回一个新的列表
map函数应用于每一个可迭代的项，返回的是一个结果list。如果有其他的可迭代参数传进来，
map函数则会把每一个参数都以相应的处理函数进行迭代处理。
map()函数接收两个参数，一个是函数，一个是序列，
map将传入的函数依次作用到序列的每个元素，并把结果作为新的list返回。
1 题目 名字前面加hr_.
第一种
li = ['wangyan','luodan','wangyanmutian']
def nam(n):
return 'hr_'+n
print(list(map(nam,li)))
['hr_wangyan', 'hr_luodan', 'hr_wangyanmutian']
for i in ret:
# print(i)
hr_wangyan
hr_luodan
hr_wangyanmutian
第二种
print(list(map(lambda n: 'hr_'+n,li)))
要是不要列表直接for 循环
map (函数，列表)
L = [1,2,3,4,]
def pow2(x):
return x*x
print(list(map(pow2,L)))
8sorted
l1 = [1,3,5,-2,-4,-6]
l2 = sorted(l1,key=abs)
print(l2)
一层内置函数 >>>>二层作用域相关
1 global 改变全局的
n = 1
def func():
global n
n = n +1
print(n)
print(n)
func()
print(n)
1 ，2，2
2 local 的内容会根据执行位置来决定作用域中的内容 如果在全局执行 和globals() 一样
3 nonlocl 修改最近拥有该变量的外层函数 不影响全局
n = 1
def func1():
n = 2
def func2():
nonlocal n
n+=1
print(n)
func2()
func1()
print(n)
答案 是 3 引用上级的, 1 全局的
一层内置函数>>>>二层迭代器/生成器相关(3)
判断是不是可迭代对象 print('__iter__'in dir(对象))
print(isinsstance(对象)，iterable )
迭代器的含义 含有 .__iter__() 的 且比可迭代对象多一个next 方法
方 法 next iter 两个个用法
生成器的含义本质 生成器的本质就是迭代器
方法
1 iter 可迭代对象的一个方法
2 next 迭代器的比可迭代对象多个方法
3 ***range
yield py关键字 genertaor 生成器
含有yield的话就变成了生成器
条件有二
1是有yield
2函数的调用
3 print(g) 是 F 或者T 是不是生成器？？？
4 打印t(g._next_())
打出来就是yield 后面
例子
打印出100件衣服 标上序号
def cloth():
for i in range (100):
yield ('衣服%s'%i)
g = cloth()
1 一件一件的打印
print(g.__next__())
2打印前50件
for i in range(50):
print(g.__next__())
3全打出了来
for i in g:
print(i)
一层内置函数>>>>二层迭代器/生成器相关(3)>>>>其他>>>>字符串类型代码的实行3个
注意这个三个尽量不要用 或者请示领导再用
1 **eval 执行 有返回值的 可以拿到结果的 针对字符串的 可以直接运算出结果来 记住针对字符串的
2 **exec 用于流程性代码的执行
print(exec('1+3-3-1'))
print(eval('1+3-3-1'))
None
0
3 compile 编译
一层内置函数>>>>二层迭代器/生成器相关(3)>>>>其他>>>>输入输出2个
1 ***input 用户交互 name = input ('请输入内容') 必须是str
2 ***print 打印出内容 默认是sep = ','
print(1,2,3,4,5 ,sep = '*')
1*2*3*4*5
一层内置函数>>>>二层迭代器/生成器相关(3)>>>>其他>>>>内存相关2个
id hashi函数是一个算法 结果是一个数字 每次数字不一样的
存储和查找 只要不可变就是
1 ***hash 可哈希（不可变） 不可哈希（可变）
2 id 内存地址
print(id('wangyan'))
print(hash('wangyan'))
每次打印的数字都是u不一样的
一层内置函数>>>>二层迭代器/生成器相关(3)>>>>其他>>>>文件操作相关(1)
1 **open
f = open('文件名',encoding = 'utf-8')
打开模式 有 默认 r 读模式
w 写模式 清空
a 不可读 追写文件的最后 没有则创建
b 以字节的形式打开
一层内置函数>>>>二层迭代器/生成器相关(3)>>>>其他>>>>模块相关(1）
1 ***import
import os
os.remove()
os.rename('old','new')
import time
start = time.time()
end = time.time()
一层内置函数>>>>二层迭代器/生成器相关(3)>>>>其他>>>>查看(1）
在pyxm 左键单击
help 包含所有的用法
in dir 只包含方法名字
1 help
a 直接help 退出 q
b help(数据类型) 制定查看某对象的帮助信息
一层内置函数>>>>二层迭代器/生成器相关(3)>>>>其他>>>>调用相关(1）
1 callable 是否可以调用 返回布尔值
a = [1,3,4,6]
print(callable(a))
print(callable(print()))
print(callable('abc'))
全是False
2 **dir 1 查看内置属性 dir(__builthin__)
2 查看某对象的属性及方法 dir()
