python入门以及接口自动化实践

一、Python入门必备基础语法
# 标识符：python中我们自己命名的都是标识符
# 项目名 包名 模块名
# 变量名 函数名 类名
# 1：字母 下划线 数字组成 命名的时候不能以数字开头
# 2：见名知意：不同的字母和数字之间用下划线隔开
# 3：项目名 包名 模块名 变量名 函数名 都是小写字母，不同的字母之间用下划线隔开
# 4：类名 首字母大写驼峰命名 StudentInfo HttpRequest
# 5：不能以关键字作为标识符 int str float class def...

# 行和缩进：利用缩进来控制代码的级别

# 注释：#表示单行注释 快捷键 ctrl+/ ''' '''成对的三个单引号括起来的内容就是多行注释

# 多行语句 连接符
print('hello\
python\
666')

#python的引号 单引号 双引号 多引号
#成对的单引号 成对的双引号 三引号括起来的内容都是字符串
a='666'
b="666"
c='''666'''
# type()可以帮助判断数据的类型

# 转义：把一些特殊字符变成普通字符
str_1='hello,\'python\''
print("这是第一行\n这是第二行")
print("这是第一行\\n这是第二行")
print(r"这是第一行\n这是第二行")
print(R"这是第一行\n这是第二行")

#python文件的输入输出
# input()从控制台获取一个数据，数据类型是字符串str
# print()

二、python变量以及常用数字类型
# 变量
# 一旦创建了一个变量，然后赋值，就会存储在python内存里
# 如果要引用一个变量，那么在引用之前，要确定是否已经定义并赋值
# 变量命名规范：字母 下划线 数字组成 命名的时候不能以数字开头，都是小写字母

# python常见的数据类型
# 数字 字符串 元组 列表 字典
# 数字：整数 浮点数

# python里面常用的数字的数据：int float 关键词
# type()可以帮助判断数据的类型

# 格式化输出

三、Python字符串的取值&运算
a='python'
# python常用数据类型之一 字符串
# 成对的双引号 或者成对的单引号括起来的内容就是字符串

# 字符串的取值访问

print(a)
print(a[3])

# 字符串：字符串里的元素是由一个个的字符组成
# 字符串都是有索引 从0开始数的
# 字符串的取值方式 字符串名[索引值]
print(a[4])

# 反序访问：从-1开始
print(a[5])
print(a[-1])

# 怎么处理字符串里的特殊字符 转义\ 加r/R
# \n \t \r
a='python\\tpython'
print(a)

# 字符串的运算：+ *
# + 拼接字符串

# * 重复字符串输出

# 判断字符串in not in 成员运算符 返回布尔值True False
a='hello'
print('t' in a)

#如果不同类型的数据拼接
a=666
b='hello'
print(str(a)+b)

四、Python字符串的切片运用
# 字符串的切片
# 根据字符串的索引去取值，缺点：只能取单个值
# 切片：可以根据你的要求去取值 子字符串
# 字符串的切片：字符串名[m:n:k]
# m索引开始的地方 n索引结束的地方 k步长
a='python'
res=a[0:6:1]
print(res)
#k=1 0 1 2 3 4 5取左不取右 n-1就结束了索引的取值
res=a[0:6:2]
print(res)#k=2 0 2 4
res=a[0:6]#如果不输入k，那么k就取默认值k=1 0 1 2 3 4 5
print(res)
res=a[:]#从头取到尾
print(res)
res=a[1:]#默认取完所有的值
print(res)

# 什么时候用切片
# 只想取个值 根据索引来取值
# 如果想获取字符串里的子字符串，就可以用切片

五、Python字符串的格式化输出
# 格式化输出%d整数 %f浮点数 %s字符串
age=18
name='python'
score=99.99
# print(name+",今年"+str(age)+'岁')
# print(name+",今年",age,'岁')

print("%s今年%d岁,数学考了%.2f"%(name,age,score))#按顺序取值
# %d必须放一个整数，%f可以放一个整数也可以放一个浮点数，%s可以放任意值

