简单学习--＞python基础语法
变量定义
变量名: 使用数字, 字母,下划线 构成 , 不能有特殊字符(同时变量名不能是数字开头 );
python的变量采用动态类型,变量的类型可以在程序运行中改变,定义变量不需要向C或java那样指定变量的类型.
#变量在定义的时候,就要给变量赋值,否则会报错
a = 10 #整数
b = 12.3 #浮点数
c = '字符串' #字符串
d = True #布尔值
数据类型
int: 整形
其他语言中的int类型可能占4个字节，8个字节，能表示的数值范围也有限，python中的int能表示的数值范围是"无穷的"，int类型可以根据要表示的数值自动扩容。
a = 1
b = 2
c = a+b #c 的就等于3
python中没有 short , long 这样的类型
float: 浮点型
python中的float占8个字节，同时float就代表了双精度浮点数，C和java中是float代表单精度，double代表双精度。
python中float就代表双精度浮点数，所以就不需要double类型
str:字符串
字符串使用单引号 ' ' 或双引号 " "把字符引起来。
#单引号和双引号的作用
#当字符串中需要有引号时
s1 = "my name is "zhangsan" !" #报错
print(s1)
#引号会跟前面最近的引号匹配 , 导致这段字符串其实是两个字符串
#一个 "my name is " 一个 " !" 中间的zhangsan是没有被引号引起来的#使用单引号 + 双引号一起用
s2 = 'my name is "zhangsan" !' #这就是一个合法字符串
print(s2)
s1 报错 ， s2 正常 ， print（s2）输出结果为：
python中没有chart字符类型（java中有用单引号引起了的单个字符chart类型，，python中无论是用单引号或是双引号引起来的都是字符串类型）
bool: 布尔类型
True代表正确，False代表错误。同时python中0也可以代表False，非0代表True
a = 0
b = 1
c = -0.1print(bool(a)) #把0转成bool类型
print(bool(b)) #把1转成bool类型
print(bool(c)) #把-0.1转成bool类型
输出结果
None : 空值
在python中用None代表空值（C和java中用null代表空）
type(): 查看数据类型方法
type(): 是python中内置函数，可以查看变量的数据类型
a = 10
b = 1.1
c = 'str'
d = True
e = None
#用type查看各个变量的类型
print(type(a)) #整数 : int
print(type(b)) #浮点数: float
print(type(c)) #字符串: str
print(type(d)) #布尔 : bool
print(type(e)) #空值 : NoneType
输出结果
声明变量类型
在定义变量时，指定变量是什么类型（不过一般没有什么大用，因为python是动态类型，变量的类型是可以改变的）
语法：
变量名 ：要指定的类型 = 赋值
a : int = 1 #指定整形
b : bool = True #指定布尔类型
因为动态类型，就算给变量指定了类型，也会变量的类型被赋值改变
注释
注释就是在代码运行中不会被执行的代码，
语法： #注释
#这是一行注释，下面才是会被执行的代码
a = 10
运算符
常用运算符
加 ： +
减 ： -
乘 ： *
除 ： / (两个整数相除时，python的除法不会像java中那样向下取整)
取整除 ：// （两个数相除的结果向下去整）
求余数 ： %
判断是否相等、判断是否相同
== ： 判断两个元素的值是否相等 （相等返回True，否则返回False）
is ： 判断两个元素是否相同，两个元素是否是同一个 （相同返回True，否则返回False）
a = 1
b = 1
a == b #a的值等于b的值，返回 True
a = [1 , 2 , 3]
b = [1 , 2 , 3]
a == b #a里的值等于b里的值，返回True
a is b #a 和 b 不是同一个元素，返回False
a = b = 'python'
a is b #a 和 b 都是指向同一个元素，返回True
逻辑运算符
逻辑运算符用于条件判断
and : 与 （要两边都是True，才返回True，否则都是返回False）
or : 或 （要两边都是False，才返回False，否则都是返回True）
not : 非 （如果是True，返回相反的False，如果是False，返回相反的True）
True and False #返回False
True and True #返回True
True or False #返回True
False or False #返回False
not True #返回 False
not False #返回 True三目运算符
语法： 结果1 if 条件 else 结果2
例子：
a = 1
b = 2
c = a if a < b else b ==> 如果a < b , 那么c=a , 如果b<a , 那么c = b
==> 这里因为a小于b，所以c等于a，也就是c == 1
输入和输出
输入 ： input（）
input输入得到的值默认是字符串str类型的，可以通过强转的方式把输入的值转成需要的类型
语法 ：
input() : 然后在控制台输入任意字符串 , 回车结束
name = input("输入你的名字： ")
print(name)
print(type(name))运行代码可以看到控制台的运行结果
输出 ： print（）
可以通过print（）在控制台输出东西
语法 ：
print（想要输出的东西）
字符串格式化
占位符替换
和C语言里一样，python可以使用占位符
通过 % ， 来把字符串里的占位符， 替换成对于的数值
如果有多个变量，就用%（） ， 用括号把多个括起来
%d 整数
%s 字符串
%.nf n位浮点数
name = '张三'
age = 11
f1 = 20.4221
print('name = %s , age = %d , sum = %.2f'
%(name , age , f1))
format（） 格式化
f '字符串 {变量}' // 或者大F 也行
使用f 在字符串里加入要的变量
name = '张三'
age = 11
f1 = 20.4221
print(f'name = {name} , age = {age} , sum = {age+f1}' )
重复字符串
'字符串' * n , 把这个字符串重复n次
print('*' * 10) ==> **********
字符串方法
1. str.replace() 替代
s1 = '小明摸出钥匙,要请小红'
print(s1.replace('小明','小蓝')) ==> 小蓝摸出钥匙,要请小红
//把小明替换成小蓝
2. str.strip () 去掉首尾空格
s2 = ' 111 ' print(s2) ==> ' 111 ' print(s2.strip()) ==> '111'
3. str.split() 按指定字符分割字符串
s3 = 'a b c'
print(s3.split(' ')) ==> ['a', 'b', 'c']
4. 查找统计
s3 = 'a b c'
print(s3.index('a')) ==> 0 找第一个a在哪个下标,没有就-1 , rindex() 反过来找倒数第一个
print(s3.find('b')) ==> 2 没有找到就-1 , rfind()反过来找倒数第一个
print(s3.count('c')) == 1 有多少个对于字符串
5.大小写转换
s3 = 'c a b c ' s4 = s3.upper() ==> 把小写转大写 print(s4) print(s4.lower()) ==>把大写转小写
转义字符
制表符: \t
反斜杠 t
引号转义
\' ==> 把转义成一个引号
print('\'') ==> 打印一个引号'
换行 \n
三引号跨行
用三个引号,打印就可以跨行打印
print('''
111
1111111
''')
列表 list
类似于数组, 但是python里的列表长度是可变的, 列表和字符串一样是有序的，可迭代的
arr = [1 , 2 , 3 , 4 , 6] print(arr[0]) ==> 1
列表方法
1.append() 添加一个
arr = [1 , 2 , 3 , 4 , 6] arr.append(5) print(arr) ==> [1,2,3,4,5,6,5]
2.extend() 添加多个元素
arr = [1 , 2 , 3 , 4 , 6] arr.extend([1 , 2]) print(arr)
3.insert() 插入一个元素
arr = [1 , 2 , 3 , 4 , 6] arr.insert(1 , True) print(arr) ==> [1 , True , 2 , 3 , 4 , 6]
4.conut() 统计列表里某个元素的数量
arr = [1 , 2 , 3 , 1, 4 , 5] print(arr.count(1)) ==> 2
5.remove() 删除指定的第一个元素
arr = [1 , 2 , 3 , 1, 4 , 5] arr.remove(1) print(arr) ==> [2 , 3 , 1 , 4 , 5]
6.pop() 删除指定下标的元素, 默认是删除最后一个
arr = [1 , 2 , 3] arr.pop() ==> arr = [1 , 2] arr.pop(1) ==> arr = [1 , 3]
7.clear() 清空所有元素
arr = [1 , 2 , 3] arr.clear() ==> arr = []
8.sort() 排序 ,默认从小到大
arr = [3 , 1 , 2 , 4] arr.sort() print(arr) ==> 1 , 2 , 3 , 4 // 按从大到小排序 arr = [3 , 1 , 2 , 4 , 6 , 5] arr.sort(reverse = True) #反转对于 True print(arr)
9.reverse() 反转列表
arr = [3 , 1 , 2 , 4] arr.reverse() print(arr) ==> 4 , 2 , 1 , 3
10.join() 用指定字符串拼接 列表里的元素 (只能拼接字符串,列表里的元素要是字符串)
arr = [1 , 2 , 3 , 4] '+'.join(arr) ==> 报错 arr= ['1' , '2' , '3' , '4'] '+'.join(arr) ==> '1+2+3+4'
元组 tuple
元组 和 列表类似
元组是不可变的序列结构 , 元组一旦创建, 里面的内容不能修改
列表是用中括号[] 元组是用括号()
创建元组
元组创建只有一个元素的话,需要加一个逗号,确定是元组, 否则会被识别成 其他类型
t1 = (1) print(type(t1)) ==> type = int t2 = (1,) print(type(t2)) ==> type = tuple
元组取值
元组取值和列表一样,用下标索引来取
t1 = (1 , True , 3 , '333' ) print(t1[0]) ==> 1 print(t1[0:]) ==> 1 , True , 3 , '333' print(t1[-1: -2:-1]) ==> '333' print(type(t1[0])) ==> int
集合 set
集合是无序的,可变的数据结果 , 用{}大括号表示
集合里放的元素要求是 : 唯一的 , 不可变的数据类型 例如: 数值,字符串 , 元组 , 不能放: 列表这样可变的
s1 = {1 , 2 , 3}
print(type(s1)) ==> set
s1 = {[1]} // 会报错, 集合里不能放列表
集合里放了重复的元素会自动去重
s1 = {1 , 2 , 1 , 2}
print(s1) ==> {1 , 2}
空集合要用 set() 创建
// 因为字典也用{}大括号来创建,如果是空的集合,要用set()创建
s1 = {}
print(type(s1)) ==> type = dict
s2 = set()
print(type(s2)) ==> type = set
集合的运算
& 交集 , | 并集
s1 = {1 , 2 , 3} s2 = {2 , 3 , 4} print(s1 - s2) s1去掉s2里有的 ==> {1} print(s2 - s1) s2去掉s1里有的 ==> {4} print(s1 & s2) 交集==> {2 , 3} , s1和s2都有的 print(s1 | s2) 并集==> {1 , 2 , 3 , 4} s1 加 s2
集合的增删改查
s1 = {1 , 2 , 3}
# s1.add(5) // 增加一个
# s1.remove(1) //删除一个
// update (可迭代的元素) 增加多个元素
s1.update([3 , 4 , 5 , 6])
print(s1) ==> {1 , 2 , 3 , 4 , 5 , 6}
s1 = {1 , 2 , 3}
s1.update('456')
print(s1) ==> {1 , 2 , 3 , 4 ,5 , 6}
一般集合的其他操作可以用 list() 把集合转换成列表 在进行
字典 dict
字典是键值对形式的数据类型,通过唯一的键key找到对于的值.
取值 : get()
d1 = {
'张三' : 1,
'历史' : 2,
'王叔' : 3 ,
'赵六' : 4
}
print(type(d1))
print(d1.get('zhangsan')) ==> None
d1.get('张三') ==> 1
添加修改 : 字典[key] = 值
1. 如果字典里没有 这个key , 则表示添加
d1 = {
'张三' : 1,
'历史' : 2,
'王叔' : 3 ,
'赵六' : 4
}
d1['无敌'] = 0
print(d1) ==> {'张三': 1, '历史': 2, '王叔': 3, '赵六': 4, '无敌': 0}
2. 如果字典里有这个key , 就是修改这个key的值
d1 = {
'张三' : 1,
'历史' : 2,
'王叔' : 3 ,
'赵六' : 4
}
d1['张三'] = 8
print(d1) ==> {张三: 8 , ....}
批量添加和修改 : 旧字典. update(新字典)
// 把字典1里原有的key的值 , 修改成字典2里有的对于的key的值
d1 = {
'张三' : 1,
'历史' : 2,
'王叔' : 3 ,
'赵六' : 4
}
d2 = {
'张三' : 3,
'历史' : 5
}
d1.update(d2)
print(d1)
// 如果字典2里有字典1里没有的key, 就添加进字典1里
d1 = {
'张三' : 1,
'历史' : 2,
'王叔' : 3 ,
'赵六' : 4
}
d2 = {
'张三' : 9,
'李四' : 10
}
d1.update(d2)
print(d1) ==> d1不仅修改了张三的值=9 , 还添加了'李四': 10
取值的同时设置默认值
和java里的getOrDefault()一样, 如果字典里没有对应的key , 则给一个默认值
d1 = {
'张三' : 1,
'历史' : 2,
'王叔' : 3 ,
'赵六' : 4
}
print(d1.setdefault('张四', 0)) ==> 0 , 没有张四, 返回0
d1.setdefault('张三' , 8) ==> 1 , 有张三,返回张三对应的值
删除: del 字典名[key]
删除字典里 的 key
d1 = {
'张三' : 1,
'历史' : 2,
'王叔' : 3 ,
'赵六' : 4
}
del d1['张三'] ==> 删掉 '张三'这个键值对
print(d1)
删除字典最后一个键值对: 字典.popitem()
删除掉字典里最后一个加入的键值对
删除: 字典.pop(key)
删除字典对于的key
d1 = {
'张三' : 1 ,
'李四' : 2
}
d1.pop('张三') == > 删掉张三这个键值对
获取所有键: 字典.keys()
获取字典里所有的键
获取所有值 : 字典.values()
获取字典里所有的值
获取所有哦键值对: 字典.items()
扩展
序列同结构都可以用 + 加号拼接
print('111' + '222') 字符串拼接
print([1 , 2 , 3] + [4 , 5 , 7]) 列表拼接
print((1 , 2 , 3) + (4 , 5 , 6)) 元组拼接
可迭代对象都可以用 in 和 not in 判断
-
in 在..里面
-
not in 不知..里面
1 in [1 , 2 ,3] ==> True 1 in '1234' == > True 0 not in [1 ,2 , 3] ==> True
可迭代对象可以用 len() 获取长度
len('zz') ==> 2
len([1 , 2 , 3]) ==> 3
数据类型对应的布尔值
1.数值 : 除了0 以外都是 True
bool(0) ==> False bool(0.01) ==> True
2.可迭代对象: 除了空都是True
bool(()) ==> False , 空元组
bool([]) ==> False , 空列表
bool('') ==> False , 空字符串
bool(' ') ==> True , 空格字符串
浅拷贝 和 深拷贝 copy()
链式赋值: a = b = c = [1 , 2 ,3 ] 这样就类似于浅拷贝, a[0] = 2 , 改了一个,b和c也改了 // copy() 就是深拷贝 a = [1 , 2 , 3] b = a.copy() print(a) print(b) a[0] = 8 ==> b是深拷贝 ,改a不影响b print(a) print(b)
字符串编码
用字符串.encode(编码) 来设置编码
s = '龙傲天'
print(s.encode('gbk'))
print(s.encode('utf-8'))
print(s.encode('ascii')) // 报错,ascii没有中文
判断
注意python对缩进非常严格
if 条件 : pass (可以用pass代表空) else : pass // 格式报错 if True : pass print() ==> 这个缩进问题导致if已经结束了,所以后面else 没有if else : pass // 多层if if 条件 : pass elif 条件2 : pass else : pass
循环
while 循环
while 条件 : 代码块
continue 和 break
continue : 跳过这次循环后面的
break : 停止循环
while else 循环
当wile循环结束, 执行 else里的
while 条件 : pass else : pass //输出 2345678910 1 ==> 最后while结束 , 执行else a = 1 while a < 10 : a += 1 print(a) else: print(1)
for 循环
for循环来遍历可迭代对象
1. 列表 list1 = [1 , 2 , 3 , 4] for a in list1 : print(a) ==> 输出 1 2 3 4 2. 字符串 for a in 'abc' : print(a) ==> 输出 'a' 'b' 'c' 3.for else 和while一样,当循环结束执行else里的 for i in list1 : pass else : pass
遍历字典
d1 = {'张三':11 , 'lisi' : 12 , 'wangwu': 13}
for i in d1 :
d1[i] += 10 ==> 给字典里的每个key的值都 +10
print(d1)
range() 函数
range可以生成起点到终点的所有整数, (左闭右开 , 不包含终点), 配合for使用
range(起点 , 终点 , 步长) range(1 , 101 , 1) 生产 1 -100 的所有整数 // 输出1到100 for i in range(1 , 101) : print(i)
函数
def python的函数使用def来定义
print() , len() ,type() 都是python内置的函数 def 函数(参数列表) return 返回列表
函数指定传参
def t1(x , y ) : print(x) print(y) t1(y= 2 , x = 1) ==> 指定参数传入给哪个 ; ==> 如果不传入好全部参数,就会报错 t1(y =2 ) ==> 会因为x没有传参报错
函数参数默认值
给参数指定默认值,这样在调用函数时,就可以不一定要传参
def t1(x = 1 , y = 2) : ==> 创建t1函数时指定了参数的默认值 print(x) print(y) t1(x = 2) ==> 调用函数时,就可以传入指定的参数
函数作用域
函数里的变量的作用域, 如果当前函数有,就用当前的, 没有就往外找
a = 11 b = 13 c = 14 def tt1() : print(a) ==> 用外面的a == 11 b = 12 def t2(): c = 10 print(b) ==> t2里面没有b, 往外找,tt1函数里面有b,就用==>12 def t3() : print(c) ==> 10 t3() t2() tt1()
函数能嵌套调用自己
def t1(): print(1) t1() t1() ==> 无限重复输出1, 无限调用t1(),最后报错
global : 声明变量是函数外的全局变量
a = 1 def test1() : global a #声明这里的a 是函数外面的a a += 1 print(a) ==> 输出 2 test1() print(a) ==> test1改变了a的值 输出2
文件操作
文件权限
read : 读 write: 覆盖写 append: 追加写入
读写模式
r+ : 读写模式,文件必须存在,从头开始读写 w+ : 读写模式,情况文件内容,再写,如果文件不存在则创建 a+ : 追加读写模式,从末尾开始读写,文件不存在则创建
文件操作
open('文件路径+文件名' , '操作模式(默认只读)' , encoding = '编码方式')
file = open('123.txt' , 'w' , encoding='utf-8') ==> 写的方式打开文件, 编码utf8
file.write('无敌了孩子')
file.close() ==> 要及时关闭文件
file = open('123.txt' , 'r' , encoding='utf-8')
message = file.read() ==> 如果文件为空会报错,文件没有内容
print(message) ==>无敌了孩子
file.close() ==> 关闭文件
seek() 光标
文件进行读写操作后, 光标会移到文件的后面,如果此时光标后面没有数据了,那么进行 读取操作读不到东西报错
file = open('123.txt' , 'w+' , encoding='utf-8')
file.write('无敌了孩子') ==>在文件里写入,此时光标在文件末尾,后面没有数据了
file.seek(0) ==> 把光标移动到最开头 , 如果不移动下面的读操作读不到东西
message = file.read() ==> 这时候再进行读操作,就能过读到东西
print(message)
file.close()
with : 上下文管理器
with在内部代码执行完后会自动 close文件 , 防止文件忘记关闭
with open('文件路径文件名' , '打开方式' , encoding='编码') as 变量名 :
代码块
with open('123.txt' , 'w+' , encoding='utf-8') as file :
file = open('123.txt' , 'w+' , encoding='utf-8')
file.write('无敌了孩子')
file.seek(0)
message = file.read()
print(message)
==> 不需要自己手动close文件
导包 import
通过import导包, 把别人的包和模块导入进来
import 包名 // 导入包 // 给包名起别名 import 包名 as 别名 ==> 后面使用别名来调用包里的函数 原来是==> 包名.函数() , 别名==> 别名.函数() // 导入包里的函数 from 包名 import 函数
内置模块和第三方模块
-
内置模块: python内置的 , 直接用import就可以导入
import calendar as c ==>导入包名直接使用 c.calendar()
-
第三方模块: 需要下载了才能使用
// 1. 下载库 pip install 库名 -i https://pypi.tuna.tsinghua.edu.cn/simple //(后面是python第三方库的镜像网站) pip install requests -i https://pypi.tuna.tsinghua.edu.cn/simple ==> 下载requests 这个库 //2. 删除库 pip uninstall 库名 // 3. 查看所有库 pip list
OS模块
python的 OS模块是用来和系统交互的模块,允许python进行系统级操作, 比如:创建/删除文件 , 允许shell命令 , 获取系统信息
1.文件重命名 : os.rename()
import os ==> 导包 os if(os.path.exists('123.txt')) : ==> 先判断文件是否存在 print('文件存在') os.rename('123.txt' , '333.txt') ==> 存在就更改名字 else: print('文件不存在') 更改后123.txt变成 333.txt
2.文件删除 : os.remove()
import os
if os.path.exists("333.txt") : ==> 判断文件是否存在
print('文件存在')
os.remove('333.txt ) ==> 删除文件
print('文件删除成功')
else:
print('文件不存在')
3. 创建目录 : os.makedirs()
可以递归创建多层文件夹 ,
import os
//1. 创建多层文件夹 ,
os.makedirs('aaa/bbb/ccc' , exist_ok=True) ==> exist_ok = True , 当文件夹已经存在了,就不会继续创建
==> 如果不加上这个=True, 当遇到文件夹存在时会报错
4. 查看所有文件 : os.listdir()
返回指定目录下所有的文件和子目录 (只包含当前这一层目录)
// 当前目录下的所有文件和子目录
os.listdir('.') ==> '.' 代表当前目录
// 只列出文件 用for 遍历列出所有文件和目录, 然后判断是不是文件,是文件就要
files = [i for i in os.listdir('.') if os.path.isfile(i)] ==> 把文件取出成列表
print(files)
5. 删除空文件夹 : os.removedirs()
// 2. 递归删除多层文件夹,
os.removedirs('aaa/bbb/ccc' ) ==> 直接把aaa/bbb/ccc 这几层文件夹都删除了,
前提是 /ccc 目录下没有东西了
==> 先删除了ccc, 然后 bbb空了,删除bbb, aaa也空了,删除aaa
6. 更改工作目录 : os.chdir()
更改python脚步的工作目录 , 当前python脚本在哪个位置,这个pythonProject1就是工作目录
//1 . 获取当前工作目录
os.getcwd()
// 2. 获取绝对路径
os.path.abspath('.')
// 更改当前脚本工作目录
os.chcwd('aaa/bbb') ==>把当前脚本的工作目录切换到aaa/bbb
==> 注意目录使用/斜杠, 更好跨平台兼容 , 使用反斜杠\, 前面要加r , 就是 r'aaa\bbb' , 否则报错
目录使用斜杠 \ 来 , 更好的跨平台兼容
高级函数
回调函数 : callback
回调函数的作用 : 当完成什么工作后,自动调用
回调函数的本质 : B函数作为A函数的参数, 在A函数里调用 , B函数就是回调函数
// 当打扫卫生后 ,发送通知
def fun1() :
print('打扫完成')
def fun2(callback) : ==> 设置参数是回调函数
print('打扫卫生')
callback() ==> 调用回调函数
fun2(fun1) ==> 在执行函数时, 传入回调函数
==> 输出
打扫卫生
打扫完成
闭包函数
一个大函数里的小函数, 小函数用到里大函数的数据, 然后大函数返回了小函数
闭包函数的作用 : 1.保存状态 , 2. 封装数据
//1. 保存状态
闭包函数, 可以在函数1要运行完要拆除了,将里面的内容保存到函数2里,返回函数2,
这样即使函数销毁了, 里面的内容我们仍然可以通过闭包函数得到
def func1():
a = 'a'
b = 'b'
c = 'c' ==> 函数里有 a,b,c变量,如果我们需要保留这些数据
print('func1')
def func2(): ==> 使用闭包函数,在函数里保func1里的内容
print('内容: '+ a + b + c) ==> 将fun1里内容保存到 这个闭包函数里
return func2 ==> fun1把闭包函数作为返回
t1 = func1() ==>
t1()
//2. 封装数据 ==> 即使外面的func1()函数已经执行完了,但是里面的数据,还留在他返回的这几个函数里
def func1():
l1 = ['苹果' , '橘子' , '香蕉' , '红糖']
def show():
print('箱子里面' , l1)
def add(num) :
print(f'添加{num},进入箱子')
l1.append(num)
def re(num):
print(f'删除箱子中的{num}')
l1.remove(num)
return {
'show' : show ,
'add' : add,
'remove' :re
}
sum = func1()
sum['show']()
sum['add']('西瓜')
sum['show']()
sum['remove']('西瓜')
sum['show']
==> 输出
箱子里面 ['苹果', '橘子', '香蕉', '红糖']
添加西瓜,进入箱子
箱子里面 ['苹果', '橘子', '香蕉', '红糖', '西瓜']
删除箱子中的西瓜
匿名函数 : lambda
语法 : lambda 参数1,参数2... : 表达式 ==> 可以有多个参数,最后返回表达式
==> 正常的相加函数
def func1 (a , b):
return a + b
==> 使用匿名函数 lambda
func2 = lambda a , b : a + b
print(func2(1, 2))
lambda的用法
排序
l1 =[ {'name': 'zhangsan' , 'score' : 30}, {'name': 'lisi', 'score': 90}, {'name': 'wangwu', 'score': 50}, {'name': 'zhaoliu', 'score': 70}, ] ==> 列表里都是字典数据, l1.sort(key = lambda l1 : l1['score']) ==> lambda匿名函数,告诉sort方法,通过成绩来排序列表里的数据 print(l1)过滤
有一个列表,过滤掉不需要的数据
// 过滤掉小于等于5的数 l1 = [ 12 , 2 , 3 , 76 , 23 , 9 , 3 , 5 , 10 , 11] ==> lambda x : x>5 ==> x做参数,判断x是否>5 ==> filter(lambda , l1) ==> filter是一个迭代器, 遍历l1这个列表 当lambda条件满足,就把数据挑出来 也就是在l1里遍历,如果数据满足lambda里的,就返回 ==> list() ==> 把返回的数据生成新的列表 l2 = list(filter(lambda x : x > 5 , l1)) print(l2) ==> 输出 [12, 76, 23, 9, 10, 11]
更多推荐
8
0- 0
已为社区贡献3条内容
所有评论(0)