标签：mktime 拼音 第三方模块 coff 文件内容 乱码 逻辑运算符 转化 basename
python2和python3的区别
python2的源码不统一,出现重复代码
python3统一了源码,不会出现重复代码
python是什么编程语言
python是一款解释性语言,具有开发效率高的优点,缺点是运行速度慢
cpython官方
jython java编写
ironpython .net
pypy python 可以提高运行速度
变量的命名规则
变量名由字母,数字_下划线组成
不能使用python的关键字
不能以数字开头
不能使用拼音和汉字
注意区分大小写
变量名要具有可描述性,可辨识性
驼峰式命名(推荐下划线的方式)
python中没有常量的概念,以变量名全部大写来识别
# 代表单行注释
‘‘‘ ‘‘‘或者""" """代表多行注释也可以包裹多行字符串
int类型
int数字类型,一般用来计算和比较
str字符串类型
字母数字汉字都可以作为字符串必须用引号包裹起来
bool类型
True为真或者1
False为假或者0
输出print
print(‘helloworld‘)
输入input(用户交互程序)
name=input(‘请输入姓名:‘)
print(type(name))#字符串
#input所接收获取到的内容都是字符串
if else 二选一
if elif elif 多个选择一个或者零个
if elif elif else 多个选一个
if if if 多选多或零
if 嵌套 进行多层判断 一般if嵌套写三层就可以了
# 用来代表单行注释
"""
多行注释
多行注释
多行注释
多行注释
多行注释
"""
# print输出
print(‘hello world‘)
# input输入，可以赋值给变量
name = input(‘请输入‘)
print(name)
# input输入为字符串格式，想要输出其他类型，要进行格式转换
age = int(input(‘输入：‘))
print(type(age))
# 常量，python常量用大写的变量名来表示
LUCKY = ‘luckycoffee‘
# 字符串拼接，字符串只能和字符串相加
a = ‘lijie‘
b = ‘guobaoyuan‘
print(a + b)
# 字符串相乘
print(a * 3)
# if elif else流程判断
# 需求，编写一个用户交互程序
name2 = input(‘亲输入用户名:‘)
age = int(input(‘亲输入年龄：‘))
sex = input(‘亲输入性别：‘)
if name2 == ‘王五‘ and age > 25 and sex == ‘男‘:
print(‘可以去城中村洗脚了‘)
if 50 > age > 35:
print(‘还是回家歇着吧‘)
elif 35 > age > 25:
print(‘小心腰‘)
else:
print(‘年少轻狂‘)
elif name2 == ‘王五‘ and 18 < age < 25 and sex == ‘女‘:
print(‘洗脚很挣钱‘)
else:
print(‘你是个？‘)
sam=1
while sam<10:#
print(sam)
sam=sam+1
sum=1
while True:
if sum == 10:
break
print(sum)
sum=sum+1
sum1 = 1
while sum1<10:
if sum1 ==8:
sum1=sum1+1
continue
print(sum1)
sum1=sum1+1
sum = int(input(‘请选择输入0或1:‘))
while sum == True:
name = input(‘亲输入用户名:‘)
pwd = input(‘亲输入密码‘)
if name == ‘lijie‘ and pwd == ‘123456‘:
print(‘登陆成功‘)
break
else:
print(‘用户名或密码错误‘)
else:
print(‘退出成功‘)
for+空格+in+可迭代对象+冒号(#整型和布尔值不能进行循环)
缩进 循环体
for i in ‘asdf‘:#i是变量名
pass#pass和...是占位符
print(i)#当在外围打印i时,值应该是for循环变量最后所获得的值
name=‘lijie‘
age=23 #在格式化的时候想要使用%可以用%%进行转义
print((‘姓名：%s,年龄：%d‘)%（name,age）)
通过顺序来传递参数
print((‘{1},{0},{1}‘).format(‘boy‘,‘girl‘))
通过变量名来传递参数
print((‘{name}:{url}‘).format(name=‘python‘,url=‘www.python.org‘))
通过字典来传递参数
dict={‘name‘:‘boy‘,‘sex‘:‘男‘}
print((‘{name},{sex}‘).format(**dict))
通过列表来传递参数
list=[‘boy‘,‘男‘,‘25‘]
list1=[‘哈哈‘,‘呵呵‘]
print((‘{0[0]},{0[1]},{0[1]}‘).format(list,list1)
name=‘lijie‘
age=3
s=f‘姓名：{name},年龄：{age}‘
print(s)
ascii 不支持中文
gbk 中文2个字节,英文1个字节
unicode 中文4个字节,英文2个字节
utf-8 中文3个字节,欧洲2个字节,英文1个字节
# 编码:将文字转换成字节形式 encode
# 解码:将字节转换成文字形式 decode
| 比较运算符 | > < >= <= == != |
|---|---|
| 赋值运算符 | += -= *= /= //= **= %= |
| 成员运算符 | in not in |
| 逻辑运算符 | and or not |
| 算法运算符 | + - * / ** % // |
下表中变量 a 为 60，b 为 13，二进制格式如下
a = 0011 1100
b = 0000 1101
-----------------
a&b = 0000 1100
a|b = 0011 1101
a^b = 0011 0001
~a = 1100 0011
------------------------
#&
按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0
(a & b) 输出结果 12 ，二进制解释： 0000 1100
#|
按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。
(a | b) 输出结果 61 ，二进制解释： 0011 1101
#^
按位异或运算符：当两对应的二进位相异时，结果为1
(a ^ b) 输出结果 49 ，二进制解释： 0011 0001
#~
按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1 。~x 类似于 -x-1
(~a ) 输出结果 -61 ，二进制解释： 1100 0011，在一个有符号二进制数的补码形式
#<<
左移动运算符：运算数的各二进位全部左移若干位，由 << 右边的数字指定了移动的位数，高位丢弃，低位补0。
a << 2 输出结果 240 ，二进制解释： 1111 0000
#>>
右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，>> 右边的数字指定了移动的位数
a >> 2 输出结果 15 ，二进制解释： 0000 1111
str转换int
a=int(‘33‘)
print(a)#结果33#只有要转换的字符串是数字的时候才能转换
?
int转换str
n=str(56)
print(n)#结果"56"
?
bool转换str
bool值不为空就是True,空就是False
b=str(True)
print(b)#结果true
?
bool转换int
b=int(True)
print(b)#结果1
?
十进制转换二进制
bin(23)#十进制转换二进制
十进制转换由下往上数
二进制转换十进制
int(‘1011‘,2)#要转换的十进制要用引号引起来,从右往左数
八进制转换十进制
# 八进制转换成十进制
v3 = "011"
print(int(v3))
# 11
十进制转换八进制
# 十进制转换成八进制：---> oct
v4 = 30
print(oct(int(v4)))
# 0o36
十六进制转换十进制
# 十六进制转换成十进制：
v5 = "0x12"
print(int(v5,16))
# 18
十进制转换十六进制
# 十进制转换成十六进制：---> hex
v6 = 87
print(hex(int(v6)))
# 0x57
format进制转换
print(format(13,">20")) # 右对齐
print(format(13,"<20")) # 左对齐
print(format(13,"^20")) # 居中
?
print(format(13,"08b")) # 2
print(format(13,"08d")) # 10
print(format(13,"08o")) # 8
print(format(12,"08x")) # 16
# name = "今天是个好日子"
# 0 1 2 3 4 5 6
#-7-6-5-4-3-2-1
# a = name[0]
# b = name[1]
# print(a+b)
# 切片
# print(name[0:2]) # 顾头不顾尾 name[起始位置:终止位置]
# print(name[:]) # 某个位置不指定的时候默认取最后或最前
# print(name[2:5])
# print(name[-2:-5])
# print(name[-2:-5:-1]) # [起始位置:终止位置:步长] 步长默认为1
?
upper()#将字符串全部大写
lower()#将字符串全部小写
startswith()#判断以什么开头,可以指定范围
endswith()#判断以什么结尾,可以指定范围
strip()#去除空格换行制表符,可以指定去除的字符
replace()#替换,可以指定次数
isalnum()#判断是不是数字字母汉字组成
isdigit()#判断是不是阿拉伯数字
isalpha()#判断是不是字母和汉字
isdecimal()#判断是不是十进制
len()#获取字符串的长度
split()#以空格换行制表符分割,可以指定分割符和次数
rsplit()
#从右边开始分割
count()#获取字符出现的次数
find()#查找字符在字符串中出现的次数,可以指定开始与结束,有返回索引,否则返回-1
index()#与find一样,但是如果找不到就报错
capitalize()#把字符串的首字母大写
‘_‘.join(s)#使用指定的字符吧字符串的每个字符分割
casefold()#与lower一样,但是lower只对ascii由效
format()#格式化输出,用{}表示
center()#返回字符串居中,空格填充的指定长度的字符串
decode()#以指定的编码格式进行解码
encode()#以指定格式进行编码,二进制
expandtabs()#将字符串中的tab键转换成空格,默认为8个
isidentifier()#判断是不是有效的puthon标识符
isspace()#判断字符串中是不是值只包含空格
isnumeric()#判读字符串是不是只包含数字字符
isprinttable()#判断是不是都是可打印的字符或字符串,可以用来查看是不是包含转义符
ljust()#与center相似,字符串左对齐,空格补充至指定长度
rjust()#与ljust相反
partition()#与split相似,但是分割后分割字符保留,返回三元字符串
splitlines()#以换行符进行分割,返回分割后的列表
swapcase()#对字符串中的大小写进行反转
#增
lst.append(‘哈哈‘)#在列表最后添加一位
lst.insert(0,‘啊啊‘)#指定索引添加,后面的元素后移
lst.extend(‘今天下雨了‘)#将字符串的每个元素分别添加到列表中,迭代增加
#删
lst.pop(0)#默认删除最后一位,可以指定索引删除,删除后讲删除的值返回,
lst.remove(‘哈哈‘)#指定元素删除,在有重命名的情况下,删除一个
lst.clear()#清除
del list[0] del list[0:5:2]#看可以使用下标,步长进行删除
#改
list[0]=‘呵呵‘#通过赋值直接更改
list[0:3]=‘1232456‘#元素可以超出切片的位数
list[0:4:2]=‘12‘#元素与位置一一对应,不能多也不能少
#查
for i in lst:
print(i)#用for循环遍历
count()#次数
sort(rever=False)#排序
reverce()#反转
?
lst=[‘你好‘,[‘哈哈‘,[‘呵呵‘]]#可以通过索引切片一层一层查找
print(range(0,10))
#python2中直接返回列表,xrange()和python3中的range相似
#python3中作为迭代对象,怎么写就怎么打印,可以使用list()进行转换
?
range(0,10)#起始位置和终止位置,起始位置是0时可以默认不写
range(10,1,-1)#也可以从大到小生成数据,
range(1,100,2)#也可以用来生成奇数和偶数等
?
# lst = []
# for i in lst:
# lst.append("alex")
# print(lst) # 不会打印内容 因为lst是空的
?
# lst = [1,2]
# for i in lst:
# lst.append("alex")
# print(lst) # 循环打印lst中的内容 -- 此循环是死循环
?
# lst = [1,2]
# for i in lst:
# lst.append("alex")
# print(lst) # 死循环 -- 不会打印内容
?
# lst = []
# for i in range(5):
# lst.append([])
# print(lst) # [[],[],[],[],[]]
?
# lst = [1,2]
# lst[0] = lst
# print(lst) # [[...],2]
?
#增加
dic[‘name‘]=‘哈哈‘#暴力添加
dic,setdefault(‘age‘,18)#不存在就添加,存在就不添加
#删除
dic.pop(‘name‘)#通过键来删除键值对,返回值:返回的是被删除的值
del dic[‘name‘]#通过键来删除键值对
dic,clear()#清空
修改
dic[‘name‘]=‘呵呵‘#暴力修改
dic.update({‘name‘:‘卡卡卡‘})#update括号内部的字典高于前面的字典
查找
for i in dic:#获取的是所有的键
dic.get(‘name‘)#通过get方法和键,来获取值,存在就返回,不存在就是空
?
#其他操作
dic.keys()#获取所有的键,是一个高仿列表,可以遍历,不可下标
dic.values()#获取所有的值,是一个高仿列表,可以遍历,不可下标
dic.items()#返回所有的键值,返回的是一个列表,键值对是元祖形式
diat=dic.fromkeys(‘123456‘,[2])#批量添加,值会共用
dic.popitem()#随机删除#3.6史默认删除最后一个
?
a,b = 10,12
print(a)
print(b)
10,12
?
a = 10
b = 20
a,b = b,a
print(a,b)
20,10
?
a,b = [1,2]
print(a,b)
1,2?
a,b = (3,4)
print(a,b)3,4
?
a,_,b = (3,4,5)
print(a,b) # 等号后边的值和前面的变量名要一一对应
3,5
?
a = 10,12 # 本质就是一个元组
print(a)
(10,12)
?
a,b = "23"
print(a,b)
2,3
?
a,b = {"1":"a","2":"b"}
print(a,b)
1,2
?
for i in dic1.items():
print(i)
?
for k,v in dic1.items():
print(k,v) # 获取每个元素的键和值
?
?
dic = {1001:["周杰伦","林俊杰"],
1002:{"汪峰":{"前妻1":["大烧饼"],"前妻2":["熊大","熊二"],"国际章":"肉丝"}},
1003:{"陈冠希":["阿娇","阿萨","张柏芝"]},
1004:{"韦小宝":[{"教主夫人":["教主"]},
{"阿珂":"刺客"},
{"双儿":"天地会"},
{"爱心觉罗建宁":"公主"},
{"独臂神尼":{"韦小宝师父":{"兰陵王":"隐身"},"花木兰":[
"唧唧复唧唧","木兰是战士",{"爸爸":["花和尚"]}]
}},
{"陈圆圆":"丈母娘"},{"穆建平":"小郡主"}]},
1005:{"常鑫":["大黑哥","大烧饼","吃大煎饼","肉夹馍","自行车","井盖",]}
}
?
?
# print(dic)
# print(dic[1004]["韦小宝"][0]["教主夫人"][0])
# print(dic[1005]["常鑫"][-1])
# print(dic[1002]["汪峰"]["前妻2"][-1])
# print(dic[1004]["韦小宝"][4]["独臂神尼"]["韦小宝师父"]["兰陵王"])
# print(dic[1004]["韦小宝"][4]["独臂神尼"]["花木兰"][2]["爸爸"][0])
?
#增加
add()#往集合中添加一个元素
update(‘你好呀‘)#迭代增加
#删除
pop()#随机删除一个
remove(‘哈哈‘)#指定元素删除
clear()#清空
#修改
集合在修改的时候是先删除再修改
#查找
使用for循环进行查找
set(‘HAHAH‘)#迭代添加
?
& #交集
| #并集
- #差集
^ #对称差集
> #父集
< #子集
forzenset()#冻结集合
?
?
注意:(列表去重)
# lst = [1,2,1,2,4,2,45,3,2,45,2345,]
# print(list(set(lst)))
?
# 列表删除 -- 从后向前删除
# 创建一个新的列表,删除旧的列表
# 字典删除 -- 循环的时候不能改变源数据的大小 (可以改变值)
# 创建一个新的字典,删除旧的字典
# 集合删除 -- 循环的时候不能改变源数据的大小
?
# python数据类型:
# 可变:
# list ,dict ,set
# 不可变:
# int bool str tuple
# 有序:
# list,tuple,str,int,bool
# 无序:
# dict,set
# 取值方式:
# 索引: str list tuple
# 直接: set ,int ,bool
# 键: dict
?
代码块:一个文件,一个函数,一个类,一个模块,终端中每一个行是一个代码块
支持:
?
数字:
在同一代码块下 只要内容相同就采用相同的内存地址(-5以后就不是)
数字在做乘法的时候范围 -5 ~ 256 ****
数字在做乘法的时候不能使用浮点数
字符串:
在同一代码块下 只要内容相同就采用相同的内存地址
乘法的时候总长度不能超过20 ****
乘法的时候中文,特殊符号乘以1或0
布尔值:
在同一代码块下 只要内容相同就采用相同的内存地址
?
小数据池:
数字: -5 ~ 256 ****
字符串:
在同一代码块下 只要内容相同就采用相同的内存地址
乘法的时候总长度不能超过20 ****
乘法的时候中文,特殊符号乘以0
布尔值:
在同一代码块下 只要内容相同就采用相同的内存地址
小数据池的验证方法,必须脱离代码块才能进行验证
先执行代码块的规则,在执行小数据的规则 --(驻留机制)
?
#赋值:
# 多个变量名指向同一个内存地址
# 一个变量对其进行操作,其他变量查看时都变动
#浅拷贝:
# lst[1:10] -- 是浅拷贝
# 浅拷贝只拷贝第一层元素
# 修改第一层元素是,新开辟的不进行改变
#深拷贝:
# 不可变的数据类型共用,可变的数据类型重新开辟一个空间
# 对源数据进行修改,深拷贝的内容不进行改变
?
#代码块: 一个文件,一个函数,一个类,一个模块,终端中每一行
# 数字: -5 ~ 256
# 字符串: 乘法时总长度不能超过20
# 布尔值: 内容相同内存地址相同
#小数据池:
# 数字: -5 ~ 256
# 字符串: 乘法时总长度不能超过20
# 布尔值: 内容相同内存地址相同
#先执行代码块后执行小数据池
#== is
# == 判断等号两边值是否相等
# is 判断两边的值内存地址是否相等
?
?
# 浅拷贝的时候只拷贝第一层元素
# 浅拷贝在修改第一层元素(不可变数据类型)的时候,拷贝出来的新列表不进行改变
# 浅拷贝在替换第一层元素(可变数据类型)的时候,拷贝出来的新列表不进行改变
# 浅拷贝在修改第一层元素中的元素(第二层)的时候,拷贝出来的新列表进行改变
?
# 深拷贝开辟一个容器空间(列表),不可变数据公用,可变数据数据类型(再次开辟一个新的空间)
# ,空间里的值是不可变的数据进行共用的,可变的数据类型再次开辟空间
?
#文件操作
# open---打开文件
# file---文件路径
# mode---文件操作模式
# encoding---文件编码集
?
#r,w,a:
# r:读模式
# read()读取全部内容
# read(3)r,w,a模式下为为字符
# readline()读取一行
# readlines()一行一行读取,保存在一个列表中
# w:写模式,先清空,后写
# write()只能写入字符串
# a:追加写模式:
# 不管光标怎么移动都是在文件末尾进行追加写
------------------------------------------------
#rb,wb,ab(字节模式,不用选择编码格式)
# rb:读取字节模式
# read(3)rb,wb,ab模式下读取的字节,
# wb:清空写(字节)
# write()先清空,后写入
#-----------------------------------------------
#r+,w+,a+
# r+(读写)一定要先读后写
# w+(写读)先清空,再写,后读
# a+(追加,读)在文件末尾追加,读的时候为空要移动光标
?
#tell()查看光标的位置,返回的是字节的位置
#seek():
# seek(0,0)移动到文件的开头位置
# seek(0,1)光标的当前位置
# seek(0,2)移动到文件的末尾
# seek(3)#按照字节进行移动,字节计算按照编码进行计算
-------------------------------------------
with open(文件操作名,模式,编码)as f:
操作
with open的好处:
1.可以同时打开多个文件
2.能够自动关闭文件
-------------------------------------------
修改文件内容:
1.创建一个新的文件
2.将文件中的内容进行替换
3.替换后的内容写入新文件中
4.改变文件名
?
路径:
绝对路径: 从磁盘根部进行查找
相对路径: ../返回上一级 --推荐使用
转义:
1."C:\\user\\ner"
2. r"C:\user\ner" -- 推荐使用
?
def 关键字--定义函数
func 函数名和变量的命名规则一样
() 格式,用来船体参数,
:申明函数定义语句的结束
def func():
print(‘哈啊哈‘)#函数体
func()#调用函数
?
return 返回值
return的内容返回给了函数的调用
return下方的代码不执行,终止这个函数
return 返回多个内容的时候还是元组形式
return 没有写返回值的时候返回的是None,不写return返回None
def yue():
print("打开手机")
print("打开微信")
return 111
print("找到女友")
print("晚上约吗")
return "萝莉小姐姐","大妈","人妖" # return 返回
print("确实有点累")
print(yue()) # 111
print(1234)
=========================================
lst = [1,2,3,4,5]
def func():
for i in lst:
print(i)
lst.append(input(">>>"))
return lst
?
1:位置参数
def yue(a,b,c): # 形参
print("打开手机")
print(f"打开{a},{c},{b}")
print("附近的人")
print("找个妹子")
print("聊一聊")
yue(True,(12,4,3),[1,2,3,4]) # 实参
2:默认参数
def userinfo(name,age,sex="男"): # 位置参数 > 默认参数
print(name,sex,age)
count = 5
while count:
name = input("name:")
sex = input("sex(男性直接回车!):")
age = input("age:")
if sex == "女":
userinfo(name,age,sex)
else:
userinfo(name, age)
count -= 1
3:关键字参数:
def func(a,c,b=1): # a,c位置参数 ,b=1 是默认参数
print(a,b,c)
?
func(a=1,b=5,c=2) # a=1,b=5,c=2 是关键字参数
4:混合参数
def func(a,b,c):
print(a,b,c)
func(1,2,c=5) # 混合参数
**************************************************************
# 形参: 函数的定义中括号里是形参
# 实参: 函数的调用括号里是实参
# 位置传参时 形参和实参必须一一对应
# 传参: 将实参传递给形参的过程就是传参
?
# 函数的参数:
# 形参: 函数定义的时候叫做形参
# 位置参数
# 默认参数
# 混合参数
?
# 实参: 函数调用的时候叫做实参
# 位置参数
# 关键字参数
# 混合参数
?
# 传参: 将实参传递给形参的过程叫做传参
?
#*args动态位置参数
def func(a,b,*args):#*args是万能的位置参数,*在函数定义的时候叫聚合
print(a,b,args)#接收的是元祖形式
def func(a,b,*args):
print(a,b*args)#*args在函数内部是打散的意思
位置参数>动态位置参数>默认参数
-------------------------------------------------
#**kwargs动态关键字参数
def func(a,b,**kwargs):#**kwargs接受的是关键字,字典的格式
print(a,b,kwargs)#字典的格式
def func(a,b,kwargs):
print(a,b,*kwargs)#*kwargs获取到的是字典的键
位置参数>动态位置参数>默认参数(关键字参数)>动态关键字参数
-------------------------------------------------
*args,**kwargs万能参数
def func(*args,**kwargs):
print(args,kwargs)
?
def func1(user,password):
"""
密码加密
:param user: 用户名 str
:param password: 密码 str
:return: 加密的密码 MD5
"""
print(user,password)
print(func.__doc__)#可以查看函数的注释
?
在python解释器开始执行之后, 就会在内存中开辟一个空间, 每当遇到一个变量的时候, 就把变量名和值之间的关系记录下来, 但是当遇到函数定义的时候, 解释器只是把函数名读入内存, 表示这个函数存在了, 至于函数内部的变量和逻辑, 解释器是不关心的. 也就是说一开始的时候函数只是加载进来, 仅此而已, 只有当函数被调用和访问的时候, 解释器才会根据函数内部声明的变量来进行开辟变量的内部空间. 随着函数执行完毕, 这些函数内部变量占用的空间也会随着函数执行完毕而被清空.
?
命名空间分类:
1. 全局命名空间--> 我们直接在py文件中, 函数外声明的变量都属于全局命名空间
2. 局部命名空间--> 在函数中声明的变量会放在局部命名空间
3. 内置命名空间--> 存放python解释器为我们提供的名字, list, tuple, str, int这些都是内置命名空间
?
#内置空间>全局空间>局部空间
?
#局部空间>全局空间>内置空间
?
#全局作用域:
内置空间+全局空间
#局部作用域
局部空间
?
# 函数中套函数
# def func():
# a = 1
# def foo():
# b = 2
# print(b) # 2
# print(a) # 1
# def f1():
# print(b) # 2
# return f1()
# return foo()
# print(func())
------------------------------------
# 函数嵌套调用
# def func():
# a = 1
# foo()
# print(a)
#
# def foo():
# b = 2
# print(b)
# func()
-------------------------------------
# 函数嵌套参数的传递
# def func(a):
# foo(a) #10
#
# def foo(e):
# b(e) # return 10
#
# def b(c):
# print(c)
# return 10
#
# print(func(5))
-------------------------------------
# 函数嵌套返回值的传递
# def func(a):
# foo(a) #10
# return 10
# def foo(e):
# b(e)
# return 10
# def b(c):
# print(c)
# return 10
#
# print(func(5))
?
#global修改变量的值
# def func():
# global a # 声明修改全局变量的值
# a += 1
# print(a)
# func()
# print(a)
---------------------------------------------
#nonlocal在外层的函数中,修改局部空间的变量值.完全不涉及全局变量,
#只修改离它最近的一层,最近的一层没有变量继续向上找,直到找到最外层函数
?
def func():
print(‘哈哈‘)
s=func
s()
?
def func():
print(‘哈哈‘)
lst=[func,func,func]
for i in lst:
i()
?
def func(f):
f()
def foo():
print(‘呵呵‘)
func(foo)
?
def func():
print(‘啊哈哈‘)
def foo():
print(‘呵呵‘)
return foo
func()
?
#可以填充字符串
s=f"{‘haha‘}"
#可以填充变量
s1=f‘{s}‘
#可以填充计算公式
s2=f"{35+35}"
#可以填充表达式
s3=f"{a if 2>3 else b}"#三元表达式
#可以填充大括号
s4=f"{{{{1}}}}"#逢二取一
?
#list,dict,tuple,str,set都是可迭代对象,优点是可以灵活使用,可以直接查值,缺点是:消耗内存,不能迭代取值
#__iter__()可以查看是不是一个可迭代对象
#dir(list)#可以查看数据类型的所有的方法
#同时拥有__iter__()和__next__()方法的就是一个迭代器
#迭代器的优点是:节省内存,惰性机制(调用一次,取一次值)
#缺点是:不灵活,不能查看全部的值,比较繁琐
#迭代器的特性是:
# 一次性使用,不能逆行取值,惰性机制节约内存
#当容器中的数据量较大时,可以使用迭代器
?
#具有__iter__()方法的都是可迭代的对象
# lst=[1,2,3,4,5,6,7,8,9]
# new_lst=lst.__iter__()#可以将迭代对象转换成迭代器
#__next__()方法可以取值,每次取一个,无法回退,
# print(new_lst.__next__())
# print(new_lst.__next__())
?
lst=[1,2,3,4,56,7,89]
new_lst=lst.__iter__()
while True:
try:
print(new_lst.__next__())
except ExceptIteration:
break
?
#递归函数的特性
#1:函数自己调用自己(不断调用自己本身)
#2:有明确的结束条件
#递:函数一直执行到条件结束
#归:从结束条件返回
-------------------------------
def func(age):
if age==4:
return 18
else:
return func(age+1)-2
print(func(1))
#import sys
sys.setrecursionlimit(400)设置函数的最大递归次数
什么是生成器
#迭代器是python自带的一种节省空间的工具
#生成器的本质就是一个迭代器
#迭代器和生成器的区别是,一个是python自带的,一个是我们自己写的
?
生成器的定义
def func():
print(1)
yield ‘哈哈‘
print(2)
yield ‘呵呵‘
g=func()#产生一个生成器
print(next(g))#一个__next__()对应一个yield
for i in g:#生成器可以使用for循环遍历
print(i)
---------------------------------------
print(func().__next__())#这种会不段产生新的生成器,这是 坑 坑 坑
?
生成器的使用场景
def func():
lst=[]
for i in range(1000000):
yield i
g=func()
foe i in range(50):
print(next(g))
#当数据量过大时,可以使用生成器来节省空间
?
生成器的总结
#在函数中将return改成yield就是一个生成器
#yield会记录执行的位置,yield和return都是返回的意思
#return可以写多个,都是只能执行一个,yield可以写多个,还可以返回多次
#一个__next__()方法和一个yield一一对应,反则会报错
#生成器可以使用for循环进行遍历,获取值
#yield from可以将可迭代对象的元素逐个返回
#在函数的内部,可以使用yield将while和for循环暂时暂停
?
列表推导式
#循环模式
print([i for i in [1,2,3,4,5,6,7]])
#筛选模式
print([i+1 for i in [1,2,3,4,56,7,8,9] if i % 2==0])
#[变量(加工后的变量) for循环 加工方式]
?
字典推导式
#循环模式
print({i:i+1 for i in range(20)})
#筛选模式
print(i:i+1 for i in range(20) if i % 2==0)
#{键:值 for循环 加工条件}
?
集合推导式
#循环模式
print({i for i in [1,2,3,4,6,7,9]})
#筛选模式
print({i+1 for i in range(20) if i %2==0})
#{变量(加工后的变量) for循环 加工条件}
?
生成器表达式
#循环模式
g=(i for i in range(20))
print(next(g))
#筛选模式
g=(i for i in range(20) if i %2==0)
print(next(g))
print(list((i for i in range(20))))#list()方法内部有循环取值
#(变量(加工后的变量 for循环 加工条件))
?
| 内置函数 | 函数的意思 |
|---|---|
| all() | all() 函数用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。 |
| any() | any() 函数用于判断给定的可迭代参数 iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 True |
| bytes() | bytes 函数返回一个新的 bytes 对象，该对象是一个 0 <= x < 256 区间内的整数不可变序列。它是 bytearray 的不可变版本 |
| callable() | callable() 函数用于检查一个对象是否是可调用的。如果返回 True，object 仍然可能调用失败；但如果返回 False，调用对象 object 绝对不会成功。 |
| chr() | chr() 用一个范围在 range（256）内的（就是0～255）整数作参数，返回一个对应的字符,返回值是当前整数对应的 ASCII 字符。 |
| complex() | complex() 函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。 |
| divmod() | python divmod() 函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)。 |
| eval() | eval() 函数用来执行一个字符串表达式，并返回表达式的值。 |
| exec() | exec 执行储存在字符串或文件中的Python语句，相比于 eval，exec可以执行更复杂的 Python 代码。 |
| frozenset() | frozenset() 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。 |
| globals() | globals() 函数会以字典类型返回当前位置的全部全局变量。 |
| hash() | hash() 用于获取取一个对象（字符串或者数值等）的哈希值。 |
| help() | help() 函数用于查看函数或模块用途的详细说明 |
| id() | id() 函数用于获取对象的内存地址。 |
| input() | 输入,获取到的是字符串类型 |
| int() | 整数类型 |
| iter() | iter() 函数用来生成迭代器。 |
| locals() | locals() 函数会以字典类型返回当前位置的全部局部变量。对于函数, 方法, lambda 函式, 类, 以及实现了 call 方法的类实例, 它都返回 True。 |
| next() | next() 返回迭代器的下一个项目。 |
| oct() | oct() 函数将一个整数转换成8进制字符串。 |
| ord() | ord() 函数是 chr() 函数（对于8位的ASCII字符串）或 unichr() 函数（对于Unicode对象）的配对函数，它以一个字符（长度为1的字符串）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值，如果所给的 Unicode 字符超出了你的 Python 定义范围，则会引发一个 TypeError 的异常。 |
| pow() | pow() 方法返回 xy（x的y次方） 的值 |
| repr() | repr() 函数将对象转化为供解释器读取的形式。 |
| round() | ound() 方法返回浮点数x的四舍五入值。 |
| 函数名 | 函数的意思 |
|---|---|
| dir() | 查看函数的所有方法 |
| abs() | 绝对值,返回的是正数 |
| enumerate() | 枚举,(‘‘可迭代对象‘‘,‘序号的起始值‘),默认起始值为0 |
| zip() | 拉链,数据合并,按照最小的进行合并,返回的是个对象的内存地址 list(zip("可迭代对象","可迭代对象")) 返回的是[(1,2),(2,3)] |
| min() | 求最小值,key是比较的方法 min("可迭代对象",key=abs) #key指定查找最小值时的规则 |
| max() | 求最大值,key是比较的方法 max("可迭代对象",key=abs) #key指定查找最大值时的规则 |
| sum() | 求和 sum(list,tuple,set) |
| range()和2.7xrange() | 获取的是一个可迭代对象,2.7中range获取的是一个列表 |
| print() | 打印,sep元素之间的连接符,end是末尾的换行符 |
| list() | 转换成列表类型,自带循环 |
| dict() | 转换成字典类型,数据格式为dict=((1,2),(2,3)) |
| format | ‘<‘左对齐‘>‘右对齐^居中,,,,b,d,o,x进制转换,08八位显示 |
| bin() | 十进制转换二进制 |
| filter(过滤函数,迭代对象) | 过滤,获取的是一个内存地址 filter("函数名","可迭代对象") 写函数的时候可以指定过滤条件 |
| map() | 映射对象, map("函数名","可迭代对象") 写函数的时候可以指定对元素的操作 |
| reversed | 反转,获取的是一个可迭代对象 reversed("可迭代对象") # 对可迭代对象进行翻转(不改变源数据) |
| sorted | 对数据进行排序,key指的是排序的规则 sorted("可迭代对象",key="函数名",reverse=True) key是指定排序的规则(默认是升序)写了reverse=True就是降序 |
| reduce (from functools import reduce) | 累计算,根据计算的函数的条件进行计算 reduce("函数","可迭代对象") # 函数指定累计算的方式 (from functools import reduce) |
lambda是一个定义函数的关键字,必须有返回值,没有也要写None,只能返回一个数据类型,形参可以不写
# f = lambda x,y:(x,y)
# print(f(1,2))
# print(f.__name__)
# print((lambda x:x)(2)) # 同一行定义 同一行调用
# lst = [lambda i:i*i for i in range(10)](面试)
# print(lst[2](2))
# lst = [lambda :i*i for i in range(10)](面试)
# print(lst[2]())
---------------------------------
# lst = list((lambda i:i*i for i in range(5)))
# print(lst[1](4))
?
# lst = [x for x in (lambda :i**i for i in range(5))]
# print(lst[2]())
#解构
# lst1 = []
# def func():
# for i in range(5):
# def foo():
# return i**i
# yield foo
#
# for x in func():
# lst1.append(x)
# print(lst1[2]())
?
在嵌套函数内,使用非全局变量(且不是本层变量) -- 就是闭包
__closure__ 判断是否是闭包
闭包的作用
1. 保证数据的安全性
2. 装饰器的本质
# print(ret.__code__.co_freevars) # 获取的是自由变量
# print(ret.__code__.co_varnames) # 获取的是局部变量
---------------------------------
# def func():
# avg_lst = [] # 自由变量
# def foo(pirce):
# avg_lst.append(pirce)
# avg = sum(avg_lst) / len(avg_lst)
# return avg
# return foo
# ret = func()
?
装饰器的规则
# 开放封闭原则:
# 扩展是开放的(增加新功能)
# 修改源码是封闭(修改已经实现的功能)
# 在不改变源代码及调用方式的基础下额外增加新的功能
# 装饰器:用来装饰的工具
?
# 版一:
import time
# start_time = time.time()
# def func():
# time.sleep(2) #睡眠 (模拟网络延时)
# print("我要飞")
# func()
# print(time.time() - start_time)
# start_time = time.time()
# def foo():
# time.sleep(3) #睡眠 (模拟网络延时)
# print("我是小明,我飞的比你高")
# foo()
# print(time.time() - start_time)
--------------------------------------------------
# 版二:
# def times(f):
# start_time = time.time()
# f()
# print(time.time() - start_time)
# def foo():
# time.sleep(3) #睡眠 (模拟网络延时)
# print("我是小明,我飞的比你高")
# def func():
# time.sleep(1) #睡眠 (模拟网络延时)
# print("我是业儿,我起不来")
# s = func
# func = times
# s = foo
# foo = times
# foo(s)
----------------------------------------------------
# 版三(初识版装饰器):
# def times(f):
# def inner():
# start_time = time.time()
# f()
# print(time.time() - start_time)
# return inner
# def foo():
# time.sleep(1) #睡眠 (模拟网络延时)
# print("我是李业,我快!")
# foo = times(foo)
# foo()
--------------------------------------------------
import time
# def wrapper(f):
# def inner(*args,**kwargs):
# "被装饰前"
# start_time = time.time()
# f(*args,**kwargs) # func("alex")
# print(time.time() - start_time)
# "被装饰后"
# return inner # 切记不要加括号
#
#
# def func(*args,**kwargs):
# print(f"这是{args}函数,李业还是不行")
# time.sleep(2) #模拟网络延时
#
#
# func = wrapper(func)
# func("alex","sur")
----------------------------------------------------
# import time
# def wrapper(f):
# def inner(*args,**kwargs):
# "被装饰前"
# start_time = time.time()
# f(*args,**kwargs) # func("alex")
# print(time.time() - start_time)
# "被装饰后"
# return inner # 切记不要加括号
# # @wrapper # func = wrapper(func)
# def func(*args,**kwargs):
# print(f"这是{args}函数,李业还是不行")
# time.sleep(2) #模拟网络延时
# # @wrapper # foo = wrapper(foo)
# def foo(*args,**kwargs):
# print(f"这是{args}函数,常鑫穿齐*小短裤")
# time.sleep(3) #模拟网络延时
# func = wrapper(func)
# foo = wrapper(foo)
# func("alex","sur")
# foo("alex","sur")
---------------------------------------------------
?
语法糖
# 语法糖 -- 甜
# 语法糖必须放在被装饰的函数正上方
import time
# def wrapper(f):
# def inner(*args,**kwargs):
# "被装饰前"
# start_time = time.time()
# ret = f(*args,**kwargs) # func("alex")
# print(time.time() - start_time)
# "被装饰后"
# return ret
# return inner # 切记不要加括号
#
# @wrapper # func = wrapper(func)
# def func(*args,**kwargs):
# print(f"这是{args}函数,李业还是不行")
# time.sleep(2) #模拟网络延时
# return "alex"
# print(func())
?
标准版装饰器
# 标准版(装饰器):
# def func(a): #a是要被装饰的函数名
# def foo(*args,**kwargs):
# "装饰之前的操作"
# ret = a(*args,**kwargs)
# "装饰之后的操作"
# return ret
# return foo
# @func
# def f1(*args,**kwargs):
# print(f"这是一个{args}")
# return "我可以返回了"
# f1(1,2,3,34,4,5)
?
在装饰器的基础上再套一层
login_dic = {
"username": None,
"flag": False
}
# 正确的案例
msg = """
QQ
微信
抖音
邮箱
请输入您要选择登陆的app:
"""
chose = input(msg).upper()
?
def auth(argv):
def wrapper(func):
def inner(*args,**kwargs):
if login_dic["flag"]:
func(*args,**kwargs)
else:
if argv == "QQ":
print("欢迎登陆QQ")
user = input("username:")
pwd = input("password:")
if user == "alex" and pwd == "alex123": # qq
login_dic["flag"] = True
login_dic["username"] = user
func(*args,**kwargs)
else:
print("用户名或密码错误!")
elif argv == "微信":
print("欢迎登陆微信")
user = input("username:")
pwd = input("password:")
if user == "1351101501" and pwd == "alex": # 微信
login_dic["flag"] = True
login_dic["username"] = user
func(*args, **kwargs)
else:
print("用户名或密码错误!")
elif argv == "抖音":
print("来了,老弟!")
user = input("username:")
pwd = input("password:")
if user == "alexdsb" and pwd == "alex": # 抖音
login_dic["flag"] = True
login_dic["username"] = user
func(*args, **kwargs)
else:
print("用户名或密码错误!")
else:
print("欢迎登陆dab邮箱")
user = input("username:")
pwd = input("password:")
if user == "alexdsb@dsb.com" and pwd == "alex": # 邮箱
login_dic["flag"] = True
login_dic["username"] = user
func(*args, **kwargs)
else:
print("用户名或密码错误!")
return inner
return wrapper