# 第二种格式化输出 format{}
print("{0}今年数学考了{1}".format(name,score))
# {}里面不指定数值，就会按顺序取值
#{}里面指定数值，就会根据你设置的去取值
#format里面的数据也是有索引的，从0开始标记数据

六、Python字符串的内建函数使用
str_1='hello'
str_2='python'
# 1、字符串的大小写切换 upper() lower()
res=str_2.lower()
print('转换后的结果:{}'.format(res))

# 2、字符串的查找 find()函数
# 单个字符 如果能够找到 就返回单个字符在字符串里的索引值
# 子字符串 如果能够找到 就返回子字符串的第一个元素在原来字符串里面的索引值
# 没找到 返回-1
res=str_1.find('h')
print('查找的结果:{}'.format(res))

# 3、字符串的替换 replace()函数 内建函数可以指定替换次数
res=str_1.replace('l','@',1)
print(res)
print(str_1)

# 4、字符串的切割split()
res=str_1.split('l')
print(res)#返回列表类型的数据，但是元素类型还是字符串

str_3='@@@hello@@@'
# 5、字符串头尾的处理　strip()
res=str_3.strip('@')
print(res)

七、Python之元组的学习和使用
# 数据类型 元组
#1. 元组的标志() 关键字tuple
#2. 元组只有一个数据的时候，请加逗号在数据后面，不然就不是元组类型的数据
#3. 元组里面的数据可以是任何类型 数字 字符串 元组 列表 字典
#4. 元组取值 是根据索引取值，也分为正序和反序（操作同字符串） 元组名[索引值]
#5. 元组切片
#6. 元组的值一旦确定 就无法再更改！删除新增修改都不允许
#7. 判断元素 in not in

tuple_1=()#空元组
tuple_2=(1,)
tuple_3=(1,0.02,'lemon',(1,2,3))

# type()
print(type(tuple_1))
print(type(tuple_2))

八、Python之列表的基础使用
# 数据类型：列表 在python里面是属于使用率最高的数据类型
# 1.标志 [] 关键字list
# 2.a=[]空列表
# 3.里面数据元素可以是任何类型
# 4.列表的取值 也是根据索引来取值 列表名[索引值] 正序反序
# 5.列表的切片 操作同字符串 列表名[m:n:k]
# 6.判断元素 in not in 成员运算符

a=[1,0.05,'python',(1,2,3),[4,5,6]]
print(type(a))
print(a[2])
print(a[0::2])
print(0.05 in a)
print(a[-1][-1])

九、python之列表常用函数
# 列表支持增加删除修改 切片 索引

a=[1,0.05,'python',(1,2,3),[4,5,6]]

# 1.新增操作
# 1）列表名.append() 加元素到列表的最后面 每次只能添加一个元素

# a.append('study')
# print(a)

# 2）列表名.insert() 加元素到列表的指定位置
# a.insert(0,'studying')
# print(a)

# 2.修改列表的元素值
# a[-1]='热爱学习的我'
# print(a)

# 3.删除元素
# 1）列表名.pop() 删除列表的最后面一个元素
# a.pop()
# print(a)
# 2）列表名.pop(index) 删除列表指定位置的元素
a.pop(2)
print(a)

# 4.其他列表
c=[7,6,5,4,3,2,1]
c.sort()#排序
c.reverse()#倒置
c.clear()#清空列表
print(c)

十、Python之字典学习和使用
# 字典
# 1、标志{} 关键字 dict
# 2、a={} 空字典
# 3、字典的数据存储格式是 key:value 键值对
# 4、字典里的value可以是任何类型的数据
# 5、取值方式：根据key取值 字典名[key]
# 6、新增一个元素 字典名[new_key]=value new_key不存在当前字典里
# 7、修改一个元素的值 字典名[old_key]=value old_key存在当前字典里
# 8、删除操作
# 9、清空操作 字典名.clear()
a={'name':'python','age':18,'money':99.99,'score':[100,100,80]}
print(type(a))
print(a)

print(a['name'])

a['sex']='girl'
print(a)

a['money']=1000
print(a)

a.pop('score')
print(a)

