首页 / PYTHON / python基础,入门教程.
python基础,入门教程.
内容导读
互联网集市收集整理的这篇技术教程文章主要介绍了python基础,入门教程.，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含38909字，纯文字阅读大概需要56分钟。
内容图文
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()
-
基础入门就这么多了
内容总结
以上是互联网集市为您收集整理的python基础,入门教程.全部内容，希望文章能够帮你解决python基础,入门教程.所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。
内容备注
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。
内容手机端
扫描二维码推送至手机访问。