🗒️Python

Python 函数的基本介绍

• 什么是函数？ 函数是一段可以直接被另外一段程序或代码引用的程序或代码，也叫做子程序，方法.
• 可重复使用
• 可互相调用

• 函数的目的
• 为了代码段的复用

• 在Python中如何定义一个函数？

• 函数的组成
• 参数列表
• 必需参数 当前参数必须按顺序传入
• 关键字参数 根据关键字参数传参可以无视顺序
• 默认参数
• 不定长参数 在装饰器中会大量应用 可以接受任意长度的参数.
• 代表了省略，省略了参数tuple（元组）
• * 省略了关键字参数dict（字典）
• 函数体 函数中的逻辑体
• 返回值
默认返回 None

Python 运算符

• 算术运算
• 加法 +
• 减法 -
• 乘法 *
• 除 /
• 整除 //
• 取余数 %
• x 的 y 次幂 x ** y
• 开方（没有提供直接的运算符） x ** (1/2)

• 赋值运算 通过 = 赋值 a=1 ```

• 比较运算 比较的是两个对象的字面值，字面值暂时可以简单地理解为输出值
• <
• <=
• \=
• \== 等于
• != 不等于

• 标识号比较运算 比较两个变量的内存地址
• is
• is not
 
• 赋值类型为 str，int 时考虑 Python 常量池 内存地址是一样的，中文不在常量池当中```null a=“test_1” b=“test_1” id(a) Out[6]: 2135370818480 id(b) Out[7]: 2135370818480 a is b Out[8]: True
a = ‘你好’ b = ‘你好’ id(a) Out[12]: 2135370954384 id(b) Out[13]: 2135370954768 a is b Out[11]: False

• 成员运算判断元素是指在当前序列当中
• in```null a=[1,2,3] 1 in a Out[15]: True b =[1,2] b in a Out[17]: False
• not in

• 布尔运算 判断当前语句的结果是 True 还是 False
• and 只有两边都是 True 才返回 True
• or 两边表达式有一个 True 返回的结果为 True
• 短路 表达式 A or 表达式 B 当表达式 A 为 True 时，表达式 B 就不会运行

• 逻辑取反 not

• 位运算 属于二进制运算
• ~
• ^
• <<
• &
• |

位运算与运算符优先级

• 自定义优先级 如果不确定优先级，出于可读性和避免未知的 BUG，我们都应该用（）来自定义优先级
• 通过（） (not b and c) or (d and e)

字符串和字节序列及编码解码问题

字符串（字符序列）和字节序列

• 字符
• 由于历史原因，将字符定义为 unicode 字符还不够准确，但是未来字符的定义一定是 unicode 字符

• 字节 字符的二进制表现形式

• 码位 计算机显示的实际上是码位

• 编码
• 字节序列（bytes）-> 字符序列（string）–解码（decode）```null len(‘\u4f60\u597d’) Out[6]: 2 b=“你好”.encode(“utf-8”) b Out[13]: b’\xe4\xbd\xa0\xe5\xa5\xbd’
• 字符序列（string）-> 字节序列（bytes）–编码（encode）```null b.decode(“utf”) Out[14]: ‘你好’

• 编码错误
• 乱码与混合码，通常是人为的错误，两种不同的编码方式，在一种编码方式下进行译码
• 检查编码 没有办法通过字节序列来得出编码格式，都是统计学来预估当前的编码 ``` bash b = “你”.encode(“utf-8”) + “好”.encode(“gbk”) b Out[5]: b’\xe4\xbd\xa0\xba\xc3’
b.decode(“utf-8”) Traceback (most recent call last):```null File “C:\ProgramData\Anaconda3\lib\site-packages\IPython\core\interactiveshell.py”, line 3437, in run_code exec(code_obj, self.user_global_ns, self.user_ns) File “”, line 1, in b.decode(“utf-8”)
UnicodeDecodeError: ‘gbk’ codec can’t decode byte 0xc3 in position 4: incomplete multibyte sequence 安装 chardet pip install chardet 导入 charet import chardet chardet.detect(b) Out[11]: {‘encoding’: ‘ISO-8859-1’, ‘confidence’: 0.73, ‘language’: ‘’} #confience 表示精度，一般在 0.9 相当准确了 chardet.detect(“你”.encode(“utf-8”)) #可以看到此编码不太准确，所以仅供参考 Out[13]: {‘encoding’: ‘ISO-8859-1’, ‘confidence’: 0.73, ‘language’: ‘’} chardet.detect(“你好”.encode(“utf-8”)) Out[14]: {‘encoding’: ‘utf-8’, ‘confidence’: 0.7525, ‘language’: ‘’} ```
• 解决乱码和混合编码
• 忽略错误编码 ```null b_2=“你好”.encode(“utf-8”) + “啊”.encode(“gbk”) b_2.decode(“utf-8”,errors=‘ignore’) Out[18]: ‘你好’
• 利用鬼符来替换，特殊字符来替换，表示知道当前错误编码 ```null b_2.decode(“utf-8”,errors=‘replace’) Out[21]: ‘你好��’

