第三天-Python流程控制与函数

1.集合的操作

1.集合的创建

1. 集合（set）是一个无序的不重复的元素序列

2.常用来对2个列表进行交并差的处理

3.集合支持所有不可变的数据类型，如元组，字符串；列表支持

4.使用大括号{}写法：如{"1","2",3}

5.与列表的区别

6.注意：通过set函数来创建集合，不能使用{}来创建空集合；

7.集合无法通过索引获取元素；

8.元素无法获取元素的任何方法；

9.集合只是用来处理列表和元组的一种临时类型，不适合存储和传输；

正确的创建：a_set=set() ,b_set={"1","2",3},c_set=set([1,2,3])

a_set = set()
b_set = {"1","2",3}
c_set = set(["1","2",3])


print(a_set)
print(b_set)
print(c_set)

set()
{3, '1', '2'}
{3, '1', '2'}

2.集合增删改

1.add函数: 用于添加集合的一个元素，如元素中存在则不执行；

•         用法： set.add(item) 添加集合的元素；

a_set = set()
a_set.add("1")

print(a_set)

{'1'}

2.update函数：加入一个新的集合或列表，元组，字符串，如新的元素在集合中存在，则忽略

•         用法：set.update(iterable) ，参数：集合，列表元组字符串；无返回值
•         与add用法类似，update可添加多个成员add只能添加一个

a_set = set(["1","2","3"])
b_set = {"a","b","c"}
a_set.update(b_set)
print(a_set)

{'1', 'b', '2', '3', 'c', 'a'}

3.remove：将集合中的某个元素进行删除，如元素不存在将会直接报错

• 用法：set.remove(item)  ； 注意元素不是索引，集合不存在索引，无返回值

4.clear：情况当前集合的所有函数

• 用法：set.clear()   无返回值

5.del： 删除集合，完全删除删除内存空间

3.集合的差集-difference

1.a,b2个集合，由所有属于a且不属于b的元素组成的集合叫做a与b的差集；

1和2为b的差集

2.用法： a_set.difference(b_set)

参数：b_set:当前集合所需要对比的集

返回值： 返回原始集合于对比集合的差集

a_set=set(["1","2","3","4"])
b_set=set(["3","4","5","6"])

print(a_set.difference(b_set))

{'1', '2'}

4.交集-intersection

1.a与b2个集合分别拥有相同的元素集，成为a,b的交集

3.4为交集

2. 用法：a_set.intersection(b_set...)

参数：与当前集合对比1,或多个集合

返回：返回原集合与对比集合的交集

a_set=set(["1","2","3","4"])
b_set=set(["3","4","5","6"])
print(a_set.intersection(b_set))

{'4', '3'}

5.并集-union

1. a，b两个集合所有的元素（去掉重复）即为a与b的并集

1,2,3,4,5,6为a，b的并集

2.返回多个集合的并集，即包含了索引集合的元素，重复的元素只会出现一次；

3.用法 a_set.union(b_set...)

参数： b_set...: 与当前集合对比1或多个集合

返回值：返回与对比集合的并集

a_set=set(["1","2","3","4"])
b_set=set(["3","4","5","6"])
print(a_set.union(b_set))

{'1', '4', '6', '5', '2', '3'}

6.2个集合是否包含相同的元素-isdisjoint函数

1.判断2个集合是否包含相同的元素，没有返回Ture,有False

2.用法 a_set.isdisjoint(b_set)

参数：b_set: 与当前集合用来判断的集合

返回：bool

2.字符串之间的转换

1.字符串与数字转换

1.字符串必须由数字转换

2.字符串与列表转换

1. 字符串转列表: split;将字符串以一定的规则进行切割

用法： string.split(sep=None, maxsplit=1)

参数：sep：切割符号，默认空格，如字符串无空格则不生成列表

maxsplit:根据切割符号切割的次数，默认-1无限制

返回：一个新的列表

a="my name is zhangs"

print(a.split())

print(a.split(sep=" ",maxsplit=1))

print(a.split(sep=","))

['my', 'name', 'is', 'zhangs']
['my', 'name is zhangs']
['my name is zhangs']

2.列表转字符串：join

1.将列表以一定规则转换成字符串

3. bytes转string

1.二进制数据流

2.字符串钱+b标记：

str = "name"
str2 = b"name"

print(str,type(str))
print(str2,type(str2))

name <class 'str'>
b'name' <class 'bytes'>

3.字符串转bytes: encode

返回一个bytes类型

4.bytes转字符串--decode

返回一个字符串

str = "张三"

print("字符串转bytes",str.encode(encoding="utf-8"))

print("bytes转字符串",str.encode(encoding="utf-8").decode(encoding="utf-8"))

字符串转bytes b'\xe5\xbc\xa0\xe4\xb8\x89'
bytes转字符串 张三

4.集合、元组、列表之间的转换

3.流程控制

1.if语句

name = "张三"
name2 = "张三"
if name == name2:
    print("这是张三")

这是张三

2.else语句

name = "张三"
name2 = "张三1"
if name == name2:
    print("这是张三")
else:
    print("这不是张三")

这不是张三

3. elif

1. 同java的 else if

4.for循环

for循环

1. for循环将关键字列表、元组、字符串、字典中的每个元素按照顺序就那些遍历

a_list = ["1","2","3"]

b_tuple=("1","2","3")

c_set={"1", "2", "3"}

d_dict={"name": "张三", "zge": 18}

print("循环list")
for i in a_list:
    print("i:",i)

print("循环元组")
for e in b_tuple:
    print("e:", e)

print("循环集合")
for e in c_set:
    print("e:", e)

print("循环字典")
for e in d_dict:
    print("字典key:", e)
    print("字典value:", d_dict[e])

