安全第五次课后练习

目录

Python基础

一、python的数据类型

二、python中的变量类型

三、python的高阶函数

四、python中的迭代器

五、python中的闭包

Python基础

一、python的数据类型

1、int (integer)：整型，整数

例如:0，1，2，3，4，-1

2、float: 浮点型,小数

例如:1.1，0.2，2.4，3.1415926

3、complex: 复数

例如:a + bj => 1 + 2j

4、bool: 布尔

真或者假 Ture or False (一般是用于逻辑判断)

5、None: 空类型

什么都没有,但也是一种类型 (当一个类型不能确定时,用空类型)

6、bytes: 字节 (计算机底层的一种存储方式)

7、str: (string) 字符串

python中没有字符的概念 例如:a, abc => 字符串

8、tuple: 元组(数组一样的结构)

形式: (element1, element2...)

特点: 里面可以有多个元素,顺序存储的结构,可以存储不同类型的元素(长度不可变,与数组类似)

9、list: 列表

形式: [element1, element2...]

特点:里面有多个元素,顺序存储结构,可以存储不同类型的元素,列表可扩展(长度是可变的)

10、dict: (dictionary)字典

形式:{key: value, key2: value2...}

key: value 一个元素,键值对(成对存在)

每个元素包含两部分: key: 键, value: 值

特点: 字典里面的key是唯一的,字典的key和value,也可是多种类型,字典的key必须不可变

11、set:集合(并集,交集,差集)

形式:{1, 2, 3, 4, 5}

特点:无序,不重复,集合中的元素是无序不重复

二、python中的变量类型

什么是变量？

是计算机语言中能存储计算结果或能表示值的概念

1、变量的定义

name = 1 + 1 => name变量

变量可以通过变量名访问，可以通过name => 1 + 1的值

name: 变量名

python中定义变量的方式：

= 赋值运算符

例：variable_name = value

test_data = 1（此处test_data就为整型，变量的类型取决于后面的赋值）

python是动态类型的语言

形式：variable_name = value

变量名 = 值（python中变量的数据类型取决于后边赋的值是什么类型）

2、常见的11中变量类型

1.int

#对int变量类型的定义

int_data = 1                        #两种定义整型的方式
int_data = int(1)
print(int_data, type(int_data))

2.float

#对float变量类型的定义

float_data = 2.2                    #两种定义浮点型的方式
float_data = float(2.2)
print(float_data, type(float_data))

3.complx

#对complx变量类型的定义

complx_data = 1 + 2j                #两种定义复数类型的方式
complx_data = (1, 2)
print(complx_data, type(complx_data))

4.bool类型的值只有Ture和False

#对bool变量类型的定义

bool_data = True
bool_data = False
bool_data = bool()                  #这里的括号里面什么都不加，默认为False
print(bool_data, type(bool_data))

5.none

#对none变量类型的定义

none_data = None
print(none_data, type(none_data))

6.bytes 字节 b' '/b" "

#对bytes变量类型的定义

bytes_data = b'123'                 #三种定义字节的方式
bytes_data = b"123"
bytes_data = bytes()
print(bytes_data, type(bytes_data))

#下标访问的形式

bytes_data = b'1234'
print(bytes_data[2])                # 以ascii码的形式输出

7.str

#对str变量类型的定义

str_data = "a"
ste_data = "abc"
str_data = 'a'
str_data = str("abc")
print(str_data, type(str_data))

#现在要打印一个字符串，这个字符串本身包含一个 ‘

#I'm a handsome boy.

str_data = 'I"m a handsome boy.'
ste_data = """Today is Sunday"""
str_data = '''To“day is ”“” Sunday''' #里面可以有单个的 ' 单个的 " 还有'''
print(str_data, type(str_data))

#下标访问的形式

str_data = "123"
print(str_data[1])

8.tuple

#对tuple变量类型的定义