• Create(创建)
• 不可变的数据类型 ```null a=“a” id(a) Out[23]: 1809422010288 a=a+“b” id(a) Out[25]: 1809520718768
• +=
• Retrieve(检索)
• 根据索引 获取字符在计算机语言当中，索引值是从 0 开始计数
• find 和 index(获取目录字符的索引值)
• startwith 和 endwith，从头 / 尾进行匹配
• UPDATE(更新)
• replace(替换)，返回的是新的字符串，全局替换```null a=“hello werld, hello werld” a.replace(“wer”,“wor”) Out[48]: ‘hello world, hello world’
• split(分割)```null a=“<>, <>, <<c++>>”a.split(“,”) Out[50]: [‘<>’, ‘java<< >>’,c’]
• join(拼接)```null b = a.split(“,”) “,”.join(b) Out[53]: ‘<>, <>, <<c++>>’
• DELETE(删除)```null a =“hello, world” a Out[55]: ‘hello, world’ a.strip() Out[56]: ‘hello, world’
• lstrip 和 rstrip 删除前后空格字符```null a.lstrip() Out[60]: ‘hello, world’ a.rstrip() Out[61]: ‘hello, world’

字符串的输出和输入

• 保存到文件 ```null
output=open(“output.txt”,“w”,encoding=“utf-8”) context=“hello, world”
output.write(context)
output.close()

• 读取文件 ```null input = open(“output.txt”, “r”, encoding=“utf-8”) content = input.read() print(content) content_2 = input.read() print(content_2)

• 追加文件 ```null output = open(“output.txt”, “a”, encoding=“utf-8”) context = “\nhello, python” output.write(context) output.close()

字符串的格式化输出

• format
• 按传入参数默认顺序 ```null a=“ping” b=“pong” print(“play pingpong: {}, {}”.format(a, b)) play pingpong: ping, pong
• 按指定参数索引，达到到重复性输出 ```null print(“play pingpong: {0}, {1}, {0}, {1}”.format(a, b)) play pingpong: ping, pong, ping, pong
• 关键词参数 ```null print(“play pingpong: {a}, {b}, {a}, {b}”.format(a=‘ping’, b=‘pong’)) play pingpong: ping, pong, ping, pong
• 推荐使用此方法，这样可读性更好，但仅能在 3.6 版本之上使用```null print(f“play pingpong: {a}, {b}”)
• 小数的表示 ```null 2 表示 保留两位 f 表示 float print(“{:.2f}”.format(3.141592)) 3.14

