第九单元 python基础--语句
一、判断语句
if语句的使用格式
4 if 要判断的条件:
条件成立时，要做的事情
if-else的使用格式
if要判断的条件:
条件成立时，要做的事情
else:
条件不成立时，要做的事情
if-elif-else的使用格式
if要判断的条件:
条件成立时，要做的事情
elif要判断的条件:
条件成立时，要做的事情
else:
条件不成立时，要做的事情
if嵌套
if要判断的条件:
条件成立时，要做的事情
if要判断的条件:
条件成立时，要做的事情
else:
条件不成立时，要做的事情
else:
条件不成立时，要做的事情
二：循环语句
while循环的格式
while条件:
条件成立时，要做的事情
条件成立时，要做的事情
.....
while循环嵌套
while条件:
条件成立时，要做的事情
条件成立时，要做的事情
.....
while条件:
条件成立时，要做的事情
条件成立时，要做的事情
.....
for循环
for 临时变量 in 列表或者字符串等可迭代对象:
循环满足条件时执行的代码
pass的使用
1.Pythonpass是空语句，是为了保持程序结构的完整性。
2.pass不做任何事情，一般用做占位语句。
第十单元列表
1.格式：listName=[元素，元素]
2.特点：有序，可重复，可变，任意类型，性能不好
3.增：
1.append:list.append（元素），追加到末尾
2.extend:list.extend（元素），追加到末尾，散开添加
3.insert：list.insert:(index,元素)，添加元素到指定位置，如果新增的索引不存在添加到末尾
4.改：list[index]=新元素
注意：如果index存在则修改，不存在则越界
5.删
1.del：del list[index],删除指定下标对应的元素，如果index不存在，则报错索引越界
2.pop：list.pop（），删除末尾元素
3.remove：删除指定元素，list.remove（元素），如果元素不存在报错
6.查
1.list.index（元素）：查看元素下标
2.list.count（元素）：查询列表中的元素的个数
7.排序：
1.升序：list.sort（）
2.降序：
1.list.sort（Reverse=True）
2.list.sort().reverse()
注意：如果不是数字，则报错
8.列表的循环取值
1.for
for i in list:
list[i]
2.while
i=0
while 条件：
list[i]
i+=1
9.list嵌套
1.格式：list=[list1,list2,list3]
2.取值：list[外层下标][内层下标】
3.删除：del [外层下标][内层下标】
4.添加：list[外层下标].insert（内层插入下标，元素）
5.[外层下标][内层下标】=值
第十一单元 元组和字典
一.元组
1.格式：t=(元素，元素)
2.特点：有序，可重复，不可变，任意类型，性能好
3.访问元组
索引值存在：print（t[2]）
索引值不存在：报错
4.查询：
1.查询个数：t.count（元素）
2.查询下标：t.index（元素）
5.修改：不可修改，虚转换类型
6.类型转换
列表转换元祖
aa = [23,34,45,56,67]
tuple(aa)
print(aa)
#[23, 34, 45, 56, 67]
元组转换列表
aTuple=('b','c','d','e','f','g')
a = list(aTuple)
print(a)
#['b', 'c', 'd', 'e', 'f', 'g']
7.元组的循环取值
1.for
for i in aTuple:
print(i)
2.while
i=0
while i < len(aTuple):
print(aTuple[i])
i=i+1
二.字典
1.格式：变量名={key1:value,key2:value}
2.特点：有序，不可重复，可变，任意类型，性能不好
3.根据键访问
1.z={key1:value,key2:value}
print(z["key"])
2.z={key1:value,key2:value}
print(z.get("name"))
4.修改
1.有对应的key
z["key"]="value"
print(z)
2.没有对应的key是新增数据到末尾
5.添加
z["key"]="value"
6.删除
1.del
del z["key"]
print(z)
2.clear：清空字典里的内容
z.clear()
print(z)
7.长度
print(len(z))
8.字典循环
1.取出key
for i in z.keys():
print(i)
2.取出value
for i in z.values():
print(i)
3.取出key和value方法一
for i,j in z.items():
print(i,j,sep=":")
4.取出key和value方法二
for i in z.keys():
print(i,z[i],sep=":")
5.扩充的
for i,j in enumerate(z):
print(i,j,z[j])
十二单元
一、集合
1.集合的特点：无序、唯一、去重
2.格式：j={元素,元素}
3.添加：
1.j.add(元素)
2.
j={1,"vfd",5,2,"vedfbrgb"}
i=["小何","真美",48]
j.update(i)
4.删除
1.remove：删除集合中的元素 如果有直接删除 如果没有程序报错
j.remove(元素)
2.pop：都是数字，删最小的，其余升序排序；
都是非数字，随机删，其余随机排序；
数字和非数字，随机删，删数字的话就是最小的，删非数字的话，随机删
注意：如果集合中没有元素，则报错
j.pop()
3.discard：如果元素存在直接删除 如果元素不存在不做任何操作
j.discard(元素)
5.交集
连接多个集合，输出相同的元素（set可用）
j={1,"vfd",5,2,"vedfbrgb"}
i={5,2,"小","美",48}
a=j&i
print(a) #{5,2}
6.并集
去重，得到全部集合中全部的元素
j={1,"vfd",5,2,"vedfbrgb"}
i={5,2,"小","美",48}
a=j|i
print(a) #{1, 2, 5, 48, '真', '小', 'vfd', 'vedfbrgb'}
7.公共方法
1.加（列表和元祖可用）
j=(1,"vfd",5,)
i=(5,48)
print(j+i) #(1, 'vfd', 5, 5, 48)
2.乘（列表和元祖可用）
j=(1,"vfd",5,)
i=(5,48)
print(j*2) #(1, 'vfd', 5, 1, 'vfd', 5)
3.包含（in）（列表和元祖和字典可用）
j=(1,"vfd",5,)
print(1 in (j)) #True
j=(1,"vfd",5,)
print(6 in (j)) #False
4.不包含（no in）（列表和元祖和字典可用）
j=(1,"vfd",5,)
print(1 not in (j)) #False
j=(1,"vfd",5,)
print(6 not in (j)) #True
8.内置函数
长度：print(len(变量名))
最大值：print(max(变量名))
最小值：print(min(变量名))
del：第一种：del 变量名
第二种：del(变量名)
二、函数
1.什么是函数
其实就是方法、功能
2.函数的定义和调用
格式：
def函数名():
执行语句
函数名()
3.函数参数
1.正常的
defadd2num():
a=11
b=22
c=a+b
printc
2.位置参数
def函数名(参数1,参数2):
代码块
函数名(值1,值2)
3.关键字参数
def函数名(参数1,参数2):
代码块
函数名(参数1=值1,参数2=值2)
案例：deffun(a,b):
print("a:",a)
print("b:",b)
fun(a=2,b=3)
案例二：deffun(a,b):
print("a:",a)
print("b:",b)
fun(3,b=2)
注意：位置参数一定要在关键字参数之前
4.缺省参数（默认参数）
案例一：
defprintinfo(name,age=20):
print("name:",name)
print("age:",age)
printinfo(name="anfly")
#name: anfly
#age: 20
案例二：
defprintinfo(name,age=20):
print("name:",name)
print("age:",age)
printinfo(name="anfly",age=10)
#name: anfly
#age: 10
注意：缺省参数一定要位于位置参数的最后面
5.不定时参数
*args：为元组
**kwargs：为字典
defprintinfo(*args,**kwargs):
print("args:",args)
print("kwargs:",kwargs)
printinfo(1,2,3,a=5,b=6)
#args:1,2,3
#kwargs:a=5,b=6
6.参数位置顺序
deffun(位置参数,*args,缺省参数,**kwargs):
代码块
fun(参数值)
案例：
deffun(a,b,*args,c=6,**kwargs):
print("a=",a)
print("b=",b)
print("args=",args)
print("c=",c)
print("kwargs=",kwargs)
fun(1,2,3,4,5,9,c=1000,f=45,cf=65)
#a= 1
#b= 2
#args= (3, 4, 5, 9)
#c= 1000 如果下面的fun不给c=1000的话下面输出的c的值就为6
#kwargs= {'f': 45, 'cf': 65}
4.函数返回值
十二.python--集合和函数
1.格式：(1).s = set() #不能初始化数据 (2).s = {元素，元素，元素} 注意：s = {}，默认字典
2.特点：无序、不可重复、可变、任意类型，用于给元组和列表去重
3.添加：s.add(元素)
4.修改：s.update(set)
5.删除：(1).remove：s.remove(元素),元素存在则删除，否则报错keyError
(2).discard:s.discard(元素),元素存在则删除，不存在则无操作 (解决报错问题keyError)
(3).pop:s.pop()：随机删除一个元素
6.遍历：for i in set1： print(i)
7.交集、并集：交集：得到多个集合公共元素 set1 & set2
并集：得到所有元素的集合并去重 set1 | set2
8.公共方法：(1).运算符：①.+：字符串、列表、元组、集合和字典不能使用
②.*：字符串、列表、元组、集合和字典不能使用
③.in及not in：字符串、列表、元组、字典
(2).内置函数：max() min() len() del() del list tuple dict set
9.函数：(1).格式
函数格式
(2).参数：①.位置参数：实参和形参按照位置一一对应
②.关键字参数：指定实参名字
③.缺省参数：给形参赋默认值
④.不定长参数：未命名不定长参数、命名不定长参数
注意：位置参数→*arges→缺省参数→**kwargs
第十三单元
1.作用：保存数据存放在磁盘,把一些存储存放起来,可以让程序下一次执行的时候直接使用,而不必重新制作一份,省时省力
文件
文件
注意：指定绝对路径，也可以用相对路径
2.文件和文件夹的操作
操作
3.异常：(1).什么是异常：一个正常执行的程序发生错误的事件
(2).常见异常：FileNotFoundError、IndexError、ValueError、ZeroDivisionError、KeyError
(3).处理
处理
(4).模块：①.概念：py文件就是一个模块
②.导入：from 包 import 模块.方法[*]、import 模块.方法[*]
(5).Python中的包：包是一个分层次的文件目录结构，它定义了一个由模块及子包，和子包下的子包等组成的 Python 的应用环境。
第十四单元：面向对象
1.基本概念：类、类变量、数据成员、方法重写、局部变量、实例变量、继承、实例化、方法、对象
2.创建类
3.python内置类属性：dict:类的属性（包含一个字典，由类的数据属性组成）
doc：类的文档字符串 name：类名
module：类定义所在的模块（类的全名是'main.className',如果类位于一个当如模块mymod中，那么className.module等于mymod）
bases：类的所有父类构成元素（包含一个由所有父类组成的元组）
4.类的继承：注意：python中，类可以多继承
5.方法重载：同一类中，方法名相同，参数个数和类型不同
6.类的私有属性和私有方法:(1)私有属性v:只能是本类中使用，在类内部的方法中使用self.__private_atters.
(2)私有方法:fun，不能在类的外部调用，在类的内部调用 self.__private_methods.