循环list
i: 1
i: 2
i: 3
循环元组
e: 1
e: 2
e: 3
循环集合
e: 1
e: 2
e: 3
循环字典
字典key: name
字典value: 张三
字典key: zge
字典value: 18

Process finished with exit code 0

items进行循环

1. 字典利用items循环进行for循环

2. items将dict内容转为为一个伪列表进行循环；

d_dict={"name": "张三", "zge": 18}

print("循环字典2")
for k,v in d_dict.items():
    print("字典key:", k)
    print("字典value:", v) 

range函数

1. 返回的是一个一定范围的可迭代对象，元素为整型，他不是一个列表，无法打印信息，但可循环；

else 在for循环中使用

嵌套for循环

5.while循环

1. 一一定条件为基础的循环，条件满足则无限训话，条件不满足则退出循环；

2.不依赖可迭代的数据类型，而for循环依赖；

flag=True
i=0
while flag:
    i+=1
    print(i)
    if i>3:
        flag=False
        print("大于3循环终止")

1
2
3
4
大于3循环终止

6.continue / break

1. continue： 遇到时将中止本次循环，进入下一次循环

九九乘法表：

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

1 * 1 = 1 
2 * 1 = 2 2 * 2 = 4 
3 * 1 = 3 3 * 2 = 6 3 * 3 = 9 
4 * 1 = 4 4 * 2 = 8 4 * 3 = 12 4 * 4 = 16 
5 * 1 = 5 5 * 2 = 10 5 * 3 = 15 5 * 4 = 20 5 * 5 = 25 
6 * 1 = 6 6 * 2 = 12 6 * 3 = 18 6 * 4 = 24 6 * 5 = 30 6 * 6 = 36 
7 * 1 = 7 7 * 2 = 14 7 * 3 = 21 7 * 4 = 28 7 * 5 = 35 7 * 6 = 42 7 * 7 = 49 
8 * 1 = 8 8 * 2 = 16 8 * 3 = 24 8 * 4 = 32 8 * 5 = 40 8 * 6 = 48 8 * 7 = 56 8 * 8 = 64 
9 * 1 = 9 9 * 2 = 18 9 * 3 = 27 9 * 4 = 36 9 * 5 = 45 9 * 6 = 54 9 * 7 = 63 9 * 8 = 72 9 * 9 = 81

 2.break：终止本次循环

九九乘法表：

i=0
j=0

while i<9:
    i+=1
    while j<9:
        j+=1
        print("{} * {} = {}".format(i, j, i * j), end=" ")
        if i==j:
            j=0
            print("")
            break

1 * 1 = 1 
2 * 1 = 2 2 * 2 = 4 
3 * 1 = 3 3 * 2 = 6 3 * 3 = 9 
4 * 1 = 4 4 * 2 = 8 4 * 3 = 12 4 * 4 = 16 
5 * 1 = 5 5 * 2 = 10 5 * 3 = 15 5 * 4 = 20 5 * 5 = 25 
6 * 1 = 6 6 * 2 = 12 6 * 3 = 18 6 * 4 = 24 6 * 5 = 30 6 * 6 = 36 
7 * 1 = 7 7 * 2 = 14 7 * 3 = 21 7 * 4 = 28 7 * 5 = 35 7 * 6 = 42 7 * 7 = 49 
8 * 1 = 8 8 * 2 = 16 8 * 3 = 24 8 * 4 = 32 8 * 5 = 40 8 * 6 = 48 8 * 7 = 56 8 * 8 = 64 
9 * 1 = 9 9 * 2 = 18 9 * 3 = 27 9 * 4 = 36 9 * 5 = 45 9 * 6 = 54 9 * 7 = 63 9 * 8 = 72 9 * 9 = 81 

4.函数

1.函数的定义

1.函数的分类：

        内置函数：如print,id,range,type

        自定义函数

2.def函数创建关键字：

        def show(args...): 

                todo

                返回值

3.函数的执行:

        show();

4.函数的返回，--return，只能在函数体中使用；有返回值的函数可以直接赋值一个变量；

2.函数的传参

1. 必传参数

• 函数中定义的参数没有默认值，在调用函数是不传入报错；
• 在定义函数时，参数后面没有等号与默认值
• 在定义函数时，没有默认值且必须在函数执行的时候传递进去参数，且顺序与参数顺序相同，就是必传参数；

2.默认参数

•  定义函数的时候，定义的参数含有默认值，通过赋值语句他是一个默认的值；
• def add(a,b=1) b为默认参数；
• 如默认参数在调用函数的时候赋予了新值，函数优先使用传入值；

3.不确定参数

def test(*args,**kwargs):
    if args:
        print(args,type(args))
    if kwargs:
        print(kwargs,type(kwargs))

test(1,2,3,name="张珊")

(1, 2, 3) <class 'tuple'>
{'name': '张珊'} <class 'dict'>

4.参数的规则

3.参数定义类型

4.局部变量和全局变量

1.全局变量：

1. 在python脚本最上层代码块的变量；
2. 全局变量在函数内可以被读取使用，但是不能对外部变量修改，函数内部可以修改（如需要修改需要使用global），不对外部有影响；

2.局部变量

    1.在函数内定义的变量

3.global

    1.定义一个全局变量

    2.定义函数：global+全局变量名 

    3.可以给全局变量进行重新赋值；

5.函数的递归

1.一个函数不同的将自己反复执行；

6.匿名函数lambda

1. 定义一个轻量化的函数

2.即用即删除，很适合完成一项功能，但此功能只在一处使用；

3.定义：

        无参数：f = lamdba : value  f()

        有参数的 f= lambda x,y: x*y  f(3,4)

f= lambda :print(1)
f()


f1= lambda x,y: x*y
print(f1(1,2))

1
2