十一、python之字典常用函数
a={'name':'python','age':18,'money':99.99,'score':[100,100,80]}

# 增删改查
# 增加元素 如果key不存在 那么就是添加一个新值
# a['class']='python'
# print('修改之后的字典值：{0}'.format(a))

# 修改元素 如果key存在 那么就是修改key对应的值
# a['name']='java'
# print('修改之后的字典值：{0}'.format(a))

# 查询元素 字典名[key]
# print('字典里的姓名是：{0}'.format(a['name']))

# 删除元素 字典是无序的 只能根据key删除 字典名.pop(key)
# a.pop('age')
# print('删除操作之后的字典值：{0}'.format(a))

# 拓展方法：
# a.clear()#清空字典

# del a['money'] #del 字典名[key] 删除指定key的元素
# print(a)
# a.popitem()#随机删除一组数据
# print(a)

# 取值的一些方法
print(a.keys())
print(a.values())
print(a.items())

#a.update(c) c里面的key如果在a里存在，那么就会把c的value值更新到a里面去
#如果不存在，那么就把不存在的key-value添加到a里面去
c={'name':'java','age':'none','class':'javastudy'}
a.update(c)
print(a)

for i in a.keys():
print(i)

十二、Python之运算符
# 算术运算符 + - * / %
# +数字的相加以及字符串的拼接
# *数字的相乘以及字符串的多次拼接
# %取余运算 一般用来判断是否可以整除 或者判断是否是偶数还是奇数

# 赋值运算符 = += -= *= /=

# 比较运算符> >= < <= != == 返回的值类型是布尔值 True False

# 逻辑运算符 and or not 返回的值类型是布尔值 True False

# 成员运算符 in not in 返回的值类型是布尔值 True False
# 判断某个元素是否存在于数据里面
L=[1,2,3,4,'HELLO']
print('H' in L[-1])

c={'name':'java','age':'none','class':'javastudy'}
print('java' in c.values())

十三、python之if条件语句
# 1、if 条件表达式：
# 满足条件表达式（True）要执行的代码

# 2、if 条件表达式：
# A代码
# else：
# B代码

# 3、if...elif...else

# 条件语句：
# 1）、一组条件语句里面 只有一个if 可以有0个或1个else 可以有0个或多个elif
# 2）、if elif 后面必须加条件表达式 否则会报错
# 3）、else 后面不能加条件表达式 否则会报错
# 4）、可以根据不同情况去进行分支划分

# 非0的数字就代表True 0就代表False
# 空数据 空列表 空字符串 空字典 空元组 都是 False
# 非空字典 列表 字符串 元组都是True

十四、python之while循环&break&continue
# while循环
# 死循环
# 非0的数字就代表True 0就代表False
# 空数据 空列表 空字符串 空字典 空元组 都是 False
# 非空字典 列表 字符串 元组都是True

# break:结束循环
# continue：结束本次循环继续下一次循环

十五、python之嵌套for循环&range
s='lemon'
L=['java','python']
t=(1,2,3,0.4,'hi')
d={'name':'python','course':'java'}
for item in s:#for 遍历in后面的数据类型里面的每一个元素 依次挨个访问
print("******item*****:",item)

# for循环 循环的次数 是由in后面的数据类型的元素个数所决定

# range(m,n,k) m开头 n结尾 k步长
# 作用 生成一个整数序列
range(0,5,2)#0 2 4
range(0,10,3)#0 3 6 9

# range(m,n)#k的值默认为1 k=1
# 只传一个值n 开头m默认是0 k默认为1

# 利用range for 完成某个列表的倒序输出
s=[1,2,3,4,5,6,7]
for i in range(6,-1,-1):
print(s[i])

# 嵌套for循环
list_1=[[2,3,8,4,9,5,6],[5,6,10,17,11,2]]

# 请把列表以及列表里面的每一个元素挨个打印出来
for item in list_1:
for value in item:
print(value)
print(type(value))
# print(item)

#利用嵌套for循环打印一个直角三角形到控制台，三角形底边元素都是*
# *
# **
# ***
# ****
# *****