tuple_data = (1, 2, 3, 4)
print(tuple_data, type(tuple_data))
tuple_data = (1,)                      #单个元组的定义
print(tuple_data, type(tuple_data))
tuple_data = tuple()                   #定义一个空元组
tuple_data = ()                        #定义一个空元组
print(tuple_data, type(tuple_data))
tuple_data = (1, 2.2, 1 + 2j, True, b'123', "str", None)
print(tuple_data, type(tuple_data))

#下标的形式去访问 元组名[下标]

tuple_data = (1, 2, 3)			#内建的不可变的序列，意思就是tuple中的元素不可以被替换
print(tuple_data[2])

9.list

#对list变量类型的定义

list_data = [1, 2, 3, 4]            # 列表的特点：1.以中括号括起来，里面的元素用逗号分隔
list_data = list()                              2.存放不同类型的数据, 可变的序列

#下标的形式访问 列表名[下标]

list_data = [1, 2, 3, 4]
print(list_data[0])
print(list_data[1])					#正的下标从左到右
print(list_data[-1])				#负的下标从右到左
print(list_data[-4])

list_data = [1, 2, 3, 4]			#内建的可变的序列，意思就是里面的元素可以被替换
list_data[3] = 11
print(list_data)

#切片：切成片段

#序列的形式：序列[start: stop: step]

#有可以省略的部分：

#[:] => step步长没有写，start省略值是0，stop省略值是字符串结尾的位置

#[0;] => 省略stop的值

#[0:-1] => 左开右闭

#start: stop: step => [:]

#start: stop: step => [0:]

#start: stop: step => [0:8]

str_data = "123456789"
print(str_data[:])              #元素     1, 2, 3, 4, 5, 6, 7, 8, 9
print(str_data[0:])             #正下标   0, 1, 2, 3, 4, 5, 6, 7, 8
print(str_data[0:9])            #负下标  -9,-8,-7,-6,-5,-4,-3,-2,-1
print(str_data[0:-1])           #[0:-1] => start=0, step=1, stop=8    (0<=下标<8)
print(str_data[0:8])            #[0:8] => start=0, step=1, stop=8    (0<=下标<8)
print(str_data[0:9:1])          #[0:9:1] => start=0, stop=9, step=1   (0<=下标<9)
print(str_data[8::-1])          # start=8, stop: 省略之后，代表的是下标0左边的位置
print(str_data[::-1])

str_data = "123456789"
print(str_data[:4])				#取前四个元素，[:4]代表从下标0开始取到4，由于左开右闭，所以就取到前四位元素
print(str_data[::2])			#取元素中的奇数
print(str_data[1::2])			#取元素中的偶数

#list的类型转换

#这里的list(可迭代对象) => 相当于list的类型转换
str_data = "123"
list_data = list(str_data)
print(list_data)
bytes_data = b'123'
list_data = list(bytes_data)
print(list_data)
tuple_data = (1, 2, 3)
list_data = list(tuple_data)
print(list_data)
list_data = [1, 2, 3]
list_data = list(list_data)
print(list_data)

10、dict

#元素的结构：key: value 一对， 键值对

                        键： 值

#要求：key必须是唯一的，且是immutable(不可变的)

#整理：不可变的数据类型：int, float, complx, bytes, bool, str, tuple(元组也并非不可变，如果元组中存在可变的数据类型，则此元组也可以发生改变)

                可变的数据类型：list, tuple, set

tuple_data = (1, 2.2, 1 + 2j, [4, 5, 6])
tuple_data[3][1] = 7
print(tuple_data)				#将元组中的列表中的值发生改变，得出的结论就是元组并非不可变，如果元组中存在可变的数据类型，则此元组可以发生改变

#操作字典里面的元素：增加，修改

1、增加

# list_data = [1, 2, 3]
# list_data[3] = 4		#list是无法直接增加元素，只能通过.append的方式去添加
list与dict的对比

