python函数名称

*闭包的作用:保护我们的变量,必须是局部变量
a = 10 # 全局的东西都是不安全的

def func1():
    print(a)

def func2():
    print(a)

func1()

# 你的同事搞事情
def func3():
    global a
    a = 20

func3()

func2()

def func():
    a = 10 # 安全的
    def func2():
        print(a)
    def func3():
        print(a)
    def func4():
        nonlocal a
        a = 20

 闭包: 内层函数对外层函数的变量的使用
 作用:
    1. 保护我们的变量不受侵害
    2. 可以让一个变量常驻内存.

def outer():
    # a = 10
    def inner():
        print("哈哈")
    print(inner.__closure__) # (<cell at 0x000001C079677588: int object at 0x0000000054776D30>,)
    return inner

ret = outer()
# 1800行代码...
ret() # 由于inner函数执行的时机是不确定的. 必须要保证innter可以正常执行. 必须把a保留到最后


#  爬虫 (low版本)
from urllib.request import urlopen # 打开一个连接用的模块
# 外层函数
def but():
    # 打开连接. 读取源代码
    content = urlopen("http://www.cctv.com/").read() # 永久驻留在内存
    # 内层函数
    def get_content():
            # 返回content
        return content
    return get_content # 内层函数

fn = but() # 这里会很慢. 需要网络请求
print(fn()) # 不会再进行网络请求了
print(fn())


关联的小点
def func(a, b):
    ‘‘‘
    文档注释
    这个函数用来计算两个数的和并返回
    :param a: 第一个数
    :param b: 第二个数
    :return:  第一个数和第二个数的和
    author:sylar
    date:2018-10-31
    ‘‘‘
    print("我是func")
    return a + b
print(func.__doc__) # document 文档注释
print(func.__name__) # name 名字 获取函数名

for循环的流程:
it = lst.__iter__()
while 1:
     try:
          el = it.__next__()
    for循环的循环体
     except StopIteration:
            break                    

print(dir(str)) # 查看str能够执行的操作. 内部的方法
__iter__  字符串可以被迭代. 发现了__iter__
print(dir(list))
print(dir(open("x",mode="w"))) # int中没有__iter__

 简单的下一个结论. 主要这个数据类型可以执行__iter__ 可以被迭代的数据类型
lst = ["汉高祖", "清高祖", "明高祖", "哈哈", "娃哈哈", "爽歪歪"]
it = lst.__iter__() # <list_iterator object at 0x000001ED54B17128> iterator 迭代器
print(it)
print(dir(it)) # 迭代器本身是可迭代的
可以使用__next__获取数据
print(it.__next__()) # 汉高祖
print(it.__next__()) # 清高祖
print(it.__next__()) # 明高祖
print(it.__next__()) # 明高祖
print(it.__next__()) # 明高祖
print(it.__next__()) # StopIteration 迭代器中没有元素了.

for循环内部的代码
it = lst.__iter__() # 获取新的迭代器
while  1:
    try:
        el = it.__next__()
        print(el)
    except StopIteration:
        print("结束了")
        break

list(内部有for循环)
for内部 迭代器
lst = [1,55,5,55,5,5,5,555,55,555]
ll = list(set(lst))
print(ll)
list(1) # ‘int‘ object is not iterable

 如何判断一个数据是否是可迭代对象
 1. dir() ->  __iter__  可迭代的
    dir() -> __next__  迭代器
lst = ["秦始皇", "汉武帝", "孝文帝", "隋炀帝", "李世民"]
print("__iter__" in dir(lst)) # True 可迭代的
print("__next__" in dir(lst)) # False 不是迭代器

print("__iter__" in  dir(int))
print("__next__" in  dir(int))

it = lst.__iter__() # 迭代器
print("__iter__" in dir(it)) # True  迭代器本身就是可迭代的
print("__next__" in dir(it)) # True
lst = ["秦始皇", "汉武帝", "孝文帝", "隋炀帝", "李世民"]

# collections 关于集合类的相关操作
# Iterable : 可迭代的
# Iterator : 迭代器
from collections import Iterable, Iterator
print(isinstance(lst, Iterable)) # True
print(isinstance(lst, Iterator)) # False

print(isinstance({1,2,3}, Iterable)) # True, 可以使用for循环

1.写函数,接收一个参数(此参数类型必须是可迭代对象),将可迭代对象的每个元素以’_’相连接,形成新的字符串,并返回.
例如 传入的可迭代对象为[1,‘老男孩‘,‘武sir‘]返回的结果为’1_老男孩_武sir’
def func(can):
    if "__iter__" in dir(can): # 判断是否是可迭代的
        result = ""
        for item in can: # 传递的参数中的每一个元素 "周杰伦"
            result += str(item)+"_"
        return result.strip("_")
    else: # 不是可迭代的
        return None # 回去 , 正常来讲这里应该抛出异常.

print(func((1,‘老男孩‘,‘武sir‘)))

2.打印图形
	 *
      * * *
   * * * * *
* * * * * *   *
n = int(input("请输入你要打印多少行"))
for i in range(1, n+1):
    # 方案一
    for k in range(n-i):
        print(" ", end="")
    for j in range(2 * i - 1):
        print("*", end="")
    print() # 换行

     #方案二
for i in range(1,n+1)
    print(" " * (n - i) + "*" * (2 * i - 1))

3.求1-100内所有的质数的和(升级题)

def func(n): # 只能被1和自身整除的数
    if n == 1: # 特殊处理的
        return False
    # n / 2, 3, 4, 5, 6, 7, 8, 9....n-1
    for i in range(2, n):
        if n % i == 0: # 不是质数
            return False
    else:
        return True
print(func(2))
sum = 0
for i in range(1, 101):
    if func(i): # 如果是质数. 帮我累加
        sum += i
print(sum)