Python--数据类型、循环、运算符、容器的使用
Python--数据类型、循环、运算符、容器的使用
由于最近有自动化测试的需要，对Python的语法不是很熟悉，Python的介绍就忽略了，下面开始Python基本语法的学习
一、第一个Python程序
下载安装Pycharm：https://www.jetbrains.com/pycharm/download/#section=windows
创建工程比较简单，这边就直接开始撸码：
python中的main函数使用if __name__ == '__main__':开始
if __name__ == '__main__':
print("hello python")运行结果：
二、数据类型
在使用数据类型之前，先来了解下python中的注释：
单行注释：#内容
多行注释：'''内容''' 或"""内容"""
1. 整型
表示一个整数：
if __name__ == '__main__':
# 定义整数变量
i = 10
print(i)
# 输出变量类型
print(type(i))运行结果：
2. 浮点型
表示一个小数：
if __name__ == '__main__':
# 定义小数变量
f = 8.8
print(f)
print(type(f))运行结果：
3. 布尔类型
Python中布尔类型使用True和False表示，这两位还可以表示1和0的整数。
if __name__ == '__main__':
# 定义布尔类型
b = True
print(b)
print(type(b))
# 将True和False转为为整形表示
print(int(True))
print(int(False))运行结果：
4. 字符串类型
4.1 定义方式
字符串是我们使用的最常见的类型，python中字符串类型定义方式有三种：
定义方式 | 描述 |
|---|---|
单引号:'内容' | 表示单行字符串 |
双引号:"内容" | 和单引号相同，表示单行字符串 |
三对单引号:'''内容''' | 表示多行字符串 |
三对双引号:"""内容""" | 表示多行字符串 |
if __name__ == '__main__':
info = '一对单引号'
print(info, type(info))
print("-------------")
info = "一对双引号"
print(info, type(info))
print("-------------")
info = '''三对单引号
三对单引号
三对单引号
'''
print(info, type(info))
print("-------------")
info = '''三对双引号
三对双引号
三对双引号
'''
print(info, type(info))
print("-------------")运行结果：
4.2 获取字符串长度
两种方式：
- 使用内置
len函数：
info = "abc"
print(len(info))- 使用字符串的
__len__函数：
info = "abc"
print(info.__len__())4.3 获取字符串拼接
python中，字符串拼接使用+号，但数字型变量（整型和浮点型）和字符串相加会报错：
info = "abc"
print(info + 1)运行结果：
可以调用内置函数str，将之转为字符串类型：
print(info + str(1))5. 类型转换
上面基本类型之间都可以相互转换，方式如下：
转换方法 | 描述 |
|---|---|
str(var) | 将var转换为字符串 |
int(var) | 将var转换为整形 |
float(var) | 将var转换为浮点型 |
三、循环
除了循环外，我把条件控制也放在这块了
1. 条件控制
1.1 单分支
用于判断表达式是否成立，语法：if 表达式:
if True:
print("真")
else:
print("假")运行结果：
1.2 多分支
多分支使用elif：
i = 10
if i > 10:
print("i大于10")
elif i < 10:
print("i小于10")
else:
print("i等于10")运行结果：
1.3 三目运算符
python中的三目运算符是我见过的最奇葩的，语法：成立执行语句 if 条件 else 不成立执行语句：
gender = 0
print("男") if gender == 1 else print("女")运行结果：
2. for循环
2.1 for循环基本语法
学习for循环之前，先来了解下range，range也是python中一个容器类型，表示一个区间，定义语法为：range([开始],结束,[步长])
for循环可以遍历range中的内容，for循环的语法为：for 变量名 in 容器:
for i in range(0, 10, 2):
print(i)运行结果：
2.2 continue 与break
-
continue可以直接进入循环的下一次
for i in range(10, 2):
if i == 4:
continue
print(i)运行结果：
-
break可以直接跳出循环：
for i in range(10, 2):
if i == 4:
break
print(i)运行结果：
2.3 else追加执行
python特有的特性，当循环正常执行完成(不使用break跳出循环)，使用else可以追加执行一块代码：
for i in range(0, 10, 2):
if i == 4:
continue
print(i)
else:
print("循环执行结束啦")运行结果：
3. while循环
while循环和for循环类似，只是结束条件需要自己指定，语法为：while 条件:
i = 0
while i < 10:
print(i)
i += 2执行结果：
除此以外，while循环中也可以使用continue、break、else
四、运算符
这边只介绍python中一些特殊的运算符
1. 算术运算符
1.1 取余：%
python中一正一负的取余操作要采用新的公式：余数 = 被除数 - 除数 * 商，其中商向上取整
print(8 % -3)执行结果：
1.2 取整：//
python使用//进行取整操作，一正一负的情况向下取整：
print(12 // 5)
print(12 // -5)执行结果：
1.3 幂运算：**
python中可以直接使用**来进行幂运算
print(2 ** 3)执行结果：
2. 赋值运算符
python中不支持++、--操作，需要使用+=1、-=1
2.1 解构
python也支持多个变量赋值：
a, b, c = range(3)
print(a, b, c)运行结果：
交换两个变量的值就可以使用解构了：
a, b = 10, 20
a, b = b, a
print(a, b)运行结果：
3. 比较运算符
3.1 值相等：==
python中的==表示的是变量的值相等，并不表示内存地址相同
由于编译器会优化以及常量池，所以使用列表进行测试，列表在后续容器中会介绍：
a = [10, 20, 30]
b = [10, 20, 30]
print(a == b)运行结果：
3.2 地址相等：is
python中使用is对比两个变量是否是一个内存地址：
a = [10, 20, 30]
b = [10, 20, 30]
print(a == b)
print(a is b)运行结果：
与is相对应，is not则表示两个变量内存地址不相等，返回True
4. 逻辑运算符
符号 | 描述 |
|---|---|
and | 并且 |
or | 或者 |
not | 非 |
五、容器
Java中有很多类型的容器，像List，Map等，他们用于存放指定类型的数据，Python中也有对应的容器
1. 列表
和Java的List对应，python中定义列表使用：[]、list()
m_list = [1, 2]
print(m_list)也可以使用list()函数，将range转换为list：
m_list = list(range(0, 2))
print(m_list)1.1 获取列表的元素
获取列表元素使用：变量名[索引]
m_list = [1, 2]
print(m_list[0])运行结果：
python中可以使用负数作为索引，表示倒着取元素：
m_list = [1, 2]
print(m_list[-1])运行结果：
1.2 列表增加元素
添加元素有三种方式：
-
append()方法在列表尾添加一个元素，相当于Java的add()：
m_list = [1, 2]
m_list.append(3)
print(m_list)运行结果：
-
extend()方法在列表尾添加一个列表，相当于Java的addAll()：
m_list = [1, 2]
m_list.append(3)
m_list.extend([4, 5])
print(m_list)运行结果：
-
insert()方法在列表指定索引后添加一个元素：
m_list = [1, 2]
m_list.append(3)
m_list.extend([4, 5])
m_list.insert(2, 10)
print(m_list)运行结果：
1.3 查找元素的索引
使用index()方法，查找元素的索引，并支持指定索引范围：
print(m_list.index(10))
print(m_list.index(10, 0, 4))运行结果：
如果查找不到，抛出异常：
print(m_list.index(8))运行结果：
1.4 列表元素的修改与删除
修改列表元素很简单，只要赋值新的值即可：
m_list = [1, 2]
m_list[0] = 3
print(m_list)运行结果：
元素删除可以通过值删除(remove()方法)，也可以通过索引删除(pop()方法)：
# 值删除
m_list.remove(2)
print(m_list)
# 索引删除
m_list.pop(0)
print(m_list)运行结果：
列表清空使用del关键字或clear()方法，其中del会将内存清空，变量不可使用：
clear()方式：
m_list.clear()
print(m_list)运行结果：
del方式：
del m_list
print(m_list)运行结果：
1.5 元素是否存在于列表中
使用in关键字，判断元素是否在列表中：
m_list = [1, 2]
# 判断3是否在列表中
print(3 in m_list)运行结果：
1.6 元素遍历
元素遍历使用for循环，语法为for 变量名 in 列表名：
m_list = [1, 2]
for item in m_list:
print(item）运行结果：
1.7 列表操作总结
功能 | 方法 | 描述或例子 |
|---|---|---|
定义列表 | 变量名=[] | 空列表：m_list=[] ;初始值列表：m_list=[1,2] |
list([range([开始],结束,[步长])]) | 空列表：m_list=list() ;初始值列表：m_list = list(range(0, 2)) | |
获取列表的元素 | 变量名[索引] | 索引支持负数，获取索引为1的元素：m_list[1] |
列表增加元素 | append(元素) | 增加一个元素：m_list.append(3) |
extend(列表) | 添加一个列表：m_list.extend([4,5]) | |
insert(索引,元素) | 指定索引后面追加一个元素：m_list.insert(2,10) | |
查找元素的索引 | index(元素,[开始],[结束]) | 如果元素存在，返回元素的索引，反之抛出异常：m_list.index(20) |
列表元素的修改 | 变量名[索引]=新元素 | 赋值一个新元素：m_list[0]=100 |
列表元素的删除 | remove(元素) | 删除指定元素：m_list.remove(100) |
pop(索引) | 删除指定索引下的元素：m_list.pop(1) | |
clear() | 清空列表元素：m_list.clear() | |
del | 删除变量内存：del m_list | |
元素是否存在于列表中 | in | 判断元素是否在列表中：2 in m_list |
元素遍历 | for 变量名 in 列表名 | 遍历列表：for item in m_list |
列表生成推导式 | [i for i in range([开始],结束,[步长])] | 快速生成一个列表：m_list = [i for i in range(0, 10,2)] |
2. 字典
字典对应Java中的HashMap，存放的是键值对，定义字典使用：{}、dict()
{}用法：
d = {"name": "张三", "age": 18}
print(d)运行结果：
dict()用法：
d = dict(name="张三", age=19)
print(d)运行结果：
2.1 字典元素的获取
字典元素都是通过键获取的，获取有两种方式：
[索引]获取：
print(d["name"])get()方法获取：
print(d.get("name"))还可以根据返回是否为None，判断是否存在键值对：
print(d.get("name1"))同样的可以使用in关键字，判断是否存在键：
print("name1" in d)运行结果：
2.2 字典元素的增删改
字典增加和修改元素使用[key]直接赋值即可：
d["gender"] = '女'
print(d["gender"])删除元素可以使用del：
del d["gender"]
print("gender" not in d)运行结果：
清空元素可以使用clear()：
d.clear()
print(list(d.keys()))运行结果：
2.3 字典所有的key和value获取
keys()方法用于获取字典中所有的key，使用list()将它转换为列表：
print(list(d.keys()))values()方法用于获取字典中所有的value：
print(list(d.values()))items()方法用于获取字典中所有的键值对，使用list()将它转换为元表，元表后续会介绍：
print(list(d.items()))运行结果：
2.4 字典元素的遍历
遍历还是使用for循环即可，其中由于python的解构特性，for循环变量也支持多个：
for k, v in d.items():
print(k, v)运行结果：
2.5 字典操作总结
功能 | 方法 | 描述或例子 |
|---|---|---|
定义字典 | 变量名={} | 空字典：d={} ;初始值字典：d = {"name": "张三", "age": 18} |
dict() | 空字典：d=dict() ;初始值字典：d= dict(name="张三", age=19) | |
获取字典的元素 | 变量名[key] | 获取key为name的元素：d["name"]，不存在抛出异常 |
get(key) | 获取key为name的元素：d.get("name")，不存在返回None | |
字典增加元素 | 变量名[key]=value | 增加一个元素：d["gender"] = '女' |
字典元素的修改 | 变量名[key]=新value | 将key赋值一个新value：d["gender"] = '男' |
字典元素的删除 | del | 删除指定键值对：del d["gender"] |
clear() | 清空列表元素：d.clear() | |
元素是否存在于字典中 | in | 判断元素是否在字典中："name1" in d |
元素遍历 | for 变量名 in 字典名 | 遍历字典：for k, v in d.items() |
字典生成推导式 | {k:v for k,v in zip(列表1, 列表2)} | 快速生成一个字典：d = {k: v for k, v in zip(keys, values)} |
3. 元组
python中元组是不可变的列表，一旦创建，内存就不可修改了，只能读取，对多线程下操作提升了性能
元组的定义使用：()、tuple()
()方式：
t = (1, 2)
print(t)tuple()方式，tuple的入参需要一个容器，其实就是将其他容器转换为元组：
t = tuple((1, 2))
print(t)运行结果：
元组除了不能增加修改外，其他用法和列表相同
4. 集合
集合对应Java中的HashSet，如果熟悉源码的就知道，HashSet就是HashMap，只是HashSet存放的value都是null，所以集合的使用和字典差不多，定义集合使用：{}、set()
{}方式：
s = {1, 2}
print(s)set()方式，也元素一样需要一个容器：
s = set([1, 2])
print(s)运行结果：
4.1 判断元素是否在集合中
使用in来判断：
print(3 in s)4.2 集合元素的增加
两种方式：add()、update()
add()方法一次增加一个元素：
s.add(3)
print(s)运行结果：
update()方法传入一个容器，一次增加多个元素：
s.update([4, 5, 6])
print(s)运行结果：
4.3 集合元素的删除
remove()方法，删除指定的key，如果不存在抛出异常：
s.remove(3)
print(s)discard()方法，删除指定的key，如果不存在不抛出异常：
s.discard(3)
print(s)pop()方法，随机删除一个元素：
s.pop()
print(s)clear()方法，清空集合：
s.clear()
print(s)运行结果：
4.4 集合间比较
集合除了使用==对比两个集合中元素是否一样外，还支持以下比较操作：
issubset()方法用于判断本集合是否是其他集合的子集：
s1 = {1, 2, 3}
s2 = {1, 2}
print(s2.issubset(s1))与之相对的，issuperset()方法用于判断本集合是否是其他集合的超集：
print(s1.issuperset(s2))运行结果：
isdisjoint()方法用于判断本集合和另一个集合是否没有交集：
s1 = {1, 2, 3}
s2 = {4, 5}
print(s1.isdisjoint(s2))运行结果：
4.5 集合数据操作
集合还支持以下的数学操作：
intersection()方法，求交集：
s1 = {1, 2, 3, 4}
s2 = {4, 5}
print(s1.intersection(s2))union()方法，求并集：
print(s1.union(s2))difference()方法，求差集：
print(s1.difference(s2))symmetric_difference()方法，求对称差集：
print(s1.symmetric_difference(s2))运行结果：
4.6 集合操作总结
功能 | 方法 | 描述或例子 |
|---|---|---|
定义集合 | 变量名={} | 空集合：s={} ;初始值集合：s = {1, 2} |
set() | 空集合：s = set() ;初始值集合：s = set([1, 2]) | |
集合增加元素 | add() | 增加一个元素：s.add(3) |
update() | 增加多个元素：s.update([4, 5, 6]) | |
字典元素的删除 | remove() | 删除指定元素，不存在抛异常：s.remove(3) |
discard() | 删除指定元素，不存在不抛异常：s.discard(3) | |
pop() | 删除随机元素：s.pop() | |
clear() | 清空集合：s.clear() | |
元素是否存在于集合中 | in | 判断元素是否在集合中：3 in s |
元素遍历 | for 变量名 in 集合名 | 遍历集合：for k in s1 |