python第一阶段总结
三:今日主要的内容
基本数据类型(int,bool,str)
1.基本数据类型
int 整数
str 字符串,一般不存放大量的数据
bool 布尔值,用来判断True,Fales
list 列表,用来存放大量数据,[]表示,里面可以装各种数据类型
tuple 元组,只读列表. ()表示
dict 字典.{key:value}
set 集合,不重复
2. int类型
bit_length() 返回一个数的二进制长度
3. bool类型
布尔只有两个值,True,False,一般是没有什么操作的
类型转换的问题:
想把xx转换成yy, yy(xx)
可以表示False的内容:0, "", [], (), {}, None
所有的空都是Flase.所有的非空是True
4.str类型
由',",''',"""阔起来的内容就是字符串
字符串是不可变得数据类型,不论你执行任何操作,源字符串是不会改变的,每次操作都会返回新字符
1. 索引和切片
索引从0开始,使用[下标]可以获取每个字符,还可以倒着数
切片:[起始位置:结束位置:步长]
1.顾头不顾尾
2.默认从左到右取值
3.当步长为负可以从右往左取值
2.字符串相关操作
1.upper() 转换成大写
2.strip() 去掉空格
3.replace(old,new) 把xxx替换成xxx
4.split() 切割,返回列表,用多长的刀,就要损失掉多少
5.startswith() 判断是否以xxx开头
6.find(),count(),index()
count() 作用：用于检索指定字符串在另一个字符串中出现的次数，如果检索的字符串不存在则返回0，否则返回出现的次数
find()作用：检索是否包含指定的字符串，如果检索的字符串不存在则返回-1，否则返回首次出现该字符串时的索引
index()作用：和find方法类似，也用于检索是否包含指定的字符串，使用index方法，当指定的字符串不存在时会抛异常
7.len() 字符串长度.python的内置函数
3. for循环
for 变量 in 可迭代对象:
循环体,也存在break和continue
else:
当循环结束的时候回执行
四:今日主要内容
1.什么是列表
列表是一个可变的数据类型
列表由[]来表示, 每一项元素使用都要隔开,列表什么都能装,能装对象的对象.
列表可以装大量的数据
2.列表的索引和切片
列表和字符串一样,也有索引和切片,只不过切出来的内容是列表
索引的下标从0开始
[起始位置:结束位置:步长]
3.列表的增删改查
1.增加
append() 追加
insert(index, 元素) 在index位置添加元素
extend() 迭代添加
2.删除
pop(index) 按照位置删除元素
remove(元素) 直接删除元素
del 切片
clear() 清空列表
3.修改
索引修改
切片修改
4.查询
for el in list:
el
5.从用操作
1. sort() 排序 reverse=True降序
2. reverse() 翻转
3. len() 求长度
4.列表的嵌套
降维, 一层一层看
5.元组
只读列表,只能看啥也不能干
使用()表示元组
如果元组中只有一个元素(元素,)
空元组: tuple()
元组是一个可迭代对象,可以使用for循环
6.range
range(n) 从0到n-1
range(m,n) 从m到n-1
range(m,n,1) 从m到n-1 每q个取1个
综上就是切片
7.使用range和for循环来获取列表中的索引
for i in range(len(列表)):
i 索引
列表[i] 元素
五 今日内容: 字典
1. 字典 dict 用{}来表示, 键值对数据 {key:value}
键: 具有唯一性 必须是可哈希的,不可变的数据类型就可以当做字典中的键,列表不能当做键
值:没有任何限制
2. 增删改查
增:
dic[key] = value 当这个键没在字典中就是添加
dic.setdefault(key,value) 如果这个键在字典中存在就不进行添加,否则就添加
可以通过key查询,没有个key返回None
删:pop del clear
pop(key) 有返回值,返回的是被删除的value
del dic[key]
popitem() 随机删除
clear() 清空字典
改:
dic[key] = value 当这个键在字典中存在时,强行修改这个键对应的值
dic.update(dict) 不常用
查:
dic.get(key)
print(dic[key])
for循环 拿到所有的key
setdefault(key)
for循环,for循环默认是获取字典中的键
dic.get() 没有返回none,可以指定返回内容
dic.setdefault() 没有返回none,根据key查询出value
3.字典独有的操作方法:
dic.keys() 高仿列表
dic.values() 高仿列表
dic.items() 高仿列表,每个又是元组
keys 获取到字典中所有的键 然后存在一个高仿的列表中
values 获取到字典中所有的值 然后存在一个高仿的列表中
items 获取到所有的键值对, 以元组的形式存在一个高仿的列表中
解构(解包)
a,b =[1,2] 将后面解构打开按位置赋值给变量,解构支持字符串,列表,元组
a,b = 1, 2
a,b = (1, 2)
4. 字典的嵌套:
dic ={'name':'汪峰',
'age':43,
'wife':{
'name':'国际章',
'age':39,
'salary':10000
},
'baby':[
{'name':'熊大', 'age':18},
{'name':'熊二', 'age':15}
]
}
dic['baby'][0]['age'] = 18
print(dic)
今日内容:
== 比较 比较的是两边的值
is 比较内存地址 比较的是内存地址,id()函数获取内存地址
小数据池:
数字小数据池的范围: -5 ~ 256
字符串:
字符串中不能包含特殊字符: + - * / @ 特殊字符
字符串中如果有特殊字符他们的内存地址就不一样
字符串中单个字符*20以内包括20他们的内存地址一样,单个字符*21以上内存地址不一致
注意:pychram的坑,一个py文件中所有相同的字符串,一般都是使用一样的内存地址
编码解码
ASCII码 python2的默认编码
不支持 中文
支持 英文 数字 符号
8位 一个字节
gbk码 国标:
支持 中文,英文,数字,符号
英文 2个字节,16位
中文 2个字节,16位
unicode 万国码
支持 中文,英文,数字,符号
英文 32位
中文 32位
不支持传输和存储
utf-8 长度可变的万国码
支持 中文 英文 数字 符号
最少用8位
英文 8位
中文 24位
python3的默认编码方式
utf-16 长度可变的万国码 最少用16位
python3中 程序运行阶段 使用的是unicode,(在内存中) 显示所有内容
bytes类型
传输和存储都是使用bytes
pychram存储的时候默认是使用utf-8
编码和解码
encode(编码方式) 拿到明文编码后对应的字节
decode(解码方式) 将编码后的字节解码成对应的明文
注意:用什么编码就用什么解码
内容回顾:
1. is和==的区别
is 比较的是内存地址 (判断两个变量指向的是否是一个对象)
== 比较的是值 (判断的是值)
id()
python中存在一个小数据池的概念(缓存)
python中两个数据类型存在小数据池:
int: -5 ~ 256
str:在python中一般的字符串都是会被缓存的,为了节约内存空间
注意:上缓存的目的快和节约内存空间
2.再谈编码
1.ASCII,英文,数字,一些特殊字符 8bit 1byte
2.GBK,国标码,汉字, 16bit 2byte 必须兼容ASCII
3. UNICODE,万国码,32bit 4byte,兼容ASCII
4.UTF-8 可变长度的万国码
英文 8bit 1byte
欧洲 16bit 2byte
汉字 24bit 3byte
python2的版本 默认使用ASCII
python3的版本 内存默认使unicode.在计算的时候会非常方便
unicode在网络传输和数据存储的时候hold不住,要换utf-8,国内的换gbk
注意:内存中用unicode,网络传输和数据存储用utf-8(90%)
编码(encode): unicode变成你需要的编码
编码之后的内容是字节(bytes类型)
解码(decode):把目标bytes转换成字符串
集合
定义:
set集合是python的一个基本数据类型,一般不是很常用,set中的元素
是不重复的,无序的,里面的元素必输是可hash的不可变得(int,str,tuple,bool),我们可以这样来记,
set就是dict类型的数据但是不保存value,只保存key,set也用{}表示
集合中的元素必须是可哈希的,不重复的,可以去重,哈希hash算法
今日内容:
对之前的知识点进行补充
1.str中的join方法,把列表转换成字符串
2.列表和字典在循环的时候不能直接删除,需要把删除的内容记录在新的列表中,然后循环新列表,删除老字典或老列表
3.fromkeys()
1.返回新字典,对原字典没有影响
set集合:
特点:
无序,不重复,元素必须可哈希(不可变)
作用:
去重复
本身是可变的数据类型,有增删改查操作
深浅拷贝
1.赋值,没有创建新对象,公用同一个对象
2.浅拷贝,拷贝第一层内容,[:]或copy()
3.深拷贝,拷贝所有内容,包括内部的所有
上次内容回顾:
1.join() 把一个列表转换成字符串
split() 切割,把字符串变成列表
删除问题:
list 和 dict
list删除 在循环的时候不能直接删除的
dict在循环的时候不要改变大小
需要把要删除的内容保存在一个新列表中,循环这个新列表删除老列表
fromkeys(a, b)把a中的每一个元素获取到和b装成一个新字典返回
1.文件操作的函数
open(文件名(路径), mode="?" , encoding="字符集")
2.模式 r只读, w只写, a追加写, r+读写, w+写读, a+追加写读, rb, wb, ab, r+b, w+b, a+b,
常用模式 r, w, a, r+, b处理非文本文件
r+ 深坑,不论你读取多少文件,写入的时候写在最后
3.常用操作
1.光标(seek)
seek(0) 开头
seek(0, 2) 结尾
2. tell() 光标的位置
3. truncate 截断文件
4.read write readline readlines
4.修改文件
1.引入os模块
2.打开目标文件,r
3.打开文件副本, w
4.从r中读取内容进行修改,写入到副本中
5.删除源文件
6.重命名副本
import os
with open("修改的目标文件", mode="r",encoding="utf-8") as f1,\
open("修改的目标文件_副本", mode="w",encoding="utf-8") as f2:
for line in f1:
"""修改操作"""
s = line.XXXXXX
f2.write(s)
os.remove("修改的目标文件")
os.rename("修改的目标文件_副本", "修改的目标文件")
10.1号
今日内容: 函数
1.函数
函数是对功能或动作的封装
语法:
def 函数名(形参列表):
函数体(代码块,可能会有return)
调用:
函数名(实参列表) 注意:形参和实参必须对的上
形参:在函数声明的位置是形参(变量)
实参:在函数调用的时候给函数的形参传递的信息(值)
传参:把实参的值交给形参的过程
注意:函数的声明并不会触发函数的执行
2. 返回值
return:在函数执行的时候,如果遇到return,直接返回
1.如果函数什么都不写,不写return,没有返回值,得到的是None
2.在函数中间或末尾写return,没有值,返回的是None
3.在函数中写return 值,返回一个值
4.在函数中和可以返回多个返回值,return 值1, 值2, 值3......., 接收的是元组(不可变,安全)
3.参数
函数执行的时候给函数传递信息.
形参:函数声明的位置的变量.(函数声明的位置)
实参:函数调用的时候给的具体的值.(函数调用的位置)
传参:把实参的值交给形参的过程
1. 实参:
1. 位置参数,按照形参的参数位置,给形参传值(记住位置)
2. 关键字参数,按照形参的名字给形参传值(记住名字)
3. 混合参数,即用位置参数,也用关键字参数(先位置在关键字)
2. 形参:
1. 位置参数
2. 默认值参数 (默认值如果是可变的数据类型,每次使用的时候都是同一个,默认值跟消亡没有关系)
3. 动态传参:
*args: 位置参数动态传参
**kwargs:关键字参数动态传参
顺序:位置,*args,默认值,**kwargs
def func(*args, **kwargs): //无敌函数 什么都能传
pass
形参的位置*, **:聚合
实参的位置*, **:打散(传参)
*和** 在函数声明的位置,表示聚合
*和** 在函数调用的位置,表示打散(传参)
4. 聚合和打散
def func(*args): # 形参:聚合, 位置参数
print(args)
lst = ["鸡蛋", "煎饼果子", "猪蹄", "滋滋冒油"]
func(*lst) # 实参: 打散,把list, tuple,set,str进行迭代打散
def func(**kwargs): # 形参:聚合, 聚合成关键字参数
print(food)
dic= {"name":"alex", "age":"18"}
func(**dic) # 实参: 打散成关键字参数
5. 命名空间
1.内置名称空间
2.全局名称空间
3.局部名称空间
加载的顺序,先加载内置,然后全局,最后函数调用的时候再加载局部
取值顺序:先局部,在全局,最后找内置
作用域:
1.全局作用域: 内置+全局
2.局部作用域: 局部(函数内部)
globals()查看全局中的内容
locals()查看当前作用域的内容
6.函数的嵌套
函数可以互相的嵌套
7.global和nonclocal关键字
global:在函数内部(局部)调用全局中的内容
nonlocal:在内层函数中寻找外层函数中离他最近的那个变量(一圈一圈往外找)
10.2
今日内容:
1.函数名的应用(第一类对象)
函数名的命名规则和变量是一样的;
函数名就是一个变量;
可以互相赋值;
函数名可以作为列表中元素进行存储;
函数名可以作为参数传递给函数;
可以作为返回值进行返回;
函数名无法进行计算;
2.闭包
闭包:在内层函数中访问外层函数的变量
闭包的好处:
1.可以保护你的变量不受外界影响
2.可以让变量常驻内存
写法:
def outer():
a = 10 # 很耗时
def inner():
print(a)
return inner
ret = outer()
ret()
ret()
查看函数是不是闭包 __closuer__
3.迭代器
__iter__() 可迭代对象,获取迭代器
__next__() + __iter__() 迭代器
使用dir() 查看xxx类型的数据可以执行那些方法
用来遍历列表,字符串,元组...可迭代对象
可迭代对象:iterable,里面有__iter__()可以获取迭代器,没有__next__()
迭代器: iterator,里面有__iter__()可以获取迭代器,还有__next__()
迭代器的特点:
1.只能向前,只能下一个下一个
2.惰性机制
3.省内存(生成器)
for循环的内部就是迭代器:
1.首先获取到迭代器
2.使用while循环获取所有数据
3.it.__next__()来获取数据
4.处理异常 try:xxx except StopIteration:
lst = ['赵本山', '赵四', '刘能', '英子']
s = lst.__iter__() # 获取迭代器
while 1:
try: # 尝试执行
print(s.__next__()) # 从迭代器中获取数据
except StopIteration: # 处理错误
break
Iterable:可迭代的
Iterator:迭代器
10.4
1.生成器
生成器的本质就是迭代器
获取生成器的方法:生成器函数,生成器表达式,通过数据转化
生成器的特点和迭代器一样,取值方式和迭代器一样 __next__()
生成器一般由生成器函数或者生成器表达式来创建
其实就是手写的迭代器
2.生成器函数
和普通函数没有区别,里面有yield的函数就是生成器函数
生成器函数在执行的时候,默认不会执行函数体,而是返回生成器
通过生成器的__next__()分段执行这个函数
send()给上一个yield传值,不能在开头(没有上一个yield),最后一个yield也不可以用send()
总结:
在函数内部有yield
这个时候我们执行这个函数.这个函数是获取生成器
__next__()可以触发生成器的执行,执行到下一个yield.
如果执行完最后一个yield之后,继续__next__(),程序会报错StopIteration
3.推导式
1.列表推导式 [结果 for循环 判断] 一次性拿值
2.字典推导式 {k:v for循环 判断}
3. 集合推导式 {k for循环 判断}
没有元组推导式
三元运算符: a if a>b else b 如果a大于b 返回a,否则b
4.生成器表达式
(结果 for循环 判断) 一个一个拿值
特点:
1.惰性机制
2.只能向前
3.节省内存(鸡)
10.5
内置函数(68个)
1.基础数据类型相关
1.1和数字相关
数据类型: bool int float complex-复数
i**2 = -1 # i叫虚数
复数 = 实数 + 虚数 3+2i
进制转换:bin-二进制ob oct-八进制0c hex-十六进制0x
数学运算:abs-绝对值 divmod-计算商和余数 round-四舍五入 pow-求次幂,第三个参数计算余数 sum-求和
min-求最小值 max-求最大值
1.2和数据结构相关
1.2.1 序列
1.2.1.1 列表和元组
1.2.1.2 相关内置函数:reversed-翻转,返回迭代器 slice-切片
1.2.1.3 字符串:
str-字符串
format-格式化
bytes-字节
bytearry memoryview-查看bytes在内存中的情况
ord-输入字符找带字符编码的位置
chr-输入位置数字找对应的字符
ascii-是ascii码中的返回该值 不是就返回\u...
repr-原样输出字符串
1.2.2 数据集合
eval 动态执行一个代码段,侧重点在返回上; 还原字典,列表
exec 执行
compile 编译
lambda 匿名函数
lambda 参数:返回值
函数名统一都叫lambda
sorted() 排序函数
排序函数
sorted(iterable, key, reverse)
key:排序规则
运行流程:把可迭代对象中的每一个元素交给后面的key函数来执行,
得到一个数字(权重),通过这个数字进行排序
filter()过滤函数
filter(function, iterable)
把可迭代对象中的每一个元素交给前面的函数进行筛选.函数返回True或Flase
map()函数
map(function,iterable)
把可迭代对象中的数据交给前面的函数进行执行,返回值就是map的处理结果
递归:
函数自己调用自己
最大深度:1000,到不1000就停了
import sys
sys.setrecursionlimit() 改深度
二分法:
核心:掐头去尾取中间,一次砍一半
两种算法:常规循环;递归循环;
# 时间复杂度最低,空间复杂度最低
lst1 = [5, 6, 7, 8]
lst2 = [0, 0, 0, 0, 0, 1, 1, 1, 1]
for le in lst1:
lst2[el] = 1
lst2[4] == 1 #0(1)
浙公网安备 33010602011771号