UI自动化测试/python编程

目录

(一)认识python

1、python背景介绍

2、python的特点

3、python的缺点

4、python的版本问题

5、认识python解释器和pycharm工具

5.1、安装python解释器

5.2、pycharm（集成开发工具）

(二)快速入门

1、变量赋值

2、标准数据类型（Number数字）

3、标准数据类型（String字符串）

3.1、字符串基础应用

 3.2、字符串合并和拆分

3.3、字符串常用函数

4、List（列表）/Tuple（元祖）

4.1、列表和元祖基础应用

4.2、列表常用操作

4.3、列表和元祖的区别

5、Set（集合）

6、Dictionary（字典）

7、输入输出函数

8、注释&编码

9、运算符

10、对象和变量引用

11、条件判断语句

12、循环语句

12.1、while循环

12.2、for循环

12.3、使用for生成列表

13、自定义函数&不定长参数

14、作用域&文档字符串

15、总结示例

15.1、示例一

15.2、示例二

15.3、示例三

15.4、示例四

16、文件操作

17、异常

18、模块

19、包

 20、猜数字游戏

20.1、解决No python interpreter for the object（该对象没有python解释器）

21、类

---

(一)认识python

1、python背景介绍

●python的格言：Life is short，use python。（人生苦短，我用python）
●由Guido van Rossum于1989年圣诞节为打发无聊时间，而开发的一个新的脚本解释程序，第一个公开发行版本于1991年。
●至于为什么选中python作为语言名字，是因为他是一个叫Monty python的喜剧团队的爱好者。

2、python的特点

●优雅、明确、简单。
●python是一个下限特别低（少儿编程），上限特别高的编程语言（人工智能）。
●下限特别低：上手容易，特别适合啥都不懂的小白作为第一们编语言。通过简单的代码就能做出实用的功能，特别容易培养兴趣。
●python语言简洁，表达能力强。
●python代码量小，维护成本低，编程效率高，标准库强大，第三方库非常丰富（比如：xlrd、pillow、selenium、appium、requests等），目前已经成为全世界最广泛使用的编程语言之一。
●同样的问题，用不同的语言解决，代码量差距多，一般情况下python是java的1/5，所以说人生苦短，我用python，多留点时间做点自己喜欢的事情吧，不要浪费太多时间在编码上面。
●解释运行。python是一种解释型语言（脚本语言）。和C/C++不同，，不是先将源代码文件转化成可执行文件，再执行，而是直接由python解释器一行一行的读取源代码，每读一行就执行一行。但严格意义上讲，python算是一种“半编译，半解释”型语言。一方面，python解释器会按行读取源代码文件，然后会将源代码转为供python解释器直接执行的“字节码”，然后再执行字节码。
●跨平台。python是基于python的解释器来进行执行。只要某个操作系统/平台上能运行python解释器，就可以完美的运行python的源代码。主流的windows、Linux、Mac等操作系统上都能够很好的支持python。
●可扩展性强。python可以很容易的调用C/C++语言。如果觉得哪里的逻辑性能不能满足要求，可以使用C/C++重构部分模块，用python调用。

3、python的缺点

●执行效率低。
●但是，在摩尔定律的作用下，硬件越来越便宜，反而是开发人员的成本原来越高，一些好的编程实践可以帮助我们写出比较高性能的代码，python解释器的执行效率也在不断被优化。

4、python的版本问题

●python3虽然是python2的升级版，但是很多语法并不兼容。
●关于兼容性：
①C++能非常好的兼容C语言（C语言写的代码可以直接使用C++编译器进行编译），但是也意味着C++背负着很多C语言的历史包袱。
②但是python3和python2很多地方不兼容（python2写的代码，不能很顺利的在python3的解释器上执行）。
③这样做是好是坏，不便评说，还是要看几年之后的最终结果是好是坏，才能棺盖定论。这样意味着很多已经用python2写好的代码不会很顺利的升级到python3。
④但是这样也意味着python3可以不用背负历史包袱，大刀阔斧的把一些不合理的地方修改掉。
⑤官方的说法是python2最多维护到2020年便停止更新。

5、认识python解释器和pycharm工具

5.1、安装python解释器

①下载对应机器的安装包

②双击下载好的安装包进行安装，安装路径可自定义也可默认
③全部进行勾

④默认勾选三个，如图所示
⑤点击安装
⑥安装成功
⑦win+R弹出运行窗口输入cmd，点击确定按钮
⑧弹出命令窗口，输入python点击Enter查看是否配置成功

5.2、pycharm（集成开发工具）

①点击pycharm-professional-173.3727.88安装包进行安装
②选择Next

③根据自身需要更改安装路径，点击Next进入下一步

④根据自身需要选择勾选64-bit launcher或32-bit launcher     .py     点击Next进行下一步

⑤点击Install,然后就是静静的等待安装了。如果我们之前没有下载有Python解释器的话，在等待安装的时间我们得去下载python解释器