# for i in range(1,6):
# for j in range(i+1):
# if i==j:
# print('*'*j)

for i in range(1,6):
for j in range(i):
print('*',end='')#控制不换行输出
print(' ')#for循环结束后换行

#99乘法表
#1*1=1
#1*2=2 2*2=4
#1*3=3 2*3=6 3*3=9

for i in range(1,10):
for j in range(1,i+1):
print('{0}*{1}={2}'.format(j,i,j*i),end=' ')
print(' ')

十六、python之函数
1）、python之函数的定义

# 自定义函数
# 语法：关键字 def

def print_msg():
'''此函数的作用是完成信息的输出到控制台'''
print('hello python')

# 调用函数 函数名(传递对应的参数)
print_msg()

# 为什么要写函数
# 1：代码可以重用
# 2：保持一致性
# 3：可拓展性

# 函数的三个概念：面向对象 面向过程 函数式编程
# 面向对象--class 类与对象
# 面向过程--def 函数 有return
# 函数式编程--def 函数 没有return

2）、python之函数return关键字
# 面向过程 return
# return后面0个参数 返回的就是None
# return后面1个参数 返回的就是你指定的参数 参数是什么类型 返回的就是什么类型
# return后面有多个参数 返回的参数会放在一个元组里面
# return后面的代码不再执行

def add():#隐式添加return 但是return后面没有任何表达式 所以返回的就是None
print(5+6)

def add_2():
return 6+6

print('第一个函数*****')
add()
result_1=add()
print(result_1)

print('第二个函数*****')
result=add_2()
print('add_2函数运行的结果是：',result)
print(add_2())
# return的作用：当你调用这个函数的时候 会返回一个结果
# 这个结果值 你可以拿到之后 做进一步处理
# 如果没有return 那么返回的就是None

# 什么时候用return 如果想拿到某个函数的运行结果 那么就要就用return

# 利用for循环 range函数编写任意整数序列的求和函数
def add():
count=0
for i in range(1,101,1):
count+=i
return count,666#多加了一个参数
print('函数内部打印求和结果是：',count)

result=add()
print('最终的函数运行结果是：',result)
# 注意点：return相当于一个结束信号，当函数遇到return 后面的代码将不会再执行

3）、python之函数位置参数
# 函数的位置参数 添加参数 参数化
def print_msg(a,b):#位置参数 形参
print(a)
print(b)

print_msg('hello','python')#实参

# 如果是位置参数
# 1：调用函数时候，有几个位置参数 就要传递几个参数
# 2：按顺序赋值，常规用法
# 3：传递的参数 使用顺序不一定按照传递顺序
# 4：参数不一定都会使用
# 5：可以不按顺序赋值，通过形参名的指定去赋值

def add(m,n,k):
count=0
for i in range(1,101,1):
count+=i
return count

result=add(1,101,1)
print('运行结果是：',result)

#三步函数法
# 1：先用零散的代码写出功能要求
# 2：变成函数 def 函数名()
# 3：想办法提高复用性 参数化

4）、Python之函数默认参数
# 默认参数

def greet(name,content='你好呀'):
'''函数的用处是向不同的用户发问候'''
print(name+content)

greet('python','hello')
greet('同学们')
greet(content='python',name='hello')
# 默认参数
# 1：带有默认值的参数，必须放在没有默认值的位置参数后面
# 2：默认参数可以有多个 在遵守条件1的前提下
# 3：如果有默认值，这个参数可以不传值，不传值就取默认值，传值就以传的值为准
# 4：按顺序赋值，也可以通过形参名去指定

5）、Python之函数动态参数
# 不定长参数/动态参数 *变量名 *args argument
def add(*args):
print(args)
print('args的类型：',type(args))#元组
count=0
for item in args:
count+=item
return count

result=add(1,2,3,4,5,6,7)
print('动态参数的求和结果',result)
# 1:什么时候用这个动态参数-->当你不确定参数个数的时候，就可以用动态参数
# 2:位置参数和动态参数的结合使用 位置参数放在动态参数的前面
# 3:默认参数和动态参数的结合使用 默认参数放在动态参数的后面