list_data = [[1, 2], [2, 3]]
dict_data[3] = 4			
print(dict_data)		#dict是可以直接增加元素的/字典是可以直接使用  字典[key] = value 去增加一个元素的

2、修改

list_data = [[1, 2], [2, 3]]
dict_data[1] = 10
print(dict_data)			#将[1, 2]修改为了[1, 10]

11、set

#set和dict类似，也是一组key的集合，但不存储value 

#set可以看成数学意义上的无序和无重复元素的集合

#两个set可以做数学意义上的交集、并集等操作

a=set([1,2,3,2,4,5,3])//一个含重复值的简单集合
a.remove(2)//删除元素2，指定删除因为不存在重复项
a.add(6)//添加元素，可以添加重复值但是不会显示,因为输出时自动会去除
print(a)//输出会自动去除重复值
b=set([1,3,5])
c=set([2,4,6])
print(b.union(c))//合并
print(b.intersection(c))//交集
print(b.difference(c))//差集

三、python的高阶函数

map: map(func, *iterables) --> map object

map(func(函数), *iterables(迭代的对象, *:多个可迭代对象)) 功能:

# 制作一个迭代器， 从每一个可迭代的对象中取出一个元素， 作为参数传递给function 获取计算结果作为迭代器的元素

# 直到我们最短的可迭代对象被耗尽了，他才停止。

Make an iterator that computes the function using arguments from each of the iterables. Stops when the shortest iterable is exhausted.

新的可迭代对象mapobj里边的元素怎么来呢?

func, *iterables

从每一个可迭代的对象中，取出一个元素，作为参数传递给func

# 例：3个可迭代对象， 每次从每一个可迭代对象中取出一个元素：

         从3个可迭代对象中，取出了3个元素

         把这三个元素作为参数传递给func(这个func可以接收三个参数)

         放在lambda表达式上: lambda arg1, arg2, arg3:

func通过传递过来的参数，计算结果

把结果作为mapobj的元素, 第一次取，作为mapobj的第一个元素 第二次取，作为mapobj的第二个元素 ... 直到某一个可迭代对象，被迭代完成(耗尽了)

使用map的时候:

1.map中的元素是由function来产生的，你定义的function返回什么就是map中的元素

2.map中function的参数个数，取决于你后边有几个可迭代的对象

3.map中的元素个数取决于,我们最短可迭代对象中有几个元素

from functools import reduce
map_obj = map(lambda x, y: x + y, [1, 2, 3], [4, 5, 6])
print(map_obj, type(map_obj))
print(list(map_obj))
# map(lambda x, y: x + y, [1, 2, 3], [4, 5, 6])
# map_obj =>
# 1, 4 => lambda x, y: x + y => x=1, y=4, x + y = 5
# 2, 5 => lambda x, y: x + y => x=2, y=5, x + y = 7

map_obj = map(lambda x, y: x + y, [1, 2, 3], [4, 5])
print(list(map_obj))

#使用map: 传入3个列表: 列表的长度: 3, 3, 4
#         结果map_obj: 每一个元素(list1[0], list2[0], list3[0])

list1 = [1, 2, 3]
list2 = [4, 5, 6]
list3 = [7, 8, 9, 10]

map_obj = map(lambda x, y, z: (x, y, z), list1, list2, list3)
print(list(map_obj))

#map_obj = map(lambda x, y, z: (x[0], y[0], z[0]), [1, 2, 3], [4, 5, 6], [7, 8, 9, 0])

四、python中的迭代器

什么是迭代器？
实现了迭代协议的对象，叫迭代器
什么是迭代协议？
    实现了__iter__: 返回迭代器本身(预置好的)
    实现了__next__: 去取下一个元素(预置好的)

迭代的时候: 第一次获取到迭代器
for i in iterable => iterable.__iter__() 获取迭代器 iterator
                  => iterator(迭代器).__next__() 获取第一个元素
                  => iterator.__next__() 去获取下一个元素
                  ....
                  => iterator.__next__() 获取到最后一个元素
                  怎么去判别结束了呢？
                  就是抛出一个异常：StopIteration的异常