⑥安装完成

(二)快速入门

1、变量赋值

# 变量和赋值
# 动态类型  type(变量)
# python中的变量不需要声明，直接定义即可使用，会在初始化的时候决定变量的“类型”
# 使用 = 来进行初始化和赋值操作
counter = 0
miles = 1000.00
name = "wms"
kilometers = 152 * miles
print(counter,miles,name,kilometers)

# python中也支持增量赋值
n = 10
n = n * 10   # 100
n *= 10   # 1000
print(n)

#但是python中不支持 ++/-- 这样的自增、自减操作，只能写成：
n += 1   # n = n + 1 == 1001
print(n)

# 运行结果：
# 0 1000.0 wms 1666.0
# 1000
# 1001

2、标准数据类型（Number数字）

# Number(数字)
# python中没有int，float这样的关键字，但是实际上数据的类型是区分int，float这样的类型的
# python3支持int(长整型)、float、bool、complex(复数)
# 内置函数type()可以用来查询变量所指的对象类型

a = 1
print(type(a))
b = 0.1
print(type(b))
c = True
print(type(c))
d = 10 + 5j
print(type(d))

# 此外，还可以用insinstance来判断
num = 222
result = isinstance(num,int)
print(result)

# 布尔值表示真(True)和假(False)
# 布尔类型的变量，也是一种特殊的整数类型，在和整数进行运算时，Ture被当做1，False被当做0
b1 = True
sum = b1 + 2
print(sum)   # 3

3、标准数据类型（String字符串）

3.1、字符串基础应用

# python中可以使用单引号(')、双引号(")、三引号('''/""")来表示字符串
str1 = 'python_wms'
str2 = "python_wms"
str3 = '''python_wms'''
str4 = """python_wms"""
print(str1,str2,str3,str4)   # python_wms python_wms python_wms python_wms

# 字符串中含有引号
str5 = 'I am "python_wms"'
print(str5)   # I am "python_wms "

# 同时使用反斜杠\转译特殊字符，如：换行符\n
name = 'My name is \n wms.'
print(name)
# 运行结果
# My name is
# wms

# \ 本身需要 \\ 这样的方式来表示
str6 = '\\index\\'
print(str6)   # \index

# 使用索引操作符[]或者切片操作符[:]来获取子字符串。（切片操作是一个前闭后开区间）
# 字符串的索引规则：第一个字符索引是0，最后一个字符索引是-1
str7 = 'hello world!'
print(str7[0])   # h
print(str7[-1])   # !
print(str7[1:3])   # el
print(str7[:3])   # hel
print(str7[3:])   # lo world!
print(str7[:])   # hello world!
print(str7[::2])   # hlowrd
print(str7[::-1])   # !dlrow olleh

# +用于字符串连接运算：* 表示赋值当前字符串，与之结合的数字为复制的次数
str8 = 'tester'
str9 = 'wms'
print(str8 + str9)   # testerwms
print(str8 * 1)   # tester
print(str8 * 0)   # 空
print(str8 * 3)   # testertestertester
print(str8 * -1)   # 空

# python没有“字符类型”这样的概念，单个字也是字符串
str10 = 'tester'
print(type(str10[0]))   # 

# 格式化字符串：%s:   格式化整型：%d
name = 'python_wms'
num = 1
print('尊敬的%s用户，您抽到的号码是%d'%(name,num))   # 尊敬的python_wmsyonghu1,您抽到的号码是1

# 内建函数len获取字符串的长度
str11 = 'hello world!'
print(len(str11))   # 12

# 原始字符串（raw strings）
print(r'/n hello /n world!')   # /n hello /n world!

 3.2、字符串合并和拆分

# 字符串合并和拆分
# 将列表中的字符串合并成一个字符串
b = "-"
a = ["wel","come","to","beijing"]
print(b.join(a))   # wel-come-to beijing

# 按空格将字符串拆分成列表
# 应用：接口自动化测试的时候，批量获取csv文件中的username,password
c = "he ll o wor l d !"
print(c.split(" "))   # ['he','ll','o','wor','l','d','!']

3.3、字符串常用函数

# 字符串常用函数
# 判定字符串的开头结尾
a = "hello world.my name is python_wms"
print(a.startswith("he"))
print(a.endswith("wms"))
print(a.startswith("wms"))
# 运行结果
# True
# True
# False

# strip（）去除字符串开头结尾的空格/换行符
b = "   welcome to my house \n   "
print(b)
print(b.strip(),end="---")
# 运行结果
#    welcome to my house
#
# welcome to my house---

# 查找子串
c = "hello world!"
print("\n")
print(c.find("wor"))   # 6 返回下标，下标从0开始
print(c[6])   # w
print(c.find("123"))   # -1 表示没有找到

# 替换子串（字符串是不可变对象，只能生成新的字符串）
d = "welcome to my house!"
print(d.replace("house","home"))   # welcome to my home!
print(d)     # welcome to my house!

