目录
2、try ... except BaseException as e： else
3、try。。。execept。。else。。。finally（无论出错与否都会执行）
1、输出函数
print（）
1.1、数字：print（520）
1.2、字符串：print（“hello”） print（‘gdgdg’）
1.3、含运算符的表达式：print（3+1）
1.4、输出在文件中:
fd = open("text1.txt", "a+")
print("djhgfjwdhf", file=fd)
fd.close()
1.5、不进行换行：
print("dfsd","sdfsdf","sdfsdfsd")
2、转义字符
\n 换行 \t 四个空格 \r 回车 \b 退一格 \\\\ == \\ \' == ' \" == " 原字符： 不希望字符串中转义字符不起作用， 在字符串前加 r/ R 但是对后一个字符不能是 一个 \ ，两个可以 printf(r"jyfjyfjfg\tjgjhgj")
3.1 二进制与字符编码
unicode 英文、中文 两个字节
utf-8 英文一个字节 、中文3个字节
print(chr(38472))
print(ord("陈"))
3.2标识符和保留字
3.1.1、查看保留字
import keyword
print(keyword.kwlist)
3.1.2、
字母、下划线、数字
不能使用数字开头
严格区分大小写
不能使用保留字
3.3变量定义及使用
id（） 获取地址 type（）获取类型
3.3.1 变量的多次赋值
多次赋值后，变量名会指向新的空间
一、数据类型
4、数据类型
整数 int 浮点型 float 布尔类型 bool
4.1 整数
英文integer ，简写int 可以表示正数 、负数和零 十进制 默认的进制 二进制 以0b开头 八进制 以0o开头 十六进制 以0x开头
4.2浮点类型
浮点存储不精确
导入模块decmal
from decimal import Decimal
print(Decimal("1.1") + Decimal("2.3"))
4.3 布尔类型
Ture 真 =》 1 False 假 =》 0 可以直接当成1、0用
4.4 字符串类型
不可变的字符序列 可以使用 单引号、双引号 、三引号 。前两者必须在一行， str1 = 'nihao' print(str1, type(str1)) str1 = "nihao" print(str1, type(str1)) str1 = '''nihaod fdfsdfd sddddddddddddd\nddddddddsfds''' print(str1, type(str1))
4.5 数据类型转换
name = "zhangsan"
age = 20
print(type(age), type(name))
print("wojiao "+name+"year"+str(age))
str（）转为字符串
int（）转为整型
文字类和小数类字符串，无法转换为整数。浮点类型转换为抹零取整
float（）转为浮点型
文字类无法转换，整数转浮点型，末尾加.0
a = 10
b = 198.2
c = False
print(type(a), type(b), type(c))
print(str(a), str(b), str(c))
print(int(a), int(b), int(c))
print(float(a), float(b), float(c))
5、注释
coding：utf-8 首行表示文件编码存储模式 单行注释：以# 开头 直到换行 多行注释 ：''' ''' 没有赋值变量就是注释
6、输入
input（）
7、运算符
7.1算术运算符
print(1+1) print(1-1) print(1*1) print(11/2) print(11//2) #整除 print(11%2) print(11**2) #11的2次方 print(-9//-4) #整除时，一正一负，向下取整 print(-9//4) #-3 print(9//-4) #-3 #公式：余数= 被除数 -除数*商 print(9%-4) #-3 9 - (-4)*(-3) = -3 print(-9%4) #3 -9 - （4）*（-3） = 3
7.2 赋值运算符
从右向左执行
a = 3+4
链式赋值：a=b=c=3
支持解包赋值: a,b,c=12,5,8
a ,b = 10,20
交换
a,b = b,a
7.3 比较运算符
比较运算的结果就是bool类型，rure或false 比较对象的标识用的是 is a=10 b=10 print(a is b) true liat1 =[11,22,33,44] liat2 =[11,22,33,44] print(liat2==liat1) true print(liat2 is liat1) false 标识不等： is not
7.4布尔运算符
1、and 与
2、or 或
3、not 取反
4、in 在什么里
print("h" in "hello") true
print("s" in "hello") fasle
5、not in
8.1 对象的布尔值
bool（）求布尔值 1、false 2、数值0 3、none 4、空字符串 5、空列表 6、空元组 7、空字典 8、空集合
8.2 结构语句
if 条件表达式 ：
条件执行
if 条件表达式 ：
条件执行1
else：
条件执行2
if 条件表达式1 ：
条件执行1
elif 条件表达式2 ：
条件执行2
代码1 if 条件判断 else 代码2
条件成立 执行代码1 ，否则执行代码2
8.3 pass语句
pass语句，什么都不做。只是一个占位符，用到需要写语句的地方 if ass== “y”： pass else： 在这里是为了不让报错，又保证了语法结构
8.4 循环语句
1、 range（）函数
生成一个整数序列
2、使用的三种方式
range（stop）： 创建一个（0，stop）之间的整数序列，步长为1
range（start，stop）：创建一个（sart，stop）之间的整数序列，步长为1
range（sart，stop，step）：创建一个（sart，stop）之间的整数序列步长为step
3、返回值是一个迭代器对象
while 条件表达式：
条件执行体
for 自定义变量 in 可迭代对象（字符串、序列（range））：
循环体
for ——（下划线） in range（5）
print（“dsfsdf”）
执行五次不关心变量
8.5 else 语句
可以和while for搭配，如果循环中没有break就会执行else。循环正常结束，没有只有break就会执行else。
for itom in range(3):
pwd = input("mima")
if pwd == "8888":
print("success")
break
else:
print("failed")
else:
print("三次密码错误")
a =0
while a<3:
pwd = input("mima\n")
if pwd == "8888":
print("success")
break
else:
print("failed")
a +=1
else:
print("三次密码错误")
9 列表
1、列表可以看成其他语言的数组
2、列表中的元素可以是任意类型
创建：
1、a = [1,"2",2,3]
2、a = list（[1,"2",3,3]）==》内置函数
3、特点
3.1、索引（下标）：
从左到右，从0开始
从右到左，从-1开始
3.2、列表可以存储重复数据
3.3、任意数据类型可以混存
3.4、根据需要自动动态分配和回收内存
4、列表元素的查询
4.1、由元素本身的值在列表中找索引值
list.index("元素") 返回该元素在列表第一次出现的位置索引
lst = ["hello", "wrod", 89, "hello"]
print(lst.index("hello"))
在指定位置查找：在列表[1,4)区间类查找“hello”，并返回索引值
lst = ["hello", "wrod", 89, "hello"]
print(lst.index("hello", 1, 4))
4.2、由索引值找具体元素值
4.2.1 正向索引：列表n个元素，从[0,n-1]，对应具体的元素
4.2.2 反向索引：列表你n个元素，[-n,-1],对应具体元素
4.3 获取多个列表中的元素：切片
4.3.1 列表名[sart:stop:step]
4.3.2 切片结果：源列表片段的拷贝
4.3.3 切片范围：[sart:stop]
4.3.4 step 默认为1
4.3.5 step为正数：
[:stop:step] 切片第一个元素默认为列表第一个元素
[start::step] 切片最后一个元素默认为列表最后一个元素
4.3.6 step为负数
[:stop:step] 切片的第一个元素是列表的最后一个元素
[start::step] 切片最后一个元素是列表第一个元素
list = [12, 34, 56, 51, 63, 72, 656, 8, 86, 9, 89, 8, 7]
print(list[:13])
print(list[-1:-5:-1])
print(list[::-1]) 逆序列表
5、 判断元素是否在列表中存在： in（是否存在） ；not in（是否不存在）
6、遍历列表元素：用for循环
7、列表元素的增加
7.1 向列表末尾添加一个元素：append（）
7.2 向列表末尾至少添加一个元素：两列表相加 或者 extend（）
7.2.1 list.append(list2)：把列表二作为一个元素添加在列表末尾
7.2.2 list+ list2 /list.extend(list2):把列表二拼接到列表1后面
7.3 在列表任意位置添加一个元素：insert（）
list.insert（1，90） 在列表索引值为1 的位置添加90.其他元素自动后移
7.4 在列表任意位置添加至少一个元素 ：切片
list[1:2] = list2
list1 = [1, 2, 3, 4, 5, 6, 7, 8]
list2 = ["11", "22", "33"]
list1[1:1] = list2 在位置1 插入list2，原list1位置1元素不变
print(list1)
list1[0:1] = list2 把0切后插入list1，原list1位置0元素删除
print(list1)
8、列表中删除元素
8.1 remove（）：一次删除一个元素；重复元素只删除第一个；元素不存在会抛出异常（valueerror）
list = [1, 2, 2, 34, 5, 6, 7, 8, 9, 12, 3, 4, 4]
list.remove(2) 删除元素值为2的第一个元素
8.2 pop（）：删除一个指定索引位置的元素；指定索引不存在抛出异常（indexerror）；不指定索引，删除列表中最后一个元素
list = [1, 2, 2, 34, 5, 6, 7, 8, 9, 12, 3, 4, 4]
list.pop(0) 删除索引为0的元素
8.3 切片： 一次至少删除一个元素；会产生一个新的列表对象
list = [1, 2, 2, 34, 5, 6, 7, 8, 9, 12, 3, 4, 4]
list2 = list[1::1] 把索引为1到末尾全切出来形成一个新列表。对于新列表，就是在源列表基础上删除了索引为0的元素
print(list)
print(list2)
方法二：用空列表替代
list[1:3] = []
把[1,3)这之间的两个元素用空列表替换，就删除了原列表索引为1、2的元素
8.4 清楚列表中所有元素：clear（）
8.5 删除列表对象： del（）
9、修改列表元素
通过索引值改：list[0] =89 ;将列表索引为0的位置上数据换成89
10、列表排序
10.1 调用sort（）
list1.sort（） 默认升序排序
list1.sort(reverse=True) 降序
list1.sort(reverse=False) 升序
10.2 调用sorted（）；原列表不变，会产生一个新列表
list1 = [1, 2, 2, 34, 5, 6, 7, 8, 9, 12, 3, 4, 4]
print(list1, id(list1))
list2 = sorted(list1，reverse=False) 产生一个升序新列表
11、 列表生成式
list1 = [i*i for i in range(1, 10)]
list1 = [i for i in range(1, 10)]
12、字典
1、与列表一样是一个可变序列（可以进行增删改查等操作）
2、以键值对的方式存储数据，字典是一个无序的序列
3、创建字典：
3.1 a ={34:12, 341:56};使用花括号
3.2 a =dict（name=“hfh”， age=45）；使用内置函数
4、从字典中获取数据
4.1 字典名[key]；如果字典中没有key 会抛出异常keyerror
4.2 字典名get(key)；如果字典中没有key 不会抛出异常,输出None
get（key，99）；当key不存在时，会返回自己设置的默认值：99
5、key的判断（in ；not in），返回ture 或false
6、删除指定的键值队：del【key】
7、清空字典：字典名clear（）
8、添加一个元素：字典名【新key】 = 具体值
9、修改一个元素：字典名【已存在key】 = 具体值
13、字典的试图操作
1、keys（） 获取字典中所有key ，返回值为dict——keys类型，通过list（）函数转换为列表 2、values（） 获取字典中所有value，返回值为dict——values类型，通过list（）函数转换为列表 3、items（） 获取字典中所有key，value队，返回值为dict——items类型，通过list（）函数转换为列表，每一个元素由元组组成。
14、字典元素的遍历
for i in 字典名 print（i） 打印的是每个key print（字典名【key】）
15、字典的特点
1、字典中的所有元素都是一个key-value队，key不允许重复，value可以重复 2、字典中的元素的无序的 3、字典中的key必须是不可变对象（数字、字符串） 4、字典也可以根据需要动态的伸缩 5、字典会浪费较大的内存，是一种使用空间换时间的数据结构
16、字典生成式
zip（）
由两个列表生成一个字典，items列表元素 作为key， pricen列表元素作为值。两个列表元素个数不一致时，以较少的列表为标准。upper()函数是将字符串变为大写
items = ["freuir", "books", "othras"]
pricen = [56, 78, 23]
d = {i.upper(): j for i, j in zip(items, pricen)}
print(d)
输出结果： {'FREUIR': 56, 'BOOKS': 78, 'OTHRAS': 23}
17、元组
元组是一个不可变序列
不可变序列：字符串、元组。没有增删改的操作
可变序列：列表、字典。可以对序列进行增删改操作，对象地址不发生更改
元组与列表用法相识。列表用【】，元组用（）。列表是可变序列，可以增删改。元组是不可变序列，不可以进行增删改操作。
1、创建
t1 = (12, 34, 455, 5, 65, 65)
t2 = tuple(("we", "ew", 32, 43, 6))
****只含有一个元素的元组，后面有一个逗号
t= （12，）
2、
空列表： lis = 【】 ； lis = list【】
空字典： d = {} ; d=dict{}
空元组： t = () ;t= tuple()
*****************
1、为什么要把元组设计成不可变序列：
对于共享资源的保护可以用锁，保证同一时间只有一个进程操作数据。元组是从另一个方向对共享资源的保护，直接规定元组不可变，多个进程可以查看但是不能修改，这样就保护了共享资源。
2、元组中存储的是对象的引用。
3、不管元组的元素是可变还是不可变，其引用都不可以再去引用其他对象。既，元组确定后，引用不可变。
如果其元素是可变序列，如：列表、字典。虽然不能将当前引用改为其他列表、字典。但是对于可变序列中的内容可以增删改操作。
t = (1, [12, 13], 34)
print(t)
# t[0] = 13 改变引用方向，报错
# t[1] = [12,45] 改变引用方向，报错
# t[1] = 12 改变引用方向，报错
t[1][0] = 234 改变元组元素（列表，可变序列）中的数据。可以
tt[1].append(123) 改变元组元素（列表，可变序列）中的数据。可以
print(t)
18、元组的遍历
t = (1, [12, 13], 34)
for i in t:
print(i)
19、集合
集合是没有value的字典，属于可变序列
创建集合
1、直接使用{}
s = {"jhkj", 78, 90, 90, 78}
print(s)
2、使用range
s2 = set(range(6))
print(s2)
3、把列表转为集合
s3 = set([12, 34, 5, 67, 7])
print(s3)
4、把元组转为集合
s4 = set((1, 2, 34, 4, 5, 6, 76))
print(s4)
5、字符串转为集合
s5 = set("pyton")
print(s5)
6、创建一个空集合，使用set，但是不能直接使用{}创建空集合
s6 = set()
*************集合元素不能重复，和字典中key一样，不能重复
集合元素是无序的
20、集合相关操作
1、集合元素的判断： in ；not in
s = {"sdfs", 34, 78, 32, 54, 12}
print(10 not in s)
2、集合元素新增：
add（）：添加一个元素
update（）：一次至少增加一个元素
s = {"sdfs", 34, 78, 32, 54, 12}
s.add(23)
s.update([23, 454, 5, 45, 4, 565, 65])
s.update({12, 3443, 34})
s.update((12, 23, 34, 3, 54, 5, "ewrr"))
print(s)
3、删除元素
3.1 remove（）：删除一个指定元素
s = {"sdfs", 34, 78, 32, 54, 12}
s.remove(500) 当元素本身不存在，调用remove会抛出异常：keyerror
print(s)
3.2 discard()：删除一个指定元素
s = {"sdfs", 34, 78, 32, 54, 12}
s.discard(599) 当元素本身不存在，不会抛出异常
print(s)
3.3 pop（）：删除一个任意元素，删除谁根本不知道
s = {"sdfs", 34, 78, 32, 54, 12}
s.pop()
print(s)
3.4 clear（） ：清空集合
21、集合间的关系
1、两个集合是否相等： == 或者 ！= 判断
s1 = {1, 2, 3, 4}
s2 = {2, 1, 3, 4, 4}
print(s1 == s2) 输出：Ture，表示s1等于s2
2、判断一个集合是否是另一个集合的子集：isiubset（）
s1 = {1, 2, 3, 4}
s2 = {2, 1, 3, 4, 4}
print(s1.issubset(s2)) 输出：Ture ，表示s1是s2子集
3、一个集合是否是另一个集合的超集 ： issuperset（）
s1 = {1, 2, 3, 4}
s2 = {2, 1, 3, 4, 4}
print(s1.issuperset(s2)) 输出：Ture， 表示 s1是s2的超级
********4、判断两集合是否右交集：isdisjoint（）
s1 = {1, 2, 3, 4}
s2 = {2, 1, 3, 4, 4}
********print(s1.isdisjoint(s2)) 输出fasle， 表示有交集
没有交集为 ture
22、集合间操作
1、求两个集合的交集
s1 = {1, 2, 3, 4}
s2 = {2, 1}
print(s1.intersection(s2))
print(s1 & s2)
2、求两集合的并集
s1 = {1, 2, 3, 4}
s2 = {2, 1}
print(s1.union(s2))
print(s1 | s2)
3、差集
s1 = {1, 2, 3, 4}
s2 = {2, 1}
print(s1.difference(s2)) ===》{3, 4}
print(s2.difference(s1)) ===》set()
4、对称差集
s1 = {1, 2, 3, 4}
s2 = {2, 1}
print(s1.symmetric_difference(s2))
print(s1 ^ s2)
23、集合生成式
lis = [i for i in range(13)]
print(lis)
s = {i for i in range(13)}
print(s)
和列表生成式区别在于，列表用[],集合用{}
24、列表、字典、元组、集合总结
二、字符串
1、字符串的驻留机制
在python中字符串是一个基本数据类型，是一个不可变序列 字符串可以使用 单引号、双引号、三引号定义 a = 'asd' b = "asd" c = '''asd''' print(id(a), id(b), id(c)) a，b，c三个地址相同 仅保留一份相同且不可变的字符串的方法：字符串驻留机制 不同的值被存放在字符串驻留池中，python的驻留机制对相同的字符串只保留一份拷贝。后续创建相同字符串时，不会开辟新空间，而是把该字符串的地址给新创建的变量。 强制驻留
2、字符串常用操作
2.1字符串查找
index（）：查找子串第一次出现位置，如果不存在抛异常：valueerror rindex（）：查找字串最后一次出现位置，如果不存在抛异常：valueerror find（）:查找子串第一次出现位置，如果不存在返回-1 rfind（）:查找字串最后一次出现位置，如果不存在返回-1
2.2、字符串大小写转换
转换后产生新字符串。 1、upper（） 字符串所有字符转为大写， 2、lower（） 字符串所有字符转为小写 3、swapcase（） 字符串所有小写转为大写，所有大写转为小写 4、capitalize（） 把一个字符转为大写，其余转为小写， 5、title（） 把每个单词第一个字符转为大写，每个单词剩余转为小写
2.3 字符串内容对齐操作的方法
1、center（） 居中对齐，第一个参数决定总字节数。总字节数减去字符串本身字节数，再均分。如果参数（总字节数）小于字符串本身字节数，会原样输出。第二个参数为填充字符，不屑默认为空格。 2、ljust（） 左对齐，参数同上 3、rjust（） 右对齐，参数同上 4、zfill（） 右对齐，只有一个参数，总字节数。默认填充0 s = "hello python" print(s.center(20, "*")) print(s.ljust(20)) print(s.rjust(20, "*")) print(s.zfill(20)) 输出： ****hello python**** hello python ********hello python 00000000hello python
2.4 字符串分割
split（） ：从左边开始分割 rsplit（）：从右边开始分割 1、返回值是一个列表 2、默认分割符是空格，可以使用 sep= 指定特定分隔符 3、默认分割完，也可以指定分割此时（maxsplit=） s = "hello python woerld" lst = s.split() print(lst) s1 = "hello |python |woerld" lst1 = s1.split(sep="|") print(lst1) s1 = "hello |python |woerld" lst1 = s1.split(sep="|",maxsplit=1) print(lst1)
2.5 字符串判断方法
isidentifier() 判断指定字符串是不是合法（由字母、数字、下划线组成）的标识符
isspace() 判断字符串是否全部由空白字符组成（回车、换行、水平制表符）
isalpha() 判断指定字符串是否全部由字母组成
isdecimal() 判断指定字符串是否全部由十进制的数字组成
isnumeric() 判断指定字符串是否全部由数字组成
isalnum() 判断指定字符串是否全部由字母和数字组成
s = "hello,pythony"
print(s.isidentifier()) #False
print("hello".isidentifier()) #Ture
print("张三".isidentifier()) #Ture
print("张三_123".isidentifier()) #Ture
print("\t".isspace()) #Ture
print("\n".isspace()) #Ture
print("abc".isalpha()) #Ture
print("张三".isalpha()) #Ture
print("张三1".isalpha()) #False
print("123".isdecimal()) #Ture
print("123四".isdecimal()) #False
print("ⅠⅡ".isdecimal()) #False
print("1234".isnumeric()) #Ture
print("123四".isnumeric()) #Ture
print("ⅠⅡ".isnumeric()) #Ture
print("abc1".isalnum()) #Ture
print("张三123".isalnum()) #Ture
print("asdsaf!".isalnum()) #False
2.6、字符串其它操作
replace():字符串替换。
join()：字符串合并。将列表或元组合并成一个字符串
str1 = "hello python"
print(str1.replace("python", "java"))
str1 = "hello python python python"
print(str1.replace("python", "java", 2))
list1 = ["hello", "java", "python"]
print("|".join(list1))
print("".join(list1))
t =("hello", "java" ,"pthon")
print("".join(t))
print("*".join("python"))
输出：
hello java
hello java java python
hello|java|python
hellojavapython
hellojavapthon
p*y*t*h*o*n
3、字符串比较
运算符：>; >=; <; <=; ==; !=
print("apple" > "app")
print("apple" > "bana")
print(ord("a")) 求a字符的原始值（ascii码值）
print(chr(97)) 求原始值对应的字符
“==” 与 “is” 的区别：
前者比较的是value值是否相等
后者比较的是id（）地址值
3.2、字符串切片操作
字符串是不可变类型，不具备增删改操作。与列表相同切片后都会产生新对象。 s = "hello,python" s1 = s[:5] 没有指定开始，默认开头 s2 = s[6:] 没有指定末尾，默认末尾 print(s1) print(s2) s3 = s1 + "*" +s2 print(s3) print(s[1:5:2]) print(s[::3]) print(s[::2]) print(s[::-1]) 字符串倒置 print(s[-6::1]) 输出： hello python hello*python el hlph hlopto nohtyp,olleh python
3.3 字符串格式化
name = "张三"
age = 25
//1、使用 %
print("姓名：%s,年龄：%d" % (name, age))
//使用format（）
print("我的名字：{0}，今年{1}岁，姓名:{0}".format(name,age))
//使用 f
print(f"我叫{name}，今年{age}岁")
print("%10d" % 98) #宽度为10
print("%.3f" % 3.1415926) #保留3位小数
print("%10.3f" % 3.1415926) #宽度为10，保留3位小数
print("{0}".format(3.1415926))
print("{0:.3}".format(3.1415926)) #.3 表示一共3位
print("{0:10.3f}".format(3.1415926)) #.3 表示保留3位小数，宽度10位
3.4 字符串编码转换
网络中传输需要转化为byte字节 编码：将字符串转换为二进制数据（bytes） 解码：将bytes类型的数据转换成文本字符串类型 s= "天涯共此时" #编码 print(s.encode(encoding="GBK")) #一个中文字符占两个字节 print(s.encode(encoding="UTF-8"))#一个中文字符占3个字节 #解码 byte =s.encode(encoding="GBK") print(byte.decode(encoding="GBK")) byte =s.encode(encoding="UTF-8") print(byte.decode(encoding="UTF-8"))
三、函数
1、函数的定义与调用
1、定义：
def 函数名 （输入参数）：
函数体
return xxx
def cale(a, b):
c = a + b
return c
s = cale(10, 29)
print(s)
2、函数的参数传递
1、位置实参：根据形参对应的位置进行实参传递
s = cale(10, 29)
2、关键字实参：根据形参名称进行实参传递
s = cale(b=10, a=29)
函数调用时，形参为实参的引用。
不可变对象在函数内被改变，不会影响到实参。
可变对象在函数内被改变，会影响到实参。
3、函数的返回值
函数返回多个值时，返回值为元组类型。 def fun(num): odd = [] even = [] for i in num: if i % 2: odd.append(i) else: even.append(i) return odd, even print(fun([10, 29, 34, 23, 44, 53, 55]))
4、函数的默认参数
1、默认参数
def func(a, b=100):
print(a, b)
func(12)
2、个数可变的位置参数：一个函数只有一个
2.1、在函数定义时，不清楚传递参数个数，使用可变的位置参数
2.2、使用*定义个数可变的位置参数
2.3、结果为一个元组
def fun(*args):
print(args)
print(args[0])
fun(10)
fun(12, 13)
fun(13, 24, 56)
输出：
(10,)
10
(12, 13)
12
(13, 24, 56)
13
3、个数可变的关键字形参：一个函数只有一个
3.1、定义函数时，无法事先确定传递的关键字实参个数，可以使用可变的关键字形参
3.2、使用**定义个数可变的关键字形参
3.3、结果为一个字典
def fun(**args):
print(args)
fun(a=10)
fun(a=12, b=13)
fun(a=-13, b=24, c=56)
输出：
{'a': 10}
{'a': 12, 'b': 13}
{'a': -13, 'b': 24, 'c': 56}
4、两者同时出现时，个数可变的位置参数必须在个数可变关键字参数前
def fun(*asd,**args ):
print(args)
print(asd)
fun(232, a=10)
fun("qww",a=12, b=13)
fun(a=-13, b=24, c=56)
5、参数总节
1、函数调用时：
def fun(a, b, c):
print(a, b, c)
fun(10, 20, 30) # 位置传参
lis = [11, 22, 33]
fun(*lis) # 函数调用时，将列表每个元素都转化为位置实参传入
fun(a=100, b=200, c=300) # 关键字传参
dic = {"a": 111, "b": 222, "c": 333}
fun(**dic) # 在函数调用时，将字典中的键值对转化为关键字实参传入
2、函数定义时：
def fun(a, b=13): # 在函数定义处，给b赋值，则b为默认形参
print(a, b)
def fun2(*args): # 个数可变的位置形参
print(args)
pass
def fun3(**args): # 个数可变的关键字形参
print(args)
pass
fun2(13, 12, 3, 4, 4)
fun3(q=13, a=32, bc=34)
输出：
(13, 12, 3, 4, 4)
{'q': 13, 'a': 32, 'bc': 34}
3、
def fun4(a, b, *, c, d): # *之后的形参，在调用时，只能使用关键字传参，否则报错
print(a)
print(b)
print(c)
print(d)
return
fun4(13, 23, c=23, d=45)
4、其它组合方式
def fun5(a, b, *, c, d, **argc):
pass
def fun6(*args, **argc):
pass
def fun7(a, b=10, *argc, **argss):
pass
6、变量的作用域
1、局部变量：
在函数内部定义并使用的变量，只能在函数内部有效，局部变量使用global声明，这个变量就会成为全局变量。
2、全局变量：
函数体外定义的变量，可作用于函数内外
7、递归函数
def func(n): if n == 1: return 1 else: return n + func(n - 1) print(func(100))
四、异常
1、try.....except 异常类型：
try:
a = int(input("输入"))
b = int(input("输入"))
re = a / b
print(re)
except ZeroDivisionError:
print("除数不为0")
except ValueError:
print("只能输入数字串")
print("程序结束")
2、try ... except BaseException as e： else
try:
a = int(input("输入"))
b = int(input("输入"))
re = a / b
except BaseException as e:
print(e)
else:
print(re)
print("程序结束")
3、try。。。execept。。else。。。finally（无论出错与否都会执行）
try:
a = int(input("输入"))
b = int(input("输入"))
re = a / b
except BaseException as e:
print(e)
else:
print(re)
finally:
print("程序结束")
4、常见异常类型
1、ZeroDivisionError：除数为零的异常：
print(10/0)
2、IndexError：序列中没有指定索引
list1 = [11,22,33,44]
print(list1[6])
3、KeyError：映射中没有这个键
dic = {"name": 23, 12: 23}
print(dic["sd"])
4、NameError： 为申明/初始化对象
print(num)
5、SyntaxError：语法错误
int a=13
6、 ValueError：传入无效参数
a = int("dsf")
5、Traceback模块
import traceback
try:
print("___________")
print(1 / 0)
except:
traceback.print_exc()
print("错误")
五、面向对象思想
1、定义类
class 类名：
内容
1、类的组成：
1.1、类的属性
1.2、实例方法
1.3、静态方法
1.4、类方法
class Student: # student类名,一个或者多个单词构成，每个单词首字母大写
native_pac = "四川" # 直接写在类里的变量，称为类属性
def __int__(self, name, age):
self.name = name
self.age = age
def fu1(self): # 实例方法
print("方法")
return
@staticmethod # 使用staticcmethod 修饰的方法
def func2(): # 静态方法中不能由self
print("静态方法")
@classmethod
def func2(cls):
print("类方法") # 使用classmethod修饰的方法
2、创建对象
class Student: # student类名,一个或者多个单词构成，每个单词首字母大写
native_pac = "四川" # 直接写在类里的变量，称为类属性
def __init__(self, name, age):
self.name = name
self.age = age
def fu1(self): # 实例方法
print("方法")
return
@staticmethod # 使用staticcmethod 修饰的方法
def func2(): # 静态方法中不能由self
print("静态方法")
@classmethod
def func3(cls):
print("类方法") # 使用classmethod修饰的方法
stu1 = Student("we", 45) # 创建一个实例
print("id", id(stu1))
print("type", type(stu1))
print("stu1", stu1)
print(stu1.name, stu1.age)
//实例方法调用方式
stu1.fu1()
Student.fu1(stu1)
stu1.func2()
stu1.func3()
3、类属性、类方法、静态方法
类属性：类中方法外的变量称为类属性，被该类所有对象所共享 类方法：使用clssmethod修饰的方法，使用类名直接访问 静态方法：使用staticmethod修饰的方法，使用类名直接访问
4、动态绑定属性和方法
class Student:
def __init__(self, name, age):
self.name = name
self.age = age
def cat(self):
print(self.name + "吃饭")
stu1 = Student("张三", 20)
stu2 = Student("李四", 30)
print(id(stu1))
print(id(stu2))
stu2.gender = "女" #为stu2再绑定一个属性
print(stu2.name, stu2.age, stu2.gender)
name和age 是stu1与stu2都有的，而后期绑定的，只有stu2有
动态绑定方法：
def show（）：
pass
stu2.show = show（动态绑定方法）
5、面向对象特征
1、封装
python中没有专门修饰符用于属性私有，如果该属性不希望在类对象外部被访问，前面加两个“—”。但是也有办法访问到：_类名__属性名 访问
class Student:
def __init__(self, name, age):
self.name = name
self.__age = age
def cat(self):
print(self.name + "吃饭")
stu1 = Student("张三", 20)
# print(stu1.__age) #报错
# print(dir(stu1)) 类中查看属性、方法 有：_Student__age
print(stu1._Student__age)
2、继承：
提高代码复用性
3、多态、
提高程序的可扩展性和可维护性
6、继承
如果一个类没有继承任何类，则默认继承object类
定义子类时，必须在其构造函数中调用父类的构造函数
class 子类类名（父类1 ， 父类2）：
pass
class Person(object):
def __init__(self, name, age):
self.name = name
self.age = age
def info(self):
print(self.name, self.age)
class Student(Person):
def __init__(self, name, age, stu_no):
super().__init__(name, age)
self.stu_no = stu_no
class Teacher(Person):
def __init__(self, name, age, teachyear):
super().__init__(name, age)
self.teachyear = teachyear
stu = Student("张三", 23, 89)
techer = Teacher("李四", 21, 13)
stu.info()
techer.info()
多继承：
class A(object):
pass
class B(object):
pass
class C(A, B):
pass
7、方法重写
class Person(object):
def __init__(self, name, age):
self.name = name
self.age = age
def info(self):
print(self.name, self.age)
class Student(Person):
def __init__(self, name, age, stu_no):
super().__init__(name, age)
self.stu_no = stu_no
def info(self): //重写info
super().info()//调用基类info
print(self.name, self.age, self.stu_no)
class Teacher(Person):
def __init__(self, name, age, teachyear):
super().__init__(name, age)
self.teachyear = teachyear
def info(self): //重写info
super().info()//调用基类info
print(self.name, self.age, self.teachyear)
stu = Student("张三", 23, 89)
techer = Teacher("李四", 21, 13)
stu.info()
techer.info()
8、objectlei
1、所有的类都有object类的属性和方法
2、内置函数dir（）可以查看指定对象的所有属性
3、object类有一个_str_（）方法，用于返回一个对于“对象描述”，对应于内置函数str（）经常用于print（）方法，帮我们查看对象的信息，所以我们经常会对_str_()进行重写
class Student:
pass
stu = Student()
print(dir(stu))
lass Student:
def __init__(self, name, age):
self.name = name
self.age = age
def __str__(self):
return "我的名字是{0}，今年{1}岁".format(self.name, self.age)
stu = Student("zhangsan",13)
print(dir(stu))
print(stu) ===》我的名字是zhangsan，今年13岁；默认调用 def __str__(self):
9、多态
class Animal(object):
def eat(self):
print("动物会吃")
class Dog(Animal):
def eat(self):
print("狗吃骨头")
class Cat(Animal):
def eat(self):
print("猫吃鱼")
class Persion:
def eat(self):
print("人吃五谷")
def func(obj):
obj.eat()
func(Animal())
func(Dog())
func(Cat())
func(Persion())
10、特殊的方法和特殊属性
10.1 特殊属性
print(dir(object))
class A:
pass
t
class B:
pass
class C(A, B):
def __init__(self, nema,age):
self.name = nema
self.age = age
x = C("jack",12)
# print(x.__dict__) 实例对象的属性字典
# print(x.__class__) 输出对象所属的类
# print(C.__bases__) c类的父类类型元素
# print(C.__base__) 多继承时，谁写前面，输出谁
# print(C.__mro__) 查看类的层次结构
# print(A.__subclasses__()) 子类列表
10.2 特殊方法
1、add
a = 20
b = 100
c = a + b
c = a.__add__(b)
print(c)
class A:
def __init__(self, name):
self.name = name
def __add__(self, other):
return self.name + other.name
def __len__(self):
return len(self.name)
stu1 = A("aa")
stu2 = A("bb")
print(stu1 + stu2)
print(stu1.__add__(stu2))
2、——new——
10.3 类的浅拷贝、深拷贝
python拷贝一般都是浅拷贝，共用一片空间。
class A:
def __init__(self, name):
self.name = name
disk = A("ddd")
import copy
com = copy.copy(disk)
print(id(disk), id(disk.name), disk.name)
print(id(com), id(com.name), disk.name)
深拷贝：
com1 = copy.deepcopy(disk)
print(id(disk), id(disk.name), disk.name)
print(id(com1), id(com1.name), com1.name)
六、模块
一个。 .py就是一个模块
1、模块导入
import 模块名称 [as 别名] import math //导入整个库 print(id(math)) print(type(math)) print(math) print(dir(math)) //查看库中方法 print(math.pow(2, 3)) //2的3次方 print(math.ceil(9.011))//求最近最大整数 print(math.floor(9.9999))//求最近最小整数 from 模块名称 import 函数/变量/ from math import pi //只是导入math中pi方法 print(pi)
2、python中的包
包含——init——.py的文件的目录叫包
目录里不包含——init——.py文件
导入包
import demo1.text1 as a //导入demo1包中text1模块 取别名a
print(a.b) //使用导入模块中的变量
导入带有包的模块时注意事项：
import 只能跟报名+模块名
使用 from 可以导入包、模块、函数、变量
3、常用的内置模块
import sys 跳转到sys库可以看解析器位置
print(sys.getsizeof(24)) 变量大小
print(sys.getsizeof(45))
print(sys.getsizeof(True))
print(sys.getsizeof(False))
import time
print(time.time()) //秒
print(time.localtime(time.time())) //转为本地时间
import urllib.request （urllib包）
print(urllib.request.urlopen("http://www.baidu.com").read())
4、第三方模块的安装及使用
安装：pip install 模块名 使用：import 模块名
七文件操作
python的解析器使用的是unicode编码 .py的文件在磁盘上使用的是uft-8编码
8、with语句
with open("ad.txt", "r") as file:
print(file.read())
离开with语句会自动关闭文件
14万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