for循环结束的条件: python解释器接收到一个StopIteration异常，认为for语句结束了
Signal the end from iterator.__next__()

迭代器有两个方法：iter（）和next（）方法。
# => len(obj) => obj.__len__()
# iter() => obj.__iter__
# next() => obj.__next__

它是一个可以记住遍历的位置的对象。
range(10) : 产生的是不是一个可迭代的对象？ 肯定是
range(10) => 0-9

提到这样的格式: for i in iterable:
iterable: 可迭代的对象
          iterable(可迭代对象): 指的是容器类，即需要迭代的对象
                                能够一次返回其成员的对象.
          实现了__iter__方法： 返回迭代器
          iterable: list，dict，tuple，str，set，bytes
                    都有__iter__

iterator: 迭代器
         实现了迭代协议: __iter__和__next__
         因为实现了__iter__意味着iterator也是一个iterable

class MyIterable:
    def __init__(self, value):
        self.stop = value
        self.start = 0

    def __iter__(self):
        print("This is Iter")
        return self

    # 迭代器可以记住遍历位置
    def __next__(self):
        # 结束条件： 数值 < 10
        #        执行: 记录位置
        #             返回值
        # position = 0
        # position = 1
        # 第一次获取0 =》 位置0 =》
        # 第二次获取1 =》 位置1
        # 最后一次获取9结束 => 0-9 => 需要结束条件
        print(f"第{self.start + 1}次迭代:")
        if self.start < self.stop:
            data = self.start
            self.start += 1
            return data
        else:
            raise StopIteration

    def __getitem__(self, item):
        return 0
    #
#0-9 => list_data[0]

 for i in MyIterable(10):
     print(i)

五、python中的闭包

什么叫闭包？
一个函数定义中引用了函数外定义的变量，并且该函数可以在其定义环境外被执行。
能够读取其他函数内部变量的函数
# 重要的信息: 嵌套函数

#代码块中定义的: 函数
#自由变量: 当前函数中引用了一个不在他内部定义的变量(自由变量)
闭包包含自由(未绑定到特定对象)变量;
这些变量不是在这个代码块内或者任何全局上下文中定义的，
而是在定义代码块的环境中定义(局部变量)

闭包一词来源于要执行的代码块和为自由变量提供绑定的计算环境两者的结合
闭包就是可以创建一个独立的环境，每个闭包里面的环境都是独立的，互不干扰。
当前活动对象中有被内部子集引用的数据，那么这个时候，这个数据不删除，保留一根指针给内部活动对象。

在计算机科学中，闭包（英语：Closure），又称词法闭包（Lexical Closure）
或函数闭包（function closures），是引用了自由变量的函数。
这个被引用的自由变量将和这个函数一同存在，即使已经离开了创造它的环境也不例外。
闭包特征: 
1.嵌套函数
2.内层函数引用了外层函数的变量
3.内层函数作为返回值返回给外层函数
特征2：
自由变量: 既不是局部变量，也不是模块全局变量
         在闭包的时候：内层引用外层函数的变量
保存我们要执行代码的环境
执行的代码块和为自由变量提供绑定的计算环境两者的结合

def outer():
    print("This is outer")
    data = 1 # data在外层函数中定义了
    def inner():
        print("This is inner")
        print(data) # data没有inner中定义，但是可以引用
                    # data就叫做自由变量
    return inner
# outer()()
inner = outer()
inner()
inner()
print(outer.__code__.co_varnames)
print(outer.__code__.co_cellvars)
print(outer.__code__.co_freevars)

print(80 * "*")
print(inner.__code__.co_freevars)  # 自由变量
print(inner.__code__.co_cellvars)
print(inner.__code__.co_varnames)
# 在inner中我有没有去定义data变量： 没有
# 但是我却可以使用data。