Python学习
这里总结的是自己看视频的笔记、不是教程哟、所以顺序会有点乱!
Python是什么
简介
Python是一种跨平台的计算机程序设计语言。 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。最初被设计用于编写自动化脚本(shell),随着版本的不断更新和语言新功能的添加,越多被用于独立的、大型项目的开发。
安装
这个是我B站的安装教程
基础知识
注释的使用
Python中通过 #
、"""
来进行注释
1 | # 这是一个单行注释 |
快捷键的使用
- 注释与反注释快捷键
ctrl + /
- 格式化代码
ctrl + alt + L
print
: 用于向控制台输出内容
1 | print("Hello World!") |
关键字
1 | import keyword # 导入keyword模块查看关键字 |
变量的使用
input
input()
: 从外部获取变量
1 | num1 = int(input("请输入一个数字:")) |
程序执行过程
自上而下运行(面向过程)
1 | age = "good" |
变量的定义
1 | num3 = 10 |
可以连续定义多个变量
1
2
3num5 = num6 = num7 = 1
print(num3, num4, num5, num6, num7)
# 10 10 1 1 1交互式定义变量
1
2
3
4
5
6
7num5, num6 = 5, 6
print(num5, num6) # 5 6
f1 = 1.1
f2 = 2.2
f3 = f1 + f2
print(f3) # 3.3000000000000003数字类型转换
int()
:将一个数值或字符串转换成整数,可以指定进制。float()
:将一个字符串转换成浮点数。str()
:将指定的对象转换成字符串形式,可以指定编码。chr()
:将整数转换成该编码对应的字符串(一个字符)。ord()
:将字符串(一个字符)转换成对应的编码(整数)。
1 | print(int(1.9)) # 1 |
数据类型
string 字符串
- 以单引号或双引号括起来的任意文本
'abc' "def"
- 字符串不可变
创建
1 | str1 = "Hello World!" |
字符串运算
字符串连接 拼接
1 | str4 = "Hello " |
输出重复字符串
1 | str7 = "good" |
索引取值
- 访问字符串中的某一个字符
- 通过索引下标查找字符,索引从0开始
1 | str8 = "I have a computer" |
字符串截取
切片操作: sname[start:end:step]
1 | str9 = "sunck is a good man!" |
截取字符串的全部字符
1
2str10 = str9[:]
print(str10) # sunck is a good man!从头开始截取
1
2str10 = str9[:5]
print(str10) # sunck从给定下标处开始截取到结尾
1
2str10 = str9[16:]
print(str10) # man!截取倒数第一个字符
1
2str10 = str9[-1]
print(str10) # !创造一个与原字符串顺序相反的字符串
1
2str10 = str9[::-1]
print(str10) # !nam doog a si kcnus逆序截取
1
2str10 = str9[:-5:-3]
print(str10) # !m
判断是否存在
1 | str11 = "sunck is a good man!" |
格式化输出
1 | num = 10 |
转义字符
转换成有特殊含义的字符
\n
换行1
2
3
4
5
6
7
8
9
10print("num = %d\nstr11 = %s\nf = %.10f" % (num, str11, f))
"""
num = 10
str11 = sunck is a good man!
f = 3.1415923635
"""
print("suck \\n is") # suck \n is
print('tom is \'good\' man') # tom is 'good' man
print("tom is 'good' man") # tom is 'good' man如果字符串内有很多换行,用\n写在一行不好阅读
1
2
3
4
5
6
7
8
9
10
11
12
13
14print("good\nman\nhandsome")
"""
good
man
handsome
"""
print("""good
man
handsome""")
"""
good
man
handsome
"""\t
制表符1
print("good\tman") # good man
前面加r为默认不转义
1
print(r"\\t\\") # \\t\\
字符串方法
eval(str)
:将字符串str当成有效的表达式来并返回计算结果1
2
3
4
5
6
7num1 = eval("123")
print(num1) # 123
print(type(num1)) # <class 'int'>
print(eval("+123")) # 123
print(eval("-123")) # -123
print(eval("12+3")) # 15
print(eval("12-3")) # 9len(str)
:返回字符串的长度(字符个数)1
print(len("sunck is a good man")) # 19
str.lower()
: 转换字符串中的大写字母为小写字母1
2str12 = "SUNCK is a good man"
print(str12.lower()) # sunck is a good manstr.upper()
:转换字符串中的小写字母为大写字母1
2
3
4print(str12.upper()) # SUNCK IS A GOOD MAN
print("sunck is a good man".upper()) # SUNCK IS A GOOD MAN
print("原字符串", str12) # 原字符串 SUNCK is a good manstr.swapcase()
: 大写变小写 小写变大写1
print("SuNcK iS a GoOd MaN".swapcase()) # sUnCk Is A gOoD mAn
str.capitalize()
首字母大写 其他字母小写1
print("SuNcK iS a GoOd MaN".capitalize()) # Sunck is a good man
str.title()
: 每个首字母大写 其他字母小写1
print("SuNcK iS a GoOd MaN".title()) # Sunck Is A Good Man
str.center(width,fillchar)
width: 返回一个指定宽度的居中字符串
fillchar: 填充的字符串(默认为空格填充)
1
print("SuNcK iS a GoOd MaN".center(25, "*")) # ***SuNcK iS a GoOd MaN***
str.ljust(width[,fillchar])
width: 返回一个指定宽度的左对齐字符串
fillchar: 填充的字符串(默认为空格填充)
1
print("SuNcK iS a GoOd MaN".ljust(25, "%")) # SuNcK iS a GoOd MaN%%%%%%
str.rjust(width[,fillchar])
width: 返回一个指定宽度的右对齐字符串
fillchar: 填充的字符串(默认为空格填充)
1
print("SuNcK iS a GoOd MaN".rjust(25, "%")) # %%%%%%SuNcK iS a GoOd MaN
str.zfill(width)
返回一个长度为width的字符串,原字符串右对齐,前面补0
1
print("SuNcK iS a GoOd MaN".zfill(25)) # 000000SuNcK iS a GoOd MaN
str.count(str[,start][,end])
返回指定字符串str出现的次数 默认从头到尾
1
print("ha Very Very is a man ,ha ha ha".count("Very", 3, 12)) # 2
str.find(str[,start][,end])
从左向右检测str字符串是否包含在字符串中 默认从头到尾 得到第一次出现返回的下标 没有返回-1
1
2
3print("ha Very Very is a man ,ha ha ha".find("Very")) # 3
print("ha Very Very is a man ,ha ha ha".find("Good")) # -1
print("ha Very Very is a man ,ha ha ha".find("Very", 7)) # 8
str.rfind(str[,start][,end])
从右向左检测str字符串是否包含在字符串中 得到第一次出现返回的下标 没有返回-1
1
2
3print("ha Very Very is a man ,ha ha ha".rfind("Very")) # 8
print("ha Very Very is a man ,ha ha ha".rfind("Good")) # -1
print("ha Very Very is a man ,ha ha ha".rfind("Very", 7)) # 8
str.index(str[,start][,end])
和find()一样 不过str不存在时会报异常
1
print("ha Very Very is a man ,ha ha ha".index("Very")) # 3
str.rindex(str[,start][,end])
和rfind()一样 不过str不存在时会报异常
1
print("ha Very Very is a man ,ha ha ha".rindex("Very")) # 8
lstrip()
: 截取字符串左侧指定的字符 默认为空格1
2print("************ha Very Very is a man ,ha ha ha".lstrip("*"))
# ha Very Very is a man ,ha ha ha
rstrip()
: 截取字符串右侧指定的字符 默认为空格1
2print("ha Very Very is a man ,ha ha ha************".rstrip("*"))
# ha Very Very is a man ,ha ha ha
strip()
截取字符串左右指定的字符 默认为空格1
2
3
4
5
6
7print("***********ha Very Very is a man ,ha ha ha***********".strip("*"))
# ha Very Very is a man ,ha ha ha
str = "a"
print(ord(str)) # 97
print(chr(65)) # A
print("a" == "a") # true字符串比较大小
从第一个字符开始比较 谁的ANSII值大谁就大 如果相等会比较下一个字符串的ANSII值 谁值大谁就大
1
print("ms" == "ms") # \0
split(str="",num)
以str为分隔符截取字符串 指定num 则仅截取num个字符串
1
2
3
4
5
6
7
8str13 = "sunck**is******a***good*man"
list1 = str13.split("*")
print(list1) # ['sunck', '', 'is', '', '', '', '', '', 'a', '', '', 'good', 'man']
c = 0
for s in list1:
if len(s) > 0:
c += 1
print(c) # 5
splitlines([keepends])
按照(‘\r’,’\r\n’,’\n’)分隔keepends == True 会保留换行符
1
2
3
4
5
6str14 = """sunck is a good man!
sunck is a nice man!
sunck is a handsome man!
"""
print(str14.splitlines())
# ['sunck is a good man!', 'sunck is a nice man!', 'sunck is a handsome man!']
join()
: 以指定的字符串分隔符,将seq中的所有元素组合成一个字符串1
2
3list2 = ['sunck', 'is', 'a', 'good', 'man']
str15 = " ".join(list2)
print(str15) # sunck is a good man
max() min()
最大值和最小值1
2
3str16 = "sunck is a good man!z"
print(max(str16)) # z
print("*" + min(str16) + "*") # 是一个空格 * *replace(oldstr,newstr,count)
用newstr替换oldstr,默认是全部替换,如果指定了count,那么只替换前count个
1
2
3
4str17 = "sunck is a good good good man!"
str18 = str17.replace("good", "nice", 1)
print(str17) # sunck is a good good good man!
print(str18) # sunck is a nice good good man!
创建一个字符串映射表
参数:
要转换的字符串 目标字符串
1
2
3
4
5t19 = str.maketrans("ac", "65")
# a--6 c--5
str20 = "sunck is a good man!"
str21 = str20.translate(t19)
print(str21) # sun5k is 6 good m6n!startswith(str,start=0,end=len(str))
在给定范围内判断是否以str开头,没有指定范围,默认为整个字符串
1
2str22 = "sunck is a good man!"
print(str22.startswith("sunck", 5, 16)) # False
endswith(str,start=0,end=len(str))
在给定范围内判断是否以str结尾,没有指定范围,默认为整个字符串
1
2str22 = "sunck is a good man!"
print(str22.endswith("man", 5, 16)) # Falseencode(encoding="utf-8",errors="strict")
编码注意:要与编码时的编码格式一致
str23 = "sunck is a good man凯!"
ignore
忽略错误1
2
3data52 = str23.encode("utf-8", "ignore")
print(data52) # b'sunck is a good man\xe5\x87\xaf!'
print(type(data52)) # <class 'bytes'>解码
1
2str24 = data52.decode("gbk", "ignore")
print(str24) # sunck is a good man鍑!
isalpha()
如果字符串中至少有一个字符且所有字符都是字母返回True,否则返回False
1
2str25 = "sunck is a good man!"
print(str25.isalpha()) # False
isalnum()
如果字符串中至少有一个字符且所有字符都是数字或字母返回True,否则返回False
1
2str26 = "1a2b3"
print(str26.isalnum()) # True
isupper()
如果字符串中至少有一个英文字符且所有字符都是大写的英文字符返回True,否则返回False
1
2
3
4
5print("ABC".isupper()) # True
print("1".isupper()) # False
print("c".isupper()) # False
print("ABC1".isupper()) # True
print("ABC#".isupper()) # True
islower()
如果字符串中至少有一个英文字符且所有字符都是小写的英文字符返回True,否则返回False
1
2
3
4
5print("abc".islower()) # True
print("abcA".islower()) # False
print("1".islower()) # False
print("abc1".islower()) # True
print("abc#".islower()) # True
istitle()
如果字符串是标题化的返回True,否则返回False
1
print("Sunck Is".istitle()) # True
isdigit()
如果字符串中只包含数字字符返回True,否则返回False
1
print("123".isdigit()) # True
isnumeric()
同上如果字符串中只包含数字字符返回True,否则返回False
1
print("1234".isnumeric()) # True
isdecimal()
字符串只包含十进制字符
1
2print("123".isdecimal()) # True
print("123z".isdecimal()) # True
isspace()
如果字符串中只包含空格则返回True,否则返回False
1
2
3
4
5
6print(" ".isspace()) # True
print(" ".isspace()) # True
print("\t".isspace()) # True
print("\n".isspace()) # True
print("\r".isspace()) # True
print("\f".isspace()) True可变字符串
1
2
3
4
5
6
7
8import io
s = "hello world"
sio = io.StringIO(s)
print(sio) # <_io.StringIO object at 0x0000025EBF11A0D8>
print(sio.getvalue()) # hello world
print(sio.seek(7)) # 7
sio.write("a")
print(sio.getvalue()) # hello warld
list 列表
列表:是一种有序的集合
创建列表
格式:列表名 = [列表选项1,列表选项2,列表选项3,......]
创建空列表
1 | list1 = [] |
创建带有元素的列表
1 | list2 = [1, 2, 3, 4, 5, 6, 7, 8, 9] |
元素可以是其他类型
1 | list3 = [1, 2, "sunck", "good", True] |
列表元素的访问
注意不要越界(下标超出了可表示的范围)
格式: 列表名[下标]
1 | list4 = [1, 2, 3, 4, 5] |
替换
1 | list4[2] = 300 |
列表操作
列表组合
1 | list5 = [1, 2, 3] |
列表的重复
1 | list8 = [7, 8, 9] |
判断元素是否在列表中
1 | list9 = [1, 2, 3, 4, 5] |
列表截取
1 | list10 = [1, 2, 3, 4, 5, 6, 7, 8, 9] |
二维列表
1 | list11 = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] |
列表方法
append()
在列表末尾添加一个元素
1 | list12 = [1, 2, 3, 4, 5] |
extend()
在末尾一次性追加另一个列表中的多个值
1 | list13 = [1, 2, 3, 4, 5] |
insert()
在下标处添加一个元素,不覆盖原数据,原数据向后移动一个
1 | list14 = [1, 2, 3, 4, 5] |
pop(x=list[-1])
移除列表中的指定下标处的元素(默认移除最后一个元素)
1 | list15 = [1, 2, 3, 4, 5] |
remove()
移除列表中的某个元素第一个匹配的结果
1 | list16 = [1, 2, 3, 4, 5, 4] |
clear()
清除列表中的所有元素
1 | list17 = [1, 2, 3, 4, 5] |
index()
从列表中找出某个值第一个匹配的索引值
1 | list18 = [1, 2, 3, 4, 5, 3, 4, 5, 6, 7] |
圈定范围
1 | index19 = listA.index(3, 3, 7) |
列表中有多少个元素
1 | list20 = [1, 2, 3, 4, 5] |
max()
获取列表中的最大值
1 | list21 = [1, 2, 3, 4, 5] |
min()
获取列表中的最小值
1 | list22 = [1, 2, 3, 4, 5] |
count()
返回指定元素在列表出现的次数
1 | list23 = [1, 2, 3, 4, 5, 3, 4, 5, 3, 3, 5, 6] |
reverse() 倒序
1 | list25 = [1, 2, 3, 4, 5] |
sort() 排序
1 | list26 = [5, 2, 1, 4, 3] |
拷贝
浅拷贝 引用拷贝
1 | list27 = [1, 2, 3, 4, 5] |
深拷贝 内存拷贝
1 | list29 = [1, 2, 3, 4, 5] |
案例
1 | import copy |
将元组转成列表
1 | list31 = list((1, 2, 3, 4)) |
list 去重
l = [1, 2, 3, 4, 3, 4, 5, 6]
1 | ## 1 |
列表推导式
1 | """ |
zip
将多个列表对应位置的元素组合成为元组,并返回这个zip对象
1 | a = [10, 20, 30] |
tuple 元组
创建空的元组
1 | tuple1 = () |
创建带有元素类型的元组
元组中的元素的类型可以不同
1 | tuple2 = (1, 2, 3, "good", True) |
定义只有一个元素的元组
1 | tuple3 = (1,) |
元组元素的访问
格式:元组名[下标] 下标从0开始
取值
1 | tuple4 = (1, 2, 3, 4, 5) |
元组中的元素不可以修改
1 | tuple5 = (1, 2, 3, 4, [5, 6, 7]) |
删除元组 del
1 | tuple6 = (1, 2, 3) |
元组的操作
1 | t7 = (1, 2, 3) |
元组重复
1 | t10 = (1, 2, 3) |
判断元素是否在元组中
1 | t11 = (1, 2, 3) |
元组的截取
格式:元组名[开始下标:结束下标]
从开始下标开始截取,截取到结束下标之前
1 | t12 = (1, 2, 3, 4, 5, 6, 7, 8, 9) |
二维元组 元素为一维元组
1 | t13 = ((1, 2, 3), (4, 5, 6), (7, 8, 9)) |
元组的方法
len()
返回元组中元素的个数
1 | t14 = (1, 2, 3, 4, 5) |
max()
返回元组中的最大值
1 | t15 = (1, 2, 3, 4, 5) |
min()
返回元组中的最小值
1 | t16 = (1, 2, 3, 4, 5) |
将列表转成元组 tuple()
1 | list1 = [1, 2, 3] |
元组的遍历
1 | for x in (1, 2, 3, 4, 5): |
元组推导式
1 | a = [1, 2, 3, 4, 5, 6, 7, 8] |
dict 字典
使用键-值(key-value)
存储,具有极快的查找速度
注意:字典是无序的
key的特性:
- 字典中的key必须唯一
- key必须是不可变对象
- 字符串、整数等都是不可变的,可以作为key
- list是可变的,不能作为key
创建字典
空字典 dict = {}
1 | dict1 = {"tom": 60, "lilei": 70} |
fromkeys函数
使用给定的键建立新的字典,键默认对应的值为None
1 | d = dict.fromkeys(['one', 'two', 'three']) |
通过zip()创建字典对象
1 | k = ['name','age','job'] |
元素的访问
获取
字典名[key] 或 get
1 | print(dict1["tom"]) # 60 |
添加
1 | dict1["hanmeimei"] = 99 |
因为一个key对应一个value,所以多次对一个key的value赋值,其实就是修改值
1 | dict1["lilei"] = 80 |
删除
pop
1 | dict1.pop("tom") |
popitem 移出字典中的最后一项
1 | dict1.popitem() |
遍历
1 | for key in dict1: |
字典推导式
大小写key合并
1 | mcase = {'a': 10, 'b': 34, 'A': 7, 'Z': 3} |
快速更换key和value
1 | mcase = {'a': 10, 'b': 34} |
和list比较
- 查找和插入的速度极快,不会随着key-value的增加而变慢
- 需要占用大量的内存,内存浪费多
list
- 查找和插入会随着数据量的增加而变慢
- 占用空间小,浪费内存少
1 | w = input("请输入一个字符串:") |
set 集合
set: 类似dict,是一组key的集合,不存储value
本质:无序和无重复元素的集合
创建
创建set需要一个list或者tuple或者dict作为输入集合
重复元素在set中会自动被过滤
1 | s1 = set([1, 2, 3, 4, 5, 5, 4, 3]) |
添加
1 | s4 = set([1, 2, 3, 4, 5]) |
插入整个list tuple 字符串 打碎插入
1 | s5 = set([1, 2, 3, 4, 5]) |
删除
1 | s6 = set([1, 2, 3, 4, 5]) |
遍历
1 | s7 = set([1, 2, 3, 4, 5]) |
set没有索引
1 | print(s7[3]) # 会报错 |
enumerate
1 | for index, data in enumerate(s7): |
基本运算
1 | s8 = set([1, 2, 3]) |
交集 &
1 | a1 = s8 & s9 |
并集 |
1 | a2 = s8 | s9 |
差集 -
1 | a3 = s8 - s9 |
对称差运算 ^
1 | a4 = s8 ^ s9 |
集合推导式
1 | squared = {x**2 for x in [1, 1, 2]} |
布尔值与空值
布尔值:True False
1 | b1 = True |
空值:None 不能理解为0
1 | n = None |
数据类型的类型转换
1 | ## list-->set |
运算符与表达式
算数运算符
1 | + - * / % ** // |
1 | num1 = 5 |
赋值运算符 =
赋值运算表达式 : 变量 = 表达式
1 | num3 = 10 |
复合运算符
1 | += a += b a = a + b |
位运算符
按位与
&
按位与运算符- 位数都为1 结果为1 否则为0
1 | print(5 & 7) # 5 |
按位或
|
按位或运算符有一个位数为1 结果为1 否则为0
1 | print(5 | 7) # 7 |
按位异或
^
按位异或运算符- 二进制两位相异是结果为1
1 | print(5 ^ 7) # 2 |
位取反
~
按位取反运算符- 每个二进制数据位取反,1变0,0变1
1 | print(~5) # -6 |
左移运算符
<<
左移运算符各二进制位左移动若干位 由<<右侧数字决定 高位丢弃 低位补0
1 | print(2 << 2) # |
右移运算符
>>
右移运算符- 各二进制位右移动若干位 由
>>
右侧数字决定
1 | print(2 >> 2) # 0 |
关系运算符
1 | 关系运算符 |
逻辑运算符
逻辑与 and
- 逻辑与运算表达式 表达式1 and 表达式2
- 有一个为假就为假
1 | num13 = 10 |
短路原则
表达式1 and 表达式2 and 表达式3 and …… and 表达式n
逻辑或 or
- 逻辑或运算表达式 表达式1 or 表达式2
- 有一个为真就为真
1 | num15 = 0 |
表达式1 or 表达式2 or 表达式3 or …… or 表达式n
逻辑非 not
1 | if not 0: |
成员运算符
in
如果在指定的序列中找到值返回True,否则返回Falsenot in
如果在指定的序列中没有找到值返回True,否则返回False
身份运算符
is
判断两个标识符是不是引用同一个对象is not
判断两个标识符是不是引用不同的对象
运算符优先级
1 | ** |
条件控制语句
if 语句
1 | if 语句 |
1 | num5 = 20 |
if-else
1 | if 语句 |
1 | age = int(input("请输入一个年龄:")) |
while 语句
1 | while 语句: |
1 | num = 1 |
死循环:表达式永远为真
1 | while 1: |
1 | while else 语句: |
1 | a = 1 |
for 语句
1 | for 语句 |
1 | for i in [1, 2, 3, 4, 5]: |
range
range([start,]end[,step])
列表生成器
- start默认为0,step默认为1
- 功能:生成数列
1 | range(101)可以产生一个0到100的整数序列。 |
1 | a = range(10) |
enumerate
同时遍历下标和元素
1 | index = 0 |
前100项的和
1 | sum = 0 |
break 语句
作用:跳出for和while循环
注意:只能跳出距离他最近的那一层循环
1 | for i in range(10): |
continue 语句
作用:跳过当前循环中的剩余语句
注意:跳过距离最近的循环
1 | for i in range(10): |
迭代器基础
可迭代对象
: 可以直接作用于for循环的对象统称为可迭代对象 、(Iterable) 可以用isinstance()去判断一个对象是否是Iterable对象
可以直接作用于for的数据类型一般分为两种
- 集合数据类型,如
list、tuple、dict、set、string
- 是generator,包括生成器和带yield的generator function
1 | from collections.abc import Iterable |
迭代器
:不但可以作用于for循环,还可以被next函数不断调用并返回下一个值,直到最后抛出一个StopIteration错误表示无法继续返回下一个值
可以被next()函数调用并不断返回下一个值的对象称为迭代器(Iterator)
可以使用isinstance()函数判断一个对象是否是Iterator对象
1 | print(isinstance((), Iterator)) # False |
案例
- iter(func,sentinel)
如果是传递两个参数给 iter() ,它会重复地调用 func ,直到迭代器的下个值等于sentinel
1 | endstr = "end" |
函数编程
函数基础
函数概述
函数
:就是完成特定功能的代码块本质
:就是对代码的封装格式
:
1 | def 函数名([参数1],[参数2]....[参数n]): |
- def:函数代码块以def关键字开始:
- 函数名:遵循标识符规则
函数的调用
- 格式:函数名(参数列表)
- 函数名:是要使用的功能的函数名字
- 参数列表:函数的调用者给函数传递的信息,如果没有参数,小括号也不能省略
函数调用的本质
:实参给形参赋值的过程
1 | # 函数也是一种数据类型 |
函数的参数
函数(无参无返回值)
1
2
3
4
5
6def myPrint1():
print("Hello world")
print("Hello new world")
print("Hello old world")
myPrint1()形参(形式参数):定义函数时小括号中的变量,本质是变量
参数必须按顺序传递,个数目前要对应
1
2def myPrint2(str, age):
print(str, age)实参(实际参数):调用函数时给函数传递的数据,本质是值
1
myPrint2("Hello world", 18)
函数的返回值
1 | def mySum(num1, num2): |
参数传递
值传递
:传递不可变类型
string、tuple、number是不可变的
1 | def fun1(num): |
引用传递
:传递可变类型
list、dict、set是可变的
1 | def fun2(lis): |
关键字参数
概念:允许函数调用时参数的顺序与定义时不一致
1 | def myPrint(str, age): |
默认参数
概念:调用函数时,如果没有传递参数,则使用默认参数
1 | # 如果以后要用默认参数,最好将默认参数放到最后 |
不定长参数
概念:能处理比定义时更多的参数
*parameter
1 | # *parameter |
**parameter
1 | # **parameter |
匿名函数
概念:不使用def这样的语句定义函数,使用lambda来创建匿名函数
特点:
- lambda只是一个表达式,函数体比def简单
- lambda的主体是一个表达式,而不是代码块,仅仅只能在lambda表达式中封装简单的逻辑
- lambda函数有自己的命名空间,且不能访问自由参数列表之外的或全局命名空间的参数
- 虽然lambda是一个表达式且看起来只能写一行,与C/C++内联函数不同
格式:lambda 参数1,参数2,……,参数n:expression(表达式)
1 | sum = lambda num1, num2: num1 + num2 |
作用域
作用域:变量可以使用的范围
程序的变量并不是在所有位置都使用的,访问的权限决定于变量的在哪里赋值的
作用域: L_E_G_B
- 局部作用域
- 函数作用域
- 全局作用域
- 内建作用域
nonlocal
用来声明外层的局部变量global
用来声明全局变量
1 | # 局部作用域 |
偏函数
1 | import functools |