day1
-
注释
- # 来表示被注释的内容,不会被当成代码执行
- 注释的快捷键: ctrl + /
- 多行注释:三引号开头,三引号结尾
-
变量 在代码中用来临时保存数据的
-
命名规范
- 只能由数字、字母、下划线组成
- 不能使用数字开头
- 不能使用python中的关键字
- python严格区分大小写
- 变量命名不要和python 得内置函数和模块同名
-
变量命名风格
-
尽量做到见名知意
-
尽量使用下划线命名法:
单词和单词之间使用下划线连接
-
不推荐使用驼峰命名
-
-
-
数值类型的数据
-
整数:int(整数)
-
小数: float(浮点数)
-
布尔值:(bool)是一种特殊的数值类型
True (表示真,条件成立)
False(表示假,条件不成) -
数值类型的运算:
1、算术运算符:
加(+)
减(-)
乘(*)
除(/)
除法取整 //
除法取余 %
幂运算 **
2、比较运算符:
大于:>
小于:<
大于等于: >=
小于等于:<=
不等于: !=
等等于: ==
-
-
字符串(str)
-
通过引号表示
-
字符串转义
\’:表示一个’
\":表示一个"
\n:表示换行(换行符)
\t:表示制表符(了解) -
获取字符串长度 pthon得内置len()函数
-
day2
-
字符串格式化
-
字符串拼接
name = input(“输入名字:”)
money = input(“输入金额:”)print(“今收到”, name, “交来学费”, money, “元,开此收据为凭”)
desc = “今收到” + name + “,交来学费” + money + “元,开此收据为凭”
print(desc) -
format:格式化
今收到XXX,交来学费XXX元,开此收据为凭
name = input(“输入名字:”)
money = input(“输入金额:”)
desc = “今收到{},交来学费{}元,开此收据为凭”
print(desc.format(name, money))
desc2 = “今收到{},交来学费{}元,开此收据为凭”.format(‘李四’, 800)
print(desc2) -
传统的%号格式化(了解即可)
%s : 表示一个字符串占位符(后面填任意类型的数据都可以)
%d : 表示一个整数占位符(后面只能填数值类型的数据,会转换为整数)
%f : 表示一个浮点数占位(后面只能填数值类型的数据,为转换为小数)bool int floatname = input(“输入名字:”)
money = input(“输入金额:”)
desc = “今收到%s,交来学费%s元,开此收据为凭” % (name, money)
print(desc)
print(‘交来学费%d元’ % (8.88))
print(‘交来学费%f元’ % (700)) -
字符串的f 表达式(f小写大写都可以)
name = ‘张三’
age = 800
desc4 = F’收到{name},交来学费{age}元,开此收 据为凭’
print(desc4) -
format更多用法
1、可以在{}中指定填充数据的位置
desc2 = “今收到{1},交来学费{0}元,开此收据为凭”.format(‘李四’, 800)
2、格式化小数位数
desc2 = “今收到{},交来学费{:.3f}元,开此收据为凭”.format(‘李四’, 888.99499923232)
3、格式化百分比显示:
desc3 = ‘接口自动的用例执行通过率为 {:.1%}’.format(0.8899)
4、格式化字符串的长度:
{:^20}: ^居中对齐
{:<20}: 左对齐
{:>20}: 右对齐
{:*>20}:可以在对齐符号的前面指定填充字符
desc2 = “今收到{1},交来学费{0}元,开此收据为凭”.format(‘李四’, 800)
print(desc2)desc2 = "今收到{},交来学费{:.3f}元,开此收据为凭".format('李四', 888.99499923232) print(desc2)
desc3 = ‘接口自动的用例执行通过率为 {:.1%}’.format(0.8899)
print(desc3) print(“今收到{:*^20},交来学费80元,开此收据为凭”.format(‘dasda’))
print(“今收到{:$>20},交来学费80元,开此收据为凭”.format(‘dsiuauidas’))
print(“今收到{:$>20},交来学费80元,开此收据为凭”.format(‘ds’))
print(“今收到{:*>20},交来学费80元,开此收据为凭”.format(‘dsasdasdsasda’))
-
-
python中所有的序列类型(字符串、列表、元组)数据都有索引:
-
索引
正向索引:按从前往后的顺序,从0开始数,越往后值越大
反向索引:按后前往前的顺序,从-1开始数,越往前值越小 -
索引取值 结果 = 数据[索引值]
s1 = ‘abcdefg’
res = s1[4] -
切片
-
切片: [start : end]
结果 = 数据[起始位置索引:终止位置的索引]
切片注意点:取头不取尾 (左闭右开)
-
加步长切片: [start : end : length]
结果 = 数据[起始位置索引:终止位置的索引:步长]
注意点:起始位置和终止位置不写,默认代表最前面和最后面
-
-
-
字符串的常用方法
''' format:格式化方法 replace:替换字符串中的内容 参数1:需要替换的内容 参数2:替换之后的内容 参数3:可以指定替换的次数(默认是替换所有的值) 注意点:(参数2)替换之后的内容只能传递字符串 find: 查找指定字符的索引位置(返回查找到的第一个的索引) join:字符拼接的方法 res = ''.join(('python', 'java', 'php')) split:把一个字符串,以分隔符为分割点,分割成多个字符 strip:去除前后指定的字符(默认是去除空白字符) upper:将字符串中的小写字符转换为大写 lower:将字符串中的大写字符转换为小写 ''' # 把字符串中的123替换成999 s = 'python123java123php123C++' res = s.replace("123", '999', 2) print(res) s2 = 'pythonAjavaAphpA' res = s2.find('A') print(res) # 2.字符串拼接: s1 = 'python' s2 = 'java' s3 = 'php' print(s1 + '===' + s2 + '===' + s3) res = '?'.join((s1, s2, s3)) print(res) # 3.字符串分割: s4 = 'python99java99php99c++' res = s4.split('99') print(res) s5 = '@id@mobile@pwd' print(s5.split('@')) # 4.字符串去除前后空白字符 s = ' python35 hello python ' print(s) res = s.strip() print(res) # 5.去除前后指定的字符 s2 = '+++++++python35 hello python--------- res2 = s2.strip('+') print(res2) res3 = s2.strip('-') print(res3) # -------扩展-------- # 去除前后的 s2.lstrip() # 去除后面的 s2.rstrip() # 6.字符串中字母大小写转换 s = 'python123JAVA' res = s.lower() print(res) print(s.upper())
day3
-
列表得基本使用
- 列表:使用[]来表示,每个元素使用逗号隔开
- 列表中的元素是有序的:
- 支持索引取值:
- 支持切片:切片得到的结果还是一个列表
- 注意点:列表中可以存放任意类型的数据
-
列表的增删查改
-
添加数据:
append:往列表的结尾处添加一个元素
insert:往列表中指定索引位置插入元素
extend:一次性往列表尾部添加多个元素 -
删除数据:
remove:指定元素进行删除(如果存在多个,则只会删除第一个)
pop:指定索引进行删除(默认删除的是最后一个)
clear: 清空列表中的所有元素(调用完会返回删除的数据) -
修改列表中元素的值:
通过索引指定位置进行修改
-
查找元素:
- 索引取值
- index:查找元素对应的索引(元素不存在,代码会报错)
- count:统计某个元素的个数
# -------------------添加数据------------------------ # append li = [11, 22, 33, 44] li.append(99) li.append(999) print(li) # insert: li = [11, 22, 33, 44] li.insert(4, 'musen') print(li) # extend li = [11, 22, 33, 44] li.extend([888, 999, 777]) li.extend('abc') # 扩展了解,实际不会使用到 print(li) # --------------------删除数据------------------------- # 方法一: remove: li = [11, 22, 33, 44, 55, 66, 77, 88, 99,11,22,33,11,22] li.remove(11) print(li) # 方法二:pop :pop方法调用的时候,会返回删除的数据 li = [11, 22, 33, 44, 55, 66, 77, 88, 99,11,22,33,11,22] res = li.pop(0) print(res) print(li) # 方法三:clear: li = [11, 22, 33, 44, 55, 66, 77, 88, 99,11,22,33,11,22] li.clear() print(li) # -----------------------修改----------------------- li = [11, 22, 33, 44, 55] li[2] = 333 print(li) # -----------------------查找----------------------- li = [11, 22, 33, 44, 55,11,22,11,11,11] # 方式1:索引取值 res = li[3] print(res) # index:查找元素对应的索引 res = li.index(22) print(res) # count:统计某个元素的个数 res = li.count(55) print(res) # -------字符串中的index和find---- res2 = "sqwrrs".index('w') print(res2) res3 = "sqwrrs".find('g') print(res3)
-
-
列表的复制
-
copy:可以用来复制列表
-
sort:对列表进行排序
升序(从小到大):li2.sort()
降序(从大到小):li2.sort(reverse=True) -
reverse:列表反转(反序)将列表倒过来
-
内置id:查看数据的内存地址编号
# -------------copy:复制列表------------- li = [11, 22, 33] li2 = li.copy() li3 = li print('li:', li2) print('li2:', li) print('li3:', li3) print('li的id:', id(li)) print('li2的id:', id(li2)) print('li3的id:', id(li3)) # ---------------sort:列表排序---------------------- li2 = [11, 22, 33, 42, 121, 4, 121, 44, 21, 2323, 1212, 44, 45, 656, 232] # 升序(从小到大) li2.sort() print(li2) # 降序(从大到小) li2 = [11, 22, 33, 42, 121, 4, 121, 44, 21, 2323, 1212, 44, 45, 656, 232] li2.sort(reverse=True) print(li2) # ------------ reverse:列表倒序------------ li3 = [11, 33, 'aa', 55, 99] li3.reverse() print(li3) # [11, 33, 'aa', 55, 99],请将这个列表反序 # 通过切片将列表反序: # -------------扩展-------- li2 = [11, 33, 'aa', 55, 99] res = li2[::-1] print(res)
-
-
元组
-
元组的定义:使用()来表示
-
元组中可以存放任何的数据类型
-
元组中的元素是有序的:
支持索引取值
支持切片 -
元组中的元素是不可变的(定义了之后,元组内部的元素不能进行添加、删除和修改)
-
元组的查找:
- 通过索引取值
- index:查找指定元素的索引
- count:统计某个元素在元组中的个数
-
-
类型转换
-
字符串、列表、元组 统称:序列类型
-
序列的共同特征:
1、都有索引值,内部元素是有序的。
2、支持切片操作 -
都可以通过len()去获取元素的个数
数据类型的相互转换:
数值:
整数:int
浮点数:float
布尔值:bool
序列:
字符串:str
列表:list
元组:tuple# --------------------int和float转换为str---- n1 = 99 n2 = 88.88 print(type(n1), type(n2)) n3 = str(n1) n4 = str(n2) print(type(n3), type(n3)) # ---------------str转换为int和float--------- s1 = '88' s2 = '99.99' s3 = int(s1) s4 = float(s2) print(s3, type(s3), s4, type(s4)) # -----------------列表和元祖之间的转换------ # 元组转列表 tu = ('musen', 18, 'nan') li = list(tu) print(li,type(li)) # 列表转元组 li2 = ['musen', 18, 'nan'] tu2 = tuple(li2) print(tu2,type(tu2)) # 列表转换为字符串--------- # li = [11,22,33,44] # s = str(li) # print(s,type(s)) # '[11,22,33,44]' # s = '[11,22,33,44]' s2 = '(11,22,33,44)' # 需求把上述的字符串转成一个列表 # li = list(s) # 行不通 # print(li) # 内置函数eval:识别字符串中的有效python表达式(去掉字符串两边的引号) li2 = eval(s2) print(li2, type(li2)) # --------------pyton中定义元祖的快捷方式(扩展,不推荐使用)--------------- tu = 11, 22, 33 print(tu, type(tu)) s3 = '[11,22,33,44],(11,22,33,44)' res3= eval(s3) print(res3,type(res3))
-
day4
-
字典得基本使用:
- 定义: 字典是通过{}来表示的,每一条数据都是一个键值对(key:value),每个元素之间使用逗号隔开
- 字典的键在同一个字典中是唯一的(不能重复)
- 字典中的键:只能是不可变类型的数据,一般情况下都是使用字符串来作为字典的键
- 不可变类型的数据:数值(int,float,bool),字符串、元组
- 可变类型的:列表、字典、集合(有增删查改的方法)
- 注意点:字典的键在同一个字典中是唯一的(不能重复)
- 字典中的值:可以是任意类型的数据
-
字典的增删查改:
-
增:
- 通过键进行赋值
- update:一次性往字典中添加多个元素(将一个字典更新到当前的字典中)
-
改:
- 通过键进行赋值(有则改、无则增)
-
删:
- pop:指定键进行删除(返回删除的元素对应的值)
- popitem:删除最后一个加入道字典中的元素,以元组的形式返回键和值
- clear:清空字典
-
查:
- 通过键查找值,如果键不存在会报错(KeyError)
- get:通过键查找值,如果键不存在,不会报错(返回None)
---------------增------------------: dic = {} # 1、通过键进行赋值 dic["skill"] ='python' print(dic) # 2、update: dic.update({"name":"msuen","age":18}) print(dic) ---------------改-----------------: dic = {"name": "msuen", "age": 18} # 通过键进行赋值 dic["name"] = "糯米" print(dic) ---------------删除----------------- dic = {"name": "msuen", "age": 18} # 1、pop:指定键进行删除 res = dic.pop("age") print(res) print(dic) dic["a1"] = 101 dic["a2"] = 102 dic["a3"] = 103 dic["a4"] = 104 # 2、popitem:删除最后一个加入到字典中的元素,以元组的形式返回键和值 res = dic.popitem() print(res) print(dic) # 3、clear:清空字典 dic.clear() print(dic) ---------------查------------ c = {"name": "msuen", "age": 18} # 1、通过键查找值,如果键不存在会报错(KeyError)。 res = dic["age"] print(res) # 2、get:通过键查找值,如果键不存在,不会报错(返回None) res2 = dic.get("name1")
-
-
字典得其他方法:
- keys:获取字典中所有的键
- values: 获取所有的值
- items:同时获取字典中的键和值,每个元素的键和值会保存再一个元组中
# 使用场景:和后续内容的for循环一起使用 # copy:复制字典 dic = {"name": "msuen", "age": 18, 'gender': "男"} # 获取字典中所有的键 res = list(dic.keys()) print(res) # 获取所有的值 res2 = list(dic.values()) print(res2) # items:同时获取字典中的键和值 res3 = list(dic.items()) print(res3)
-
定义字典得三种方法:
# 第一种:直接通过{} dic = {"name": "msuen", "age": 18, 'gender': "男"} print(dic) # 第二种:使用内置函数dict(了解) dic2 = dict([('name', 'msuen'), ('age', 18), ('gender', '男')]) print(dic2) # 第三种:内置函数dict dic3 = dict(name="musen", age=18, gender="男") print(dic3)
-
集合(set):
- 集合定义:也是使用{}来定义
- 注意点:{}代表空字典,空集合使用set()来定义
- 集合是可变类型的数据(有增删查改的方法)
- 集合中的元素是唯一的(没有重复的元素)
- 应用场景:数据去重
- 集合中的元素是无序的(没有下标索引)
- 集合中只能存放不可变类型的数据
set1 = {11, 22, 33, 44} print(type(set1)) # 空字典还是空集合?? set2 = {} print(type(set2)) # 空集合: set3 = set() print(type(set3)) # 集合种事没有重复的元素的 set4 = {1, 2, 3, 1, 2, 3, 1, 3, 4, 1, 2, 3, 1, 2} print(set4) # 无序 li = ["101", '101', '102', '101', '103'] res = set(li) print(res) # 集合中只能存放不可变类型的数据 s = {1, 1.1, False, 'str11', (11, 22, 33)}
- 集合定义:也是使用{}来定义
-
random
# random:生成数据数的官方库 import random # 生成一个随机的整数(指定范围,包含边界值) res = random.randint(0, 3) print(res) # 生成一个随机的小数(0到1之间) res2 = random.random() print(res2) # 需求:如果生成一个10-20之间的小数?(指定范围的小数) res3 = random.uniform(10, 20) print(res3) # 从列表中随机选择一个数据 li = [11, 22, 33, 44, 55] res4 = random.choice(li) print(res4)
-
数据类型总结:
- python中的基本数据类型:
- 数值: int float bool
- 复数(complex):用不到,没讲
- 序列:str 、list 、tuple、dict 、set
- 不可变类型的数据:数值(int,float,bool),字符串、元组
- 可变类型的:列表、字典、集合(有增删查改的方法)
- python中的基本数据类型:
# 数据变化之后,看id是否变化
s = "python"
print(id(s))
s = s.replace('p', '999')
# print(s)
print(id(s))
print('------------------------------')
li = [11, 22, 33]
print(id(li))
li.append(1111)
print(id(li))
tu = (11, 22, 33)
tu = (11, 22, 33, 44)
n = 10
print(id(n))
n = n + 1
print(id(n))
day5
-
控制流程_条件判断:
- 顺序:代码执行的顺序从上往下
- 分支:根据不同的条件,执行不同的代码
- 循环:特定的代码重复执行
price = int(input("请输入考试分数:")) if price >= 60: print("很开心,你考试及格") print("今天可看电视") print("可以吃大餐") else: print("不及格,获得一个大嘴巴子") print("今天晚上通宵敲代码") """ 需求三:请根据用户输入成绩,按以下等级区分: 59<:D 60-75:C 76-85:B 86-100:A """ price = int(input("请输入考试分数:")) if 0 <= price <= 59: print("等级为D") elif 60 <= price <= 75: print("等级为C") elif 76 <= price <= 85: print("等级为B") elif 86 <= price <= 100: print("等级为A") else: print("您输入的成绩有误!")
-
运算符集合条件判断:
-
数值:
- 算术运算
- 比较运算:> < <= >= != ==
n = int(input("输入数字:")) if 22 != n: print('成立') else: print("不成立")
-
其他的运算符
-
逻辑运算
and:与(前后的添加都要成立)
or: 或(前后只要有一个条件成立即可)
not:非(取反)
-
成员运算
in : 判读是里面的成员
not in: 判断不是里面的成员 -
身份运算符:判断id是否一致(了解)
is:
is not: -
赋值运算符:
= :赋值
+=:
*=
/=
%=
n = 10 m = 100 if not (n - m > 0 or (m + n > 10 and n - m > 0)): print("---yes------------") else: print("---no------------") # 成员运算: stus = ["糯米", "当你", "Sen", "不动声色"] name = input("输入名字:") if name in stus: print("是咱们班的,赶紧上课写代码") else: print("不是的,不能进教室") # 字符串 str1 = "ducshkpythonfsdfbsdfsdf" if 'python' in str1: print("----yes----") else: print('----no----') # 字典:字典成员运算判断的默认是键 str1 = {"name": "musen"} if 'musen' not in str1.values(): print("----yes----") else: print('----no----') li = [11, 22] li2 = li li3 = li.copy() print(id(li),id(li2),id(li3)) if li is not li3: print("----yes----") else: print('----no----') # ----------------赋值运算------------------- = 100 n = n + 1 #等同于 += n += 1 n -= 10 print(n)
-
-
-
while循环:
-
while循环(条件循环):
- 如果条件一直成立,则一直循环做条件满足的事情,直到条件不成立,结束循环
#语法: # while 条件: # 条件成立,循环执行的代码一 # 条件成立,循环执行的代码二 # 条件成立,循环执行的代码三 # 条件成立,循环执行的代码四 # 案例循环打印hello python i = 1 while i <= 100: print("这是第{}遍hello python".format(i)) i += 1 print("--end--") continue # 中止当前本轮循环,回到条件判断的地方(重新判断条件) i = 0 while i < 50: i += 1 if i == 25: continue # 中止当前本轮循环,回到条件判断的地方(重新判断条件) print("当前的i为:{}".format(i))
-
-
for循环: 循环遍历
li = [34, 66, 33, 78, 66, 90, 78, 87] for price in li: # 循环体 # print("循环执行的代码1") # print("循环执行的代码2") # print("循环执行的代码3") # print("-----------------") if price > 60: print("您的成绩为{},及格".format(price)) else: print("您的成绩为{},不及格".format(price))
day6
-
for循环遍历
- 遍历列表
- 遍历字典
- 遍历字符串
# 一、遍历列表 li = [34, 66, 33, 78, 66, 90, 78, 87] for price in li: if price > 60: print("您的成绩为{},及格".format(price)) else: print("您的成绩为{},不及格".format(price)) # 二、遍历字典 dic = {"aa": 11, "bb": 22, "cc": 33, "dd": 44} # 1、默认遍历出来的是键: for i in dic: print(i) # 2、遍历字典的值 for i in dic.values(): print(i) # 3、遍历键和值 for k, v in dic.items(): print("key:", k, "value:", v) # -------------------扩展知识点:元组拆包---------- tu = ("python", 323243, 'musen') # 元组拆包 k, v, name = tu print("key:", k, "value:", v, "name:", name) ''' for 循环指定循环多少次? 内置函数range():可以用来生成一个指定长度的序列 1、range(n):默认生成一个 0到n-1的整数序列, 对于这个整数序列,我们可以通过list()函数转化为列表类型的数据。 2、range(n,m):默认生成一个n到m-1的整数序列, 对于这个整数序列,我们可以通过list()函数转化为列表类型的数据。 3、range(n,m,k):相当于其他函数里面的for循环。 n 初始值 m 结束值 , k 步长,会生成初始值为n,结束值为m-1,递减或者是递增的整数序列。 ''' li = list(range(100)) print(li) for i in range(100, 200, 5): print("这是第{}遍hello python".format(i)) # 打印0-100之间的偶数 for i in range(101): if i % 2 == 0: print(i)
-
for循环关键字使用
- continue的作用:终止本轮循环,开启下一轮循环(回到for中获取下一个数据)
- break的作用:强制终止循环
for-else语法: for x in XX: # 循环体 else: #循环正常结束执行执行else中的代码 # 循环通过break强制结束则不会执行else # continue的作用:终止本轮循环,开启下一轮循环(回到for中获取下一个数据) for i in range(10): if i == 5: continue print(i) print('----------------------------------') # break的作用:强制终止循环 for i in range(10): if i == 5: break print(i) print('----------------------------------') for i in range(10): print('-----{}---------'.format(i)) if i == 5: break else: print("所有的数据全部遍历完,执行else中的代码") # --------------for--else案例:判断输入的数据的是否存在 li = [ {"name": "py35", "pwd": 'lemonban'}, {"name": "py36", "pwd": 'lemonban'}, {"name": "py37", "pwd": 'lemonban'}, ] name = input("请输入用户名:") # 判断用户输入的用户名,是否存在 for item in li: if item["name"] == name: print("用户存在") break else: print("用户不存在")
-
for循环嵌套使用
# 打印5*5的正方形 for i in range(5): for j in range(5): print("* ", end='') print() # 打印三角形 for i in range(9): for j in range(i + 1): print("* ", end='') print()
-
列表推导式:可以用来快速的生成一个列表
li = [i for i in XXX] # 需求:生成这样一个列表["page0",'page1','page2',.....'page20'] # 常规的for循环语法 li = [] for i in range(21): d = 'page{}'.format(i) li.append(d) print(li) # 列表推导式实现 li2 = ['page{}'.format(i) for i in range(21)] print(li2) li2 = ['http://www.baidu.com/page{}'.format(i) for i in range(10)] tu = (11, 22, 33, 44, 55, 66, 77) # 需求:将元组中的每个数据+1,转换为列表 li = [i + 1 for i in tu] print(li) li = [i * 10 for i in tu] print(li)
day7
-
函数的基本使用
-
函数可以用来封装独立的功能代码,通过封装可以提高代码的重用率,提高开发效率
-
函数的定义:函数在定义之后不会自动执行
语法:
def 函数名():
# 函数体(写到函数里面的功能代码) -
函数调用:函数名(“参数”)
-
函数名的命名规则:(和变量的命名规则一样)
函数名推荐下划线命名法,尽量做到见名知意
打印三角形 for i in range(9): for j in range(i + 1): print("* ", end='') print() print("--执行了200代码之后---") for i in range(9): for j in range(i + 1): print("* ", end='') print() print("--执行了100代码之后---") for i in range(9): for j in range(i + 1): print("* ", end='') print() # 定义函数 def print_func(): """打印三角形的函数""" for i in range(9): for j in range(i + 1): print("* ", end='') print() # 调用函数 print_func() print("--执行了100代码之后---") print_func() print("--执行了200代码之后---") print_func() print('你好')
-
-
函数的参数
-
参数的定义:在函数名后面的括号中可以定义参数
-
参数的传递:定义在函数括号后面的参数,需要在调用函数的时候传递进行
-
形参和实参:
形参:定义的参数
实参:调用时传递的参数# 定义函数 def print_func(n): """打印三角形的函数""" for i in range(n): for j in range(i + 1): print("* ", end='') print() print_func(3) print_func(4) print_func(5)
-
-
参数传递的方式
-
调用函数的时候参数传递的方式:
-
位置传参(位置参数)
例:add(101, 22)
-
指定参数名传参(关键字参数)
add(m=101, n=22)
-
注意点:两种传参方式混合使用的时候,位置参数在前,关键字参数在后
def add(n, m): print("n:", n) print("m:", m) print(n + m) # 位置参数 add(101, 22) # 关键字参数 add(m=101, n=22) ----------------------------------- def add(n, m, a, b): print("n:", n) print("m:", m) print("a:", a) print("b:", b) add(a=11, b=22, n=33, m=44) # 两种传参方式混合使用的时候,位置参数在前,关键字参数在后 add(11, 22, a=33, b=44) add(11, 22, b=33, a=22)
-
-
-
参数定义的形式
-
必备参数(必需参数):定义了必须要传,不能多不能少
def func(a,b):
-
默认参数(缺省参数):调研的时候可以传,也可以不传,不传就使用默认值
def func(a=11,b=22):
-
不定长参数(可变参数):调用的时候可以传0个或者多个值
*args: 只能使用位置传参的形式传值,接收到的参数以元组的形式保存
**kwargs: 只能使用关键字参数的形式传值,接收到的参数以字典的形式保存
-
注意点:必需参数要写前面,默认参数写后面
# 1、-------必备参数------- def add(n, m, c): print("n:", n) print("m:", m) print("c:", c) add(11, 22, 66) # 2、---------默认参数---------- def add(n=11, m=22, c=99): print("n:", n) print("m:", m) print("c:", c) add(c=99999) # 3、-------------不定长参数--------------- def func(*args): print(args) func() func(11, 22, '33', 333, 444, 111, 333, 444, 433, 432, 22) def func(**kwargs): print(kwargs) func() func(aa=11, b=22, c=22, dd=444, g=555) print("a", "b", "c", "ccc", 100, 220, 333, 322, 11, 22, 3333, 444, 55, 666, 77, 88) # 需求:定义一个可以接收任意个参数的函数,同时支持位置传参和关键字传参 def func(*args, **kwargs): print(args) print(kwargs) func(11, 22) func(11, 22, a=33, b=44) func(bb=11, c=22, a=33, b=44) def func(a, b, c=99, *args, **kwargs): print(a) print(b) print(c) print(args) print(kwargs) func(11, 22, 33, 111, 22, 222, aa=22)
-
-
函数参数的拆包
-
函数的参数可以传任意类型
-
函数中养成写注释的习惯
-
函数参数的拆包(仅限于函数调用是传参使用)
可以对列表或者元组进行拆包,把元素当成位置参数传递
** 可以对字典进行拆包处理,把元素当成关键字参数传递import requests def func(a, b, c=99): """ 函数功能说明的注释 :param a: :param b: :param c: :return: """ print(a) print(b) print(c) li = [11, 22, 33, 44] func(li[0],li[1],li[2]) func(*li) # 调用函数的时候可以使用*对列表或者元组进行拆包,把元素当成位置参数传递 dic = {"a": 111, "b": 222, "c": 333} # 调用函数的时候可以使用**对字典进行拆包,把元素当成关键字参数传递 func(**dic)
-
day8
-
函数得返回值
- 函数的返回值:关键字return
函数中没有return,返回值数目=0:返回None
返回值数目=1:返回object
返回值数目>1:返回tuple
注意点:当函数执行到return之后,就会结束函数的运行
- 函数的返回值:关键字return
-
全局变量和局部变量
- 全局变量:直接定义在python文件(模块)中的变量叫做全局变量
全局变量的有效范围(作用域),整个文件内容任何地方都可以使用 - 局部变量:在函数内部定义的变量叫做局部变量
局部变量的有效范围(作用域),仅限于改函数内部使用
- 全局变量:直接定义在python文件(模块)中的变量叫做全局变量
-
global关键字使用
-
需求:在函数内部定义或者修改全局变量
global:函数内部声明操作的全局变量
number = 100 def func(): # print(number+100) global number,name name = 'musen' number = number + 100 func() print(number) print(name)
-
-
函数内部变量及引用优先级问题
-
如果函数中的局部变量和全局变量同名,在函数内部使用这个变量的时候,会优先使用局部变量(函数中使用变量的时候,会优先使用局部变量)
注意点:函数内部定义局部变量时,尽量不要和全局变量同名
n = 100 def func(): n = 9999 print(n) func()
-
-
匿名函数
-
匿名函数:适用于函数内部代码非常简单的函数(函数)
语法:lambda 参数:返回值res = func(10) print(res) # 接收一个参数的匿名函数 func1 = lambda x: 2 * x res2 = func1(10) print(res2) # 接收两个参数的匿名函数 func3 = lambda x, y: x + y func3(11, 22)
-
-
常用得内置函数
-
min:获取最小值
-
max:获取最大值
-
sum:求和
-
可迭代对象(iterable):能够使用for进行遍历的数据都是可迭代对象(字符串、列表、字典、元组、集合)
-
高级的内置函数
eval():识别字符串中有效的python表达式
li = [11, 2, 343, 5, 2, 5, 33, 55, 33, 55, 441, 6, 6, 4] # 获取最小值 res = min(li) print(res) # 获取最大值 res = max(li) print(res) # 求和 res3 = sum(li) print(res3) # --------------高级的内置函数------------------- # 1、eval():识别字符串中有效的python表达式 print(eval('11+22')) # 2、enumerate:获取列表中的数据以及索引 li = ["name", "python", "java", "php"] for i in li: print(li.index(i), i) print("------------------------") for i, v in enumerate(li): print(i, v) # 3、zip:数据的聚合打包 title = ["name", "age", "gender"] datas = ["木森", 18, "男"] res = zip(title, datas) print(list(res)) print(dict(res)) # 注意点:zip聚合之后的数据只能使用一次 -----------zip的扩展------ li1 = [1, 2] li2 = [11, 22, 33, 44] li3 = [111, 222, 333, 444] li4 = [111] li5 = [111, 222, 333, 444] li6 = [111, 222, 333, 444] res = zip(li1,li2,li3,li4,li5,li6) print(list(res)) # 4、filter:过滤器函数(扩展了解) """ filter的作用:批量的过滤数据 参数一:过滤的规则(函数) 参数二:需要过滤的数据 """ stu = [45, 66, 88, 99, 100, 89, 97, 96] new_list = [] for i in stu: if i > 80: new_list.append(i) print(new_list) def func(x): return x > 80 res = filter(func, stu) res = filter(lambda x: x > 80, stu) print(list(res)) # -----------列表排序扩展------------ li = [45, 66, 88, 99, 100, 89, 97, 96] li = [(11, 22, 33), (3, 100, 55), (98, 78, 1)] li = [[11, 22, 33], [3, 100, 55], [98, 78, 99]] x = (11, 22, 33) print(x[1]) def func(x): return x[1] li.sort(key=func) li.sort(key=lambda x: x[2]) print(li)
-
day9
-
文件的基本操作
- 内置函数open:
参数file:传一个文件名(路径)
参数mode:文件打开的模式
r:只读
参数encoding:指定编码格式
- 内置函数open:
-
读取文件
-
操作文件的步骤:
1、打开文件:使用内置函数open2、进行操作(读或者写)
read方法:默认读取文件中所有的内容
readline:读取一行内容
readlines:按行读取所有的内容,返回一个列3、关闭文件
close方法# 1、打开文件,返回文件的句柄 f = open(file='biji.txt', mode='r', encoding='utf-8') # 2、读取文件的内容 # res = f.read() # 读取一行内容 # res = f.readline() # print(res) # 按行读取所有的内容 res = f.readlines() print(res) # 3、关闭文件 f.close()
-
-
写入文件
-
内置函数open:
参数file:传一个文件名(路径)
参数mode:文件打开的模式
r:只读,如果文件不存在,则报错
w:覆盖写入,如果文件不存在,则会自动创建一个
a:追加写入,如果文件不存在,则会自动创建一个
参数encoding:指定编码格式操作文件的步骤:
1、打开文件:使用内置函数open2、进行操作(写)
write方法:写入内容3、关闭文件
close方法#-----------------------a模式操作文件----------------------- # 1、打开文件,返回文件的句柄 f = open(file='biji02.txt', mode='a', encoding='utf-8') f.write("\n"+'python00111') # 3、关闭文件 f.close()
-
#-----------------------w模式操作文件-----------------------
# 1、打开文件,返回文件的句柄
f = open(file=‘biji04.txt’, mode=‘w’, encoding=‘utf-8’)
f.write(‘35期大佬很多’)
# 3、关闭文件
f.close()
```
-
操作其他路径下的文件
-
绝对路径:从磁盘的根目录开始的完整路径
C:\project\python_35\py35_01day\笔记.txt C:\project\python_35\py35_01day\test.txt
注意点:如果路径中包含专题字符的时候,要做特殊处理(在字符串前面加一个r,关闭转义)
-
相对路径:相对于当前文件所在的路径
. :代表当前目录
… :代表上级目录# ----------------------绝对路径----------------------- # 1、打开文件,返回文件的句柄 f = open(file='C:\project\python_35\py35_01day\笔记.txt', mode='r', encoding='utf-8') res = f.read() print(res) # 3、关闭文件 f.close() # 1、打开文件,返回文件的句柄 f = open(file='C:\project\python_35\py35_01day\test.txt', mode='r', encoding='utf-8') res = f.read() print(res) # 3、关闭文件 f.close() print('C:\project\python_35\py35_01day\test.txt') print(r'C:\project\python_35\py35_01day\test.txt') # ----------------扩展repr()--------------- print("hello python") print("{'a':11}") print(repr("{'a':11}")) print(repr("hello python")) print(repr('C:\project\python_35\py35_01day\test.txt')) # ----------------------相对路径----------------------- # 1、打开文件,返回文件的句柄 f = open(file='..\py35_01day\笔记.txt', mode='r', encoding='utf-8') res = f.read() print(res) # 3、关闭文件
-
-
文件操作的其他模式
参数file:传一个文件名(路径)
参数mode:文件打开的模式
#------------操作文本文件------
r:只读,如果文件不存在,则报错
w:覆盖写入,如果文件不存在,则会自动创建一个
a:追加写入,如果文件不存在,则会自动创建一个
#-----------图片或者视频等等文件,读取或者写入---------------- #不需要加encoding参数指定编码了
rb(二进制的模式打开):只读,如果文件不存在,则报错
wb(二进制的模式打开):覆盖写入,如果文件不存在,则会自动创建一个
ab(二进制的模式打开):追加写入,如果文件不存在,则会自动创建一个
#-----------扩展的模式(可读可写)---------------
用不到 不需要掌握
r+:
a+:
w+:
rb+
ab+
wb+:
参数encoding:指定编码格式 -
使用withopen来打开文件
-
with as :上下文管理器协议的启动器(扩展)
-
with open去操作文件会自动关闭文件(记住)
-
day10
-
异常捕获
-
try:
有可能会出错的代码
except:
当try里面的代码执行出现错误时,会执行exept中的代码,可以在这里对异常进行处理try:
有可能会出错的代码
except 异常类型 as e:
pass# -----------------捕获所有的常规异常类型------------------------- try: number = float(input("请输入一个数字:")) except: # 可以在这里对异常进行处理 # print("当try里面的代码执行出现错误时,会执行exept中的代码") print("您输入的不是数字!") number = 0 try: number = float(input("请输入一个数字:")) except Exception as e: # 可以在这里对异常进行处理 # print("当try里面的代码执行出现错误时,会执行exept中的代码") print("您输入的不是数字!") number = 0 print('错误信息:', e) # -------------捕获指定的异常类型-------------------------- c = {'a': 11} print(name) print(dic["b"]) try: print("------1------") print(name) print("------2------") print(dic["b"]) except NameError as e: print(e) # ---------------捕获多个异常类型:不同异常类型做不同的处理------------- try: print("------1------") print(name) print("------2------") print(dic["b"]) except NameError as e: print("nameError的处理方案") except KeyError as e: print("KeyError的处理方案")
-
try:
有可能会出错的代码(try会去监测代码执行是否出错)
except:
当try里面的代码执行出现错误时,会执行except中的代码,可以在这里对异常进行处理
else:
try中的代码执行没有错误,则会执行else中的代码
finally:
不管try中的代码执行是否出错,都会执行finally中的代码# ---------------------else--------------- # 读取data1.txt文件中的内容, 然后再写入: python 你好 try: with open('data1.txt', "r", encoding='utf-8') as f: res = f.read() except: print("data1.txt这个文件不存在") else: print(res) with open('data1.txt', "w", encoding='utf-8') as f: f.write('python 你好') # -------------------finally--------------- name = 'musen' try: print(name) except NameError: # res = 11 + '11' print("代码出错了") else: print("代码没出错") finally: print("finally执行了") print("----9999---------")
-
-
断言
-
assert:断言
预期结果:
实际结果:# 预期结果: expected = '注册成功' # 实际结果: res = '注册失败' if expected == res: print("用例通过") else: print("用例不通过") assert expected == res print('-------------') #-----------此处省略50行代码(接口请求代码)----- # 预期结果: expected = '注册成功' # 实际结果: res = '注册失败' try: assert expected == res except AssertionError as e: print("断言不通过,用例执行不通过") else: print("断言通过,用例执行成功")
-
-
raise主动抛出异常
- raise:主动抛出异常
raise NameError(‘xxx没定义’)
raise ValueError
raise AssertionError
# -------------------raise的应用场景--------------------------- # 限定参数的类型,不是对应的类型,主动抛出错误 def add(a, b): if not isinstance(a, int): raise ValueError('a只能是int类型') if not isinstance(b, int): raise ValueError('b只能是int类型') return a + b # res = add('aa', 'bb') # print(res)
- raise:主动抛出异常
day11
-
类得定义
-
类的定义语法:
-
方式一:
class 类名:
pass -
方式二:
lass 类名(object):
pass
以上两种定义语法没有任何区别
- 类名的规范:
1、遵循大驼峰额命名规范(每个单词的首字母大写)
2、可以由数字字母下划线组成,不能用数字开头,不要使用关键字
-
-
-
通过类实例化对象
-
1、通过类实例化对象:
语法:
对象 = 类名()万物皆对象:所以的数据都是对象
字符串:str类型的对象
列表:list类型的对象
函数:函数类型的对象
整数:int类型的对象class Cat: pass # 通过猫类创建对象 coffee = Cat() jingle = Cat() print(coffee,type(coffee)) print(jingle,type(jingle)) class PersonClass(object): pass # 通过人类创建对象 wen = PersonClass() Try = PersonClass() print(wen,type(wen)) print(Try,type(Try)) s = 'asas' str() list() print(s,type(s))
-
-
通过类得方法和属性,关于self理解
-
特征:属性
行为:方法类的方法和属性
一、属性:
1、类属性:这类事物都具备这个属性,并且属性值是一样的(定位为类属性)
(类属性是所有的对象共有的)
类属性的定义:直接定义在类里面的变量
类名.属性名 = 属性值二、方法:定义在类里面的函数叫做方法
2、对象(实例)属性:对象自己的特性(属性)
实例属性的定义:对象.属性名 = 属性值三、self:代表的是对象自己(对象本身)
那个对象调用该方法,self代表的就是那个对象class Cat: # 类属性 leg = 4 tail = 1 eye = 2 def func(self): print("这个是抓老鼠的功能") def skill01(self): print("这换个是爬树的功能") # 通过猫类创建对象 coffee = Cat() coffee.name = "加菲猫" coffee.age = '18个月' # 通过对象调用方法 coffee.func() jingle = Cat() jingle.name = "叮当猫" coffee.age = '50个月' # # ------------方法怎么使用---------------- # s = '1111' # res = s.replace('1','2') # print(res) # ----------------------------关于self------------------------------------------- class Cat: # 类属性 leg = 4 tail = 1 eye = 2 def func(self): # print(self.name) print("{}正在抓老鼠".format(self.name)) def skill01(self): print("这换个是爬树的功能") # 通过猫类创建对象 coffee = Cat() jingle = Cat() coffee.name = "加菲猫" jingle.name = "叮当猫" # print(coffee.name) # print(jingle.name) # 通过对象调用方法 coffee.func() jingle.func()
-
-
方法的参数定义
-
二、方法:定义在类里面的函数叫做方法
方法中的参数除self之外,其他的参数传递和函数是一样的
方法中的 return 也是用来返回数据的class Cat: # 类属性 leg = 4 tail = 1 eye = 2 def func(self, addr, number): # print(self.name) print("{}正{}抓{}只老鼠".format(self.name, addr, number)) return '3只老鼠' # 通过猫类创建对象 coffee = Cat() jingle = Cat() coffee.name = "加菲猫" jingle.name = "叮当猫" # 通过对象调用方法 res = coffee.func('在树上',1) print(res) jingle.func('小黑屋',10)
-
-
属性和方法的调用
-
类属性的调用:
1、可以通过类去调用 -->类.属性名
2、也可以通过对象调用 -->对象.属性名 -
实例属性的调用:
只能通过对象去调用自己的属性 -
方法的调用:
1、不能直接类调用(因为没有对象)
2、只能通过对象直接调用 -
方法的分类:
方法中第一个参数是self的方法:叫做实例(对象)方法
类方法:
静态方法:class Cat: # 类属性 leg = 4 tail = 1 eye = 2 def func(self): print("抓了3只老鼠") def skill01(self): print("正在爬树") # 通过猫类创建对象 coffee = Cat() coffee.name = '加菲猫' # ------类属性的调用------------ # print(Cat.leg) # print(coffee.leg) # ------实例属性的调用---------- # print(Cat.name) # 类调用不了 # print(coffee.name) # ----------方法的调用--------------- # Cat.func() # 不能直接用类调用 # coffee.func()
-
-
_ _init_ _初始化方法
-
-----------------------init-------------------
魔术方法:双下滑先开头和双下滑线结尾的方法,不需要手动调研,在特定的情况下自动调用
初始化方法__init__:在通过类创建对象的时候自动调用的
在创建对象的时候,给对象设置对象属性class Person: attr = '类属性1111' def __init__(self, name, age, sex): """在创建对象的时候,给对象设置对象属性""" self.name = name self.age = age self.sex = sex print("这个是---init-----") musen = Person('MUSEN', 18, '男') Try = Person('TRY', 18, '男') print(musen.name) print(musen.age) print(musen.sex) print(Try.name)
-
day12
-
私有属性&私有方法
-
私有属性:仅供类的内部使用(不要在外部调用)
_单下划线开头:表示这是一个私有属性(没有真正的私有化,类外部依然可以调用)
__双下滑线开头:表示这是一个私有属性(类外部不可以调用) -
私有方法:
_单下划线开头:表示这是一个私有方法(没有真正的私有化,类外部依然可以调用)
__双下滑线开头:表示这是一个私有方法(类外部不可以调用)class MyClass: _attr = 100 __name = 'musen' def __get_info(self): print('---get_info') def _get_name(self): print('---get_info') def func(self): print(self.__name) b = MyClass() # print(b._attr) # print(b.__name) # 不能直接使用 # b.func()
-
-
静态方法&类方法
- 实例方法:
1、只能通过对象调用(第一个参数self:代表对象本身)
2、适用场景:方法内部如果要使用对象的属性或者方法,就要定义成对象方法 - 类方法定义:要先使用@classmethod声明. 类方法:(第一个参数cls:代表类本身)
1、可以通过类调用,也可以通过对象用
2、适用场景:方法内部只使用类属性或者类方法(不需要使用对象属性和方法),适合定义为类方法 - 静态方法定义:要先使用@staticmethod声明
1、可以通过类调用,也可以通过对象用
2、适用场景:方法内部(既不需要使用类属性和类方法也不需要使用对象属性和方法),适合定义为静态方法方法
class MyClass: def func(self): print('----func---实例方法') @classmethod def func_cls(cls): print(cls) print("----func---类方法-") @staticmethod def func_static(): print("----func---静态方法------") MyClass.func_cls()
- 实例方法:
-
继承的语法和作用&继承小案例
-
方式一:
class 类名:
pass -
方式二:
class 类名(object):
pass上面定义类的两种形式 都是继承object
object:python中所有类的顶级父类(基类)
-
作用:子类通过继承可以获得父类的属性和方法,提高开发的效率及代码的复用率。(__开头的私有属性和方法的除外)
class BasePhone: attr = '移动电话' __attr2 = '1000' def __init__(self, name): self.name = name def call(self): print(f"{self.name}打电话的功能") class PhoneV2(BasePhone): def __init__(self, name, price): # 方式一:类名.方法名(self,) # BasePhone.__init__(self, name) # 方式二:super().方法() super().__init__(name) # 对该方法的功能扩展 self.price = price def send_msg(self): print("发短息") def music(self): print("放音乐") # p = PhoneV2('诺基亚N95') # p.call() # print(p.attr) p = PhoneV2('诺基亚N95', 5880) p.send_msg() p.call() print(p.price)
# --------------------普通模式--------------------- # class BasePhone: # def call(self): # print("打电话的功能") # # # class PhoneV2: # # def call(self): # print("打电话的功能") # # def send_msg(self): # print("发短息") # # def music(self): # print("放音乐") # # # class PhoneV3: # # def call(self): # print("打电话的功能") # # def send_msg(self): # print("发短息") # # def music(self): # print("放音乐") # # def pay(self): # print("手机支付") # # def game(self): # print('玩游戏') # --------------------继承的模式--------------------- class BasePhone: def call(self): print("打电话的功能") class PhoneV2(BasePhone): def send_msg(self): print("发短息") def music(self): print("放音乐") class PhoneV3(PhoneV2): def pay(self): print("手机支付") def game(self): print('玩游戏') xiaomi = PhoneV3() xiaomi.call() xiaomi.send_msg() xiaomi.music() xiaomi.pay()
-
-
动态属性设置
- 动态属性设置:setattr()
参数1:对象(类)
参数2:属性名
参数3:属性值 - 动态获取属性:getattr()
参数1:对象(类)
参数2:属性名
参数3:(非必传)设置一个属性不存在时返回的默认值(不传,属性不存在则报错) - 动态删除属性:delattr()
参数1:对象(类)
参数2:属性名 - 判断属性是否存在:hasattr()
参数1:对象(类)
参数2:属性名
# ------------------------动态属性设置------------------------------------- class MyClass: attr = 100 # 在代码执行的过程中给类添加属性 # 方式一:通过类名 MyClass.name = 'musen' print(MyClass.name) key = 'name' value ='musen' setattr(MyClass,key,value) print(MyClass.__dict__) # 需求:把字典中的键值对设置为类的属性和属性值 data = {"name": "musen", "age": 18, "gender": "男"} for k, v in data.items(): setattr(MyClass, k, v) print(MyClass.__dict__) # 需求:把字典中的键值对设置为对象的属性和属性值 m = MyClass() data = {"name": "musen", "age": 18, "gender": "男"} for k, v in data.items(): setattr(m, k, v) print(m.__dict__) print(m.name) print(m.age) print(m.gender) # --------------------------动态获取属性-------------------------------------- class MyClass: attr = 100 name = '木森' age = 18 key2 = 'attr' res = getattr(MyClass,key2) print(res) key = input("请输入要获取的属性") res = getattr(MyClass,key) print(res) # -------------------------动态删除属性---------------------------- class MyClass: attr = 100 name = '木森' age = 18 del MyClass.name print(MyClass.__dict__) key = input("请输入要删除的属性") delattr(MyClass, key) print(MyClass.__dict__) try: res = MyClass.attr1 except: print("没有attr1属性") else: print('有attr1属性') res = hasattr(MyClass,'attr1') print(res) if hasattr(MyClass,'name'): print('有name')
- 动态属性设置:setattr()
-
多继承(了解)
-
多继承:同时继承多个父类
class BaseA: A = 100 def func(self): print('-----A---func') class BaseB: B = 200 def func(self): print('-----B---func') class MyClass(BaseA, BaseB): def func(self): print('-----MyClass----func') super().func() m = MyClass() m.func()
-
基础入门就这么多了