# 判定字符串是字母还是数字
# str.isalpha（）如果字符串至少有一个字符并且所有的字符都是字母，则返回True
# str.isdigit（）如果字符串只包含数字则返回True，否则返回False
e = "123456"
f = "abc"
g = "123abc"
print(e.isalpha())
print(e.isdigit())
print(f.isdigit(),f.isalpha(),g.isdigit(),g.isalpha())
# 运行结果
# False
# True
# False True False False

4、List（列表）/Tuple（元祖）

4.1、列表和元祖基础应用

# 列表和元祖类似于C语言中的数组，使用[]来表示列表，用（）来表示元祖
# 对象有序排列，通过索引读取，下标从0开始，最后一个下标为-1
# 能保存任意数量、任意类型的python对象，可以是数字、字符串、元祖、其它列表、字典
a_list = [1,3.666,[1,2,3],{"name":20,20:10},4,(1,2,3,4),"string",True]
print(a_list,type(a_list))
print(a_list[0],a_list[-1])
a_tuple = (1,2,3,4)
print(a_tuple,type(a_tuple))
# 运行结果
# [1, 3.666, [1, 2, 3], {'name': 20, 20: 10}, 4, (1, 2, 3, 4), 'string', True] 
# 1 True
# (1, 2, 3, 4) 

 # 可以使用[:]切片操作得到列表或元祖的子集，这个动作和字符串操作是一样的
a_list = [1,3.666,[1,2,3],{"name":20,20:10},4,(1,2,3,4),"string",True]
print(a_list[0:2])   # 从0索引开始，取两个[1,3.666]
print(a_list[:])   # [1,3.666,[1,2,3],{"name":20,20:10},4,(1,2,3,4),"string",True]
print(a_list[::-1])   # [True, 'string', (1, 2, 3, 4), 4, {'name': 20, 20: 10}, [1, 2, 3], 3.666, 1]
a_tuple = (1,2,3,4)   # 列表和元祖唯一的区别是：列表中的元素可以修改，但是元祖中的元素不能修改
a_list[0] = 0
print(a_list)   # [0,3.666，...]

# a_tuple[0] = 0   # TypeError:'tuple'object does not support item assignment

# 理解元祖的不可变
# 元祖的不可变指的是元祖元素的id不可变，就是说一个元祖包含了几个对象
# 然后不可以给这几个元祖再添加或者删除其中的某个对象
# 也不可以将某个对象改成其他的对象
# 但是，如果元祖中的某个元素是可变对象（比如列表或字典），那么仍然可以修改
a_tuple02 = (1,2,[1,2,3,4])
print(a_tuple02)   # (1,2,[1,2,3,4])
a_tuple02[2][0] = 0
print(a_tuple02)   # (1,2,[1,2,3,4])

# 排序
# sorted（）排序：这是一个非常有用的函数，返回一个有序的系列（输入参数的副本）
a_list = [1,5,2,3,80,55,66]
a_tuple02 = sorted(a_list)   # 不会破坏原本的列表，而是自己生成一个排序后的新列表
print(a_list)   # [1, 5, 2, 3, 80, 55, 66]
print(a_tuple02)   # [1, 2, 3, 5, 55, 66, 80]

# sorted（）支持自定义排序规则
# 逆向排序
print(sorted(a_list,reverse=True))   # [80, 66, 55, 5, 3, 2, 1]
a_list03 = ["abc","name","u"]
print(sorted(a_list03,key=len))   # ['u', 'abc', 'name']

# sort（）排序，会改变列表本身
a_list04 = [1,5,2,6]
print(a_list04)   # [1, 5, 2, 6]
a_list04.sort()
print(a_list04)   # [1, 2, 5, 6]

4.2、列表常用操作

# append（）：追加元素
a_list = [1,2]
a_list.append(3)
print(a_list)   # [1,2,3]

# 删除指定下标元素
a_list02 = [6,5,4,3,2,1]
del a_list02[0]
print(a_list02)   # [5, 4, 3, 2, 1]

# remove（）按值删除元素
a_list02.remove(3)
print(a_list02)   # [5, 4, 2, 1]
# a_list02.remove("1")   # ValueError:list.remove(x):x not in list 删除不存在的值会提示not in

# 列表比较操作： ==/= 判定所有元素都相等，则认为列表项等
# < > <= >= 则是两个列表从第一个元素开始依次比较，直到某一方胜出
a = ["abc",1233]
b = ["xyz",789]
c = ["abc",823]
print(a < b)
print(b < c)
print(b > c and a == c)
# 运行结果
# True
# False
# False

# 删除列表中指定的值（全部删除）
# 删除列表中所有的2
a_list = [1,2,2,3,5,2,2,8,9,2]
n = len(a_list)
new_list = []
for i in range(0,n):
    if a_list[i] == 2:
        pass
    else:
        new_list.append(a_list[i])
print(a_list)
print(new_list)
# 运行结果
# [1, 2, 2, 3, 5, 2, 2, 8, 9, 2]
# [1, 3, 5, 8, 9]