6）、python之函数关键字参数

# 关键字参数 **kwargs key word arguments-->字典类型
# 参数类型key value
def study(**kwargs):
print(kwargs)
for item in kwargs.values():
print(item)

study(t_name='youxian',t_course='python')

# 结合位置参数 位置参数必须放在关键字参数前
# 结合默认参数 默认参数必须放在关键字参数前

十七、python类与对象

# 类
# 他们具有共同的特征===划分为一个类
# 标准：编写代码的人来定义

# 在python如何用代码表达出来
# python类与对象知识
# 关键字 class 类里面一般包含 属性以及方法
# self就是实例本身

# 属性 1、实例属性 2、类属性 3、私有属性

# 1、类方法 @classmethod
# 什么时候定义为类方法？1）、如果想直接通过类名.函数名调用 2）、当有初始化函数的时候，可以直接定义为类方法
# 3）、类方法不能访问实例属性 必须传入cls参数（类本身），并且用此来调用类属性：cls.类属性名
# 2、静态方法 @staticmethod
# 什么时候定义为静态方法？1）、如果想直接通过类名.函数名调用 2）、当有初始化函数的时候，可以直接定义为类方法
# 3）静态方法不能访问类属性和实例属性，参数不能传入self，与类相关但是不依赖类与实例的方法

# 3、实例方法 参数(self)是实例本身---常用
# 实例方法如果是调用类里面的属性 self.属性名
# 如果是实例方法自己带参数，参数传递的规则同普通函数

# 类方法 静态方法 实例方法
# 1、都可以被实例调用
# 2、只有静态方法和类方法，可以直接通过类名.函数名()调用
# 3、静态方法和类方法，不能调用实例属性

# 类属性与类方法是类固有的方法和属性，不会因为实例不同而改变，写他们的目的是减少多实例时所创造出来的内存空间，加快运行速度

class BoyFriend:
# 类属性
height=175
money=200000
name="***"
age=28
# def __init__(self,height,money,name,age):
# self.height=height
# self.money=money
# self.name=name
# self.age=age
#行为特征--->方法 跟普通函数80%相似度
def cooking(self):#类函数与普通函数的区别
print("打印self",self)#self就是实例本身
print(self.name+"会做饭")

@staticmethod#静态方法
def hiking():
print("喜欢户外运动")

@classmethod#类方法
def swimming(cls):
print(cls.name+"喜欢游泳")

def coding(self,sex,language='java'):
print(self.name+",{0},会写{1}代码".format(sex,language))

#怎么调用类里面的属性和函数呢---通过实例/对象
# 创建实例：类名()
# 调用方法 实例.方法
# 调用属性 实例.属性

# 直接以实例调用
bf=BoyFriend()
bf.coding('女','python')
bf.coding('女')
bf.cooking()
bf.hiking()#实例调用静态方法
print("打印实例",bf)
print(bf.height)
print(bf.money)

# 把实例作为参数传递进去
bf_1=BoyFriend
print(bf_1)
print(BoyFriend.age)#类调用属性
BoyFriend.swimming()#类方法
BoyFriend.hiking()#类调用静态方法
bf_1.cooking(BoyFriend())

十八、python之requests接口自动化
# http消息：请求消息和响应消息
# 请求消息组成：请求行、请求头、空行、请求体
# 响应消息组成：状态行、响应头、空行、响应正文

# HTTP典型响应状态码
# 200 客户端请求成功
# 302 重定向
# 400 客户端请求有语法错误，不能被服务器识别
# 403 服务器收到请求，但拒绝提供服务
# 404 请求的资源不存在
# 500 服务器发生不可预期的错误

import requests
url="http://www.baidu.com"
res_get=requests.get(url)
# res_post=requests.post(url)
print("get请求的结果",res_get)
# print(res_post)
print("get请求的状态码",res_get.status_code)
print("get请求的响应报文",res_get.text)#html text xml
# print("get请求的响应报文",res_get.json())#确保返回的数据格式是json
print("get请求的响应头",res_get.headers)
print("get请求的请求头",res_get.request.headers)