• %```null “playing %s %s” % (“ping”,“pong”) Out[3]: ‘playing ping pong’

变量与引用

了解变量和引用

• 变量 简单来说指向一个实体

• 引用 简单来说指向同一个内存地址

基础数据结构的 CRUD 操作

• List(列表)list 中存的元素是引用
• create(增加)
• append 末尾添加元素
• 和 +=拼接两个列表，返回一个新的列表 ```null l1=[‘a’] l2=[‘b’] l3=l1+l2 id(l1) Out[19]: 1184852612864 id(l2) Out[20]: 1184852093440 id(l3) Out[21]: 1184852614400 l1 Out[22]: [‘a’] l2 Out[23]: [‘b’] l3 Out[24]: [‘a’, ‘b’]+= a='a' id(a) Out[28]: 1184775915440 a+='b' a Out[30]: 'ab' id(a) Out[31]: 1184869746800 l=['a'] id(l) Out[33]: 1184852815424 l+=['b'] id(l) Out[35]: 1184852815424 l Out[36]: ['a', 'b']和 *= a='a' id(a) Out[38]: 1184775915440 l=[a]*10 id(l[0]) Out[40]: 1184775915440 id(l[9]) Out[41]: 1184775915440 l Out[42]: ['a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a'] 赋值语句之后，a已经是一个新的对象，可以看到内存地址改变了 a='b' id(a) Out[44]: 1184775821808 l Out[45]: ['a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a', 'a']insert 指定位置添加元素 l=["a"] l.insert(0,'b') l Out[48]: ['b', 'a'] l.insert(10,'z') l Out[50]: ['b', 'a', 'z']
• Retrieve(检索)
• 索引取值，所有序列都支持索引取值
• 切片 ```null your_list[start:end:step]
取一段区间 your_list[start:end]
取最后一个值 your_list[-1] 此值会少 1 位 your_list[len(your_list)]
间隔 步长 your_list[1:10:2] 取 1 到 10 的基数
l=list(range(20)) l Out[56]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19] l[0:10] Out[57]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] l[11:-1] Out[62]: [11, 12, 13, 14, 15, 16, 17, 18] l[11:len(l)] Out[63]: [11, 12, 13, 14, 15, 16, 17, 18, 19] l[-1] Out[64]: 19
l[1:10:2] Out[65]: [1, 3, 5, 7, 9]
• index```null l=[‘a’,‘b’,‘c’] l Out[68]: [‘a’, ‘b’, ‘c’] l.index(‘b’) Out[70]: 1
在值为 b 的插入一个元素，查找下标在插入 l.insert(l.index(‘b’),‘test’) l Out[72]: [‘a’, ‘test’, ‘b’, ‘c’]
• Update(更新)
• 索引赋值 ```null your_list[下标值]=‘新值’
l Out[73]: [‘a’, ‘test’, ‘b’, ‘c’] id(l) Out[74]: 1184869994688 l[0]=“a_1” l[l.index(‘test’)]=“a_2” l Out[78]: [‘a_1’, ‘a_2’, ‘b’, ‘c’] id (l) Out[79]: 1184869994688
• 切片赋值
• DELETE(删除)
• pop() 从末尾删除元素并返回，适用于消息队列 ```null l Out[86]: [‘a’, ‘b’, ‘c’] x=l.pop() x Out[88]: ‘c’ l Out[89]: [‘a’, ‘b’]
• clear() 清除当前列表的元素，不会改变列表的内存地址，若重新赋值，会改变列表的当前地址 ```null l Out[90]: [‘a’, ‘b’] id(l) Out[91]: 1184869994688 l.clear() id(l) Out[93]: 1184869994688 l=[] id(l) Out[95]: 1184870031424
• 排序
• sort 修改本身的元素
• sorted 不修改本身，返回处理结果，排序后返回新列表
• reversed 倒序之后返回新列表
• tuple 不可变的列表
• Create 无
• Retrieve
• 索引取值
• index
• 切片 ```null t=(1,2,3) t.index(1) Out[118]: 0 t[0:1] Out[119]: (1,)
• Update 无
• Delete 无
• dict 字典 CURD
• Create
• 键对值赋值
• update 提供合并字典功能 ```null d={} id(d) Out[122]: 1184870022336 d[‘a’]=1 d2={“b”:2,“c”:3} d.update(d2) d Out[126]: {‘a’: 1, ‘b’: 2, ‘c’: 3} id(d) Out[127]: 1184870022336
• setdefault 如果字典中没有当前 key，那么设置默认值，相当于没有 key，新增并设置默认值 ```null d Out[128]: {‘a’: 1, ‘b’: 2, ‘c’: 3} d.setdefault(‘a’,0) Out[129]: 1 d Out[130]: {‘a’: 1, ‘b’: 2, ‘c’: 3} d.setdefault(‘d’,0) Out[132]: 0 d Out[133]: {‘a’: 1, ‘b’: 2, ‘c’: 3, ‘d’: 0}
• Retrieve
• 键对值访问
• get 键对值访问缺失 key 会报错，而 get 不会，返回 null，且可以指定默认值
• keys() 返回所有的 key
• values() 返回所有的 values
• item() 返回所有键对值
• Update
• 键对值赋值 ```null d Out[158]: {‘a’: 1, ‘b’: 2, ‘c’: 3, ‘d’: 0} d[‘a’]=11 d Out[160]: {‘a’: 11, ‘b’: 2, ‘c’: 3, ‘d’: 0}
• update```null d.update({“b”:22,“c”:33}) d Out[163]: {‘a’: 11, ‘b’: 22, ‘c’: 33, ‘d’: 0}
• Delete
• pop(key) 删除当前元素并返回 value```null d Out[164]: {‘a’: 11, ‘b’: 22, ‘c’: 33, ‘d’: 0} d.pop(‘a’) Out[165]: 11 d Out[166]: {‘b’: 22, ‘c’: 33, ‘d’: 0}
• popitem() 对于人来说无序的，相当于随机返回一个 item```null Out[165]: 11 d Out[166]: {‘b’: 22, ‘c’: 33, ‘d’: 0} d.popitem() Out[167]: (‘d’, 0) d Out[168]: {‘b’: 22, ‘c’: 33}
• clear()```null d.clear() d Out[172]: {}
• set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等
• Create
• add```null s=set() s.add(“a”) s Out[175]: {‘a’}
• Retrieve 检索
• 运算符 in 过滤，成员检测 ```null s Out[179]: {‘a’} ‘a’ in s Out[181]: True
• Update
• update
• union
• Delete
• remove 和 discard discard 缺失元素时不会报错，而 remove 会报错 ```null s Out[193]: {‘a’, ‘b’, ‘c’} s.remove(“a”) s Out[195]: {‘b’, ‘c’} s.discard(“e”) s.remove(“e”) 若值不存在会报错 Traceback (most recent call last): File “C:\ProgramData\Anaconda3\lib\site-packages\IPython\core\interactiveshell.py”, line 3437, in run_code exec(code_obj, self.user_global_ns, self.user_ns) File “”, line 1, in s.remove(“e”) KeyError: ‘e’
• pop() 无序删除并返回元素 删除和返回的无序元素

练习