4.3、列表和元祖的区别

1、列表和元祖唯一的区别是：列表中的元素可以修改，但是元祖中的元素不能修改。
2、理解元祖的不可变（子元素不可改，若子元素是一个列表那么列表里面的内容可以改）
元祖的不可变指的是元祖元素的id不可变，就是说一个元祖包含了几个对象，然后不可以给这几个元祖再添加或者删除其中的某个对象，也不可以将某个对象改成其它的对象，但是，如果元组中的某个元素是可变对象（比如列表或字典），那么仍然可以修改。

5、Set（集合）

# 集合（Set）是一个无序的不重复元素序列
# 可以使用大括号{ }或者set（）函数创建集合，注意：创建一个空集合必须用set（）而不是{ }，因为{ }是用来创建一个空字典
# 创建格式：
a_set = {50,20,20}
print(a_set)   # {50, 20}
value = {50,20,20}
a_set02 = set(value)
print(a_set02)   # {50, 20}

basket = {'apple','orange','apple','pear','orange','banana'}
print(basket)   # {'pear', 'banana', 'orange', 'apple'}这里演示的是去重功能

print('orange'in basket)   # True 快速判断元素是否在集合内
print('crabgrass'in basket)   # False

# 下面展示两个集合间的计算
a = set('name')
b = set('username')
print(a)   # {'a', 'n', 'm', 'e'}
print(b)   # {'n', 'a', 'm', 'r', 'e', 's', 'u'}
print(a - b)   # set()空集合 集合a中包含而集合b中不包含的元素
print(a | b)   # {'n', 'r', 'e', 'a', 'u', 's', 'm'} 集合a或b中包含的所有元素
print(a & b)   # {'m', 'n', 'a', 'e'} 集合a和b中都包含了的元素
print(a ^ b)   # {'s', 'u', 'r'} 不同时包含于a和b的元素

6、Dictionary（字典）

字典是python中的映射数据类型，存储键值对（key：value），无序（3.7有优化，相对有序，按输入的顺序显示），几乎所有类型的python对象都可以用作键。 不过一般是数字和字符串最常用，且key不能重复。使用{ }表示字典。

# 字典是python中的映射数据类型，存储键值对（key：value），无序（3.7有优化，相对有序按输入的顺序显示）
# 几乎所有类型的python对象都可以用作键。不过一般是数字和字符串最常用，且key不能重复
# 使用{ }表示字典
a_dic = {'name':'poo-poo-cai','age':21}   # 创建字典
print(type(a_dic))   # 
print(a_dic["name"])   # poo-poo-cai 取字典中的元素
a_dic['name'] = "小趴菜"   # 修改值
print(a_dic["name"])   # 小趴菜
a_dic["address"] = "北京"   # 插入新的键值对
print(a_dic["address"])   # 北京

# 删除某一个键值对，del
del a_dic['address']
print(a_dic)   # {'name': '小趴菜', 'age': 21}

# 使用clear（)方法，清空整个字典中所有的键值对
a_dic02 = {"username":"007",7:8}
print(a_dic02)   # {'username': '007', 7: 8}
a_dic02.clear()
print(a_dic02)   # {}

# 使用pop（)方法，清空整个字典中所有的键值对
a_dic03 = {"age":20,"habits":"play computer"}
print(a_dic03)   # {'age': 20, 'habits': 'play computer'}
habits = a_dic03.pop("habits")
print(a_dic03)   # {'age': 20}
print(habits)   # play computer
# 注意：字典也是可变对象，但是键值对的key是不能修改的

# keys（）：返回一个列表，包含字典的所有key
# values():返回一个列表，包含字典的所有value
# items（）：返回一个列表，每一个元素都是一个元祖，包含了key和value
a_dic04 = {'name':'poo-poo-cai','age':21,"address":"陕西"}
print(a_dic04.keys())
print(a_dic04.values())
print(a_dic04.items())
# 运行结果
# dict_keys(['name', 'age', 'address'])
# dict_values(['poo-poo-cai', 21, '陕西'])
# dict_items([('name', 'poo-poo-cai'), ('age', 21), ('address', '陕西')])

7、输入输出函数

# 输入和输出
# print函数，将结果输出到标准输出（显示屏）上
# input函数，从标准输入中获取用户输入
name = input('小趴菜')
print('小趴菜',name)
# 运行结果
# 请输入你的姓名：小趴菜
# 你的姓名是：小趴菜

# input返回的结果只是一个字符串，如果需要获取一个数字，需要使用int函数把字符串转换成数字
num = input('please input a number:')
print('type:',type(num),end="---")   # type:
num2 = int(num)
print('your number is:',num2,'type:',type(num2))   # your number is:20 type:

8、注释&编码

python中使用#作为单行注释，#后面的内容都是注释的内容

# python中使用#作为单行注释，#后面的内容都是注释的内容
a = 1.0   # define a

