review-1

# ### for 循环和序列的运用

# remember = ['从入门到放弃', '从入门到如土', 123, 'happy']
# for each in remember:
#     print(each, end= '\n')
#
# happy= {'从入门到放弃', '从入门到如土', 123, 'happy'}
# for each in happy:
#     print(each, end= '\n')

#while 循环的使用
# '''
# 这是多行注释
# '''
# bingo = '小甲鱼是帅哥'
# answer = input('请输入小甲鱼想听的一户话：')
# while True:
#     if bingo == answer:
#         break
#     answer = input('抱歉输错了，请再猜（答案正确才能退出游戏）：')
# print('遗忘的速度是真的快')

#符串拼接 and 转义字符 and 原始字符串

# 使用 "\" 可以进行字符转义
# “+”可以字符串拼接，“*”可以进行字符串翻倍操作
# 在字符串前面加“r”就表示是原始字符串。注意：在原始字符串最后不能加“\”
# 利用三重引号字符串可以实现跨越多行的字符串，一般用来实现多行注释。

# count = 1
# print('##登陆程序##')
# a = int(input('请输入答案：'))
# count = 1
# while a != 8:
#     if count >= 4:
#         print('太难猜了，不玩了')
#         break
#     a = int(input('答案错误，请输入正确答案：'))
#     count += 1

## type（）和isinstance（）
format
a = int(input('请输入年份：'))
b = a/4
if b == 0:
    print('闰年')
else:
    print('不是闰年')

# is 和 == 的区别：前者用于判断两个变量引用对象是否是同一个，后者用于判断变量引用的值是否相等。
# type()函数用法：输入一个参数，返回参数的类型；isinstance()函数用法：isinstance(object,classinfo)。
# 利用切片操作、工厂方法、list方法等拷贝叫浅拷贝，只是拷贝了最外围的对象本身，内部的元素都只是拷贝了一个引用而已。
# 利用copy中的deepcopy()方法进行的拷贝是深拷贝，外围和内部都进行了拷贝对象本身，而不是引用。
# 对于数字、字符串和其他原子类型的对象，没有拷贝这一说法，实际上都是以增加引用标签，如果对其重新赋值，也只是创建一个对象，替换掉旧的而已。
# 注意赋值和浅拷贝的区别。

# help(object)查看对象的更多信息；dir(object)显示对象的大部分相关属性名；object.__doc__显示对象相应的文档字符串。
# 列表解析表达式：[有关v表达式 for v in range(num)]：
#  >>>[i** 2 for i in range(10)]
#[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
'''列表函数，
append():L.append(object) -> None -- append object to end、
extend():L.extend(iterable) -> None -- extend list by appending elements from the iterable
insert():L.insert(index, object) -- insert object before index
index(): L.index(value, [start, [stop]])
pop():L.pop([index]) -> item -- remove and return item at index (default last)
count(...):L.count(value) -> integer -- return number of occurrences of value.
copy(...):L.copy() -> list -- a shallow copy of L
remove(...):L.remove(value) -> None -- remove first occurrence of value.
            Raises ValueError if the value is not present.
reverse(...):L.reverse() -- reverse *IN PLACE*
'''

'''元组
1、元组和列表的使用和操作十分相似，不同带你在于列表可以修改里面的内容，而元组不行。
2、“，”是创建元组的关键，
3、元组的内容是不可修改的，但是可以通过元组连接的方式实现元组更新,也可以是索引访问、运算符运算、切片的操作
4、所有的多对象的、逗号分隔的、没有明确用符号定义的这些集合默认的类型都是元组。
x, y, z = 1, 2, 3
h = x,y,z
type(h)
<class 'tuple'>
元组函数：
tuple() -> empty tuple
tuple(iterable) -> tuple initialized from iterable's items
T.count(value) -> integer -- return number of occurrences of value
T.index(value, [start, [stop]]) -> integer -- return first index of value.
                                Raises ValueError if the value is not present.
'''

'''
序列、格式化、函数
1、序列：列表、元组、字符串统称为序列，都是可迭代对象，存在很多相同之处，也存在细小的差别。
        相同之处：1)创建、list(iterable)、tuple(iterable)、str(iterable)
                    2)拼接、切片、成员操作符、关系操作符等。
                    3）都可以进行索引
        不同之处：1）列表和元组可以使用的BIF：min()、max()、len()等，
                2）字符串和元组的内容都不可以修改，而列表的内容可以修改。
                3）列表和字符串有pop()、reverse()等方法，而元组不行。

2、函数：形参、实参、关键字参数、默认参数、可变参数（在参数面前加上“*”即可），当一个函数定义中
可变参数还需要其他参数时，需要默认参数配合使用，否则会出错。
3、一个函数最多只能有一个return,如果需要传回多个值，采用列表等形式传回；
    如果没有return,函数返回一个None对象。
4、内部函数的整个作用域都在外部函数的作用域之内，即在外部函数外无法调用内部函数；
    闭包：在一个内部函数里对外部作用域的变量（但不是全局变量）进行引用，那么内部函数被认为是闭包；
    闭包的创建和调用：
    def funX(x):
        def funY(y):
            return x*y
        return funY
>>>i = funX(5)
>>>type(5)
<class 'int'>
>>>type(i)
<class 'function'>
>>>i(8)
40
>>>funX(5)(8)                           ***
40

5、匿名函数：lambda 变量：表达式，用lambda创建匿名函数时，返回一个函数类型的对象。
>>>g =lamdba x,y:x+y
>>>g(3,4)
7    

7、filter函数（）：filter(function or None, iterable) --> filter object

    Return an iterator yielding those items of iterable for which function(item)
    is true. If function is None, return the items that are true.
>>>list(filter(None,[1,0,False,True]))
[1,Ture]
>>>list(filter(lambda x:x%2,range(10))) #功能，返回10以内的奇数

8、map()函数： map(func, *iterables) --> map object
 |  
 |  Make an iterator that computes the function using arguments from
 |  each of the iterables.  Stops when the shortest iterable is exhausted.
>>>list(map(lambda x:x*2,range(5)))
[0,2,4,6,8]

9、格式化有采用“%”和format函数两种方式。
'''

'''
变量作用域问题：
    1、在函数内部可以访问全局变量，也可以使用‘global’关键字对全局变量进行“修改”；
    如果不采用global关键字进行修改，那么对全局变量进行修改的本质是创建一个与全局变量
    名称相同的局部变量。
    2、在局部函数里，只能对外部函数的局部变量（非全局变量）进行引用，而不能进行修改，
    除非使用 local 关键字，或者用容器类型的变量规避这个问题。

'''