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