# 查看系统默认编码方式
import sys

print(sys.getdefaultencoding())

# 如果要包含中文，默认不是utf-8的话，需要在代码文件最开头的地方注明
# -*- coding：utf-8 -*-

9、运算符

python中支持+ - * / % （加、减、乘、除、取余）这样的操作符

# 操作符
# python中支持 + - * / % （加、减、乘、除、取余）这样的操作符
a = 1
b = 2
print(a + b)   # 3
print(a - b)   # -1
print(a * b)   # 2
print(a / b)   # 0.5
print(a % b)   # 1

# // 是地板除，无论操作数类型如何，都会对结果进行取地板运算符（向下取整）
print(a // b)   # 0

# ** 表示乘方运算
c = 3
print(c ** 3)   # 27

# 比较运算符，>、<、==、>=、<=、!=，返回一个布尔值
print(2 < 3)   # True
print(2 > 3)   # False
print(2 == 3)   # False
print(2 >= 3)   # False
print(2 <= 3)   # True
print(2 != 3)   # True

# 逻辑运算符and、or、not
# 字符串之间可以使用==或者！ = 来判断字符串的内容是否相同
'test' == 'tester'   # False
'test' != 'tester'   # True

# 字符串之间也可以比较大小，这个大小的结果取决于字符串的字典序
# 从小到大 0-9 A-Z a-z
'a' < 'bb'   # # True

10、对象和变量引用

# 理解引用
# python中可以用id这个内建函数，查看变量的地址
# 对象的三要素：1.type 2.id 3.value
a = 100
print(type(a),id(a),a)
a = 200
print(type(a),id(a),a)
b = a
print(type(b),id(b),b)
b = 300
print(type(b),id(b),b)
# 运行结果
#  140716622593968 100
#  140716622597168 200
#  140716622597168 200
#  2160085242448 300

●给a重新赋值成200，相当于新创建了一个200这样的对象，然后将变量名a重新绑定到200这个对象上。
●将a赋值给b，相当于又创建了一个变量名为b的对象，并将b这个名字和200这个对象绑定到一起。
●再次修改b的值，可以看出其实是又创建了一个300的对象，将b绑定到300这个对象上。
●像创建的a、b这样的变量名，其实只是一个对象的别名，或者叫做变量的“引用”。

11、条件判断语句

# if语句
if 2 > 3:
    print('wang')   # wang

# if else
if 2 > 3:
    print('wang')
else:
    print('dai dai')   # dai dai

# 非0 || True
if 1:
    print('非0')   # 非0

if '':
    print('非0')
else:
    print('空字符串')   # 空字符串

if []:
    print('非0')
else:
    print('空列表')   # 空列表

if {}:
    print('非0')
else:
    print('空字典')   # 空字典

x = int(input("please input x's value:"))
y = int(input("please input x's value:"))
if x > 0:
    if y > 0
        print('x and y > 0')
    else:
        print('y <= 0')
else:
    print('x <= 0')

12、循环语句

12.1、while循环

# while循环
n = 1
while n > 4:
    print('这是我循环的第%d次' % n)
    n += 1

12.2、for循环

# 循环列表
lists = [1, 1.5, True, 5 + 10j, 'wang', (1, 2, 3)]
for list in lists:
    print(list)

dicts = {'id': 666, 'name': 'ce_shi_a_dai', 'sex': 'boy'}
for dict in dicts:
    print(dict)
for k in dicts.keys():
    print(k)
for v in dicts.values():
    print(v, end=' ')   # 666 ce_shi_a_dai boy
print('\n')
for k, v in dicts.items():
    print(k, end=' ')
    print(v, end=' ')   # id 666 name ce_shi_a_dai sex boy

print('\n')
for n in range(1, 5):   # 左闭右开
    print(n)
# 1
# 2
# 3
# 4

常用内置函数/模块（abs、divmod、round、break、continue、pass）

# continue、break、pass
# 查找[1, 100)第一个3的倍数
for n in range(1,100):
    if n % 3 == 0:
        print(n)
        break  # 跳出当前循环   运行结果：3

for n in range(1,100):
    if n % 3 != 0:
        continue   # 终止一次循环
    print(n)
    break   # 运行结果：3

if 3 == 3:
    pass   # 空语句，用来占位

# abs:求一个数的绝对值
a = -20
print(abs(a))   # 20

# divmod:返回一个元祖，同时计算商和余数
a, b = divmod(10, 3)
print(a, b)   # 3 1

# round:对浮点数进行四舍五入
# round有两个参数，第一个是要进行运算的值，第二个是要保留小数点后多少位
r = round(1.66666, 2)
print(r)   # 1.67

12.3、使用for生成列表

# 生成列表
# 使用for循环将生成的值存放到一个列表中
# 生成[0,4)的数字的平方列表
s = [x ** 2 for x in range(4)]
print(s)   # [0, 1, 4, 9]

# 还可以搭配使用if语句
# 获取[0,8)区间中的所有奇数
e = [x for x in range(8) if x % 2 == 1]
print(e)   # [1, 3, 5, 7]

13、自定义函数&不定长参数

# 函数
# 一些可以被重复使用的代码，可以提取出来放到函数中
# python使用def来定义一个函数，使用return来返回结果
def add(num=3):
    num = num + 1
    return num

# 调用函数
num = add()
print(num)
num = add(5)
print(num)

# 理解“形参”和“实参”：形参相当于数学中的未知数这样的概念，实参就是给未知数确定具体的数值
# python中相同名字的函数，后面的会覆盖前面的
# python支持默认参数，函数的参数可以具备默认值
def fun(x=1):
    y = x ** 3
    z = y + x
    return  x, y, z

# python解包（unpack）语法，函数返回多个值，但是我只关注z，不想关注x、y，可以使用_作为占位符
_,_, z = fun(2)
print(z)

# 我们是实现一个打印日志的函数，这个函数第一个参数是一条日志的前缀，后续可能有n个参数
# n个参数之间使用\t（tab键）分割，join（）方法用于将序列中的元素以指定的字符连接成一个新的字符串
def log(prefix, *data):
    print(prefix + "\t".join(data))

# 调用函数
log('[Notice]', "hello", "world")   # [Notice]hello	world

# 不定长参数
def bdc(*canshu):
    print(canshu)

bdc(1, 1.5, True, 'hello')   # (1, 1.5, True, 'hello')

# 通过在参数名前加两个星号，星号后面的部分表示传入的参数是一个字典
# 这时候调用函数就可以按照键值对的方式传参
# 成对传参
def chengdui(**kv):
    print(kv)

chengdui(name='wang', age=21)   # {'name': 'wang', 'age': 21}

14、作用域&文档字符串

# 作用域
# python中，def、class会改变变量的作用域
# if else elif while for try 不会改变变量的作用域
# global

for i in range(3):
    print(i)
print(i)   # 即使出了for循环语句块，变量i仍然访问到i变量

def fun(**kv):
    """全局变量"""
    global new_kv
    new_kv = kv
    return kv
# 运行结果
# 0
# 1
# 2
# 2

kv = fun(name='wang', age=21)
print(kv)   # {'name': 'wang', 'age': 21}
print(new_kv)   # {'name': 'wang', 'age': 21}

# 文档字符串
# 写注释对于提升程序的可读性有很大的帮助，前面我们介绍了 # 来表示单行注释
# 对于多行注释，我们可以使用三引号（'''/"""）在函数/类开始位置表示，这个东西也被称为文档字符串

def fun():
    """文档字符串"""

# 使用对象的doc属性就能看到这个帮助文档
print(fun.__doc__)   # 文档字符串
# 或者内建函数help也可以做到相同的效果
help(fun)
# help on function fun in module __main__
# fun()
# 文档字符串
# 注意：文档字符串一定要放在函数或者类的开始位置，否则上述两个函数无法来访问

15、总结示例

15.1、示例一

提醒用户输入自己的英文名字，然后保存到字典中（以name位key）。
将用户输入的英文名字翻转，继续保存到刚才的字典中（以new_name为key）。
将字典中的用户的正常的英文姓名赋值给变量real_name
告知客户“您的英文名字是：” +变量，“您的英文名字翻转是：” +字典里获取。

name = input('请输入您的英文名字：')
dic = {'name': name}
new_name = name[::-1]
dic['new_name'] = new_name
real_name = dic['name']
print('"您的英文名字是:%s"'% real_name,',''"您的英文名字翻转是:%s"'% dic['new_name'])
# 运行结果
# 请输入您的英文名字：heson
# "您的英文名字是：heson"，"您的英文名字翻转是:noseh"

15.2、示例二

提醒用户依次输入数学、语文、英语、综合四门的成绩，按照输入的成绩排序，告诉用户“您的最高的一门成绩是：”xx（不用告诉用户是那一科）。

math = int(input('请输入数学成绩：'))
chinese = int(input('请输入语文成绩：'))
english = int(input('请输入英语成绩：'))
comprehensive = int(input('请输入综合成绩：'))
ls = [math, chinese, english, comprehensive]
# 排序方法1，sorted（）函数返回一个新的list
print("您的最高的一门成绩是:",sorted(ls)[-1])
# 排序方法2，sort（）函数对已存在的列表ls进行操作
# ls.sort（）
# print（"您的最高的一门成绩是："，ls[-1])）
# 运行结果
# 请输入数学成绩：90
# 请输入语文成绩：88
# 请输入英语成绩：85
# 请输入综合成绩：80
# 您的最高的一门成绩是：90

15.3、示例三

使用input让用户依次输入两个数字，计算两个数字的和并显示。

num1 = float(input('请输入第一个数字：'))
num2 = float(input('请输入第二个数字：'))

sun1 = num1 + num2
print('两个数字的和为：',sum1)

# 运行结果
# 请输入第一个数字：10
# 请输入第二个数字：99.9
# 两个数字的和为：109.9

15.4、示例四

用python实现冒泡算法，给你一个包含若干值的列表，将他们从小到大排序输出（不能用sort或者sorted，自己用代码实现）
eg：
maopao（[2,1,8,4,3,6,]）
输出结果：[1,2,3,4,6,8]
冒泡排序（Bubble Sort），是一种计算机领域的较简单的排序方法，它重复地走访过要排序的元素列。
依次比较两个相邻的元素，如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来。

def bubble_sort(ls):
    # 检测列表的数据个数
    n = len(ls)   # n=6
    # i为数据排序的轮次
    # 第一轮:i=0
    for i in range(n - 1):
        # j为列表数据的下标
        # 第一轮:①j=0 ②j=1 ③j=2 ④j=3 ⑤j=4
        for j in range(0, n - i - 1):
            # 比较相邻两个数的大小
            # 第一轮:①ls[0]>ls[1]:True ②ls[1]>ls[2]:False ③ls[2]>ls[3]:True ④ls[3]>ls[4]:True ⑤ls[4]>ls[5]:True
            if ls[j] > ls[j + 1]:
                # 相邻两个数交换位置
                # 第一轮:①[1,2,8,4,3,6] ②[1,2,8,4,3,6] ③[1,2,4,8,3,6] ④[1,2,4,3,8,6] ⑤[1,2,4,3,6,8],第一轮结束最大值在最右边
                ls[j], ls[j + 1] = ls[j + 1], ls[j]
    # 输出排序后的数据列表
    print(ls)

ls = [2, 1, 8, 4, 3, 6]
bubble_sort(ls)
# 运行结果
# [1, 2, 3, 4, 6, 8]

16、文件操作

使用内建函数open（打开一个文件）。
handle = open（'file_name','r'）
第一个参数file_name是文件的名字，可以是一个绝对路径，也可以是一个相对路径。
第二个参数是文件的打开方式，选项有：
'r'：只读
'w'：覆盖写
'a'：追加写

# 方式一（使用相对路径）：
handle = open('test.txt', 'r', encoding='utf-8')   #指定编码格式encoding，默认是gbk
# 方式二（使用绝对路径）：
handle = open(r'test.txt', 'r', encoding='utf-8')

# handle是一个文件句柄，是一个可迭代的对象，可以直接使用for循环按行读取文件内容
for line in handle:
    print(list.strip())   # strip去除空格和换行
# handle使用完毕，需要close掉，否则会引起资源泄露（一个进程能打开的句柄数目是有限的）
handle.close()

print(handle.read(3))
# 读取一行，前面如果读过则不会重复读取，自动从未读取往下读
print(handle.readline())
# 读取所有行，将结果存储在result中，第一行的索引为0，以此类推
result = handle.readlines()
print(result[0].strip())
handle.close()

# 写文件：向文件中写一段字符串。（PS：读取文件的时候若文件不存在则无法读取，写文件的时候若文件不存在）
# 追加写
file_write = open('text02.txt', 'a', encoding='utf-8')
for n in range(1, 6):
    file_write.write('这是覆盖第%d行\n' % n)
file_write.close()

# with open文件
with open('test01.txt', 'w', encoding='utf-8') as f:
    for n in range(1, 6)
        f.write('这是覆盖第%d行\n' % n)

17、异常

在我们前面经常提到“程序运行出错”这样的概念，实际上这是python解释器抛出了一个异常。

list01 = [1, 2, 3]
try:
    print(list01[2])   # IndexError:list index out of range.try except捕获异常，后面程序正常运行
    handle = open(r'test02.txt','r',encoding='utf-8')   # No such file or directory:'test02.txt'
except Exception as error:
    # except IndexError:
    print(error)
    print(type(error))
    if str(error) == 'list index out of range':
        print('IndexError')
    elif str(error) == "[Errno 2] No such file or directory: 'test02.txt'":
        print('FileNotFoundError')
        
# print(list01[3])   # 没有抛异常，后界的程序无法运行
print('成功捕获异常')

18、模块

当代码量比较大的时候，我们最好把代码拆分成一些有组织的代码片段。每个代码片段里面包含一组逻辑上有关联的函数或类。
每一个片段里放在一个独立的文件中，这样的片段就成为模块（module）。
使用import可以在一个python文件中引入其它的模块。
既然模块也是一个对象，那么可以给这个对象赋值（相当于定义别名）。
使用 import 模块 as 别名。

def bubble_sort(ls):
    # 检测列表的数据个数
    n = len(ls)   # n=6
    # i为数据排列的轮次
    for i in range(n - 1):
        # j为列表数据的下标
        for j in range(0, n - i - 1):
            # 比较相邻两个数的大小
            if ls[j] > ls[j + 1]:
                # 相邻两个数交换位置
                ls[j], ls[j + 1] = ls[j + 1], ls[j]
    # 输出排序后的数据列表
    print(ls)

from c_wang.python基础,模块.test01 import bubble_sort as b
b([2, 3, 5, 22, 2, 1, 99, 0, 2])   # [0, 1, 2, 2, 2, 3, 5, 22, 99]

注意： 

①.py文件的命名可以使用数字、字母、下划线。
②当文件作为主程序运行时，文件名开头可以随意，以字母、数字、下划线开始都可以、例如：666_wang.py，wang.py，wang666.py，wang1.py，wangdaidai.py。
③但是，当.py文件作为模块被导入到其他文件中调用时，则作为模块的.py文件不能以数字开头命名，可以用下划线和字母开头，例如：wang.py，_wang666.py，wang666.py，_666wang.py，若命名为666wang.py则会出错。
④同理，若作文模块的.py文件位于某个包下，则这个包的命名也不能以数字开头。

19、包

当我们代码量进一步变大时，光拆分成多个文件已经不足以满足需求，还需要能按照一定的目录结构层次化的组织这些模块，同时包也可以解决模块之间的名字冲突问题，例如，我们可以以下面的方式组织代码结构：

test.py
bao_package/
        add.py
        divide.py
        __init__.py
在bao_package目录中增加一个__init__.py文件，bao_package这个目录就成了包
可以在test.py中import bao_package中的模块
from c_wang.python基础.包.bao_package import add divide

# 调用add.py文件
add
# 调用divide.py文件
divide
# __init__.py 是在包加载的时候会进行执行，负责一些包的初始化操作，一般是空文件即可

 20、猜数字游戏

代码中生成一个随机整数，然后用户输入数字后，程序提示用户的输入是高了还是低了，直到用户猜中这个数字，游戏结束。
提示：random模块的randint函数能够帮助我们生成随机整数。

from random import randint
correct_num = randint(1, 20)   # 随机生成一个大于等于1，小于等于20的整数
is_quit = 'n'   # 设置变量is_quit，用于判断是否退出游戏
print('请输入一个1-20的整数(输入q/Q/666可直接退出游戏)：')
while is_quit != 'y':
    try:
        guess_num = input()   # 用于获取用户输入的值

        if guess_num.upper() == 'Q':   # upper(),用户若输入q，则自动转换成Q
            guess_num = 666   # 设置一个随机字符串，作为退出循环的条件
        guess_num = int(guess_num)   # 若用户输入的值为整数，则转换为int类型

        if guess_num == correct_num:
            print('恭喜你，猜对了，你真棒呀！')
            is_quit = input('您要退出游戏吗？y/n ：')
            while is_quit != 'y' and is_quit != 'n':
                is_quit = input('只能输入y/n，请重新输入：')
            if is_quit == 'n':
                correct_num = randint(1,20)
                print('请输入一个1-20的整数(输入q/Q/666可直接退出游戏)：')
        elif 1 <= guess_num < correct_num:
            print('猜小了，请重新输入：')
        elif correct_num < guess_num <= 20:
            print('猜大了，请重新输入：')
        elif guess_num == 666:
            is_quit = 'y'   # 用于退出循环，结束游戏
        else:
            print('您输入的整数不在1-20范围内，请重新输入：')   # 若输入的整数不在1-20范围内，则提示用户重新输入
    except ValueError:   # 若输入非整数类型，捕获异常
        print('您输入的不是一个整数，请重新输入：')
print('游戏结束！')

20.1、解决No python interpreter for the object（该对象没有python解释器）

1、File-->Settings

2、Project:[项目名]-->Project Interpreter-->点击齿轮

3、点击齿轮出现Add，点击Add

4、System Interpreter-->点击右上角的...-->找到自己安装的python.exe

21、类

面向对象：封装
①面向对象-oop是一种编程思想，万物皆对象，面向对象提高了编程效率，重复利用性高。
②一个对象包含了数据和操作数据的函数。
抽象
①抽象是指对现实世界的问题和实体的本质表现，行为、特征进行建模，抽象的反义词是具体。
②抽象的本质，是抓住我们共同关注的主体，而忽略一些我们不需要关注的细节。
③写程序也是一样的，我们不可能把一个现实事物所有的信息都在程序中表示出来，而是只表示我们需要用到的。
类和实例
①类是施工图纸，里面有房子的重要信息（比如：户型、面积、朝向、层高等）。
②实例是造好房子，房子造好了，才能住进去。
③通过同一张图纸可以建造出N个相同格局的房子，那么N个实例就都是属于同一个类。

class Tester:
    def __init__(self, house_type):
        self.house_type = house_type

    developer = 'SOHO'

    def show_price(self,s):
        if self.house_type == '别墅':
            print('单价30000/每平米')
            print('整套的价格是：%d' % (30000 * s))
        elif self.house_type == '高层':
            print('单价25000/每平米')
        else:
            print('单价20000/每平米')

# 实例化类
cai = Tester('别墅')
cai.show_price(100)
cai.house_type == '高层'